From b5e5252dcf433048a3226294d520f9597e7e1db6 Mon Sep 17 00:00:00 2001 From: Onuralp SEZER Date: Sun, 1 Dec 2024 23:10:57 +0300 Subject: [PATCH] =?UTF-8?q?feat:=20=E2=9C=A8=20D-FINE=20Object=20Detection?= =?UTF-8?q?=20model=20inference=20and=20training=20added?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Onuralp SEZER --- README.md | 3 +- automation/notebooks-table-data.csv | 1 + ...e-object-detection-on-custom-dataset.ipynb | 4440 +++++++++++++++++ 3 files changed, 4443 insertions(+), 1 deletion(-) create mode 100644 notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb diff --git a/README.md b/README.md index 0c2aa95..6307a12 100644 --- a/README.md +++ b/README.md @@ -70,11 +70,12 @@ Curious to learn more about GPT-4 Vision? [Check out our GPT-4V experiments ๐Ÿงช WARNING: DO NOT EDIT THIS TABLE MANUALLY. IT IS AUTOMATICALLY GENERATED. HEAD OVER TO CONTRIBUTING.MD FOR MORE DETAILS ON HOW TO MAKE CHANGES PROPERLY. --> -## ๐Ÿš€ model tutorials (43 notebooks) +## ๐Ÿš€ model tutorials (44 notebooks) | **notebook** | **open in colab / kaggle / sagemaker studio lab** | **complementary materials** | **repository / paper** | |:------------:|:-------------------------------------------------:|:---------------------------:|:----------------------:| | [Fine-Tune Segment Anything 2.1 (SAM-2.1)](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/fine-tune-sam-2.1.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/fine-tune-sam-2.1.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/fine-tune-sam-2.1.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/fine-tune-sam-2-1/) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/facebookresearch/sam2) | | [Fine-Tune GPT-4o](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/openai-gpt-4o-fine-tuning.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/openai-gpt-4o-fine-tuning.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/openai-gpt-4o-fine-tuning.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/gpt-4o-object-detection/) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=6Q6TieCBA4E) | | +| [D-FINE Object Detection](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb) | | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/Peterande/D-FINE) [![arXiv](https://img.shields.io/badge/arXiv-2410.13842-b31b1b.svg)](https://arxiv.org/abs/2410.13842)| | [YOLO11 Object Detection](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-object-detection-on-custom-dataset.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-object-detection-on-custom-dataset.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-object-detection-on-custom-dataset.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/yolov11-how-to-train-custom-data/) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=jE_s4tVgPHA) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/ultralytics/ultralytics) | | [YOLO11 Instance Segmentation](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-instance-segmentation-on-custom-dataset.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-instance-segmentation-on-custom-dataset.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolo11-instance-segmentation-on-custom-dataset.ipynb) | [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=jE_s4tVgPHA) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/ultralytics/ultralytics) | | [Segment Images with SAM2](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-segment-images-with-sam-2.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-segment-images-with-sam-2.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-segment-images-with-sam-2.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/what-is-segment-anything-2/) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/live/Dv003fTyO-Y) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/facebookresearch/segment-anything-2) [![arXiv](https://img.shields.io/badge/arXiv-2408.00714-b31b1b.svg)](https://arxiv.org/abs/2408.00714)| diff --git a/automation/notebooks-table-data.csv b/automation/notebooks-table-data.csv index 25a06d1..04bc9fa 100644 --- a/automation/notebooks-table-data.csv +++ b/automation/notebooks-table-data.csv @@ -1,6 +1,7 @@ display_name, notebook_name, roboflow_blogpost_path, youtube_video_path, github_repository_path, arxiv_index, should_open_in_sagemaker_labs, readme_section Fine-Tune Segment Anything 2.1 (SAM-2.1), fine-tune-sam-2.1.ipynb, https://blog.roboflow.com/fine-tune-sam-2-1/, , https://github.com/facebookresearch/sam2, , False, models Fine-Tune GPT-4o, openai-gpt-4o-fine-tuning.ipynb, https://blog.roboflow.com/gpt-4o-object-detection/, https://www.youtube.com/watch?v=6Q6TieCBA4E, , , False, models +D-FINE Object Detection, train-d-fine-object-detection-on-custom-dataset.ipynb, , , https://github.com/Peterande/D-FINE, 2410.13842, False, models YOLO11 Object Detection, train-yolo11-object-detection-on-custom-dataset.ipynb, https://blog.roboflow.com/yolov11-how-to-train-custom-data/, https://www.youtube.com/watch?v=jE_s4tVgPHA, https://github.com/ultralytics/ultralytics, , False, models YOLO11 Instance Segmentation, train-yolo11-instance-segmentation-on-custom-dataset.ipynb, , https://www.youtube.com/watch?v=jE_s4tVgPHA, https://github.com/ultralytics/ultralytics, , False, models Football AI, football-ai.ipynb, https://blog.roboflow.com/camera-calibration-sports-computer-vision/, https://youtu.be/aBVGKoNZQUw, https://github.com/roboflow/sports, , False, skills diff --git a/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb b/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb new file mode 100644 index 0000000..5fb5cef --- /dev/null +++ b/notebooks/train-d-fine-object-detection-on-custom-dataset.ipynb @@ -0,0 +1,4440 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b203c2ffe0284d6b", + "metadata": { + "id": "b203c2ffe0284d6b" + }, + "source": [ + "[![Roboflow Notebooks](https://media.roboflow.com/notebooks/template/bannertest2-2.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672932710194)](https://github.com/roboflow/notebooks)\n", + "\n", + "# How to Train D-Fine Object Detection on a Custom Dataset\n", + "\n", + "---\n", + "\n", + "[![D-FINE Grpah](https://raw.githubusercontent.com/Peterande/storage/master/figs/stats_padded.png)](https://raw.githubusercontent.com/Peterande/storage/master/figs/stats_padded.png)\n", + "\n", + "\n", + "[![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/Peterande/D-FINE/)\n", + "[![arXiv](https://img.shields.io/badge/arXiv-2311.06242-b31b1b.svg)](https://arxiv.org/abs/2410.13842)\n", + "\n", + "\n", + "D-FINE is a powerful real-time object detector that redefines the bounding box regression task in DETRs as Fine-grained Distribution Refinement (FDR) and introduces Global Optimal Localization Self-Distillation (GO-LSD), achieving outstanding performance without introducing additional inference and training costs.\n", + "\n", + "D-FINE is available in 5 different sizes, ranging from `4M` to `62M` parameters, and capable of achieving from `42.8` to `55.8` mAP on the COCO dataset. It is also available in Object365+COCO trained 4 different sizes, ranging from `10M` to `62M` parameters, and capable of achieving from `50.7` to `59.3` mAP on the Object365 finetuned models" + ] + }, + { + "cell_type": "markdown", + "id": "297447a84ad90149", + "metadata": { + "id": "297447a84ad90149" + }, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "markdown", + "id": "803977ea935e03b2", + "metadata": { + "id": "803977ea935e03b2" + }, + "source": [ + "### Configure API keys\n", + "\n", + "To train D-FINE model, you need to provide your Roboflow API key. Follow these steps:\n", + "\n", + "- Go to your [`Roboflow Settings`](https://app.roboflow.com/settings/api) page. Click `Copy`. This will place your private key in the clipboard.\n", + "- In Colab, go to the left pane and click on `Secrets` (๐Ÿ”‘). Store Roboflow API Key under the name `ROBOFLOW_API_KEY`.\n", + "- In your local environment make sure you set `export ROBOFLOW_API_KEY=MY_ROBOFLOW_API_KEY`\n" + ] + }, + { + "cell_type": "markdown", + "id": "8ff4fef615211f8", + "metadata": { + "id": "8ff4fef615211f8" + }, + "source": [ + "### Before you start\n", + "\n", + "Let's make sure that we have access to GPU. We can use `nvidia-smi` command to do that. In case of any problems navigate to `Edit` -> `Notebook settings` -> `Hardware accelerator`, set it to `GPU`, and then click `Save`.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "37798482db25eca6", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T18:21:26.748362Z", + "start_time": "2024-11-30T18:21:26.484655Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "37798482db25eca6", + "outputId": "978ac4e9-1480-4aa2-b2e8-d407c0222ecd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Sun Dec 1 15:37:02 2024 \n", + "+---------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 535.104.05 Driver Version: 535.104.05 CUDA Version: 12.2 |\n", + "|-----------------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+======================+======================|\n", + "| 0 NVIDIA A100-SXM4-40GB Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 32C P0 45W / 400W | 2MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-----------------------------------------+----------------------+----------------------+\n", + " \n", + "+---------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=======================================================================================|\n", + "| No running processes found |\n", + "+---------------------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "814133ddbac32b8e", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T18:22:10.162080Z", + "start_time": "2024-11-30T18:22:10.159660Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "814133ddbac32b8e", + "outputId": "5aa93adb-d631-43f2-ba4d-2f9ac4a5286c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content\n" + ] + } + ], + "source": [ + "import os\n", + "HOME = os.getcwd()\n", + "print(HOME)" + ] + }, + { + "cell_type": "markdown", + "id": "cbbb3457b885a940", + "metadata": { + "id": "cbbb3457b885a940" + }, + "source": [ + "## Clone D-FINE Repository\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f975614144c5c102", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T18:32:58.889163Z", + "start_time": "2024-11-30T18:32:57.617092Z" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f975614144c5c102", + "outputId": "357c02b9-009c-48ab-f0cc-c559070d9137" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'D-FINE'...\n", + "remote: Enumerating objects: 899, done.\u001b[K\n", + "remote: Counting objects: 100% (608/608), done.\u001b[K\n", + "remote: Compressing objects: 100% (307/307), done.\u001b[K\n", + "remote: Total 899 (delta 359), reused 488 (delta 293), pack-reused 291 (from 1)\u001b[K\n", + "Receiving objects: 100% (899/899), 388.81 KiB | 869.00 KiB/s, done.\n", + "Resolving deltas: 100% (485/485), done.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/Peterande/D-FINE/" + ] + }, + { + "cell_type": "markdown", + "id": "d734f9b08166783e", + "metadata": { + "id": "d734f9b08166783e" + }, + "source": [ + "## Inference with model pre-trained on COCO dataset" + ] + }, + { + "cell_type": "markdown", + "id": "ce9ead8f191872e0", + "metadata": { + "id": "ce9ead8f191872e0" + }, + "source": [ + "### Download example image and large model weight file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "453a827f-7eb7-4905-9b01-c4202fb1900f", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T18:36:02.349658Z", + "start_time": "2024-11-30T18:36:01.587779Z" + }, + "id": "453a827f-7eb7-4905-9b01-c4202fb1900f" + }, + "outputs": [], + "source": [ + "!wget https://media.roboflow.com/notebooks/examples/dog.jpeg\n", + "!wget -O dfine_l_coco.pth https://github.com/Peterande/storage/releases/download/dfinev1.0/dfine_l_coco.pth" + ] + }, + { + "cell_type": "markdown", + "id": "0ba0b3f5-c6fe-4ef2-a054-40554a6b9c68", + "metadata": { + "id": "0ba0b3f5-c6fe-4ef2-a054-40554a6b9c68" + }, + "source": [ + "### Install D-FINE Package requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "180d524494279206", + "metadata": { + "id": "180d524494279206" + }, + "outputs": [], + "source": [ + "%pip install torch torchvision supervision\n", + "%pip install -r D-FINE/requirements.txt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee6ea203c389d03e", + "metadata": { + "id": "ee6ea203c389d03e" + }, + "outputs": [], + "source": [ + "!python D-FINE/tools/inference/torch_inf.py -c D-FINE/configs/dfine/dfine_hgnetv2_l_coco.yml -r dfine_l_coco.pth --input dog.jpeg --device cuda:0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b40bb75829434a3", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T19:05:42.386269Z", + "start_time": "2024-11-30T19:05:42.376676Z" + }, + "id": "9b40bb75829434a3", + "outputId": "187a650b-27e8-4649-a6a5-ada39fdc2b95" + }, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": { + "image/jpeg": { + "width": 600 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image as IPyImage\n", + "IPyImage(filename=f'{HOME}/torch_results.jpg', width=600)" + ] + }, + { + "cell_type": "markdown", + "id": "4f699c6d-6ac7-459e-baab-828523421e41", + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-30T19:00:29.526353Z", + "start_time": "2024-11-30T19:00:29.522847Z" + }, + "id": "4f699c6d-6ac7-459e-baab-828523421e41" + }, + "source": [ + "### Inference via Pytorch and Visualize with Supervision" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "b3afdb63-ee02-4352-a69d-c8c6182f9998", + "metadata": { + "id": "b3afdb63-ee02-4352-a69d-c8c6182f9998" + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "from typing import List, Optional\n", + "import supervision as sv\n", + "import torch\n", + "import torch.nn as nn\n", + "import torchvision.transforms as T\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import cv2\n", + "sys.path.append(os.path.abspath(\"./D-FINE/\"))\n", + "from src.core import YAMLConfig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f8a17ef-078e-4b1a-9187-57ab85116c64", + "metadata": { + "id": "2f8a17ef-078e-4b1a-9187-57ab85116c64" + }, + "outputs": [], + "source": [ + "MSCOCO_NAMELIST = (\n", + "'person',\n", + "'bicycle',\n", + "'car',\n", + "'motorcycle',\n", + "'airplane',\n", + "'bus',\n", + "'train',\n", + "'truck',\n", + "'boat',\n", + "'traffic light',\n", + "'fire hydrant',\n", + "'stop sign',\n", + "'parking meter',\n", + "'bench',\n", + "'bird',\n", + "'cat',\n", + "'dog',\n", + "'horse',\n", + "'sheep',\n", + "'cow',\n", + "'elephant',\n", + "'bear',\n", + "'zebra',\n", + "'giraffe',\n", + "'backpack',\n", + "'umbrella',\n", + "'handbag',\n", + "'tie',\n", + "'suitcase',\n", + "'frisbee',\n", + "'skis',\n", + "'snowboard',\n", + "'sports ball',\n", + "'kite',\n", + "'baseball bat',\n", + "'baseball glove',\n", + "'skateboard',\n", + "'surfboard',\n", + "'tennis racket',\n", + "'bottle',\n", + "'wine glass',\n", + "'cup',\n", + "'fork',\n", + "'knife',\n", + "'spoon',\n", + "'bowl',\n", + "'banana',\n", + "'apple',\n", + "'sandwich',\n", + "'orange',\n", + "'broccoli',\n", + "'carrot',\n", + "'hot dog',\n", + "'pizza',\n", + "'donut',\n", + "'cake',\n", + "'chair',\n", + "'couch',\n", + "'potted plant',\n", + "'bed',\n", + "'dining table',\n", + "'toilet',\n", + "'tv',\n", + "'laptop',\n", + "'mouse',\n", + "'remote',\n", + "'keyboard',\n", + "'cell phone',\n", + "'microwave',\n", + "'oven',\n", + "'toaster',\n", + "'sink',\n", + "'refrigerator',\n", + "'book',\n", + "'clock',\n", + "'vase',\n", + "'scissors',\n", + "'teddy bear',\n", + "'hair drier',\n", + "'toothbrush'\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbef580aa48e318", + "metadata": { + "id": "bbef580aa48e318" + }, + "outputs": [], + "source": [ + "MODEL_FILENAME = \"dfine_l_coco.pth\"\n", + "YAML_CONFIG_PATH = \"./D-FINE/configs/dfine/dfine_hgnetv2_l_coco.yml\"\n", + "INPUT_IMAGE = \"dog.jpeg\"\n", + "CONFIDENCE_THRESHOLD = 0.4\n", + "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "BOX_ANNOTATOR = sv.BoxAnnotator()\n", + "LABEL_ANNOTATOR = sv.LabelAnnotator()\n", + "TRANSFORMS = T.Compose(\n", + " [T.Resize((640,640)), T.ToTensor()]\n", + ")\n", + "\n", + "\n", + "cfg = YAMLConfig(\n", + " YAML_CONFIG_PATH, resume=MODEL_FILENAME\n", + ")\n", + "\n", + "if \"HGNetv2\" in cfg.yaml_cfg:\n", + " cfg.yaml_cfg[\"HGNetv2\"][\"pretrained\"] = False\n", + "checkpoint = torch.load(MODEL_FILENAME, map_location=DEVICE)\n", + "if \"ema\" in checkpoint:\n", + " state = checkpoint[\"ema\"][\"module\"]\n", + "else:\n", + " state = checkpoint[\"model\"]\n", + "\n", + "\n", + "cfg.model.load_state_dict(state)\n", + "\n", + "class Model(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.model = cfg.model.deploy()\n", + " self.postprocessor = cfg.postprocessor.deploy()\n", + "\n", + " def forward(self, images, orig_target_sizes):\n", + " outputs = self.model(images)\n", + " outputs = self.postprocessor(outputs, orig_target_sizes)\n", + " return outputs\n", + "\n", + "model = Model().to(DEVICE)\n", + "\n", + "im_pil = Image.open(INPUT_IMAGE).convert('RGB')\n", + "w, h = im_pil.size\n", + "orig_size = torch.tensor([[w, h]]).to(DEVICE)\n", + "im_data = TRANSFORMS(im_pil).unsqueeze(0).to(DEVICE)\n", + "output = model(im_data, orig_size)\n", + "labels, boxes, scores = output\n", + "class_id = labels.detach().cpu().numpy().astype(int)\n", + "xyxy = boxes.detach().cpu().numpy()\n", + "confidence = scores.detach().cpu().numpy()\n", + "\n", + "detections = sv.Detections(\n", + " xyxy=xyxy[0],\n", + " confidence=confidence[0],\n", + " class_id=class_id[0],\n", + ")\n", + "\n", + "\n", + "detections = detections[detections.confidence > CONFIDENCE_THRESHOLD].with_nms()\n", + "\n", + "class_names = []\n", + "for idx in detections.class_id:\n", + " class_names.append(MSCOCO_NAMELIST[idx])\n", + "\n", + "labels = [\n", + " f\"{class_name} {confidence:.2f}\"\n", + " for class_name, confidence\n", + " in zip(class_names, detections.confidence)\n", + "]\n", + "\n", + "\n", + "annotated_image = BOX_ANNOTATOR.annotate(scene=im_pil,detections=detections)\n", + "annotated_image = LABEL_ANNOTATOR.annotate(scene=annotated_image,detections=detections,labels=labels)\n", + "\n", + "\n", + "detections = detections[detections.confidence > CONFIDENCE_THRESHOLD].with_nms()\n", + "\n", + "annotated_image = BOX_ANNOTATOR.annotate(scene=im_pil,detections=detections)\n", + "annotated_image = LABEL_ANNOTATOR.annotate(scene=annotated_image,detections=detections,labels=labels)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5533d75-e5bc-46ef-b0ee-1363b03402d3", + "metadata": { + "id": "c5533d75-e5bc-46ef-b0ee-1363b03402d3", + "outputId": "2a17f601-6ea4-4ce1-c67f-558de299c88c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sv.plot_image(annotated_image)" + ] + }, + { + "cell_type": "markdown", + "id": "8a60a19d-fdd2-4b70-9017-5591bbd54183", + "metadata": { + "id": "8a60a19d-fdd2-4b70-9017-5591bbd54183" + }, + "source": [ + "# Training D-FINE on custom dataset\n", + "\n", + "In this tutorial, we will use one of the [datasets](https://universe.roboflow.com/roboflow-100/circuit-elements) available on [Roboflow Universe](https://universe.roboflow.com/). When downloading, make sure to select the `coco` export format.\n", + "\n", + "## About Dataset\n", + "\n", + "It is RF-100 Circuit dataset\n", + "\n", + "* Class Number: 46\n", + "* Train Image: 672\n", + "* Validation Image: 64\n", + "* Test Image : 36\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e847361-c10f-4229-bc7a-a0af1394e76e", + "metadata": { + "id": "0e847361-c10f-4229-bc7a-a0af1394e76e" + }, + "outputs": [], + "source": [ + "%pip install roboflow" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b29c4368-f206-460b-800c-c1b966dcddd2", + "metadata": { + "id": "b29c4368-f206-460b-800c-c1b966dcddd2" + }, + "outputs": [], + "source": [ + "!mkdir -p {HOME}/datasets\n", + "%cd {HOME}/datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31bef82b-502f-4bb4-b30e-8ad2e5e0fc0a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "31bef82b-502f-4bb4-b30e-8ad2e5e0fc0a", + "outputId": "0049b4bb-7a95-4915-9cd5-1caa4db6853d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "loading Roboflow workspace...\n", + "loading Roboflow project...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Downloading Dataset Version Zip in circuit-elements-3 to coco:: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 84888/84888 [00:06<00:00, 14065.44it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "Extracting Dataset Version Zip to circuit-elements-3 in coco:: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 780/780 [00:00<00:00, 3108.44it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } + ], + "source": [ + "from roboflow import Roboflow\n", + "from google.colab import userdata\n", + "ROBOFLOW_API_KEY = userdata.get('ROBOFLOW_API_KEY')\n", + "\n", + "rf = Roboflow(api_key=ROBOFLOW_API_KEY)\n", + "project = rf.workspace(\"roboflow-100\").project(\"circuit-elements\")\n", + "version = project.version(3)\n", + "dataset = version.download(\"coco\")\n", + "\n", + "%cd .." + ] + }, + { + "cell_type": "markdown", + "id": "7bb6cdee-f9ba-4933-b967-b2812233eb71", + "metadata": { + "id": "7bb6cdee-f9ba-4933-b967-b2812233eb71" + }, + "source": [ + "## Training on Custom Dataset" + ] + }, + { + "cell_type": "markdown", + "id": "b0259955-55c5-49e7-a157-cc67aa6a1927", + "metadata": { + "id": "b0259955-55c5-49e7-a157-cc67aa6a1927" + }, + "source": [ + "## Configuration File Modifications\n", + "\n", + "This code modifies two YAML configuration files for a machine learning project:\n", + "\n", + "### 1. Custom Detection Configuration\n", + "- Opens `custom_detection.yml` and updates:\n", + " - Dataset paths to point to circuit-elements-3 dataset\n", + " - Changes training data path from `/data/yourdataset/train` to dataset path\n", + " - Updates validation data path from `/data/yourdataset/val` to dataset path\n", + " - Sets number of classes from 777 to 46 (based on dataset)\n", + " - Reduces number of workers from 4 to 2\n", + "\n", + "### 2. Data Loader Configuration\n", + "- Opens `dataloader.yml` and modifies:\n", + " - Reduces total batch size from 32 to 8\n", + " - Reduces another batch size from 64 to 16\n", + " - Decreases number of workers from 4 to 1\n", + "\n", + "The changes appear to optimize the configuration for a smaller compute environment by:\n", + "- Using local paths instead of network paths\n", + "- Reducing batch sizes\n", + "- Decreasing parallel workers\n", + "- Updating dataset-specific parameters\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "91b4bada-36bb-47b0-9098-4c1e7e3ba5a0", + "metadata": { + "id": "91b4bada-36bb-47b0-9098-4c1e7e3ba5a0" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "custom_detection_config = os.path.join(HOME, 'D-FINE/configs/dataset/custom_detection.yml')\n", + "\n", + "with open(custom_detection_config, 'r') as file:\n", + " data = file.read()\n", + "\n", + "\n", + "data = data.replace('/data/yourdataset/train/train.json', os.path.join(HOME, 'datasets/circuit-elements-3/train/_annotations.coco.json'))\n", + "data = data.replace('/data/yourdataset/val/val.json', os.path.join(HOME, 'datasets/circuit-elements-3/valid/_annotations.coco.json'))\n", + "data = data.replace('/data/yourdataset/train', os.path.join(HOME, 'datasets/circuit-elements-3/train'))\n", + "data = data.replace('/data/yourdataset/val', os.path.join(HOME, 'datasets/circuit-elements-3/valid'))\n", + "data = data.replace('num_classes: 777 # your dataset classes', 'num_classes: 46') # class number coming from the dataset\n", + "data = data.replace('num_workers: 4', 'num_workers: 2')\n", + "\n", + "\n", + "with open(custom_detection_config, 'w') as file:\n", + " file.write(data)" + ] + }, + { + "cell_type": "code", + "source": [ + "data_loader_path = os.path.join(HOME, 'D-FINE/configs/dfine/include/dataloader.yml')\n", + "\n", + "with open(data_loader_path, 'r') as file:\n", + " data = file.read()\n", + "\n", + "data = data.replace('total_batch_size: 32 #', 'total_batch_size: 8 #')\n", + "data = data.replace('total_batch_size: 64', 'total_batch_size: 16')\n", + "data = data.replace('num_workers: 4', 'num_workers: 1')\n", + "\n", + "\n", + "with open(data_loader_path, 'w') as file:\n", + " file.write(data)" + ], + "metadata": { + "id": "yyK1U0WkyukH" + }, + "id": "yyK1U0WkyukH", + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's do a final check of our custom detection dataset configurations" + ], + "metadata": { + "id": "f8eySozMxH2O" + }, + "id": "f8eySozMxH2O" + }, + { + "cell_type": "code", + "source": [ + "!cat /content/D-FINE/configs/dataset/custom_detection.yml" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "b0yM9ZydwkqM", + "outputId": "588a89dd-236d-4f55-ade9-a6640087bbdd" + }, + "id": "b0yM9ZydwkqM", + "execution_count": 33, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "task: detection\n", + "\n", + "evaluator:\n", + " type: CocoEvaluator\n", + " iou_types: ['bbox', ]\n", + "\n", + "num_classes: 46\n", + "remap_mscoco_category: False\n", + "\n", + "train_dataloader:\n", + " type: DataLoader\n", + " dataset:\n", + " type: CocoDetection\n", + " img_folder: /content/datasets/circuit-elements-3/train\n", + " ann_file: /content/datasets/circuit-elements-3/train/_annotations.coco.json\n", + " return_masks: False\n", + " transforms:\n", + " type: Compose\n", + " ops: ~\n", + " shuffle: True\n", + " num_workers: 2\n", + " drop_last: True\n", + " collate_fn:\n", + " type: BatchImageCollateFunction\n", + "\n", + "\n", + "val_dataloader:\n", + " type: DataLoader\n", + " dataset:\n", + " type: CocoDetection\n", + " img_folder: /content/datasets/circuit-elements-3/valid\n", + " ann_file: /content/datasets/circuit-elements-3/valid/_annotations.coco.json\n", + " return_masks: False\n", + " transforms:\n", + " type: Compose\n", + " ops: ~\n", + " shuffle: False\n", + " num_workers: 2\n", + " drop_last: False\n", + " collate_fn:\n", + " type: BatchImageCollateFunction\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!cat /content/D-FINE/configs/dfine/include/dataloader.yml" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JQ0H1TAO0AmF", + "outputId": "e437ba30-83ca-4d3b-d091-2c7c1b3640c0" + }, + "id": "JQ0H1TAO0AmF", + "execution_count": 32, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "train_dataloader:\n", + " dataset:\n", + " transforms:\n", + " ops:\n", + " - {type: RandomPhotometricDistort, p: 0.5}\n", + " - {type: RandomZoomOut, fill: 0}\n", + " - {type: RandomIoUCrop, p: 0.8}\n", + " - {type: SanitizeBoundingBoxes, min_size: 1}\n", + " - {type: RandomHorizontalFlip}\n", + " - {type: Resize, size: [640, 640], }\n", + " - {type: SanitizeBoundingBoxes, min_size: 1}\n", + " - {type: ConvertPILImage, dtype: 'float32', scale: True}\n", + " - {type: ConvertBoxes, fmt: 'cxcywh', normalize: True}\n", + " policy:\n", + " name: stop_epoch\n", + " epoch: 72 # epoch in [71, ~) stop `ops`\n", + " ops: ['RandomPhotometricDistort', 'RandomZoomOut', 'RandomIoUCrop']\n", + "\n", + " collate_fn:\n", + " type: BatchImageCollateFunction\n", + " base_size: 640\n", + " base_size_repeat: 3\n", + " stop_epoch: 72 # epoch in [72, ~) stop `multiscales`\n", + "\n", + " shuffle: True\n", + " total_batch_size: 8 # total batch size equals to 32 (4 * 8)\n", + " num_workers: 1\n", + "\n", + "\n", + "val_dataloader:\n", + " dataset:\n", + " transforms:\n", + " ops:\n", + " - {type: Resize, size: [640, 640], }\n", + " - {type: ConvertPILImage, dtype: 'float32', scale: True}\n", + " shuffle: False\n", + " total_batch_size: 16\n", + " num_workers: 1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Load the TensorBoard notebook extension\n", + "%load_ext tensorboard" + ], + "metadata": { + "id": "wMk4_DxXRh4a" + }, + "id": "wMk4_DxXRh4a", + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4aceba72-9809-41e8-96b6-636dc7c44779", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4aceba72-9809-41e8-96b6-636dc7c44779", + "outputId": "4d3e1ba5-f528-4b3f-f425-702c2a5db98a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2024-12-01 15:40:16.548160: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-12-01 15:40:16.565327: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-12-01 15:40:16.586433: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-12-01 15:40:16.592798: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-12-01 15:40:16.607674: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-12-01 15:40:17.734048: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "Initialized distributed mode...\n", + "cfg: {'task': 'detection', '_model': None, '_postprocessor': None, '_criterion': None, '_optimizer': None, '_lr_scheduler': None, '_lr_warmup_scheduler': None, '_train_dataloader': None, '_val_dataloader': None, '_ema': None, '_scaler': None, '_train_dataset': None, '_val_dataset': None, '_collate_fn': None, '_evaluator': None, '_writer': None, 'num_workers': 0, 'batch_size': None, '_train_batch_size': None, '_val_batch_size': None, '_train_shuffle': None, '_val_shuffle': None, 'resume': None, 'tuning': None, 'epoches': 80, 'last_epoch': -1, 'use_amp': True, 'use_ema': True, 'ema_decay': 0.9999, 'ema_warmups': 2000, 'sync_bn': True, 'clip_max_norm': 0.1, 'find_unused_parameters': False, 'seed': 0, 'print_freq': 100, 'checkpoint_freq': 12, 'output_dir': './output/dfine_hgnetv2_l_custom', 'summary_dir': None, 'device': '', 'yaml_cfg': {'task': 'detection', 'evaluator': {'type': 'CocoEvaluator', 'iou_types': ['bbox']}, 'num_classes': 46, 'remap_mscoco_category': False, 'train_dataloader': {'type': 'DataLoader', 'dataset': {'type': 'CocoDetection', 'img_folder': '/content/datasets/circuit-elements-3/train', 'ann_file': '/content/datasets/circuit-elements-3/train/_annotations.coco.json', 'return_masks': False, 'transforms': {'type': 'Compose', 'ops': [{'type': 'RandomPhotometricDistort', 'p': 0.5}, {'type': 'RandomZoomOut', 'fill': 0}, {'type': 'RandomIoUCrop', 'p': 0.8}, {'type': 'SanitizeBoundingBoxes', 'min_size': 1}, {'type': 'RandomHorizontalFlip'}, {'type': 'Resize', 'size': [640, 640]}, {'type': 'SanitizeBoundingBoxes', 'min_size': 1}, {'type': 'ConvertPILImage', 'dtype': 'float32', 'scale': True}, {'type': 'ConvertBoxes', 'fmt': 'cxcywh', 'normalize': True}], 'policy': {'name': 'stop_epoch', 'epoch': 72, 'ops': ['RandomPhotometricDistort', 'RandomZoomOut', 'RandomIoUCrop']}}}, 'shuffle': True, 'num_workers': 1, 'drop_last': True, 'collate_fn': {'type': 'BatchImageCollateFunction', 'base_size': 640, 'base_size_repeat': 4, 'stop_epoch': 72, 'ema_restart_decay': 0.9999}, 'total_batch_size': 8}, 'val_dataloader': {'type': 'DataLoader', 'dataset': {'type': 'CocoDetection', 'img_folder': '/content/datasets/circuit-elements-3/valid', 'ann_file': '/content/datasets/circuit-elements-3/valid/_annotations.coco.json', 'return_masks': False, 'transforms': {'type': 'Compose', 'ops': [{'type': 'Resize', 'size': [640, 640]}, {'type': 'ConvertPILImage', 'dtype': 'float32', 'scale': True}]}}, 'shuffle': False, 'num_workers': 1, 'drop_last': False, 'collate_fn': {'type': 'BatchImageCollateFunction'}, 'total_batch_size': 16}, 'print_freq': 100, 'output_dir': './output/dfine_hgnetv2_l_custom', 'checkpoint_freq': 12, 'sync_bn': True, 'find_unused_parameters': False, 'use_amp': True, 'scaler': {'type': 'GradScaler', 'enabled': True}, 'use_ema': True, 'ema': {'type': 'ModelEMA', 'decay': 0.9999, 'warmups': 1000, 'start': 0}, 'epoches': 80, 'clip_max_norm': 0.1, 'optimizer': {'type': 'AdamW', 'params': [{'params': '^(?=.*backbone)(?!.*norm|bn).*$', 'lr': 1.25e-05}, {'params': '^(?=.*(?:encoder|decoder))(?=.*(?:norm|bn)).*$', 'weight_decay': 0.0}], 'lr': 0.00025, 'betas': [0.9, 0.999], 'weight_decay': 0.000125}, 'lr_scheduler': {'type': 'MultiStepLR', 'milestones': [500], 'gamma': 0.1}, 'lr_warmup_scheduler': {'type': 'LinearWarmup', 'warmup_duration': 500}, 'model': 'DFINE', 'criterion': 'DFINECriterion', 'postprocessor': 'DFINEPostProcessor', 'use_focal_loss': True, 'eval_spatial_size': [640, 640], 'DFINE': {'backbone': 'HGNetv2', 'encoder': 'HybridEncoder', 'decoder': 'DFINETransformer'}, 'HGNetv2': {'pretrained': True, 'local_model_dir': 'weight/hgnetv2/', 'name': 'B4', 'return_idx': [1, 2, 3], 'freeze_stem_only': True, 'freeze_at': 0, 'freeze_norm': True}, 'HybridEncoder': {'in_channels': [512, 1024, 2048], 'feat_strides': [8, 16, 32], 'hidden_dim': 256, 'use_encoder_idx': [2], 'num_encoder_layers': 1, 'nhead': 8, 'dim_feedforward': 1024, 'dropout': 0.0, 'enc_act': 'gelu', 'expansion': 1.0, 'depth_mult': 1, 'act': 'silu'}, 'DFINETransformer': {'feat_channels': [256, 256, 256], 'feat_strides': [8, 16, 32], 'hidden_dim': 256, 'num_levels': 3, 'num_layers': 6, 'eval_idx': -1, 'num_queries': 300, 'num_denoising': 100, 'label_noise_ratio': 0.5, 'box_noise_scale': 1.0, 'reg_max': 32, 'reg_scale': 4, 'layer_scale': 1, 'num_points': [3, 6, 3], 'cross_attn_method': 'default', 'query_select_method': 'default'}, 'DFINEPostProcessor': {'num_top_queries': 300}, 'DFINECriterion': {'weight_dict': {'loss_vfl': 1, 'loss_bbox': 5, 'loss_giou': 2, 'loss_fgl': 0.15, 'loss_ddf': 1.5}, 'losses': ['vfl', 'boxes', 'local'], 'alpha': 0.75, 'gamma': 2.0, 'reg_max': 32, 'matcher': {'type': 'HungarianMatcher', 'weight_dict': {'cost_class': 2, 'cost_bbox': 5, 'cost_giou': 2}, 'alpha': 0.25, 'gamma': 2.0}}, '__include__': ['../../dataset/custom_detection.yml', '../../runtime.yml', '../include/dataloader.yml', '../include/optimizer.yml', '../include/dfine_hgnetv2.yml'], 'config': 'D-FINE/configs/dfine/custom/dfine_hgnetv2_l_custom.yml', 'seed': 0, 'test_only': False, 'print_method': 'builtin', 'print_rank': 0}}\n", + "\u001b[92mIf the pretrained HGNetV2 can't be downloaded automatically. Please check your network connection.\u001b[0m\n", + "\u001b[92mPlease check your network connection. Or download the model manually from \u001b[0mhttps://github.com/Peterande/storage/releases/download/dfinev1.0/PPHGNetV2_B4_stage1.pth\u001b[92m to \u001b[0mweight/hgnetv2/.\u001b[0m\n", + "Downloading: \"https://github.com/Peterande/storage/releases/download/dfinev1.0/PPHGNetV2_B4_stage1.pth\" to weight/hgnetv2/PPHGNetV2_B4_stage1.pth\n", + "100% 52.0M/52.0M [00:00<00:00, 358MB/s]\n", + "Loaded stage1 B4 HGNetV2 from URL.\n", + "/content/D-FINE/src/core/workspace.py:180: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n", + " return module(**module_kwargs)\n", + "Initial lr: [1.25e-05, 0.00025, 0.00025]\n", + "building train_dataloader with batch_size=8...\n", + "building val_dataloader with batch_size=16...\n", + "\n", + "------------------------------------- Calculate Flops Results -------------------------------------\n", + "Notations:\n", + "number of parameters (Params), number of multiply-accumulate operations(MACs),\n", + "number of floating-point operations (FLOPs), floating-point operations per second (FLOPS),\n", + "fwd FLOPs (model forward propagation FLOPs), bwd FLOPs (model backward propagation FLOPs),\n", + "default model backpropagation takes 2.00 times as much computation as forward propagation.\n", + "\n", + "Total Training Params: 30.67 M \n", + "fwd MACs: 45.3752 GMACs\n", + "fwd FLOPs: 90.883 GFLOPS\n", + "fwd+bwd MACs: 136.125 GMACs\n", + "fwd+bwd FLOPs: 272.649 GFLOPS\n", + "---------------------------------------------------------------------------------------------------\n", + "{'Model FLOPs:90.883 GFLOPS MACs:45.3752 GMACs Params:30698015'}\n", + "------------------------------------------Start training-------------------------------------------\n", + "Epoch: [0] [ 0/84] eta: 0:05:58 lr: 0.000000 loss: 60.5611 (60.5611) loss_vfl: 0.0102 (0.0102) loss_bbox: 1.8449 (1.8449) loss_giou: 3.1346 (3.1346) loss_fgl: 0.0343 (0.0343) loss_vfl_aux_0: 0.0094 (0.0094) loss_bbox_aux_0: 1.8449 (1.8449) loss_giou_aux_0: 3.1346 (3.1346) loss_fgl_aux_0: 0.0343 (0.0343) loss_ddf_aux_0: 0.0000 (0.0000) loss_vfl_aux_1: 0.0106 (0.0106) loss_bbox_aux_1: 1.8449 (1.8449) loss_giou_aux_1: 3.1346 (3.1346) loss_fgl_aux_1: 0.0343 (0.0343) loss_ddf_aux_1: 0.0000 (0.0000) loss_vfl_aux_2: 0.0108 (0.0108) loss_bbox_aux_2: 1.8449 (1.8449) loss_giou_aux_2: 3.1346 (3.1346) loss_fgl_aux_2: 0.0343 (0.0343) loss_ddf_aux_2: 0.0000 (0.0000) loss_vfl_aux_3: 0.0091 (0.0091) loss_bbox_aux_3: 1.8449 (1.8449) loss_giou_aux_3: 3.1346 (3.1346) loss_fgl_aux_3: 0.0343 (0.0343) loss_ddf_aux_3: 0.0000 (0.0000) loss_vfl_aux_4: 0.0102 (0.0102) loss_bbox_aux_4: 1.8449 (1.8449) loss_giou_aux_4: 3.1346 (3.1346) loss_fgl_aux_4: 0.0343 (0.0343) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.0094 (0.0094) loss_bbox_pre: 1.8449 (1.8449) loss_giou_pre: 3.1346 (3.1346) loss_vfl_enc_0: 0.0080 (0.0080) loss_bbox_enc_0: 1.8449 (1.8449) loss_giou_enc_0: 3.1346 (3.1346) loss_vfl_dn_0: 0.7197 (0.7197) loss_bbox_dn_0: 0.0544 (0.0544) loss_giou_dn_0: 1.3859 (1.3859) loss_fgl_dn_0: 0.8090 (0.8090) loss_ddf_dn_0: 0.0000 (0.0000) loss_vfl_dn_1: 0.8516 (0.8516) loss_bbox_dn_1: 0.0544 (0.0544) loss_giou_dn_1: 1.3859 (1.3859) loss_fgl_dn_1: 0.8090 (0.8090) loss_ddf_dn_1: 0.0000 (0.0000) loss_vfl_dn_2: 0.8496 (0.8496) loss_bbox_dn_2: 0.0544 (0.0544) loss_giou_dn_2: 1.3859 (1.3859) loss_fgl_dn_2: 0.8090 (0.8090) loss_ddf_dn_2: 0.0000 (0.0000) loss_vfl_dn_3: 0.8350 (0.8350) loss_bbox_dn_3: 0.0544 (0.0544) loss_giou_dn_3: 1.3859 (1.3859) loss_fgl_dn_3: 0.8090 (0.8090) loss_ddf_dn_3: 0.0000 (0.0000) loss_vfl_dn_4: 0.7393 (0.7393) loss_bbox_dn_4: 0.0544 (0.0544) loss_giou_dn_4: 1.3859 (1.3859) loss_fgl_dn_4: 0.8090 (0.8090) loss_ddf_dn_4: 0.0000 (0.0000) loss_vfl_dn_5: 0.7905 (0.7905) loss_bbox_dn_5: 0.0544 (0.0544) loss_giou_dn_5: 1.3859 (1.3859) loss_fgl_dn_5: 0.8090 (0.8090) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.7197 (0.7197) loss_bbox_dn_pre: 0.0544 (0.0544) loss_giou_dn_pre: 1.3859 (1.3859) time: 4.2679 data: 0.7943 max mem: 24867\n", + "Epoch: [0] [83/84] eta: 0:00:01 lr: 0.000002 loss: 54.1478 (59.2502) loss_vfl: 0.0312 (0.0261) loss_bbox: 1.4277 (1.8090) loss_giou: 2.9221 (3.1084) loss_fgl: 0.0668 (0.0544) loss_vfl_aux_0: 0.0307 (0.0245) loss_bbox_aux_0: 1.4725 (1.8316) loss_giou_aux_0: 2.9024 (3.0921) loss_fgl_aux_0: 0.0681 (0.0546) loss_ddf_aux_0: 0.0054 (0.0020) loss_vfl_aux_1: 0.0322 (0.0263) loss_bbox_aux_1: 1.4580 (1.8255) loss_giou_aux_1: 2.9144 (3.0966) loss_fgl_aux_1: 0.0679 (0.0545) loss_ddf_aux_1: 0.0032 (0.0011) loss_vfl_aux_2: 0.0323 (0.0263) loss_bbox_aux_2: 1.4471 (1.8205) loss_giou_aux_2: 2.9205 (3.1003) loss_fgl_aux_2: 0.0675 (0.0544) loss_ddf_aux_2: 0.0015 (0.0005) loss_vfl_aux_3: 0.0336 (0.0253) loss_bbox_aux_3: 1.4365 (1.8148) loss_giou_aux_3: 2.9267 (3.1044) loss_fgl_aux_3: 0.0671 (0.0543) loss_ddf_aux_3: 0.0006 (0.0002) loss_vfl_aux_4: 0.0329 (0.0263) loss_bbox_aux_4: 1.4308 (1.8115) loss_giou_aux_4: 2.9244 (3.1067) loss_fgl_aux_4: 0.0669 (0.0544) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0305 (0.0245) loss_bbox_pre: 1.4809 (1.8351) loss_giou_pre: 2.8950 (3.0896) loss_vfl_enc_0: 0.0328 (0.0252) loss_bbox_enc_0: 1.4986 (1.8422) loss_giou_enc_0: 2.8794 (3.0845) loss_vfl_dn_0: 0.4773 (0.6095) loss_bbox_dn_0: 0.0606 (0.0673) loss_giou_dn_0: 1.3910 (1.3901) loss_fgl_dn_0: 0.7979 (0.8031) loss_ddf_dn_0: 0.0280 (0.0086) loss_vfl_dn_1: 0.4897 (0.6653) loss_bbox_dn_1: 0.0601 (0.0670) loss_giou_dn_1: 1.3925 (1.3909) loss_fgl_dn_1: 0.7886 (0.7994) loss_ddf_dn_1: 0.0157 (0.0050) loss_vfl_dn_2: 0.4502 (0.6346) loss_bbox_dn_2: 0.0598 (0.0668) loss_giou_dn_2: 1.3935 (1.3914) loss_fgl_dn_2: 0.7811 (0.7964) loss_ddf_dn_2: 0.0069 (0.0022) loss_vfl_dn_3: 0.4724 (0.6271) loss_bbox_dn_3: 0.0597 (0.0667) loss_giou_dn_3: 1.3935 (1.3920) loss_fgl_dn_3: 0.7774 (0.7943) loss_ddf_dn_3: 0.0029 (0.0010) loss_vfl_dn_4: 0.4780 (0.5993) loss_bbox_dn_4: 0.0601 (0.0666) loss_giou_dn_4: 1.3940 (1.3922) loss_fgl_dn_4: 0.7760 (0.7928) loss_ddf_dn_4: 0.0007 (0.0004) loss_vfl_dn_5: 0.4624 (0.5945) loss_bbox_dn_5: 0.0606 (0.0665) loss_giou_dn_5: 1.3935 (1.3923) loss_fgl_dn_5: 0.7752 (0.7919) loss_ddf_dn_5: -0.0000 (0.0000) loss_vfl_dn_pre: 0.4780 (0.6100) loss_bbox_dn_pre: 0.0610 (0.0675) loss_giou_dn_pre: 1.3902 (1.3898) time: 1.1291 data: 0.0166 max mem: 28434\n", + "Epoch: [0] Total time: 0:01:49 (1.3023 s / it)\n", + "Averaged stats: lr: 0.000002 loss: 54.1478 (59.2502) loss_vfl: 0.0312 (0.0261) loss_bbox: 1.4277 (1.8090) loss_giou: 2.9221 (3.1084) loss_fgl: 0.0668 (0.0544) loss_vfl_aux_0: 0.0307 (0.0245) loss_bbox_aux_0: 1.4725 (1.8316) loss_giou_aux_0: 2.9024 (3.0921) loss_fgl_aux_0: 0.0681 (0.0546) loss_ddf_aux_0: 0.0054 (0.0020) loss_vfl_aux_1: 0.0322 (0.0263) loss_bbox_aux_1: 1.4580 (1.8255) loss_giou_aux_1: 2.9144 (3.0966) loss_fgl_aux_1: 0.0679 (0.0545) loss_ddf_aux_1: 0.0032 (0.0011) loss_vfl_aux_2: 0.0323 (0.0263) loss_bbox_aux_2: 1.4471 (1.8205) loss_giou_aux_2: 2.9205 (3.1003) loss_fgl_aux_2: 0.0675 (0.0544) loss_ddf_aux_2: 0.0015 (0.0005) loss_vfl_aux_3: 0.0336 (0.0253) loss_bbox_aux_3: 1.4365 (1.8148) loss_giou_aux_3: 2.9267 (3.1044) loss_fgl_aux_3: 0.0671 (0.0543) loss_ddf_aux_3: 0.0006 (0.0002) loss_vfl_aux_4: 0.0329 (0.0263) loss_bbox_aux_4: 1.4308 (1.8115) loss_giou_aux_4: 2.9244 (3.1067) loss_fgl_aux_4: 0.0669 (0.0544) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0305 (0.0245) loss_bbox_pre: 1.4809 (1.8351) loss_giou_pre: 2.8950 (3.0896) loss_vfl_enc_0: 0.0328 (0.0252) loss_bbox_enc_0: 1.4986 (1.8422) loss_giou_enc_0: 2.8794 (3.0845) loss_vfl_dn_0: 0.4773 (0.6095) loss_bbox_dn_0: 0.0606 (0.0673) loss_giou_dn_0: 1.3910 (1.3901) loss_fgl_dn_0: 0.7979 (0.8031) loss_ddf_dn_0: 0.0280 (0.0086) loss_vfl_dn_1: 0.4897 (0.6653) loss_bbox_dn_1: 0.0601 (0.0670) loss_giou_dn_1: 1.3925 (1.3909) loss_fgl_dn_1: 0.7886 (0.7994) loss_ddf_dn_1: 0.0157 (0.0050) loss_vfl_dn_2: 0.4502 (0.6346) loss_bbox_dn_2: 0.0598 (0.0668) loss_giou_dn_2: 1.3935 (1.3914) loss_fgl_dn_2: 0.7811 (0.7964) loss_ddf_dn_2: 0.0069 (0.0022) loss_vfl_dn_3: 0.4724 (0.6271) loss_bbox_dn_3: 0.0597 (0.0667) loss_giou_dn_3: 1.3935 (1.3920) loss_fgl_dn_3: 0.7774 (0.7943) loss_ddf_dn_3: 0.0029 (0.0010) loss_vfl_dn_4: 0.4780 (0.5993) loss_bbox_dn_4: 0.0601 (0.0666) loss_giou_dn_4: 1.3940 (1.3922) loss_fgl_dn_4: 0.7760 (0.7928) loss_ddf_dn_4: 0.0007 (0.0004) loss_vfl_dn_5: 0.4624 (0.5945) loss_bbox_dn_5: 0.0606 (0.0665) loss_giou_dn_5: 1.3935 (1.3923) loss_fgl_dn_5: 0.7752 (0.7919) loss_ddf_dn_5: -0.0000 (0.0000) loss_vfl_dn_pre: 0.4780 (0.6100) loss_bbox_dn_pre: 0.0610 (0.0675) loss_giou_dn_pre: 1.3902 (1.3898)\n", + "Test: [0/4] eta: 0:00:03 time: 0.8483 data: 0.5054 max mem: 28434\n", + "Test: [3/4] eta: 0:00:00 time: 0.5833 data: 0.1673 max mem: 28434\n", + "Test: Total time: 0:00:02 (0.5995 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.04s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.007\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + "best_stat: {'epoch': 0, 'coco_eval_bbox': 1.1819770171391798e-06}\n", + "Epoch: [1] [ 0/84] eta: 0:03:04 lr: 0.000002 loss: 47.5798 (47.5798) loss_vfl: 0.0385 (0.0385) loss_bbox: 0.9823 (0.9823) loss_giou: 2.5776 (2.5776) loss_fgl: 0.1034 (0.1034) loss_vfl_aux_0: 0.0339 (0.0339) loss_bbox_aux_0: 0.9963 (0.9963) loss_giou_aux_0: 2.5663 (2.5663) loss_fgl_aux_0: 0.1000 (0.1000) loss_ddf_aux_0: 0.0124 (0.0124) loss_vfl_aux_1: 0.0355 (0.0355) loss_bbox_aux_1: 0.9827 (0.9827) loss_giou_aux_1: 2.5774 (2.5774) loss_fgl_aux_1: 0.1002 (0.1002) loss_ddf_aux_1: 0.0062 (0.0062) loss_vfl_aux_2: 0.0358 (0.0358) loss_bbox_aux_2: 0.9776 (0.9776) loss_giou_aux_2: 2.5817 (2.5817) loss_fgl_aux_2: 0.1010 (0.1010) loss_ddf_aux_2: 0.0025 (0.0025) loss_vfl_aux_3: 0.0356 (0.0356) loss_bbox_aux_3: 0.9725 (0.9725) loss_giou_aux_3: 2.5860 (2.5860) loss_fgl_aux_3: 0.1017 (0.1017) loss_ddf_aux_3: 0.0010 (0.0010) loss_vfl_aux_4: 0.0354 (0.0354) loss_bbox_aux_4: 0.9778 (0.9778) loss_giou_aux_4: 2.5813 (2.5813) loss_fgl_aux_4: 0.1027 (0.1027) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.0339 (0.0339) loss_bbox_pre: 1.0057 (1.0057) loss_giou_pre: 2.5591 (2.5591) loss_vfl_enc_0: 0.0361 (0.0361) loss_bbox_enc_0: 1.0270 (1.0270) loss_giou_enc_0: 2.5434 (2.5434) loss_vfl_dn_0: 0.4495 (0.4495) loss_bbox_dn_0: 0.0636 (0.0636) loss_giou_dn_0: 1.3864 (1.3864) loss_fgl_dn_0: 0.7978 (0.7978) loss_ddf_dn_0: 0.0514 (0.0514) loss_vfl_dn_1: 0.4756 (0.4756) loss_bbox_dn_1: 0.0633 (0.0633) loss_giou_dn_1: 1.3879 (1.3879) loss_fgl_dn_1: 0.7854 (0.7854) loss_ddf_dn_1: 0.0259 (0.0259) loss_vfl_dn_2: 0.4353 (0.4353) loss_bbox_dn_2: 0.0633 (0.0633) loss_giou_dn_2: 1.3877 (1.3877) loss_fgl_dn_2: 0.7804 (0.7804) loss_ddf_dn_2: 0.0098 (0.0098) loss_vfl_dn_3: 0.4834 (0.4834) loss_bbox_dn_3: 0.0634 (0.0634) loss_giou_dn_3: 1.3874 (1.3874) loss_fgl_dn_3: 0.7800 (0.7800) loss_ddf_dn_3: 0.0044 (0.0044) loss_vfl_dn_4: 0.4700 (0.4700) loss_bbox_dn_4: 0.0639 (0.0639) loss_giou_dn_4: 1.3853 (1.3853) loss_fgl_dn_4: 0.7834 (0.7834) loss_ddf_dn_4: 0.0009 (0.0009) loss_vfl_dn_5: 0.4495 (0.4495) loss_bbox_dn_5: 0.0645 (0.0645) loss_giou_dn_5: 1.3841 (1.3841) loss_fgl_dn_5: 0.7860 (0.7860) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4507 (0.4507) loss_bbox_dn_pre: 0.0640 (0.0640) loss_giou_dn_pre: 1.3854 (1.3854) time: 2.1975 data: 0.7972 max mem: 28434\n", + "Epoch: [1] [83/84] eta: 0:00:00 lr: 0.000004 loss: 41.3792 (43.5945) loss_vfl: 0.0663 (0.0707) loss_bbox: 0.5932 (0.7276) loss_giou: 2.1889 (2.3246) loss_fgl: 0.1861 (0.1656) loss_vfl_aux_0: 0.0644 (0.0644) loss_bbox_aux_0: 0.6013 (0.7290) loss_giou_aux_0: 2.1907 (2.3263) loss_fgl_aux_0: 0.1823 (0.1621) loss_ddf_aux_0: 0.0031 (0.0075) loss_vfl_aux_1: 0.0629 (0.0652) loss_bbox_aux_1: 0.6018 (0.7260) loss_giou_aux_1: 2.1890 (2.3281) loss_fgl_aux_1: 0.1842 (0.1636) loss_ddf_aux_1: 0.0017 (0.0028) loss_vfl_aux_2: 0.0632 (0.0658) loss_bbox_aux_2: 0.5997 (0.7270) loss_giou_aux_2: 2.1877 (2.3265) loss_fgl_aux_2: 0.1852 (0.1645) loss_ddf_aux_2: 0.0010 (0.0012) loss_vfl_aux_3: 0.0649 (0.0672) loss_bbox_aux_3: 0.5946 (0.7254) loss_giou_aux_3: 2.1897 (2.3275) loss_fgl_aux_3: 0.1861 (0.1651) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.0667 (0.0679) loss_bbox_aux_4: 0.5932 (0.7272) loss_giou_aux_4: 2.1901 (2.3253) loss_fgl_aux_4: 0.1862 (0.1654) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.0655 (0.0642) loss_bbox_pre: 0.5970 (0.7301) loss_giou_pre: 2.1927 (2.3262) loss_vfl_enc_0: 0.0623 (0.0652) loss_bbox_enc_0: 0.5984 (0.7408) loss_giou_enc_0: 2.1942 (2.3173) loss_vfl_dn_0: 0.3584 (0.3786) loss_bbox_dn_0: 0.0639 (0.0694) loss_giou_dn_0: 1.3896 (1.3903) loss_fgl_dn_0: 0.7772 (0.7824) loss_ddf_dn_0: 0.0100 (0.0255) loss_vfl_dn_1: 0.3538 (0.3785) loss_bbox_dn_1: 0.0637 (0.0699) loss_giou_dn_1: 1.3903 (1.3901) loss_fgl_dn_1: 0.7759 (0.7792) loss_ddf_dn_1: 0.0041 (0.0095) loss_vfl_dn_2: 0.3535 (0.3751) loss_bbox_dn_2: 0.0639 (0.0706) loss_giou_dn_2: 1.3908 (1.3896) loss_fgl_dn_2: 0.7755 (0.7799) loss_ddf_dn_2: 0.0024 (0.0035) loss_vfl_dn_3: 0.3582 (0.3850) loss_bbox_dn_3: 0.0639 (0.0707) loss_giou_dn_3: 1.3908 (1.3894) loss_fgl_dn_3: 0.7756 (0.7806) loss_ddf_dn_3: 0.0010 (0.0015) loss_vfl_dn_4: 0.3640 (0.3894) loss_bbox_dn_4: 0.0642 (0.0711) loss_giou_dn_4: 1.3906 (1.3891) loss_fgl_dn_4: 0.7760 (0.7816) loss_ddf_dn_4: 0.0004 (0.0004) loss_vfl_dn_5: 0.3730 (0.3995) loss_bbox_dn_5: 0.0647 (0.0712) loss_giou_dn_5: 1.3905 (1.3891) loss_fgl_dn_5: 0.7765 (0.7820) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3577 (0.3784) loss_bbox_dn_pre: 0.0637 (0.0689) loss_giou_dn_pre: 1.3898 (1.3904) time: 0.9432 data: 0.0167 max mem: 28434\n", + "Epoch: [1] Total time: 0:01:23 (0.9924 s / it)\n", + "Averaged stats: lr: 0.000004 loss: 41.3792 (43.5945) loss_vfl: 0.0663 (0.0707) loss_bbox: 0.5932 (0.7276) loss_giou: 2.1889 (2.3246) loss_fgl: 0.1861 (0.1656) loss_vfl_aux_0: 0.0644 (0.0644) loss_bbox_aux_0: 0.6013 (0.7290) loss_giou_aux_0: 2.1907 (2.3263) loss_fgl_aux_0: 0.1823 (0.1621) loss_ddf_aux_0: 0.0031 (0.0075) loss_vfl_aux_1: 0.0629 (0.0652) loss_bbox_aux_1: 0.6018 (0.7260) loss_giou_aux_1: 2.1890 (2.3281) loss_fgl_aux_1: 0.1842 (0.1636) loss_ddf_aux_1: 0.0017 (0.0028) loss_vfl_aux_2: 0.0632 (0.0658) loss_bbox_aux_2: 0.5997 (0.7270) loss_giou_aux_2: 2.1877 (2.3265) loss_fgl_aux_2: 0.1852 (0.1645) loss_ddf_aux_2: 0.0010 (0.0012) loss_vfl_aux_3: 0.0649 (0.0672) loss_bbox_aux_3: 0.5946 (0.7254) loss_giou_aux_3: 2.1897 (2.3275) loss_fgl_aux_3: 0.1861 (0.1651) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.0667 (0.0679) loss_bbox_aux_4: 0.5932 (0.7272) loss_giou_aux_4: 2.1901 (2.3253) loss_fgl_aux_4: 0.1862 (0.1654) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.0655 (0.0642) loss_bbox_pre: 0.5970 (0.7301) loss_giou_pre: 2.1927 (2.3262) loss_vfl_enc_0: 0.0623 (0.0652) loss_bbox_enc_0: 0.5984 (0.7408) loss_giou_enc_0: 2.1942 (2.3173) loss_vfl_dn_0: 0.3584 (0.3786) loss_bbox_dn_0: 0.0639 (0.0694) loss_giou_dn_0: 1.3896 (1.3903) loss_fgl_dn_0: 0.7772 (0.7824) loss_ddf_dn_0: 0.0100 (0.0255) loss_vfl_dn_1: 0.3538 (0.3785) loss_bbox_dn_1: 0.0637 (0.0699) loss_giou_dn_1: 1.3903 (1.3901) loss_fgl_dn_1: 0.7759 (0.7792) loss_ddf_dn_1: 0.0041 (0.0095) loss_vfl_dn_2: 0.3535 (0.3751) loss_bbox_dn_2: 0.0639 (0.0706) loss_giou_dn_2: 1.3908 (1.3896) loss_fgl_dn_2: 0.7755 (0.7799) loss_ddf_dn_2: 0.0024 (0.0035) loss_vfl_dn_3: 0.3582 (0.3850) loss_bbox_dn_3: 0.0639 (0.0707) loss_giou_dn_3: 1.3908 (1.3894) loss_fgl_dn_3: 0.7756 (0.7806) loss_ddf_dn_3: 0.0010 (0.0015) loss_vfl_dn_4: 0.3640 (0.3894) loss_bbox_dn_4: 0.0642 (0.0711) loss_giou_dn_4: 1.3906 (1.3891) loss_fgl_dn_4: 0.7760 (0.7816) loss_ddf_dn_4: 0.0004 (0.0004) loss_vfl_dn_5: 0.3730 (0.3995) loss_bbox_dn_5: 0.0647 (0.0712) loss_giou_dn_5: 1.3905 (1.3891) loss_fgl_dn_5: 0.7765 (0.7820) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3577 (0.3784) loss_bbox_dn_pre: 0.0637 (0.0689) loss_giou_dn_pre: 1.3898 (1.3904)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7280 data: 0.4943 max mem: 28434\n", + "Test: [3/4] eta: 0:00:00 time: 0.3960 data: 0.1710 max mem: 28434\n", + "Test: Total time: 0:00:01 (0.4104 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.04s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.001\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.007\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + "best_stat: {'epoch': 1, 'coco_eval_bbox': 0.0001096125950098194}\n", + "Epoch: [2] [ 0/84] eta: 0:03:06 lr: 0.000004 loss: 39.2806 (39.2806) loss_vfl: 0.0624 (0.0624) loss_bbox: 0.4263 (0.4263) loss_giou: 2.0715 (2.0715) loss_fgl: 0.2152 (0.2152) loss_vfl_aux_0: 0.0601 (0.0601) loss_bbox_aux_0: 0.4253 (0.4253) loss_giou_aux_0: 2.0752 (2.0752) loss_fgl_aux_0: 0.2141 (0.2141) loss_ddf_aux_0: 0.0051 (0.0051) loss_vfl_aux_1: 0.0617 (0.0617) loss_bbox_aux_1: 0.4221 (0.4221) loss_giou_aux_1: 2.0787 (2.0787) loss_fgl_aux_1: 0.2154 (0.2154) loss_ddf_aux_1: 0.0028 (0.0028) loss_vfl_aux_2: 0.0628 (0.0628) loss_bbox_aux_2: 0.4226 (0.4226) loss_giou_aux_2: 2.0771 (2.0771) loss_fgl_aux_2: 0.2159 (0.2159) loss_ddf_aux_2: 0.0017 (0.0017) loss_vfl_aux_3: 0.0646 (0.0646) loss_bbox_aux_3: 0.4224 (0.4224) loss_giou_aux_3: 2.0766 (2.0766) loss_fgl_aux_3: 0.2161 (0.2161) loss_ddf_aux_3: 0.0009 (0.0009) loss_vfl_aux_4: 0.0638 (0.0638) loss_bbox_aux_4: 0.4242 (0.4242) loss_giou_aux_4: 2.0740 (2.0740) loss_fgl_aux_4: 0.2158 (0.2158) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.0594 (0.0594) loss_bbox_pre: 0.4260 (0.4260) loss_giou_pre: 2.0754 (2.0754) loss_vfl_enc_0: 0.0617 (0.0617) loss_bbox_enc_0: 0.4258 (0.4258) loss_giou_enc_0: 2.0769 (2.0769) loss_vfl_dn_0: 0.3562 (0.3562) loss_bbox_dn_0: 0.0816 (0.0816) loss_giou_dn_0: 1.3810 (1.3810) loss_fgl_dn_0: 0.7854 (0.7854) loss_ddf_dn_0: 0.0168 (0.0168) loss_vfl_dn_1: 0.3545 (0.3545) loss_bbox_dn_1: 0.0820 (0.0820) loss_giou_dn_1: 1.3816 (1.3816) loss_fgl_dn_1: 0.7842 (0.7842) loss_ddf_dn_1: 0.0061 (0.0061) loss_vfl_dn_2: 0.3569 (0.3569) loss_bbox_dn_2: 0.0825 (0.0825) loss_giou_dn_2: 1.3823 (1.3823) loss_fgl_dn_2: 0.7836 (0.7836) loss_ddf_dn_2: 0.0028 (0.0028) loss_vfl_dn_3: 0.3560 (0.3560) loss_bbox_dn_3: 0.0827 (0.0827) loss_giou_dn_3: 1.3827 (1.3827) loss_fgl_dn_3: 0.7834 (0.7834) loss_ddf_dn_3: 0.0010 (0.0010) loss_vfl_dn_4: 0.3542 (0.3542) loss_bbox_dn_4: 0.0833 (0.0833) loss_giou_dn_4: 1.3836 (1.3836) loss_fgl_dn_4: 0.7833 (0.7833) loss_ddf_dn_4: 0.0003 (0.0003) loss_vfl_dn_5: 0.3643 (0.3643) loss_bbox_dn_5: 0.0838 (0.0838) loss_giou_dn_5: 1.3844 (1.3844) loss_fgl_dn_5: 0.7832 (0.7832) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3552 (0.3552) loss_bbox_dn_pre: 0.0809 (0.0809) loss_giou_dn_pre: 1.3808 (1.3808) time: 2.2222 data: 1.1492 max mem: 28434\n", + "Epoch: [2] [83/84] eta: 0:00:00 lr: 0.000006 loss: 40.4128 (40.3949) loss_vfl: 0.0980 (0.0952) loss_bbox: 0.4688 (0.4830) loss_giou: 2.1141 (2.1117) loss_fgl: 0.2300 (0.2303) loss_vfl_aux_0: 0.0961 (0.0940) loss_bbox_aux_0: 0.4703 (0.4844) loss_giou_aux_0: 2.1150 (2.1122) loss_fgl_aux_0: 0.2318 (0.2306) loss_ddf_aux_0: 0.0489 (0.0205) loss_vfl_aux_1: 0.0948 (0.0946) loss_bbox_aux_1: 0.4688 (0.4820) loss_giou_aux_1: 2.1163 (2.1147) loss_fgl_aux_1: 0.2315 (0.2311) loss_ddf_aux_1: 0.0038 (0.0032) loss_vfl_aux_2: 0.0967 (0.0949) loss_bbox_aux_2: 0.4691 (0.4830) loss_giou_aux_2: 2.1160 (2.1132) loss_fgl_aux_2: 0.2307 (0.2308) loss_ddf_aux_2: 0.0010 (0.0013) loss_vfl_aux_3: 0.0963 (0.0951) loss_bbox_aux_3: 0.4691 (0.4826) loss_giou_aux_3: 2.1156 (2.1131) loss_fgl_aux_3: 0.2303 (0.2307) loss_ddf_aux_3: 0.0004 (0.0006) loss_vfl_aux_4: 0.0956 (0.0951) loss_bbox_aux_4: 0.4689 (0.4828) loss_giou_aux_4: 2.1148 (2.1123) loss_fgl_aux_4: 0.2300 (0.2305) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0952 (0.0931) loss_bbox_pre: 0.4712 (0.4852) loss_giou_pre: 2.1167 (2.1121) loss_vfl_enc_0: 0.0931 (0.0911) loss_bbox_enc_0: 0.4654 (0.4829) loss_giou_enc_0: 2.1216 (2.1158) loss_vfl_dn_0: 0.3521 (0.3548) loss_bbox_dn_0: 0.0747 (0.0703) loss_giou_dn_0: 1.3863 (1.3867) loss_fgl_dn_0: 0.7821 (0.7814) loss_ddf_dn_0: 0.1910 (0.0811) loss_vfl_dn_1: 0.3469 (0.3508) loss_bbox_dn_1: 0.0757 (0.0710) loss_giou_dn_1: 1.3854 (1.3867) loss_fgl_dn_1: 0.7809 (0.7811) loss_ddf_dn_1: 0.0099 (0.0074) loss_vfl_dn_2: 0.3481 (0.3505) loss_bbox_dn_2: 0.0759 (0.0714) loss_giou_dn_2: 1.3852 (1.3867) loss_fgl_dn_2: 0.7808 (0.7811) loss_ddf_dn_2: 0.0015 (0.0018) loss_vfl_dn_3: 0.3491 (0.3523) loss_bbox_dn_3: 0.0759 (0.0715) loss_giou_dn_3: 1.3854 (1.3866) loss_fgl_dn_3: 0.7812 (0.7812) loss_ddf_dn_3: 0.0004 (0.0006) loss_vfl_dn_4: 0.3489 (0.3557) loss_bbox_dn_4: 0.0759 (0.0717) loss_giou_dn_4: 1.3854 (1.3866) loss_fgl_dn_4: 0.7815 (0.7813) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3552 (0.3614) loss_bbox_dn_5: 0.0757 (0.0717) loss_giou_dn_5: 1.3853 (1.3866) loss_fgl_dn_5: 0.7817 (0.7814) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3503 (0.3534) loss_bbox_dn_pre: 0.0755 (0.0697) loss_giou_dn_pre: 1.3860 (1.3867) time: 0.8865 data: 0.0173 max mem: 28434\n", + "Epoch: [2] Total time: 0:01:18 (0.9347 s / it)\n", + "Averaged stats: lr: 0.000006 loss: 40.4128 (40.3949) loss_vfl: 0.0980 (0.0952) loss_bbox: 0.4688 (0.4830) loss_giou: 2.1141 (2.1117) loss_fgl: 0.2300 (0.2303) loss_vfl_aux_0: 0.0961 (0.0940) loss_bbox_aux_0: 0.4703 (0.4844) loss_giou_aux_0: 2.1150 (2.1122) loss_fgl_aux_0: 0.2318 (0.2306) loss_ddf_aux_0: 0.0489 (0.0205) loss_vfl_aux_1: 0.0948 (0.0946) loss_bbox_aux_1: 0.4688 (0.4820) loss_giou_aux_1: 2.1163 (2.1147) loss_fgl_aux_1: 0.2315 (0.2311) loss_ddf_aux_1: 0.0038 (0.0032) loss_vfl_aux_2: 0.0967 (0.0949) loss_bbox_aux_2: 0.4691 (0.4830) loss_giou_aux_2: 2.1160 (2.1132) loss_fgl_aux_2: 0.2307 (0.2308) loss_ddf_aux_2: 0.0010 (0.0013) loss_vfl_aux_3: 0.0963 (0.0951) loss_bbox_aux_3: 0.4691 (0.4826) loss_giou_aux_3: 2.1156 (2.1131) loss_fgl_aux_3: 0.2303 (0.2307) loss_ddf_aux_3: 0.0004 (0.0006) loss_vfl_aux_4: 0.0956 (0.0951) loss_bbox_aux_4: 0.4689 (0.4828) loss_giou_aux_4: 2.1148 (2.1123) loss_fgl_aux_4: 0.2300 (0.2305) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0952 (0.0931) loss_bbox_pre: 0.4712 (0.4852) loss_giou_pre: 2.1167 (2.1121) loss_vfl_enc_0: 0.0931 (0.0911) loss_bbox_enc_0: 0.4654 (0.4829) loss_giou_enc_0: 2.1216 (2.1158) loss_vfl_dn_0: 0.3521 (0.3548) loss_bbox_dn_0: 0.0747 (0.0703) loss_giou_dn_0: 1.3863 (1.3867) loss_fgl_dn_0: 0.7821 (0.7814) loss_ddf_dn_0: 0.1910 (0.0811) loss_vfl_dn_1: 0.3469 (0.3508) loss_bbox_dn_1: 0.0757 (0.0710) loss_giou_dn_1: 1.3854 (1.3867) loss_fgl_dn_1: 0.7809 (0.7811) loss_ddf_dn_1: 0.0099 (0.0074) loss_vfl_dn_2: 0.3481 (0.3505) loss_bbox_dn_2: 0.0759 (0.0714) loss_giou_dn_2: 1.3852 (1.3867) loss_fgl_dn_2: 0.7808 (0.7811) loss_ddf_dn_2: 0.0015 (0.0018) loss_vfl_dn_3: 0.3491 (0.3523) loss_bbox_dn_3: 0.0759 (0.0715) loss_giou_dn_3: 1.3854 (1.3866) loss_fgl_dn_3: 0.7812 (0.7812) loss_ddf_dn_3: 0.0004 (0.0006) loss_vfl_dn_4: 0.3489 (0.3557) loss_bbox_dn_4: 0.0759 (0.0717) loss_giou_dn_4: 1.3854 (1.3866) loss_fgl_dn_4: 0.7815 (0.7813) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3552 (0.3614) loss_bbox_dn_5: 0.0757 (0.0717) loss_giou_dn_5: 1.3853 (1.3866) loss_fgl_dn_5: 0.7817 (0.7814) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3503 (0.3534) loss_bbox_dn_pre: 0.0755 (0.0697) loss_giou_dn_pre: 1.3860 (1.3867)\n", + "Test: [0/4] eta: 0:00:02 time: 0.6851 data: 0.4740 max mem: 28434\n", + "Test: [3/4] eta: 0:00:00 time: 0.3546 data: 0.1584 max mem: 28434\n", + "Test: Total time: 0:00:01 (0.3677 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.04s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.002\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.002\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.001\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.036\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.000\n", + "best_stat: {'epoch': 2, 'coco_eval_bbox': 0.0002828161935537151}\n", + "Epoch: [3] [ 0/84] eta: 0:02:30 lr: 0.000006 loss: 38.3657 (38.3657) loss_vfl: 0.1711 (0.1711) loss_bbox: 0.3639 (0.3639) loss_giou: 1.8109 (1.8109) loss_fgl: 0.2979 (0.2979) loss_vfl_aux_0: 0.1803 (0.1803) loss_bbox_aux_0: 0.3711 (0.3711) loss_giou_aux_0: 1.8115 (1.8115) loss_fgl_aux_0: 0.2945 (0.2945) loss_ddf_aux_0: 0.0956 (0.0956) loss_vfl_aux_1: 0.1781 (0.1781) loss_bbox_aux_1: 0.3680 (0.3680) loss_giou_aux_1: 1.8117 (1.8117) loss_fgl_aux_1: 0.2960 (0.2960) loss_ddf_aux_1: 0.0064 (0.0064) loss_vfl_aux_2: 0.1658 (0.1658) loss_bbox_aux_2: 0.3672 (0.3672) loss_giou_aux_2: 1.8114 (1.8114) loss_fgl_aux_2: 0.2963 (0.2963) loss_ddf_aux_2: 0.0018 (0.0018) loss_vfl_aux_3: 0.1675 (0.1675) loss_bbox_aux_3: 0.3659 (0.3659) loss_giou_aux_3: 1.8106 (1.8106) loss_fgl_aux_3: 0.2970 (0.2970) loss_ddf_aux_3: 0.0007 (0.0007) loss_vfl_aux_4: 0.1669 (0.1669) loss_bbox_aux_4: 0.3649 (0.3649) loss_giou_aux_4: 1.8103 (1.8103) loss_fgl_aux_4: 0.2975 (0.2975) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1793 (0.1793) loss_bbox_pre: 0.3659 (0.3659) loss_giou_pre: 1.8124 (1.8124) loss_vfl_enc_0: 0.1639 (0.1639) loss_bbox_enc_0: 0.3617 (0.3617) loss_giou_enc_0: 1.8155 (1.8155) loss_vfl_dn_0: 0.3533 (0.3533) loss_bbox_dn_0: 0.0819 (0.0819) loss_giou_dn_0: 1.3969 (1.3969) loss_fgl_dn_0: 0.7794 (0.7794) loss_ddf_dn_0: 0.1706 (0.1706) loss_vfl_dn_1: 0.3501 (0.3501) loss_bbox_dn_1: 0.0828 (0.0828) loss_giou_dn_1: 1.3961 (1.3961) loss_fgl_dn_1: 0.7802 (0.7802) loss_ddf_dn_1: 0.0111 (0.0111) loss_vfl_dn_2: 0.3501 (0.3501) loss_bbox_dn_2: 0.0828 (0.0828) loss_giou_dn_2: 1.3961 (1.3961) loss_fgl_dn_2: 0.7806 (0.7806) loss_ddf_dn_2: 0.0013 (0.0013) loss_vfl_dn_3: 0.3484 (0.3484) loss_bbox_dn_3: 0.0826 (0.0826) loss_giou_dn_3: 1.3952 (1.3952) loss_fgl_dn_3: 0.7815 (0.7815) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3545 (0.3545) loss_bbox_dn_4: 0.0822 (0.0822) loss_giou_dn_4: 1.3944 (1.3944) loss_fgl_dn_4: 0.7823 (0.7823) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3635 (0.3635) loss_bbox_dn_5: 0.0816 (0.0816) loss_giou_dn_5: 1.3944 (1.3944) loss_fgl_dn_5: 0.7824 (0.7824) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3503 (0.3503) loss_bbox_dn_pre: 0.0799 (0.0799) loss_giou_dn_pre: 1.3988 (1.3988) time: 1.7952 data: 1.0894 max mem: 28434\n", + "Epoch: [3] [83/84] eta: 0:00:00 lr: 0.000008 loss: 40.1163 (40.0748) loss_vfl: 0.0908 (0.1032) loss_bbox: 0.4504 (0.4565) loss_giou: 2.0940 (2.0913) loss_fgl: 0.2419 (0.2467) loss_vfl_aux_0: 0.0870 (0.1000) loss_bbox_aux_0: 0.4510 (0.4623) loss_giou_aux_0: 2.0920 (2.0874) loss_fgl_aux_0: 0.2402 (0.2450) loss_ddf_aux_0: 0.0090 (0.0213) loss_vfl_aux_1: 0.0880 (0.1007) loss_bbox_aux_1: 0.4463 (0.4577) loss_giou_aux_1: 2.0998 (2.0926) loss_fgl_aux_1: 0.2390 (0.2458) loss_ddf_aux_1: 0.0030 (0.0028) loss_vfl_aux_2: 0.0880 (0.1011) loss_bbox_aux_2: 0.4472 (0.4573) loss_giou_aux_2: 2.0993 (2.0923) loss_fgl_aux_2: 0.2397 (0.2461) loss_ddf_aux_2: 0.0018 (0.0016) loss_vfl_aux_3: 0.0891 (0.1019) loss_bbox_aux_3: 0.4478 (0.4567) loss_giou_aux_3: 2.0977 (2.0916) loss_fgl_aux_3: 0.2407 (0.2466) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.0889 (0.1021) loss_bbox_aux_4: 0.4493 (0.4564) loss_giou_aux_4: 2.0951 (2.0915) loss_fgl_aux_4: 0.2415 (0.2467) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0862 (0.1000) loss_bbox_pre: 0.4593 (0.4650) loss_giou_pre: 2.0726 (2.0792) loss_vfl_enc_0: 0.0894 (0.1004) loss_bbox_enc_0: 0.4619 (0.4632) loss_giou_enc_0: 2.0725 (2.0820) loss_vfl_dn_0: 0.3484 (0.3499) loss_bbox_dn_0: 0.0688 (0.0728) loss_giou_dn_0: 1.3879 (1.3875) loss_fgl_dn_0: 0.7797 (0.7797) loss_ddf_dn_0: 0.0075 (0.0264) loss_vfl_dn_1: 0.3433 (0.3467) loss_bbox_dn_1: 0.0690 (0.0734) loss_giou_dn_1: 1.3871 (1.3875) loss_fgl_dn_1: 0.7807 (0.7800) loss_ddf_dn_1: 0.0023 (0.0028) loss_vfl_dn_2: 0.3447 (0.3473) loss_bbox_dn_2: 0.0685 (0.0733) loss_giou_dn_2: 1.3862 (1.3869) loss_fgl_dn_2: 0.7816 (0.7805) loss_ddf_dn_2: 0.0014 (0.0013) loss_vfl_dn_3: 0.3472 (0.3493) loss_bbox_dn_3: 0.0681 (0.0730) loss_giou_dn_3: 1.3854 (1.3859) loss_fgl_dn_3: 0.7825 (0.7811) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3506 (0.3521) loss_bbox_dn_4: 0.0679 (0.0728) loss_giou_dn_4: 1.3844 (1.3851) loss_fgl_dn_4: 0.7826 (0.7815) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.3562 (0.3563) loss_bbox_dn_5: 0.0678 (0.0725) loss_giou_dn_5: 1.3840 (1.3848) loss_fgl_dn_5: 0.7829 (0.7817) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3459 (0.3483) loss_bbox_dn_pre: 0.0675 (0.0711) loss_giou_dn_pre: 1.3883 (1.3870) time: 0.8932 data: 0.0172 max mem: 28724\n", + "Epoch: [3] Total time: 0:01:17 (0.9187 s / it)\n", + "Averaged stats: lr: 0.000008 loss: 40.1163 (40.0748) loss_vfl: 0.0908 (0.1032) loss_bbox: 0.4504 (0.4565) loss_giou: 2.0940 (2.0913) loss_fgl: 0.2419 (0.2467) loss_vfl_aux_0: 0.0870 (0.1000) loss_bbox_aux_0: 0.4510 (0.4623) loss_giou_aux_0: 2.0920 (2.0874) loss_fgl_aux_0: 0.2402 (0.2450) loss_ddf_aux_0: 0.0090 (0.0213) loss_vfl_aux_1: 0.0880 (0.1007) loss_bbox_aux_1: 0.4463 (0.4577) loss_giou_aux_1: 2.0998 (2.0926) loss_fgl_aux_1: 0.2390 (0.2458) loss_ddf_aux_1: 0.0030 (0.0028) loss_vfl_aux_2: 0.0880 (0.1011) loss_bbox_aux_2: 0.4472 (0.4573) loss_giou_aux_2: 2.0993 (2.0923) loss_fgl_aux_2: 0.2397 (0.2461) loss_ddf_aux_2: 0.0018 (0.0016) loss_vfl_aux_3: 0.0891 (0.1019) loss_bbox_aux_3: 0.4478 (0.4567) loss_giou_aux_3: 2.0977 (2.0916) loss_fgl_aux_3: 0.2407 (0.2466) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.0889 (0.1021) loss_bbox_aux_4: 0.4493 (0.4564) loss_giou_aux_4: 2.0951 (2.0915) loss_fgl_aux_4: 0.2415 (0.2467) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0862 (0.1000) loss_bbox_pre: 0.4593 (0.4650) loss_giou_pre: 2.0726 (2.0792) loss_vfl_enc_0: 0.0894 (0.1004) loss_bbox_enc_0: 0.4619 (0.4632) loss_giou_enc_0: 2.0725 (2.0820) loss_vfl_dn_0: 0.3484 (0.3499) loss_bbox_dn_0: 0.0688 (0.0728) loss_giou_dn_0: 1.3879 (1.3875) loss_fgl_dn_0: 0.7797 (0.7797) loss_ddf_dn_0: 0.0075 (0.0264) loss_vfl_dn_1: 0.3433 (0.3467) loss_bbox_dn_1: 0.0690 (0.0734) loss_giou_dn_1: 1.3871 (1.3875) loss_fgl_dn_1: 0.7807 (0.7800) loss_ddf_dn_1: 0.0023 (0.0028) loss_vfl_dn_2: 0.3447 (0.3473) loss_bbox_dn_2: 0.0685 (0.0733) loss_giou_dn_2: 1.3862 (1.3869) loss_fgl_dn_2: 0.7816 (0.7805) loss_ddf_dn_2: 0.0014 (0.0013) loss_vfl_dn_3: 0.3472 (0.3493) loss_bbox_dn_3: 0.0681 (0.0730) loss_giou_dn_3: 1.3854 (1.3859) loss_fgl_dn_3: 0.7825 (0.7811) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3506 (0.3521) loss_bbox_dn_4: 0.0679 (0.0728) loss_giou_dn_4: 1.3844 (1.3851) loss_fgl_dn_4: 0.7826 (0.7815) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.3562 (0.3563) loss_bbox_dn_5: 0.0678 (0.0725) loss_giou_dn_5: 1.3840 (1.3848) loss_fgl_dn_5: 0.7829 (0.7817) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3459 (0.3483) loss_bbox_dn_pre: 0.0675 (0.0711) loss_giou_dn_pre: 1.3883 (1.3870)\n", + "Test: [0/4] eta: 0:00:02 time: 0.6992 data: 0.4786 max mem: 28724\n", + "Test: [3/4] eta: 0:00:00 time: 0.3739 data: 0.1567 max mem: 28724\n", + "Test: Total time: 0:00:01 (0.3877 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.04s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.003\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.001\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.004\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.003\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.011\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.013\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.001\n", + "best_stat: {'epoch': 3, 'coco_eval_bbox': 0.0014412864607787567}\n", + "Epoch: [4] [ 0/84] eta: 0:03:01 lr: 0.000008 loss: 38.8551 (38.8551) loss_vfl: 0.0535 (0.0535) loss_bbox: 0.4100 (0.4100) loss_giou: 2.1093 (2.1093) loss_fgl: 0.1807 (0.1807) loss_vfl_aux_0: 0.0574 (0.0574) loss_bbox_aux_0: 0.4093 (0.4093) loss_giou_aux_0: 2.1123 (2.1123) loss_fgl_aux_0: 0.1814 (0.1814) loss_ddf_aux_0: 0.0053 (0.0053) loss_vfl_aux_1: 0.0579 (0.0579) loss_bbox_aux_1: 0.4047 (0.4047) loss_giou_aux_1: 2.1159 (2.1159) loss_fgl_aux_1: 0.1826 (0.1826) loss_ddf_aux_1: 0.0037 (0.0037) loss_vfl_aux_2: 0.0563 (0.0563) loss_bbox_aux_2: 0.4051 (0.4051) loss_giou_aux_2: 2.1139 (2.1139) loss_fgl_aux_2: 0.1826 (0.1826) loss_ddf_aux_2: 0.0022 (0.0022) loss_vfl_aux_3: 0.0559 (0.0559) loss_bbox_aux_3: 0.4072 (0.4072) loss_giou_aux_3: 2.1112 (2.1112) loss_fgl_aux_3: 0.1818 (0.1818) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.0548 (0.0548) loss_bbox_aux_4: 0.4088 (0.4088) loss_giou_aux_4: 2.1102 (2.1102) loss_fgl_aux_4: 0.1812 (0.1812) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0570 (0.0570) loss_bbox_pre: 0.4089 (0.4089) loss_giou_pre: 2.1119 (2.1119) loss_vfl_enc_0: 0.0528 (0.0528) loss_bbox_enc_0: 0.4091 (0.4091) loss_giou_enc_0: 2.1120 (2.1120) loss_vfl_dn_0: 0.3416 (0.3416) loss_bbox_dn_0: 0.0504 (0.0504) loss_giou_dn_0: 1.4073 (1.4073) loss_fgl_dn_0: 0.7653 (0.7653) loss_ddf_dn_0: 0.0071 (0.0071) loss_vfl_dn_1: 0.3347 (0.3347) loss_bbox_dn_1: 0.0508 (0.0508) loss_giou_dn_1: 1.4069 (1.4069) loss_fgl_dn_1: 0.7659 (0.7659) loss_ddf_dn_1: 0.0028 (0.0028) loss_vfl_dn_2: 0.3301 (0.3301) loss_bbox_dn_2: 0.0506 (0.0506) loss_giou_dn_2: 1.4063 (1.4063) loss_fgl_dn_2: 0.7663 (0.7663) loss_ddf_dn_2: 0.0018 (0.0018) loss_vfl_dn_3: 0.3306 (0.3306) loss_bbox_dn_3: 0.0506 (0.0506) loss_giou_dn_3: 1.4060 (1.4060) loss_fgl_dn_3: 0.7665 (0.7665) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3320 (0.3320) loss_bbox_dn_4: 0.0506 (0.0506) loss_giou_dn_4: 1.4052 (1.4052) loss_fgl_dn_4: 0.7669 (0.7669) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3330 (0.3330) loss_bbox_dn_5: 0.0507 (0.0507) loss_giou_dn_5: 1.4049 (1.4049) loss_fgl_dn_5: 0.7671 (0.7671) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3384 (0.3384) loss_bbox_dn_pre: 0.0486 (0.0486) loss_giou_dn_pre: 1.4079 (1.4079) time: 2.1649 data: 0.9466 max mem: 28724\n", + "Epoch: [4] [83/84] eta: 0:00:00 lr: 0.000011 loss: 40.7012 (40.1741) loss_vfl: 0.1099 (0.1098) loss_bbox: 0.5113 (0.4661) loss_giou: 2.1408 (2.0787) loss_fgl: 0.2503 (0.2572) loss_vfl_aux_0: 0.0935 (0.1029) loss_bbox_aux_0: 0.5205 (0.4708) loss_giou_aux_0: 2.1431 (2.0833) loss_fgl_aux_0: 0.2459 (0.2535) loss_ddf_aux_0: 0.0283 (0.0158) loss_vfl_aux_1: 0.0949 (0.1029) loss_bbox_aux_1: 0.5170 (0.4670) loss_giou_aux_1: 2.1419 (2.0859) loss_fgl_aux_1: 0.2476 (0.2546) loss_ddf_aux_1: 0.0234 (0.0113) loss_vfl_aux_2: 0.0999 (0.1049) loss_bbox_aux_2: 0.5138 (0.4666) loss_giou_aux_2: 2.1356 (2.0809) loss_fgl_aux_2: 0.2501 (0.2564) loss_ddf_aux_2: 0.0091 (0.0049) loss_vfl_aux_3: 0.1034 (0.1073) loss_bbox_aux_3: 0.5123 (0.4657) loss_giou_aux_3: 2.1377 (2.0799) loss_fgl_aux_3: 0.2512 (0.2572) loss_ddf_aux_3: 0.0032 (0.0014) loss_vfl_aux_4: 0.1055 (0.1087) loss_bbox_aux_4: 0.5116 (0.4658) loss_giou_aux_4: 2.1398 (2.0792) loss_fgl_aux_4: 0.2505 (0.2573) loss_ddf_aux_4: 0.0004 (0.0002) loss_vfl_pre: 0.0922 (0.1017) loss_bbox_pre: 0.5301 (0.4779) loss_giou_pre: 2.1346 (2.0758) loss_vfl_enc_0: 0.0934 (0.1027) loss_bbox_enc_0: 0.5316 (0.4777) loss_giou_enc_0: 2.1450 (2.0786) loss_vfl_dn_0: 0.3464 (0.3485) loss_bbox_dn_0: 0.0661 (0.0733) loss_giou_dn_0: 1.3874 (1.3856) loss_fgl_dn_0: 0.7795 (0.7821) loss_ddf_dn_0: 0.0169 (0.0120) loss_vfl_dn_1: 0.3472 (0.3458) loss_bbox_dn_1: 0.0659 (0.0733) loss_giou_dn_1: 1.3843 (1.3844) loss_fgl_dn_1: 0.7813 (0.7831) loss_ddf_dn_1: 0.0137 (0.0085) loss_vfl_dn_2: 0.3486 (0.3492) loss_bbox_dn_2: 0.0645 (0.0724) loss_giou_dn_2: 1.3744 (1.3795) loss_fgl_dn_2: 0.7866 (0.7855) loss_ddf_dn_2: 0.0056 (0.0040) loss_vfl_dn_3: 0.3506 (0.3532) loss_bbox_dn_3: 0.0640 (0.0717) loss_giou_dn_3: 1.3710 (1.3760) loss_fgl_dn_3: 0.7868 (0.7872) loss_ddf_dn_3: 0.0017 (0.0013) loss_vfl_dn_4: 0.3547 (0.3557) loss_bbox_dn_4: 0.0642 (0.0715) loss_giou_dn_4: 1.3706 (1.3746) loss_fgl_dn_4: 0.7877 (0.7879) loss_ddf_dn_4: 0.0003 (0.0002) loss_vfl_dn_5: 0.3601 (0.3595) loss_bbox_dn_5: 0.0644 (0.0715) loss_giou_dn_5: 1.3716 (1.3743) loss_fgl_dn_5: 0.7875 (0.7882) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3457 (0.3466) loss_bbox_dn_pre: 0.0636 (0.0715) loss_giou_dn_pre: 1.3865 (1.3857) time: 0.9185 data: 0.0169 max mem: 29062\n", + "Epoch: [4] Total time: 0:01:17 (0.9197 s / it)\n", + "Averaged stats: lr: 0.000011 loss: 40.7012 (40.1741) loss_vfl: 0.1099 (0.1098) loss_bbox: 0.5113 (0.4661) loss_giou: 2.1408 (2.0787) loss_fgl: 0.2503 (0.2572) loss_vfl_aux_0: 0.0935 (0.1029) loss_bbox_aux_0: 0.5205 (0.4708) loss_giou_aux_0: 2.1431 (2.0833) loss_fgl_aux_0: 0.2459 (0.2535) loss_ddf_aux_0: 0.0283 (0.0158) loss_vfl_aux_1: 0.0949 (0.1029) loss_bbox_aux_1: 0.5170 (0.4670) loss_giou_aux_1: 2.1419 (2.0859) loss_fgl_aux_1: 0.2476 (0.2546) loss_ddf_aux_1: 0.0234 (0.0113) loss_vfl_aux_2: 0.0999 (0.1049) loss_bbox_aux_2: 0.5138 (0.4666) loss_giou_aux_2: 2.1356 (2.0809) loss_fgl_aux_2: 0.2501 (0.2564) loss_ddf_aux_2: 0.0091 (0.0049) loss_vfl_aux_3: 0.1034 (0.1073) loss_bbox_aux_3: 0.5123 (0.4657) loss_giou_aux_3: 2.1377 (2.0799) loss_fgl_aux_3: 0.2512 (0.2572) loss_ddf_aux_3: 0.0032 (0.0014) loss_vfl_aux_4: 0.1055 (0.1087) loss_bbox_aux_4: 0.5116 (0.4658) loss_giou_aux_4: 2.1398 (2.0792) loss_fgl_aux_4: 0.2505 (0.2573) loss_ddf_aux_4: 0.0004 (0.0002) loss_vfl_pre: 0.0922 (0.1017) loss_bbox_pre: 0.5301 (0.4779) loss_giou_pre: 2.1346 (2.0758) loss_vfl_enc_0: 0.0934 (0.1027) loss_bbox_enc_0: 0.5316 (0.4777) loss_giou_enc_0: 2.1450 (2.0786) loss_vfl_dn_0: 0.3464 (0.3485) loss_bbox_dn_0: 0.0661 (0.0733) loss_giou_dn_0: 1.3874 (1.3856) loss_fgl_dn_0: 0.7795 (0.7821) loss_ddf_dn_0: 0.0169 (0.0120) loss_vfl_dn_1: 0.3472 (0.3458) loss_bbox_dn_1: 0.0659 (0.0733) loss_giou_dn_1: 1.3843 (1.3844) loss_fgl_dn_1: 0.7813 (0.7831) loss_ddf_dn_1: 0.0137 (0.0085) loss_vfl_dn_2: 0.3486 (0.3492) loss_bbox_dn_2: 0.0645 (0.0724) loss_giou_dn_2: 1.3744 (1.3795) loss_fgl_dn_2: 0.7866 (0.7855) loss_ddf_dn_2: 0.0056 (0.0040) loss_vfl_dn_3: 0.3506 (0.3532) loss_bbox_dn_3: 0.0640 (0.0717) loss_giou_dn_3: 1.3710 (1.3760) loss_fgl_dn_3: 0.7868 (0.7872) loss_ddf_dn_3: 0.0017 (0.0013) loss_vfl_dn_4: 0.3547 (0.3557) loss_bbox_dn_4: 0.0642 (0.0715) loss_giou_dn_4: 1.3706 (1.3746) loss_fgl_dn_4: 0.7877 (0.7879) loss_ddf_dn_4: 0.0003 (0.0002) loss_vfl_dn_5: 0.3601 (0.3595) loss_bbox_dn_5: 0.0644 (0.0715) loss_giou_dn_5: 1.3716 (1.3743) loss_fgl_dn_5: 0.7875 (0.7882) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3457 (0.3466) loss_bbox_dn_pre: 0.0636 (0.0715) loss_giou_dn_pre: 1.3865 (1.3857)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7274 data: 0.4836 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.3944 data: 0.1610 max mem: 29062\n", + "Test: Total time: 0:00:01 (0.4084 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.001\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.003\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.018\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.002\n", + "best_stat: {'epoch': 4, 'coco_eval_bbox': 0.0014631443945622975}\n", + "Epoch: [5] [ 0/84] eta: 0:02:14 lr: 0.000011 loss: 39.8672 (39.8672) loss_vfl: 0.1268 (0.1268) loss_bbox: 0.3851 (0.3851) loss_giou: 2.0757 (2.0757) loss_fgl: 0.2979 (0.2979) loss_vfl_aux_0: 0.1227 (0.1227) loss_bbox_aux_0: 0.3900 (0.3900) loss_giou_aux_0: 2.0792 (2.0792) loss_fgl_aux_0: 0.2901 (0.2901) loss_ddf_aux_0: 0.0153 (0.0153) loss_vfl_aux_1: 0.1218 (0.1218) loss_bbox_aux_1: 0.3863 (0.3863) loss_giou_aux_1: 2.0807 (2.0807) loss_fgl_aux_1: 0.2934 (0.2934) loss_ddf_aux_1: 0.0090 (0.0090) loss_vfl_aux_2: 0.1238 (0.1238) loss_bbox_aux_2: 0.3857 (0.3857) loss_giou_aux_2: 2.0746 (2.0746) loss_fgl_aux_2: 0.2965 (0.2965) loss_ddf_aux_2: 0.0030 (0.0030) loss_vfl_aux_3: 0.1245 (0.1245) loss_bbox_aux_3: 0.3847 (0.3847) loss_giou_aux_3: 2.0754 (2.0754) loss_fgl_aux_3: 0.2980 (0.2980) loss_ddf_aux_3: 0.0006 (0.0006) loss_vfl_aux_4: 0.1240 (0.1240) loss_bbox_aux_4: 0.3849 (0.3849) loss_giou_aux_4: 2.0761 (2.0761) loss_fgl_aux_4: 0.2979 (0.2979) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1191 (0.1191) loss_bbox_pre: 0.3961 (0.3961) loss_giou_pre: 2.0749 (2.0749) loss_vfl_enc_0: 0.1159 (0.1159) loss_bbox_enc_0: 0.3988 (0.3988) loss_giou_enc_0: 2.0769 (2.0769) loss_vfl_dn_0: 0.3450 (0.3450) loss_bbox_dn_0: 0.0835 (0.0835) loss_giou_dn_0: 1.3787 (1.3787) loss_fgl_dn_0: 0.7882 (0.7882) loss_ddf_dn_0: 0.0110 (0.0110) loss_vfl_dn_1: 0.3428 (0.3428) loss_bbox_dn_1: 0.0830 (0.0830) loss_giou_dn_1: 1.3748 (1.3748) loss_fgl_dn_1: 0.7897 (0.7897) loss_ddf_dn_1: 0.0077 (0.0077) loss_vfl_dn_2: 0.3445 (0.3445) loss_bbox_dn_2: 0.0812 (0.0812) loss_giou_dn_2: 1.3670 (1.3670) loss_fgl_dn_2: 0.7924 (0.7924) loss_ddf_dn_2: 0.0024 (0.0024) loss_vfl_dn_3: 0.3486 (0.3486) loss_bbox_dn_3: 0.0802 (0.0802) loss_giou_dn_3: 1.3638 (1.3638) loss_fgl_dn_3: 0.7935 (0.7935) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.3503 (0.3503) loss_bbox_dn_4: 0.0798 (0.0798) loss_giou_dn_4: 1.3622 (1.3622) loss_fgl_dn_4: 0.7940 (0.7940) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.3574 (0.3574) loss_bbox_dn_5: 0.0798 (0.0798) loss_giou_dn_5: 1.3617 (1.3617) loss_fgl_dn_5: 0.7941 (0.7941) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3430 (0.3430) loss_bbox_dn_pre: 0.0811 (0.0811) loss_giou_dn_pre: 1.3794 (1.3794) time: 1.6051 data: 0.8375 max mem: 29062\n", + "Epoch: [5] [83/84] eta: 0:00:00 lr: 0.000013 loss: 40.0608 (40.3957) loss_vfl: 0.1069 (0.1111) loss_bbox: 0.4879 (0.4759) loss_giou: 2.0982 (2.0915) loss_fgl: 0.2462 (0.2551) loss_vfl_aux_0: 0.0967 (0.0994) loss_bbox_aux_0: 0.4920 (0.4821) loss_giou_aux_0: 2.1093 (2.1059) loss_fgl_aux_0: 0.2425 (0.2479) loss_ddf_aux_0: 0.0617 (0.0400) loss_vfl_aux_1: 0.0986 (0.1020) loss_bbox_aux_1: 0.4876 (0.4783) loss_giou_aux_1: 2.1008 (2.1009) loss_fgl_aux_1: 0.2415 (0.2511) loss_ddf_aux_1: 0.0379 (0.0248) loss_vfl_aux_2: 0.1055 (0.1080) loss_bbox_aux_2: 0.4892 (0.4763) loss_giou_aux_2: 2.0987 (2.0929) loss_fgl_aux_2: 0.2433 (0.2542) loss_ddf_aux_2: 0.0076 (0.0062) loss_vfl_aux_3: 0.1068 (0.1099) loss_bbox_aux_3: 0.4896 (0.4759) loss_giou_aux_3: 2.0985 (2.0916) loss_fgl_aux_3: 0.2455 (0.2549) loss_ddf_aux_3: 0.0018 (0.0011) loss_vfl_aux_4: 0.1089 (0.1111) loss_bbox_aux_4: 0.4907 (0.4761) loss_giou_aux_4: 2.0981 (2.0912) loss_fgl_aux_4: 0.2461 (0.2550) loss_ddf_aux_4: 0.0002 (0.0001) loss_vfl_pre: 0.0942 (0.0970) loss_bbox_pre: 0.4991 (0.4907) loss_giou_pre: 2.1102 (2.0964) loss_vfl_enc_0: 0.0890 (0.0951) loss_bbox_enc_0: 0.5152 (0.4959) loss_giou_enc_0: 2.1142 (2.1025) loss_vfl_dn_0: 0.3455 (0.3460) loss_bbox_dn_0: 0.0694 (0.0721) loss_giou_dn_0: 1.3780 (1.3865) loss_fgl_dn_0: 0.7851 (0.7814) loss_ddf_dn_0: 0.0323 (0.0226) loss_vfl_dn_1: 0.3499 (0.3464) loss_bbox_dn_1: 0.0663 (0.0709) loss_giou_dn_1: 1.3691 (1.3813) loss_fgl_dn_1: 0.7901 (0.7835) loss_ddf_dn_1: 0.0209 (0.0151) loss_vfl_dn_2: 0.3562 (0.3510) loss_bbox_dn_2: 0.0640 (0.0696) loss_giou_dn_2: 1.3600 (1.3739) loss_fgl_dn_2: 0.7947 (0.7867) loss_ddf_dn_2: 0.0061 (0.0050) loss_vfl_dn_3: 0.3560 (0.3538) loss_bbox_dn_3: 0.0635 (0.0692) loss_giou_dn_3: 1.3561 (1.3711) loss_fgl_dn_3: 0.7962 (0.7880) loss_ddf_dn_3: 0.0016 (0.0011) loss_vfl_dn_4: 0.3574 (0.3558) loss_bbox_dn_4: 0.0635 (0.0692) loss_giou_dn_4: 1.3550 (1.3702) loss_fgl_dn_4: 0.7964 (0.7887) loss_ddf_dn_4: 0.0003 (0.0002) loss_vfl_dn_5: 0.3594 (0.3594) loss_bbox_dn_5: 0.0630 (0.0692) loss_giou_dn_5: 1.3557 (1.3701) loss_fgl_dn_5: 0.7961 (0.7888) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3438 (0.3444) loss_bbox_dn_pre: 0.0687 (0.0701) loss_giou_dn_pre: 1.3789 (1.3866) time: 0.9119 data: 0.0166 max mem: 29062\n", + "Epoch: [5] Total time: 0:01:17 (0.9250 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 40.0608 (40.3957) loss_vfl: 0.1069 (0.1111) loss_bbox: 0.4879 (0.4759) loss_giou: 2.0982 (2.0915) loss_fgl: 0.2462 (0.2551) loss_vfl_aux_0: 0.0967 (0.0994) loss_bbox_aux_0: 0.4920 (0.4821) loss_giou_aux_0: 2.1093 (2.1059) loss_fgl_aux_0: 0.2425 (0.2479) loss_ddf_aux_0: 0.0617 (0.0400) loss_vfl_aux_1: 0.0986 (0.1020) loss_bbox_aux_1: 0.4876 (0.4783) loss_giou_aux_1: 2.1008 (2.1009) loss_fgl_aux_1: 0.2415 (0.2511) loss_ddf_aux_1: 0.0379 (0.0248) loss_vfl_aux_2: 0.1055 (0.1080) loss_bbox_aux_2: 0.4892 (0.4763) loss_giou_aux_2: 2.0987 (2.0929) loss_fgl_aux_2: 0.2433 (0.2542) loss_ddf_aux_2: 0.0076 (0.0062) loss_vfl_aux_3: 0.1068 (0.1099) loss_bbox_aux_3: 0.4896 (0.4759) loss_giou_aux_3: 2.0985 (2.0916) loss_fgl_aux_3: 0.2455 (0.2549) loss_ddf_aux_3: 0.0018 (0.0011) loss_vfl_aux_4: 0.1089 (0.1111) loss_bbox_aux_4: 0.4907 (0.4761) loss_giou_aux_4: 2.0981 (2.0912) loss_fgl_aux_4: 0.2461 (0.2550) loss_ddf_aux_4: 0.0002 (0.0001) loss_vfl_pre: 0.0942 (0.0970) loss_bbox_pre: 0.4991 (0.4907) loss_giou_pre: 2.1102 (2.0964) loss_vfl_enc_0: 0.0890 (0.0951) loss_bbox_enc_0: 0.5152 (0.4959) loss_giou_enc_0: 2.1142 (2.1025) loss_vfl_dn_0: 0.3455 (0.3460) loss_bbox_dn_0: 0.0694 (0.0721) loss_giou_dn_0: 1.3780 (1.3865) loss_fgl_dn_0: 0.7851 (0.7814) loss_ddf_dn_0: 0.0323 (0.0226) loss_vfl_dn_1: 0.3499 (0.3464) loss_bbox_dn_1: 0.0663 (0.0709) loss_giou_dn_1: 1.3691 (1.3813) loss_fgl_dn_1: 0.7901 (0.7835) loss_ddf_dn_1: 0.0209 (0.0151) loss_vfl_dn_2: 0.3562 (0.3510) loss_bbox_dn_2: 0.0640 (0.0696) loss_giou_dn_2: 1.3600 (1.3739) loss_fgl_dn_2: 0.7947 (0.7867) loss_ddf_dn_2: 0.0061 (0.0050) loss_vfl_dn_3: 0.3560 (0.3538) loss_bbox_dn_3: 0.0635 (0.0692) loss_giou_dn_3: 1.3561 (1.3711) loss_fgl_dn_3: 0.7962 (0.7880) loss_ddf_dn_3: 0.0016 (0.0011) loss_vfl_dn_4: 0.3574 (0.3558) loss_bbox_dn_4: 0.0635 (0.0692) loss_giou_dn_4: 1.3550 (1.3702) loss_fgl_dn_4: 0.7964 (0.7887) loss_ddf_dn_4: 0.0003 (0.0002) loss_vfl_dn_5: 0.3594 (0.3594) loss_bbox_dn_5: 0.0630 (0.0692) loss_giou_dn_5: 1.3557 (1.3701) loss_fgl_dn_5: 0.7961 (0.7888) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3438 (0.3444) loss_bbox_dn_pre: 0.0687 (0.0701) loss_giou_dn_pre: 1.3789 (1.3866)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7346 data: 0.4924 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.3991 data: 0.1673 max mem: 29062\n", + "Test: Total time: 0:00:01 (0.4141 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.003\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.003\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.009\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.003\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.013\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.018\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.012\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.051\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.007\n", + "best_stat: {'epoch': 5, 'coco_eval_bbox': 0.0028719066435348864}\n", + "Epoch: [6] [ 0/84] eta: 0:02:48 lr: 0.000013 loss: 40.0193 (40.0193) loss_vfl: 0.1401 (0.1401) loss_bbox: 0.3735 (0.3735) loss_giou: 2.0502 (2.0502) loss_fgl: 0.2833 (0.2833) loss_vfl_aux_0: 0.1237 (0.1237) loss_bbox_aux_0: 0.3762 (0.3762) loss_giou_aux_0: 2.0785 (2.0785) loss_fgl_aux_0: 0.2703 (0.2703) loss_ddf_aux_0: 0.1286 (0.1286) loss_vfl_aux_1: 0.1320 (0.1320) loss_bbox_aux_1: 0.3722 (0.3722) loss_giou_aux_1: 2.0740 (2.0740) loss_fgl_aux_1: 0.2733 (0.2733) loss_ddf_aux_1: 0.1021 (0.1021) loss_vfl_aux_2: 0.1376 (0.1376) loss_bbox_aux_2: 0.3709 (0.3709) loss_giou_aux_2: 2.0641 (2.0641) loss_fgl_aux_2: 0.2779 (0.2779) loss_ddf_aux_2: 0.0421 (0.0421) loss_vfl_aux_3: 0.1426 (0.1426) loss_bbox_aux_3: 0.3717 (0.3717) loss_giou_aux_3: 2.0568 (2.0568) loss_fgl_aux_3: 0.2808 (0.2808) loss_ddf_aux_3: 0.0080 (0.0080) loss_vfl_aux_4: 0.1392 (0.1392) loss_bbox_aux_4: 0.3736 (0.3736) loss_giou_aux_4: 2.0511 (2.0511) loss_fgl_aux_4: 0.2828 (0.2828) loss_ddf_aux_4: 0.0004 (0.0004) loss_vfl_pre: 0.1227 (0.1227) loss_bbox_pre: 0.3842 (0.3842) loss_giou_pre: 2.0632 (2.0632) loss_vfl_enc_0: 0.1212 (0.1212) loss_bbox_enc_0: 0.3900 (0.3900) loss_giou_enc_0: 2.0742 (2.0742) loss_vfl_dn_0: 0.3513 (0.3513) loss_bbox_dn_0: 0.0683 (0.0683) loss_giou_dn_0: 1.3712 (1.3712) loss_fgl_dn_0: 0.7950 (0.7950) loss_ddf_dn_0: 0.0689 (0.0689) loss_vfl_dn_1: 0.3555 (0.3555) loss_bbox_dn_1: 0.0664 (0.0664) loss_giou_dn_1: 1.3602 (1.3602) loss_fgl_dn_1: 0.7996 (0.7996) loss_ddf_dn_1: 0.0559 (0.0559) loss_vfl_dn_2: 0.3657 (0.3657) loss_bbox_dn_2: 0.0643 (0.0643) loss_giou_dn_2: 1.3481 (1.3481) loss_fgl_dn_2: 0.8064 (0.8064) loss_ddf_dn_2: 0.0241 (0.0241) loss_vfl_dn_3: 0.3755 (0.3755) loss_bbox_dn_3: 0.0645 (0.0645) loss_giou_dn_3: 1.3485 (1.3485) loss_fgl_dn_3: 0.8078 (0.8078) loss_ddf_dn_3: 0.0048 (0.0048) loss_vfl_dn_4: 0.3689 (0.3689) loss_bbox_dn_4: 0.0661 (0.0661) loss_giou_dn_4: 1.3523 (1.3523) loss_fgl_dn_4: 0.8075 (0.8075) loss_ddf_dn_4: 0.0004 (0.0004) loss_vfl_dn_5: 0.3735 (0.3735) loss_bbox_dn_5: 0.0662 (0.0662) loss_giou_dn_5: 1.3526 (1.3526) loss_fgl_dn_5: 0.8077 (0.8077) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3496 (0.3496) loss_bbox_dn_pre: 0.0666 (0.0666) loss_giou_dn_pre: 1.3729 (1.3729) time: 2.0015 data: 1.0377 max mem: 29062\n", + "Epoch: [6] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.8314 (40.3415) loss_vfl: 0.1302 (0.1299) loss_bbox: 0.3896 (0.4708) loss_giou: 2.0005 (2.0358) loss_fgl: 0.3285 (0.2933) loss_vfl_aux_0: 0.1204 (0.1198) loss_bbox_aux_0: 0.3941 (0.4726) loss_giou_aux_0: 2.0083 (2.0460) loss_fgl_aux_0: 0.3228 (0.2872) loss_ddf_aux_0: 0.0677 (0.0795) loss_vfl_aux_1: 0.1249 (0.1239) loss_bbox_aux_1: 0.3936 (0.4710) loss_giou_aux_1: 2.0025 (2.0394) loss_fgl_aux_1: 0.3263 (0.2902) loss_ddf_aux_1: 0.0236 (0.0349) loss_vfl_aux_2: 0.1321 (0.1290) loss_bbox_aux_2: 0.3912 (0.4701) loss_giou_aux_2: 2.0000 (2.0365) loss_fgl_aux_2: 0.3278 (0.2923) loss_ddf_aux_2: 0.0039 (0.0076) loss_vfl_aux_3: 0.1313 (0.1293) loss_bbox_aux_3: 0.3912 (0.4705) loss_giou_aux_3: 1.9999 (2.0358) loss_fgl_aux_3: 0.3282 (0.2929) loss_ddf_aux_3: 0.0010 (0.0017) loss_vfl_aux_4: 0.1313 (0.1298) loss_bbox_aux_4: 0.3910 (0.4707) loss_giou_aux_4: 1.9999 (2.0357) loss_fgl_aux_4: 0.3284 (0.2932) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1195 (0.1175) loss_bbox_pre: 0.4022 (0.4785) loss_giou_pre: 2.0007 (2.0392) loss_vfl_enc_0: 0.1069 (0.1077) loss_bbox_enc_0: 0.4278 (0.4921) loss_giou_enc_0: 2.0447 (2.0702) loss_vfl_dn_0: 0.3489 (0.3474) loss_bbox_dn_0: 0.0651 (0.0711) loss_giou_dn_0: 1.3687 (1.3771) loss_fgl_dn_0: 0.7912 (0.7876) loss_ddf_dn_0: 0.0383 (0.0352) loss_vfl_dn_1: 0.3560 (0.3545) loss_bbox_dn_1: 0.0634 (0.0690) loss_giou_dn_1: 1.3539 (1.3646) loss_fgl_dn_1: 0.7982 (0.7929) loss_ddf_dn_1: 0.0134 (0.0174) loss_vfl_dn_2: 0.3596 (0.3581) loss_bbox_dn_2: 0.0620 (0.0677) loss_giou_dn_2: 1.3490 (1.3579) loss_fgl_dn_2: 0.8007 (0.7960) loss_ddf_dn_2: 0.0028 (0.0046) loss_vfl_dn_3: 0.3611 (0.3600) loss_bbox_dn_3: 0.0618 (0.0676) loss_giou_dn_3: 1.3480 (1.3567) loss_fgl_dn_3: 0.8009 (0.7968) loss_ddf_dn_3: 0.0008 (0.0012) loss_vfl_dn_4: 0.3611 (0.3618) loss_bbox_dn_4: 0.0617 (0.0675) loss_giou_dn_4: 1.3471 (1.3562) loss_fgl_dn_4: 0.8011 (0.7974) loss_ddf_dn_4: 0.0003 (0.0003) loss_vfl_dn_5: 0.3616 (0.3653) loss_bbox_dn_5: 0.0617 (0.0674) loss_giou_dn_5: 1.3469 (1.3563) loss_fgl_dn_5: 0.8012 (0.7974) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3452 (0.3445) loss_bbox_dn_pre: 0.0640 (0.0694) loss_giou_dn_pre: 1.3723 (1.3797) time: 0.9055 data: 0.0170 max mem: 29062\n", + "Epoch: [6] Total time: 0:01:18 (0.9300 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.8314 (40.3415) loss_vfl: 0.1302 (0.1299) loss_bbox: 0.3896 (0.4708) loss_giou: 2.0005 (2.0358) loss_fgl: 0.3285 (0.2933) loss_vfl_aux_0: 0.1204 (0.1198) loss_bbox_aux_0: 0.3941 (0.4726) loss_giou_aux_0: 2.0083 (2.0460) loss_fgl_aux_0: 0.3228 (0.2872) loss_ddf_aux_0: 0.0677 (0.0795) loss_vfl_aux_1: 0.1249 (0.1239) loss_bbox_aux_1: 0.3936 (0.4710) loss_giou_aux_1: 2.0025 (2.0394) loss_fgl_aux_1: 0.3263 (0.2902) loss_ddf_aux_1: 0.0236 (0.0349) loss_vfl_aux_2: 0.1321 (0.1290) loss_bbox_aux_2: 0.3912 (0.4701) loss_giou_aux_2: 2.0000 (2.0365) loss_fgl_aux_2: 0.3278 (0.2923) loss_ddf_aux_2: 0.0039 (0.0076) loss_vfl_aux_3: 0.1313 (0.1293) loss_bbox_aux_3: 0.3912 (0.4705) loss_giou_aux_3: 1.9999 (2.0358) loss_fgl_aux_3: 0.3282 (0.2929) loss_ddf_aux_3: 0.0010 (0.0017) loss_vfl_aux_4: 0.1313 (0.1298) loss_bbox_aux_4: 0.3910 (0.4707) loss_giou_aux_4: 1.9999 (2.0357) loss_fgl_aux_4: 0.3284 (0.2932) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1195 (0.1175) loss_bbox_pre: 0.4022 (0.4785) loss_giou_pre: 2.0007 (2.0392) loss_vfl_enc_0: 0.1069 (0.1077) loss_bbox_enc_0: 0.4278 (0.4921) loss_giou_enc_0: 2.0447 (2.0702) loss_vfl_dn_0: 0.3489 (0.3474) loss_bbox_dn_0: 0.0651 (0.0711) loss_giou_dn_0: 1.3687 (1.3771) loss_fgl_dn_0: 0.7912 (0.7876) loss_ddf_dn_0: 0.0383 (0.0352) loss_vfl_dn_1: 0.3560 (0.3545) loss_bbox_dn_1: 0.0634 (0.0690) loss_giou_dn_1: 1.3539 (1.3646) loss_fgl_dn_1: 0.7982 (0.7929) loss_ddf_dn_1: 0.0134 (0.0174) loss_vfl_dn_2: 0.3596 (0.3581) loss_bbox_dn_2: 0.0620 (0.0677) loss_giou_dn_2: 1.3490 (1.3579) loss_fgl_dn_2: 0.8007 (0.7960) loss_ddf_dn_2: 0.0028 (0.0046) loss_vfl_dn_3: 0.3611 (0.3600) loss_bbox_dn_3: 0.0618 (0.0676) loss_giou_dn_3: 1.3480 (1.3567) loss_fgl_dn_3: 0.8009 (0.7968) loss_ddf_dn_3: 0.0008 (0.0012) loss_vfl_dn_4: 0.3611 (0.3618) loss_bbox_dn_4: 0.0617 (0.0675) loss_giou_dn_4: 1.3471 (1.3562) loss_fgl_dn_4: 0.8011 (0.7974) loss_ddf_dn_4: 0.0003 (0.0003) loss_vfl_dn_5: 0.3616 (0.3653) loss_bbox_dn_5: 0.0617 (0.0674) loss_giou_dn_5: 1.3469 (1.3563) loss_fgl_dn_5: 0.8012 (0.7974) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3452 (0.3445) loss_bbox_dn_pre: 0.0640 (0.0694) loss_giou_dn_pre: 1.3723 (1.3797)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7619 data: 0.5238 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.4010 data: 0.1720 max mem: 29062\n", + "Test: Total time: 0:00:01 (0.4152 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.003\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.003\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.002\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.011\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.018\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.015\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.205\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.058\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.006\n", + "best_stat: {'epoch': 6, 'coco_eval_bbox': 0.002885499499098386}\n", + "Epoch: [7] [ 0/84] eta: 0:02:18 lr: 0.000013 loss: 39.0678 (39.0678) loss_vfl: 0.1414 (0.1414) loss_bbox: 0.3411 (0.3411) loss_giou: 2.0102 (2.0102) loss_fgl: 0.2867 (0.2867) loss_vfl_aux_0: 0.1392 (0.1392) loss_bbox_aux_0: 0.3381 (0.3381) loss_giou_aux_0: 2.0232 (2.0232) loss_fgl_aux_0: 0.2826 (0.2826) loss_ddf_aux_0: 0.0249 (0.0249) loss_vfl_aux_1: 0.1375 (0.1375) loss_bbox_aux_1: 0.3406 (0.3406) loss_giou_aux_1: 2.0119 (2.0119) loss_fgl_aux_1: 0.2863 (0.2863) loss_ddf_aux_1: 0.0055 (0.0055) loss_vfl_aux_2: 0.1475 (0.1475) loss_bbox_aux_2: 0.3409 (0.3409) loss_giou_aux_2: 2.0105 (2.0105) loss_fgl_aux_2: 0.2868 (0.2868) loss_ddf_aux_2: 0.0012 (0.0012) loss_vfl_aux_3: 0.1426 (0.1426) loss_bbox_aux_3: 0.3410 (0.3410) loss_giou_aux_3: 2.0101 (2.0101) loss_fgl_aux_3: 0.2868 (0.2868) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1416 (0.1416) loss_bbox_aux_4: 0.3412 (0.3412) loss_giou_aux_4: 2.0100 (2.0100) loss_fgl_aux_4: 0.2868 (0.2868) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1353 (0.1353) loss_bbox_pre: 0.3429 (0.3429) loss_giou_pre: 2.0172 (2.0172) loss_vfl_enc_0: 0.1287 (0.1287) loss_bbox_enc_0: 0.3527 (0.3527) loss_giou_enc_0: 2.0309 (2.0309) loss_vfl_dn_0: 0.3516 (0.3516) loss_bbox_dn_0: 0.0698 (0.0698) loss_giou_dn_0: 1.3692 (1.3692) loss_fgl_dn_0: 0.7970 (0.7970) loss_ddf_dn_0: 0.0278 (0.0278) loss_vfl_dn_1: 0.3613 (0.3613) loss_bbox_dn_1: 0.0689 (0.0689) loss_giou_dn_1: 1.3564 (1.3564) loss_fgl_dn_1: 0.8008 (0.8008) loss_ddf_dn_1: 0.0080 (0.0080) loss_vfl_dn_2: 0.3633 (0.3633) loss_bbox_dn_2: 0.0670 (0.0670) loss_giou_dn_2: 1.3536 (1.3536) loss_fgl_dn_2: 0.8016 (0.8016) loss_ddf_dn_2: 0.0014 (0.0014) loss_vfl_dn_3: 0.3628 (0.3628) loss_bbox_dn_3: 0.0670 (0.0670) loss_giou_dn_3: 1.3537 (1.3537) loss_fgl_dn_3: 0.8014 (0.8014) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.3630 (0.3630) loss_bbox_dn_4: 0.0669 (0.0669) loss_giou_dn_4: 1.3536 (1.3536) loss_fgl_dn_4: 0.8015 (0.8015) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3667 (0.3667) loss_bbox_dn_5: 0.0669 (0.0669) loss_giou_dn_5: 1.3538 (1.3538) loss_fgl_dn_5: 0.8014 (0.8014) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3501 (0.3501) loss_bbox_dn_pre: 0.0667 (0.0667) loss_giou_dn_pre: 1.3700 (1.3700) time: 1.6466 data: 0.7883 max mem: 29062\n", + "Epoch: [7] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.3517 (40.1790) loss_vfl: 0.1315 (0.1374) loss_bbox: 0.3775 (0.4554) loss_giou: 1.9706 (2.0203) loss_fgl: 0.3164 (0.3037) loss_vfl_aux_0: 0.1220 (0.1305) loss_bbox_aux_0: 0.3787 (0.4573) loss_giou_aux_0: 1.9857 (2.0292) loss_fgl_aux_0: 0.3097 (0.3001) loss_ddf_aux_0: 0.0557 (0.0704) loss_vfl_aux_1: 0.1274 (0.1341) loss_bbox_aux_1: 0.3767 (0.4559) loss_giou_aux_1: 1.9798 (2.0222) loss_fgl_aux_1: 0.3144 (0.3024) loss_ddf_aux_1: 0.0153 (0.0217) loss_vfl_aux_2: 0.1296 (0.1372) loss_bbox_aux_2: 0.3765 (0.4548) loss_giou_aux_2: 1.9770 (2.0213) loss_fgl_aux_2: 0.3153 (0.3034) loss_ddf_aux_2: 0.0032 (0.0036) loss_vfl_aux_3: 0.1345 (0.1378) loss_bbox_aux_3: 0.3771 (0.4550) loss_giou_aux_3: 1.9741 (2.0208) loss_fgl_aux_3: 0.3159 (0.3036) loss_ddf_aux_3: 0.0006 (0.0007) loss_vfl_aux_4: 0.1320 (0.1370) loss_bbox_aux_4: 0.3775 (0.4555) loss_giou_aux_4: 1.9709 (2.0203) loss_fgl_aux_4: 0.3163 (0.3037) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1210 (0.1281) loss_bbox_pre: 0.3837 (0.4626) loss_giou_pre: 1.9786 (2.0227) loss_vfl_enc_0: 0.1078 (0.1124) loss_bbox_enc_0: 0.4059 (0.4830) loss_giou_enc_0: 2.0032 (2.0634) loss_vfl_dn_0: 0.3538 (0.3538) loss_bbox_dn_0: 0.0657 (0.0690) loss_giou_dn_0: 1.3584 (1.3636) loss_fgl_dn_0: 0.7991 (0.7981) loss_ddf_dn_0: 0.0427 (0.0466) loss_vfl_dn_1: 0.3633 (0.3639) loss_bbox_dn_1: 0.0610 (0.0658) loss_giou_dn_1: 1.3385 (1.3439) loss_fgl_dn_1: 0.8047 (0.8049) loss_ddf_dn_1: 0.0127 (0.0169) loss_vfl_dn_2: 0.3650 (0.3656) loss_bbox_dn_2: 0.0598 (0.0641) loss_giou_dn_2: 1.3318 (1.3361) loss_fgl_dn_2: 0.8078 (0.8076) loss_ddf_dn_2: 0.0030 (0.0032) loss_vfl_dn_3: 0.3660 (0.3673) loss_bbox_dn_3: 0.0601 (0.0640) loss_giou_dn_3: 1.3303 (1.3346) loss_fgl_dn_3: 0.8080 (0.8080) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.3687 (0.3677) loss_bbox_dn_4: 0.0602 (0.0640) loss_giou_dn_4: 1.3292 (1.3340) loss_fgl_dn_4: 0.8072 (0.8082) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3687 (0.3690) loss_bbox_dn_5: 0.0602 (0.0639) loss_giou_dn_5: 1.3293 (1.3339) loss_fgl_dn_5: 0.8073 (0.8082) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3516 (0.3511) loss_bbox_dn_pre: 0.0636 (0.0668) loss_giou_dn_pre: 1.3620 (1.3665) time: 0.8534 data: 0.0167 max mem: 29062\n", + "Epoch: [7] Total time: 0:01:16 (0.9165 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.3517 (40.1790) loss_vfl: 0.1315 (0.1374) loss_bbox: 0.3775 (0.4554) loss_giou: 1.9706 (2.0203) loss_fgl: 0.3164 (0.3037) loss_vfl_aux_0: 0.1220 (0.1305) loss_bbox_aux_0: 0.3787 (0.4573) loss_giou_aux_0: 1.9857 (2.0292) loss_fgl_aux_0: 0.3097 (0.3001) loss_ddf_aux_0: 0.0557 (0.0704) loss_vfl_aux_1: 0.1274 (0.1341) loss_bbox_aux_1: 0.3767 (0.4559) loss_giou_aux_1: 1.9798 (2.0222) loss_fgl_aux_1: 0.3144 (0.3024) loss_ddf_aux_1: 0.0153 (0.0217) loss_vfl_aux_2: 0.1296 (0.1372) loss_bbox_aux_2: 0.3765 (0.4548) loss_giou_aux_2: 1.9770 (2.0213) loss_fgl_aux_2: 0.3153 (0.3034) loss_ddf_aux_2: 0.0032 (0.0036) loss_vfl_aux_3: 0.1345 (0.1378) loss_bbox_aux_3: 0.3771 (0.4550) loss_giou_aux_3: 1.9741 (2.0208) loss_fgl_aux_3: 0.3159 (0.3036) loss_ddf_aux_3: 0.0006 (0.0007) loss_vfl_aux_4: 0.1320 (0.1370) loss_bbox_aux_4: 0.3775 (0.4555) loss_giou_aux_4: 1.9709 (2.0203) loss_fgl_aux_4: 0.3163 (0.3037) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1210 (0.1281) loss_bbox_pre: 0.3837 (0.4626) loss_giou_pre: 1.9786 (2.0227) loss_vfl_enc_0: 0.1078 (0.1124) loss_bbox_enc_0: 0.4059 (0.4830) loss_giou_enc_0: 2.0032 (2.0634) loss_vfl_dn_0: 0.3538 (0.3538) loss_bbox_dn_0: 0.0657 (0.0690) loss_giou_dn_0: 1.3584 (1.3636) loss_fgl_dn_0: 0.7991 (0.7981) loss_ddf_dn_0: 0.0427 (0.0466) loss_vfl_dn_1: 0.3633 (0.3639) loss_bbox_dn_1: 0.0610 (0.0658) loss_giou_dn_1: 1.3385 (1.3439) loss_fgl_dn_1: 0.8047 (0.8049) loss_ddf_dn_1: 0.0127 (0.0169) loss_vfl_dn_2: 0.3650 (0.3656) loss_bbox_dn_2: 0.0598 (0.0641) loss_giou_dn_2: 1.3318 (1.3361) loss_fgl_dn_2: 0.8078 (0.8076) loss_ddf_dn_2: 0.0030 (0.0032) loss_vfl_dn_3: 0.3660 (0.3673) loss_bbox_dn_3: 0.0601 (0.0640) loss_giou_dn_3: 1.3303 (1.3346) loss_fgl_dn_3: 0.8080 (0.8080) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.3687 (0.3677) loss_bbox_dn_4: 0.0602 (0.0640) loss_giou_dn_4: 1.3292 (1.3340) loss_fgl_dn_4: 0.8072 (0.8082) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3687 (0.3690) loss_bbox_dn_5: 0.0602 (0.0639) loss_giou_dn_5: 1.3293 (1.3339) loss_fgl_dn_5: 0.8073 (0.8082) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3516 (0.3511) loss_bbox_dn_pre: 0.0636 (0.0668) loss_giou_dn_pre: 1.3620 (1.3665)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7246 data: 0.4778 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.5311 data: 0.1658 max mem: 29062\n", + "Test: Total time: 0:00:02 (0.5487 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.004\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.002\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.004\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.029\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.051\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.004\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.015\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.022\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.025\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.097\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.175\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.061\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.010\n", + "best_stat: {'epoch': 7, 'coco_eval_bbox': 0.00395076620349019}\n", + "Epoch: [8] [ 0/84] eta: 0:02:26 lr: 0.000013 loss: 40.3788 (40.3788) loss_vfl: 0.1235 (0.1235) loss_bbox: 0.3892 (0.3892) loss_giou: 2.1162 (2.1162) loss_fgl: 0.2906 (0.2906) loss_vfl_aux_0: 0.1197 (0.1197) loss_bbox_aux_0: 0.3865 (0.3865) loss_giou_aux_0: 2.1288 (2.1288) loss_fgl_aux_0: 0.2889 (0.2889) loss_ddf_aux_0: 0.0647 (0.0647) loss_vfl_aux_1: 0.1281 (0.1281) loss_bbox_aux_1: 0.3879 (0.3879) loss_giou_aux_1: 2.1199 (2.1199) loss_fgl_aux_1: 0.2900 (0.2900) loss_ddf_aux_1: 0.0212 (0.0212) loss_vfl_aux_2: 0.1273 (0.1273) loss_bbox_aux_2: 0.3866 (0.3866) loss_giou_aux_2: 2.1198 (2.1198) loss_fgl_aux_2: 0.2907 (0.2907) loss_ddf_aux_2: 0.0046 (0.0046) loss_vfl_aux_3: 0.1252 (0.1252) loss_bbox_aux_3: 0.3875 (0.3875) loss_giou_aux_3: 2.1182 (2.1182) loss_fgl_aux_3: 0.2908 (0.2908) loss_ddf_aux_3: 0.0010 (0.0010) loss_vfl_aux_4: 0.1243 (0.1243) loss_bbox_aux_4: 0.3889 (0.3889) loss_giou_aux_4: 2.1168 (2.1168) loss_fgl_aux_4: 0.2906 (0.2906) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1196 (0.1196) loss_bbox_pre: 0.3880 (0.3880) loss_giou_pre: 2.1254 (2.1254) loss_vfl_enc_0: 0.1106 (0.1106) loss_bbox_enc_0: 0.3960 (0.3960) loss_giou_enc_0: 2.1647 (2.1647) loss_vfl_dn_0: 0.3511 (0.3511) loss_bbox_dn_0: 0.0826 (0.0826) loss_giou_dn_0: 1.3669 (1.3669) loss_fgl_dn_0: 0.7955 (0.7955) loss_ddf_dn_0: 0.0567 (0.0567) loss_vfl_dn_1: 0.3616 (0.3616) loss_bbox_dn_1: 0.0796 (0.0796) loss_giou_dn_1: 1.3542 (1.3542) loss_fgl_dn_1: 0.8001 (0.8001) loss_ddf_dn_1: 0.0230 (0.0230) loss_vfl_dn_2: 0.3628 (0.3628) loss_bbox_dn_2: 0.0776 (0.0776) loss_giou_dn_2: 1.3507 (1.3507) loss_fgl_dn_2: 0.8018 (0.8018) loss_ddf_dn_2: 0.0048 (0.0048) loss_vfl_dn_3: 0.3611 (0.3611) loss_bbox_dn_3: 0.0783 (0.0783) loss_giou_dn_3: 1.3506 (1.3506) loss_fgl_dn_3: 0.8017 (0.8017) loss_ddf_dn_3: 0.0010 (0.0010) loss_vfl_dn_4: 0.3613 (0.3613) loss_bbox_dn_4: 0.0789 (0.0789) loss_giou_dn_4: 1.3511 (1.3511) loss_fgl_dn_4: 0.8011 (0.8011) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3655 (0.3655) loss_bbox_dn_5: 0.0790 (0.0790) loss_giou_dn_5: 1.3512 (1.3512) loss_fgl_dn_5: 0.8011 (0.8011) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3491 (0.3491) loss_bbox_dn_pre: 0.0783 (0.0783) loss_giou_dn_pre: 1.3689 (1.3689) time: 1.7425 data: 0.8358 max mem: 29062\n", + "Epoch: [8] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5613 (39.3211) loss_vfl: 0.1299 (0.1477) loss_bbox: 0.3342 (0.3901) loss_giou: 1.9129 (1.9548) loss_fgl: 0.3386 (0.3240) loss_vfl_aux_0: 0.1283 (0.1407) loss_bbox_aux_0: 0.3350 (0.3930) loss_giou_aux_0: 1.9149 (1.9637) loss_fgl_aux_0: 0.3357 (0.3209) loss_ddf_aux_0: 0.0728 (0.0828) loss_vfl_aux_1: 0.1299 (0.1466) loss_bbox_aux_1: 0.3329 (0.3903) loss_giou_aux_1: 1.9185 (1.9566) loss_fgl_aux_1: 0.3382 (0.3229) loss_ddf_aux_1: 0.0138 (0.0194) loss_vfl_aux_2: 0.1293 (0.1482) loss_bbox_aux_2: 0.3333 (0.3893) loss_giou_aux_2: 1.9160 (1.9559) loss_fgl_aux_2: 0.3391 (0.3237) loss_ddf_aux_2: 0.0023 (0.0029) loss_vfl_aux_3: 0.1268 (0.1473) loss_bbox_aux_3: 0.3338 (0.3897) loss_giou_aux_3: 1.9142 (1.9553) loss_fgl_aux_3: 0.3389 (0.3239) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1288 (0.1474) loss_bbox_aux_4: 0.3341 (0.3900) loss_giou_aux_4: 1.9131 (1.9549) loss_fgl_aux_4: 0.3386 (0.3240) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1266 (0.1387) loss_bbox_pre: 0.3383 (0.3966) loss_giou_pre: 1.9131 (1.9593) loss_vfl_enc_0: 0.1152 (0.1243) loss_bbox_enc_0: 0.3490 (0.4133) loss_giou_enc_0: 1.9710 (2.0019) loss_vfl_dn_0: 0.3567 (0.3592) loss_bbox_dn_0: 0.0569 (0.0654) loss_giou_dn_0: 1.3491 (1.3493) loss_fgl_dn_0: 0.8117 (0.8091) loss_ddf_dn_0: 0.0683 (0.0667) loss_vfl_dn_1: 0.3789 (0.3755) loss_bbox_dn_1: 0.0525 (0.0609) loss_giou_dn_1: 1.3097 (1.3185) loss_fgl_dn_1: 0.8205 (0.8181) loss_ddf_dn_1: 0.0139 (0.0172) loss_vfl_dn_2: 0.3774 (0.3756) loss_bbox_dn_2: 0.0524 (0.0599) loss_giou_dn_2: 1.3019 (1.3113) loss_fgl_dn_2: 0.8222 (0.8200) loss_ddf_dn_2: 0.0026 (0.0030) loss_vfl_dn_3: 0.3792 (0.3756) loss_bbox_dn_3: 0.0524 (0.0597) loss_giou_dn_3: 1.3001 (1.3094) loss_fgl_dn_3: 0.8226 (0.8204) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.3796 (0.3765) loss_bbox_dn_4: 0.0522 (0.0597) loss_giou_dn_4: 1.2997 (1.3088) loss_fgl_dn_4: 0.8224 (0.8205) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3804 (0.3783) loss_bbox_dn_5: 0.0521 (0.0597) loss_giou_dn_5: 1.2996 (1.3087) loss_fgl_dn_5: 0.8224 (0.8205) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3555 (0.3570) loss_bbox_dn_pre: 0.0548 (0.0630) loss_giou_dn_pre: 1.3520 (1.3519) time: 0.8685 data: 0.0167 max mem: 29062\n", + "Epoch: [8] Total time: 0:01:15 (0.9030 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5613 (39.3211) loss_vfl: 0.1299 (0.1477) loss_bbox: 0.3342 (0.3901) loss_giou: 1.9129 (1.9548) loss_fgl: 0.3386 (0.3240) loss_vfl_aux_0: 0.1283 (0.1407) loss_bbox_aux_0: 0.3350 (0.3930) loss_giou_aux_0: 1.9149 (1.9637) loss_fgl_aux_0: 0.3357 (0.3209) loss_ddf_aux_0: 0.0728 (0.0828) loss_vfl_aux_1: 0.1299 (0.1466) loss_bbox_aux_1: 0.3329 (0.3903) loss_giou_aux_1: 1.9185 (1.9566) loss_fgl_aux_1: 0.3382 (0.3229) loss_ddf_aux_1: 0.0138 (0.0194) loss_vfl_aux_2: 0.1293 (0.1482) loss_bbox_aux_2: 0.3333 (0.3893) loss_giou_aux_2: 1.9160 (1.9559) loss_fgl_aux_2: 0.3391 (0.3237) loss_ddf_aux_2: 0.0023 (0.0029) loss_vfl_aux_3: 0.1268 (0.1473) loss_bbox_aux_3: 0.3338 (0.3897) loss_giou_aux_3: 1.9142 (1.9553) loss_fgl_aux_3: 0.3389 (0.3239) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1288 (0.1474) loss_bbox_aux_4: 0.3341 (0.3900) loss_giou_aux_4: 1.9131 (1.9549) loss_fgl_aux_4: 0.3386 (0.3240) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1266 (0.1387) loss_bbox_pre: 0.3383 (0.3966) loss_giou_pre: 1.9131 (1.9593) loss_vfl_enc_0: 0.1152 (0.1243) loss_bbox_enc_0: 0.3490 (0.4133) loss_giou_enc_0: 1.9710 (2.0019) loss_vfl_dn_0: 0.3567 (0.3592) loss_bbox_dn_0: 0.0569 (0.0654) loss_giou_dn_0: 1.3491 (1.3493) loss_fgl_dn_0: 0.8117 (0.8091) loss_ddf_dn_0: 0.0683 (0.0667) loss_vfl_dn_1: 0.3789 (0.3755) loss_bbox_dn_1: 0.0525 (0.0609) loss_giou_dn_1: 1.3097 (1.3185) loss_fgl_dn_1: 0.8205 (0.8181) loss_ddf_dn_1: 0.0139 (0.0172) loss_vfl_dn_2: 0.3774 (0.3756) loss_bbox_dn_2: 0.0524 (0.0599) loss_giou_dn_2: 1.3019 (1.3113) loss_fgl_dn_2: 0.8222 (0.8200) loss_ddf_dn_2: 0.0026 (0.0030) loss_vfl_dn_3: 0.3792 (0.3756) loss_bbox_dn_3: 0.0524 (0.0597) loss_giou_dn_3: 1.3001 (1.3094) loss_fgl_dn_3: 0.8226 (0.8204) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.3796 (0.3765) loss_bbox_dn_4: 0.0522 (0.0597) loss_giou_dn_4: 1.2997 (1.3088) loss_fgl_dn_4: 0.8224 (0.8205) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.3804 (0.3783) loss_bbox_dn_5: 0.0521 (0.0597) loss_giou_dn_5: 1.2996 (1.3087) loss_fgl_dn_5: 0.8224 (0.8205) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3555 (0.3570) loss_bbox_dn_pre: 0.0548 (0.0630) loss_giou_dn_pre: 1.3520 (1.3519)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7231 data: 0.4803 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.3883 data: 0.1616 max mem: 29062\n", + "Test: Total time: 0:00:01 (0.4035 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.020\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.006\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.070\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.003\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.022\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.036\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.039\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.156\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.100\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.025\n", + "best_stat: {'epoch': 8, 'coco_eval_bbox': 0.007344170564153883}\n", + "Epoch: [9] [ 0/84] eta: 0:02:57 lr: 0.000013 loss: 36.9528 (36.9528) loss_vfl: 0.0934 (0.0934) loss_bbox: 0.2474 (0.2474) loss_giou: 1.9109 (1.9109) loss_fgl: 0.3059 (0.3059) loss_vfl_aux_0: 0.1001 (0.1001) loss_bbox_aux_0: 0.2494 (0.2494) loss_giou_aux_0: 1.9110 (1.9110) loss_fgl_aux_0: 0.3042 (0.3042) loss_ddf_aux_0: 0.0260 (0.0260) loss_vfl_aux_1: 0.1012 (0.1012) loss_bbox_aux_1: 0.2470 (0.2470) loss_giou_aux_1: 1.9105 (1.9105) loss_fgl_aux_1: 0.3056 (0.3056) loss_ddf_aux_1: 0.0049 (0.0049) loss_vfl_aux_2: 0.0989 (0.0989) loss_bbox_aux_2: 0.2465 (0.2465) loss_giou_aux_2: 1.9113 (1.9113) loss_fgl_aux_2: 0.3057 (0.3057) loss_ddf_aux_2: 0.0009 (0.0009) loss_vfl_aux_3: 0.0955 (0.0955) loss_bbox_aux_3: 0.2468 (0.2468) loss_giou_aux_3: 1.9112 (1.9112) loss_fgl_aux_3: 0.3058 (0.3058) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.0931 (0.0931) loss_bbox_aux_4: 0.2473 (0.2473) loss_giou_aux_4: 1.9109 (1.9109) loss_fgl_aux_4: 0.3058 (0.3058) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0973 (0.0973) loss_bbox_pre: 0.2546 (0.2546) loss_giou_pre: 1.9050 (1.9050) loss_vfl_enc_0: 0.0859 (0.0859) loss_bbox_enc_0: 0.2670 (0.2670) loss_giou_enc_0: 1.9352 (1.9352) loss_vfl_dn_0: 0.3542 (0.3542) loss_bbox_dn_0: 0.0338 (0.0338) loss_giou_dn_0: 1.3606 (1.3606) loss_fgl_dn_0: 0.8029 (0.8029) loss_ddf_dn_0: 0.0466 (0.0466) loss_vfl_dn_1: 0.3677 (0.3677) loss_bbox_dn_1: 0.0315 (0.0315) loss_giou_dn_1: 1.3229 (1.3229) loss_fgl_dn_1: 0.8126 (0.8126) loss_ddf_dn_1: 0.0108 (0.0108) loss_vfl_dn_2: 0.3704 (0.3704) loss_bbox_dn_2: 0.0312 (0.0312) loss_giou_dn_2: 1.3126 (1.3126) loss_fgl_dn_2: 0.8146 (0.8146) loss_ddf_dn_2: 0.0027 (0.0027) loss_vfl_dn_3: 0.3721 (0.3721) loss_bbox_dn_3: 0.0314 (0.0314) loss_giou_dn_3: 1.3110 (1.3110) loss_fgl_dn_3: 0.8144 (0.8144) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3738 (0.3738) loss_bbox_dn_4: 0.0315 (0.0315) loss_giou_dn_4: 1.3100 (1.3100) loss_fgl_dn_4: 0.8144 (0.8144) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.3718 (0.3718) loss_bbox_dn_5: 0.0315 (0.0315) loss_giou_dn_5: 1.3099 (1.3099) loss_fgl_dn_5: 0.8144 (0.8144) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3516 (0.3516) loss_bbox_dn_pre: 0.0319 (0.0319) loss_giou_dn_pre: 1.3650 (1.3650) time: 2.1084 data: 1.1137 max mem: 29062\n", + "Epoch: [9] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.4143 (39.4255) loss_vfl: 0.1130 (0.1526) loss_bbox: 0.3584 (0.4027) loss_giou: 1.9329 (1.9406) loss_fgl: 0.3245 (0.3382) loss_vfl_aux_0: 0.1069 (0.1476) loss_bbox_aux_0: 0.3612 (0.4019) loss_giou_aux_0: 1.9443 (1.9537) loss_fgl_aux_0: 0.3228 (0.3361) loss_ddf_aux_0: 0.0708 (0.0861) loss_vfl_aux_1: 0.1092 (0.1512) loss_bbox_aux_1: 0.3582 (0.4015) loss_giou_aux_1: 1.9334 (1.9435) loss_fgl_aux_1: 0.3243 (0.3375) loss_ddf_aux_1: 0.0116 (0.0159) loss_vfl_aux_2: 0.1131 (0.1518) loss_bbox_aux_2: 0.3585 (0.4022) loss_giou_aux_2: 1.9327 (1.9416) loss_fgl_aux_2: 0.3244 (0.3379) loss_ddf_aux_2: 0.0022 (0.0024) loss_vfl_aux_3: 0.1096 (0.1511) loss_bbox_aux_3: 0.3584 (0.4023) loss_giou_aux_3: 1.9328 (1.9411) loss_fgl_aux_3: 0.3245 (0.3381) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1121 (0.1514) loss_bbox_aux_4: 0.3584 (0.4027) loss_giou_aux_4: 1.9327 (1.9407) loss_fgl_aux_4: 0.3246 (0.3382) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1051 (0.1454) loss_bbox_pre: 0.3653 (0.4067) loss_giou_pre: 1.9358 (1.9480) loss_vfl_enc_0: 0.1001 (0.1318) loss_bbox_enc_0: 0.3867 (0.4238) loss_giou_enc_0: 1.9830 (1.9899) loss_vfl_dn_0: 0.3557 (0.3616) loss_bbox_dn_0: 0.0607 (0.0670) loss_giou_dn_0: 1.3451 (1.3412) loss_fgl_dn_0: 0.8091 (0.8153) loss_ddf_dn_0: 0.1011 (0.1104) loss_vfl_dn_1: 0.3928 (0.3941) loss_bbox_dn_1: 0.0520 (0.0603) loss_giou_dn_1: 1.2604 (1.2751) loss_fgl_dn_1: 0.8391 (0.8352) loss_ddf_dn_1: 0.0188 (0.0254) loss_vfl_dn_2: 0.3982 (0.3972) loss_bbox_dn_2: 0.0513 (0.0593) loss_giou_dn_2: 1.2500 (1.2601) loss_fgl_dn_2: 0.8376 (0.8384) loss_ddf_dn_2: 0.0029 (0.0040) loss_vfl_dn_3: 0.3923 (0.3964) loss_bbox_dn_3: 0.0509 (0.0591) loss_giou_dn_3: 1.2485 (1.2576) loss_fgl_dn_3: 0.8377 (0.8389) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.3958 (0.3964) loss_bbox_dn_4: 0.0505 (0.0590) loss_giou_dn_4: 1.2473 (1.2568) loss_fgl_dn_4: 0.8387 (0.8391) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.3989 (0.3974) loss_bbox_dn_5: 0.0506 (0.0589) loss_giou_dn_5: 1.2473 (1.2568) loss_fgl_dn_5: 0.8388 (0.8391) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3560 (0.3600) loss_bbox_dn_pre: 0.0584 (0.0645) loss_giou_dn_pre: 1.3464 (1.3436) time: 0.9246 data: 0.0209 max mem: 29062\n", + "Epoch: [9] Total time: 0:01:16 (0.9070 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.4143 (39.4255) loss_vfl: 0.1130 (0.1526) loss_bbox: 0.3584 (0.4027) loss_giou: 1.9329 (1.9406) loss_fgl: 0.3245 (0.3382) loss_vfl_aux_0: 0.1069 (0.1476) loss_bbox_aux_0: 0.3612 (0.4019) loss_giou_aux_0: 1.9443 (1.9537) loss_fgl_aux_0: 0.3228 (0.3361) loss_ddf_aux_0: 0.0708 (0.0861) loss_vfl_aux_1: 0.1092 (0.1512) loss_bbox_aux_1: 0.3582 (0.4015) loss_giou_aux_1: 1.9334 (1.9435) loss_fgl_aux_1: 0.3243 (0.3375) loss_ddf_aux_1: 0.0116 (0.0159) loss_vfl_aux_2: 0.1131 (0.1518) loss_bbox_aux_2: 0.3585 (0.4022) loss_giou_aux_2: 1.9327 (1.9416) loss_fgl_aux_2: 0.3244 (0.3379) loss_ddf_aux_2: 0.0022 (0.0024) loss_vfl_aux_3: 0.1096 (0.1511) loss_bbox_aux_3: 0.3584 (0.4023) loss_giou_aux_3: 1.9328 (1.9411) loss_fgl_aux_3: 0.3245 (0.3381) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1121 (0.1514) loss_bbox_aux_4: 0.3584 (0.4027) loss_giou_aux_4: 1.9327 (1.9407) loss_fgl_aux_4: 0.3246 (0.3382) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1051 (0.1454) loss_bbox_pre: 0.3653 (0.4067) loss_giou_pre: 1.9358 (1.9480) loss_vfl_enc_0: 0.1001 (0.1318) loss_bbox_enc_0: 0.3867 (0.4238) loss_giou_enc_0: 1.9830 (1.9899) loss_vfl_dn_0: 0.3557 (0.3616) loss_bbox_dn_0: 0.0607 (0.0670) loss_giou_dn_0: 1.3451 (1.3412) loss_fgl_dn_0: 0.8091 (0.8153) loss_ddf_dn_0: 0.1011 (0.1104) loss_vfl_dn_1: 0.3928 (0.3941) loss_bbox_dn_1: 0.0520 (0.0603) loss_giou_dn_1: 1.2604 (1.2751) loss_fgl_dn_1: 0.8391 (0.8352) loss_ddf_dn_1: 0.0188 (0.0254) loss_vfl_dn_2: 0.3982 (0.3972) loss_bbox_dn_2: 0.0513 (0.0593) loss_giou_dn_2: 1.2500 (1.2601) loss_fgl_dn_2: 0.8376 (0.8384) loss_ddf_dn_2: 0.0029 (0.0040) loss_vfl_dn_3: 0.3923 (0.3964) loss_bbox_dn_3: 0.0509 (0.0591) loss_giou_dn_3: 1.2485 (1.2576) loss_fgl_dn_3: 0.8377 (0.8389) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.3958 (0.3964) loss_bbox_dn_4: 0.0505 (0.0590) loss_giou_dn_4: 1.2473 (1.2568) loss_fgl_dn_4: 0.8387 (0.8391) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.3989 (0.3974) loss_bbox_dn_5: 0.0506 (0.0589) loss_giou_dn_5: 1.2473 (1.2568) loss_fgl_dn_5: 0.8388 (0.8391) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3560 (0.3600) loss_bbox_dn_pre: 0.0584 (0.0645) loss_giou_dn_pre: 1.3464 (1.3436)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7268 data: 0.4910 max mem: 29062\n", + "Test: [3/4] eta: 0:00:00 time: 0.3796 data: 0.1605 max mem: 29062\n", + "Test: Total time: 0:00:01 (0.3941 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.008\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.092\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.034\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.006\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.029\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.033\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.323\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.100\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.034\n", + "best_stat: {'epoch': 9, 'coco_eval_bbox': 0.010720836875337045}\n", + "Epoch: [10] [ 0/84] eta: 0:02:30 lr: 0.000013 loss: 38.4105 (38.4105) loss_vfl: 0.0932 (0.0932) loss_bbox: 0.4065 (0.4065) loss_giou: 1.9276 (1.9276) loss_fgl: 0.2774 (0.2774) loss_vfl_aux_0: 0.0906 (0.0906) loss_bbox_aux_0: 0.3965 (0.3965) loss_giou_aux_0: 1.9464 (1.9464) loss_fgl_aux_0: 0.2791 (0.2791) loss_ddf_aux_0: 0.1605 (0.1605) loss_vfl_aux_1: 0.0967 (0.0967) loss_bbox_aux_1: 0.3993 (0.3993) loss_giou_aux_1: 1.9319 (1.9319) loss_fgl_aux_1: 0.2778 (0.2778) loss_ddf_aux_1: 0.0335 (0.0335) loss_vfl_aux_2: 0.0967 (0.0967) loss_bbox_aux_2: 0.4060 (0.4060) loss_giou_aux_2: 1.9285 (1.9285) loss_fgl_aux_2: 0.2771 (0.2771) loss_ddf_aux_2: 0.0057 (0.0057) loss_vfl_aux_3: 0.0953 (0.0953) loss_bbox_aux_3: 0.4063 (0.4063) loss_giou_aux_3: 1.9284 (1.9284) loss_fgl_aux_3: 0.2774 (0.2774) loss_ddf_aux_3: 0.0008 (0.0008) loss_vfl_aux_4: 0.0952 (0.0952) loss_bbox_aux_4: 0.4064 (0.4064) loss_giou_aux_4: 1.9277 (1.9277) loss_fgl_aux_4: 0.2775 (0.2775) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0894 (0.0894) loss_bbox_pre: 0.4017 (0.4017) loss_giou_pre: 1.9417 (1.9417) loss_vfl_enc_0: 0.0867 (0.0867) loss_bbox_enc_0: 0.4130 (0.4130) loss_giou_enc_0: 2.0000 (2.0000) loss_vfl_dn_0: 0.3542 (0.3542) loss_bbox_dn_0: 0.0528 (0.0528) loss_giou_dn_0: 1.3510 (1.3510) loss_fgl_dn_0: 0.8049 (0.8049) loss_ddf_dn_0: 0.0969 (0.0969) loss_vfl_dn_1: 0.4011 (0.4011) loss_bbox_dn_1: 0.0445 (0.0445) loss_giou_dn_1: 1.2570 (1.2570) loss_fgl_dn_1: 0.8355 (0.8355) loss_ddf_dn_1: 0.0182 (0.0182) loss_vfl_dn_2: 0.4038 (0.4038) loss_bbox_dn_2: 0.0426 (0.0426) loss_giou_dn_2: 1.2321 (1.2321) loss_fgl_dn_2: 0.8414 (0.8414) loss_ddf_dn_2: 0.0027 (0.0027) loss_vfl_dn_3: 0.3970 (0.3970) loss_bbox_dn_3: 0.0420 (0.0420) loss_giou_dn_3: 1.2294 (1.2294) loss_fgl_dn_3: 0.8419 (0.8419) loss_ddf_dn_3: 0.0007 (0.0007) loss_vfl_dn_4: 0.3977 (0.3977) loss_bbox_dn_4: 0.0416 (0.0416) loss_giou_dn_4: 1.2286 (1.2286) loss_fgl_dn_4: 0.8425 (0.8425) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4021 (0.4021) loss_bbox_dn_5: 0.0415 (0.0415) loss_giou_dn_5: 1.2285 (1.2285) loss_fgl_dn_5: 0.8426 (0.8426) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3538 (0.3538) loss_bbox_dn_pre: 0.0510 (0.0510) loss_giou_dn_pre: 1.3518 (1.3518) time: 1.7888 data: 0.6602 max mem: 29062\n", + "Epoch: [10] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.4834 (39.4397) loss_vfl: 0.1616 (0.1590) loss_bbox: 0.3650 (0.3992) loss_giou: 1.9208 (1.9393) loss_fgl: 0.3544 (0.3382) loss_vfl_aux_0: 0.1583 (0.1522) loss_bbox_aux_0: 0.3686 (0.4004) loss_giou_aux_0: 1.9339 (1.9498) loss_fgl_aux_0: 0.3484 (0.3363) loss_ddf_aux_0: 0.0786 (0.0953) loss_vfl_aux_1: 0.1678 (0.1576) loss_bbox_aux_1: 0.3670 (0.3992) loss_giou_aux_1: 1.9223 (1.9406) loss_fgl_aux_1: 0.3515 (0.3372) loss_ddf_aux_1: 0.0148 (0.0183) loss_vfl_aux_2: 0.1609 (0.1597) loss_bbox_aux_2: 0.3659 (0.3992) loss_giou_aux_2: 1.9206 (1.9395) loss_fgl_aux_2: 0.3538 (0.3379) loss_ddf_aux_2: 0.0020 (0.0027) loss_vfl_aux_3: 0.1603 (0.1584) loss_bbox_aux_3: 0.3652 (0.3990) loss_giou_aux_3: 1.9207 (1.9396) loss_fgl_aux_3: 0.3542 (0.3382) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1604 (0.1583) loss_bbox_aux_4: 0.3650 (0.3992) loss_giou_aux_4: 1.9208 (1.9393) loss_fgl_aux_4: 0.3544 (0.3382) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1560 (0.1500) loss_bbox_pre: 0.3757 (0.4059) loss_giou_pre: 1.9302 (1.9434) loss_vfl_enc_0: 0.1481 (0.1391) loss_bbox_enc_0: 0.3963 (0.4226) loss_giou_enc_0: 1.9573 (1.9813) loss_vfl_dn_0: 0.3726 (0.3678) loss_bbox_dn_0: 0.0610 (0.0660) loss_giou_dn_0: 1.3041 (1.3246) loss_fgl_dn_0: 0.8446 (0.8275) loss_ddf_dn_0: 0.1441 (0.1395) loss_vfl_dn_1: 0.4119 (0.4096) loss_bbox_dn_1: 0.0559 (0.0589) loss_giou_dn_1: 1.2260 (1.2397) loss_fgl_dn_1: 0.8626 (0.8535) loss_ddf_dn_1: 0.0357 (0.0340) loss_vfl_dn_2: 0.4253 (0.4176) loss_bbox_dn_2: 0.0536 (0.0573) loss_giou_dn_2: 1.1947 (1.2149) loss_fgl_dn_2: 0.8695 (0.8593) loss_ddf_dn_2: 0.0045 (0.0047) loss_vfl_dn_3: 0.4216 (0.4145) loss_bbox_dn_3: 0.0530 (0.0568) loss_giou_dn_3: 1.1968 (1.2125) loss_fgl_dn_3: 0.8705 (0.8602) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4216 (0.4144) loss_bbox_dn_4: 0.0529 (0.0566) loss_giou_dn_4: 1.1966 (1.2118) loss_fgl_dn_4: 0.8714 (0.8606) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4226 (0.4160) loss_bbox_dn_5: 0.0529 (0.0566) loss_giou_dn_5: 1.1964 (1.2118) loss_fgl_dn_5: 0.8715 (0.8606) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3735 (0.3668) loss_bbox_dn_pre: 0.0600 (0.0642) loss_giou_dn_pre: 1.3059 (1.3264) time: 0.8609 data: 0.0168 max mem: 29821\n", + "Epoch: [10] Total time: 0:01:14 (0.8882 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.4834 (39.4397) loss_vfl: 0.1616 (0.1590) loss_bbox: 0.3650 (0.3992) loss_giou: 1.9208 (1.9393) loss_fgl: 0.3544 (0.3382) loss_vfl_aux_0: 0.1583 (0.1522) loss_bbox_aux_0: 0.3686 (0.4004) loss_giou_aux_0: 1.9339 (1.9498) loss_fgl_aux_0: 0.3484 (0.3363) loss_ddf_aux_0: 0.0786 (0.0953) loss_vfl_aux_1: 0.1678 (0.1576) loss_bbox_aux_1: 0.3670 (0.3992) loss_giou_aux_1: 1.9223 (1.9406) loss_fgl_aux_1: 0.3515 (0.3372) loss_ddf_aux_1: 0.0148 (0.0183) loss_vfl_aux_2: 0.1609 (0.1597) loss_bbox_aux_2: 0.3659 (0.3992) loss_giou_aux_2: 1.9206 (1.9395) loss_fgl_aux_2: 0.3538 (0.3379) loss_ddf_aux_2: 0.0020 (0.0027) loss_vfl_aux_3: 0.1603 (0.1584) loss_bbox_aux_3: 0.3652 (0.3990) loss_giou_aux_3: 1.9207 (1.9396) loss_fgl_aux_3: 0.3542 (0.3382) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1604 (0.1583) loss_bbox_aux_4: 0.3650 (0.3992) loss_giou_aux_4: 1.9208 (1.9393) loss_fgl_aux_4: 0.3544 (0.3382) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1560 (0.1500) loss_bbox_pre: 0.3757 (0.4059) loss_giou_pre: 1.9302 (1.9434) loss_vfl_enc_0: 0.1481 (0.1391) loss_bbox_enc_0: 0.3963 (0.4226) loss_giou_enc_0: 1.9573 (1.9813) loss_vfl_dn_0: 0.3726 (0.3678) loss_bbox_dn_0: 0.0610 (0.0660) loss_giou_dn_0: 1.3041 (1.3246) loss_fgl_dn_0: 0.8446 (0.8275) loss_ddf_dn_0: 0.1441 (0.1395) loss_vfl_dn_1: 0.4119 (0.4096) loss_bbox_dn_1: 0.0559 (0.0589) loss_giou_dn_1: 1.2260 (1.2397) loss_fgl_dn_1: 0.8626 (0.8535) loss_ddf_dn_1: 0.0357 (0.0340) loss_vfl_dn_2: 0.4253 (0.4176) loss_bbox_dn_2: 0.0536 (0.0573) loss_giou_dn_2: 1.1947 (1.2149) loss_fgl_dn_2: 0.8695 (0.8593) loss_ddf_dn_2: 0.0045 (0.0047) loss_vfl_dn_3: 0.4216 (0.4145) loss_bbox_dn_3: 0.0530 (0.0568) loss_giou_dn_3: 1.1968 (1.2125) loss_fgl_dn_3: 0.8705 (0.8602) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4216 (0.4144) loss_bbox_dn_4: 0.0529 (0.0566) loss_giou_dn_4: 1.1966 (1.2118) loss_fgl_dn_4: 0.8714 (0.8606) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4226 (0.4160) loss_bbox_dn_5: 0.0529 (0.0566) loss_giou_dn_5: 1.1964 (1.2118) loss_fgl_dn_5: 0.8715 (0.8606) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3735 (0.3668) loss_bbox_dn_pre: 0.0600 (0.0642) loss_giou_dn_pre: 1.3059 (1.3264)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7364 data: 0.4858 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5286 data: 0.2991 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5457 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.008\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.070\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.149\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.006\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.037\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.185\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.300\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.084\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + "best_stat: {'epoch': 9, 'coco_eval_bbox': 0.010720836875337045}\n", + "Epoch: [11] [ 0/84] eta: 0:02:54 lr: 0.000013 loss: 38.8446 (38.8446) loss_vfl: 0.1500 (0.1500) loss_bbox: 0.3984 (0.3984) loss_giou: 1.9003 (1.9003) loss_fgl: 0.3309 (0.3309) loss_vfl_aux_0: 0.1467 (0.1467) loss_bbox_aux_0: 0.3943 (0.3943) loss_giou_aux_0: 1.9106 (1.9106) loss_fgl_aux_0: 0.3284 (0.3284) loss_ddf_aux_0: 0.0745 (0.0745) loss_vfl_aux_1: 0.1526 (0.1526) loss_bbox_aux_1: 0.3953 (0.3953) loss_giou_aux_1: 1.9011 (1.9011) loss_fgl_aux_1: 0.3306 (0.3306) loss_ddf_aux_1: 0.0099 (0.0099) loss_vfl_aux_2: 0.1552 (0.1552) loss_bbox_aux_2: 0.3966 (0.3966) loss_giou_aux_2: 1.9008 (1.9008) loss_fgl_aux_2: 0.3310 (0.3310) loss_ddf_aux_2: 0.0009 (0.0009) loss_vfl_aux_3: 0.1516 (0.1516) loss_bbox_aux_3: 0.3975 (0.3975) loss_giou_aux_3: 1.9005 (1.9005) loss_fgl_aux_3: 0.3310 (0.3310) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1504 (0.1504) loss_bbox_aux_4: 0.3983 (0.3983) loss_giou_aux_4: 1.9003 (1.9003) loss_fgl_aux_4: 0.3309 (0.3309) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1440 (0.1440) loss_bbox_pre: 0.3997 (0.3997) loss_giou_pre: 1.9071 (1.9071) loss_vfl_enc_0: 0.1388 (0.1388) loss_bbox_enc_0: 0.4000 (0.4000) loss_giou_enc_0: 1.9431 (1.9431) loss_vfl_dn_0: 0.3608 (0.3608) loss_bbox_dn_0: 0.0626 (0.0626) loss_giou_dn_0: 1.3161 (1.3161) loss_fgl_dn_0: 0.8248 (0.8248) loss_ddf_dn_0: 0.1202 (0.1202) loss_vfl_dn_1: 0.4221 (0.4221) loss_bbox_dn_1: 0.0561 (0.0561) loss_giou_dn_1: 1.2228 (1.2228) loss_fgl_dn_1: 0.8584 (0.8584) loss_ddf_dn_1: 0.0342 (0.0342) loss_vfl_dn_2: 0.4443 (0.4443) loss_bbox_dn_2: 0.0543 (0.0543) loss_giou_dn_2: 1.1863 (1.1863) loss_fgl_dn_2: 0.8652 (0.8652) loss_ddf_dn_2: 0.0037 (0.0037) loss_vfl_dn_3: 0.4233 (0.4233) loss_bbox_dn_3: 0.0546 (0.0546) loss_giou_dn_3: 1.1868 (1.1868) loss_fgl_dn_3: 0.8627 (0.8627) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4182 (0.4182) loss_bbox_dn_4: 0.0549 (0.0549) loss_giou_dn_4: 1.1873 (1.1873) loss_fgl_dn_4: 0.8620 (0.8620) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4192 (0.4192) loss_bbox_dn_5: 0.0549 (0.0549) loss_giou_dn_5: 1.1873 (1.1873) loss_fgl_dn_5: 0.8621 (0.8621) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3640 (0.3640) loss_bbox_dn_pre: 0.0606 (0.0606) loss_giou_dn_pre: 1.3127 (1.3127) time: 2.0750 data: 1.2181 max mem: 29821\n", + "Epoch: [11] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.3343 (39.4527) loss_vfl: 0.1582 (0.1581) loss_bbox: 0.3923 (0.3993) loss_giou: 1.9309 (1.9337) loss_fgl: 0.3500 (0.3470) loss_vfl_aux_0: 0.1495 (0.1540) loss_bbox_aux_0: 0.3921 (0.4000) loss_giou_aux_0: 1.9380 (1.9443) loss_fgl_aux_0: 0.3492 (0.3445) loss_ddf_aux_0: 0.1014 (0.0984) loss_vfl_aux_1: 0.1606 (0.1589) loss_bbox_aux_1: 0.3927 (0.3991) loss_giou_aux_1: 1.9326 (1.9355) loss_fgl_aux_1: 0.3495 (0.3458) loss_ddf_aux_1: 0.0167 (0.0165) loss_vfl_aux_2: 0.1587 (0.1584) loss_bbox_aux_2: 0.3928 (0.3993) loss_giou_aux_2: 1.9305 (1.9342) loss_fgl_aux_2: 0.3500 (0.3466) loss_ddf_aux_2: 0.0020 (0.0025) loss_vfl_aux_3: 0.1577 (0.1577) loss_bbox_aux_3: 0.3925 (0.3993) loss_giou_aux_3: 1.9306 (1.9339) loss_fgl_aux_3: 0.3500 (0.3469) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1581 (0.1574) loss_bbox_aux_4: 0.3924 (0.3994) loss_giou_aux_4: 1.9308 (1.9337) loss_fgl_aux_4: 0.3500 (0.3470) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1458 (0.1518) loss_bbox_pre: 0.3982 (0.4054) loss_giou_pre: 1.9286 (1.9375) loss_vfl_enc_0: 0.1353 (0.1413) loss_bbox_enc_0: 0.4040 (0.4222) loss_giou_enc_0: 1.9817 (1.9721) loss_vfl_dn_0: 0.3765 (0.3737) loss_bbox_dn_0: 0.0643 (0.0631) loss_giou_dn_0: 1.2966 (1.3037) loss_fgl_dn_0: 0.8483 (0.8425) loss_ddf_dn_0: 0.1549 (0.1465) loss_vfl_dn_1: 0.4148 (0.4136) loss_bbox_dn_1: 0.0592 (0.0565) loss_giou_dn_1: 1.2100 (1.2229) loss_fgl_dn_1: 0.8711 (0.8683) loss_ddf_dn_1: 0.0407 (0.0354) loss_vfl_dn_2: 0.4185 (0.4216) loss_bbox_dn_2: 0.0583 (0.0550) loss_giou_dn_2: 1.1993 (1.2018) loss_fgl_dn_2: 0.8759 (0.8749) loss_ddf_dn_2: 0.0052 (0.0044) loss_vfl_dn_3: 0.4160 (0.4181) loss_bbox_dn_3: 0.0577 (0.0546) loss_giou_dn_3: 1.1962 (1.1996) loss_fgl_dn_3: 0.8760 (0.8759) loss_ddf_dn_3: 0.0008 (0.0008) loss_vfl_dn_4: 0.4182 (0.4182) loss_bbox_dn_4: 0.0574 (0.0544) loss_giou_dn_4: 1.1959 (1.1990) loss_fgl_dn_4: 0.8760 (0.8764) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4180 (0.4197) loss_bbox_dn_5: 0.0574 (0.0544) loss_giou_dn_5: 1.1958 (1.1990) loss_fgl_dn_5: 0.8762 (0.8764) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3770 (0.3727) loss_bbox_dn_pre: 0.0631 (0.0621) loss_giou_dn_pre: 1.2974 (1.3052) time: 0.8901 data: 0.0172 max mem: 29821\n", + "Epoch: [11] Total time: 0:01:15 (0.8975 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.3343 (39.4527) loss_vfl: 0.1582 (0.1581) loss_bbox: 0.3923 (0.3993) loss_giou: 1.9309 (1.9337) loss_fgl: 0.3500 (0.3470) loss_vfl_aux_0: 0.1495 (0.1540) loss_bbox_aux_0: 0.3921 (0.4000) loss_giou_aux_0: 1.9380 (1.9443) loss_fgl_aux_0: 0.3492 (0.3445) loss_ddf_aux_0: 0.1014 (0.0984) loss_vfl_aux_1: 0.1606 (0.1589) loss_bbox_aux_1: 0.3927 (0.3991) loss_giou_aux_1: 1.9326 (1.9355) loss_fgl_aux_1: 0.3495 (0.3458) loss_ddf_aux_1: 0.0167 (0.0165) loss_vfl_aux_2: 0.1587 (0.1584) loss_bbox_aux_2: 0.3928 (0.3993) loss_giou_aux_2: 1.9305 (1.9342) loss_fgl_aux_2: 0.3500 (0.3466) loss_ddf_aux_2: 0.0020 (0.0025) loss_vfl_aux_3: 0.1577 (0.1577) loss_bbox_aux_3: 0.3925 (0.3993) loss_giou_aux_3: 1.9306 (1.9339) loss_fgl_aux_3: 0.3500 (0.3469) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1581 (0.1574) loss_bbox_aux_4: 0.3924 (0.3994) loss_giou_aux_4: 1.9308 (1.9337) loss_fgl_aux_4: 0.3500 (0.3470) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1458 (0.1518) loss_bbox_pre: 0.3982 (0.4054) loss_giou_pre: 1.9286 (1.9375) loss_vfl_enc_0: 0.1353 (0.1413) loss_bbox_enc_0: 0.4040 (0.4222) loss_giou_enc_0: 1.9817 (1.9721) loss_vfl_dn_0: 0.3765 (0.3737) loss_bbox_dn_0: 0.0643 (0.0631) loss_giou_dn_0: 1.2966 (1.3037) loss_fgl_dn_0: 0.8483 (0.8425) loss_ddf_dn_0: 0.1549 (0.1465) loss_vfl_dn_1: 0.4148 (0.4136) loss_bbox_dn_1: 0.0592 (0.0565) loss_giou_dn_1: 1.2100 (1.2229) loss_fgl_dn_1: 0.8711 (0.8683) loss_ddf_dn_1: 0.0407 (0.0354) loss_vfl_dn_2: 0.4185 (0.4216) loss_bbox_dn_2: 0.0583 (0.0550) loss_giou_dn_2: 1.1993 (1.2018) loss_fgl_dn_2: 0.8759 (0.8749) loss_ddf_dn_2: 0.0052 (0.0044) loss_vfl_dn_3: 0.4160 (0.4181) loss_bbox_dn_3: 0.0577 (0.0546) loss_giou_dn_3: 1.1962 (1.1996) loss_fgl_dn_3: 0.8760 (0.8759) loss_ddf_dn_3: 0.0008 (0.0008) loss_vfl_dn_4: 0.4182 (0.4182) loss_bbox_dn_4: 0.0574 (0.0544) loss_giou_dn_4: 1.1959 (1.1990) loss_fgl_dn_4: 0.8760 (0.8764) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4180 (0.4197) loss_bbox_dn_5: 0.0574 (0.0544) loss_giou_dn_5: 1.1958 (1.1990) loss_fgl_dn_5: 0.8762 (0.8764) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3770 (0.3727) loss_bbox_dn_pre: 0.0631 (0.0621) loss_giou_dn_pre: 1.2974 (1.3052)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7112 data: 0.4716 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3896 data: 0.1664 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4033 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.014\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.033\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.104\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.059\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.004\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.024\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.039\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.217\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.275\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.094\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + "best_stat: {'epoch': 11, 'coco_eval_bbox': 0.013863723494761776}\n", + "Epoch: [12] [ 0/84] eta: 0:02:30 lr: 0.000013 loss: 39.3418 (39.3418) loss_vfl: 0.1569 (0.1569) loss_bbox: 0.3615 (0.3615) loss_giou: 1.9137 (1.9137) loss_fgl: 0.4010 (0.4010) loss_vfl_aux_0: 0.1473 (0.1473) loss_bbox_aux_0: 0.3584 (0.3584) loss_giou_aux_0: 1.9281 (1.9281) loss_fgl_aux_0: 0.3956 (0.3956) loss_ddf_aux_0: 0.1488 (0.1488) loss_vfl_aux_1: 0.1519 (0.1519) loss_bbox_aux_1: 0.3602 (0.3602) loss_giou_aux_1: 1.9166 (1.9166) loss_fgl_aux_1: 0.3984 (0.3984) loss_ddf_aux_1: 0.0300 (0.0300) loss_vfl_aux_2: 0.1531 (0.1531) loss_bbox_aux_2: 0.3616 (0.3616) loss_giou_aux_2: 1.9143 (1.9143) loss_fgl_aux_2: 0.4000 (0.4000) loss_ddf_aux_2: 0.0050 (0.0050) loss_vfl_aux_3: 0.1544 (0.1544) loss_bbox_aux_3: 0.3617 (0.3617) loss_giou_aux_3: 1.9138 (1.9138) loss_fgl_aux_3: 0.4007 (0.4007) loss_ddf_aux_3: 0.0008 (0.0008) loss_vfl_aux_4: 0.1552 (0.1552) loss_bbox_aux_4: 0.3616 (0.3616) loss_giou_aux_4: 1.9136 (1.9136) loss_fgl_aux_4: 0.4010 (0.4010) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1450 (0.1450) loss_bbox_pre: 0.3654 (0.3654) loss_giou_pre: 1.9190 (1.9190) loss_vfl_enc_0: 0.1447 (0.1447) loss_bbox_enc_0: 0.3797 (0.3797) loss_giou_enc_0: 1.9487 (1.9487) loss_vfl_dn_0: 0.3789 (0.3789) loss_bbox_dn_0: 0.0639 (0.0639) loss_giou_dn_0: 1.2970 (1.2970) loss_fgl_dn_0: 0.8480 (0.8480) loss_ddf_dn_0: 0.1521 (0.1521) loss_vfl_dn_1: 0.4048 (0.4048) loss_bbox_dn_1: 0.0600 (0.0600) loss_giou_dn_1: 1.2310 (1.2310) loss_fgl_dn_1: 0.8669 (0.8669) loss_ddf_dn_1: 0.0382 (0.0382) loss_vfl_dn_2: 0.4043 (0.4043) loss_bbox_dn_2: 0.0606 (0.0606) loss_giou_dn_2: 1.2256 (1.2256) loss_fgl_dn_2: 0.8612 (0.8612) loss_ddf_dn_2: 0.0052 (0.0052) loss_vfl_dn_3: 0.4004 (0.4004) loss_bbox_dn_3: 0.0599 (0.0599) loss_giou_dn_3: 1.2248 (1.2248) loss_fgl_dn_3: 0.8602 (0.8602) loss_ddf_dn_3: 0.0010 (0.0010) loss_vfl_dn_4: 0.3977 (0.3977) loss_bbox_dn_4: 0.0595 (0.0595) loss_giou_dn_4: 1.2254 (1.2254) loss_fgl_dn_4: 0.8594 (0.8594) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4043 (0.4043) loss_bbox_dn_5: 0.0593 (0.0593) loss_giou_dn_5: 1.2252 (1.2252) loss_fgl_dn_5: 0.8596 (0.8596) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3767 (0.3767) loss_bbox_dn_pre: 0.0632 (0.0632) loss_giou_dn_pre: 1.2999 (1.2999) time: 1.7947 data: 0.9162 max mem: 29821\n", + "Epoch: [12] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.1506 (39.4461) loss_vfl: 0.1425 (0.1644) loss_bbox: 0.3817 (0.3920) loss_giou: 1.9397 (1.9192) loss_fgl: 0.3340 (0.3648) loss_vfl_aux_0: 0.1405 (0.1614) loss_bbox_aux_0: 0.3809 (0.3936) loss_giou_aux_0: 1.9442 (1.9309) loss_fgl_aux_0: 0.3335 (0.3631) loss_ddf_aux_0: 0.0976 (0.1035) loss_vfl_aux_1: 0.1455 (0.1657) loss_bbox_aux_1: 0.3820 (0.3919) loss_giou_aux_1: 1.9393 (1.9213) loss_fgl_aux_1: 0.3327 (0.3641) loss_ddf_aux_1: 0.0172 (0.0179) loss_vfl_aux_2: 0.1431 (0.1645) loss_bbox_aux_2: 0.3816 (0.3920) loss_giou_aux_2: 1.9392 (1.9194) loss_fgl_aux_2: 0.3337 (0.3646) loss_ddf_aux_2: 0.0020 (0.0024) loss_vfl_aux_3: 0.1420 (0.1633) loss_bbox_aux_3: 0.3817 (0.3919) loss_giou_aux_3: 1.9397 (1.9193) loss_fgl_aux_3: 0.3340 (0.3647) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1428 (0.1636) loss_bbox_aux_4: 0.3817 (0.3920) loss_giou_aux_4: 1.9396 (1.9191) loss_fgl_aux_4: 0.3340 (0.3648) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1387 (0.1591) loss_bbox_pre: 0.3865 (0.3987) loss_giou_pre: 1.9398 (1.9241) loss_vfl_enc_0: 0.1152 (0.1470) loss_bbox_enc_0: 0.3962 (0.4155) loss_giou_enc_0: 1.9547 (1.9637) loss_vfl_dn_0: 0.3887 (0.3843) loss_bbox_dn_0: 0.0565 (0.0627) loss_giou_dn_0: 1.2750 (1.2761) loss_fgl_dn_0: 0.8583 (0.8597) loss_ddf_dn_0: 0.1324 (0.1444) loss_vfl_dn_1: 0.4253 (0.4200) loss_bbox_dn_1: 0.0516 (0.0562) loss_giou_dn_1: 1.2019 (1.2045) loss_fgl_dn_1: 0.8882 (0.8838) loss_ddf_dn_1: 0.0333 (0.0363) loss_vfl_dn_2: 0.4277 (0.4261) loss_bbox_dn_2: 0.0495 (0.0545) loss_giou_dn_2: 1.1750 (1.1850) loss_fgl_dn_2: 0.8917 (0.8896) loss_ddf_dn_2: 0.0035 (0.0044) loss_vfl_dn_3: 0.4255 (0.4227) loss_bbox_dn_3: 0.0493 (0.0541) loss_giou_dn_3: 1.1744 (1.1832) loss_fgl_dn_3: 0.8923 (0.8903) loss_ddf_dn_3: 0.0006 (0.0007) loss_vfl_dn_4: 0.4243 (0.4226) loss_bbox_dn_4: 0.0490 (0.0539) loss_giou_dn_4: 1.1747 (1.1828) loss_fgl_dn_4: 0.8928 (0.8906) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4255 (0.4240) loss_bbox_dn_5: 0.0490 (0.0539) loss_giou_dn_5: 1.1747 (1.1828) loss_fgl_dn_5: 0.8929 (0.8906) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3870 (0.3835) loss_bbox_dn_pre: 0.0561 (0.0621) loss_giou_dn_pre: 1.2737 (1.2768) time: 0.8972 data: 0.0167 max mem: 29821\n", + "Epoch: [12] Total time: 0:01:17 (0.9174 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.1506 (39.4461) loss_vfl: 0.1425 (0.1644) loss_bbox: 0.3817 (0.3920) loss_giou: 1.9397 (1.9192) loss_fgl: 0.3340 (0.3648) loss_vfl_aux_0: 0.1405 (0.1614) loss_bbox_aux_0: 0.3809 (0.3936) loss_giou_aux_0: 1.9442 (1.9309) loss_fgl_aux_0: 0.3335 (0.3631) loss_ddf_aux_0: 0.0976 (0.1035) loss_vfl_aux_1: 0.1455 (0.1657) loss_bbox_aux_1: 0.3820 (0.3919) loss_giou_aux_1: 1.9393 (1.9213) loss_fgl_aux_1: 0.3327 (0.3641) loss_ddf_aux_1: 0.0172 (0.0179) loss_vfl_aux_2: 0.1431 (0.1645) loss_bbox_aux_2: 0.3816 (0.3920) loss_giou_aux_2: 1.9392 (1.9194) loss_fgl_aux_2: 0.3337 (0.3646) loss_ddf_aux_2: 0.0020 (0.0024) loss_vfl_aux_3: 0.1420 (0.1633) loss_bbox_aux_3: 0.3817 (0.3919) loss_giou_aux_3: 1.9397 (1.9193) loss_fgl_aux_3: 0.3340 (0.3647) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1428 (0.1636) loss_bbox_aux_4: 0.3817 (0.3920) loss_giou_aux_4: 1.9396 (1.9191) loss_fgl_aux_4: 0.3340 (0.3648) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1387 (0.1591) loss_bbox_pre: 0.3865 (0.3987) loss_giou_pre: 1.9398 (1.9241) loss_vfl_enc_0: 0.1152 (0.1470) loss_bbox_enc_0: 0.3962 (0.4155) loss_giou_enc_0: 1.9547 (1.9637) loss_vfl_dn_0: 0.3887 (0.3843) loss_bbox_dn_0: 0.0565 (0.0627) loss_giou_dn_0: 1.2750 (1.2761) loss_fgl_dn_0: 0.8583 (0.8597) loss_ddf_dn_0: 0.1324 (0.1444) loss_vfl_dn_1: 0.4253 (0.4200) loss_bbox_dn_1: 0.0516 (0.0562) loss_giou_dn_1: 1.2019 (1.2045) loss_fgl_dn_1: 0.8882 (0.8838) loss_ddf_dn_1: 0.0333 (0.0363) loss_vfl_dn_2: 0.4277 (0.4261) loss_bbox_dn_2: 0.0495 (0.0545) loss_giou_dn_2: 1.1750 (1.1850) loss_fgl_dn_2: 0.8917 (0.8896) loss_ddf_dn_2: 0.0035 (0.0044) loss_vfl_dn_3: 0.4255 (0.4227) loss_bbox_dn_3: 0.0493 (0.0541) loss_giou_dn_3: 1.1744 (1.1832) loss_fgl_dn_3: 0.8923 (0.8903) loss_ddf_dn_3: 0.0006 (0.0007) loss_vfl_dn_4: 0.4243 (0.4226) loss_bbox_dn_4: 0.0490 (0.0539) loss_giou_dn_4: 1.1747 (1.1828) loss_fgl_dn_4: 0.8928 (0.8906) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4255 (0.4240) loss_bbox_dn_5: 0.0490 (0.0539) loss_giou_dn_5: 1.1747 (1.1828) loss_fgl_dn_5: 0.8929 (0.8906) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3870 (0.3835) loss_bbox_dn_pre: 0.0561 (0.0621) loss_giou_dn_pre: 1.2737 (1.2768)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7835 data: 0.5414 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3981 data: 0.1757 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4120 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.064\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.127\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.042\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.041\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.225\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.125\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.032\n", + "best_stat: {'epoch': 11, 'coco_eval_bbox': 0.013863723494761776}\n", + "Epoch: [13] [ 0/84] eta: 0:02:51 lr: 0.000013 loss: 37.5473 (37.5473) loss_vfl: 0.0947 (0.0947) loss_bbox: 0.3195 (0.3195) loss_giou: 1.8911 (1.8911) loss_fgl: 0.2954 (0.2954) loss_vfl_aux_0: 0.0919 (0.0919) loss_bbox_aux_0: 0.3166 (0.3166) loss_giou_aux_0: 1.8985 (1.8985) loss_fgl_aux_0: 0.2951 (0.2951) loss_ddf_aux_0: 0.0601 (0.0601) loss_vfl_aux_1: 0.0936 (0.0936) loss_bbox_aux_1: 0.3200 (0.3200) loss_giou_aux_1: 1.8931 (1.8931) loss_fgl_aux_1: 0.2949 (0.2949) loss_ddf_aux_1: 0.0081 (0.0081) loss_vfl_aux_2: 0.0940 (0.0940) loss_bbox_aux_2: 0.3198 (0.3198) loss_giou_aux_2: 1.8916 (1.8916) loss_fgl_aux_2: 0.2952 (0.2952) loss_ddf_aux_2: 0.0015 (0.0015) loss_vfl_aux_3: 0.0945 (0.0945) loss_bbox_aux_3: 0.3196 (0.3196) loss_giou_aux_3: 1.8913 (1.8913) loss_fgl_aux_3: 0.2954 (0.2954) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.0945 (0.0945) loss_bbox_aux_4: 0.3195 (0.3195) loss_giou_aux_4: 1.8911 (1.8911) loss_fgl_aux_4: 0.2954 (0.2954) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.0903 (0.0903) loss_bbox_pre: 0.3233 (0.3233) loss_giou_pre: 1.8935 (1.8935) loss_vfl_enc_0: 0.0831 (0.0831) loss_bbox_enc_0: 0.3322 (0.3322) loss_giou_enc_0: 1.9256 (1.9256) loss_vfl_dn_0: 0.3721 (0.3721) loss_bbox_dn_0: 0.0461 (0.0461) loss_giou_dn_0: 1.2900 (1.2900) loss_fgl_dn_0: 0.8485 (0.8485) loss_ddf_dn_0: 0.1217 (0.1217) loss_vfl_dn_1: 0.4192 (0.4192) loss_bbox_dn_1: 0.0394 (0.0394) loss_giou_dn_1: 1.2229 (1.2229) loss_fgl_dn_1: 0.8810 (0.8810) loss_ddf_dn_1: 0.0265 (0.0265) loss_vfl_dn_2: 0.4373 (0.4373) loss_bbox_dn_2: 0.0379 (0.0379) loss_giou_dn_2: 1.2136 (1.2136) loss_fgl_dn_2: 0.8848 (0.8848) loss_ddf_dn_2: 0.0025 (0.0025) loss_vfl_dn_3: 0.4207 (0.4207) loss_bbox_dn_3: 0.0376 (0.0376) loss_giou_dn_3: 1.2133 (1.2133) loss_fgl_dn_3: 0.8850 (0.8850) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4214 (0.4214) loss_bbox_dn_4: 0.0371 (0.0371) loss_giou_dn_4: 1.2130 (1.2130) loss_fgl_dn_4: 0.8850 (0.8850) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4231 (0.4231) loss_bbox_dn_5: 0.0370 (0.0370) loss_giou_dn_5: 1.2129 (1.2129) loss_fgl_dn_5: 0.8850 (0.8850) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3721 (0.3721) loss_bbox_dn_pre: 0.0459 (0.0459) loss_giou_dn_pre: 1.2895 (1.2895) time: 2.0465 data: 0.8869 max mem: 29821\n", + "Epoch: [13] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.4332 (39.4129) loss_vfl: 0.1521 (0.1535) loss_bbox: 0.3916 (0.3883) loss_giou: 1.9373 (1.9354) loss_fgl: 0.3329 (0.3572) loss_vfl_aux_0: 0.1476 (0.1509) loss_bbox_aux_0: 0.3851 (0.3881) loss_giou_aux_0: 1.9582 (1.9485) loss_fgl_aux_0: 0.3317 (0.3559) loss_ddf_aux_0: 0.0831 (0.1041) loss_vfl_aux_1: 0.1541 (0.1551) loss_bbox_aux_1: 0.3880 (0.3882) loss_giou_aux_1: 1.9389 (1.9375) loss_fgl_aux_1: 0.3326 (0.3565) loss_ddf_aux_1: 0.0135 (0.0164) loss_vfl_aux_2: 0.1481 (0.1539) loss_bbox_aux_2: 0.3918 (0.3885) loss_giou_aux_2: 1.9380 (1.9355) loss_fgl_aux_2: 0.3327 (0.3569) loss_ddf_aux_2: 0.0020 (0.0024) loss_vfl_aux_3: 0.1455 (0.1528) loss_bbox_aux_3: 0.3922 (0.3884) loss_giou_aux_3: 1.9377 (1.9354) loss_fgl_aux_3: 0.3329 (0.3570) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1436 (0.1527) loss_bbox_aux_4: 0.3918 (0.3883) loss_giou_aux_4: 1.9373 (1.9353) loss_fgl_aux_4: 0.3329 (0.3571) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1447 (0.1485) loss_bbox_pre: 0.3916 (0.3941) loss_giou_pre: 1.9510 (1.9401) loss_vfl_enc_0: 0.1326 (0.1376) loss_bbox_enc_0: 0.4138 (0.4115) loss_giou_enc_0: 1.9806 (1.9710) loss_vfl_dn_0: 0.3713 (0.3852) loss_bbox_dn_0: 0.0556 (0.0593) loss_giou_dn_0: 1.3172 (1.2788) loss_fgl_dn_0: 0.8391 (0.8621) loss_ddf_dn_0: 0.1400 (0.1404) loss_vfl_dn_1: 0.4136 (0.4201) loss_bbox_dn_1: 0.0506 (0.0532) loss_giou_dn_1: 1.2206 (1.2108) loss_fgl_dn_1: 0.8624 (0.8830) loss_ddf_dn_1: 0.0359 (0.0340) loss_vfl_dn_2: 0.4202 (0.4254) loss_bbox_dn_2: 0.0487 (0.0512) loss_giou_dn_2: 1.1924 (1.1916) loss_fgl_dn_2: 0.8728 (0.8889) loss_ddf_dn_2: 0.0043 (0.0043) loss_vfl_dn_3: 0.4214 (0.4224) loss_bbox_dn_3: 0.0483 (0.0508) loss_giou_dn_3: 1.1923 (1.1902) loss_fgl_dn_3: 0.8737 (0.8896) loss_ddf_dn_3: 0.0009 (0.0008) loss_vfl_dn_4: 0.4209 (0.4222) loss_bbox_dn_4: 0.0479 (0.0506) loss_giou_dn_4: 1.1924 (1.1897) loss_fgl_dn_4: 0.8743 (0.8899) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4214 (0.4226) loss_bbox_dn_5: 0.0478 (0.0506) loss_giou_dn_5: 1.1924 (1.1897) loss_fgl_dn_5: 0.8745 (0.8899) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3711 (0.3845) loss_bbox_dn_pre: 0.0545 (0.0591) loss_giou_dn_pre: 1.3173 (1.2789) time: 0.8724 data: 0.0184 max mem: 29821\n", + "Epoch: [13] Total time: 0:01:16 (0.9123 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.4332 (39.4129) loss_vfl: 0.1521 (0.1535) loss_bbox: 0.3916 (0.3883) loss_giou: 1.9373 (1.9354) loss_fgl: 0.3329 (0.3572) loss_vfl_aux_0: 0.1476 (0.1509) loss_bbox_aux_0: 0.3851 (0.3881) loss_giou_aux_0: 1.9582 (1.9485) loss_fgl_aux_0: 0.3317 (0.3559) loss_ddf_aux_0: 0.0831 (0.1041) loss_vfl_aux_1: 0.1541 (0.1551) loss_bbox_aux_1: 0.3880 (0.3882) loss_giou_aux_1: 1.9389 (1.9375) loss_fgl_aux_1: 0.3326 (0.3565) loss_ddf_aux_1: 0.0135 (0.0164) loss_vfl_aux_2: 0.1481 (0.1539) loss_bbox_aux_2: 0.3918 (0.3885) loss_giou_aux_2: 1.9380 (1.9355) loss_fgl_aux_2: 0.3327 (0.3569) loss_ddf_aux_2: 0.0020 (0.0024) loss_vfl_aux_3: 0.1455 (0.1528) loss_bbox_aux_3: 0.3922 (0.3884) loss_giou_aux_3: 1.9377 (1.9354) loss_fgl_aux_3: 0.3329 (0.3570) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1436 (0.1527) loss_bbox_aux_4: 0.3918 (0.3883) loss_giou_aux_4: 1.9373 (1.9353) loss_fgl_aux_4: 0.3329 (0.3571) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1447 (0.1485) loss_bbox_pre: 0.3916 (0.3941) loss_giou_pre: 1.9510 (1.9401) loss_vfl_enc_0: 0.1326 (0.1376) loss_bbox_enc_0: 0.4138 (0.4115) loss_giou_enc_0: 1.9806 (1.9710) loss_vfl_dn_0: 0.3713 (0.3852) loss_bbox_dn_0: 0.0556 (0.0593) loss_giou_dn_0: 1.3172 (1.2788) loss_fgl_dn_0: 0.8391 (0.8621) loss_ddf_dn_0: 0.1400 (0.1404) loss_vfl_dn_1: 0.4136 (0.4201) loss_bbox_dn_1: 0.0506 (0.0532) loss_giou_dn_1: 1.2206 (1.2108) loss_fgl_dn_1: 0.8624 (0.8830) loss_ddf_dn_1: 0.0359 (0.0340) loss_vfl_dn_2: 0.4202 (0.4254) loss_bbox_dn_2: 0.0487 (0.0512) loss_giou_dn_2: 1.1924 (1.1916) loss_fgl_dn_2: 0.8728 (0.8889) loss_ddf_dn_2: 0.0043 (0.0043) loss_vfl_dn_3: 0.4214 (0.4224) loss_bbox_dn_3: 0.0483 (0.0508) loss_giou_dn_3: 1.1923 (1.1902) loss_fgl_dn_3: 0.8737 (0.8896) loss_ddf_dn_3: 0.0009 (0.0008) loss_vfl_dn_4: 0.4209 (0.4222) loss_bbox_dn_4: 0.0479 (0.0506) loss_giou_dn_4: 1.1924 (1.1897) loss_fgl_dn_4: 0.8743 (0.8899) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4214 (0.4226) loss_bbox_dn_5: 0.0478 (0.0506) loss_giou_dn_5: 1.1924 (1.1897) loss_fgl_dn_5: 0.8745 (0.8899) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3711 (0.3845) loss_bbox_dn_pre: 0.0545 (0.0591) loss_giou_dn_pre: 1.3173 (1.2789)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7698 data: 0.5274 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3904 data: 0.1704 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4058 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.085\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.320\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.025\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.033\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.033\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.176\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.775\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.022\n", + "best_stat: {'epoch': 11, 'coco_eval_bbox': 0.013863723494761776}\n", + "Epoch: [14] [ 0/84] eta: 0:02:43 lr: 0.000013 loss: 39.4087 (39.4087) loss_vfl: 0.0861 (0.0861) loss_bbox: 0.3572 (0.3572) loss_giou: 2.1871 (2.1871) loss_fgl: 0.1883 (0.1883) loss_vfl_aux_0: 0.0834 (0.0834) loss_bbox_aux_0: 0.3520 (0.3520) loss_giou_aux_0: 2.2010 (2.2010) loss_fgl_aux_0: 0.1891 (0.1891) loss_ddf_aux_0: 0.0512 (0.0512) loss_vfl_aux_1: 0.0880 (0.0880) loss_bbox_aux_1: 0.3530 (0.3530) loss_giou_aux_1: 2.1963 (2.1963) loss_fgl_aux_1: 0.1891 (0.1891) loss_ddf_aux_1: 0.0118 (0.0118) loss_vfl_aux_2: 0.0875 (0.0875) loss_bbox_aux_2: 0.3567 (0.3567) loss_giou_aux_2: 2.1869 (2.1869) loss_fgl_aux_2: 0.1884 (0.1884) loss_ddf_aux_2: 0.0018 (0.0018) loss_vfl_aux_3: 0.0820 (0.0820) loss_bbox_aux_3: 0.3573 (0.3573) loss_giou_aux_3: 2.1863 (2.1863) loss_fgl_aux_3: 0.1883 (0.1883) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.0829 (0.0829) loss_bbox_aux_4: 0.3573 (0.3573) loss_giou_aux_4: 2.1869 (2.1869) loss_fgl_aux_4: 0.1883 (0.1883) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0815 (0.0815) loss_bbox_pre: 0.3578 (0.3578) loss_giou_pre: 2.1848 (2.1848) loss_vfl_enc_0: 0.0717 (0.0717) loss_bbox_enc_0: 0.3723 (0.3723) loss_giou_enc_0: 2.2324 (2.2324) loss_vfl_dn_0: 0.3467 (0.3467) loss_bbox_dn_0: 0.0461 (0.0461) loss_giou_dn_0: 1.3587 (1.3587) loss_fgl_dn_0: 0.7933 (0.7933) loss_ddf_dn_0: 0.1506 (0.1506) loss_vfl_dn_1: 0.3982 (0.3982) loss_bbox_dn_1: 0.0388 (0.0388) loss_giou_dn_1: 1.2688 (1.2688) loss_fgl_dn_1: 0.8319 (0.8319) loss_ddf_dn_1: 0.0689 (0.0689) loss_vfl_dn_2: 0.4102 (0.4102) loss_bbox_dn_2: 0.0394 (0.0394) loss_giou_dn_2: 1.2345 (1.2345) loss_fgl_dn_2: 0.8309 (0.8309) loss_ddf_dn_2: 0.0045 (0.0045) loss_vfl_dn_3: 0.4104 (0.4104) loss_bbox_dn_3: 0.0398 (0.0398) loss_giou_dn_3: 1.2380 (1.2380) loss_fgl_dn_3: 0.8283 (0.8283) loss_ddf_dn_3: 0.0009 (0.0009) loss_vfl_dn_4: 0.4131 (0.4131) loss_bbox_dn_4: 0.0397 (0.0397) loss_giou_dn_4: 1.2382 (1.2382) loss_fgl_dn_4: 0.8284 (0.8284) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4121 (0.4121) loss_bbox_dn_5: 0.0397 (0.0397) loss_giou_dn_5: 1.2383 (1.2383) loss_fgl_dn_5: 0.8285 (0.8285) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3518 (0.3518) loss_bbox_dn_pre: 0.0442 (0.0442) loss_giou_dn_pre: 1.3504 (1.3504) time: 1.9518 data: 0.9244 max mem: 29821\n", + "Epoch: [14] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.8574 (39.0711) loss_vfl: 0.1434 (0.1584) loss_bbox: 0.3352 (0.3641) loss_giou: 1.9194 (1.9082) loss_fgl: 0.3218 (0.3527) loss_vfl_aux_0: 0.1320 (0.1545) loss_bbox_aux_0: 0.3460 (0.3657) loss_giou_aux_0: 1.9239 (1.9215) loss_fgl_aux_0: 0.3184 (0.3502) loss_ddf_aux_0: 0.1230 (0.1316) loss_vfl_aux_1: 0.1440 (0.1594) loss_bbox_aux_1: 0.3451 (0.3644) loss_giou_aux_1: 1.9178 (1.9102) loss_fgl_aux_1: 0.3197 (0.3515) loss_ddf_aux_1: 0.0254 (0.0221) loss_vfl_aux_2: 0.1472 (0.1610) loss_bbox_aux_2: 0.3366 (0.3642) loss_giou_aux_2: 1.9190 (1.9083) loss_fgl_aux_2: 0.3211 (0.3524) loss_ddf_aux_2: 0.0031 (0.0028) loss_vfl_aux_3: 0.1420 (0.1580) loss_bbox_aux_3: 0.3354 (0.3642) loss_giou_aux_3: 1.9194 (1.9081) loss_fgl_aux_3: 0.3216 (0.3526) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1423 (0.1579) loss_bbox_aux_4: 0.3353 (0.3642) loss_giou_aux_4: 1.9193 (1.9081) loss_fgl_aux_4: 0.3218 (0.3527) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1267 (0.1519) loss_bbox_pre: 0.3521 (0.3712) loss_giou_pre: 1.9164 (1.9146) loss_vfl_enc_0: 0.1230 (0.1407) loss_bbox_enc_0: 0.3746 (0.3879) loss_giou_enc_0: 1.9439 (1.9536) loss_vfl_dn_0: 0.3921 (0.3875) loss_bbox_dn_0: 0.0565 (0.0590) loss_giou_dn_0: 1.2447 (1.2684) loss_fgl_dn_0: 0.8689 (0.8667) loss_ddf_dn_0: 0.1263 (0.1653) loss_vfl_dn_1: 0.4148 (0.4201) loss_bbox_dn_1: 0.0511 (0.0532) loss_giou_dn_1: 1.2041 (1.2038) loss_fgl_dn_1: 0.8797 (0.8842) loss_ddf_dn_1: 0.0425 (0.0496) loss_vfl_dn_2: 0.4312 (0.4316) loss_bbox_dn_2: 0.0478 (0.0508) loss_giou_dn_2: 1.1895 (1.1812) loss_fgl_dn_2: 0.8907 (0.8926) loss_ddf_dn_2: 0.0045 (0.0049) loss_vfl_dn_3: 0.4202 (0.4257) loss_bbox_dn_3: 0.0476 (0.0505) loss_giou_dn_3: 1.1901 (1.1800) loss_fgl_dn_3: 0.8923 (0.8932) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4146 (0.4251) loss_bbox_dn_4: 0.0474 (0.0503) loss_giou_dn_4: 1.1897 (1.1797) loss_fgl_dn_4: 0.8928 (0.8935) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4153 (0.4262) loss_bbox_dn_5: 0.0473 (0.0503) loss_giou_dn_5: 1.1896 (1.1797) loss_fgl_dn_5: 0.8929 (0.8936) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3938 (0.3872) loss_bbox_dn_pre: 0.0556 (0.0587) loss_giou_dn_pre: 1.2472 (1.2678) time: 0.8812 data: 0.0195 max mem: 29821\n", + "Epoch: [14] Total time: 0:01:16 (0.9078 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.8574 (39.0711) loss_vfl: 0.1434 (0.1584) loss_bbox: 0.3352 (0.3641) loss_giou: 1.9194 (1.9082) loss_fgl: 0.3218 (0.3527) loss_vfl_aux_0: 0.1320 (0.1545) loss_bbox_aux_0: 0.3460 (0.3657) loss_giou_aux_0: 1.9239 (1.9215) loss_fgl_aux_0: 0.3184 (0.3502) loss_ddf_aux_0: 0.1230 (0.1316) loss_vfl_aux_1: 0.1440 (0.1594) loss_bbox_aux_1: 0.3451 (0.3644) loss_giou_aux_1: 1.9178 (1.9102) loss_fgl_aux_1: 0.3197 (0.3515) loss_ddf_aux_1: 0.0254 (0.0221) loss_vfl_aux_2: 0.1472 (0.1610) loss_bbox_aux_2: 0.3366 (0.3642) loss_giou_aux_2: 1.9190 (1.9083) loss_fgl_aux_2: 0.3211 (0.3524) loss_ddf_aux_2: 0.0031 (0.0028) loss_vfl_aux_3: 0.1420 (0.1580) loss_bbox_aux_3: 0.3354 (0.3642) loss_giou_aux_3: 1.9194 (1.9081) loss_fgl_aux_3: 0.3216 (0.3526) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1423 (0.1579) loss_bbox_aux_4: 0.3353 (0.3642) loss_giou_aux_4: 1.9193 (1.9081) loss_fgl_aux_4: 0.3218 (0.3527) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1267 (0.1519) loss_bbox_pre: 0.3521 (0.3712) loss_giou_pre: 1.9164 (1.9146) loss_vfl_enc_0: 0.1230 (0.1407) loss_bbox_enc_0: 0.3746 (0.3879) loss_giou_enc_0: 1.9439 (1.9536) loss_vfl_dn_0: 0.3921 (0.3875) loss_bbox_dn_0: 0.0565 (0.0590) loss_giou_dn_0: 1.2447 (1.2684) loss_fgl_dn_0: 0.8689 (0.8667) loss_ddf_dn_0: 0.1263 (0.1653) loss_vfl_dn_1: 0.4148 (0.4201) loss_bbox_dn_1: 0.0511 (0.0532) loss_giou_dn_1: 1.2041 (1.2038) loss_fgl_dn_1: 0.8797 (0.8842) loss_ddf_dn_1: 0.0425 (0.0496) loss_vfl_dn_2: 0.4312 (0.4316) loss_bbox_dn_2: 0.0478 (0.0508) loss_giou_dn_2: 1.1895 (1.1812) loss_fgl_dn_2: 0.8907 (0.8926) loss_ddf_dn_2: 0.0045 (0.0049) loss_vfl_dn_3: 0.4202 (0.4257) loss_bbox_dn_3: 0.0476 (0.0505) loss_giou_dn_3: 1.1901 (1.1800) loss_fgl_dn_3: 0.8923 (0.8932) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4146 (0.4251) loss_bbox_dn_4: 0.0474 (0.0503) loss_giou_dn_4: 1.1897 (1.1797) loss_fgl_dn_4: 0.8928 (0.8935) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4153 (0.4262) loss_bbox_dn_5: 0.0473 (0.0503) loss_giou_dn_5: 1.1896 (1.1797) loss_fgl_dn_5: 0.8929 (0.8936) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3938 (0.3872) loss_bbox_dn_pre: 0.0556 (0.0587) loss_giou_dn_pre: 1.2472 (1.2678)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7347 data: 0.4916 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3901 data: 0.1646 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4075 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.045\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.013\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.137\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.099\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.050\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.069\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.065\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.335\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.450\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.155\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.046\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [15] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 38.8573 (38.8573) loss_vfl: 0.1042 (0.1042) loss_bbox: 0.4804 (0.4804) loss_giou: 1.7753 (1.7753) loss_fgl: 0.4471 (0.4471) loss_vfl_aux_0: 0.1088 (0.1088) loss_bbox_aux_0: 0.4933 (0.4933) loss_giou_aux_0: 1.7808 (1.7808) loss_fgl_aux_0: 0.4353 (0.4353) loss_ddf_aux_0: 0.2667 (0.2667) loss_vfl_aux_1: 0.1098 (0.1098) loss_bbox_aux_1: 0.4830 (0.4830) loss_giou_aux_1: 1.7715 (1.7715) loss_fgl_aux_1: 0.4408 (0.4408) loss_ddf_aux_1: 0.0490 (0.0490) loss_vfl_aux_2: 0.1096 (0.1096) loss_bbox_aux_2: 0.4800 (0.4800) loss_giou_aux_2: 1.7725 (1.7725) loss_fgl_aux_2: 0.4449 (0.4449) loss_ddf_aux_2: 0.0076 (0.0076) loss_vfl_aux_3: 0.1018 (0.1018) loss_bbox_aux_3: 0.4801 (0.4801) loss_giou_aux_3: 1.7748 (1.7748) loss_fgl_aux_3: 0.4467 (0.4467) loss_ddf_aux_3: 0.0008 (0.0008) loss_vfl_aux_4: 0.1027 (0.1027) loss_bbox_aux_4: 0.4804 (0.4804) loss_giou_aux_4: 1.7752 (1.7752) loss_fgl_aux_4: 0.4471 (0.4471) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1071 (0.1071) loss_bbox_pre: 0.4984 (0.4984) loss_giou_pre: 1.7777 (1.7777) loss_vfl_enc_0: 0.1049 (0.1049) loss_bbox_enc_0: 0.5147 (0.5147) loss_giou_enc_0: 1.8362 (1.8362) loss_vfl_dn_0: 0.3601 (0.3601) loss_bbox_dn_0: 0.0400 (0.0400) loss_giou_dn_0: 1.2941 (1.2941) loss_fgl_dn_0: 0.8176 (0.8176) loss_ddf_dn_0: 0.1108 (0.1108) loss_vfl_dn_1: 0.4158 (0.4158) loss_bbox_dn_1: 0.0373 (0.0373) loss_giou_dn_1: 1.2373 (1.2373) loss_fgl_dn_1: 0.8226 (0.8226) loss_ddf_dn_1: 0.0281 (0.0281) loss_vfl_dn_2: 0.4377 (0.4377) loss_bbox_dn_2: 0.0370 (0.0370) loss_giou_dn_2: 1.2326 (1.2326) loss_fgl_dn_2: 0.8262 (0.8262) loss_ddf_dn_2: 0.0039 (0.0039) loss_vfl_dn_3: 0.3867 (0.3867) loss_bbox_dn_3: 0.0368 (0.0368) loss_giou_dn_3: 1.2317 (1.2317) loss_fgl_dn_3: 0.8291 (0.8291) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.3877 (0.3877) loss_bbox_dn_4: 0.0367 (0.0367) loss_giou_dn_4: 1.2312 (1.2312) loss_fgl_dn_4: 0.8299 (0.8299) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.3879 (0.3879) loss_bbox_dn_5: 0.0366 (0.0366) loss_giou_dn_5: 1.2311 (1.2311) loss_fgl_dn_5: 0.8300 (0.8300) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3623 (0.3623) loss_bbox_dn_pre: 0.0397 (0.0397) loss_giou_dn_pre: 1.2887 (1.2887) time: 1.8185 data: 0.7951 max mem: 29821\n", + "Epoch: [15] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.7254 (39.5323) loss_vfl: 0.1516 (0.1531) loss_bbox: 0.3656 (0.4067) loss_giou: 1.9061 (1.9372) loss_fgl: 0.3191 (0.3474) loss_vfl_aux_0: 0.1459 (0.1496) loss_bbox_aux_0: 0.3696 (0.4087) loss_giou_aux_0: 1.9093 (1.9495) loss_fgl_aux_0: 0.3114 (0.3452) loss_ddf_aux_0: 0.0972 (0.1163) loss_vfl_aux_1: 0.1517 (0.1541) loss_bbox_aux_1: 0.3653 (0.4062) loss_giou_aux_1: 1.9066 (1.9391) loss_fgl_aux_1: 0.3178 (0.3467) loss_ddf_aux_1: 0.0098 (0.0151) loss_vfl_aux_2: 0.1498 (0.1535) loss_bbox_aux_2: 0.3654 (0.4067) loss_giou_aux_2: 1.9051 (1.9373) loss_fgl_aux_2: 0.3189 (0.3472) loss_ddf_aux_2: 0.0015 (0.0023) loss_vfl_aux_3: 0.1532 (0.1531) loss_bbox_aux_3: 0.3655 (0.4067) loss_giou_aux_3: 1.9054 (1.9371) loss_fgl_aux_3: 0.3190 (0.3473) loss_ddf_aux_3: 0.0003 (0.0005) loss_vfl_aux_4: 0.1517 (0.1526) loss_bbox_aux_4: 0.3656 (0.4067) loss_giou_aux_4: 1.9059 (1.9371) loss_fgl_aux_4: 0.3191 (0.3474) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1432 (0.1476) loss_bbox_pre: 0.3764 (0.4132) loss_giou_pre: 1.9057 (1.9441) loss_vfl_enc_0: 0.1282 (0.1375) loss_bbox_enc_0: 0.3923 (0.4306) loss_giou_enc_0: 1.9546 (1.9827) loss_vfl_dn_0: 0.3657 (0.3779) loss_bbox_dn_0: 0.0586 (0.0587) loss_giou_dn_0: 1.3268 (1.3040) loss_fgl_dn_0: 0.8268 (0.8491) loss_ddf_dn_0: 0.2053 (0.1692) loss_vfl_dn_1: 0.4216 (0.4204) loss_bbox_dn_1: 0.0479 (0.0511) loss_giou_dn_1: 1.2034 (1.2084) loss_fgl_dn_1: 0.8643 (0.8737) loss_ddf_dn_1: 0.0340 (0.0337) loss_vfl_dn_2: 0.4336 (0.4282) loss_bbox_dn_2: 0.0458 (0.0496) loss_giou_dn_2: 1.1802 (1.1933) loss_fgl_dn_2: 0.8746 (0.8792) loss_ddf_dn_2: 0.0047 (0.0045) loss_vfl_dn_3: 0.4275 (0.4204) loss_bbox_dn_3: 0.0451 (0.0492) loss_giou_dn_3: 1.1775 (1.1921) loss_fgl_dn_3: 0.8756 (0.8797) loss_ddf_dn_3: 0.0008 (0.0010) loss_vfl_dn_4: 0.4287 (0.4203) loss_bbox_dn_4: 0.0449 (0.0490) loss_giou_dn_4: 1.1770 (1.1914) loss_fgl_dn_4: 0.8759 (0.8801) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4253 (0.4211) loss_bbox_dn_5: 0.0449 (0.0490) loss_giou_dn_5: 1.1771 (1.1914) loss_fgl_dn_5: 0.8760 (0.8802) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3645 (0.3765) loss_bbox_dn_pre: 0.0585 (0.0584) loss_giou_dn_pre: 1.3288 (1.3050) time: 0.9085 data: 0.0181 max mem: 29821\n", + "Epoch: [15] Total time: 0:01:16 (0.9160 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.7254 (39.5323) loss_vfl: 0.1516 (0.1531) loss_bbox: 0.3656 (0.4067) loss_giou: 1.9061 (1.9372) loss_fgl: 0.3191 (0.3474) loss_vfl_aux_0: 0.1459 (0.1496) loss_bbox_aux_0: 0.3696 (0.4087) loss_giou_aux_0: 1.9093 (1.9495) loss_fgl_aux_0: 0.3114 (0.3452) loss_ddf_aux_0: 0.0972 (0.1163) loss_vfl_aux_1: 0.1517 (0.1541) loss_bbox_aux_1: 0.3653 (0.4062) loss_giou_aux_1: 1.9066 (1.9391) loss_fgl_aux_1: 0.3178 (0.3467) loss_ddf_aux_1: 0.0098 (0.0151) loss_vfl_aux_2: 0.1498 (0.1535) loss_bbox_aux_2: 0.3654 (0.4067) loss_giou_aux_2: 1.9051 (1.9373) loss_fgl_aux_2: 0.3189 (0.3472) loss_ddf_aux_2: 0.0015 (0.0023) loss_vfl_aux_3: 0.1532 (0.1531) loss_bbox_aux_3: 0.3655 (0.4067) loss_giou_aux_3: 1.9054 (1.9371) loss_fgl_aux_3: 0.3190 (0.3473) loss_ddf_aux_3: 0.0003 (0.0005) loss_vfl_aux_4: 0.1517 (0.1526) loss_bbox_aux_4: 0.3656 (0.4067) loss_giou_aux_4: 1.9059 (1.9371) loss_fgl_aux_4: 0.3191 (0.3474) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1432 (0.1476) loss_bbox_pre: 0.3764 (0.4132) loss_giou_pre: 1.9057 (1.9441) loss_vfl_enc_0: 0.1282 (0.1375) loss_bbox_enc_0: 0.3923 (0.4306) loss_giou_enc_0: 1.9546 (1.9827) loss_vfl_dn_0: 0.3657 (0.3779) loss_bbox_dn_0: 0.0586 (0.0587) loss_giou_dn_0: 1.3268 (1.3040) loss_fgl_dn_0: 0.8268 (0.8491) loss_ddf_dn_0: 0.2053 (0.1692) loss_vfl_dn_1: 0.4216 (0.4204) loss_bbox_dn_1: 0.0479 (0.0511) loss_giou_dn_1: 1.2034 (1.2084) loss_fgl_dn_1: 0.8643 (0.8737) loss_ddf_dn_1: 0.0340 (0.0337) loss_vfl_dn_2: 0.4336 (0.4282) loss_bbox_dn_2: 0.0458 (0.0496) loss_giou_dn_2: 1.1802 (1.1933) loss_fgl_dn_2: 0.8746 (0.8792) loss_ddf_dn_2: 0.0047 (0.0045) loss_vfl_dn_3: 0.4275 (0.4204) loss_bbox_dn_3: 0.0451 (0.0492) loss_giou_dn_3: 1.1775 (1.1921) loss_fgl_dn_3: 0.8756 (0.8797) loss_ddf_dn_3: 0.0008 (0.0010) loss_vfl_dn_4: 0.4287 (0.4203) loss_bbox_dn_4: 0.0449 (0.0490) loss_giou_dn_4: 1.1770 (1.1914) loss_fgl_dn_4: 0.8759 (0.8801) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4253 (0.4211) loss_bbox_dn_5: 0.0449 (0.0490) loss_giou_dn_5: 1.1771 (1.1914) loss_fgl_dn_5: 0.8760 (0.8802) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3645 (0.3765) loss_bbox_dn_pre: 0.0585 (0.0584) loss_giou_dn_pre: 1.3288 (1.3050)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7641 data: 0.5235 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3955 data: 0.1727 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4102 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.003\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.032\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.056\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.126\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.075\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.114\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.029\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [16] [ 0/84] eta: 0:02:58 lr: 0.000013 loss: 40.3817 (40.3817) loss_vfl: 0.1763 (0.1763) loss_bbox: 0.4278 (0.4278) loss_giou: 2.0710 (2.0710) loss_fgl: 0.2943 (0.2943) loss_vfl_aux_0: 0.1729 (0.1729) loss_bbox_aux_0: 0.4379 (0.4379) loss_giou_aux_0: 2.0671 (2.0671) loss_fgl_aux_0: 0.2898 (0.2898) loss_ddf_aux_0: 0.0439 (0.0439) loss_vfl_aux_1: 0.1840 (0.1840) loss_bbox_aux_1: 0.4268 (0.4268) loss_giou_aux_1: 2.0717 (2.0717) loss_fgl_aux_1: 0.2945 (0.2945) loss_ddf_aux_1: 0.0058 (0.0058) loss_vfl_aux_2: 0.1847 (0.1847) loss_bbox_aux_2: 0.4282 (0.4282) loss_giou_aux_2: 2.0700 (2.0700) loss_fgl_aux_2: 0.2941 (0.2941) loss_ddf_aux_2: 0.0012 (0.0012) loss_vfl_aux_3: 0.1826 (0.1826) loss_bbox_aux_3: 0.4281 (0.4281) loss_giou_aux_3: 2.0704 (2.0704) loss_fgl_aux_3: 0.2942 (0.2942) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1782 (0.1782) loss_bbox_aux_4: 0.4279 (0.4279) loss_giou_aux_4: 2.0709 (2.0709) loss_fgl_aux_4: 0.2943 (0.2943) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1682 (0.1682) loss_bbox_pre: 0.4450 (0.4450) loss_giou_pre: 2.0618 (2.0618) loss_vfl_enc_0: 0.1597 (0.1597) loss_bbox_enc_0: 0.4619 (0.4619) loss_giou_enc_0: 2.0796 (2.0796) loss_vfl_dn_0: 0.3555 (0.3555) loss_bbox_dn_0: 0.0521 (0.0521) loss_giou_dn_0: 1.3261 (1.3261) loss_fgl_dn_0: 0.8251 (0.8251) loss_ddf_dn_0: 0.2397 (0.2397) loss_vfl_dn_1: 0.4255 (0.4255) loss_bbox_dn_1: 0.0426 (0.0426) loss_giou_dn_1: 1.1862 (1.1862) loss_fgl_dn_1: 0.8615 (0.8615) loss_ddf_dn_1: 0.0513 (0.0513) loss_vfl_dn_2: 0.4216 (0.4216) loss_bbox_dn_2: 0.0415 (0.0415) loss_giou_dn_2: 1.1696 (1.1696) loss_fgl_dn_2: 0.8652 (0.8652) loss_ddf_dn_2: 0.0058 (0.0058) loss_vfl_dn_3: 0.4275 (0.4275) loss_bbox_dn_3: 0.0411 (0.0411) loss_giou_dn_3: 1.1669 (1.1669) loss_fgl_dn_3: 0.8665 (0.8665) loss_ddf_dn_3: 0.0011 (0.0011) loss_vfl_dn_4: 0.4312 (0.4312) loss_bbox_dn_4: 0.0410 (0.0410) loss_giou_dn_4: 1.1668 (1.1668) loss_fgl_dn_4: 0.8668 (0.8668) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4321 (0.4321) loss_bbox_dn_5: 0.0410 (0.0410) loss_giou_dn_5: 1.1669 (1.1669) loss_fgl_dn_5: 0.8668 (0.8668) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3577 (0.3577) loss_bbox_dn_pre: 0.0504 (0.0504) loss_giou_dn_pre: 1.3230 (1.3230) time: 2.1225 data: 1.0782 max mem: 29821\n", + "Epoch: [16] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5950 (38.7666) loss_vfl: 0.1389 (0.1535) loss_bbox: 0.3014 (0.3448) loss_giou: 1.8792 (1.9063) loss_fgl: 0.3714 (0.3571) loss_vfl_aux_0: 0.1320 (0.1511) loss_bbox_aux_0: 0.3102 (0.3464) loss_giou_aux_0: 1.8883 (1.9178) loss_fgl_aux_0: 0.3671 (0.3554) loss_ddf_aux_0: 0.0804 (0.0968) loss_vfl_aux_1: 0.1495 (0.1563) loss_bbox_aux_1: 0.3046 (0.3452) loss_giou_aux_1: 1.8838 (1.9081) loss_fgl_aux_1: 0.3702 (0.3563) loss_ddf_aux_1: 0.0177 (0.0140) loss_vfl_aux_2: 0.1398 (0.1535) loss_bbox_aux_2: 0.3032 (0.3451) loss_giou_aux_2: 1.8800 (1.9064) loss_fgl_aux_2: 0.3713 (0.3568) loss_ddf_aux_2: 0.0031 (0.0024) loss_vfl_aux_3: 0.1395 (0.1524) loss_bbox_aux_3: 0.3020 (0.3448) loss_giou_aux_3: 1.8793 (1.9062) loss_fgl_aux_3: 0.3713 (0.3570) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1378 (0.1525) loss_bbox_aux_4: 0.3015 (0.3448) loss_giou_aux_4: 1.8792 (1.9063) loss_fgl_aux_4: 0.3713 (0.3571) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1293 (0.1485) loss_bbox_pre: 0.3155 (0.3521) loss_giou_pre: 1.8834 (1.9103) loss_vfl_enc_0: 0.1255 (0.1390) loss_bbox_enc_0: 0.3229 (0.3728) loss_giou_enc_0: 1.9199 (1.9452) loss_vfl_dn_0: 0.3918 (0.3830) loss_bbox_dn_0: 0.0551 (0.0587) loss_giou_dn_0: 1.2608 (1.2737) loss_fgl_dn_0: 0.8802 (0.8605) loss_ddf_dn_0: 0.1700 (0.1766) loss_vfl_dn_1: 0.4233 (0.4277) loss_bbox_dn_1: 0.0465 (0.0506) loss_giou_dn_1: 1.1888 (1.1843) loss_fgl_dn_1: 0.8917 (0.8883) loss_ddf_dn_1: 0.0451 (0.0371) loss_vfl_dn_2: 0.4333 (0.4328) loss_bbox_dn_2: 0.0446 (0.0489) loss_giou_dn_2: 1.1640 (1.1632) loss_fgl_dn_2: 0.9024 (0.8942) loss_ddf_dn_2: 0.0065 (0.0046) loss_vfl_dn_3: 0.4290 (0.4296) loss_bbox_dn_3: 0.0443 (0.0485) loss_giou_dn_3: 1.1606 (1.1617) loss_fgl_dn_3: 0.9034 (0.8948) loss_ddf_dn_3: 0.0009 (0.0008) loss_vfl_dn_4: 0.4275 (0.4296) loss_bbox_dn_4: 0.0442 (0.0484) loss_giou_dn_4: 1.1617 (1.1615) loss_fgl_dn_4: 0.9042 (0.8950) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4263 (0.4302) loss_bbox_dn_5: 0.0442 (0.0484) loss_giou_dn_5: 1.1616 (1.1615) loss_fgl_dn_5: 0.9041 (0.8951) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3894 (0.3831) loss_bbox_dn_pre: 0.0545 (0.0579) loss_giou_dn_pre: 1.2675 (1.2732) time: 0.8931 data: 0.0177 max mem: 29821\n", + "Epoch: [16] Total time: 0:01:16 (0.9100 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5950 (38.7666) loss_vfl: 0.1389 (0.1535) loss_bbox: 0.3014 (0.3448) loss_giou: 1.8792 (1.9063) loss_fgl: 0.3714 (0.3571) loss_vfl_aux_0: 0.1320 (0.1511) loss_bbox_aux_0: 0.3102 (0.3464) loss_giou_aux_0: 1.8883 (1.9178) loss_fgl_aux_0: 0.3671 (0.3554) loss_ddf_aux_0: 0.0804 (0.0968) loss_vfl_aux_1: 0.1495 (0.1563) loss_bbox_aux_1: 0.3046 (0.3452) loss_giou_aux_1: 1.8838 (1.9081) loss_fgl_aux_1: 0.3702 (0.3563) loss_ddf_aux_1: 0.0177 (0.0140) loss_vfl_aux_2: 0.1398 (0.1535) loss_bbox_aux_2: 0.3032 (0.3451) loss_giou_aux_2: 1.8800 (1.9064) loss_fgl_aux_2: 0.3713 (0.3568) loss_ddf_aux_2: 0.0031 (0.0024) loss_vfl_aux_3: 0.1395 (0.1524) loss_bbox_aux_3: 0.3020 (0.3448) loss_giou_aux_3: 1.8793 (1.9062) loss_fgl_aux_3: 0.3713 (0.3570) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1378 (0.1525) loss_bbox_aux_4: 0.3015 (0.3448) loss_giou_aux_4: 1.8792 (1.9063) loss_fgl_aux_4: 0.3713 (0.3571) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1293 (0.1485) loss_bbox_pre: 0.3155 (0.3521) loss_giou_pre: 1.8834 (1.9103) loss_vfl_enc_0: 0.1255 (0.1390) loss_bbox_enc_0: 0.3229 (0.3728) loss_giou_enc_0: 1.9199 (1.9452) loss_vfl_dn_0: 0.3918 (0.3830) loss_bbox_dn_0: 0.0551 (0.0587) loss_giou_dn_0: 1.2608 (1.2737) loss_fgl_dn_0: 0.8802 (0.8605) loss_ddf_dn_0: 0.1700 (0.1766) loss_vfl_dn_1: 0.4233 (0.4277) loss_bbox_dn_1: 0.0465 (0.0506) loss_giou_dn_1: 1.1888 (1.1843) loss_fgl_dn_1: 0.8917 (0.8883) loss_ddf_dn_1: 0.0451 (0.0371) loss_vfl_dn_2: 0.4333 (0.4328) loss_bbox_dn_2: 0.0446 (0.0489) loss_giou_dn_2: 1.1640 (1.1632) loss_fgl_dn_2: 0.9024 (0.8942) loss_ddf_dn_2: 0.0065 (0.0046) loss_vfl_dn_3: 0.4290 (0.4296) loss_bbox_dn_3: 0.0443 (0.0485) loss_giou_dn_3: 1.1606 (1.1617) loss_fgl_dn_3: 0.9034 (0.8948) loss_ddf_dn_3: 0.0009 (0.0008) loss_vfl_dn_4: 0.4275 (0.4296) loss_bbox_dn_4: 0.0442 (0.0484) loss_giou_dn_4: 1.1617 (1.1615) loss_fgl_dn_4: 0.9042 (0.8950) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4263 (0.4302) loss_bbox_dn_5: 0.0442 (0.0484) loss_giou_dn_5: 1.1616 (1.1615) loss_fgl_dn_5: 0.9041 (0.8951) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3894 (0.3831) loss_bbox_dn_pre: 0.0545 (0.0579) loss_giou_dn_pre: 1.2675 (1.2732)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7453 data: 0.5004 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3995 data: 0.1702 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4146 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.006\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.080\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.304\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.006\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.038\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.052\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.132\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.300\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.136\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.027\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [17] [ 0/84] eta: 0:02:35 lr: 0.000013 loss: 38.2785 (38.2785) loss_vfl: 0.1008 (0.1008) loss_bbox: 0.3136 (0.3136) loss_giou: 2.0399 (2.0399) loss_fgl: 0.2679 (0.2679) loss_vfl_aux_0: 0.1046 (0.1046) loss_bbox_aux_0: 0.3198 (0.3198) loss_giou_aux_0: 2.0299 (2.0299) loss_fgl_aux_0: 0.2667 (0.2667) loss_ddf_aux_0: 0.0542 (0.0542) loss_vfl_aux_1: 0.1108 (0.1108) loss_bbox_aux_1: 0.3154 (0.3154) loss_giou_aux_1: 2.0346 (2.0346) loss_fgl_aux_1: 0.2674 (0.2674) loss_ddf_aux_1: 0.0098 (0.0098) loss_vfl_aux_2: 0.1036 (0.1036) loss_bbox_aux_2: 0.3143 (0.3143) loss_giou_aux_2: 2.0359 (2.0359) loss_fgl_aux_2: 0.2680 (0.2680) loss_ddf_aux_2: 0.0018 (0.0018) loss_vfl_aux_3: 0.1047 (0.1047) loss_bbox_aux_3: 0.3139 (0.3139) loss_giou_aux_3: 2.0387 (2.0387) loss_fgl_aux_3: 0.2678 (0.2678) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1017 (0.1017) loss_bbox_aux_4: 0.3136 (0.3136) loss_giou_aux_4: 2.0398 (2.0398) loss_fgl_aux_4: 0.2678 (0.2678) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1024 (0.1024) loss_bbox_pre: 0.3268 (0.3268) loss_giou_pre: 2.0215 (2.0215) loss_vfl_enc_0: 0.0942 (0.0942) loss_bbox_enc_0: 0.3326 (0.3326) loss_giou_enc_0: 2.0517 (2.0517) loss_vfl_dn_0: 0.3486 (0.3486) loss_bbox_dn_0: 0.0507 (0.0507) loss_giou_dn_0: 1.3112 (1.3112) loss_fgl_dn_0: 0.7972 (0.7972) loss_ddf_dn_0: 0.1615 (0.1615) loss_vfl_dn_1: 0.4172 (0.4172) loss_bbox_dn_1: 0.0395 (0.0395) loss_giou_dn_1: 1.1947 (1.1947) loss_fgl_dn_1: 0.8639 (0.8639) loss_ddf_dn_1: 0.0371 (0.0371) loss_vfl_dn_2: 0.4204 (0.4204) loss_bbox_dn_2: 0.0365 (0.0365) loss_giou_dn_2: 1.1766 (1.1766) loss_fgl_dn_2: 0.8735 (0.8735) loss_ddf_dn_2: 0.0028 (0.0028) loss_vfl_dn_3: 0.4170 (0.4170) loss_bbox_dn_3: 0.0366 (0.0366) loss_giou_dn_3: 1.1777 (1.1777) loss_fgl_dn_3: 0.8733 (0.8733) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4133 (0.4133) loss_bbox_dn_4: 0.0365 (0.0365) loss_giou_dn_4: 1.1784 (1.1784) loss_fgl_dn_4: 0.8731 (0.8731) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4116 (0.4116) loss_bbox_dn_5: 0.0365 (0.0365) loss_giou_dn_5: 1.1785 (1.1785) loss_fgl_dn_5: 0.8731 (0.8731) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3550 (0.3550) loss_bbox_dn_pre: 0.0489 (0.0489) loss_giou_dn_pre: 1.3004 (1.3004) time: 1.8511 data: 0.9097 max mem: 29821\n", + "Epoch: [17] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.9714 (39.1231) loss_vfl: 0.1500 (0.1641) loss_bbox: 0.3213 (0.3565) loss_giou: 1.9326 (1.9033) loss_fgl: 0.3737 (0.3726) loss_vfl_aux_0: 0.1512 (0.1635) loss_bbox_aux_0: 0.3207 (0.3586) loss_giou_aux_0: 1.9486 (1.9165) loss_fgl_aux_0: 0.3727 (0.3711) loss_ddf_aux_0: 0.1022 (0.1107) loss_vfl_aux_1: 0.1536 (0.1669) loss_bbox_aux_1: 0.3221 (0.3578) loss_giou_aux_1: 1.9344 (1.9048) loss_fgl_aux_1: 0.3729 (0.3718) loss_ddf_aux_1: 0.0135 (0.0163) loss_vfl_aux_2: 0.1489 (0.1652) loss_bbox_aux_2: 0.3213 (0.3569) loss_giou_aux_2: 1.9331 (1.9035) loss_fgl_aux_2: 0.3734 (0.3725) loss_ddf_aux_2: 0.0025 (0.0024) loss_vfl_aux_3: 0.1506 (0.1650) loss_bbox_aux_3: 0.3212 (0.3567) loss_giou_aux_3: 1.9327 (1.9034) loss_fgl_aux_3: 0.3736 (0.3726) loss_ddf_aux_3: 0.0004 (0.0003) loss_vfl_aux_4: 0.1506 (0.1639) loss_bbox_aux_4: 0.3212 (0.3566) loss_giou_aux_4: 1.9327 (1.9033) loss_fgl_aux_4: 0.3737 (0.3726) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1486 (0.1612) loss_bbox_pre: 0.3248 (0.3634) loss_giou_pre: 1.9404 (1.9100) loss_vfl_enc_0: 0.1407 (0.1513) loss_bbox_enc_0: 0.3490 (0.3850) loss_giou_enc_0: 1.9681 (1.9460) loss_vfl_dn_0: 0.3792 (0.3952) loss_bbox_dn_0: 0.0546 (0.0572) loss_giou_dn_0: 1.3011 (1.2548) loss_fgl_dn_0: 0.8507 (0.8787) loss_ddf_dn_0: 0.2352 (0.1906) loss_vfl_dn_1: 0.4312 (0.4392) loss_bbox_dn_1: 0.0481 (0.0497) loss_giou_dn_1: 1.1785 (1.1648) loss_fgl_dn_1: 0.8856 (0.9078) loss_ddf_dn_1: 0.0296 (0.0362) loss_vfl_dn_2: 0.4302 (0.4412) loss_bbox_dn_2: 0.0483 (0.0478) loss_giou_dn_2: 1.1649 (1.1508) loss_fgl_dn_2: 0.8898 (0.9114) loss_ddf_dn_2: 0.0038 (0.0037) loss_vfl_dn_3: 0.4285 (0.4381) loss_bbox_dn_3: 0.0478 (0.0474) loss_giou_dn_3: 1.1643 (1.1496) loss_fgl_dn_3: 0.8908 (0.9119) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4272 (0.4373) loss_bbox_dn_4: 0.0476 (0.0473) loss_giou_dn_4: 1.1636 (1.1494) loss_fgl_dn_4: 0.8914 (0.9120) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4282 (0.4380) loss_bbox_dn_5: 0.0476 (0.0473) loss_giou_dn_5: 1.1636 (1.1494) loss_fgl_dn_5: 0.8915 (0.9121) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3770 (0.3937) loss_bbox_dn_pre: 0.0545 (0.0573) loss_giou_dn_pre: 1.3051 (1.2562) time: 0.9066 data: 0.0171 max mem: 29821\n", + "Epoch: [17] Total time: 0:01:16 (0.9153 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.9714 (39.1231) loss_vfl: 0.1500 (0.1641) loss_bbox: 0.3213 (0.3565) loss_giou: 1.9326 (1.9033) loss_fgl: 0.3737 (0.3726) loss_vfl_aux_0: 0.1512 (0.1635) loss_bbox_aux_0: 0.3207 (0.3586) loss_giou_aux_0: 1.9486 (1.9165) loss_fgl_aux_0: 0.3727 (0.3711) loss_ddf_aux_0: 0.1022 (0.1107) loss_vfl_aux_1: 0.1536 (0.1669) loss_bbox_aux_1: 0.3221 (0.3578) loss_giou_aux_1: 1.9344 (1.9048) loss_fgl_aux_1: 0.3729 (0.3718) loss_ddf_aux_1: 0.0135 (0.0163) loss_vfl_aux_2: 0.1489 (0.1652) loss_bbox_aux_2: 0.3213 (0.3569) loss_giou_aux_2: 1.9331 (1.9035) loss_fgl_aux_2: 0.3734 (0.3725) loss_ddf_aux_2: 0.0025 (0.0024) loss_vfl_aux_3: 0.1506 (0.1650) loss_bbox_aux_3: 0.3212 (0.3567) loss_giou_aux_3: 1.9327 (1.9034) loss_fgl_aux_3: 0.3736 (0.3726) loss_ddf_aux_3: 0.0004 (0.0003) loss_vfl_aux_4: 0.1506 (0.1639) loss_bbox_aux_4: 0.3212 (0.3566) loss_giou_aux_4: 1.9327 (1.9033) loss_fgl_aux_4: 0.3737 (0.3726) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1486 (0.1612) loss_bbox_pre: 0.3248 (0.3634) loss_giou_pre: 1.9404 (1.9100) loss_vfl_enc_0: 0.1407 (0.1513) loss_bbox_enc_0: 0.3490 (0.3850) loss_giou_enc_0: 1.9681 (1.9460) loss_vfl_dn_0: 0.3792 (0.3952) loss_bbox_dn_0: 0.0546 (0.0572) loss_giou_dn_0: 1.3011 (1.2548) loss_fgl_dn_0: 0.8507 (0.8787) loss_ddf_dn_0: 0.2352 (0.1906) loss_vfl_dn_1: 0.4312 (0.4392) loss_bbox_dn_1: 0.0481 (0.0497) loss_giou_dn_1: 1.1785 (1.1648) loss_fgl_dn_1: 0.8856 (0.9078) loss_ddf_dn_1: 0.0296 (0.0362) loss_vfl_dn_2: 0.4302 (0.4412) loss_bbox_dn_2: 0.0483 (0.0478) loss_giou_dn_2: 1.1649 (1.1508) loss_fgl_dn_2: 0.8898 (0.9114) loss_ddf_dn_2: 0.0038 (0.0037) loss_vfl_dn_3: 0.4285 (0.4381) loss_bbox_dn_3: 0.0478 (0.0474) loss_giou_dn_3: 1.1643 (1.1496) loss_fgl_dn_3: 0.8908 (0.9119) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4272 (0.4373) loss_bbox_dn_4: 0.0476 (0.0473) loss_giou_dn_4: 1.1636 (1.1494) loss_fgl_dn_4: 0.8914 (0.9120) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4282 (0.4380) loss_bbox_dn_5: 0.0476 (0.0473) loss_giou_dn_5: 1.1636 (1.1494) loss_fgl_dn_5: 0.8915 (0.9121) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3770 (0.3937) loss_bbox_dn_pre: 0.0545 (0.0573) loss_giou_dn_pre: 1.3051 (1.2562)\n", + "Test: [0/4] eta: 0:00:03 time: 0.8058 data: 0.5627 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4044 data: 0.1781 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4194 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.013\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.034\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.014\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.100\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.034\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.044\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.057\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.064\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.188\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.100\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.139\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.033\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [18] [ 0/84] eta: 0:02:50 lr: 0.000013 loss: 38.3527 (38.3527) loss_vfl: 0.0899 (0.0899) loss_bbox: 0.3186 (0.3186) loss_giou: 2.0559 (2.0559) loss_fgl: 0.2535 (0.2535) loss_vfl_aux_0: 0.0909 (0.0909) loss_bbox_aux_0: 0.3176 (0.3176) loss_giou_aux_0: 2.0707 (2.0707) loss_fgl_aux_0: 0.2529 (0.2529) loss_ddf_aux_0: 0.0552 (0.0552) loss_vfl_aux_1: 0.0960 (0.0960) loss_bbox_aux_1: 0.3181 (0.3181) loss_giou_aux_1: 2.0579 (2.0579) loss_fgl_aux_1: 0.2539 (0.2539) loss_ddf_aux_1: 0.0075 (0.0075) loss_vfl_aux_2: 0.0925 (0.0925) loss_bbox_aux_2: 0.3186 (0.3186) loss_giou_aux_2: 2.0563 (2.0563) loss_fgl_aux_2: 0.2538 (0.2538) loss_ddf_aux_2: 0.0017 (0.0017) loss_vfl_aux_3: 0.0895 (0.0895) loss_bbox_aux_3: 0.3187 (0.3187) loss_giou_aux_3: 2.0559 (2.0559) loss_fgl_aux_3: 0.2536 (0.2536) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.0892 (0.0892) loss_bbox_aux_4: 0.3186 (0.3186) loss_giou_aux_4: 2.0559 (2.0559) loss_fgl_aux_4: 0.2536 (0.2536) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0897 (0.0897) loss_bbox_pre: 0.3212 (0.3212) loss_giou_pre: 2.0662 (2.0662) loss_vfl_enc_0: 0.0896 (0.0896) loss_bbox_enc_0: 0.3503 (0.3503) loss_giou_enc_0: 2.0887 (2.0887) loss_vfl_dn_0: 0.3586 (0.3586) loss_bbox_dn_0: 0.0406 (0.0406) loss_giou_dn_0: 1.3343 (1.3343) loss_fgl_dn_0: 0.8209 (0.8209) loss_ddf_dn_0: 0.1531 (0.1531) loss_vfl_dn_1: 0.4268 (0.4268) loss_bbox_dn_1: 0.0376 (0.0376) loss_giou_dn_1: 1.1850 (1.1850) loss_fgl_dn_1: 0.8639 (0.8639) loss_ddf_dn_1: 0.0164 (0.0164) loss_vfl_dn_2: 0.4229 (0.4229) loss_bbox_dn_2: 0.0369 (0.0369) loss_giou_dn_2: 1.1711 (1.1711) loss_fgl_dn_2: 0.8664 (0.8664) loss_ddf_dn_2: 0.0022 (0.0022) loss_vfl_dn_3: 0.4170 (0.4170) loss_bbox_dn_3: 0.0368 (0.0368) loss_giou_dn_3: 1.1704 (1.1704) loss_fgl_dn_3: 0.8673 (0.8673) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4185 (0.4185) loss_bbox_dn_4: 0.0368 (0.0368) loss_giou_dn_4: 1.1701 (1.1701) loss_fgl_dn_4: 0.8679 (0.8679) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4214 (0.4214) loss_bbox_dn_5: 0.0368 (0.0368) loss_giou_dn_5: 1.1702 (1.1702) loss_fgl_dn_5: 0.8679 (0.8679) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3564 (0.3564) loss_bbox_dn_pre: 0.0407 (0.0407) loss_giou_dn_pre: 1.3349 (1.3349) time: 2.0294 data: 0.9535 max mem: 29821\n", + "Epoch: [18] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5546 (38.9107) loss_vfl: 0.1570 (0.1585) loss_bbox: 0.3023 (0.3490) loss_giou: 1.8883 (1.8973) loss_fgl: 0.3608 (0.3681) loss_vfl_aux_0: 0.1541 (0.1560) loss_bbox_aux_0: 0.3092 (0.3553) loss_giou_aux_0: 1.9075 (1.9100) loss_fgl_aux_0: 0.3605 (0.3659) loss_ddf_aux_0: 0.1203 (0.1187) loss_vfl_aux_1: 0.1569 (0.1608) loss_bbox_aux_1: 0.3054 (0.3496) loss_giou_aux_1: 1.8930 (1.8997) loss_fgl_aux_1: 0.3605 (0.3675) loss_ddf_aux_1: 0.0165 (0.0161) loss_vfl_aux_2: 0.1569 (0.1598) loss_bbox_aux_2: 0.3041 (0.3492) loss_giou_aux_2: 1.8896 (1.8977) loss_fgl_aux_2: 0.3607 (0.3679) loss_ddf_aux_2: 0.0026 (0.0026) loss_vfl_aux_3: 0.1554 (0.1588) loss_bbox_aux_3: 0.3027 (0.3490) loss_giou_aux_3: 1.8887 (1.8973) loss_fgl_aux_3: 0.3606 (0.3680) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1566 (0.1583) loss_bbox_aux_4: 0.3023 (0.3490) loss_giou_aux_4: 1.8884 (1.8972) loss_fgl_aux_4: 0.3608 (0.3681) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1503 (0.1537) loss_bbox_pre: 0.3165 (0.3606) loss_giou_pre: 1.8955 (1.9040) loss_vfl_enc_0: 0.1450 (0.1471) loss_bbox_enc_0: 0.3397 (0.3789) loss_giou_enc_0: 1.9335 (1.9384) loss_vfl_dn_0: 0.3945 (0.3928) loss_bbox_dn_0: 0.0562 (0.0587) loss_giou_dn_0: 1.2324 (1.2518) loss_fgl_dn_0: 0.8845 (0.8767) loss_ddf_dn_0: 0.1626 (0.1841) loss_vfl_dn_1: 0.4275 (0.4350) loss_bbox_dn_1: 0.0481 (0.0503) loss_giou_dn_1: 1.1713 (1.1667) loss_fgl_dn_1: 0.9059 (0.9046) loss_ddf_dn_1: 0.0323 (0.0357) loss_vfl_dn_2: 0.4355 (0.4401) loss_bbox_dn_2: 0.0460 (0.0484) loss_giou_dn_2: 1.1518 (1.1483) loss_fgl_dn_2: 0.9090 (0.9093) loss_ddf_dn_2: 0.0033 (0.0041) loss_vfl_dn_3: 0.4343 (0.4360) loss_bbox_dn_3: 0.0459 (0.0481) loss_giou_dn_3: 1.1500 (1.1470) loss_fgl_dn_3: 0.9101 (0.9098) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4353 (0.4357) loss_bbox_dn_4: 0.0457 (0.0480) loss_giou_dn_4: 1.1497 (1.1466) loss_fgl_dn_4: 0.9109 (0.9101) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4370 (0.4362) loss_bbox_dn_5: 0.0456 (0.0480) loss_giou_dn_5: 1.1499 (1.1466) loss_fgl_dn_5: 0.9109 (0.9101) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3967 (0.3923) loss_bbox_dn_pre: 0.0558 (0.0585) loss_giou_dn_pre: 1.2370 (1.2515) time: 0.8812 data: 0.0185 max mem: 29821\n", + "Epoch: [18] Total time: 0:01:15 (0.8936 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5546 (38.9107) loss_vfl: 0.1570 (0.1585) loss_bbox: 0.3023 (0.3490) loss_giou: 1.8883 (1.8973) loss_fgl: 0.3608 (0.3681) loss_vfl_aux_0: 0.1541 (0.1560) loss_bbox_aux_0: 0.3092 (0.3553) loss_giou_aux_0: 1.9075 (1.9100) loss_fgl_aux_0: 0.3605 (0.3659) loss_ddf_aux_0: 0.1203 (0.1187) loss_vfl_aux_1: 0.1569 (0.1608) loss_bbox_aux_1: 0.3054 (0.3496) loss_giou_aux_1: 1.8930 (1.8997) loss_fgl_aux_1: 0.3605 (0.3675) loss_ddf_aux_1: 0.0165 (0.0161) loss_vfl_aux_2: 0.1569 (0.1598) loss_bbox_aux_2: 0.3041 (0.3492) loss_giou_aux_2: 1.8896 (1.8977) loss_fgl_aux_2: 0.3607 (0.3679) loss_ddf_aux_2: 0.0026 (0.0026) loss_vfl_aux_3: 0.1554 (0.1588) loss_bbox_aux_3: 0.3027 (0.3490) loss_giou_aux_3: 1.8887 (1.8973) loss_fgl_aux_3: 0.3606 (0.3680) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1566 (0.1583) loss_bbox_aux_4: 0.3023 (0.3490) loss_giou_aux_4: 1.8884 (1.8972) loss_fgl_aux_4: 0.3608 (0.3681) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1503 (0.1537) loss_bbox_pre: 0.3165 (0.3606) loss_giou_pre: 1.8955 (1.9040) loss_vfl_enc_0: 0.1450 (0.1471) loss_bbox_enc_0: 0.3397 (0.3789) loss_giou_enc_0: 1.9335 (1.9384) loss_vfl_dn_0: 0.3945 (0.3928) loss_bbox_dn_0: 0.0562 (0.0587) loss_giou_dn_0: 1.2324 (1.2518) loss_fgl_dn_0: 0.8845 (0.8767) loss_ddf_dn_0: 0.1626 (0.1841) loss_vfl_dn_1: 0.4275 (0.4350) loss_bbox_dn_1: 0.0481 (0.0503) loss_giou_dn_1: 1.1713 (1.1667) loss_fgl_dn_1: 0.9059 (0.9046) loss_ddf_dn_1: 0.0323 (0.0357) loss_vfl_dn_2: 0.4355 (0.4401) loss_bbox_dn_2: 0.0460 (0.0484) loss_giou_dn_2: 1.1518 (1.1483) loss_fgl_dn_2: 0.9090 (0.9093) loss_ddf_dn_2: 0.0033 (0.0041) loss_vfl_dn_3: 0.4343 (0.4360) loss_bbox_dn_3: 0.0459 (0.0481) loss_giou_dn_3: 1.1500 (1.1470) loss_fgl_dn_3: 0.9101 (0.9098) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4353 (0.4357) loss_bbox_dn_4: 0.0457 (0.0480) loss_giou_dn_4: 1.1497 (1.1466) loss_fgl_dn_4: 0.9109 (0.9101) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4370 (0.4362) loss_bbox_dn_5: 0.0456 (0.0480) loss_giou_dn_5: 1.1499 (1.1466) loss_fgl_dn_5: 0.9109 (0.9101) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3967 (0.3923) loss_bbox_dn_pre: 0.0558 (0.0585) loss_giou_dn_pre: 1.2370 (1.2515)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7281 data: 0.4800 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3922 data: 0.1619 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4069 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.044\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.008\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.090\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.114\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.015\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.049\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.064\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.069\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.183\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.175\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.146\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.030\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [19] [ 0/84] eta: 0:03:25 lr: 0.000013 loss: 42.1010 (42.1010) loss_vfl: 0.0566 (0.0566) loss_bbox: 0.6762 (0.6762) loss_giou: 2.2830 (2.2830) loss_fgl: 0.1968 (0.1968) loss_vfl_aux_0: 0.0574 (0.0574) loss_bbox_aux_0: 0.6754 (0.6754) loss_giou_aux_0: 2.2880 (2.2880) loss_fgl_aux_0: 0.1965 (0.1965) loss_ddf_aux_0: 0.0102 (0.0102) loss_vfl_aux_1: 0.0593 (0.0593) loss_bbox_aux_1: 0.6752 (0.6752) loss_giou_aux_1: 2.2848 (2.2848) loss_fgl_aux_1: 0.1969 (0.1969) loss_ddf_aux_1: 0.0013 (0.0013) loss_vfl_aux_2: 0.0578 (0.0578) loss_bbox_aux_2: 0.6759 (0.6759) loss_giou_aux_2: 2.2832 (2.2832) loss_fgl_aux_2: 0.1968 (0.1968) loss_ddf_aux_2: 0.0002 (0.0002) loss_vfl_aux_3: 0.0560 (0.0560) loss_bbox_aux_3: 0.6761 (0.6761) loss_giou_aux_3: 2.2830 (2.2830) loss_fgl_aux_3: 0.1968 (0.1968) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.0565 (0.0565) loss_bbox_aux_4: 0.6762 (0.6762) loss_giou_aux_4: 2.2829 (2.2829) loss_fgl_aux_4: 0.1968 (0.1968) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.0562 (0.0562) loss_bbox_pre: 0.6804 (0.6804) loss_giou_pre: 2.2810 (2.2810) loss_vfl_enc_0: 0.0546 (0.0546) loss_bbox_enc_0: 0.6949 (0.6949) loss_giou_enc_0: 2.3009 (2.3009) loss_vfl_dn_0: 0.3391 (0.3391) loss_bbox_dn_0: 0.0357 (0.0357) loss_giou_dn_0: 1.3542 (1.3542) loss_fgl_dn_0: 0.7591 (0.7591) loss_ddf_dn_0: 0.1217 (0.1217) loss_vfl_dn_1: 0.4048 (0.4048) loss_bbox_dn_1: 0.0272 (0.0272) loss_giou_dn_1: 1.2190 (1.2190) loss_fgl_dn_1: 0.8351 (0.8351) loss_ddf_dn_1: 0.0156 (0.0156) loss_vfl_dn_2: 0.4185 (0.4185) loss_bbox_dn_2: 0.0268 (0.0268) loss_giou_dn_2: 1.2035 (1.2035) loss_fgl_dn_2: 0.8377 (0.8377) loss_ddf_dn_2: 0.0011 (0.0011) loss_vfl_dn_3: 0.4065 (0.4065) loss_bbox_dn_3: 0.0268 (0.0268) loss_giou_dn_3: 1.2035 (1.2035) loss_fgl_dn_3: 0.8374 (0.8374) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4065 (0.4065) loss_bbox_dn_4: 0.0268 (0.0268) loss_giou_dn_4: 1.2031 (1.2031) loss_fgl_dn_4: 0.8377 (0.8377) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4019 (0.4019) loss_bbox_dn_5: 0.0268 (0.0268) loss_giou_dn_5: 1.2032 (1.2032) loss_fgl_dn_5: 0.8376 (0.8376) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3464 (0.3464) loss_bbox_dn_pre: 0.0342 (0.0342) loss_giou_dn_pre: 1.3393 (1.3393) time: 2.4516 data: 1.0064 max mem: 29821\n", + "Epoch: [19] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.1447 (39.2976) loss_vfl: 0.1404 (0.1541) loss_bbox: 0.3324 (0.3707) loss_giou: 1.9042 (1.9272) loss_fgl: 0.3329 (0.3655) loss_vfl_aux_0: 0.1342 (0.1510) loss_bbox_aux_0: 0.3362 (0.3765) loss_giou_aux_0: 1.9204 (1.9372) loss_fgl_aux_0: 0.3321 (0.3620) loss_ddf_aux_0: 0.0983 (0.1282) loss_vfl_aux_1: 0.1417 (0.1574) loss_bbox_aux_1: 0.3330 (0.3706) loss_giou_aux_1: 1.9057 (1.9300) loss_fgl_aux_1: 0.3319 (0.3647) loss_ddf_aux_1: 0.0177 (0.0177) loss_vfl_aux_2: 0.1382 (0.1567) loss_bbox_aux_2: 0.3325 (0.3708) loss_giou_aux_2: 1.9045 (1.9275) loss_fgl_aux_2: 0.3328 (0.3652) loss_ddf_aux_2: 0.0023 (0.0027) loss_vfl_aux_3: 0.1362 (0.1538) loss_bbox_aux_3: 0.3325 (0.3707) loss_giou_aux_3: 1.9042 (1.9272) loss_fgl_aux_3: 0.3328 (0.3654) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1376 (0.1533) loss_bbox_aux_4: 0.3324 (0.3708) loss_giou_aux_4: 1.9041 (1.9271) loss_fgl_aux_4: 0.3328 (0.3655) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1315 (0.1488) loss_bbox_pre: 0.3417 (0.3809) loss_giou_pre: 1.9150 (1.9317) loss_vfl_enc_0: 0.1243 (0.1408) loss_bbox_enc_0: 0.3684 (0.4020) loss_giou_enc_0: 1.9530 (1.9695) loss_vfl_dn_0: 0.3882 (0.3863) loss_bbox_dn_0: 0.0560 (0.0567) loss_giou_dn_0: 1.2559 (1.2686) loss_fgl_dn_0: 0.8734 (0.8623) loss_ddf_dn_0: 0.1689 (0.1932) loss_vfl_dn_1: 0.4199 (0.4272) loss_bbox_dn_1: 0.0510 (0.0492) loss_giou_dn_1: 1.1995 (1.1891) loss_fgl_dn_1: 0.8997 (0.8925) loss_ddf_dn_1: 0.0393 (0.0403) loss_vfl_dn_2: 0.4268 (0.4343) loss_bbox_dn_2: 0.0496 (0.0475) loss_giou_dn_2: 1.1855 (1.1685) loss_fgl_dn_2: 0.8934 (0.8980) loss_ddf_dn_2: 0.0039 (0.0045) loss_vfl_dn_3: 0.4238 (0.4285) loss_bbox_dn_3: 0.0491 (0.0473) loss_giou_dn_3: 1.1846 (1.1674) loss_fgl_dn_3: 0.8934 (0.8986) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4219 (0.4272) loss_bbox_dn_4: 0.0490 (0.0472) loss_giou_dn_4: 1.1851 (1.1672) loss_fgl_dn_4: 0.8939 (0.8989) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4233 (0.4282) loss_bbox_dn_5: 0.0490 (0.0472) loss_giou_dn_5: 1.1853 (1.1672) loss_fgl_dn_5: 0.8939 (0.8989) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3882 (0.3855) loss_bbox_dn_pre: 0.0564 (0.0564) loss_giou_dn_pre: 1.2544 (1.2691) time: 0.8947 data: 0.0181 max mem: 29821\n", + "Epoch: [19] Total time: 0:01:17 (0.9259 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.1447 (39.2976) loss_vfl: 0.1404 (0.1541) loss_bbox: 0.3324 (0.3707) loss_giou: 1.9042 (1.9272) loss_fgl: 0.3329 (0.3655) loss_vfl_aux_0: 0.1342 (0.1510) loss_bbox_aux_0: 0.3362 (0.3765) loss_giou_aux_0: 1.9204 (1.9372) loss_fgl_aux_0: 0.3321 (0.3620) loss_ddf_aux_0: 0.0983 (0.1282) loss_vfl_aux_1: 0.1417 (0.1574) loss_bbox_aux_1: 0.3330 (0.3706) loss_giou_aux_1: 1.9057 (1.9300) loss_fgl_aux_1: 0.3319 (0.3647) loss_ddf_aux_1: 0.0177 (0.0177) loss_vfl_aux_2: 0.1382 (0.1567) loss_bbox_aux_2: 0.3325 (0.3708) loss_giou_aux_2: 1.9045 (1.9275) loss_fgl_aux_2: 0.3328 (0.3652) loss_ddf_aux_2: 0.0023 (0.0027) loss_vfl_aux_3: 0.1362 (0.1538) loss_bbox_aux_3: 0.3325 (0.3707) loss_giou_aux_3: 1.9042 (1.9272) loss_fgl_aux_3: 0.3328 (0.3654) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1376 (0.1533) loss_bbox_aux_4: 0.3324 (0.3708) loss_giou_aux_4: 1.9041 (1.9271) loss_fgl_aux_4: 0.3328 (0.3655) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1315 (0.1488) loss_bbox_pre: 0.3417 (0.3809) loss_giou_pre: 1.9150 (1.9317) loss_vfl_enc_0: 0.1243 (0.1408) loss_bbox_enc_0: 0.3684 (0.4020) loss_giou_enc_0: 1.9530 (1.9695) loss_vfl_dn_0: 0.3882 (0.3863) loss_bbox_dn_0: 0.0560 (0.0567) loss_giou_dn_0: 1.2559 (1.2686) loss_fgl_dn_0: 0.8734 (0.8623) loss_ddf_dn_0: 0.1689 (0.1932) loss_vfl_dn_1: 0.4199 (0.4272) loss_bbox_dn_1: 0.0510 (0.0492) loss_giou_dn_1: 1.1995 (1.1891) loss_fgl_dn_1: 0.8997 (0.8925) loss_ddf_dn_1: 0.0393 (0.0403) loss_vfl_dn_2: 0.4268 (0.4343) loss_bbox_dn_2: 0.0496 (0.0475) loss_giou_dn_2: 1.1855 (1.1685) loss_fgl_dn_2: 0.8934 (0.8980) loss_ddf_dn_2: 0.0039 (0.0045) loss_vfl_dn_3: 0.4238 (0.4285) loss_bbox_dn_3: 0.0491 (0.0473) loss_giou_dn_3: 1.1846 (1.1674) loss_fgl_dn_3: 0.8934 (0.8986) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4219 (0.4272) loss_bbox_dn_4: 0.0490 (0.0472) loss_giou_dn_4: 1.1851 (1.1672) loss_fgl_dn_4: 0.8939 (0.8989) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4233 (0.4282) loss_bbox_dn_5: 0.0490 (0.0472) loss_giou_dn_5: 1.1853 (1.1672) loss_fgl_dn_5: 0.8939 (0.8989) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3882 (0.3855) loss_bbox_dn_pre: 0.0564 (0.0564) loss_giou_dn_pre: 1.2544 (1.2691)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7581 data: 0.5148 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3928 data: 0.1670 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5658 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.047\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.015\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.094\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.196\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.011\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.043\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.054\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.053\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.233\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.325\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.143\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [20] [ 0/84] eta: 0:02:41 lr: 0.000013 loss: 40.6656 (40.6656) loss_vfl: 0.1316 (0.1316) loss_bbox: 0.4890 (0.4890) loss_giou: 2.0148 (2.0148) loss_fgl: 0.3342 (0.3342) loss_vfl_aux_0: 0.1439 (0.1439) loss_bbox_aux_0: 0.4854 (0.4854) loss_giou_aux_0: 2.0244 (2.0244) loss_fgl_aux_0: 0.3307 (0.3307) loss_ddf_aux_0: 0.1230 (0.1230) loss_vfl_aux_1: 0.1459 (0.1459) loss_bbox_aux_1: 0.4882 (0.4882) loss_giou_aux_1: 2.0162 (2.0162) loss_fgl_aux_1: 0.3328 (0.3328) loss_ddf_aux_1: 0.0142 (0.0142) loss_vfl_aux_2: 0.1398 (0.1398) loss_bbox_aux_2: 0.4888 (0.4888) loss_giou_aux_2: 2.0150 (2.0150) loss_fgl_aux_2: 0.3338 (0.3338) loss_ddf_aux_2: 0.0012 (0.0012) loss_vfl_aux_3: 0.1328 (0.1328) loss_bbox_aux_3: 0.4888 (0.4888) loss_giou_aux_3: 2.0149 (2.0149) loss_fgl_aux_3: 0.3340 (0.3340) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1338 (0.1338) loss_bbox_aux_4: 0.4890 (0.4890) loss_giou_aux_4: 2.0148 (2.0148) loss_fgl_aux_4: 0.3341 (0.3341) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1414 (0.1414) loss_bbox_pre: 0.4888 (0.4888) loss_giou_pre: 2.0203 (2.0203) loss_vfl_enc_0: 0.1298 (0.1298) loss_bbox_enc_0: 0.4782 (0.4782) loss_giou_enc_0: 2.0640 (2.0640) loss_vfl_dn_0: 0.3730 (0.3730) loss_bbox_dn_0: 0.0801 (0.0801) loss_giou_dn_0: 1.2774 (1.2774) loss_fgl_dn_0: 0.8488 (0.8488) loss_ddf_dn_0: 0.1811 (0.1811) loss_vfl_dn_1: 0.4187 (0.4187) loss_bbox_dn_1: 0.0632 (0.0632) loss_giou_dn_1: 1.2071 (1.2071) loss_fgl_dn_1: 0.8906 (0.8906) loss_ddf_dn_1: 0.0336 (0.0336) loss_vfl_dn_2: 0.4290 (0.4290) loss_bbox_dn_2: 0.0601 (0.0601) loss_giou_dn_2: 1.1774 (1.1774) loss_fgl_dn_2: 0.9002 (0.9002) loss_ddf_dn_2: 0.0011 (0.0011) loss_vfl_dn_3: 0.4229 (0.4229) loss_bbox_dn_3: 0.0598 (0.0598) loss_giou_dn_3: 1.1762 (1.1762) loss_fgl_dn_3: 0.9009 (0.9009) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4260 (0.4260) loss_bbox_dn_4: 0.0598 (0.0598) loss_giou_dn_4: 1.1759 (1.1759) loss_fgl_dn_4: 0.9010 (0.9010) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4229 (0.4229) loss_bbox_dn_5: 0.0597 (0.0597) loss_giou_dn_5: 1.1758 (1.1758) loss_fgl_dn_5: 0.9011 (0.9011) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3789 (0.3789) loss_bbox_dn_pre: 0.0781 (0.0781) loss_giou_dn_pre: 1.2673 (1.2673) time: 1.9181 data: 1.0026 max mem: 29821\n", + "Epoch: [20] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.4207 (38.8492) loss_vfl: 0.1483 (0.1598) loss_bbox: 0.3526 (0.3518) loss_giou: 1.8677 (1.8866) loss_fgl: 0.3524 (0.3720) loss_vfl_aux_0: 0.1337 (0.1597) loss_bbox_aux_0: 0.3564 (0.3552) loss_giou_aux_0: 1.8762 (1.8982) loss_fgl_aux_0: 0.3473 (0.3700) loss_ddf_aux_0: 0.0847 (0.0979) loss_vfl_aux_1: 0.1404 (0.1636) loss_bbox_aux_1: 0.3514 (0.3523) loss_giou_aux_1: 1.8701 (1.8884) loss_fgl_aux_1: 0.3510 (0.3715) loss_ddf_aux_1: 0.0100 (0.0130) loss_vfl_aux_2: 0.1410 (0.1619) loss_bbox_aux_2: 0.3525 (0.3519) loss_giou_aux_2: 1.8679 (1.8869) loss_fgl_aux_2: 0.3519 (0.3719) loss_ddf_aux_2: 0.0013 (0.0015) loss_vfl_aux_3: 0.1415 (0.1597) loss_bbox_aux_3: 0.3526 (0.3518) loss_giou_aux_3: 1.8677 (1.8867) loss_fgl_aux_3: 0.3523 (0.3720) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1437 (0.1592) loss_bbox_aux_4: 0.3526 (0.3518) loss_giou_aux_4: 1.8676 (1.8866) loss_fgl_aux_4: 0.3524 (0.3720) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1331 (0.1574) loss_bbox_pre: 0.3569 (0.3593) loss_giou_pre: 1.8740 (1.8935) loss_vfl_enc_0: 0.1332 (0.1478) loss_bbox_enc_0: 0.3726 (0.3783) loss_giou_enc_0: 1.9137 (1.9355) loss_vfl_dn_0: 0.4019 (0.4026) loss_bbox_dn_0: 0.0512 (0.0572) loss_giou_dn_0: 1.2280 (1.2244) loss_fgl_dn_0: 0.8880 (0.8941) loss_ddf_dn_0: 0.1636 (0.1726) loss_vfl_dn_1: 0.4387 (0.4409) loss_bbox_dn_1: 0.0421 (0.0491) loss_giou_dn_1: 1.1490 (1.1530) loss_fgl_dn_1: 0.9147 (0.9192) loss_ddf_dn_1: 0.0289 (0.0311) loss_vfl_dn_2: 0.4502 (0.4452) loss_bbox_dn_2: 0.0414 (0.0474) loss_giou_dn_2: 1.1346 (1.1367) loss_fgl_dn_2: 0.9197 (0.9233) loss_ddf_dn_2: 0.0028 (0.0027) loss_vfl_dn_3: 0.4409 (0.4402) loss_bbox_dn_3: 0.0416 (0.0472) loss_giou_dn_3: 1.1334 (1.1358) loss_fgl_dn_3: 0.9197 (0.9236) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4412 (0.4400) loss_bbox_dn_4: 0.0416 (0.0471) loss_giou_dn_4: 1.1329 (1.1355) loss_fgl_dn_4: 0.9198 (0.9238) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4402 (0.4403) loss_bbox_dn_5: 0.0417 (0.0471) loss_giou_dn_5: 1.1328 (1.1355) loss_fgl_dn_5: 0.9198 (0.9238) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4004 (0.4022) loss_bbox_dn_pre: 0.0513 (0.0571) loss_giou_dn_pre: 1.2251 (1.2243) time: 0.9008 data: 0.0174 max mem: 29821\n", + "Epoch: [20] Total time: 0:01:14 (0.8899 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.4207 (38.8492) loss_vfl: 0.1483 (0.1598) loss_bbox: 0.3526 (0.3518) loss_giou: 1.8677 (1.8866) loss_fgl: 0.3524 (0.3720) loss_vfl_aux_0: 0.1337 (0.1597) loss_bbox_aux_0: 0.3564 (0.3552) loss_giou_aux_0: 1.8762 (1.8982) loss_fgl_aux_0: 0.3473 (0.3700) loss_ddf_aux_0: 0.0847 (0.0979) loss_vfl_aux_1: 0.1404 (0.1636) loss_bbox_aux_1: 0.3514 (0.3523) loss_giou_aux_1: 1.8701 (1.8884) loss_fgl_aux_1: 0.3510 (0.3715) loss_ddf_aux_1: 0.0100 (0.0130) loss_vfl_aux_2: 0.1410 (0.1619) loss_bbox_aux_2: 0.3525 (0.3519) loss_giou_aux_2: 1.8679 (1.8869) loss_fgl_aux_2: 0.3519 (0.3719) loss_ddf_aux_2: 0.0013 (0.0015) loss_vfl_aux_3: 0.1415 (0.1597) loss_bbox_aux_3: 0.3526 (0.3518) loss_giou_aux_3: 1.8677 (1.8867) loss_fgl_aux_3: 0.3523 (0.3720) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1437 (0.1592) loss_bbox_aux_4: 0.3526 (0.3518) loss_giou_aux_4: 1.8676 (1.8866) loss_fgl_aux_4: 0.3524 (0.3720) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1331 (0.1574) loss_bbox_pre: 0.3569 (0.3593) loss_giou_pre: 1.8740 (1.8935) loss_vfl_enc_0: 0.1332 (0.1478) loss_bbox_enc_0: 0.3726 (0.3783) loss_giou_enc_0: 1.9137 (1.9355) loss_vfl_dn_0: 0.4019 (0.4026) loss_bbox_dn_0: 0.0512 (0.0572) loss_giou_dn_0: 1.2280 (1.2244) loss_fgl_dn_0: 0.8880 (0.8941) loss_ddf_dn_0: 0.1636 (0.1726) loss_vfl_dn_1: 0.4387 (0.4409) loss_bbox_dn_1: 0.0421 (0.0491) loss_giou_dn_1: 1.1490 (1.1530) loss_fgl_dn_1: 0.9147 (0.9192) loss_ddf_dn_1: 0.0289 (0.0311) loss_vfl_dn_2: 0.4502 (0.4452) loss_bbox_dn_2: 0.0414 (0.0474) loss_giou_dn_2: 1.1346 (1.1367) loss_fgl_dn_2: 0.9197 (0.9233) loss_ddf_dn_2: 0.0028 (0.0027) loss_vfl_dn_3: 0.4409 (0.4402) loss_bbox_dn_3: 0.0416 (0.0472) loss_giou_dn_3: 1.1334 (1.1358) loss_fgl_dn_3: 0.9197 (0.9236) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4412 (0.4400) loss_bbox_dn_4: 0.0416 (0.0471) loss_giou_dn_4: 1.1329 (1.1355) loss_fgl_dn_4: 0.9198 (0.9238) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4402 (0.4403) loss_bbox_dn_5: 0.0417 (0.0471) loss_giou_dn_5: 1.1328 (1.1355) loss_fgl_dn_5: 0.9198 (0.9238) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4004 (0.4022) loss_bbox_dn_pre: 0.0513 (0.0571) loss_giou_dn_pre: 1.2251 (1.2243)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7307 data: 0.4839 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5378 data: 0.1718 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5548 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.009\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.081\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.346\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.044\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.058\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.207\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.350\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.134\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.032\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [21] [ 0/84] eta: 0:02:47 lr: 0.000013 loss: 43.2279 (43.2279) loss_vfl: 0.1978 (0.1978) loss_bbox: 0.6738 (0.6738) loss_giou: 2.0710 (2.0710) loss_fgl: 0.3151 (0.3151) loss_vfl_aux_0: 0.1921 (0.1921) loss_bbox_aux_0: 0.6817 (0.6817) loss_giou_aux_0: 2.0898 (2.0898) loss_fgl_aux_0: 0.3124 (0.3124) loss_ddf_aux_0: 0.0947 (0.0947) loss_vfl_aux_1: 0.1937 (0.1937) loss_bbox_aux_1: 0.6760 (0.6760) loss_giou_aux_1: 2.0703 (2.0703) loss_fgl_aux_1: 0.3147 (0.3147) loss_ddf_aux_1: 0.0119 (0.0119) loss_vfl_aux_2: 0.1936 (0.1936) loss_bbox_aux_2: 0.6745 (0.6745) loss_giou_aux_2: 2.0705 (2.0705) loss_fgl_aux_2: 0.3150 (0.3150) loss_ddf_aux_2: 0.0015 (0.0015) loss_vfl_aux_3: 0.1937 (0.1937) loss_bbox_aux_3: 0.6741 (0.6741) loss_giou_aux_3: 2.0708 (2.0708) loss_fgl_aux_3: 0.3151 (0.3151) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1948 (0.1948) loss_bbox_aux_4: 0.6739 (0.6739) loss_giou_aux_4: 2.0708 (2.0708) loss_fgl_aux_4: 0.3152 (0.3152) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1881 (0.1881) loss_bbox_pre: 0.6869 (0.6869) loss_giou_pre: 2.0859 (2.0859) loss_vfl_enc_0: 0.1836 (0.1836) loss_bbox_enc_0: 0.7226 (0.7226) loss_giou_enc_0: 2.1037 (2.1037) loss_vfl_dn_0: 0.4324 (0.4324) loss_bbox_dn_0: 0.0845 (0.0845) loss_giou_dn_0: 1.1787 (1.1787) loss_fgl_dn_0: 0.9406 (0.9406) loss_ddf_dn_0: 0.1955 (0.1955) loss_vfl_dn_1: 0.4622 (0.4622) loss_bbox_dn_1: 0.0759 (0.0759) loss_giou_dn_1: 1.1063 (1.1063) loss_fgl_dn_1: 0.9629 (0.9629) loss_ddf_dn_1: 0.0348 (0.0348) loss_vfl_dn_2: 0.4673 (0.4673) loss_bbox_dn_2: 0.0731 (0.0731) loss_giou_dn_2: 1.1026 (1.1026) loss_fgl_dn_2: 0.9632 (0.9632) loss_ddf_dn_2: 0.0036 (0.0036) loss_vfl_dn_3: 0.4666 (0.4666) loss_bbox_dn_3: 0.0725 (0.0725) loss_giou_dn_3: 1.1005 (1.1005) loss_fgl_dn_3: 0.9638 (0.9638) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4690 (0.4690) loss_bbox_dn_4: 0.0723 (0.0723) loss_giou_dn_4: 1.0999 (1.0999) loss_fgl_dn_4: 0.9637 (0.9637) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4707 (0.4707) loss_bbox_dn_5: 0.0723 (0.0723) loss_giou_dn_5: 1.0999 (1.0999) loss_fgl_dn_5: 0.9638 (0.9638) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4277 (0.4277) loss_bbox_dn_pre: 0.0858 (0.0858) loss_giou_dn_pre: 1.1852 (1.1852) time: 1.9911 data: 1.0905 max mem: 29821\n", + "Epoch: [21] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.1083 (39.1843) loss_vfl: 0.1361 (0.1664) loss_bbox: 0.3352 (0.3510) loss_giou: 1.9169 (1.8986) loss_fgl: 0.3453 (0.3835) loss_vfl_aux_0: 0.1333 (0.1632) loss_bbox_aux_0: 0.3448 (0.3572) loss_giou_aux_0: 1.9092 (1.9107) loss_fgl_aux_0: 0.3472 (0.3805) loss_ddf_aux_0: 0.0930 (0.1324) loss_vfl_aux_1: 0.1394 (0.1692) loss_bbox_aux_1: 0.3364 (0.3517) loss_giou_aux_1: 1.9170 (1.9007) loss_fgl_aux_1: 0.3463 (0.3829) loss_ddf_aux_1: 0.0142 (0.0188) loss_vfl_aux_2: 0.1378 (0.1683) loss_bbox_aux_2: 0.3351 (0.3512) loss_giou_aux_2: 1.9172 (1.8988) loss_fgl_aux_2: 0.3452 (0.3833) loss_ddf_aux_2: 0.0015 (0.0028) loss_vfl_aux_3: 0.1371 (0.1667) loss_bbox_aux_3: 0.3353 (0.3510) loss_giou_aux_3: 1.9168 (1.8986) loss_fgl_aux_3: 0.3453 (0.3835) loss_ddf_aux_3: 0.0002 (0.0004) loss_vfl_aux_4: 0.1371 (0.1663) loss_bbox_aux_4: 0.3353 (0.3510) loss_giou_aux_4: 1.9169 (1.8985) loss_fgl_aux_4: 0.3453 (0.3835) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1306 (0.1607) loss_bbox_pre: 0.3518 (0.3684) loss_giou_pre: 1.9017 (1.9037) loss_vfl_enc_0: 0.1187 (0.1524) loss_bbox_enc_0: 0.3690 (0.3942) loss_giou_enc_0: 1.9553 (1.9430) loss_vfl_dn_0: 0.4004 (0.3871) loss_bbox_dn_0: 0.0498 (0.0584) loss_giou_dn_0: 1.2319 (1.2732) loss_fgl_dn_0: 0.8925 (0.8682) loss_ddf_dn_0: 0.1801 (0.2389) loss_vfl_dn_1: 0.4487 (0.4403) loss_bbox_dn_1: 0.0423 (0.0489) loss_giou_dn_1: 1.1510 (1.1562) loss_fgl_dn_1: 0.9220 (0.9041) loss_ddf_dn_1: 0.0441 (0.0430) loss_vfl_dn_2: 0.4500 (0.4435) loss_bbox_dn_2: 0.0420 (0.0469) loss_giou_dn_2: 1.1285 (1.1384) loss_fgl_dn_2: 0.9278 (0.9102) loss_ddf_dn_2: 0.0033 (0.0051) loss_vfl_dn_3: 0.4521 (0.4418) loss_bbox_dn_3: 0.0420 (0.0465) loss_giou_dn_3: 1.1268 (1.1365) loss_fgl_dn_3: 0.9280 (0.9109) loss_ddf_dn_3: 0.0004 (0.0007) loss_vfl_dn_4: 0.4514 (0.4419) loss_bbox_dn_4: 0.0419 (0.0464) loss_giou_dn_4: 1.1261 (1.1362) loss_fgl_dn_4: 0.9284 (0.9111) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4509 (0.4428) loss_bbox_dn_5: 0.0419 (0.0464) loss_giou_dn_5: 1.1260 (1.1362) loss_fgl_dn_5: 0.9284 (0.9112) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3994 (0.3861) loss_bbox_dn_pre: 0.0487 (0.0583) loss_giou_dn_pre: 1.2343 (1.2751) time: 0.8691 data: 0.0229 max mem: 29821\n", + "Epoch: [21] Total time: 0:01:15 (0.9026 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.1083 (39.1843) loss_vfl: 0.1361 (0.1664) loss_bbox: 0.3352 (0.3510) loss_giou: 1.9169 (1.8986) loss_fgl: 0.3453 (0.3835) loss_vfl_aux_0: 0.1333 (0.1632) loss_bbox_aux_0: 0.3448 (0.3572) loss_giou_aux_0: 1.9092 (1.9107) loss_fgl_aux_0: 0.3472 (0.3805) loss_ddf_aux_0: 0.0930 (0.1324) loss_vfl_aux_1: 0.1394 (0.1692) loss_bbox_aux_1: 0.3364 (0.3517) loss_giou_aux_1: 1.9170 (1.9007) loss_fgl_aux_1: 0.3463 (0.3829) loss_ddf_aux_1: 0.0142 (0.0188) loss_vfl_aux_2: 0.1378 (0.1683) loss_bbox_aux_2: 0.3351 (0.3512) loss_giou_aux_2: 1.9172 (1.8988) loss_fgl_aux_2: 0.3452 (0.3833) loss_ddf_aux_2: 0.0015 (0.0028) loss_vfl_aux_3: 0.1371 (0.1667) loss_bbox_aux_3: 0.3353 (0.3510) loss_giou_aux_3: 1.9168 (1.8986) loss_fgl_aux_3: 0.3453 (0.3835) loss_ddf_aux_3: 0.0002 (0.0004) loss_vfl_aux_4: 0.1371 (0.1663) loss_bbox_aux_4: 0.3353 (0.3510) loss_giou_aux_4: 1.9169 (1.8985) loss_fgl_aux_4: 0.3453 (0.3835) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1306 (0.1607) loss_bbox_pre: 0.3518 (0.3684) loss_giou_pre: 1.9017 (1.9037) loss_vfl_enc_0: 0.1187 (0.1524) loss_bbox_enc_0: 0.3690 (0.3942) loss_giou_enc_0: 1.9553 (1.9430) loss_vfl_dn_0: 0.4004 (0.3871) loss_bbox_dn_0: 0.0498 (0.0584) loss_giou_dn_0: 1.2319 (1.2732) loss_fgl_dn_0: 0.8925 (0.8682) loss_ddf_dn_0: 0.1801 (0.2389) loss_vfl_dn_1: 0.4487 (0.4403) loss_bbox_dn_1: 0.0423 (0.0489) loss_giou_dn_1: 1.1510 (1.1562) loss_fgl_dn_1: 0.9220 (0.9041) loss_ddf_dn_1: 0.0441 (0.0430) loss_vfl_dn_2: 0.4500 (0.4435) loss_bbox_dn_2: 0.0420 (0.0469) loss_giou_dn_2: 1.1285 (1.1384) loss_fgl_dn_2: 0.9278 (0.9102) loss_ddf_dn_2: 0.0033 (0.0051) loss_vfl_dn_3: 0.4521 (0.4418) loss_bbox_dn_3: 0.0420 (0.0465) loss_giou_dn_3: 1.1268 (1.1365) loss_fgl_dn_3: 0.9280 (0.9109) loss_ddf_dn_3: 0.0004 (0.0007) loss_vfl_dn_4: 0.4514 (0.4419) loss_bbox_dn_4: 0.0419 (0.0464) loss_giou_dn_4: 1.1261 (1.1362) loss_fgl_dn_4: 0.9284 (0.9111) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4509 (0.4428) loss_bbox_dn_5: 0.0419 (0.0464) loss_giou_dn_5: 1.1260 (1.1362) loss_fgl_dn_5: 0.9284 (0.9112) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3994 (0.3861) loss_bbox_dn_pre: 0.0487 (0.0583) loss_giou_dn_pre: 1.2343 (1.2751)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7337 data: 0.4827 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3891 data: 0.1620 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4042 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.05s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.015\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.009\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.015\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.087\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.261\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.004\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.026\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.042\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.210\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.400\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.102\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.029\n", + "best_stat: {'epoch': 14, 'coco_eval_bbox': 0.018554424649616506}\n", + "Epoch: [22] [ 0/84] eta: 0:02:53 lr: 0.000013 loss: 39.9577 (39.9577) loss_vfl: 0.1813 (0.1813) loss_bbox: 0.4328 (0.4328) loss_giou: 1.9725 (1.9725) loss_fgl: 0.3289 (0.3289) loss_vfl_aux_0: 0.1954 (0.1954) loss_bbox_aux_0: 0.4337 (0.4337) loss_giou_aux_0: 1.9842 (1.9842) loss_fgl_aux_0: 0.3308 (0.3308) loss_ddf_aux_0: 0.0798 (0.0798) loss_vfl_aux_1: 0.1978 (0.1978) loss_bbox_aux_1: 0.4351 (0.4351) loss_giou_aux_1: 1.9695 (1.9695) loss_fgl_aux_1: 0.3293 (0.3293) loss_ddf_aux_1: 0.0121 (0.0121) loss_vfl_aux_2: 0.2001 (0.2001) loss_bbox_aux_2: 0.4332 (0.4332) loss_giou_aux_2: 1.9718 (1.9718) loss_fgl_aux_2: 0.3290 (0.3290) loss_ddf_aux_2: 0.0015 (0.0015) loss_vfl_aux_3: 0.1882 (0.1882) loss_bbox_aux_3: 0.4329 (0.4329) loss_giou_aux_3: 1.9721 (1.9721) loss_fgl_aux_3: 0.3288 (0.3288) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1814 (0.1814) loss_bbox_aux_4: 0.4329 (0.4329) loss_giou_aux_4: 1.9721 (1.9721) loss_fgl_aux_4: 0.3289 (0.3289) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1927 (0.1927) loss_bbox_pre: 0.4366 (0.4366) loss_giou_pre: 1.9779 (1.9779) loss_vfl_enc_0: 0.1646 (0.1646) loss_bbox_enc_0: 0.4607 (0.4607) loss_giou_enc_0: 2.0365 (2.0365) loss_vfl_dn_0: 0.3806 (0.3806) loss_bbox_dn_0: 0.0493 (0.0493) loss_giou_dn_0: 1.2562 (1.2562) loss_fgl_dn_0: 0.8438 (0.8438) loss_ddf_dn_0: 0.2119 (0.2119) loss_vfl_dn_1: 0.4578 (0.4578) loss_bbox_dn_1: 0.0385 (0.0385) loss_giou_dn_1: 1.1334 (1.1334) loss_fgl_dn_1: 0.9036 (0.9036) loss_ddf_dn_1: 0.0432 (0.0432) loss_vfl_dn_2: 0.4609 (0.4609) loss_bbox_dn_2: 0.0364 (0.0364) loss_giou_dn_2: 1.1073 (1.1073) loss_fgl_dn_2: 0.9088 (0.9088) loss_ddf_dn_2: 0.0044 (0.0044) loss_vfl_dn_3: 0.4563 (0.4563) loss_bbox_dn_3: 0.0361 (0.0361) loss_giou_dn_3: 1.1062 (1.1062) loss_fgl_dn_3: 0.9089 (0.9089) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4507 (0.4507) loss_bbox_dn_4: 0.0359 (0.0359) loss_giou_dn_4: 1.1057 (1.1057) loss_fgl_dn_4: 0.9092 (0.9092) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4539 (0.4539) loss_bbox_dn_5: 0.0359 (0.0359) loss_giou_dn_5: 1.1057 (1.1057) loss_fgl_dn_5: 0.9092 (0.9092) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3845 (0.3845) loss_bbox_dn_pre: 0.0490 (0.0490) loss_giou_dn_pre: 1.2480 (1.2480) time: 2.0597 data: 1.1475 max mem: 29821\n", + "Epoch: [22] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5792 (38.8645) loss_vfl: 0.1307 (0.1573) loss_bbox: 0.3078 (0.3458) loss_giou: 1.9356 (1.8924) loss_fgl: 0.3320 (0.3665) loss_vfl_aux_0: 0.1320 (0.1575) loss_bbox_aux_0: 0.3111 (0.3486) loss_giou_aux_0: 1.9371 (1.9037) loss_fgl_aux_0: 0.3306 (0.3651) loss_ddf_aux_0: 0.1418 (0.1218) loss_vfl_aux_1: 0.1334 (0.1607) loss_bbox_aux_1: 0.3097 (0.3470) loss_giou_aux_1: 1.9337 (1.8930) loss_fgl_aux_1: 0.3335 (0.3660) loss_ddf_aux_1: 0.0202 (0.0164) loss_vfl_aux_2: 0.1287 (0.1590) loss_bbox_aux_2: 0.3080 (0.3460) loss_giou_aux_2: 1.9353 (1.8924) loss_fgl_aux_2: 0.3322 (0.3664) loss_ddf_aux_2: 0.0024 (0.0019) loss_vfl_aux_3: 0.1312 (0.1576) loss_bbox_aux_3: 0.3078 (0.3459) loss_giou_aux_3: 1.9354 (1.8923) loss_fgl_aux_3: 0.3321 (0.3665) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1302 (0.1571) loss_bbox_aux_4: 0.3079 (0.3459) loss_giou_aux_4: 1.9356 (1.8923) loss_fgl_aux_4: 0.3321 (0.3665) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1307 (0.1550) loss_bbox_pre: 0.3167 (0.3527) loss_giou_pre: 1.9333 (1.8987) loss_vfl_enc_0: 0.1274 (0.1473) loss_bbox_enc_0: 0.3303 (0.3712) loss_giou_enc_0: 1.9777 (1.9364) loss_vfl_dn_0: 0.3750 (0.3938) loss_bbox_dn_0: 0.0509 (0.0552) loss_giou_dn_0: 1.2832 (1.2529) loss_fgl_dn_0: 0.8559 (0.8789) loss_ddf_dn_0: 0.2838 (0.2314) loss_vfl_dn_1: 0.4214 (0.4389) loss_bbox_dn_1: 0.0423 (0.0467) loss_giou_dn_1: 1.1771 (1.1580) loss_fgl_dn_1: 0.8794 (0.9091) loss_ddf_dn_1: 0.0575 (0.0450) loss_vfl_dn_2: 0.4358 (0.4450) loss_bbox_dn_2: 0.0399 (0.0447) loss_giou_dn_2: 1.1491 (1.1366) loss_fgl_dn_2: 0.8938 (0.9162) loss_ddf_dn_2: 0.0039 (0.0036) loss_vfl_dn_3: 0.4316 (0.4414) loss_bbox_dn_3: 0.0396 (0.0445) loss_giou_dn_3: 1.1481 (1.1357) loss_fgl_dn_3: 0.8947 (0.9167) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4324 (0.4405) loss_bbox_dn_4: 0.0398 (0.0444) loss_giou_dn_4: 1.1485 (1.1356) loss_fgl_dn_4: 0.8948 (0.9169) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4324 (0.4411) loss_bbox_dn_5: 0.0398 (0.0444) loss_giou_dn_5: 1.1484 (1.1355) loss_fgl_dn_5: 0.8948 (0.9170) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3735 (0.3931) loss_bbox_dn_pre: 0.0497 (0.0549) loss_giou_dn_pre: 1.2770 (1.2527) time: 0.8853 data: 0.0173 max mem: 29821\n", + "Epoch: [22] Total time: 0:01:15 (0.8960 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5792 (38.8645) loss_vfl: 0.1307 (0.1573) loss_bbox: 0.3078 (0.3458) loss_giou: 1.9356 (1.8924) loss_fgl: 0.3320 (0.3665) loss_vfl_aux_0: 0.1320 (0.1575) loss_bbox_aux_0: 0.3111 (0.3486) loss_giou_aux_0: 1.9371 (1.9037) loss_fgl_aux_0: 0.3306 (0.3651) loss_ddf_aux_0: 0.1418 (0.1218) loss_vfl_aux_1: 0.1334 (0.1607) loss_bbox_aux_1: 0.3097 (0.3470) loss_giou_aux_1: 1.9337 (1.8930) loss_fgl_aux_1: 0.3335 (0.3660) loss_ddf_aux_1: 0.0202 (0.0164) loss_vfl_aux_2: 0.1287 (0.1590) loss_bbox_aux_2: 0.3080 (0.3460) loss_giou_aux_2: 1.9353 (1.8924) loss_fgl_aux_2: 0.3322 (0.3664) loss_ddf_aux_2: 0.0024 (0.0019) loss_vfl_aux_3: 0.1312 (0.1576) loss_bbox_aux_3: 0.3078 (0.3459) loss_giou_aux_3: 1.9354 (1.8923) loss_fgl_aux_3: 0.3321 (0.3665) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1302 (0.1571) loss_bbox_aux_4: 0.3079 (0.3459) loss_giou_aux_4: 1.9356 (1.8923) loss_fgl_aux_4: 0.3321 (0.3665) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1307 (0.1550) loss_bbox_pre: 0.3167 (0.3527) loss_giou_pre: 1.9333 (1.8987) loss_vfl_enc_0: 0.1274 (0.1473) loss_bbox_enc_0: 0.3303 (0.3712) loss_giou_enc_0: 1.9777 (1.9364) loss_vfl_dn_0: 0.3750 (0.3938) loss_bbox_dn_0: 0.0509 (0.0552) loss_giou_dn_0: 1.2832 (1.2529) loss_fgl_dn_0: 0.8559 (0.8789) loss_ddf_dn_0: 0.2838 (0.2314) loss_vfl_dn_1: 0.4214 (0.4389) loss_bbox_dn_1: 0.0423 (0.0467) loss_giou_dn_1: 1.1771 (1.1580) loss_fgl_dn_1: 0.8794 (0.9091) loss_ddf_dn_1: 0.0575 (0.0450) loss_vfl_dn_2: 0.4358 (0.4450) loss_bbox_dn_2: 0.0399 (0.0447) loss_giou_dn_2: 1.1491 (1.1366) loss_fgl_dn_2: 0.8938 (0.9162) loss_ddf_dn_2: 0.0039 (0.0036) loss_vfl_dn_3: 0.4316 (0.4414) loss_bbox_dn_3: 0.0396 (0.0445) loss_giou_dn_3: 1.1481 (1.1357) loss_fgl_dn_3: 0.8947 (0.9167) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4324 (0.4405) loss_bbox_dn_4: 0.0398 (0.0444) loss_giou_dn_4: 1.1485 (1.1356) loss_fgl_dn_4: 0.8948 (0.9169) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4324 (0.4411) loss_bbox_dn_5: 0.0398 (0.0444) loss_giou_dn_5: 1.1484 (1.1355) loss_fgl_dn_5: 0.8948 (0.9170) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3735 (0.3931) loss_bbox_dn_pre: 0.0497 (0.0549) loss_giou_dn_pre: 1.2770 (1.2527)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7964 data: 0.5430 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4243 data: 0.1882 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4392 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.048\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.127\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.724\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.014\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.041\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.055\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.053\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.267\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.825\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.120\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.034\n", + "best_stat: {'epoch': 22, 'coco_eval_bbox': 0.01885204964041436}\n", + "Epoch: [23] [ 0/84] eta: 0:02:10 lr: 0.000013 loss: 39.2771 (39.2771) loss_vfl: 0.1803 (0.1803) loss_bbox: 0.3172 (0.3172) loss_giou: 1.8470 (1.8470) loss_fgl: 0.4315 (0.4315) loss_vfl_aux_0: 0.1744 (0.1744) loss_bbox_aux_0: 0.3144 (0.3144) loss_giou_aux_0: 1.8747 (1.8747) loss_fgl_aux_0: 0.4250 (0.4250) loss_ddf_aux_0: 0.1988 (0.1988) loss_vfl_aux_1: 0.1783 (0.1783) loss_bbox_aux_1: 0.3222 (0.3222) loss_giou_aux_1: 1.8465 (1.8465) loss_fgl_aux_1: 0.4283 (0.4283) loss_ddf_aux_1: 0.0344 (0.0344) loss_vfl_aux_2: 0.1853 (0.1853) loss_bbox_aux_2: 0.3179 (0.3179) loss_giou_aux_2: 1.8470 (1.8470) loss_fgl_aux_2: 0.4309 (0.4309) loss_ddf_aux_2: 0.0035 (0.0035) loss_vfl_aux_3: 0.1809 (0.1809) loss_bbox_aux_3: 0.3175 (0.3175) loss_giou_aux_3: 1.8471 (1.8471) loss_fgl_aux_3: 0.4313 (0.4313) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1813 (0.1813) loss_bbox_aux_4: 0.3173 (0.3173) loss_giou_aux_4: 1.8470 (1.8470) loss_fgl_aux_4: 0.4315 (0.4315) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1744 (0.1744) loss_bbox_pre: 0.3185 (0.3185) loss_giou_pre: 1.8652 (1.8652) loss_vfl_enc_0: 0.1635 (0.1635) loss_bbox_enc_0: 0.3338 (0.3338) loss_giou_enc_0: 1.9102 (1.9102) loss_vfl_dn_0: 0.4009 (0.4009) loss_bbox_dn_0: 0.0786 (0.0786) loss_giou_dn_0: 1.2882 (1.2882) loss_fgl_dn_0: 0.8628 (0.8628) loss_ddf_dn_0: 0.3611 (0.3611) loss_vfl_dn_1: 0.4478 (0.4478) loss_bbox_dn_1: 0.0667 (0.0667) loss_giou_dn_1: 1.1660 (1.1660) loss_fgl_dn_1: 0.8932 (0.8932) loss_ddf_dn_1: 0.0655 (0.0655) loss_vfl_dn_2: 0.4521 (0.4521) loss_bbox_dn_2: 0.0645 (0.0645) loss_giou_dn_2: 1.1412 (1.1412) loss_fgl_dn_2: 0.9005 (0.9005) loss_ddf_dn_2: 0.0043 (0.0043) loss_vfl_dn_3: 0.4438 (0.4438) loss_bbox_dn_3: 0.0644 (0.0644) loss_giou_dn_3: 1.1414 (1.1414) loss_fgl_dn_3: 0.9004 (0.9004) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4375 (0.4375) loss_bbox_dn_4: 0.0645 (0.0645) loss_giou_dn_4: 1.1421 (1.1421) loss_fgl_dn_4: 0.9002 (0.9002) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4377 (0.4377) loss_bbox_dn_5: 0.0645 (0.0645) loss_giou_dn_5: 1.1421 (1.1421) loss_fgl_dn_5: 0.9002 (0.9002) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3977 (0.3977) loss_bbox_dn_pre: 0.0791 (0.0791) loss_giou_dn_pre: 1.2900 (1.2900) time: 1.5581 data: 0.7043 max mem: 29821\n", + "Epoch: [23] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.6944 (38.8261) loss_vfl: 0.1919 (0.1645) loss_bbox: 0.3097 (0.3315) loss_giou: 1.8144 (1.8800) loss_fgl: 0.4155 (0.3821) loss_vfl_aux_0: 0.1958 (0.1662) loss_bbox_aux_0: 0.3101 (0.3321) loss_giou_aux_0: 1.8238 (1.8935) loss_fgl_aux_0: 0.4080 (0.3808) loss_ddf_aux_0: 0.0908 (0.1243) loss_vfl_aux_1: 0.1929 (0.1689) loss_bbox_aux_1: 0.3098 (0.3316) loss_giou_aux_1: 1.8149 (1.8821) loss_fgl_aux_1: 0.4146 (0.3818) loss_ddf_aux_1: 0.0151 (0.0172) loss_vfl_aux_2: 0.1891 (0.1671) loss_bbox_aux_2: 0.3097 (0.3312) loss_giou_aux_2: 1.8146 (1.8806) loss_fgl_aux_2: 0.4158 (0.3821) loss_ddf_aux_2: 0.0018 (0.0024) loss_vfl_aux_3: 0.1893 (0.1647) loss_bbox_aux_3: 0.3096 (0.3313) loss_giou_aux_3: 1.8145 (1.8803) loss_fgl_aux_3: 0.4154 (0.3821) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1926 (0.1644) loss_bbox_aux_4: 0.3097 (0.3315) loss_giou_aux_4: 1.8144 (1.8800) loss_fgl_aux_4: 0.4155 (0.3821) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1914 (0.1629) loss_bbox_pre: 0.3181 (0.3391) loss_giou_pre: 1.8136 (1.8851) loss_vfl_enc_0: 0.1876 (0.1546) loss_bbox_enc_0: 0.3373 (0.3599) loss_giou_enc_0: 1.8634 (1.9245) loss_vfl_dn_0: 0.4167 (0.4026) loss_bbox_dn_0: 0.0647 (0.0584) loss_giou_dn_0: 1.2055 (1.2282) loss_fgl_dn_0: 0.9128 (0.8957) loss_ddf_dn_0: 0.2025 (0.2308) loss_vfl_dn_1: 0.4573 (0.4457) loss_bbox_dn_1: 0.0531 (0.0498) loss_giou_dn_1: 1.1181 (1.1401) loss_fgl_dn_1: 0.9397 (0.9232) loss_ddf_dn_1: 0.0371 (0.0367) loss_vfl_dn_2: 0.4541 (0.4483) loss_bbox_dn_2: 0.0524 (0.0483) loss_giou_dn_2: 1.1013 (1.1248) loss_fgl_dn_2: 0.9437 (0.9276) loss_ddf_dn_2: 0.0032 (0.0039) loss_vfl_dn_3: 0.4497 (0.4442) loss_bbox_dn_3: 0.0526 (0.0480) loss_giou_dn_3: 1.1010 (1.1237) loss_fgl_dn_3: 0.9437 (0.9280) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4526 (0.4434) loss_bbox_dn_4: 0.0523 (0.0479) loss_giou_dn_4: 1.1006 (1.1234) loss_fgl_dn_4: 0.9438 (0.9282) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4507 (0.4438) loss_bbox_dn_5: 0.0524 (0.0479) loss_giou_dn_5: 1.1005 (1.1234) loss_fgl_dn_5: 0.9438 (0.9282) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4143 (0.4014) loss_bbox_dn_pre: 0.0641 (0.0586) loss_giou_dn_pre: 1.2076 (1.2285) time: 0.7827 data: 0.0180 max mem: 29821\n", + "Epoch: [23] Total time: 0:01:12 (0.8619 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.6944 (38.8261) loss_vfl: 0.1919 (0.1645) loss_bbox: 0.3097 (0.3315) loss_giou: 1.8144 (1.8800) loss_fgl: 0.4155 (0.3821) loss_vfl_aux_0: 0.1958 (0.1662) loss_bbox_aux_0: 0.3101 (0.3321) loss_giou_aux_0: 1.8238 (1.8935) loss_fgl_aux_0: 0.4080 (0.3808) loss_ddf_aux_0: 0.0908 (0.1243) loss_vfl_aux_1: 0.1929 (0.1689) loss_bbox_aux_1: 0.3098 (0.3316) loss_giou_aux_1: 1.8149 (1.8821) loss_fgl_aux_1: 0.4146 (0.3818) loss_ddf_aux_1: 0.0151 (0.0172) loss_vfl_aux_2: 0.1891 (0.1671) loss_bbox_aux_2: 0.3097 (0.3312) loss_giou_aux_2: 1.8146 (1.8806) loss_fgl_aux_2: 0.4158 (0.3821) loss_ddf_aux_2: 0.0018 (0.0024) loss_vfl_aux_3: 0.1893 (0.1647) loss_bbox_aux_3: 0.3096 (0.3313) loss_giou_aux_3: 1.8145 (1.8803) loss_fgl_aux_3: 0.4154 (0.3821) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1926 (0.1644) loss_bbox_aux_4: 0.3097 (0.3315) loss_giou_aux_4: 1.8144 (1.8800) loss_fgl_aux_4: 0.4155 (0.3821) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1914 (0.1629) loss_bbox_pre: 0.3181 (0.3391) loss_giou_pre: 1.8136 (1.8851) loss_vfl_enc_0: 0.1876 (0.1546) loss_bbox_enc_0: 0.3373 (0.3599) loss_giou_enc_0: 1.8634 (1.9245) loss_vfl_dn_0: 0.4167 (0.4026) loss_bbox_dn_0: 0.0647 (0.0584) loss_giou_dn_0: 1.2055 (1.2282) loss_fgl_dn_0: 0.9128 (0.8957) loss_ddf_dn_0: 0.2025 (0.2308) loss_vfl_dn_1: 0.4573 (0.4457) loss_bbox_dn_1: 0.0531 (0.0498) loss_giou_dn_1: 1.1181 (1.1401) loss_fgl_dn_1: 0.9397 (0.9232) loss_ddf_dn_1: 0.0371 (0.0367) loss_vfl_dn_2: 0.4541 (0.4483) loss_bbox_dn_2: 0.0524 (0.0483) loss_giou_dn_2: 1.1013 (1.1248) loss_fgl_dn_2: 0.9437 (0.9276) loss_ddf_dn_2: 0.0032 (0.0039) loss_vfl_dn_3: 0.4497 (0.4442) loss_bbox_dn_3: 0.0526 (0.0480) loss_giou_dn_3: 1.1010 (1.1237) loss_fgl_dn_3: 0.9437 (0.9280) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4526 (0.4434) loss_bbox_dn_4: 0.0523 (0.0479) loss_giou_dn_4: 1.1006 (1.1234) loss_fgl_dn_4: 0.9438 (0.9282) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4507 (0.4438) loss_bbox_dn_5: 0.0524 (0.0479) loss_giou_dn_5: 1.1005 (1.1234) loss_fgl_dn_5: 0.9438 (0.9282) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4143 (0.4014) loss_bbox_dn_pre: 0.0641 (0.0586) loss_giou_dn_pre: 1.2076 (1.2285)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7622 data: 0.5113 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3980 data: 0.1694 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4124 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.063\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.159\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.401\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.007\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.044\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.061\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.057\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.383\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.450\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.142\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.043\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [24] [ 0/84] eta: 0:02:38 lr: 0.000013 loss: 37.5161 (37.5161) loss_vfl: 0.1028 (0.1028) loss_bbox: 0.3173 (0.3173) loss_giou: 1.8740 (1.8740) loss_fgl: 0.3179 (0.3179) loss_vfl_aux_0: 0.1022 (0.1022) loss_bbox_aux_0: 0.3183 (0.3183) loss_giou_aux_0: 1.8910 (1.8910) loss_fgl_aux_0: 0.3171 (0.3171) loss_ddf_aux_0: 0.1219 (0.1219) loss_vfl_aux_1: 0.1069 (0.1069) loss_bbox_aux_1: 0.3174 (0.3174) loss_giou_aux_1: 1.8778 (1.8778) loss_fgl_aux_1: 0.3174 (0.3174) loss_ddf_aux_1: 0.0204 (0.0204) loss_vfl_aux_2: 0.1085 (0.1085) loss_bbox_aux_2: 0.3172 (0.3172) loss_giou_aux_2: 1.8747 (1.8747) loss_fgl_aux_2: 0.3177 (0.3177) loss_ddf_aux_2: 0.0029 (0.0029) loss_vfl_aux_3: 0.1033 (0.1033) loss_bbox_aux_3: 0.3172 (0.3172) loss_giou_aux_3: 1.8743 (1.8743) loss_fgl_aux_3: 0.3178 (0.3178) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1024 (0.1024) loss_bbox_aux_4: 0.3174 (0.3174) loss_giou_aux_4: 1.8740 (1.8740) loss_fgl_aux_4: 0.3179 (0.3179) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1002 (0.1002) loss_bbox_pre: 0.3265 (0.3265) loss_giou_pre: 1.8833 (1.8833) loss_vfl_enc_0: 0.0948 (0.0948) loss_bbox_enc_0: 0.3577 (0.3577) loss_giou_enc_0: 1.9182 (1.9182) loss_vfl_dn_0: 0.3801 (0.3801) loss_bbox_dn_0: 0.0520 (0.0520) loss_giou_dn_0: 1.2391 (1.2391) loss_fgl_dn_0: 0.8620 (0.8620) loss_ddf_dn_0: 0.1448 (0.1448) loss_vfl_dn_1: 0.4380 (0.4380) loss_bbox_dn_1: 0.0389 (0.0389) loss_giou_dn_1: 1.1404 (1.1404) loss_fgl_dn_1: 0.9104 (0.9104) loss_ddf_dn_1: 0.0195 (0.0195) loss_vfl_dn_2: 0.4363 (0.4363) loss_bbox_dn_2: 0.0372 (0.0372) loss_giou_dn_2: 1.1347 (1.1347) loss_fgl_dn_2: 0.9118 (0.9118) loss_ddf_dn_2: 0.0016 (0.0016) loss_vfl_dn_3: 0.4390 (0.4390) loss_bbox_dn_3: 0.0371 (0.0371) loss_giou_dn_3: 1.1347 (1.1347) loss_fgl_dn_3: 0.9120 (0.9120) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4407 (0.4407) loss_bbox_dn_4: 0.0371 (0.0371) loss_giou_dn_4: 1.1347 (1.1347) loss_fgl_dn_4: 0.9120 (0.9120) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4397 (0.4397) loss_bbox_dn_5: 0.0371 (0.0371) loss_giou_dn_5: 1.1347 (1.1347) loss_fgl_dn_5: 0.9120 (0.9120) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3831 (0.3831) loss_bbox_dn_pre: 0.0515 (0.0515) loss_giou_dn_pre: 1.2345 (1.2345) time: 1.8878 data: 0.7601 max mem: 29821\n", + "Epoch: [24] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.3165 (38.4097) loss_vfl: 0.1536 (0.1630) loss_bbox: 0.3158 (0.3112) loss_giou: 1.8670 (1.8436) loss_fgl: 0.3650 (0.3868) loss_vfl_aux_0: 0.1548 (0.1662) loss_bbox_aux_0: 0.3217 (0.3126) loss_giou_aux_0: 1.8763 (1.8584) loss_fgl_aux_0: 0.3601 (0.3863) loss_ddf_aux_0: 0.1771 (0.1369) loss_vfl_aux_1: 0.1549 (0.1678) loss_bbox_aux_1: 0.3145 (0.3112) loss_giou_aux_1: 1.8674 (1.8460) loss_fgl_aux_1: 0.3644 (0.3869) loss_ddf_aux_1: 0.0248 (0.0202) loss_vfl_aux_2: 0.1553 (0.1663) loss_bbox_aux_2: 0.3165 (0.3113) loss_giou_aux_2: 1.8667 (1.8438) loss_fgl_aux_2: 0.3655 (0.3869) loss_ddf_aux_2: 0.0029 (0.0026) loss_vfl_aux_3: 0.1500 (0.1635) loss_bbox_aux_3: 0.3162 (0.3112) loss_giou_aux_3: 1.8668 (1.8436) loss_fgl_aux_3: 0.3651 (0.3868) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1511 (0.1627) loss_bbox_aux_4: 0.3161 (0.3113) loss_giou_aux_4: 1.8668 (1.8435) loss_fgl_aux_4: 0.3649 (0.3868) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1504 (0.1630) loss_bbox_pre: 0.3254 (0.3194) loss_giou_pre: 1.8680 (1.8524) loss_vfl_enc_0: 0.1436 (0.1541) loss_bbox_enc_0: 0.3331 (0.3389) loss_giou_enc_0: 1.9275 (1.8965) loss_vfl_dn_0: 0.4001 (0.3994) loss_bbox_dn_0: 0.0468 (0.0552) loss_giou_dn_0: 1.2213 (1.2364) loss_fgl_dn_0: 0.8916 (0.8911) loss_ddf_dn_0: 0.2398 (0.2428) loss_vfl_dn_1: 0.4460 (0.4440) loss_bbox_dn_1: 0.0402 (0.0464) loss_giou_dn_1: 1.1393 (1.1392) loss_fgl_dn_1: 0.9196 (0.9224) loss_ddf_dn_1: 0.0448 (0.0375) loss_vfl_dn_2: 0.4448 (0.4462) loss_bbox_dn_2: 0.0394 (0.0447) loss_giou_dn_2: 1.1167 (1.1242) loss_fgl_dn_2: 0.9282 (0.9272) loss_ddf_dn_2: 0.0050 (0.0038) loss_vfl_dn_3: 0.4424 (0.4437) loss_bbox_dn_3: 0.0395 (0.0445) loss_giou_dn_3: 1.1159 (1.1231) loss_fgl_dn_3: 0.9285 (0.9277) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4395 (0.4428) loss_bbox_dn_4: 0.0393 (0.0444) loss_giou_dn_4: 1.1160 (1.1230) loss_fgl_dn_4: 0.9286 (0.9279) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4387 (0.4430) loss_bbox_dn_5: 0.0392 (0.0444) loss_giou_dn_5: 1.1160 (1.1230) loss_fgl_dn_5: 0.9286 (0.9279) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4014 (0.3984) loss_bbox_dn_pre: 0.0468 (0.0552) loss_giou_dn_pre: 1.2224 (1.2372) time: 0.8800 data: 0.0174 max mem: 29821\n", + "Epoch: [24] Total time: 0:01:14 (0.8856 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.3165 (38.4097) loss_vfl: 0.1536 (0.1630) loss_bbox: 0.3158 (0.3112) loss_giou: 1.8670 (1.8436) loss_fgl: 0.3650 (0.3868) loss_vfl_aux_0: 0.1548 (0.1662) loss_bbox_aux_0: 0.3217 (0.3126) loss_giou_aux_0: 1.8763 (1.8584) loss_fgl_aux_0: 0.3601 (0.3863) loss_ddf_aux_0: 0.1771 (0.1369) loss_vfl_aux_1: 0.1549 (0.1678) loss_bbox_aux_1: 0.3145 (0.3112) loss_giou_aux_1: 1.8674 (1.8460) loss_fgl_aux_1: 0.3644 (0.3869) loss_ddf_aux_1: 0.0248 (0.0202) loss_vfl_aux_2: 0.1553 (0.1663) loss_bbox_aux_2: 0.3165 (0.3113) loss_giou_aux_2: 1.8667 (1.8438) loss_fgl_aux_2: 0.3655 (0.3869) loss_ddf_aux_2: 0.0029 (0.0026) loss_vfl_aux_3: 0.1500 (0.1635) loss_bbox_aux_3: 0.3162 (0.3112) loss_giou_aux_3: 1.8668 (1.8436) loss_fgl_aux_3: 0.3651 (0.3868) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1511 (0.1627) loss_bbox_aux_4: 0.3161 (0.3113) loss_giou_aux_4: 1.8668 (1.8435) loss_fgl_aux_4: 0.3649 (0.3868) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1504 (0.1630) loss_bbox_pre: 0.3254 (0.3194) loss_giou_pre: 1.8680 (1.8524) loss_vfl_enc_0: 0.1436 (0.1541) loss_bbox_enc_0: 0.3331 (0.3389) loss_giou_enc_0: 1.9275 (1.8965) loss_vfl_dn_0: 0.4001 (0.3994) loss_bbox_dn_0: 0.0468 (0.0552) loss_giou_dn_0: 1.2213 (1.2364) loss_fgl_dn_0: 0.8916 (0.8911) loss_ddf_dn_0: 0.2398 (0.2428) loss_vfl_dn_1: 0.4460 (0.4440) loss_bbox_dn_1: 0.0402 (0.0464) loss_giou_dn_1: 1.1393 (1.1392) loss_fgl_dn_1: 0.9196 (0.9224) loss_ddf_dn_1: 0.0448 (0.0375) loss_vfl_dn_2: 0.4448 (0.4462) loss_bbox_dn_2: 0.0394 (0.0447) loss_giou_dn_2: 1.1167 (1.1242) loss_fgl_dn_2: 0.9282 (0.9272) loss_ddf_dn_2: 0.0050 (0.0038) loss_vfl_dn_3: 0.4424 (0.4437) loss_bbox_dn_3: 0.0395 (0.0445) loss_giou_dn_3: 1.1159 (1.1231) loss_fgl_dn_3: 0.9285 (0.9277) loss_ddf_dn_3: 0.0007 (0.0006) loss_vfl_dn_4: 0.4395 (0.4428) loss_bbox_dn_4: 0.0393 (0.0444) loss_giou_dn_4: 1.1160 (1.1230) loss_fgl_dn_4: 0.9286 (0.9279) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4387 (0.4430) loss_bbox_dn_5: 0.0392 (0.0444) loss_giou_dn_5: 1.1160 (1.1230) loss_fgl_dn_5: 0.9286 (0.9279) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4014 (0.3984) loss_bbox_dn_pre: 0.0468 (0.0552) loss_giou_dn_pre: 1.2224 (1.2372)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7458 data: 0.4932 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4013 data: 0.1647 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4159 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.065\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.009\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.171\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.413\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.007\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.056\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.069\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.358\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.425\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.164\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.029\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [25] [ 0/84] eta: 0:02:38 lr: 0.000013 loss: 38.8252 (38.8252) loss_vfl: 0.1541 (0.1541) loss_bbox: 0.3258 (0.3258) loss_giou: 1.9083 (1.9083) loss_fgl: 0.3724 (0.3724) loss_vfl_aux_0: 0.1509 (0.1509) loss_bbox_aux_0: 0.3365 (0.3365) loss_giou_aux_0: 1.9089 (1.9089) loss_fgl_aux_0: 0.3705 (0.3705) loss_ddf_aux_0: 0.1478 (0.1478) loss_vfl_aux_1: 0.1532 (0.1532) loss_bbox_aux_1: 0.3263 (0.3263) loss_giou_aux_1: 1.9081 (1.9081) loss_fgl_aux_1: 0.3738 (0.3738) loss_ddf_aux_1: 0.0284 (0.0284) loss_vfl_aux_2: 0.1495 (0.1495) loss_bbox_aux_2: 0.3264 (0.3264) loss_giou_aux_2: 1.9072 (1.9072) loss_fgl_aux_2: 0.3730 (0.3730) loss_ddf_aux_2: 0.0075 (0.0075) loss_vfl_aux_3: 0.1494 (0.1494) loss_bbox_aux_3: 0.3262 (0.3262) loss_giou_aux_3: 1.9078 (1.9078) loss_fgl_aux_3: 0.3724 (0.3724) loss_ddf_aux_3: 0.0007 (0.0007) loss_vfl_aux_4: 0.1552 (0.1552) loss_bbox_aux_4: 0.3259 (0.3259) loss_giou_aux_4: 1.9081 (1.9081) loss_fgl_aux_4: 0.3723 (0.3723) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1469 (0.1469) loss_bbox_pre: 0.3442 (0.3442) loss_giou_pre: 1.9019 (1.9019) loss_vfl_enc_0: 0.1382 (0.1382) loss_bbox_enc_0: 0.3725 (0.3725) loss_giou_enc_0: 1.9285 (1.9285) loss_vfl_dn_0: 0.4104 (0.4104) loss_bbox_dn_0: 0.0454 (0.0454) loss_giou_dn_0: 1.2059 (1.2059) loss_fgl_dn_0: 0.9163 (0.9163) loss_ddf_dn_0: 0.2312 (0.2312) loss_vfl_dn_1: 0.4365 (0.4365) loss_bbox_dn_1: 0.0385 (0.0385) loss_giou_dn_1: 1.1411 (1.1411) loss_fgl_dn_1: 0.9339 (0.9339) loss_ddf_dn_1: 0.0530 (0.0530) loss_vfl_dn_2: 0.4495 (0.4495) loss_bbox_dn_2: 0.0359 (0.0359) loss_giou_dn_2: 1.1121 (1.1121) loss_fgl_dn_2: 0.9438 (0.9438) loss_ddf_dn_2: 0.0076 (0.0076) loss_vfl_dn_3: 0.4443 (0.4443) loss_bbox_dn_3: 0.0359 (0.0359) loss_giou_dn_3: 1.1127 (1.1127) loss_fgl_dn_3: 0.9435 (0.9435) loss_ddf_dn_3: 0.0011 (0.0011) loss_vfl_dn_4: 0.4482 (0.4482) loss_bbox_dn_4: 0.0360 (0.0360) loss_giou_dn_4: 1.1143 (1.1143) loss_fgl_dn_4: 0.9431 (0.9431) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4507 (0.4507) loss_bbox_dn_5: 0.0360 (0.0360) loss_giou_dn_5: 1.1144 (1.1144) loss_fgl_dn_5: 0.9431 (0.9431) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4089 (0.4089) loss_bbox_dn_pre: 0.0460 (0.0460) loss_giou_dn_pre: 1.2067 (1.2067) time: 1.8911 data: 0.9582 max mem: 29821\n", + "Epoch: [25] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.9456 (38.4224) loss_vfl: 0.1548 (0.1578) loss_bbox: 0.3150 (0.3066) loss_giou: 1.9291 (1.8674) loss_fgl: 0.3304 (0.3818) loss_vfl_aux_0: 0.1522 (0.1599) loss_bbox_aux_0: 0.3120 (0.3082) loss_giou_aux_0: 1.9339 (1.8807) loss_fgl_aux_0: 0.3302 (0.3817) loss_ddf_aux_0: 0.0939 (0.1054) loss_vfl_aux_1: 0.1548 (0.1627) loss_bbox_aux_1: 0.3190 (0.3075) loss_giou_aux_1: 1.9289 (1.8690) loss_fgl_aux_1: 0.3307 (0.3817) loss_ddf_aux_1: 0.0124 (0.0139) loss_vfl_aux_2: 0.1556 (0.1612) loss_bbox_aux_2: 0.3166 (0.3071) loss_giou_aux_2: 1.9290 (1.8673) loss_fgl_aux_2: 0.3303 (0.3816) loss_ddf_aux_2: 0.0017 (0.0020) loss_vfl_aux_3: 0.1539 (0.1588) loss_bbox_aux_3: 0.3157 (0.3068) loss_giou_aux_3: 1.9290 (1.8673) loss_fgl_aux_3: 0.3302 (0.3817) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1537 (0.1580) loss_bbox_aux_4: 0.3153 (0.3067) loss_giou_aux_4: 1.9290 (1.8673) loss_fgl_aux_4: 0.3303 (0.3818) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1503 (0.1567) loss_bbox_pre: 0.3177 (0.3142) loss_giou_pre: 1.9327 (1.8734) loss_vfl_enc_0: 0.1451 (0.1491) loss_bbox_enc_0: 0.3523 (0.3351) loss_giou_enc_0: 1.9903 (1.9152) loss_vfl_dn_0: 0.3982 (0.4062) loss_bbox_dn_0: 0.0469 (0.0534) loss_giou_dn_0: 1.2485 (1.2181) loss_fgl_dn_0: 0.8869 (0.9025) loss_ddf_dn_0: 0.2082 (0.2145) loss_vfl_dn_1: 0.4402 (0.4442) loss_bbox_dn_1: 0.0409 (0.0453) loss_giou_dn_1: 1.1503 (1.1393) loss_fgl_dn_1: 0.9164 (0.9288) loss_ddf_dn_1: 0.0240 (0.0372) loss_vfl_dn_2: 0.4424 (0.4484) loss_bbox_dn_2: 0.0401 (0.0439) loss_giou_dn_2: 1.1425 (1.1233) loss_fgl_dn_2: 0.9216 (0.9336) loss_ddf_dn_2: 0.0024 (0.0028) loss_vfl_dn_3: 0.4338 (0.4426) loss_bbox_dn_3: 0.0398 (0.0437) loss_giou_dn_3: 1.1415 (1.1228) loss_fgl_dn_3: 0.9220 (0.9338) loss_ddf_dn_3: 0.0006 (0.0005) loss_vfl_dn_4: 0.4348 (0.4419) loss_bbox_dn_4: 0.0397 (0.0436) loss_giou_dn_4: 1.1409 (1.1226) loss_fgl_dn_4: 0.9222 (0.9340) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4358 (0.4422) loss_bbox_dn_5: 0.0397 (0.0436) loss_giou_dn_5: 1.1408 (1.1226) loss_fgl_dn_5: 0.9222 (0.9340) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3975 (0.4051) loss_bbox_dn_pre: 0.0475 (0.0535) loss_giou_dn_pre: 1.2475 (1.2183) time: 0.8838 data: 0.0178 max mem: 29821\n", + "Epoch: [25] Total time: 0:01:14 (0.8830 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.9456 (38.4224) loss_vfl: 0.1548 (0.1578) loss_bbox: 0.3150 (0.3066) loss_giou: 1.9291 (1.8674) loss_fgl: 0.3304 (0.3818) loss_vfl_aux_0: 0.1522 (0.1599) loss_bbox_aux_0: 0.3120 (0.3082) loss_giou_aux_0: 1.9339 (1.8807) loss_fgl_aux_0: 0.3302 (0.3817) loss_ddf_aux_0: 0.0939 (0.1054) loss_vfl_aux_1: 0.1548 (0.1627) loss_bbox_aux_1: 0.3190 (0.3075) loss_giou_aux_1: 1.9289 (1.8690) loss_fgl_aux_1: 0.3307 (0.3817) loss_ddf_aux_1: 0.0124 (0.0139) loss_vfl_aux_2: 0.1556 (0.1612) loss_bbox_aux_2: 0.3166 (0.3071) loss_giou_aux_2: 1.9290 (1.8673) loss_fgl_aux_2: 0.3303 (0.3816) loss_ddf_aux_2: 0.0017 (0.0020) loss_vfl_aux_3: 0.1539 (0.1588) loss_bbox_aux_3: 0.3157 (0.3068) loss_giou_aux_3: 1.9290 (1.8673) loss_fgl_aux_3: 0.3302 (0.3817) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1537 (0.1580) loss_bbox_aux_4: 0.3153 (0.3067) loss_giou_aux_4: 1.9290 (1.8673) loss_fgl_aux_4: 0.3303 (0.3818) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1503 (0.1567) loss_bbox_pre: 0.3177 (0.3142) loss_giou_pre: 1.9327 (1.8734) loss_vfl_enc_0: 0.1451 (0.1491) loss_bbox_enc_0: 0.3523 (0.3351) loss_giou_enc_0: 1.9903 (1.9152) loss_vfl_dn_0: 0.3982 (0.4062) loss_bbox_dn_0: 0.0469 (0.0534) loss_giou_dn_0: 1.2485 (1.2181) loss_fgl_dn_0: 0.8869 (0.9025) loss_ddf_dn_0: 0.2082 (0.2145) loss_vfl_dn_1: 0.4402 (0.4442) loss_bbox_dn_1: 0.0409 (0.0453) loss_giou_dn_1: 1.1503 (1.1393) loss_fgl_dn_1: 0.9164 (0.9288) loss_ddf_dn_1: 0.0240 (0.0372) loss_vfl_dn_2: 0.4424 (0.4484) loss_bbox_dn_2: 0.0401 (0.0439) loss_giou_dn_2: 1.1425 (1.1233) loss_fgl_dn_2: 0.9216 (0.9336) loss_ddf_dn_2: 0.0024 (0.0028) loss_vfl_dn_3: 0.4338 (0.4426) loss_bbox_dn_3: 0.0398 (0.0437) loss_giou_dn_3: 1.1415 (1.1228) loss_fgl_dn_3: 0.9220 (0.9338) loss_ddf_dn_3: 0.0006 (0.0005) loss_vfl_dn_4: 0.4348 (0.4419) loss_bbox_dn_4: 0.0397 (0.0436) loss_giou_dn_4: 1.1409 (1.1226) loss_fgl_dn_4: 0.9222 (0.9340) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4358 (0.4422) loss_bbox_dn_5: 0.0397 (0.0436) loss_giou_dn_5: 1.1408 (1.1226) loss_fgl_dn_5: 0.9222 (0.9340) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3975 (0.4051) loss_bbox_dn_pre: 0.0475 (0.0535) loss_giou_dn_pre: 1.2475 (1.2183)\n", + "Test: [0/4] eta: 0:00:05 time: 1.2967 data: 0.4964 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5355 data: 0.1608 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5531 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.056\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.139\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.206\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.008\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.058\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.364\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.200\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.163\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.036\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [26] [ 0/84] eta: 0:02:33 lr: 0.000013 loss: 37.9496 (37.9496) loss_vfl: 0.2260 (0.2260) loss_bbox: 0.2826 (0.2826) loss_giou: 1.5754 (1.5754) loss_fgl: 0.5397 (0.5397) loss_vfl_aux_0: 0.2317 (0.2317) loss_bbox_aux_0: 0.2962 (0.2962) loss_giou_aux_0: 1.5992 (1.5992) loss_fgl_aux_0: 0.5331 (0.5331) loss_ddf_aux_0: 0.2131 (0.2131) loss_vfl_aux_1: 0.2412 (0.2412) loss_bbox_aux_1: 0.2862 (0.2862) loss_giou_aux_1: 1.5784 (1.5784) loss_fgl_aux_1: 0.5388 (0.5388) loss_ddf_aux_1: 0.0322 (0.0322) loss_vfl_aux_2: 0.2400 (0.2400) loss_bbox_aux_2: 0.2840 (0.2840) loss_giou_aux_2: 1.5763 (1.5763) loss_fgl_aux_2: 0.5398 (0.5398) loss_ddf_aux_2: 0.0060 (0.0060) loss_vfl_aux_3: 0.2290 (0.2290) loss_bbox_aux_3: 0.2830 (0.2830) loss_giou_aux_3: 1.5755 (1.5755) loss_fgl_aux_3: 0.5396 (0.5396) loss_ddf_aux_3: 0.0009 (0.0009) loss_vfl_aux_4: 0.2269 (0.2269) loss_bbox_aux_4: 0.2827 (0.2827) loss_giou_aux_4: 1.5754 (1.5754) loss_fgl_aux_4: 0.5397 (0.5397) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2262 (0.2262) loss_bbox_pre: 0.3009 (0.3009) loss_giou_pre: 1.5992 (1.5992) loss_vfl_enc_0: 0.2174 (0.2174) loss_bbox_enc_0: 0.3174 (0.3174) loss_giou_enc_0: 1.6629 (1.6629) loss_vfl_dn_0: 0.4272 (0.4272) loss_bbox_dn_0: 0.0694 (0.0694) loss_giou_dn_0: 1.1919 (1.1919) loss_fgl_dn_0: 0.9289 (0.9289) loss_ddf_dn_0: 0.3069 (0.3069) loss_vfl_dn_1: 0.4800 (0.4800) loss_bbox_dn_1: 0.0560 (0.0560) loss_giou_dn_1: 1.1022 (1.1022) loss_fgl_dn_1: 0.9553 (0.9553) loss_ddf_dn_1: 0.0370 (0.0370) loss_vfl_dn_2: 0.4792 (0.4792) loss_bbox_dn_2: 0.0542 (0.0542) loss_giou_dn_2: 1.0933 (1.0933) loss_fgl_dn_2: 0.9569 (0.9569) loss_ddf_dn_2: 0.0051 (0.0051) loss_vfl_dn_3: 0.4739 (0.4739) loss_bbox_dn_3: 0.0532 (0.0532) loss_giou_dn_3: 1.0894 (1.0894) loss_fgl_dn_3: 0.9576 (0.9576) loss_ddf_dn_3: 0.0010 (0.0010) loss_vfl_dn_4: 0.4736 (0.4736) loss_bbox_dn_4: 0.0526 (0.0526) loss_giou_dn_4: 1.0881 (1.0881) loss_fgl_dn_4: 0.9578 (0.9578) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4771 (0.4771) loss_bbox_dn_5: 0.0524 (0.0524) loss_giou_dn_5: 1.0880 (1.0880) loss_fgl_dn_5: 0.9578 (0.9578) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4265 (0.4265) loss_bbox_dn_pre: 0.0696 (0.0696) loss_giou_dn_pre: 1.1905 (1.1905) time: 1.8239 data: 0.9568 max mem: 29821\n", + "Epoch: [26] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7658 (38.2779) loss_vfl: 0.1647 (0.1620) loss_bbox: 0.2685 (0.3018) loss_giou: 1.7812 (1.8462) loss_fgl: 0.4149 (0.3918) loss_vfl_aux_0: 0.1716 (0.1653) loss_bbox_aux_0: 0.2714 (0.3045) loss_giou_aux_0: 1.7979 (1.8571) loss_fgl_aux_0: 0.4135 (0.3901) loss_ddf_aux_0: 0.0942 (0.1195) loss_vfl_aux_1: 0.1686 (0.1674) loss_bbox_aux_1: 0.2691 (0.3025) loss_giou_aux_1: 1.7829 (1.8476) loss_fgl_aux_1: 0.4143 (0.3914) loss_ddf_aux_1: 0.0109 (0.0169) loss_vfl_aux_2: 0.1652 (0.1655) loss_bbox_aux_2: 0.2685 (0.3020) loss_giou_aux_2: 1.7813 (1.8463) loss_fgl_aux_2: 0.4148 (0.3917) loss_ddf_aux_2: 0.0016 (0.0027) loss_vfl_aux_3: 0.1660 (0.1633) loss_bbox_aux_3: 0.2685 (0.3019) loss_giou_aux_3: 1.7810 (1.8462) loss_fgl_aux_3: 0.4148 (0.3917) loss_ddf_aux_3: 0.0003 (0.0005) loss_vfl_aux_4: 0.1647 (0.1620) loss_bbox_aux_4: 0.2686 (0.3018) loss_giou_aux_4: 1.7811 (1.8461) loss_fgl_aux_4: 0.4149 (0.3918) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1697 (0.1622) loss_bbox_pre: 0.2768 (0.3100) loss_giou_pre: 1.7931 (1.8509) loss_vfl_enc_0: 0.1597 (0.1552) loss_bbox_enc_0: 0.2897 (0.3316) loss_giou_enc_0: 1.8393 (1.8895) loss_vfl_dn_0: 0.4067 (0.4088) loss_bbox_dn_0: 0.0525 (0.0526) loss_giou_dn_0: 1.2023 (1.2086) loss_fgl_dn_0: 0.9076 (0.9071) loss_ddf_dn_0: 0.2143 (0.2148) loss_vfl_dn_1: 0.4519 (0.4505) loss_bbox_dn_1: 0.0477 (0.0443) loss_giou_dn_1: 1.1068 (1.1215) loss_fgl_dn_1: 0.9389 (0.9356) loss_ddf_dn_1: 0.0266 (0.0297) loss_vfl_dn_2: 0.4524 (0.4503) loss_bbox_dn_2: 0.0465 (0.0429) loss_giou_dn_2: 1.0973 (1.1098) loss_fgl_dn_2: 0.9416 (0.9385) loss_ddf_dn_2: 0.0026 (0.0033) loss_vfl_dn_3: 0.4512 (0.4475) loss_bbox_dn_3: 0.0463 (0.0427) loss_giou_dn_3: 1.0962 (1.1090) loss_fgl_dn_3: 0.9420 (0.9388) loss_ddf_dn_3: 0.0004 (0.0006) loss_vfl_dn_4: 0.4512 (0.4465) loss_bbox_dn_4: 0.0463 (0.0426) loss_giou_dn_4: 1.0959 (1.1088) loss_fgl_dn_4: 0.9420 (0.9389) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4471) loss_bbox_dn_5: 0.0463 (0.0426) loss_giou_dn_5: 1.0959 (1.1088) loss_fgl_dn_5: 0.9420 (0.9390) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4062 (0.4078) loss_bbox_dn_pre: 0.0525 (0.0529) loss_giou_dn_pre: 1.2019 (1.2088) time: 0.8515 data: 0.0183 max mem: 29821\n", + "Epoch: [26] Total time: 0:01:13 (0.8763 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7658 (38.2779) loss_vfl: 0.1647 (0.1620) loss_bbox: 0.2685 (0.3018) loss_giou: 1.7812 (1.8462) loss_fgl: 0.4149 (0.3918) loss_vfl_aux_0: 0.1716 (0.1653) loss_bbox_aux_0: 0.2714 (0.3045) loss_giou_aux_0: 1.7979 (1.8571) loss_fgl_aux_0: 0.4135 (0.3901) loss_ddf_aux_0: 0.0942 (0.1195) loss_vfl_aux_1: 0.1686 (0.1674) loss_bbox_aux_1: 0.2691 (0.3025) loss_giou_aux_1: 1.7829 (1.8476) loss_fgl_aux_1: 0.4143 (0.3914) loss_ddf_aux_1: 0.0109 (0.0169) loss_vfl_aux_2: 0.1652 (0.1655) loss_bbox_aux_2: 0.2685 (0.3020) loss_giou_aux_2: 1.7813 (1.8463) loss_fgl_aux_2: 0.4148 (0.3917) loss_ddf_aux_2: 0.0016 (0.0027) loss_vfl_aux_3: 0.1660 (0.1633) loss_bbox_aux_3: 0.2685 (0.3019) loss_giou_aux_3: 1.7810 (1.8462) loss_fgl_aux_3: 0.4148 (0.3917) loss_ddf_aux_3: 0.0003 (0.0005) loss_vfl_aux_4: 0.1647 (0.1620) loss_bbox_aux_4: 0.2686 (0.3018) loss_giou_aux_4: 1.7811 (1.8461) loss_fgl_aux_4: 0.4149 (0.3918) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1697 (0.1622) loss_bbox_pre: 0.2768 (0.3100) loss_giou_pre: 1.7931 (1.8509) loss_vfl_enc_0: 0.1597 (0.1552) loss_bbox_enc_0: 0.2897 (0.3316) loss_giou_enc_0: 1.8393 (1.8895) loss_vfl_dn_0: 0.4067 (0.4088) loss_bbox_dn_0: 0.0525 (0.0526) loss_giou_dn_0: 1.2023 (1.2086) loss_fgl_dn_0: 0.9076 (0.9071) loss_ddf_dn_0: 0.2143 (0.2148) loss_vfl_dn_1: 0.4519 (0.4505) loss_bbox_dn_1: 0.0477 (0.0443) loss_giou_dn_1: 1.1068 (1.1215) loss_fgl_dn_1: 0.9389 (0.9356) loss_ddf_dn_1: 0.0266 (0.0297) loss_vfl_dn_2: 0.4524 (0.4503) loss_bbox_dn_2: 0.0465 (0.0429) loss_giou_dn_2: 1.0973 (1.1098) loss_fgl_dn_2: 0.9416 (0.9385) loss_ddf_dn_2: 0.0026 (0.0033) loss_vfl_dn_3: 0.4512 (0.4475) loss_bbox_dn_3: 0.0463 (0.0427) loss_giou_dn_3: 1.0962 (1.1090) loss_fgl_dn_3: 0.9420 (0.9388) loss_ddf_dn_3: 0.0004 (0.0006) loss_vfl_dn_4: 0.4512 (0.4465) loss_bbox_dn_4: 0.0463 (0.0426) loss_giou_dn_4: 1.0959 (1.1088) loss_fgl_dn_4: 0.9420 (0.9389) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4471) loss_bbox_dn_5: 0.0463 (0.0426) loss_giou_dn_5: 1.0959 (1.1088) loss_fgl_dn_5: 0.9420 (0.9390) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4062 (0.4078) loss_bbox_dn_pre: 0.0525 (0.0529) loss_giou_dn_pre: 1.2019 (1.2088)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7923 data: 0.5355 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4075 data: 0.1731 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4238 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.053\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.013\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.087\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.280\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.017\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.056\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.202\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.300\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.158\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.041\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [27] [ 0/84] eta: 0:02:36 lr: 0.000013 loss: 38.3921 (38.3921) loss_vfl: 0.1158 (0.1158) loss_bbox: 0.3387 (0.3387) loss_giou: 1.9838 (1.9838) loss_fgl: 0.2785 (0.2785) loss_vfl_aux_0: 0.1142 (0.1142) loss_bbox_aux_0: 0.3412 (0.3412) loss_giou_aux_0: 1.9932 (1.9932) loss_fgl_aux_0: 0.2815 (0.2815) loss_ddf_aux_0: 0.0792 (0.0792) loss_vfl_aux_1: 0.1171 (0.1171) loss_bbox_aux_1: 0.3402 (0.3402) loss_giou_aux_1: 1.9850 (1.9850) loss_fgl_aux_1: 0.2797 (0.2797) loss_ddf_aux_1: 0.0105 (0.0105) loss_vfl_aux_2: 0.1146 (0.1146) loss_bbox_aux_2: 0.3393 (0.3393) loss_giou_aux_2: 1.9840 (1.9840) loss_fgl_aux_2: 0.2786 (0.2786) loss_ddf_aux_2: 0.0013 (0.0013) loss_vfl_aux_3: 0.1161 (0.1161) loss_bbox_aux_3: 0.3389 (0.3389) loss_giou_aux_3: 1.9837 (1.9837) loss_fgl_aux_3: 0.2785 (0.2785) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1163 (0.1163) loss_bbox_aux_4: 0.3388 (0.3388) loss_giou_aux_4: 1.9837 (1.9837) loss_fgl_aux_4: 0.2785 (0.2785) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1130 (0.1130) loss_bbox_pre: 0.3466 (0.3466) loss_giou_pre: 1.9835 (1.9835) loss_vfl_enc_0: 0.1058 (0.1058) loss_bbox_enc_0: 0.3727 (0.3727) loss_giou_enc_0: 2.0493 (2.0493) loss_vfl_dn_0: 0.3977 (0.3977) loss_bbox_dn_0: 0.0424 (0.0424) loss_giou_dn_0: 1.2165 (1.2165) loss_fgl_dn_0: 0.8904 (0.8904) loss_ddf_dn_0: 0.1674 (0.1674) loss_vfl_dn_1: 0.4399 (0.4399) loss_bbox_dn_1: 0.0355 (0.0355) loss_giou_dn_1: 1.1376 (1.1376) loss_fgl_dn_1: 0.9214 (0.9214) loss_ddf_dn_1: 0.0197 (0.0197) loss_vfl_dn_2: 0.4480 (0.4480) loss_bbox_dn_2: 0.0333 (0.0333) loss_giou_dn_2: 1.1151 (1.1151) loss_fgl_dn_2: 0.9295 (0.9295) loss_ddf_dn_2: 0.0017 (0.0017) loss_vfl_dn_3: 0.4417 (0.4417) loss_bbox_dn_3: 0.0330 (0.0330) loss_giou_dn_3: 1.1138 (1.1138) loss_fgl_dn_3: 0.9301 (0.9301) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4419 (0.4419) loss_bbox_dn_4: 0.0329 (0.0329) loss_giou_dn_4: 1.1135 (1.1135) loss_fgl_dn_4: 0.9303 (0.9303) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4417 (0.4417) loss_bbox_dn_5: 0.0329 (0.0329) loss_giou_dn_5: 1.1135 (1.1135) loss_fgl_dn_5: 0.9303 (0.9303) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3972 (0.3972) loss_bbox_dn_pre: 0.0430 (0.0430) loss_giou_dn_pre: 1.2179 (1.2179) time: 1.8607 data: 0.9783 max mem: 29821\n", + "Epoch: [27] [83/84] eta: 0:00:00 lr: 0.000013 loss: 39.2337 (38.6692) loss_vfl: 0.1548 (0.1727) loss_bbox: 0.3376 (0.3205) loss_giou: 1.9358 (1.8596) loss_fgl: 0.3600 (0.3922) loss_vfl_aux_0: 0.1548 (0.1734) loss_bbox_aux_0: 0.3375 (0.3235) loss_giou_aux_0: 1.9457 (1.8716) loss_fgl_aux_0: 0.3580 (0.3907) loss_ddf_aux_0: 0.0946 (0.1126) loss_vfl_aux_1: 0.1610 (0.1776) loss_bbox_aux_1: 0.3351 (0.3209) loss_giou_aux_1: 1.9384 (1.8613) loss_fgl_aux_1: 0.3596 (0.3919) loss_ddf_aux_1: 0.0153 (0.0148) loss_vfl_aux_2: 0.1586 (0.1756) loss_bbox_aux_2: 0.3380 (0.3208) loss_giou_aux_2: 1.9358 (1.8596) loss_fgl_aux_2: 0.3600 (0.3920) loss_ddf_aux_2: 0.0018 (0.0022) loss_vfl_aux_3: 0.1576 (0.1740) loss_bbox_aux_3: 0.3377 (0.3206) loss_giou_aux_3: 1.9358 (1.8595) loss_fgl_aux_3: 0.3599 (0.3921) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1548 (0.1725) loss_bbox_aux_4: 0.3377 (0.3206) loss_giou_aux_4: 1.9358 (1.8596) loss_fgl_aux_4: 0.3599 (0.3922) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1509 (0.1708) loss_bbox_pre: 0.3466 (0.3282) loss_giou_pre: 1.9402 (1.8664) loss_vfl_enc_0: 0.1443 (0.1629) loss_bbox_enc_0: 0.3656 (0.3481) loss_giou_enc_0: 1.9685 (1.9072) loss_vfl_dn_0: 0.3892 (0.4057) loss_bbox_dn_0: 0.0529 (0.0575) loss_giou_dn_0: 1.2602 (1.2208) loss_fgl_dn_0: 0.8798 (0.9026) loss_ddf_dn_0: 0.2516 (0.2455) loss_vfl_dn_1: 0.4412 (0.4517) loss_bbox_dn_1: 0.0465 (0.0480) loss_giou_dn_1: 1.1314 (1.1176) loss_fgl_dn_1: 0.9141 (0.9344) loss_ddf_dn_1: 0.0384 (0.0343) loss_vfl_dn_2: 0.4431 (0.4527) loss_bbox_dn_2: 0.0447 (0.0464) loss_giou_dn_2: 1.1131 (1.1036) loss_fgl_dn_2: 0.9200 (0.9384) loss_ddf_dn_2: 0.0033 (0.0036) loss_vfl_dn_3: 0.4429 (0.4504) loss_bbox_dn_3: 0.0446 (0.0461) loss_giou_dn_3: 1.1129 (1.1027) loss_fgl_dn_3: 0.9203 (0.9389) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4404 (0.4496) loss_bbox_dn_4: 0.0446 (0.0460) loss_giou_dn_4: 1.1133 (1.1025) loss_fgl_dn_4: 0.9205 (0.9390) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4399 (0.4504) loss_bbox_dn_5: 0.0446 (0.0460) loss_giou_dn_5: 1.1134 (1.1025) loss_fgl_dn_5: 0.9205 (0.9390) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3879 (0.4044) loss_bbox_dn_pre: 0.0535 (0.0578) loss_giou_dn_pre: 1.2621 (1.2216) time: 0.8706 data: 0.0174 max mem: 29821\n", + "Epoch: [27] Total time: 0:01:13 (0.8716 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 39.2337 (38.6692) loss_vfl: 0.1548 (0.1727) loss_bbox: 0.3376 (0.3205) loss_giou: 1.9358 (1.8596) loss_fgl: 0.3600 (0.3922) loss_vfl_aux_0: 0.1548 (0.1734) loss_bbox_aux_0: 0.3375 (0.3235) loss_giou_aux_0: 1.9457 (1.8716) loss_fgl_aux_0: 0.3580 (0.3907) loss_ddf_aux_0: 0.0946 (0.1126) loss_vfl_aux_1: 0.1610 (0.1776) loss_bbox_aux_1: 0.3351 (0.3209) loss_giou_aux_1: 1.9384 (1.8613) loss_fgl_aux_1: 0.3596 (0.3919) loss_ddf_aux_1: 0.0153 (0.0148) loss_vfl_aux_2: 0.1586 (0.1756) loss_bbox_aux_2: 0.3380 (0.3208) loss_giou_aux_2: 1.9358 (1.8596) loss_fgl_aux_2: 0.3600 (0.3920) loss_ddf_aux_2: 0.0018 (0.0022) loss_vfl_aux_3: 0.1576 (0.1740) loss_bbox_aux_3: 0.3377 (0.3206) loss_giou_aux_3: 1.9358 (1.8595) loss_fgl_aux_3: 0.3599 (0.3921) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1548 (0.1725) loss_bbox_aux_4: 0.3377 (0.3206) loss_giou_aux_4: 1.9358 (1.8596) loss_fgl_aux_4: 0.3599 (0.3922) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1509 (0.1708) loss_bbox_pre: 0.3466 (0.3282) loss_giou_pre: 1.9402 (1.8664) loss_vfl_enc_0: 0.1443 (0.1629) loss_bbox_enc_0: 0.3656 (0.3481) loss_giou_enc_0: 1.9685 (1.9072) loss_vfl_dn_0: 0.3892 (0.4057) loss_bbox_dn_0: 0.0529 (0.0575) loss_giou_dn_0: 1.2602 (1.2208) loss_fgl_dn_0: 0.8798 (0.9026) loss_ddf_dn_0: 0.2516 (0.2455) loss_vfl_dn_1: 0.4412 (0.4517) loss_bbox_dn_1: 0.0465 (0.0480) loss_giou_dn_1: 1.1314 (1.1176) loss_fgl_dn_1: 0.9141 (0.9344) loss_ddf_dn_1: 0.0384 (0.0343) loss_vfl_dn_2: 0.4431 (0.4527) loss_bbox_dn_2: 0.0447 (0.0464) loss_giou_dn_2: 1.1131 (1.1036) loss_fgl_dn_2: 0.9200 (0.9384) loss_ddf_dn_2: 0.0033 (0.0036) loss_vfl_dn_3: 0.4429 (0.4504) loss_bbox_dn_3: 0.0446 (0.0461) loss_giou_dn_3: 1.1129 (1.1027) loss_fgl_dn_3: 0.9203 (0.9389) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4404 (0.4496) loss_bbox_dn_4: 0.0446 (0.0460) loss_giou_dn_4: 1.1133 (1.1025) loss_fgl_dn_4: 0.9205 (0.9390) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4399 (0.4504) loss_bbox_dn_5: 0.0446 (0.0460) loss_giou_dn_5: 1.1134 (1.1025) loss_fgl_dn_5: 0.9205 (0.9390) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3879 (0.4044) loss_bbox_dn_pre: 0.0535 (0.0578) loss_giou_dn_pre: 1.2621 (1.2216)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7770 data: 0.5264 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4029 data: 0.1693 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4193 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.062\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.165\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.478\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.028\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.059\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.075\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.079\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.475\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.168\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.034\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [28] [ 0/84] eta: 0:02:14 lr: 0.000013 loss: 38.8317 (38.8317) loss_vfl: 0.2186 (0.2186) loss_bbox: 0.2844 (0.2844) loss_giou: 1.7541 (1.7541) loss_fgl: 0.4887 (0.4887) loss_vfl_aux_0: 0.2178 (0.2178) loss_bbox_aux_0: 0.2865 (0.2865) loss_giou_aux_0: 1.7814 (1.7814) loss_fgl_aux_0: 0.4895 (0.4895) loss_ddf_aux_0: 0.2168 (0.2168) loss_vfl_aux_1: 0.2429 (0.2429) loss_bbox_aux_1: 0.2823 (0.2823) loss_giou_aux_1: 1.7661 (1.7661) loss_fgl_aux_1: 0.4890 (0.4890) loss_ddf_aux_1: 0.0324 (0.0324) loss_vfl_aux_2: 0.2435 (0.2435) loss_bbox_aux_2: 0.2851 (0.2851) loss_giou_aux_2: 1.7559 (1.7559) loss_fgl_aux_2: 0.4884 (0.4884) loss_ddf_aux_2: 0.0039 (0.0039) loss_vfl_aux_3: 0.2264 (0.2264) loss_bbox_aux_3: 0.2860 (0.2860) loss_giou_aux_3: 1.7546 (1.7546) loss_fgl_aux_3: 0.4885 (0.4885) loss_ddf_aux_3: 0.0007 (0.0007) loss_vfl_aux_4: 0.2225 (0.2225) loss_bbox_aux_4: 0.2848 (0.2848) loss_giou_aux_4: 1.7542 (1.7542) loss_fgl_aux_4: 0.4887 (0.4887) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2170 (0.2170) loss_bbox_pre: 0.2920 (0.2920) loss_giou_pre: 1.7721 (1.7721) loss_vfl_enc_0: 0.2013 (0.2013) loss_bbox_enc_0: 0.3137 (0.3137) loss_giou_enc_0: 1.8151 (1.8151) loss_vfl_dn_0: 0.3882 (0.3882) loss_bbox_dn_0: 0.0708 (0.0708) loss_giou_dn_0: 1.2619 (1.2619) loss_fgl_dn_0: 0.8806 (0.8806) loss_ddf_dn_0: 0.3031 (0.3031) loss_vfl_dn_1: 0.4414 (0.4414) loss_bbox_dn_1: 0.0601 (0.0601) loss_giou_dn_1: 1.1546 (1.1546) loss_fgl_dn_1: 0.9026 (0.9026) loss_ddf_dn_1: 0.0409 (0.0409) loss_vfl_dn_2: 0.4519 (0.4519) loss_bbox_dn_2: 0.0572 (0.0572) loss_giou_dn_2: 1.1308 (1.1308) loss_fgl_dn_2: 0.9108 (0.9108) loss_ddf_dn_2: 0.0034 (0.0034) loss_vfl_dn_3: 0.4407 (0.4407) loss_bbox_dn_3: 0.0566 (0.0566) loss_giou_dn_3: 1.1282 (1.1282) loss_fgl_dn_3: 0.9121 (0.9121) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4368 (0.4368) loss_bbox_dn_4: 0.0564 (0.0564) loss_giou_dn_4: 1.1278 (1.1278) loss_fgl_dn_4: 0.9126 (0.9126) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4365 (0.4365) loss_bbox_dn_5: 0.0564 (0.0564) loss_giou_dn_5: 1.1278 (1.1278) loss_fgl_dn_5: 0.9127 (0.9127) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3860 (0.3860) loss_bbox_dn_pre: 0.0713 (0.0713) loss_giou_dn_pre: 1.2659 (1.2659) time: 1.6040 data: 0.8245 max mem: 29821\n", + "Epoch: [28] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.1926 (38.5720) loss_vfl: 0.1472 (0.1649) loss_bbox: 0.2910 (0.3147) loss_giou: 1.8629 (1.8623) loss_fgl: 0.4061 (0.3865) loss_vfl_aux_0: 0.1514 (0.1665) loss_bbox_aux_0: 0.2867 (0.3171) loss_giou_aux_0: 1.8855 (1.8744) loss_fgl_aux_0: 0.4016 (0.3844) loss_ddf_aux_0: 0.1018 (0.1330) loss_vfl_aux_1: 0.1528 (0.1703) loss_bbox_aux_1: 0.2929 (0.3153) loss_giou_aux_1: 1.8649 (1.8634) loss_fgl_aux_1: 0.4051 (0.3858) loss_ddf_aux_1: 0.0158 (0.0175) loss_vfl_aux_2: 0.1527 (0.1691) loss_bbox_aux_2: 0.2909 (0.3150) loss_giou_aux_2: 1.8634 (1.8620) loss_fgl_aux_2: 0.4060 (0.3862) loss_ddf_aux_2: 0.0022 (0.0027) loss_vfl_aux_3: 0.1517 (0.1659) loss_bbox_aux_3: 0.2909 (0.3149) loss_giou_aux_3: 1.8630 (1.8621) loss_fgl_aux_3: 0.4061 (0.3864) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1455 (0.1651) loss_bbox_aux_4: 0.2910 (0.3147) loss_giou_aux_4: 1.8629 (1.8622) loss_fgl_aux_4: 0.4061 (0.3865) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1488 (0.1637) loss_bbox_pre: 0.2915 (0.3216) loss_giou_pre: 1.8773 (1.8687) loss_vfl_enc_0: 0.1394 (0.1562) loss_bbox_enc_0: 0.3238 (0.3438) loss_giou_enc_0: 1.9092 (1.9087) loss_vfl_dn_0: 0.4077 (0.4022) loss_bbox_dn_0: 0.0492 (0.0564) loss_giou_dn_0: 1.2148 (1.2242) loss_fgl_dn_0: 0.9043 (0.8954) loss_ddf_dn_0: 0.2174 (0.2579) loss_vfl_dn_1: 0.4558 (0.4509) loss_bbox_dn_1: 0.0394 (0.0472) loss_giou_dn_1: 1.1189 (1.1248) loss_fgl_dn_1: 0.9342 (0.9282) loss_ddf_dn_1: 0.0316 (0.0372) loss_vfl_dn_2: 0.4519 (0.4513) loss_bbox_dn_2: 0.0394 (0.0458) loss_giou_dn_2: 1.1082 (1.1109) loss_fgl_dn_2: 0.9402 (0.9322) loss_ddf_dn_2: 0.0042 (0.0042) loss_vfl_dn_3: 0.4504 (0.4475) loss_bbox_dn_3: 0.0396 (0.0456) loss_giou_dn_3: 1.1076 (1.1100) loss_fgl_dn_3: 0.9410 (0.9327) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4497 (0.4473) loss_bbox_dn_4: 0.0395 (0.0456) loss_giou_dn_4: 1.1084 (1.1099) loss_fgl_dn_4: 0.9411 (0.9328) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4509 (0.4478) loss_bbox_dn_5: 0.0394 (0.0456) loss_giou_dn_5: 1.1085 (1.1099) loss_fgl_dn_5: 0.9411 (0.9328) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4053 (0.4011) loss_bbox_dn_pre: 0.0496 (0.0566) loss_giou_dn_pre: 1.2228 (1.2249) time: 0.8978 data: 0.0169 max mem: 29821\n", + "Epoch: [28] Total time: 0:01:13 (0.8746 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.1926 (38.5720) loss_vfl: 0.1472 (0.1649) loss_bbox: 0.2910 (0.3147) loss_giou: 1.8629 (1.8623) loss_fgl: 0.4061 (0.3865) loss_vfl_aux_0: 0.1514 (0.1665) loss_bbox_aux_0: 0.2867 (0.3171) loss_giou_aux_0: 1.8855 (1.8744) loss_fgl_aux_0: 0.4016 (0.3844) loss_ddf_aux_0: 0.1018 (0.1330) loss_vfl_aux_1: 0.1528 (0.1703) loss_bbox_aux_1: 0.2929 (0.3153) loss_giou_aux_1: 1.8649 (1.8634) loss_fgl_aux_1: 0.4051 (0.3858) loss_ddf_aux_1: 0.0158 (0.0175) loss_vfl_aux_2: 0.1527 (0.1691) loss_bbox_aux_2: 0.2909 (0.3150) loss_giou_aux_2: 1.8634 (1.8620) loss_fgl_aux_2: 0.4060 (0.3862) loss_ddf_aux_2: 0.0022 (0.0027) loss_vfl_aux_3: 0.1517 (0.1659) loss_bbox_aux_3: 0.2909 (0.3149) loss_giou_aux_3: 1.8630 (1.8621) loss_fgl_aux_3: 0.4061 (0.3864) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1455 (0.1651) loss_bbox_aux_4: 0.2910 (0.3147) loss_giou_aux_4: 1.8629 (1.8622) loss_fgl_aux_4: 0.4061 (0.3865) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1488 (0.1637) loss_bbox_pre: 0.2915 (0.3216) loss_giou_pre: 1.8773 (1.8687) loss_vfl_enc_0: 0.1394 (0.1562) loss_bbox_enc_0: 0.3238 (0.3438) loss_giou_enc_0: 1.9092 (1.9087) loss_vfl_dn_0: 0.4077 (0.4022) loss_bbox_dn_0: 0.0492 (0.0564) loss_giou_dn_0: 1.2148 (1.2242) loss_fgl_dn_0: 0.9043 (0.8954) loss_ddf_dn_0: 0.2174 (0.2579) loss_vfl_dn_1: 0.4558 (0.4509) loss_bbox_dn_1: 0.0394 (0.0472) loss_giou_dn_1: 1.1189 (1.1248) loss_fgl_dn_1: 0.9342 (0.9282) loss_ddf_dn_1: 0.0316 (0.0372) loss_vfl_dn_2: 0.4519 (0.4513) loss_bbox_dn_2: 0.0394 (0.0458) loss_giou_dn_2: 1.1082 (1.1109) loss_fgl_dn_2: 0.9402 (0.9322) loss_ddf_dn_2: 0.0042 (0.0042) loss_vfl_dn_3: 0.4504 (0.4475) loss_bbox_dn_3: 0.0396 (0.0456) loss_giou_dn_3: 1.1076 (1.1100) loss_fgl_dn_3: 0.9410 (0.9327) loss_ddf_dn_3: 0.0005 (0.0007) loss_vfl_dn_4: 0.4497 (0.4473) loss_bbox_dn_4: 0.0395 (0.0456) loss_giou_dn_4: 1.1084 (1.1099) loss_fgl_dn_4: 0.9411 (0.9328) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4509 (0.4478) loss_bbox_dn_5: 0.0394 (0.0456) loss_giou_dn_5: 1.1085 (1.1099) loss_fgl_dn_5: 0.9411 (0.9328) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4053 (0.4011) loss_bbox_dn_pre: 0.0496 (0.0566) loss_giou_dn_pre: 1.2228 (1.2249)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7938 data: 0.5453 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4106 data: 0.1745 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4274 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.059\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.020\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.113\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.350\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.005\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.030\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.047\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.045\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.228\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.375\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.108\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.032\n", + "best_stat: {'epoch': 23, 'coco_eval_bbox': 0.02352958378082212}\n", + "Epoch: [29] [ 0/84] eta: 0:02:38 lr: 0.000013 loss: 38.1779 (38.1779) loss_vfl: 0.1752 (0.1752) loss_bbox: 0.2412 (0.2412) loss_giou: 1.9143 (1.9143) loss_fgl: 0.3495 (0.3495) loss_vfl_aux_0: 0.1680 (0.1680) loss_bbox_aux_0: 0.2422 (0.2422) loss_giou_aux_0: 1.9394 (1.9394) loss_fgl_aux_0: 0.3492 (0.3492) loss_ddf_aux_0: 0.1352 (0.1352) loss_vfl_aux_1: 0.1682 (0.1682) loss_bbox_aux_1: 0.2437 (0.2437) loss_giou_aux_1: 1.9181 (1.9181) loss_fgl_aux_1: 0.3483 (0.3483) loss_ddf_aux_1: 0.0196 (0.0196) loss_vfl_aux_2: 0.1687 (0.1687) loss_bbox_aux_2: 0.2416 (0.2416) loss_giou_aux_2: 1.9155 (1.9155) loss_fgl_aux_2: 0.3492 (0.3492) loss_ddf_aux_2: 0.0020 (0.0020) loss_vfl_aux_3: 0.1761 (0.1761) loss_bbox_aux_3: 0.2412 (0.2412) loss_giou_aux_3: 1.9145 (1.9145) loss_fgl_aux_3: 0.3493 (0.3493) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1749 (0.1749) loss_bbox_aux_4: 0.2412 (0.2412) loss_giou_aux_4: 1.9142 (1.9142) loss_fgl_aux_4: 0.3495 (0.3495) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1671 (0.1671) loss_bbox_pre: 0.2443 (0.2443) loss_giou_pre: 1.9338 (1.9338) loss_vfl_enc_0: 0.1677 (0.1677) loss_bbox_enc_0: 0.2657 (0.2657) loss_giou_enc_0: 2.0091 (2.0091) loss_vfl_dn_0: 0.4180 (0.4180) loss_bbox_dn_0: 0.0483 (0.0483) loss_giou_dn_0: 1.1733 (1.1733) loss_fgl_dn_0: 0.9383 (0.9383) loss_ddf_dn_0: 0.2338 (0.2338) loss_vfl_dn_1: 0.4453 (0.4453) loss_bbox_dn_1: 0.0391 (0.0391) loss_giou_dn_1: 1.1007 (1.1007) loss_fgl_dn_1: 0.9554 (0.9554) loss_ddf_dn_1: 0.0343 (0.0343) loss_vfl_dn_2: 0.4490 (0.4490) loss_bbox_dn_2: 0.0377 (0.0377) loss_giou_dn_2: 1.0874 (1.0874) loss_fgl_dn_2: 0.9581 (0.9581) loss_ddf_dn_2: 0.0037 (0.0037) loss_vfl_dn_3: 0.4431 (0.4431) loss_bbox_dn_3: 0.0374 (0.0374) loss_giou_dn_3: 1.0857 (1.0857) loss_fgl_dn_3: 0.9584 (0.9584) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4426 (0.4426) loss_bbox_dn_4: 0.0371 (0.0371) loss_giou_dn_4: 1.0853 (1.0853) loss_fgl_dn_4: 0.9584 (0.9584) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4443 (0.4443) loss_bbox_dn_5: 0.0371 (0.0371) loss_giou_dn_5: 1.0854 (1.0854) loss_fgl_dn_5: 0.9584 (0.9584) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4165 (0.4165) loss_bbox_dn_pre: 0.0493 (0.0493) loss_giou_dn_pre: 1.1774 (1.1774) time: 1.8907 data: 1.0548 max mem: 29821\n", + "Epoch: [29] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5078 (38.4470) loss_vfl: 0.1423 (0.1662) loss_bbox: 0.2969 (0.3065) loss_giou: 1.8771 (1.8433) loss_fgl: 0.3509 (0.3983) loss_vfl_aux_0: 0.1473 (0.1689) loss_bbox_aux_0: 0.3093 (0.3117) loss_giou_aux_0: 1.8913 (1.8544) loss_fgl_aux_0: 0.3472 (0.3965) loss_ddf_aux_0: 0.1503 (0.1373) loss_vfl_aux_1: 0.1512 (0.1722) loss_bbox_aux_1: 0.2988 (0.3083) loss_giou_aux_1: 1.8789 (1.8442) loss_fgl_aux_1: 0.3504 (0.3975) loss_ddf_aux_1: 0.0141 (0.0175) loss_vfl_aux_2: 0.1464 (0.1710) loss_bbox_aux_2: 0.2973 (0.3069) loss_giou_aux_2: 1.8774 (1.8434) loss_fgl_aux_2: 0.3508 (0.3982) loss_ddf_aux_2: 0.0020 (0.0026) loss_vfl_aux_3: 0.1442 (0.1678) loss_bbox_aux_3: 0.2970 (0.3067) loss_giou_aux_3: 1.8770 (1.8432) loss_fgl_aux_3: 0.3508 (0.3983) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1420 (0.1659) loss_bbox_aux_4: 0.2970 (0.3065) loss_giou_aux_4: 1.8771 (1.8433) loss_fgl_aux_4: 0.3508 (0.3983) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1451 (0.1663) loss_bbox_pre: 0.3136 (0.3156) loss_giou_pre: 1.8867 (1.8502) loss_vfl_enc_0: 0.1262 (0.1584) loss_bbox_enc_0: 0.3363 (0.3362) loss_giou_enc_0: 1.9614 (1.8993) loss_vfl_dn_0: 0.4167 (0.4072) loss_bbox_dn_0: 0.0478 (0.0542) loss_giou_dn_0: 1.1914 (1.2092) loss_fgl_dn_0: 0.9229 (0.9060) loss_ddf_dn_0: 0.1954 (0.2307) loss_vfl_dn_1: 0.4531 (0.4446) loss_bbox_dn_1: 0.0394 (0.0462) loss_giou_dn_1: 1.1183 (1.1361) loss_fgl_dn_1: 0.9503 (0.9322) loss_ddf_dn_1: 0.0288 (0.0439) loss_vfl_dn_2: 0.4546 (0.4526) loss_bbox_dn_2: 0.0383 (0.0441) loss_giou_dn_2: 1.1062 (1.1086) loss_fgl_dn_2: 0.9485 (0.9392) loss_ddf_dn_2: 0.0027 (0.0033) loss_vfl_dn_3: 0.4507 (0.4484) loss_bbox_dn_3: 0.0382 (0.0438) loss_giou_dn_3: 1.1041 (1.1077) loss_fgl_dn_3: 0.9493 (0.9396) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4524 (0.4474) loss_bbox_dn_4: 0.0383 (0.0437) loss_giou_dn_4: 1.1040 (1.1075) loss_fgl_dn_4: 0.9496 (0.9397) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4504 (0.4477) loss_bbox_dn_5: 0.0383 (0.0437) loss_giou_dn_5: 1.1040 (1.1075) loss_fgl_dn_5: 0.9497 (0.9397) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4136 (0.4062) loss_bbox_dn_pre: 0.0479 (0.0544) loss_giou_dn_pre: 1.1960 (1.2100) time: 0.8243 data: 0.0175 max mem: 29821\n", + "Epoch: [29] Total time: 0:01:13 (0.8747 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5078 (38.4470) loss_vfl: 0.1423 (0.1662) loss_bbox: 0.2969 (0.3065) loss_giou: 1.8771 (1.8433) loss_fgl: 0.3509 (0.3983) loss_vfl_aux_0: 0.1473 (0.1689) loss_bbox_aux_0: 0.3093 (0.3117) loss_giou_aux_0: 1.8913 (1.8544) loss_fgl_aux_0: 0.3472 (0.3965) loss_ddf_aux_0: 0.1503 (0.1373) loss_vfl_aux_1: 0.1512 (0.1722) loss_bbox_aux_1: 0.2988 (0.3083) loss_giou_aux_1: 1.8789 (1.8442) loss_fgl_aux_1: 0.3504 (0.3975) loss_ddf_aux_1: 0.0141 (0.0175) loss_vfl_aux_2: 0.1464 (0.1710) loss_bbox_aux_2: 0.2973 (0.3069) loss_giou_aux_2: 1.8774 (1.8434) loss_fgl_aux_2: 0.3508 (0.3982) loss_ddf_aux_2: 0.0020 (0.0026) loss_vfl_aux_3: 0.1442 (0.1678) loss_bbox_aux_3: 0.2970 (0.3067) loss_giou_aux_3: 1.8770 (1.8432) loss_fgl_aux_3: 0.3508 (0.3983) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1420 (0.1659) loss_bbox_aux_4: 0.2970 (0.3065) loss_giou_aux_4: 1.8771 (1.8433) loss_fgl_aux_4: 0.3508 (0.3983) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1451 (0.1663) loss_bbox_pre: 0.3136 (0.3156) loss_giou_pre: 1.8867 (1.8502) loss_vfl_enc_0: 0.1262 (0.1584) loss_bbox_enc_0: 0.3363 (0.3362) loss_giou_enc_0: 1.9614 (1.8993) loss_vfl_dn_0: 0.4167 (0.4072) loss_bbox_dn_0: 0.0478 (0.0542) loss_giou_dn_0: 1.1914 (1.2092) loss_fgl_dn_0: 0.9229 (0.9060) loss_ddf_dn_0: 0.1954 (0.2307) loss_vfl_dn_1: 0.4531 (0.4446) loss_bbox_dn_1: 0.0394 (0.0462) loss_giou_dn_1: 1.1183 (1.1361) loss_fgl_dn_1: 0.9503 (0.9322) loss_ddf_dn_1: 0.0288 (0.0439) loss_vfl_dn_2: 0.4546 (0.4526) loss_bbox_dn_2: 0.0383 (0.0441) loss_giou_dn_2: 1.1062 (1.1086) loss_fgl_dn_2: 0.9485 (0.9392) loss_ddf_dn_2: 0.0027 (0.0033) loss_vfl_dn_3: 0.4507 (0.4484) loss_bbox_dn_3: 0.0382 (0.0438) loss_giou_dn_3: 1.1041 (1.1077) loss_fgl_dn_3: 0.9493 (0.9396) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4524 (0.4474) loss_bbox_dn_4: 0.0383 (0.0437) loss_giou_dn_4: 1.1040 (1.1075) loss_fgl_dn_4: 0.9496 (0.9397) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4504 (0.4477) loss_bbox_dn_5: 0.0383 (0.0437) loss_giou_dn_5: 1.1040 (1.1075) loss_fgl_dn_5: 0.9497 (0.9397) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4136 (0.4062) loss_bbox_dn_pre: 0.0479 (0.0544) loss_giou_dn_pre: 1.1960 (1.2100)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7552 data: 0.5064 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3982 data: 0.1704 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4133 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.066\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.012\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.115\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.378\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.007\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.238\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.450\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.156\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.031\n", + "best_stat: {'epoch': 29, 'coco_eval_bbox': 0.023576797723323908}\n", + "Epoch: [30] [ 0/84] eta: 0:02:54 lr: 0.000013 loss: 37.6904 (37.6904) loss_vfl: 0.1014 (0.1014) loss_bbox: 0.2909 (0.2909) loss_giou: 1.9236 (1.9236) loss_fgl: 0.2989 (0.2989) loss_vfl_aux_0: 0.1020 (0.1020) loss_bbox_aux_0: 0.2906 (0.2906) loss_giou_aux_0: 1.9297 (1.9297) loss_fgl_aux_0: 0.2954 (0.2954) loss_ddf_aux_0: 0.0887 (0.0887) loss_vfl_aux_1: 0.1034 (0.1034) loss_bbox_aux_1: 0.2914 (0.2914) loss_giou_aux_1: 1.9232 (1.9232) loss_fgl_aux_1: 0.2981 (0.2981) loss_ddf_aux_1: 0.0105 (0.0105) loss_vfl_aux_2: 0.1059 (0.1059) loss_bbox_aux_2: 0.2910 (0.2910) loss_giou_aux_2: 1.9234 (1.9234) loss_fgl_aux_2: 0.2987 (0.2987) loss_ddf_aux_2: 0.0016 (0.0016) loss_vfl_aux_3: 0.1031 (0.1031) loss_bbox_aux_3: 0.2910 (0.2910) loss_giou_aux_3: 1.9235 (1.9235) loss_fgl_aux_3: 0.2988 (0.2988) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1016 (0.1016) loss_bbox_aux_4: 0.2910 (0.2910) loss_giou_aux_4: 1.9235 (1.9235) loss_fgl_aux_4: 0.2989 (0.2989) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0997 (0.0997) loss_bbox_pre: 0.2951 (0.2951) loss_giou_pre: 1.9257 (1.9257) loss_vfl_enc_0: 0.0937 (0.0937) loss_bbox_enc_0: 0.3166 (0.3166) loss_giou_enc_0: 1.9585 (1.9585) loss_vfl_dn_0: 0.3845 (0.3845) loss_bbox_dn_0: 0.0373 (0.0373) loss_giou_dn_0: 1.2517 (1.2517) loss_fgl_dn_0: 0.8653 (0.8653) loss_ddf_dn_0: 0.1746 (0.1746) loss_vfl_dn_1: 0.4297 (0.4297) loss_bbox_dn_1: 0.0306 (0.0306) loss_giou_dn_1: 1.1813 (1.1813) loss_fgl_dn_1: 0.9063 (0.9063) loss_ddf_dn_1: 0.0267 (0.0267) loss_vfl_dn_2: 0.4270 (0.4270) loss_bbox_dn_2: 0.0313 (0.0313) loss_giou_dn_2: 1.1963 (1.1963) loss_fgl_dn_2: 0.9039 (0.9039) loss_ddf_dn_2: 0.0016 (0.0016) loss_vfl_dn_3: 0.4314 (0.4314) loss_bbox_dn_3: 0.0312 (0.0312) loss_giou_dn_3: 1.1965 (1.1965) loss_fgl_dn_3: 0.9042 (0.9042) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4282 (0.4282) loss_bbox_dn_4: 0.0311 (0.0311) loss_giou_dn_4: 1.1963 (1.1963) loss_fgl_dn_4: 0.9043 (0.9043) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4263 (0.4263) loss_bbox_dn_5: 0.0311 (0.0311) loss_giou_dn_5: 1.1963 (1.1963) loss_fgl_dn_5: 0.9044 (0.9044) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3862 (0.3862) loss_bbox_dn_pre: 0.0369 (0.0369) loss_giou_dn_pre: 1.2480 (1.2480) time: 2.0824 data: 1.0318 max mem: 29821\n", + "Epoch: [30] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.1019 (38.4340) loss_vfl: 0.1240 (0.1723) loss_bbox: 0.2875 (0.3021) loss_giou: 1.8788 (1.8402) loss_fgl: 0.3479 (0.4020) loss_vfl_aux_0: 0.1215 (0.1739) loss_bbox_aux_0: 0.3011 (0.3054) loss_giou_aux_0: 1.8802 (1.8534) loss_fgl_aux_0: 0.3411 (0.4006) loss_ddf_aux_0: 0.1303 (0.1261) loss_vfl_aux_1: 0.1279 (0.1776) loss_bbox_aux_1: 0.2897 (0.3024) loss_giou_aux_1: 1.8810 (1.8419) loss_fgl_aux_1: 0.3492 (0.4019) loss_ddf_aux_1: 0.0165 (0.0158) loss_vfl_aux_2: 0.1257 (0.1762) loss_bbox_aux_2: 0.2886 (0.3023) loss_giou_aux_2: 1.8787 (1.8403) loss_fgl_aux_2: 0.3481 (0.4019) loss_ddf_aux_2: 0.0024 (0.0024) loss_vfl_aux_3: 0.1246 (0.1733) loss_bbox_aux_3: 0.2877 (0.3022) loss_giou_aux_3: 1.8785 (1.8402) loss_fgl_aux_3: 0.3480 (0.4020) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1233 (0.1723) loss_bbox_aux_4: 0.2875 (0.3022) loss_giou_aux_4: 1.8787 (1.8402) loss_fgl_aux_4: 0.3479 (0.4020) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1197 (0.1713) loss_bbox_pre: 0.3033 (0.3097) loss_giou_pre: 1.8743 (1.8482) loss_vfl_enc_0: 0.1213 (0.1636) loss_bbox_enc_0: 0.3254 (0.3317) loss_giou_enc_0: 1.9229 (1.8898) loss_vfl_dn_0: 0.4067 (0.4102) loss_bbox_dn_0: 0.0453 (0.0546) loss_giou_dn_0: 1.2164 (1.2058) loss_fgl_dn_0: 0.9035 (0.9114) loss_ddf_dn_0: 0.1997 (0.2460) loss_vfl_dn_1: 0.4355 (0.4541) loss_bbox_dn_1: 0.0399 (0.0457) loss_giou_dn_1: 1.1419 (1.1122) loss_fgl_dn_1: 0.9247 (0.9404) loss_ddf_dn_1: 0.0338 (0.0321) loss_vfl_dn_2: 0.4426 (0.4537) loss_bbox_dn_2: 0.0379 (0.0444) loss_giou_dn_2: 1.1145 (1.1014) loss_fgl_dn_2: 0.9302 (0.9434) loss_ddf_dn_2: 0.0035 (0.0035) loss_vfl_dn_3: 0.4443 (0.4504) loss_bbox_dn_3: 0.0375 (0.0442) loss_giou_dn_3: 1.1137 (1.1006) loss_fgl_dn_3: 0.9295 (0.9437) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4414 (0.4502) loss_bbox_dn_4: 0.0375 (0.0441) loss_giou_dn_4: 1.1134 (1.1005) loss_fgl_dn_4: 0.9299 (0.9438) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4424 (0.4506) loss_bbox_dn_5: 0.0376 (0.0441) loss_giou_dn_5: 1.1133 (1.1005) loss_fgl_dn_5: 0.9299 (0.9438) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4045 (0.4093) loss_bbox_dn_pre: 0.0453 (0.0549) loss_giou_dn_pre: 1.2167 (1.2060) time: 0.8509 data: 0.0168 max mem: 29821\n", + "Epoch: [30] Total time: 0:01:12 (0.8630 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.1019 (38.4340) loss_vfl: 0.1240 (0.1723) loss_bbox: 0.2875 (0.3021) loss_giou: 1.8788 (1.8402) loss_fgl: 0.3479 (0.4020) loss_vfl_aux_0: 0.1215 (0.1739) loss_bbox_aux_0: 0.3011 (0.3054) loss_giou_aux_0: 1.8802 (1.8534) loss_fgl_aux_0: 0.3411 (0.4006) loss_ddf_aux_0: 0.1303 (0.1261) loss_vfl_aux_1: 0.1279 (0.1776) loss_bbox_aux_1: 0.2897 (0.3024) loss_giou_aux_1: 1.8810 (1.8419) loss_fgl_aux_1: 0.3492 (0.4019) loss_ddf_aux_1: 0.0165 (0.0158) loss_vfl_aux_2: 0.1257 (0.1762) loss_bbox_aux_2: 0.2886 (0.3023) loss_giou_aux_2: 1.8787 (1.8403) loss_fgl_aux_2: 0.3481 (0.4019) loss_ddf_aux_2: 0.0024 (0.0024) loss_vfl_aux_3: 0.1246 (0.1733) loss_bbox_aux_3: 0.2877 (0.3022) loss_giou_aux_3: 1.8785 (1.8402) loss_fgl_aux_3: 0.3480 (0.4020) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1233 (0.1723) loss_bbox_aux_4: 0.2875 (0.3022) loss_giou_aux_4: 1.8787 (1.8402) loss_fgl_aux_4: 0.3479 (0.4020) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1197 (0.1713) loss_bbox_pre: 0.3033 (0.3097) loss_giou_pre: 1.8743 (1.8482) loss_vfl_enc_0: 0.1213 (0.1636) loss_bbox_enc_0: 0.3254 (0.3317) loss_giou_enc_0: 1.9229 (1.8898) loss_vfl_dn_0: 0.4067 (0.4102) loss_bbox_dn_0: 0.0453 (0.0546) loss_giou_dn_0: 1.2164 (1.2058) loss_fgl_dn_0: 0.9035 (0.9114) loss_ddf_dn_0: 0.1997 (0.2460) loss_vfl_dn_1: 0.4355 (0.4541) loss_bbox_dn_1: 0.0399 (0.0457) loss_giou_dn_1: 1.1419 (1.1122) loss_fgl_dn_1: 0.9247 (0.9404) loss_ddf_dn_1: 0.0338 (0.0321) loss_vfl_dn_2: 0.4426 (0.4537) loss_bbox_dn_2: 0.0379 (0.0444) loss_giou_dn_2: 1.1145 (1.1014) loss_fgl_dn_2: 0.9302 (0.9434) loss_ddf_dn_2: 0.0035 (0.0035) loss_vfl_dn_3: 0.4443 (0.4504) loss_bbox_dn_3: 0.0375 (0.0442) loss_giou_dn_3: 1.1137 (1.1006) loss_fgl_dn_3: 0.9295 (0.9437) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4414 (0.4502) loss_bbox_dn_4: 0.0375 (0.0441) loss_giou_dn_4: 1.1134 (1.1005) loss_fgl_dn_4: 0.9299 (0.9438) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4424 (0.4506) loss_bbox_dn_5: 0.0376 (0.0441) loss_giou_dn_5: 1.1133 (1.1005) loss_fgl_dn_5: 0.9299 (0.9438) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4045 (0.4093) loss_bbox_dn_pre: 0.0453 (0.0549) loss_giou_dn_pre: 1.2167 (1.2060)\n", + "Test: [0/4] eta: 0:00:05 time: 1.2883 data: 0.4933 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5287 data: 0.1616 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5459 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.029\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.076\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.013\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.157\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.487\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.030\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.065\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.081\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.079\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.281\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.550\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.173\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.039\n", + "best_stat: {'epoch': 30, 'coco_eval_bbox': 0.029212015460184978}\n", + "Epoch: [31] [ 0/84] eta: 0:02:54 lr: 0.000013 loss: 38.9538 (38.9538) loss_vfl: 0.0884 (0.0884) loss_bbox: 0.3703 (0.3703) loss_giou: 2.0365 (2.0365) loss_fgl: 0.3108 (0.3108) loss_vfl_aux_0: 0.0846 (0.0846) loss_bbox_aux_0: 0.3790 (0.3790) loss_giou_aux_0: 2.0425 (2.0425) loss_fgl_aux_0: 0.3030 (0.3030) loss_ddf_aux_0: 0.0792 (0.0792) loss_vfl_aux_1: 0.0884 (0.0884) loss_bbox_aux_1: 0.3750 (0.3750) loss_giou_aux_1: 2.0381 (2.0381) loss_fgl_aux_1: 0.3103 (0.3103) loss_ddf_aux_1: 0.0112 (0.0112) loss_vfl_aux_2: 0.0904 (0.0904) loss_bbox_aux_2: 0.3717 (0.3717) loss_giou_aux_2: 2.0347 (2.0347) loss_fgl_aux_2: 0.3109 (0.3109) loss_ddf_aux_2: 0.0018 (0.0018) loss_vfl_aux_3: 0.0882 (0.0882) loss_bbox_aux_3: 0.3713 (0.3713) loss_giou_aux_3: 2.0360 (2.0360) loss_fgl_aux_3: 0.3107 (0.3107) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.0888 (0.0888) loss_bbox_aux_4: 0.3705 (0.3705) loss_giou_aux_4: 2.0364 (2.0364) loss_fgl_aux_4: 0.3108 (0.3108) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0826 (0.0826) loss_bbox_pre: 0.3878 (0.3878) loss_giou_pre: 2.0320 (2.0320) loss_vfl_enc_0: 0.0828 (0.0828) loss_bbox_enc_0: 0.4232 (0.4232) loss_giou_enc_0: 2.0704 (2.0704) loss_vfl_dn_0: 0.3960 (0.3960) loss_bbox_dn_0: 0.0362 (0.0362) loss_giou_dn_0: 1.2381 (1.2381) loss_fgl_dn_0: 0.8713 (0.8713) loss_ddf_dn_0: 0.1112 (0.1112) loss_vfl_dn_1: 0.4265 (0.4265) loss_bbox_dn_1: 0.0298 (0.0298) loss_giou_dn_1: 1.1642 (1.1642) loss_fgl_dn_1: 0.9046 (0.9046) loss_ddf_dn_1: 0.0206 (0.0206) loss_vfl_dn_2: 0.4355 (0.4355) loss_bbox_dn_2: 0.0300 (0.0300) loss_giou_dn_2: 1.1557 (1.1557) loss_fgl_dn_2: 0.9009 (0.9009) loss_ddf_dn_2: 0.0015 (0.0015) loss_vfl_dn_3: 0.4285 (0.4285) loss_bbox_dn_3: 0.0300 (0.0300) loss_giou_dn_3: 1.1559 (1.1559) loss_fgl_dn_3: 0.9003 (0.9003) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4287 (0.4287) loss_bbox_dn_4: 0.0299 (0.0299) loss_giou_dn_4: 1.1556 (1.1556) loss_fgl_dn_4: 0.9006 (0.9006) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4285 (0.4285) loss_bbox_dn_5: 0.0299 (0.0299) loss_giou_dn_5: 1.1556 (1.1556) loss_fgl_dn_5: 0.9006 (0.9006) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3960 (0.3960) loss_bbox_dn_pre: 0.0361 (0.0361) loss_giou_dn_pre: 1.2362 (1.2362) time: 2.0793 data: 0.8522 max mem: 29821\n", + "Epoch: [31] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.2214 (38.5123) loss_vfl: 0.1561 (0.1667) loss_bbox: 0.2892 (0.3100) loss_giou: 1.8349 (1.8587) loss_fgl: 0.3896 (0.3902) loss_vfl_aux_0: 0.1561 (0.1705) loss_bbox_aux_0: 0.2892 (0.3130) loss_giou_aux_0: 1.8546 (1.8706) loss_fgl_aux_0: 0.3913 (0.3898) loss_ddf_aux_0: 0.1373 (0.1245) loss_vfl_aux_1: 0.1569 (0.1726) loss_bbox_aux_1: 0.2887 (0.3110) loss_giou_aux_1: 1.8381 (1.8595) loss_fgl_aux_1: 0.3898 (0.3900) loss_ddf_aux_1: 0.0148 (0.0156) loss_vfl_aux_2: 0.1550 (0.1708) loss_bbox_aux_2: 0.2896 (0.3103) loss_giou_aux_2: 1.8346 (1.8584) loss_fgl_aux_2: 0.3896 (0.3901) loss_ddf_aux_2: 0.0016 (0.0021) loss_vfl_aux_3: 0.1567 (0.1683) loss_bbox_aux_3: 0.2892 (0.3101) loss_giou_aux_3: 1.8349 (1.8586) loss_fgl_aux_3: 0.3896 (0.3902) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1571 (0.1667) loss_bbox_aux_4: 0.2892 (0.3100) loss_giou_aux_4: 1.8348 (1.8586) loss_fgl_aux_4: 0.3896 (0.3902) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1534 (0.1678) loss_bbox_pre: 0.2923 (0.3185) loss_giou_pre: 1.8511 (1.8641) loss_vfl_enc_0: 0.1464 (0.1581) loss_bbox_enc_0: 0.3086 (0.3414) loss_giou_enc_0: 1.8872 (1.9094) loss_vfl_dn_0: 0.4075 (0.4107) loss_bbox_dn_0: 0.0537 (0.0524) loss_giou_dn_0: 1.2226 (1.2050) loss_fgl_dn_0: 0.9021 (0.9119) loss_ddf_dn_0: 0.2748 (0.2470) loss_vfl_dn_1: 0.4497 (0.4535) loss_bbox_dn_1: 0.0445 (0.0438) loss_giou_dn_1: 1.1154 (1.1121) loss_fgl_dn_1: 0.9330 (0.9400) loss_ddf_dn_1: 0.0260 (0.0318) loss_vfl_dn_2: 0.4507 (0.4532) loss_bbox_dn_2: 0.0437 (0.0426) loss_giou_dn_2: 1.1074 (1.1015) loss_fgl_dn_2: 0.9331 (0.9425) loss_ddf_dn_2: 0.0022 (0.0034) loss_vfl_dn_3: 0.4458 (0.4496) loss_bbox_dn_3: 0.0429 (0.0424) loss_giou_dn_3: 1.1067 (1.1008) loss_fgl_dn_3: 0.9339 (0.9428) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4480 (0.4487) loss_bbox_dn_4: 0.0426 (0.0423) loss_giou_dn_4: 1.1066 (1.1007) loss_fgl_dn_4: 0.9343 (0.9429) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4497 (0.4498) loss_bbox_dn_5: 0.0425 (0.0423) loss_giou_dn_5: 1.1065 (1.1007) loss_fgl_dn_5: 0.9344 (0.9429) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4043 (0.4097) loss_bbox_dn_pre: 0.0548 (0.0527) loss_giou_dn_pre: 1.2247 (1.2053) time: 0.8898 data: 0.0187 max mem: 29821\n", + "Epoch: [31] Total time: 0:01:14 (0.8856 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.2214 (38.5123) loss_vfl: 0.1561 (0.1667) loss_bbox: 0.2892 (0.3100) loss_giou: 1.8349 (1.8587) loss_fgl: 0.3896 (0.3902) loss_vfl_aux_0: 0.1561 (0.1705) loss_bbox_aux_0: 0.2892 (0.3130) loss_giou_aux_0: 1.8546 (1.8706) loss_fgl_aux_0: 0.3913 (0.3898) loss_ddf_aux_0: 0.1373 (0.1245) loss_vfl_aux_1: 0.1569 (0.1726) loss_bbox_aux_1: 0.2887 (0.3110) loss_giou_aux_1: 1.8381 (1.8595) loss_fgl_aux_1: 0.3898 (0.3900) loss_ddf_aux_1: 0.0148 (0.0156) loss_vfl_aux_2: 0.1550 (0.1708) loss_bbox_aux_2: 0.2896 (0.3103) loss_giou_aux_2: 1.8346 (1.8584) loss_fgl_aux_2: 0.3896 (0.3901) loss_ddf_aux_2: 0.0016 (0.0021) loss_vfl_aux_3: 0.1567 (0.1683) loss_bbox_aux_3: 0.2892 (0.3101) loss_giou_aux_3: 1.8349 (1.8586) loss_fgl_aux_3: 0.3896 (0.3902) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1571 (0.1667) loss_bbox_aux_4: 0.2892 (0.3100) loss_giou_aux_4: 1.8348 (1.8586) loss_fgl_aux_4: 0.3896 (0.3902) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1534 (0.1678) loss_bbox_pre: 0.2923 (0.3185) loss_giou_pre: 1.8511 (1.8641) loss_vfl_enc_0: 0.1464 (0.1581) loss_bbox_enc_0: 0.3086 (0.3414) loss_giou_enc_0: 1.8872 (1.9094) loss_vfl_dn_0: 0.4075 (0.4107) loss_bbox_dn_0: 0.0537 (0.0524) loss_giou_dn_0: 1.2226 (1.2050) loss_fgl_dn_0: 0.9021 (0.9119) loss_ddf_dn_0: 0.2748 (0.2470) loss_vfl_dn_1: 0.4497 (0.4535) loss_bbox_dn_1: 0.0445 (0.0438) loss_giou_dn_1: 1.1154 (1.1121) loss_fgl_dn_1: 0.9330 (0.9400) loss_ddf_dn_1: 0.0260 (0.0318) loss_vfl_dn_2: 0.4507 (0.4532) loss_bbox_dn_2: 0.0437 (0.0426) loss_giou_dn_2: 1.1074 (1.1015) loss_fgl_dn_2: 0.9331 (0.9425) loss_ddf_dn_2: 0.0022 (0.0034) loss_vfl_dn_3: 0.4458 (0.4496) loss_bbox_dn_3: 0.0429 (0.0424) loss_giou_dn_3: 1.1067 (1.1008) loss_fgl_dn_3: 0.9339 (0.9428) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4480 (0.4487) loss_bbox_dn_4: 0.0426 (0.0423) loss_giou_dn_4: 1.1066 (1.1007) loss_fgl_dn_4: 0.9343 (0.9429) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4497 (0.4498) loss_bbox_dn_5: 0.0425 (0.0423) loss_giou_dn_5: 1.1065 (1.1007) loss_fgl_dn_5: 0.9344 (0.9429) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4043 (0.4097) loss_bbox_dn_pre: 0.0548 (0.0527) loss_giou_dn_pre: 1.2247 (1.2053)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7457 data: 0.4971 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3957 data: 0.1656 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4102 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.074\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.014\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.164\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.403\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.016\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.370\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.425\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.174\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.041\n", + "best_stat: {'epoch': 30, 'coco_eval_bbox': 0.029212015460184978}\n", + "Epoch: [32] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 37.9532 (37.9532) loss_vfl: 0.2181 (0.2181) loss_bbox: 0.2439 (0.2439) loss_giou: 1.7851 (1.7851) loss_fgl: 0.4440 (0.4440) loss_vfl_aux_0: 0.2246 (0.2246) loss_bbox_aux_0: 0.2517 (0.2517) loss_giou_aux_0: 1.7896 (1.7896) loss_fgl_aux_0: 0.4424 (0.4424) loss_ddf_aux_0: 0.1138 (0.1138) loss_vfl_aux_1: 0.2214 (0.2214) loss_bbox_aux_1: 0.2445 (0.2445) loss_giou_aux_1: 1.7867 (1.7867) loss_fgl_aux_1: 0.4448 (0.4448) loss_ddf_aux_1: 0.0108 (0.0108) loss_vfl_aux_2: 0.2283 (0.2283) loss_bbox_aux_2: 0.2437 (0.2437) loss_giou_aux_2: 1.7852 (1.7852) loss_fgl_aux_2: 0.4443 (0.4443) loss_ddf_aux_2: 0.0011 (0.0011) loss_vfl_aux_3: 0.2252 (0.2252) loss_bbox_aux_3: 0.2437 (0.2437) loss_giou_aux_3: 1.7851 (1.7851) loss_fgl_aux_3: 0.4442 (0.4442) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.2195 (0.2195) loss_bbox_aux_4: 0.2439 (0.2439) loss_giou_aux_4: 1.7851 (1.7851) loss_fgl_aux_4: 0.4441 (0.4441) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2198 (0.2198) loss_bbox_pre: 0.2565 (0.2565) loss_giou_pre: 1.7876 (1.7876) loss_vfl_enc_0: 0.2198 (0.2198) loss_bbox_enc_0: 0.2875 (0.2875) loss_giou_enc_0: 1.8262 (1.8262) loss_vfl_dn_0: 0.4177 (0.4177) loss_bbox_dn_0: 0.0527 (0.0527) loss_giou_dn_0: 1.1556 (1.1556) loss_fgl_dn_0: 0.9457 (0.9457) loss_ddf_dn_0: 0.2669 (0.2669) loss_vfl_dn_1: 0.4565 (0.4565) loss_bbox_dn_1: 0.0426 (0.0426) loss_giou_dn_1: 1.0476 (1.0476) loss_fgl_dn_1: 0.9732 (0.9732) loss_ddf_dn_1: 0.0292 (0.0292) loss_vfl_dn_2: 0.4543 (0.4543) loss_bbox_dn_2: 0.0419 (0.0419) loss_giou_dn_2: 1.0372 (1.0372) loss_fgl_dn_2: 0.9746 (0.9746) loss_ddf_dn_2: 0.0028 (0.0028) loss_vfl_dn_3: 0.4524 (0.4524) loss_bbox_dn_3: 0.0416 (0.0416) loss_giou_dn_3: 1.0366 (1.0366) loss_fgl_dn_3: 0.9750 (0.9750) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4524 (0.4524) loss_bbox_dn_4: 0.0416 (0.0416) loss_giou_dn_4: 1.0364 (1.0364) loss_fgl_dn_4: 0.9752 (0.9752) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4534 (0.4534) loss_bbox_dn_5: 0.0415 (0.0415) loss_giou_dn_5: 1.0364 (1.0364) loss_fgl_dn_5: 0.9752 (0.9752) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4177 (0.4177) loss_bbox_dn_pre: 0.0524 (0.0524) loss_giou_dn_pre: 1.1536 (1.1536) time: 1.8113 data: 1.0020 max mem: 29821\n", + "Epoch: [32] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.6608 (38.6416) loss_vfl: 0.1702 (0.1698) loss_bbox: 0.2962 (0.3144) loss_giou: 1.8001 (1.8583) loss_fgl: 0.4097 (0.3980) loss_vfl_aux_0: 0.1796 (0.1741) loss_bbox_aux_0: 0.2975 (0.3176) loss_giou_aux_0: 1.8129 (1.8716) loss_fgl_aux_0: 0.4073 (0.3965) loss_ddf_aux_0: 0.1399 (0.1342) loss_vfl_aux_1: 0.1772 (0.1773) loss_bbox_aux_1: 0.2992 (0.3148) loss_giou_aux_1: 1.8012 (1.8599) loss_fgl_aux_1: 0.4066 (0.3977) loss_ddf_aux_1: 0.0166 (0.0168) loss_vfl_aux_2: 0.1753 (0.1767) loss_bbox_aux_2: 0.2964 (0.3145) loss_giou_aux_2: 1.8000 (1.8584) loss_fgl_aux_2: 0.4088 (0.3978) loss_ddf_aux_2: 0.0022 (0.0024) loss_vfl_aux_3: 0.1718 (0.1723) loss_bbox_aux_3: 0.2959 (0.3144) loss_giou_aux_3: 1.8001 (1.8584) loss_fgl_aux_3: 0.4096 (0.3980) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1689 (0.1700) loss_bbox_aux_4: 0.2962 (0.3144) loss_giou_aux_4: 1.8001 (1.8583) loss_fgl_aux_4: 0.4097 (0.3980) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1765 (0.1711) loss_bbox_pre: 0.2992 (0.3222) loss_giou_pre: 1.8105 (1.8659) loss_vfl_enc_0: 0.1647 (0.1636) loss_bbox_enc_0: 0.3201 (0.3452) loss_giou_enc_0: 1.8605 (1.9101) loss_vfl_dn_0: 0.4045 (0.4062) loss_bbox_dn_0: 0.0564 (0.0548) loss_giou_dn_0: 1.1994 (1.2095) loss_fgl_dn_0: 0.9063 (0.9043) loss_ddf_dn_0: 0.3061 (0.2784) loss_vfl_dn_1: 0.4475 (0.4538) loss_bbox_dn_1: 0.0470 (0.0449) loss_giou_dn_1: 1.1133 (1.1073) loss_fgl_dn_1: 0.9296 (0.9374) loss_ddf_dn_1: 0.0325 (0.0317) loss_vfl_dn_2: 0.4463 (0.4528) loss_bbox_dn_2: 0.0449 (0.0436) loss_giou_dn_2: 1.1152 (1.0985) loss_fgl_dn_2: 0.9323 (0.9400) loss_ddf_dn_2: 0.0028 (0.0035) loss_vfl_dn_3: 0.4407 (0.4497) loss_bbox_dn_3: 0.0445 (0.0434) loss_giou_dn_3: 1.1145 (1.0977) loss_fgl_dn_3: 0.9329 (0.9404) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4414 (0.4487) loss_bbox_dn_4: 0.0446 (0.0433) loss_giou_dn_4: 1.1147 (1.0976) loss_fgl_dn_4: 0.9331 (0.9404) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4421 (0.4488) loss_bbox_dn_5: 0.0446 (0.0433) loss_giou_dn_5: 1.1147 (1.0976) loss_fgl_dn_5: 0.9330 (0.9405) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4060 (0.4054) loss_bbox_dn_pre: 0.0566 (0.0549) loss_giou_dn_pre: 1.2023 (1.2094) time: 0.8567 data: 0.0182 max mem: 29821\n", + "Epoch: [32] Total time: 0:01:15 (0.9007 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.6608 (38.6416) loss_vfl: 0.1702 (0.1698) loss_bbox: 0.2962 (0.3144) loss_giou: 1.8001 (1.8583) loss_fgl: 0.4097 (0.3980) loss_vfl_aux_0: 0.1796 (0.1741) loss_bbox_aux_0: 0.2975 (0.3176) loss_giou_aux_0: 1.8129 (1.8716) loss_fgl_aux_0: 0.4073 (0.3965) loss_ddf_aux_0: 0.1399 (0.1342) loss_vfl_aux_1: 0.1772 (0.1773) loss_bbox_aux_1: 0.2992 (0.3148) loss_giou_aux_1: 1.8012 (1.8599) loss_fgl_aux_1: 0.4066 (0.3977) loss_ddf_aux_1: 0.0166 (0.0168) loss_vfl_aux_2: 0.1753 (0.1767) loss_bbox_aux_2: 0.2964 (0.3145) loss_giou_aux_2: 1.8000 (1.8584) loss_fgl_aux_2: 0.4088 (0.3978) loss_ddf_aux_2: 0.0022 (0.0024) loss_vfl_aux_3: 0.1718 (0.1723) loss_bbox_aux_3: 0.2959 (0.3144) loss_giou_aux_3: 1.8001 (1.8584) loss_fgl_aux_3: 0.4096 (0.3980) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1689 (0.1700) loss_bbox_aux_4: 0.2962 (0.3144) loss_giou_aux_4: 1.8001 (1.8583) loss_fgl_aux_4: 0.4097 (0.3980) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1765 (0.1711) loss_bbox_pre: 0.2992 (0.3222) loss_giou_pre: 1.8105 (1.8659) loss_vfl_enc_0: 0.1647 (0.1636) loss_bbox_enc_0: 0.3201 (0.3452) loss_giou_enc_0: 1.8605 (1.9101) loss_vfl_dn_0: 0.4045 (0.4062) loss_bbox_dn_0: 0.0564 (0.0548) loss_giou_dn_0: 1.1994 (1.2095) loss_fgl_dn_0: 0.9063 (0.9043) loss_ddf_dn_0: 0.3061 (0.2784) loss_vfl_dn_1: 0.4475 (0.4538) loss_bbox_dn_1: 0.0470 (0.0449) loss_giou_dn_1: 1.1133 (1.1073) loss_fgl_dn_1: 0.9296 (0.9374) loss_ddf_dn_1: 0.0325 (0.0317) loss_vfl_dn_2: 0.4463 (0.4528) loss_bbox_dn_2: 0.0449 (0.0436) loss_giou_dn_2: 1.1152 (1.0985) loss_fgl_dn_2: 0.9323 (0.9400) loss_ddf_dn_2: 0.0028 (0.0035) loss_vfl_dn_3: 0.4407 (0.4497) loss_bbox_dn_3: 0.0445 (0.0434) loss_giou_dn_3: 1.1145 (1.0977) loss_fgl_dn_3: 0.9329 (0.9404) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4414 (0.4487) loss_bbox_dn_4: 0.0446 (0.0433) loss_giou_dn_4: 1.1147 (1.0976) loss_fgl_dn_4: 0.9331 (0.9404) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4421 (0.4488) loss_bbox_dn_5: 0.0446 (0.0433) loss_giou_dn_5: 1.1147 (1.0976) loss_fgl_dn_5: 0.9330 (0.9405) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4060 (0.4054) loss_bbox_dn_pre: 0.0566 (0.0549) loss_giou_dn_pre: 1.2023 (1.2094)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7971 data: 0.5461 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4108 data: 0.1740 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4266 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.075\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.173\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.304\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.017\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.061\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.079\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.338\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.350\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.172\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.040\n", + "best_stat: {'epoch': 30, 'coco_eval_bbox': 0.029212015460184978}\n", + "Epoch: [33] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 40.4842 (40.4842) loss_vfl: 0.2561 (0.2561) loss_bbox: 0.3948 (0.3948) loss_giou: 1.8612 (1.8612) loss_fgl: 0.4471 (0.4471) loss_vfl_aux_0: 0.2578 (0.2578) loss_bbox_aux_0: 0.4037 (0.4037) loss_giou_aux_0: 1.8788 (1.8788) loss_fgl_aux_0: 0.4503 (0.4503) loss_ddf_aux_0: 0.1910 (0.1910) loss_vfl_aux_1: 0.2610 (0.2610) loss_bbox_aux_1: 0.3968 (0.3968) loss_giou_aux_1: 1.8618 (1.8618) loss_fgl_aux_1: 0.4472 (0.4472) loss_ddf_aux_1: 0.0217 (0.0217) loss_vfl_aux_2: 0.2600 (0.2600) loss_bbox_aux_2: 0.3949 (0.3949) loss_giou_aux_2: 1.8613 (1.8613) loss_fgl_aux_2: 0.4470 (0.4470) loss_ddf_aux_2: 0.0029 (0.0029) loss_vfl_aux_3: 0.2554 (0.2554) loss_bbox_aux_3: 0.3947 (0.3947) loss_giou_aux_3: 1.8612 (1.8612) loss_fgl_aux_3: 0.4471 (0.4471) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.2583 (0.2583) loss_bbox_aux_4: 0.3948 (0.3948) loss_giou_aux_4: 1.8613 (1.8613) loss_fgl_aux_4: 0.4471 (0.4471) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2554 (0.2554) loss_bbox_pre: 0.4065 (0.4065) loss_giou_pre: 1.8737 (1.8737) loss_vfl_enc_0: 0.2578 (0.2578) loss_bbox_enc_0: 0.4117 (0.4117) loss_giou_enc_0: 1.9238 (1.9238) loss_vfl_dn_0: 0.4209 (0.4209) loss_bbox_dn_0: 0.0681 (0.0681) loss_giou_dn_0: 1.1955 (1.1955) loss_fgl_dn_0: 0.9290 (0.9290) loss_ddf_dn_0: 0.4054 (0.4054) loss_vfl_dn_1: 0.4851 (0.4851) loss_bbox_dn_1: 0.0513 (0.0513) loss_giou_dn_1: 1.0555 (1.0555) loss_fgl_dn_1: 0.9523 (0.9523) loss_ddf_dn_1: 0.0544 (0.0544) loss_vfl_dn_2: 0.4700 (0.4700) loss_bbox_dn_2: 0.0478 (0.0478) loss_giou_dn_2: 1.0532 (1.0532) loss_fgl_dn_2: 0.9478 (0.9478) loss_ddf_dn_2: 0.0054 (0.0054) loss_vfl_dn_3: 0.4563 (0.4563) loss_bbox_dn_3: 0.0474 (0.0474) loss_giou_dn_3: 1.0533 (1.0533) loss_fgl_dn_3: 0.9474 (0.9474) loss_ddf_dn_3: 0.0008 (0.0008) loss_vfl_dn_4: 0.4551 (0.4551) loss_bbox_dn_4: 0.0473 (0.0473) loss_giou_dn_4: 1.0534 (1.0534) loss_fgl_dn_4: 0.9475 (0.9475) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4580 (0.4580) loss_bbox_dn_5: 0.0473 (0.0473) loss_giou_dn_5: 1.0535 (1.0535) loss_fgl_dn_5: 0.9475 (0.9475) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4199 (0.4199) loss_bbox_dn_pre: 0.0692 (0.0692) loss_giou_dn_pre: 1.1939 (1.1939) time: 1.8103 data: 0.9632 max mem: 29821\n", + "Epoch: [33] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.0007 (38.4219) loss_vfl: 0.1503 (0.1692) loss_bbox: 0.2971 (0.3087) loss_giou: 1.8700 (1.8412) loss_fgl: 0.3515 (0.3957) loss_vfl_aux_0: 0.1488 (0.1718) loss_bbox_aux_0: 0.3036 (0.3132) loss_giou_aux_0: 1.8817 (1.8538) loss_fgl_aux_0: 0.3506 (0.3944) loss_ddf_aux_0: 0.1127 (0.1288) loss_vfl_aux_1: 0.1550 (0.1754) loss_bbox_aux_1: 0.2987 (0.3096) loss_giou_aux_1: 1.8696 (1.8427) loss_fgl_aux_1: 0.3510 (0.3955) loss_ddf_aux_1: 0.0140 (0.0172) loss_vfl_aux_2: 0.1534 (0.1744) loss_bbox_aux_2: 0.2974 (0.3090) loss_giou_aux_2: 1.8697 (1.8413) loss_fgl_aux_2: 0.3513 (0.3956) loss_ddf_aux_2: 0.0017 (0.0023) loss_vfl_aux_3: 0.1503 (0.1709) loss_bbox_aux_3: 0.2972 (0.3087) loss_giou_aux_3: 1.8701 (1.8412) loss_fgl_aux_3: 0.3515 (0.3957) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1482 (0.1694) loss_bbox_aux_4: 0.2971 (0.3087) loss_giou_aux_4: 1.8699 (1.8412) loss_fgl_aux_4: 0.3515 (0.3957) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1469 (0.1691) loss_bbox_pre: 0.3074 (0.3173) loss_giou_pre: 1.8790 (1.8490) loss_vfl_enc_0: 0.1426 (0.1637) loss_bbox_enc_0: 0.3273 (0.3372) loss_giou_enc_0: 1.9187 (1.8929) loss_vfl_dn_0: 0.4092 (0.4124) loss_bbox_dn_0: 0.0459 (0.0518) loss_giou_dn_0: 1.2126 (1.2015) loss_fgl_dn_0: 0.9052 (0.9155) loss_ddf_dn_0: 0.2595 (0.2602) loss_vfl_dn_1: 0.4529 (0.4584) loss_bbox_dn_1: 0.0383 (0.0428) loss_giou_dn_1: 1.1102 (1.0991) loss_fgl_dn_1: 0.9403 (0.9468) loss_ddf_dn_1: 0.0272 (0.0306) loss_vfl_dn_2: 0.4565 (0.4577) loss_bbox_dn_2: 0.0364 (0.0416) loss_giou_dn_2: 1.0953 (1.0874) loss_fgl_dn_2: 0.9438 (0.9495) loss_ddf_dn_2: 0.0025 (0.0033) loss_vfl_dn_3: 0.4539 (0.4548) loss_bbox_dn_3: 0.0359 (0.0414) loss_giou_dn_3: 1.0952 (1.0866) loss_fgl_dn_3: 0.9440 (0.9499) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4507 (0.4539) loss_bbox_dn_4: 0.0359 (0.0413) loss_giou_dn_4: 1.0953 (1.0865) loss_fgl_dn_4: 0.9441 (0.9500) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4514 (0.4541) loss_bbox_dn_5: 0.0359 (0.0413) loss_giou_dn_5: 1.0953 (1.0865) loss_fgl_dn_5: 0.9441 (0.9500) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4067 (0.4112) loss_bbox_dn_pre: 0.0461 (0.0519) loss_giou_dn_pre: 1.2134 (1.2024) time: 0.8247 data: 0.0192 max mem: 29821\n", + "Epoch: [33] Total time: 0:01:13 (0.8717 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.0007 (38.4219) loss_vfl: 0.1503 (0.1692) loss_bbox: 0.2971 (0.3087) loss_giou: 1.8700 (1.8412) loss_fgl: 0.3515 (0.3957) loss_vfl_aux_0: 0.1488 (0.1718) loss_bbox_aux_0: 0.3036 (0.3132) loss_giou_aux_0: 1.8817 (1.8538) loss_fgl_aux_0: 0.3506 (0.3944) loss_ddf_aux_0: 0.1127 (0.1288) loss_vfl_aux_1: 0.1550 (0.1754) loss_bbox_aux_1: 0.2987 (0.3096) loss_giou_aux_1: 1.8696 (1.8427) loss_fgl_aux_1: 0.3510 (0.3955) loss_ddf_aux_1: 0.0140 (0.0172) loss_vfl_aux_2: 0.1534 (0.1744) loss_bbox_aux_2: 0.2974 (0.3090) loss_giou_aux_2: 1.8697 (1.8413) loss_fgl_aux_2: 0.3513 (0.3956) loss_ddf_aux_2: 0.0017 (0.0023) loss_vfl_aux_3: 0.1503 (0.1709) loss_bbox_aux_3: 0.2972 (0.3087) loss_giou_aux_3: 1.8701 (1.8412) loss_fgl_aux_3: 0.3515 (0.3957) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1482 (0.1694) loss_bbox_aux_4: 0.2971 (0.3087) loss_giou_aux_4: 1.8699 (1.8412) loss_fgl_aux_4: 0.3515 (0.3957) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1469 (0.1691) loss_bbox_pre: 0.3074 (0.3173) loss_giou_pre: 1.8790 (1.8490) loss_vfl_enc_0: 0.1426 (0.1637) loss_bbox_enc_0: 0.3273 (0.3372) loss_giou_enc_0: 1.9187 (1.8929) loss_vfl_dn_0: 0.4092 (0.4124) loss_bbox_dn_0: 0.0459 (0.0518) loss_giou_dn_0: 1.2126 (1.2015) loss_fgl_dn_0: 0.9052 (0.9155) loss_ddf_dn_0: 0.2595 (0.2602) loss_vfl_dn_1: 0.4529 (0.4584) loss_bbox_dn_1: 0.0383 (0.0428) loss_giou_dn_1: 1.1102 (1.0991) loss_fgl_dn_1: 0.9403 (0.9468) loss_ddf_dn_1: 0.0272 (0.0306) loss_vfl_dn_2: 0.4565 (0.4577) loss_bbox_dn_2: 0.0364 (0.0416) loss_giou_dn_2: 1.0953 (1.0874) loss_fgl_dn_2: 0.9438 (0.9495) loss_ddf_dn_2: 0.0025 (0.0033) loss_vfl_dn_3: 0.4539 (0.4548) loss_bbox_dn_3: 0.0359 (0.0414) loss_giou_dn_3: 1.0952 (1.0866) loss_fgl_dn_3: 0.9440 (0.9499) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4507 (0.4539) loss_bbox_dn_4: 0.0359 (0.0413) loss_giou_dn_4: 1.0953 (1.0865) loss_fgl_dn_4: 0.9441 (0.9500) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4514 (0.4541) loss_bbox_dn_5: 0.0359 (0.0413) loss_giou_dn_5: 1.0953 (1.0865) loss_fgl_dn_5: 0.9441 (0.9500) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4067 (0.4112) loss_bbox_dn_pre: 0.0461 (0.0519) loss_giou_dn_pre: 1.2134 (1.2024)\n", + "Test: [0/4] eta: 0:00:03 time: 0.8265 data: 0.5736 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5598 data: 0.1900 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5786 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.080\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.192\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.176\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.020\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.063\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.080\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.365\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.325\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.173\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.038\n", + "best_stat: {'epoch': 33, 'coco_eval_bbox': 0.03221177616279706}\n", + "Epoch: [34] [ 0/84] eta: 0:03:02 lr: 0.000013 loss: 38.3559 (38.3559) loss_vfl: 0.1628 (0.1628) loss_bbox: 0.2522 (0.2522) loss_giou: 1.8108 (1.8108) loss_fgl: 0.4680 (0.4680) loss_vfl_aux_0: 0.1696 (0.1696) loss_bbox_aux_0: 0.2595 (0.2595) loss_giou_aux_0: 1.8210 (1.8210) loss_fgl_aux_0: 0.4686 (0.4686) loss_ddf_aux_0: 0.3076 (0.3076) loss_vfl_aux_1: 0.1747 (0.1747) loss_bbox_aux_1: 0.2530 (0.2530) loss_giou_aux_1: 1.8139 (1.8139) loss_fgl_aux_1: 0.4689 (0.4689) loss_ddf_aux_1: 0.0463 (0.0463) loss_vfl_aux_2: 0.1700 (0.1700) loss_bbox_aux_2: 0.2530 (0.2530) loss_giou_aux_2: 1.8114 (1.8114) loss_fgl_aux_2: 0.4683 (0.4683) loss_ddf_aux_2: 0.0047 (0.0047) loss_vfl_aux_3: 0.1656 (0.1656) loss_bbox_aux_3: 0.2523 (0.2523) loss_giou_aux_3: 1.8110 (1.8110) loss_fgl_aux_3: 0.4680 (0.4680) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1624 (0.1624) loss_bbox_aux_4: 0.2522 (0.2522) loss_giou_aux_4: 1.8109 (1.8109) loss_fgl_aux_4: 0.4680 (0.4680) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1669 (0.1669) loss_bbox_pre: 0.2644 (0.2644) loss_giou_pre: 1.8151 (1.8151) loss_vfl_enc_0: 0.1533 (0.1533) loss_bbox_enc_0: 0.2994 (0.2994) loss_giou_enc_0: 1.8587 (1.8587) loss_vfl_dn_0: 0.3914 (0.3914) loss_bbox_dn_0: 0.0510 (0.0510) loss_giou_dn_0: 1.2416 (1.2416) loss_fgl_dn_0: 0.8993 (0.8993) loss_ddf_dn_0: 0.2382 (0.2382) loss_vfl_dn_1: 0.4514 (0.4514) loss_bbox_dn_1: 0.0410 (0.0410) loss_giou_dn_1: 1.1116 (1.1116) loss_fgl_dn_1: 0.9470 (0.9470) loss_ddf_dn_1: 0.0316 (0.0316) loss_vfl_dn_2: 0.4548 (0.4548) loss_bbox_dn_2: 0.0404 (0.0404) loss_giou_dn_2: 1.0904 (1.0904) loss_fgl_dn_2: 0.9524 (0.9524) loss_ddf_dn_2: 0.0025 (0.0025) loss_vfl_dn_3: 0.4502 (0.4502) loss_bbox_dn_3: 0.0404 (0.0404) loss_giou_dn_3: 1.0898 (1.0898) loss_fgl_dn_3: 0.9526 (0.9526) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4492 (0.4492) loss_bbox_dn_4: 0.0401 (0.0401) loss_giou_dn_4: 1.0896 (1.0896) loss_fgl_dn_4: 0.9526 (0.9526) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4460 (0.4460) loss_bbox_dn_5: 0.0401 (0.0401) loss_giou_dn_5: 1.0895 (1.0895) loss_fgl_dn_5: 0.9526 (0.9526) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3882 (0.3882) loss_bbox_dn_pre: 0.0515 (0.0515) loss_giou_dn_pre: 1.2455 (1.2455) time: 2.1729 data: 1.3128 max mem: 29821\n", + "Epoch: [34] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.5761 (38.2526) loss_vfl: 0.1520 (0.1688) loss_bbox: 0.2859 (0.2902) loss_giou: 1.8775 (1.8391) loss_fgl: 0.3650 (0.4027) loss_vfl_aux_0: 0.1498 (0.1729) loss_bbox_aux_0: 0.2863 (0.2939) loss_giou_aux_0: 1.8899 (1.8516) loss_fgl_aux_0: 0.3633 (0.4017) loss_ddf_aux_0: 0.0893 (0.1228) loss_vfl_aux_1: 0.1534 (0.1738) loss_bbox_aux_1: 0.2868 (0.2912) loss_giou_aux_1: 1.8777 (1.8404) loss_fgl_aux_1: 0.3642 (0.4024) loss_ddf_aux_1: 0.0128 (0.0174) loss_vfl_aux_2: 0.1520 (0.1732) loss_bbox_aux_2: 0.2859 (0.2904) loss_giou_aux_2: 1.8775 (1.8393) loss_fgl_aux_2: 0.3647 (0.4026) loss_ddf_aux_2: 0.0018 (0.0027) loss_vfl_aux_3: 0.1520 (0.1706) loss_bbox_aux_3: 0.2855 (0.2902) loss_giou_aux_3: 1.8777 (1.8392) loss_fgl_aux_3: 0.3649 (0.4027) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1514 (0.1689) loss_bbox_aux_4: 0.2854 (0.2901) loss_giou_aux_4: 1.8776 (1.8392) loss_fgl_aux_4: 0.3650 (0.4027) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1481 (0.1700) loss_bbox_pre: 0.2886 (0.2979) loss_giou_pre: 1.8846 (1.8470) loss_vfl_enc_0: 0.1409 (0.1607) loss_bbox_enc_0: 0.3039 (0.3209) loss_giou_enc_0: 1.9245 (1.8920) loss_vfl_dn_0: 0.4167 (0.4130) loss_bbox_dn_0: 0.0443 (0.0530) loss_giou_dn_0: 1.1833 (1.1892) loss_fgl_dn_0: 0.9188 (0.9168) loss_ddf_dn_0: 0.2482 (0.2583) loss_vfl_dn_1: 0.4531 (0.4576) loss_bbox_dn_1: 0.0398 (0.0436) loss_giou_dn_1: 1.0914 (1.0958) loss_fgl_dn_1: 0.9432 (0.9466) loss_ddf_dn_1: 0.0257 (0.0311) loss_vfl_dn_2: 0.4553 (0.4563) loss_bbox_dn_2: 0.0382 (0.0423) loss_giou_dn_2: 1.0791 (1.0844) loss_fgl_dn_2: 0.9452 (0.9498) loss_ddf_dn_2: 0.0026 (0.0031) loss_vfl_dn_3: 0.4517 (0.4534) loss_bbox_dn_3: 0.0381 (0.0420) loss_giou_dn_3: 1.0784 (1.0837) loss_fgl_dn_3: 0.9457 (0.9501) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4578 (0.4527) loss_bbox_dn_4: 0.0381 (0.0420) loss_giou_dn_4: 1.0782 (1.0836) loss_fgl_dn_4: 0.9456 (0.9502) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4575 (0.4532) loss_bbox_dn_5: 0.0381 (0.0420) loss_giou_dn_5: 1.0782 (1.0836) loss_fgl_dn_5: 0.9456 (0.9502) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4146 (0.4117) loss_bbox_dn_pre: 0.0447 (0.0532) loss_giou_dn_pre: 1.1830 (1.1900) time: 0.8952 data: 0.0212 max mem: 29821\n", + "Epoch: [34] Total time: 0:01:13 (0.8723 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.5761 (38.2526) loss_vfl: 0.1520 (0.1688) loss_bbox: 0.2859 (0.2902) loss_giou: 1.8775 (1.8391) loss_fgl: 0.3650 (0.4027) loss_vfl_aux_0: 0.1498 (0.1729) loss_bbox_aux_0: 0.2863 (0.2939) loss_giou_aux_0: 1.8899 (1.8516) loss_fgl_aux_0: 0.3633 (0.4017) loss_ddf_aux_0: 0.0893 (0.1228) loss_vfl_aux_1: 0.1534 (0.1738) loss_bbox_aux_1: 0.2868 (0.2912) loss_giou_aux_1: 1.8777 (1.8404) loss_fgl_aux_1: 0.3642 (0.4024) loss_ddf_aux_1: 0.0128 (0.0174) loss_vfl_aux_2: 0.1520 (0.1732) loss_bbox_aux_2: 0.2859 (0.2904) loss_giou_aux_2: 1.8775 (1.8393) loss_fgl_aux_2: 0.3647 (0.4026) loss_ddf_aux_2: 0.0018 (0.0027) loss_vfl_aux_3: 0.1520 (0.1706) loss_bbox_aux_3: 0.2855 (0.2902) loss_giou_aux_3: 1.8777 (1.8392) loss_fgl_aux_3: 0.3649 (0.4027) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1514 (0.1689) loss_bbox_aux_4: 0.2854 (0.2901) loss_giou_aux_4: 1.8776 (1.8392) loss_fgl_aux_4: 0.3650 (0.4027) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1481 (0.1700) loss_bbox_pre: 0.2886 (0.2979) loss_giou_pre: 1.8846 (1.8470) loss_vfl_enc_0: 0.1409 (0.1607) loss_bbox_enc_0: 0.3039 (0.3209) loss_giou_enc_0: 1.9245 (1.8920) loss_vfl_dn_0: 0.4167 (0.4130) loss_bbox_dn_0: 0.0443 (0.0530) loss_giou_dn_0: 1.1833 (1.1892) loss_fgl_dn_0: 0.9188 (0.9168) loss_ddf_dn_0: 0.2482 (0.2583) loss_vfl_dn_1: 0.4531 (0.4576) loss_bbox_dn_1: 0.0398 (0.0436) loss_giou_dn_1: 1.0914 (1.0958) loss_fgl_dn_1: 0.9432 (0.9466) loss_ddf_dn_1: 0.0257 (0.0311) loss_vfl_dn_2: 0.4553 (0.4563) loss_bbox_dn_2: 0.0382 (0.0423) loss_giou_dn_2: 1.0791 (1.0844) loss_fgl_dn_2: 0.9452 (0.9498) loss_ddf_dn_2: 0.0026 (0.0031) loss_vfl_dn_3: 0.4517 (0.4534) loss_bbox_dn_3: 0.0381 (0.0420) loss_giou_dn_3: 1.0784 (1.0837) loss_fgl_dn_3: 0.9457 (0.9501) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4578 (0.4527) loss_bbox_dn_4: 0.0381 (0.0420) loss_giou_dn_4: 1.0782 (1.0836) loss_fgl_dn_4: 0.9456 (0.9502) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4575 (0.4532) loss_bbox_dn_5: 0.0381 (0.0420) loss_giou_dn_5: 1.0782 (1.0836) loss_fgl_dn_5: 0.9456 (0.9502) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4146 (0.4117) loss_bbox_dn_pre: 0.0447 (0.0532) loss_giou_dn_pre: 1.1830 (1.1900)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7644 data: 0.5079 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4176 data: 0.1790 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4328 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.082\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.029\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.121\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.404\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.026\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.061\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.214\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.575\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.175\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.038\n", + "best_stat: {'epoch': 33, 'coco_eval_bbox': 0.03221177616279706}\n", + "Epoch: [35] [ 0/84] eta: 0:02:24 lr: 0.000013 loss: 39.6013 (39.6013) loss_vfl: 0.2030 (0.2030) loss_bbox: 0.3070 (0.3070) loss_giou: 1.9406 (1.9406) loss_fgl: 0.4072 (0.4072) loss_vfl_aux_0: 0.2190 (0.2190) loss_bbox_aux_0: 0.3112 (0.3112) loss_giou_aux_0: 1.9539 (1.9539) loss_fgl_aux_0: 0.4085 (0.4085) loss_ddf_aux_0: 0.1806 (0.1806) loss_vfl_aux_1: 0.2216 (0.2216) loss_bbox_aux_1: 0.3076 (0.3076) loss_giou_aux_1: 1.9426 (1.9426) loss_fgl_aux_1: 0.4070 (0.4070) loss_ddf_aux_1: 0.0260 (0.0260) loss_vfl_aux_2: 0.2137 (0.2137) loss_bbox_aux_2: 0.3071 (0.3071) loss_giou_aux_2: 1.9413 (1.9413) loss_fgl_aux_2: 0.4070 (0.4070) loss_ddf_aux_2: 0.0044 (0.0044) loss_vfl_aux_3: 0.2065 (0.2065) loss_bbox_aux_3: 0.3068 (0.3068) loss_giou_aux_3: 1.9409 (1.9409) loss_fgl_aux_3: 0.4072 (0.4072) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.2061 (0.2061) loss_bbox_aux_4: 0.3067 (0.3067) loss_giou_aux_4: 1.9408 (1.9408) loss_fgl_aux_4: 0.4073 (0.4073) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2151 (0.2151) loss_bbox_pre: 0.3153 (0.3153) loss_giou_pre: 1.9505 (1.9505) loss_vfl_enc_0: 0.2003 (0.2003) loss_bbox_enc_0: 0.3416 (0.3416) loss_giou_enc_0: 1.9720 (1.9720) loss_vfl_dn_0: 0.4172 (0.4172) loss_bbox_dn_0: 0.0530 (0.0530) loss_giou_dn_0: 1.1867 (1.1867) loss_fgl_dn_0: 0.9236 (0.9236) loss_ddf_dn_0: 0.2754 (0.2754) loss_vfl_dn_1: 0.4658 (0.4658) loss_bbox_dn_1: 0.0447 (0.0447) loss_giou_dn_1: 1.0856 (1.0856) loss_fgl_dn_1: 0.9509 (0.9509) loss_ddf_dn_1: 0.0359 (0.0359) loss_vfl_dn_2: 0.4519 (0.4519) loss_bbox_dn_2: 0.0428 (0.0428) loss_giou_dn_2: 1.0757 (1.0757) loss_fgl_dn_2: 0.9540 (0.9540) loss_ddf_dn_2: 0.0039 (0.0039) loss_vfl_dn_3: 0.4458 (0.4458) loss_bbox_dn_3: 0.0422 (0.0422) loss_giou_dn_3: 1.0749 (1.0749) loss_fgl_dn_3: 0.9540 (0.9540) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4458 (0.4458) loss_bbox_dn_4: 0.0422 (0.0422) loss_giou_dn_4: 1.0750 (1.0750) loss_fgl_dn_4: 0.9540 (0.9540) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4473 (0.4473) loss_bbox_dn_5: 0.0422 (0.0422) loss_giou_dn_5: 1.0750 (1.0750) loss_fgl_dn_5: 0.9541 (0.9541) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4170 (0.4170) loss_bbox_dn_pre: 0.0529 (0.0529) loss_giou_dn_pre: 1.1842 (1.1842) time: 1.7167 data: 0.8189 max mem: 29821\n", + "Epoch: [35] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.4118 (38.1987) loss_vfl: 0.1475 (0.1631) loss_bbox: 0.2586 (0.2922) loss_giou: 1.8226 (1.8411) loss_fgl: 0.4077 (0.3954) loss_vfl_aux_0: 0.1477 (0.1666) loss_bbox_aux_0: 0.2602 (0.2958) loss_giou_aux_0: 1.8393 (1.8548) loss_fgl_aux_0: 0.4090 (0.3946) loss_ddf_aux_0: 0.1219 (0.1314) loss_vfl_aux_1: 0.1462 (0.1689) loss_bbox_aux_1: 0.2576 (0.2925) loss_giou_aux_1: 1.8252 (1.8438) loss_fgl_aux_1: 0.4077 (0.3953) loss_ddf_aux_1: 0.0125 (0.0198) loss_vfl_aux_2: 0.1478 (0.1673) loss_bbox_aux_2: 0.2585 (0.2925) loss_giou_aux_2: 1.8227 (1.8412) loss_fgl_aux_2: 0.4076 (0.3953) loss_ddf_aux_2: 0.0019 (0.0029) loss_vfl_aux_3: 0.1443 (0.1645) loss_bbox_aux_3: 0.2585 (0.2923) loss_giou_aux_3: 1.8227 (1.8411) loss_fgl_aux_3: 0.4078 (0.3954) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1469 (0.1630) loss_bbox_aux_4: 0.2586 (0.2922) loss_giou_aux_4: 1.8227 (1.8411) loss_fgl_aux_4: 0.4077 (0.3954) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1459 (0.1639) loss_bbox_pre: 0.2653 (0.3003) loss_giou_pre: 1.8344 (1.8494) loss_vfl_enc_0: 0.1415 (0.1571) loss_bbox_enc_0: 0.2963 (0.3230) loss_giou_enc_0: 1.8659 (1.8979) loss_vfl_dn_0: 0.4058 (0.4103) loss_bbox_dn_0: 0.0499 (0.0501) loss_giou_dn_0: 1.2112 (1.1987) loss_fgl_dn_0: 0.9134 (0.9124) loss_ddf_dn_0: 0.2439 (0.2725) loss_vfl_dn_1: 0.4543 (0.4567) loss_bbox_dn_1: 0.0399 (0.0412) loss_giou_dn_1: 1.0891 (1.0937) loss_fgl_dn_1: 0.9446 (0.9445) loss_ddf_dn_1: 0.0240 (0.0310) loss_vfl_dn_2: 0.4578 (0.4552) loss_bbox_dn_2: 0.0392 (0.0400) loss_giou_dn_2: 1.0782 (1.0845) loss_fgl_dn_2: 0.9471 (0.9469) loss_ddf_dn_2: 0.0024 (0.0029) loss_vfl_dn_3: 0.4517 (0.4524) loss_bbox_dn_3: 0.0391 (0.0398) loss_giou_dn_3: 1.0776 (1.0839) loss_fgl_dn_3: 0.9473 (0.9471) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4517 (0.4512) loss_bbox_dn_4: 0.0391 (0.0398) loss_giou_dn_4: 1.0776 (1.0838) loss_fgl_dn_4: 0.9473 (0.9472) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4515) loss_bbox_dn_5: 0.0391 (0.0398) loss_giou_dn_5: 1.0776 (1.0838) loss_fgl_dn_5: 0.9473 (0.9472) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4048 (0.4087) loss_bbox_dn_pre: 0.0498 (0.0504) loss_giou_dn_pre: 1.2103 (1.1996) time: 0.8467 data: 0.0187 max mem: 29821\n", + "Epoch: [35] Total time: 0:01:12 (0.8595 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.4118 (38.1987) loss_vfl: 0.1475 (0.1631) loss_bbox: 0.2586 (0.2922) loss_giou: 1.8226 (1.8411) loss_fgl: 0.4077 (0.3954) loss_vfl_aux_0: 0.1477 (0.1666) loss_bbox_aux_0: 0.2602 (0.2958) loss_giou_aux_0: 1.8393 (1.8548) loss_fgl_aux_0: 0.4090 (0.3946) loss_ddf_aux_0: 0.1219 (0.1314) loss_vfl_aux_1: 0.1462 (0.1689) loss_bbox_aux_1: 0.2576 (0.2925) loss_giou_aux_1: 1.8252 (1.8438) loss_fgl_aux_1: 0.4077 (0.3953) loss_ddf_aux_1: 0.0125 (0.0198) loss_vfl_aux_2: 0.1478 (0.1673) loss_bbox_aux_2: 0.2585 (0.2925) loss_giou_aux_2: 1.8227 (1.8412) loss_fgl_aux_2: 0.4076 (0.3953) loss_ddf_aux_2: 0.0019 (0.0029) loss_vfl_aux_3: 0.1443 (0.1645) loss_bbox_aux_3: 0.2585 (0.2923) loss_giou_aux_3: 1.8227 (1.8411) loss_fgl_aux_3: 0.4078 (0.3954) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1469 (0.1630) loss_bbox_aux_4: 0.2586 (0.2922) loss_giou_aux_4: 1.8227 (1.8411) loss_fgl_aux_4: 0.4077 (0.3954) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1459 (0.1639) loss_bbox_pre: 0.2653 (0.3003) loss_giou_pre: 1.8344 (1.8494) loss_vfl_enc_0: 0.1415 (0.1571) loss_bbox_enc_0: 0.2963 (0.3230) loss_giou_enc_0: 1.8659 (1.8979) loss_vfl_dn_0: 0.4058 (0.4103) loss_bbox_dn_0: 0.0499 (0.0501) loss_giou_dn_0: 1.2112 (1.1987) loss_fgl_dn_0: 0.9134 (0.9124) loss_ddf_dn_0: 0.2439 (0.2725) loss_vfl_dn_1: 0.4543 (0.4567) loss_bbox_dn_1: 0.0399 (0.0412) loss_giou_dn_1: 1.0891 (1.0937) loss_fgl_dn_1: 0.9446 (0.9445) loss_ddf_dn_1: 0.0240 (0.0310) loss_vfl_dn_2: 0.4578 (0.4552) loss_bbox_dn_2: 0.0392 (0.0400) loss_giou_dn_2: 1.0782 (1.0845) loss_fgl_dn_2: 0.9471 (0.9469) loss_ddf_dn_2: 0.0024 (0.0029) loss_vfl_dn_3: 0.4517 (0.4524) loss_bbox_dn_3: 0.0391 (0.0398) loss_giou_dn_3: 1.0776 (1.0839) loss_fgl_dn_3: 0.9473 (0.9471) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4517 (0.4512) loss_bbox_dn_4: 0.0391 (0.0398) loss_giou_dn_4: 1.0776 (1.0838) loss_fgl_dn_4: 0.9473 (0.9472) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4515) loss_bbox_dn_5: 0.0391 (0.0398) loss_giou_dn_5: 1.0776 (1.0838) loss_fgl_dn_5: 0.9473 (0.9472) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4048 (0.4087) loss_bbox_dn_pre: 0.0498 (0.0504) loss_giou_dn_pre: 1.2103 (1.1996)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7404 data: 0.4940 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3964 data: 0.1642 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4107 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.036\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.084\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.031\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.180\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.169\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.032\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.066\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.082\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.343\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.425\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.174\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.038\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [36] [ 0/84] eta: 0:02:37 lr: 0.000013 loss: 37.6394 (37.6394) loss_vfl: 0.1038 (0.1038) loss_bbox: 0.3009 (0.3009) loss_giou: 1.8532 (1.8532) loss_fgl: 0.3649 (0.3649) loss_vfl_aux_0: 0.1085 (0.1085) loss_bbox_aux_0: 0.2926 (0.2926) loss_giou_aux_0: 1.8666 (1.8666) loss_fgl_aux_0: 0.3688 (0.3688) loss_ddf_aux_0: 0.1989 (0.1989) loss_vfl_aux_1: 0.1063 (0.1063) loss_bbox_aux_1: 0.2985 (0.2985) loss_giou_aux_1: 1.8540 (1.8540) loss_fgl_aux_1: 0.3654 (0.3654) loss_ddf_aux_1: 0.0184 (0.0184) loss_vfl_aux_2: 0.1065 (0.1065) loss_bbox_aux_2: 0.3008 (0.3008) loss_giou_aux_2: 1.8532 (1.8532) loss_fgl_aux_2: 0.3648 (0.3648) loss_ddf_aux_2: 0.0020 (0.0020) loss_vfl_aux_3: 0.1051 (0.1051) loss_bbox_aux_3: 0.3008 (0.3008) loss_giou_aux_3: 1.8532 (1.8532) loss_fgl_aux_3: 0.3649 (0.3649) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1043 (0.1043) loss_bbox_aux_4: 0.3008 (0.3008) loss_giou_aux_4: 1.8532 (1.8532) loss_fgl_aux_4: 0.3650 (0.3650) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1072 (0.1072) loss_bbox_pre: 0.2947 (0.2947) loss_giou_pre: 1.8641 (1.8641) loss_vfl_enc_0: 0.1060 (0.1060) loss_bbox_enc_0: 0.3109 (0.3109) loss_giou_enc_0: 1.8986 (1.8986) loss_vfl_dn_0: 0.4219 (0.4219) loss_bbox_dn_0: 0.0425 (0.0425) loss_giou_dn_0: 1.1631 (1.1631) loss_fgl_dn_0: 0.9421 (0.9421) loss_ddf_dn_0: 0.2141 (0.2141) loss_vfl_dn_1: 0.4526 (0.4526) loss_bbox_dn_1: 0.0369 (0.0369) loss_giou_dn_1: 1.0835 (1.0835) loss_fgl_dn_1: 0.9645 (0.9645) loss_ddf_dn_1: 0.0190 (0.0190) loss_vfl_dn_2: 0.4534 (0.4534) loss_bbox_dn_2: 0.0361 (0.0361) loss_giou_dn_2: 1.0755 (1.0755) loss_fgl_dn_2: 0.9661 (0.9661) loss_ddf_dn_2: 0.0016 (0.0016) loss_vfl_dn_3: 0.4504 (0.4504) loss_bbox_dn_3: 0.0360 (0.0360) loss_giou_dn_3: 1.0751 (1.0751) loss_fgl_dn_3: 0.9663 (0.9663) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4497 (0.4497) loss_bbox_dn_4: 0.0360 (0.0360) loss_giou_dn_4: 1.0750 (1.0750) loss_fgl_dn_4: 0.9664 (0.9664) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4487 (0.4487) loss_bbox_dn_5: 0.0360 (0.0360) loss_giou_dn_5: 1.0750 (1.0750) loss_fgl_dn_5: 0.9664 (0.9664) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4207 (0.4207) loss_bbox_dn_pre: 0.0428 (0.0428) loss_giou_dn_pre: 1.1640 (1.1640) time: 1.8806 data: 0.8373 max mem: 29821\n", + "Epoch: [36] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.9401 (38.2269) loss_vfl: 0.1329 (0.1630) loss_bbox: 0.2724 (0.2953) loss_giou: 1.9114 (1.8377) loss_fgl: 0.3741 (0.4033) loss_vfl_aux_0: 0.1359 (0.1674) loss_bbox_aux_0: 0.2785 (0.2994) loss_giou_aux_0: 1.9266 (1.8494) loss_fgl_aux_0: 0.3741 (0.4020) loss_ddf_aux_0: 0.1130 (0.1238) loss_vfl_aux_1: 0.1393 (0.1692) loss_bbox_aux_1: 0.2752 (0.2960) loss_giou_aux_1: 1.9134 (1.8389) loss_fgl_aux_1: 0.3732 (0.4033) loss_ddf_aux_1: 0.0183 (0.0185) loss_vfl_aux_2: 0.1422 (0.1674) loss_bbox_aux_2: 0.2748 (0.2955) loss_giou_aux_2: 1.9118 (1.8379) loss_fgl_aux_2: 0.3740 (0.4033) loss_ddf_aux_2: 0.0025 (0.0027) loss_vfl_aux_3: 0.1356 (0.1649) loss_bbox_aux_3: 0.2717 (0.2952) loss_giou_aux_3: 1.9115 (1.8378) loss_fgl_aux_3: 0.3742 (0.4034) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1342 (0.1629) loss_bbox_aux_4: 0.2723 (0.2953) loss_giou_aux_4: 1.9115 (1.8377) loss_fgl_aux_4: 0.3741 (0.4034) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1343 (0.1648) loss_bbox_pre: 0.2807 (0.3036) loss_giou_pre: 1.9204 (1.8444) loss_vfl_enc_0: 0.1272 (0.1592) loss_bbox_enc_0: 0.3054 (0.3238) loss_giou_enc_0: 1.9518 (1.8891) loss_vfl_dn_0: 0.4099 (0.4163) loss_bbox_dn_0: 0.0461 (0.0519) loss_giou_dn_0: 1.1910 (1.1872) loss_fgl_dn_0: 0.9137 (0.9218) loss_ddf_dn_0: 0.2477 (0.2544) loss_vfl_dn_1: 0.4607 (0.4609) loss_bbox_dn_1: 0.0375 (0.0424) loss_giou_dn_1: 1.0926 (1.0858) loss_fgl_dn_1: 0.9461 (0.9527) loss_ddf_dn_1: 0.0294 (0.0285) loss_vfl_dn_2: 0.4553 (0.4586) loss_bbox_dn_2: 0.0361 (0.0412) loss_giou_dn_2: 1.0838 (1.0751) loss_fgl_dn_2: 0.9470 (0.9550) loss_ddf_dn_2: 0.0032 (0.0029) loss_vfl_dn_3: 0.4514 (0.4552) loss_bbox_dn_3: 0.0357 (0.0410) loss_giou_dn_3: 1.0844 (1.0744) loss_fgl_dn_3: 0.9468 (0.9552) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4507 (0.4550) loss_bbox_dn_4: 0.0357 (0.0410) loss_giou_dn_4: 1.0843 (1.0743) loss_fgl_dn_4: 0.9469 (0.9553) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4514 (0.4552) loss_bbox_dn_5: 0.0357 (0.0410) loss_giou_dn_5: 1.0843 (1.0743) loss_fgl_dn_5: 0.9470 (0.9553) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4092 (0.4151) loss_bbox_dn_pre: 0.0467 (0.0521) loss_giou_dn_pre: 1.1926 (1.1874) time: 0.9114 data: 0.0174 max mem: 29821\n", + "Epoch: [36] Total time: 0:01:13 (0.8737 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.9401 (38.2269) loss_vfl: 0.1329 (0.1630) loss_bbox: 0.2724 (0.2953) loss_giou: 1.9114 (1.8377) loss_fgl: 0.3741 (0.4033) loss_vfl_aux_0: 0.1359 (0.1674) loss_bbox_aux_0: 0.2785 (0.2994) loss_giou_aux_0: 1.9266 (1.8494) loss_fgl_aux_0: 0.3741 (0.4020) loss_ddf_aux_0: 0.1130 (0.1238) loss_vfl_aux_1: 0.1393 (0.1692) loss_bbox_aux_1: 0.2752 (0.2960) loss_giou_aux_1: 1.9134 (1.8389) loss_fgl_aux_1: 0.3732 (0.4033) loss_ddf_aux_1: 0.0183 (0.0185) loss_vfl_aux_2: 0.1422 (0.1674) loss_bbox_aux_2: 0.2748 (0.2955) loss_giou_aux_2: 1.9118 (1.8379) loss_fgl_aux_2: 0.3740 (0.4033) loss_ddf_aux_2: 0.0025 (0.0027) loss_vfl_aux_3: 0.1356 (0.1649) loss_bbox_aux_3: 0.2717 (0.2952) loss_giou_aux_3: 1.9115 (1.8378) loss_fgl_aux_3: 0.3742 (0.4034) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1342 (0.1629) loss_bbox_aux_4: 0.2723 (0.2953) loss_giou_aux_4: 1.9115 (1.8377) loss_fgl_aux_4: 0.3741 (0.4034) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1343 (0.1648) loss_bbox_pre: 0.2807 (0.3036) loss_giou_pre: 1.9204 (1.8444) loss_vfl_enc_0: 0.1272 (0.1592) loss_bbox_enc_0: 0.3054 (0.3238) loss_giou_enc_0: 1.9518 (1.8891) loss_vfl_dn_0: 0.4099 (0.4163) loss_bbox_dn_0: 0.0461 (0.0519) loss_giou_dn_0: 1.1910 (1.1872) loss_fgl_dn_0: 0.9137 (0.9218) loss_ddf_dn_0: 0.2477 (0.2544) loss_vfl_dn_1: 0.4607 (0.4609) loss_bbox_dn_1: 0.0375 (0.0424) loss_giou_dn_1: 1.0926 (1.0858) loss_fgl_dn_1: 0.9461 (0.9527) loss_ddf_dn_1: 0.0294 (0.0285) loss_vfl_dn_2: 0.4553 (0.4586) loss_bbox_dn_2: 0.0361 (0.0412) loss_giou_dn_2: 1.0838 (1.0751) loss_fgl_dn_2: 0.9470 (0.9550) loss_ddf_dn_2: 0.0032 (0.0029) loss_vfl_dn_3: 0.4514 (0.4552) loss_bbox_dn_3: 0.0357 (0.0410) loss_giou_dn_3: 1.0844 (1.0744) loss_fgl_dn_3: 0.9468 (0.9552) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4507 (0.4550) loss_bbox_dn_4: 0.0357 (0.0410) loss_giou_dn_4: 1.0843 (1.0743) loss_fgl_dn_4: 0.9469 (0.9553) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4514 (0.4552) loss_bbox_dn_5: 0.0357 (0.0410) loss_giou_dn_5: 1.0843 (1.0743) loss_fgl_dn_5: 0.9470 (0.9553) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4092 (0.4151) loss_bbox_dn_pre: 0.0467 (0.0521) loss_giou_dn_pre: 1.1926 (1.1874)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7313 data: 0.4843 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3932 data: 0.1629 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4079 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.031\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.077\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.015\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.186\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.429\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.017\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.058\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.279\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.450\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.166\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.035\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [37] [ 0/84] eta: 0:02:28 lr: 0.000013 loss: 38.5124 (38.5124) loss_vfl: 0.2162 (0.2162) loss_bbox: 0.2432 (0.2432) loss_giou: 1.7903 (1.7903) loss_fgl: 0.4599 (0.4599) loss_vfl_aux_0: 0.2242 (0.2242) loss_bbox_aux_0: 0.2487 (0.2487) loss_giou_aux_0: 1.8035 (1.8035) loss_fgl_aux_0: 0.4593 (0.4593) loss_ddf_aux_0: 0.2617 (0.2617) loss_vfl_aux_1: 0.2302 (0.2302) loss_bbox_aux_1: 0.2439 (0.2439) loss_giou_aux_1: 1.7891 (1.7891) loss_fgl_aux_1: 0.4569 (0.4569) loss_ddf_aux_1: 0.0385 (0.0385) loss_vfl_aux_2: 0.2345 (0.2345) loss_bbox_aux_2: 0.2427 (0.2427) loss_giou_aux_2: 1.7905 (1.7905) loss_fgl_aux_2: 0.4587 (0.4587) loss_ddf_aux_2: 0.0058 (0.0058) loss_vfl_aux_3: 0.2169 (0.2169) loss_bbox_aux_3: 0.2431 (0.2431) loss_giou_aux_3: 1.7907 (1.7907) loss_fgl_aux_3: 0.4598 (0.4598) loss_ddf_aux_3: 0.0008 (0.0008) loss_vfl_aux_4: 0.2142 (0.2142) loss_bbox_aux_4: 0.2432 (0.2432) loss_giou_aux_4: 1.7903 (1.7903) loss_fgl_aux_4: 0.4599 (0.4599) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2185 (0.2185) loss_bbox_pre: 0.2553 (0.2553) loss_giou_pre: 1.7992 (1.7992) loss_vfl_enc_0: 0.1980 (0.1980) loss_bbox_enc_0: 0.2850 (0.2850) loss_giou_enc_0: 1.8427 (1.8427) loss_vfl_dn_0: 0.4150 (0.4150) loss_bbox_dn_0: 0.0638 (0.0638) loss_giou_dn_0: 1.1875 (1.1875) loss_fgl_dn_0: 0.9196 (0.9196) loss_ddf_dn_0: 0.3243 (0.3243) loss_vfl_dn_1: 0.4832 (0.4832) loss_bbox_dn_1: 0.0521 (0.0521) loss_giou_dn_1: 1.0629 (1.0629) loss_fgl_dn_1: 0.9544 (0.9544) loss_ddf_dn_1: 0.0396 (0.0396) loss_vfl_dn_2: 0.4744 (0.4744) loss_bbox_dn_2: 0.0511 (0.0511) loss_giou_dn_2: 1.0531 (1.0531) loss_fgl_dn_2: 0.9564 (0.9564) loss_ddf_dn_2: 0.0045 (0.0045) loss_vfl_dn_3: 0.4636 (0.4636) loss_bbox_dn_3: 0.0508 (0.0508) loss_giou_dn_3: 1.0526 (1.0526) loss_fgl_dn_3: 0.9571 (0.9571) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4658 (0.4658) loss_bbox_dn_4: 0.0512 (0.0512) loss_giou_dn_4: 1.0527 (1.0527) loss_fgl_dn_4: 0.9573 (0.9573) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4719 (0.4719) loss_bbox_dn_5: 0.0512 (0.0512) loss_giou_dn_5: 1.0526 (1.0526) loss_fgl_dn_5: 0.9573 (0.9573) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4128 (0.4128) loss_bbox_dn_pre: 0.0654 (0.0654) loss_giou_dn_pre: 1.1919 (1.1919) time: 1.7653 data: 0.9893 max mem: 29821\n", + "Epoch: [37] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.9284 (38.0766) loss_vfl: 0.1565 (0.1660) loss_bbox: 0.2856 (0.2826) loss_giou: 1.8426 (1.8274) loss_fgl: 0.3824 (0.4016) loss_vfl_aux_0: 0.1676 (0.1708) loss_bbox_aux_0: 0.2845 (0.2864) loss_giou_aux_0: 1.8473 (1.8422) loss_fgl_aux_0: 0.3797 (0.4005) loss_ddf_aux_0: 0.1031 (0.1319) loss_vfl_aux_1: 0.1675 (0.1738) loss_bbox_aux_1: 0.2859 (0.2837) loss_giou_aux_1: 1.8421 (1.8284) loss_fgl_aux_1: 0.3825 (0.4013) loss_ddf_aux_1: 0.0131 (0.0174) loss_vfl_aux_2: 0.1669 (0.1715) loss_bbox_aux_2: 0.2857 (0.2830) loss_giou_aux_2: 1.8424 (1.8274) loss_fgl_aux_2: 0.3824 (0.4014) loss_ddf_aux_2: 0.0020 (0.0026) loss_vfl_aux_3: 0.1588 (0.1681) loss_bbox_aux_3: 0.2855 (0.2827) loss_giou_aux_3: 1.8425 (1.8274) loss_fgl_aux_3: 0.3825 (0.4016) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1580 (0.1664) loss_bbox_aux_4: 0.2856 (0.2826) loss_giou_aux_4: 1.8426 (1.8274) loss_fgl_aux_4: 0.3824 (0.4016) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1621 (0.1680) loss_bbox_pre: 0.2865 (0.2905) loss_giou_pre: 1.8430 (1.8372) loss_vfl_enc_0: 0.1594 (0.1619) loss_bbox_enc_0: 0.2963 (0.3126) loss_giou_enc_0: 1.8718 (1.8853) loss_vfl_dn_0: 0.4124 (0.4115) loss_bbox_dn_0: 0.0462 (0.0513) loss_giou_dn_0: 1.1807 (1.1962) loss_fgl_dn_0: 0.9184 (0.9148) loss_ddf_dn_0: 0.2929 (0.2723) loss_vfl_dn_1: 0.4609 (0.4598) loss_bbox_dn_1: 0.0357 (0.0415) loss_giou_dn_1: 1.0826 (1.0879) loss_fgl_dn_1: 0.9459 (0.9473) loss_ddf_dn_1: 0.0292 (0.0302) loss_vfl_dn_2: 0.4551 (0.4579) loss_bbox_dn_2: 0.0345 (0.0403) loss_giou_dn_2: 1.0789 (1.0763) loss_fgl_dn_2: 0.9466 (0.9505) loss_ddf_dn_2: 0.0025 (0.0028) loss_vfl_dn_3: 0.4517 (0.4547) loss_bbox_dn_3: 0.0344 (0.0401) loss_giou_dn_3: 1.0778 (1.0756) loss_fgl_dn_3: 0.9472 (0.9508) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4514 (0.4545) loss_bbox_dn_4: 0.0345 (0.0400) loss_giou_dn_4: 1.0776 (1.0755) loss_fgl_dn_4: 0.9472 (0.9508) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4519 (0.4547) loss_bbox_dn_5: 0.0345 (0.0400) loss_giou_dn_5: 1.0776 (1.0755) loss_fgl_dn_5: 0.9472 (0.9508) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4121 (0.4104) loss_bbox_dn_pre: 0.0462 (0.0515) loss_giou_dn_pre: 1.1803 (1.1968) time: 0.8387 data: 0.0183 max mem: 29821\n", + "Epoch: [37] Total time: 0:01:12 (0.8589 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.9284 (38.0766) loss_vfl: 0.1565 (0.1660) loss_bbox: 0.2856 (0.2826) loss_giou: 1.8426 (1.8274) loss_fgl: 0.3824 (0.4016) loss_vfl_aux_0: 0.1676 (0.1708) loss_bbox_aux_0: 0.2845 (0.2864) loss_giou_aux_0: 1.8473 (1.8422) loss_fgl_aux_0: 0.3797 (0.4005) loss_ddf_aux_0: 0.1031 (0.1319) loss_vfl_aux_1: 0.1675 (0.1738) loss_bbox_aux_1: 0.2859 (0.2837) loss_giou_aux_1: 1.8421 (1.8284) loss_fgl_aux_1: 0.3825 (0.4013) loss_ddf_aux_1: 0.0131 (0.0174) loss_vfl_aux_2: 0.1669 (0.1715) loss_bbox_aux_2: 0.2857 (0.2830) loss_giou_aux_2: 1.8424 (1.8274) loss_fgl_aux_2: 0.3824 (0.4014) loss_ddf_aux_2: 0.0020 (0.0026) loss_vfl_aux_3: 0.1588 (0.1681) loss_bbox_aux_3: 0.2855 (0.2827) loss_giou_aux_3: 1.8425 (1.8274) loss_fgl_aux_3: 0.3825 (0.4016) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1580 (0.1664) loss_bbox_aux_4: 0.2856 (0.2826) loss_giou_aux_4: 1.8426 (1.8274) loss_fgl_aux_4: 0.3824 (0.4016) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1621 (0.1680) loss_bbox_pre: 0.2865 (0.2905) loss_giou_pre: 1.8430 (1.8372) loss_vfl_enc_0: 0.1594 (0.1619) loss_bbox_enc_0: 0.2963 (0.3126) loss_giou_enc_0: 1.8718 (1.8853) loss_vfl_dn_0: 0.4124 (0.4115) loss_bbox_dn_0: 0.0462 (0.0513) loss_giou_dn_0: 1.1807 (1.1962) loss_fgl_dn_0: 0.9184 (0.9148) loss_ddf_dn_0: 0.2929 (0.2723) loss_vfl_dn_1: 0.4609 (0.4598) loss_bbox_dn_1: 0.0357 (0.0415) loss_giou_dn_1: 1.0826 (1.0879) loss_fgl_dn_1: 0.9459 (0.9473) loss_ddf_dn_1: 0.0292 (0.0302) loss_vfl_dn_2: 0.4551 (0.4579) loss_bbox_dn_2: 0.0345 (0.0403) loss_giou_dn_2: 1.0789 (1.0763) loss_fgl_dn_2: 0.9466 (0.9505) loss_ddf_dn_2: 0.0025 (0.0028) loss_vfl_dn_3: 0.4517 (0.4547) loss_bbox_dn_3: 0.0344 (0.0401) loss_giou_dn_3: 1.0778 (1.0756) loss_fgl_dn_3: 0.9472 (0.9508) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4514 (0.4545) loss_bbox_dn_4: 0.0345 (0.0400) loss_giou_dn_4: 1.0776 (1.0755) loss_fgl_dn_4: 0.9472 (0.9508) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4519 (0.4547) loss_bbox_dn_5: 0.0345 (0.0400) loss_giou_dn_5: 1.0776 (1.0755) loss_fgl_dn_5: 0.9472 (0.9508) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4121 (0.4104) loss_bbox_dn_pre: 0.0462 (0.0515) loss_giou_dn_pre: 1.1803 (1.1968)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7541 data: 0.5006 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4003 data: 0.1671 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4151 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.034\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.082\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.017\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.184\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.296\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.035\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.067\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.288\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.165\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.081\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [38] [ 0/84] eta: 0:02:37 lr: 0.000013 loss: 40.7357 (40.7357) loss_vfl: 0.2861 (0.2861) loss_bbox: 0.3565 (0.3565) loss_giou: 1.7693 (1.7693) loss_fgl: 0.5608 (0.5608) loss_vfl_aux_0: 0.2803 (0.2803) loss_bbox_aux_0: 0.3747 (0.3747) loss_giou_aux_0: 1.7806 (1.7806) loss_fgl_aux_0: 0.5629 (0.5629) loss_ddf_aux_0: 0.2618 (0.2618) loss_vfl_aux_1: 0.2920 (0.2920) loss_bbox_aux_1: 0.3582 (0.3582) loss_giou_aux_1: 1.7710 (1.7710) loss_fgl_aux_1: 0.5619 (0.5619) loss_ddf_aux_1: 0.0344 (0.0344) loss_vfl_aux_2: 0.2871 (0.2871) loss_bbox_aux_2: 0.3563 (0.3563) loss_giou_aux_2: 1.7695 (1.7695) loss_fgl_aux_2: 0.5613 (0.5613) loss_ddf_aux_2: 0.0054 (0.0054) loss_vfl_aux_3: 0.2849 (0.2849) loss_bbox_aux_3: 0.3564 (0.3564) loss_giou_aux_3: 1.7694 (1.7694) loss_fgl_aux_3: 0.5609 (0.5609) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.2847 (0.2847) loss_bbox_aux_4: 0.3565 (0.3565) loss_giou_aux_4: 1.7694 (1.7694) loss_fgl_aux_4: 0.5608 (0.5608) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2756 (0.2756) loss_bbox_pre: 0.3794 (0.3794) loss_giou_pre: 1.7771 (1.7771) loss_vfl_enc_0: 0.2656 (0.2656) loss_bbox_enc_0: 0.4367 (0.4367) loss_giou_enc_0: 1.8583 (1.8583) loss_vfl_dn_0: 0.4260 (0.4260) loss_bbox_dn_0: 0.0827 (0.0827) loss_giou_dn_0: 1.1761 (1.1761) loss_fgl_dn_0: 0.9404 (0.9404) loss_ddf_dn_0: 0.4679 (0.4679) loss_vfl_dn_1: 0.4856 (0.4856) loss_bbox_dn_1: 0.0645 (0.0645) loss_giou_dn_1: 1.0400 (1.0400) loss_fgl_dn_1: 0.9741 (0.9741) loss_ddf_dn_1: 0.0621 (0.0621) loss_vfl_dn_2: 0.4915 (0.4915) loss_bbox_dn_2: 0.0598 (0.0598) loss_giou_dn_2: 1.0190 (1.0190) loss_fgl_dn_2: 0.9765 (0.9765) loss_ddf_dn_2: 0.0076 (0.0076) loss_vfl_dn_3: 0.4863 (0.4863) loss_bbox_dn_3: 0.0591 (0.0591) loss_giou_dn_3: 1.0159 (1.0159) loss_fgl_dn_3: 0.9769 (0.9769) loss_ddf_dn_3: 0.0007 (0.0007) loss_vfl_dn_4: 0.4868 (0.4868) loss_bbox_dn_4: 0.0589 (0.0589) loss_giou_dn_4: 1.0152 (1.0152) loss_fgl_dn_4: 0.9772 (0.9772) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4878 (0.4878) loss_bbox_dn_5: 0.0588 (0.0588) loss_giou_dn_5: 1.0151 (1.0151) loss_fgl_dn_5: 0.9772 (0.9772) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4258 (0.4258) loss_bbox_dn_pre: 0.0824 (0.0824) loss_giou_dn_pre: 1.1713 (1.1713) time: 1.8758 data: 1.0623 max mem: 29821\n", + "Epoch: [38] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.9193 (38.4840) loss_vfl: 0.1393 (0.1623) loss_bbox: 0.2881 (0.3085) loss_giou: 1.8201 (1.8586) loss_fgl: 0.4078 (0.3955) loss_vfl_aux_0: 0.1447 (0.1663) loss_bbox_aux_0: 0.2896 (0.3124) loss_giou_aux_0: 1.8380 (1.8723) loss_fgl_aux_0: 0.4088 (0.3950) loss_ddf_aux_0: 0.1169 (0.1396) loss_vfl_aux_1: 0.1469 (0.1693) loss_bbox_aux_1: 0.2882 (0.3092) loss_giou_aux_1: 1.8230 (1.8605) loss_fgl_aux_1: 0.4081 (0.3956) loss_ddf_aux_1: 0.0151 (0.0196) loss_vfl_aux_2: 0.1451 (0.1674) loss_bbox_aux_2: 0.2883 (0.3088) loss_giou_aux_2: 1.8211 (1.8589) loss_fgl_aux_2: 0.4075 (0.3954) loss_ddf_aux_2: 0.0023 (0.0030) loss_vfl_aux_3: 0.1429 (0.1642) loss_bbox_aux_3: 0.2879 (0.3086) loss_giou_aux_3: 1.8208 (1.8587) loss_fgl_aux_3: 0.4077 (0.3955) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1403 (0.1623) loss_bbox_aux_4: 0.2880 (0.3085) loss_giou_aux_4: 1.8201 (1.8587) loss_fgl_aux_4: 0.4078 (0.3955) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1417 (0.1636) loss_bbox_pre: 0.2923 (0.3162) loss_giou_pre: 1.8373 (1.8676) loss_vfl_enc_0: 0.1381 (0.1571) loss_bbox_enc_0: 0.3181 (0.3409) loss_giou_enc_0: 1.8908 (1.9171) loss_vfl_dn_0: 0.4172 (0.4187) loss_bbox_dn_0: 0.0465 (0.0501) loss_giou_dn_0: 1.1724 (1.1807) loss_fgl_dn_0: 0.9294 (0.9282) loss_ddf_dn_0: 0.2347 (0.2740) loss_vfl_dn_1: 0.4607 (0.4623) loss_bbox_dn_1: 0.0365 (0.0408) loss_giou_dn_1: 1.0819 (1.0789) loss_fgl_dn_1: 0.9547 (0.9573) loss_ddf_dn_1: 0.0247 (0.0300) loss_vfl_dn_2: 0.4558 (0.4606) loss_bbox_dn_2: 0.0362 (0.0395) loss_giou_dn_2: 1.0734 (1.0680) loss_fgl_dn_2: 0.9554 (0.9597) loss_ddf_dn_2: 0.0025 (0.0030) loss_vfl_dn_3: 0.4529 (0.4575) loss_bbox_dn_3: 0.0357 (0.0392) loss_giou_dn_3: 1.0722 (1.0672) loss_fgl_dn_3: 0.9554 (0.9599) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4500 (0.4568) loss_bbox_dn_4: 0.0355 (0.0392) loss_giou_dn_4: 1.0719 (1.0670) loss_fgl_dn_4: 0.9556 (0.9600) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4512 (0.4570) loss_bbox_dn_5: 0.0355 (0.0392) loss_giou_dn_5: 1.0719 (1.0670) loss_fgl_dn_5: 0.9556 (0.9600) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4160 (0.4173) loss_bbox_dn_pre: 0.0466 (0.0503) loss_giou_dn_pre: 1.1734 (1.1811) time: 0.9173 data: 0.0183 max mem: 29821\n", + "Epoch: [38] Total time: 0:01:15 (0.9006 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.9193 (38.4840) loss_vfl: 0.1393 (0.1623) loss_bbox: 0.2881 (0.3085) loss_giou: 1.8201 (1.8586) loss_fgl: 0.4078 (0.3955) loss_vfl_aux_0: 0.1447 (0.1663) loss_bbox_aux_0: 0.2896 (0.3124) loss_giou_aux_0: 1.8380 (1.8723) loss_fgl_aux_0: 0.4088 (0.3950) loss_ddf_aux_0: 0.1169 (0.1396) loss_vfl_aux_1: 0.1469 (0.1693) loss_bbox_aux_1: 0.2882 (0.3092) loss_giou_aux_1: 1.8230 (1.8605) loss_fgl_aux_1: 0.4081 (0.3956) loss_ddf_aux_1: 0.0151 (0.0196) loss_vfl_aux_2: 0.1451 (0.1674) loss_bbox_aux_2: 0.2883 (0.3088) loss_giou_aux_2: 1.8211 (1.8589) loss_fgl_aux_2: 0.4075 (0.3954) loss_ddf_aux_2: 0.0023 (0.0030) loss_vfl_aux_3: 0.1429 (0.1642) loss_bbox_aux_3: 0.2879 (0.3086) loss_giou_aux_3: 1.8208 (1.8587) loss_fgl_aux_3: 0.4077 (0.3955) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1403 (0.1623) loss_bbox_aux_4: 0.2880 (0.3085) loss_giou_aux_4: 1.8201 (1.8587) loss_fgl_aux_4: 0.4078 (0.3955) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1417 (0.1636) loss_bbox_pre: 0.2923 (0.3162) loss_giou_pre: 1.8373 (1.8676) loss_vfl_enc_0: 0.1381 (0.1571) loss_bbox_enc_0: 0.3181 (0.3409) loss_giou_enc_0: 1.8908 (1.9171) loss_vfl_dn_0: 0.4172 (0.4187) loss_bbox_dn_0: 0.0465 (0.0501) loss_giou_dn_0: 1.1724 (1.1807) loss_fgl_dn_0: 0.9294 (0.9282) loss_ddf_dn_0: 0.2347 (0.2740) loss_vfl_dn_1: 0.4607 (0.4623) loss_bbox_dn_1: 0.0365 (0.0408) loss_giou_dn_1: 1.0819 (1.0789) loss_fgl_dn_1: 0.9547 (0.9573) loss_ddf_dn_1: 0.0247 (0.0300) loss_vfl_dn_2: 0.4558 (0.4606) loss_bbox_dn_2: 0.0362 (0.0395) loss_giou_dn_2: 1.0734 (1.0680) loss_fgl_dn_2: 0.9554 (0.9597) loss_ddf_dn_2: 0.0025 (0.0030) loss_vfl_dn_3: 0.4529 (0.4575) loss_bbox_dn_3: 0.0357 (0.0392) loss_giou_dn_3: 1.0722 (1.0672) loss_fgl_dn_3: 0.9554 (0.9599) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4500 (0.4568) loss_bbox_dn_4: 0.0355 (0.0392) loss_giou_dn_4: 1.0719 (1.0670) loss_fgl_dn_4: 0.9556 (0.9600) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4512 (0.4570) loss_bbox_dn_5: 0.0355 (0.0392) loss_giou_dn_5: 1.0719 (1.0670) loss_fgl_dn_5: 0.9556 (0.9600) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4160 (0.4173) loss_bbox_dn_pre: 0.0466 (0.0503) loss_giou_dn_pre: 1.1734 (1.1811)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7455 data: 0.4974 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5438 data: 0.1713 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5614 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.082\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.196\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.165\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.030\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.064\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.081\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.348\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.275\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.175\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.037\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [39] [ 0/84] eta: 0:02:21 lr: 0.000013 loss: 36.3366 (36.3366) loss_vfl: 0.1866 (0.1866) loss_bbox: 0.1674 (0.1674) loss_giou: 1.7436 (1.7436) loss_fgl: 0.3682 (0.3682) loss_vfl_aux_0: 0.1869 (0.1869) loss_bbox_aux_0: 0.1705 (0.1705) loss_giou_aux_0: 1.7544 (1.7544) loss_fgl_aux_0: 0.3676 (0.3676) loss_ddf_aux_0: 0.1597 (0.1597) loss_vfl_aux_1: 0.1908 (0.1908) loss_bbox_aux_1: 0.1670 (0.1670) loss_giou_aux_1: 1.7448 (1.7448) loss_fgl_aux_1: 0.3670 (0.3670) loss_ddf_aux_1: 0.0256 (0.0256) loss_vfl_aux_2: 0.1876 (0.1876) loss_bbox_aux_2: 0.1669 (0.1669) loss_giou_aux_2: 1.7434 (1.7434) loss_fgl_aux_2: 0.3678 (0.3678) loss_ddf_aux_2: 0.0039 (0.0039) loss_vfl_aux_3: 0.1807 (0.1807) loss_bbox_aux_3: 0.1672 (0.1672) loss_giou_aux_3: 1.7438 (1.7438) loss_fgl_aux_3: 0.3683 (0.3683) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1812 (0.1812) loss_bbox_aux_4: 0.1674 (0.1674) loss_giou_aux_4: 1.7436 (1.7436) loss_fgl_aux_4: 0.3682 (0.3682) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.1832 (0.1832) loss_bbox_pre: 0.1737 (0.1737) loss_giou_pre: 1.7476 (1.7476) loss_vfl_enc_0: 0.1802 (0.1802) loss_bbox_enc_0: 0.1913 (0.1913) loss_giou_enc_0: 1.7799 (1.7799) loss_vfl_dn_0: 0.4333 (0.4333) loss_bbox_dn_0: 0.0436 (0.0436) loss_giou_dn_0: 1.1531 (1.1531) loss_fgl_dn_0: 0.9552 (0.9552) loss_ddf_dn_0: 0.3013 (0.3013) loss_vfl_dn_1: 0.4705 (0.4705) loss_bbox_dn_1: 0.0334 (0.0334) loss_giou_dn_1: 1.0384 (1.0384) loss_fgl_dn_1: 0.9758 (0.9758) loss_ddf_dn_1: 0.0347 (0.0347) loss_vfl_dn_2: 0.4717 (0.4717) loss_bbox_dn_2: 0.0313 (0.0313) loss_giou_dn_2: 1.0284 (1.0284) loss_fgl_dn_2: 0.9745 (0.9745) loss_ddf_dn_2: 0.0040 (0.0040) loss_vfl_dn_3: 0.4678 (0.4678) loss_bbox_dn_3: 0.0313 (0.0313) loss_giou_dn_3: 1.0281 (1.0281) loss_fgl_dn_3: 0.9747 (0.9747) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4683 (0.4683) loss_bbox_dn_4: 0.0315 (0.0315) loss_giou_dn_4: 1.0281 (1.0281) loss_fgl_dn_4: 0.9749 (0.9749) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4722 (0.4722) loss_bbox_dn_5: 0.0315 (0.0315) loss_giou_dn_5: 1.0281 (1.0281) loss_fgl_dn_5: 0.9749 (0.9749) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4326 (0.4326) loss_bbox_dn_pre: 0.0437 (0.0437) loss_giou_dn_pre: 1.1523 (1.1523) time: 1.6848 data: 0.9611 max mem: 29821\n", + "Epoch: [39] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.0187 (37.9943) loss_vfl: 0.1521 (0.1633) loss_bbox: 0.2960 (0.2759) loss_giou: 1.8713 (1.8188) loss_fgl: 0.3825 (0.4055) loss_vfl_aux_0: 0.1562 (0.1671) loss_bbox_aux_0: 0.3188 (0.2822) loss_giou_aux_0: 1.8826 (1.8316) loss_fgl_aux_0: 0.3810 (0.4034) loss_ddf_aux_0: 0.1699 (0.1462) loss_vfl_aux_1: 0.1610 (0.1703) loss_bbox_aux_1: 0.2961 (0.2769) loss_giou_aux_1: 1.8736 (1.8204) loss_fgl_aux_1: 0.3835 (0.4054) loss_ddf_aux_1: 0.0211 (0.0217) loss_vfl_aux_2: 0.1572 (0.1692) loss_bbox_aux_2: 0.2960 (0.2760) loss_giou_aux_2: 1.8711 (1.8191) loss_fgl_aux_2: 0.3827 (0.4054) loss_ddf_aux_2: 0.0022 (0.0032) loss_vfl_aux_3: 0.1534 (0.1650) loss_bbox_aux_3: 0.2959 (0.2758) loss_giou_aux_3: 1.8713 (1.8189) loss_fgl_aux_3: 0.3826 (0.4056) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1533 (0.1633) loss_bbox_aux_4: 0.2959 (0.2758) loss_giou_aux_4: 1.8714 (1.8188) loss_fgl_aux_4: 0.3826 (0.4055) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1547 (0.1645) loss_bbox_pre: 0.3202 (0.2849) loss_giou_pre: 1.8766 (1.8277) loss_vfl_enc_0: 0.1488 (0.1601) loss_bbox_enc_0: 0.3220 (0.3096) loss_giou_enc_0: 1.9298 (1.8746) loss_vfl_dn_0: 0.4062 (0.4184) loss_bbox_dn_0: 0.0504 (0.0510) loss_giou_dn_0: 1.2099 (1.1822) loss_fgl_dn_0: 0.9083 (0.9271) loss_ddf_dn_0: 0.2684 (0.2827) loss_vfl_dn_1: 0.4524 (0.4607) loss_bbox_dn_1: 0.0404 (0.0414) loss_giou_dn_1: 1.1014 (1.0795) loss_fgl_dn_1: 0.9388 (0.9570) loss_ddf_dn_1: 0.0409 (0.0314) loss_vfl_dn_2: 0.4485 (0.4598) loss_bbox_dn_2: 0.0403 (0.0401) loss_giou_dn_2: 1.0827 (1.0671) loss_fgl_dn_2: 0.9415 (0.9600) loss_ddf_dn_2: 0.0023 (0.0029) loss_vfl_dn_3: 0.4443 (0.4567) loss_bbox_dn_3: 0.0404 (0.0400) loss_giou_dn_3: 1.0828 (1.0665) loss_fgl_dn_3: 0.9411 (0.9603) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4438 (0.4562) loss_bbox_dn_4: 0.0402 (0.0399) loss_giou_dn_4: 1.0827 (1.0664) loss_fgl_dn_4: 0.9413 (0.9604) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4463 (0.4567) loss_bbox_dn_5: 0.0402 (0.0399) loss_giou_dn_5: 1.0827 (1.0664) loss_fgl_dn_5: 0.9412 (0.9604) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4075 (0.4172) loss_bbox_dn_pre: 0.0498 (0.0510) loss_giou_dn_pre: 1.2071 (1.1824) time: 0.8678 data: 0.0185 max mem: 29821\n", + "Epoch: [39] Total time: 0:01:12 (0.8614 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.0187 (37.9943) loss_vfl: 0.1521 (0.1633) loss_bbox: 0.2960 (0.2759) loss_giou: 1.8713 (1.8188) loss_fgl: 0.3825 (0.4055) loss_vfl_aux_0: 0.1562 (0.1671) loss_bbox_aux_0: 0.3188 (0.2822) loss_giou_aux_0: 1.8826 (1.8316) loss_fgl_aux_0: 0.3810 (0.4034) loss_ddf_aux_0: 0.1699 (0.1462) loss_vfl_aux_1: 0.1610 (0.1703) loss_bbox_aux_1: 0.2961 (0.2769) loss_giou_aux_1: 1.8736 (1.8204) loss_fgl_aux_1: 0.3835 (0.4054) loss_ddf_aux_1: 0.0211 (0.0217) loss_vfl_aux_2: 0.1572 (0.1692) loss_bbox_aux_2: 0.2960 (0.2760) loss_giou_aux_2: 1.8711 (1.8191) loss_fgl_aux_2: 0.3827 (0.4054) loss_ddf_aux_2: 0.0022 (0.0032) loss_vfl_aux_3: 0.1534 (0.1650) loss_bbox_aux_3: 0.2959 (0.2758) loss_giou_aux_3: 1.8713 (1.8189) loss_fgl_aux_3: 0.3826 (0.4056) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1533 (0.1633) loss_bbox_aux_4: 0.2959 (0.2758) loss_giou_aux_4: 1.8714 (1.8188) loss_fgl_aux_4: 0.3826 (0.4055) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1547 (0.1645) loss_bbox_pre: 0.3202 (0.2849) loss_giou_pre: 1.8766 (1.8277) loss_vfl_enc_0: 0.1488 (0.1601) loss_bbox_enc_0: 0.3220 (0.3096) loss_giou_enc_0: 1.9298 (1.8746) loss_vfl_dn_0: 0.4062 (0.4184) loss_bbox_dn_0: 0.0504 (0.0510) loss_giou_dn_0: 1.2099 (1.1822) loss_fgl_dn_0: 0.9083 (0.9271) loss_ddf_dn_0: 0.2684 (0.2827) loss_vfl_dn_1: 0.4524 (0.4607) loss_bbox_dn_1: 0.0404 (0.0414) loss_giou_dn_1: 1.1014 (1.0795) loss_fgl_dn_1: 0.9388 (0.9570) loss_ddf_dn_1: 0.0409 (0.0314) loss_vfl_dn_2: 0.4485 (0.4598) loss_bbox_dn_2: 0.0403 (0.0401) loss_giou_dn_2: 1.0827 (1.0671) loss_fgl_dn_2: 0.9415 (0.9600) loss_ddf_dn_2: 0.0023 (0.0029) loss_vfl_dn_3: 0.4443 (0.4567) loss_bbox_dn_3: 0.0404 (0.0400) loss_giou_dn_3: 1.0828 (1.0665) loss_fgl_dn_3: 0.9411 (0.9603) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4438 (0.4562) loss_bbox_dn_4: 0.0402 (0.0399) loss_giou_dn_4: 1.0827 (1.0664) loss_fgl_dn_4: 0.9413 (0.9604) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4463 (0.4567) loss_bbox_dn_5: 0.0402 (0.0399) loss_giou_dn_5: 1.0827 (1.0664) loss_fgl_dn_5: 0.9412 (0.9604) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4075 (0.4172) loss_bbox_dn_pre: 0.0498 (0.0510) loss_giou_dn_pre: 1.2071 (1.1824)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7575 data: 0.5092 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3995 data: 0.1692 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4145 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.083\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.190\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.125\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.020\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.065\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.080\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.296\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.350\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.170\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.037\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [40] [ 0/84] eta: 0:02:16 lr: 0.000013 loss: 36.3178 (36.3178) loss_vfl: 0.1204 (0.1204) loss_bbox: 0.2079 (0.2079) loss_giou: 1.7165 (1.7165) loss_fgl: 0.4154 (0.4154) loss_vfl_aux_0: 0.1233 (0.1233) loss_bbox_aux_0: 0.2121 (0.2121) loss_giou_aux_0: 1.7313 (1.7313) loss_fgl_aux_0: 0.4138 (0.4138) loss_ddf_aux_0: 0.1647 (0.1647) loss_vfl_aux_1: 0.1212 (0.1212) loss_bbox_aux_1: 0.2115 (0.2115) loss_giou_aux_1: 1.7209 (1.7209) loss_fgl_aux_1: 0.4173 (0.4173) loss_ddf_aux_1: 0.0375 (0.0375) loss_vfl_aux_2: 0.1268 (0.1268) loss_bbox_aux_2: 0.2085 (0.2085) loss_giou_aux_2: 1.7171 (1.7171) loss_fgl_aux_2: 0.4154 (0.4154) loss_ddf_aux_2: 0.0040 (0.0040) loss_vfl_aux_3: 0.1243 (0.1243) loss_bbox_aux_3: 0.2080 (0.2080) loss_giou_aux_3: 1.7166 (1.7166) loss_fgl_aux_3: 0.4153 (0.4153) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1207 (0.1207) loss_bbox_aux_4: 0.2079 (0.2079) loss_giou_aux_4: 1.7166 (1.7166) loss_fgl_aux_4: 0.4154 (0.4154) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1212 (0.1212) loss_bbox_pre: 0.2153 (0.2153) loss_giou_pre: 1.7269 (1.7269) loss_vfl_enc_0: 0.1224 (0.1224) loss_bbox_enc_0: 0.2529 (0.2529) loss_giou_enc_0: 1.7670 (1.7670) loss_vfl_dn_0: 0.4097 (0.4097) loss_bbox_dn_0: 0.0380 (0.0380) loss_giou_dn_0: 1.2038 (1.2038) loss_fgl_dn_0: 0.9173 (0.9173) loss_ddf_dn_0: 0.2401 (0.2401) loss_vfl_dn_1: 0.4526 (0.4526) loss_bbox_dn_1: 0.0334 (0.0334) loss_giou_dn_1: 1.1069 (1.1069) loss_fgl_dn_1: 0.9436 (0.9436) loss_ddf_dn_1: 0.0474 (0.0474) loss_vfl_dn_2: 0.4541 (0.4541) loss_bbox_dn_2: 0.0309 (0.0309) loss_giou_dn_2: 1.0928 (1.0928) loss_fgl_dn_2: 0.9429 (0.9429) loss_ddf_dn_2: 0.0029 (0.0029) loss_vfl_dn_3: 0.4470 (0.4470) loss_bbox_dn_3: 0.0306 (0.0306) loss_giou_dn_3: 1.0919 (1.0919) loss_fgl_dn_3: 0.9427 (0.9427) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4443 (0.4443) loss_bbox_dn_4: 0.0304 (0.0304) loss_giou_dn_4: 1.0920 (1.0920) loss_fgl_dn_4: 0.9426 (0.9426) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4473 (0.4473) loss_bbox_dn_5: 0.0304 (0.0304) loss_giou_dn_5: 1.0920 (1.0920) loss_fgl_dn_5: 0.9426 (0.9426) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4077 (0.4077) loss_bbox_dn_pre: 0.0378 (0.0378) loss_giou_dn_pre: 1.2052 (1.2052) time: 1.6195 data: 0.7137 max mem: 29821\n", + "Epoch: [40] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3385 (37.8836) loss_vfl: 0.1450 (0.1599) loss_bbox: 0.2327 (0.2643) loss_giou: 1.8171 (1.8335) loss_fgl: 0.3802 (0.3993) loss_vfl_aux_0: 0.1503 (0.1647) loss_bbox_aux_0: 0.2407 (0.2684) loss_giou_aux_0: 1.8321 (1.8451) loss_fgl_aux_0: 0.3784 (0.3979) loss_ddf_aux_0: 0.0901 (0.1239) loss_vfl_aux_1: 0.1544 (0.1674) loss_bbox_aux_1: 0.2342 (0.2657) loss_giou_aux_1: 1.8169 (1.8337) loss_fgl_aux_1: 0.3804 (0.3989) loss_ddf_aux_1: 0.0108 (0.0175) loss_vfl_aux_2: 0.1464 (0.1655) loss_bbox_aux_2: 0.2325 (0.2645) loss_giou_aux_2: 1.8163 (1.8334) loss_fgl_aux_2: 0.3801 (0.3992) loss_ddf_aux_2: 0.0015 (0.0031) loss_vfl_aux_3: 0.1481 (0.1626) loss_bbox_aux_3: 0.2326 (0.2643) loss_giou_aux_3: 1.8168 (1.8335) loss_fgl_aux_3: 0.3801 (0.3993) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1453 (0.1603) loss_bbox_aux_4: 0.2327 (0.2643) loss_giou_aux_4: 1.8171 (1.8335) loss_fgl_aux_4: 0.3802 (0.3993) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1462 (0.1620) loss_bbox_pre: 0.2446 (0.2718) loss_giou_pre: 1.8250 (1.8405) loss_vfl_enc_0: 0.1368 (0.1561) loss_bbox_enc_0: 0.2643 (0.2948) loss_giou_enc_0: 1.8475 (1.8849) loss_vfl_dn_0: 0.4248 (0.4162) loss_bbox_dn_0: 0.0449 (0.0473) loss_giou_dn_0: 1.1577 (1.1872) loss_fgl_dn_0: 0.9432 (0.9243) loss_ddf_dn_0: 0.2207 (0.2543) loss_vfl_dn_1: 0.4587 (0.4602) loss_bbox_dn_1: 0.0370 (0.0394) loss_giou_dn_1: 1.0747 (1.0860) loss_fgl_dn_1: 0.9664 (0.9526) loss_ddf_dn_1: 0.0197 (0.0264) loss_vfl_dn_2: 0.4556 (0.4590) loss_bbox_dn_2: 0.0366 (0.0382) loss_giou_dn_2: 1.0742 (1.0770) loss_fgl_dn_2: 0.9665 (0.9549) loss_ddf_dn_2: 0.0021 (0.0028) loss_vfl_dn_3: 0.4531 (0.4556) loss_bbox_dn_3: 0.0366 (0.0380) loss_giou_dn_3: 1.0748 (1.0764) loss_fgl_dn_3: 0.9664 (0.9551) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4536 (0.4545) loss_bbox_dn_4: 0.0365 (0.0380) loss_giou_dn_4: 1.0748 (1.0763) loss_fgl_dn_4: 0.9664 (0.9552) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4556 (0.4547) loss_bbox_dn_5: 0.0365 (0.0380) loss_giou_dn_5: 1.0748 (1.0763) loss_fgl_dn_5: 0.9664 (0.9552) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4236 (0.4149) loss_bbox_dn_pre: 0.0446 (0.0476) loss_giou_dn_pre: 1.1588 (1.1876) time: 0.8735 data: 0.0187 max mem: 29821\n", + "Epoch: [40] Total time: 0:01:12 (0.8689 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3385 (37.8836) loss_vfl: 0.1450 (0.1599) loss_bbox: 0.2327 (0.2643) loss_giou: 1.8171 (1.8335) loss_fgl: 0.3802 (0.3993) loss_vfl_aux_0: 0.1503 (0.1647) loss_bbox_aux_0: 0.2407 (0.2684) loss_giou_aux_0: 1.8321 (1.8451) loss_fgl_aux_0: 0.3784 (0.3979) loss_ddf_aux_0: 0.0901 (0.1239) loss_vfl_aux_1: 0.1544 (0.1674) loss_bbox_aux_1: 0.2342 (0.2657) loss_giou_aux_1: 1.8169 (1.8337) loss_fgl_aux_1: 0.3804 (0.3989) loss_ddf_aux_1: 0.0108 (0.0175) loss_vfl_aux_2: 0.1464 (0.1655) loss_bbox_aux_2: 0.2325 (0.2645) loss_giou_aux_2: 1.8163 (1.8334) loss_fgl_aux_2: 0.3801 (0.3992) loss_ddf_aux_2: 0.0015 (0.0031) loss_vfl_aux_3: 0.1481 (0.1626) loss_bbox_aux_3: 0.2326 (0.2643) loss_giou_aux_3: 1.8168 (1.8335) loss_fgl_aux_3: 0.3801 (0.3993) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1453 (0.1603) loss_bbox_aux_4: 0.2327 (0.2643) loss_giou_aux_4: 1.8171 (1.8335) loss_fgl_aux_4: 0.3802 (0.3993) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1462 (0.1620) loss_bbox_pre: 0.2446 (0.2718) loss_giou_pre: 1.8250 (1.8405) loss_vfl_enc_0: 0.1368 (0.1561) loss_bbox_enc_0: 0.2643 (0.2948) loss_giou_enc_0: 1.8475 (1.8849) loss_vfl_dn_0: 0.4248 (0.4162) loss_bbox_dn_0: 0.0449 (0.0473) loss_giou_dn_0: 1.1577 (1.1872) loss_fgl_dn_0: 0.9432 (0.9243) loss_ddf_dn_0: 0.2207 (0.2543) loss_vfl_dn_1: 0.4587 (0.4602) loss_bbox_dn_1: 0.0370 (0.0394) loss_giou_dn_1: 1.0747 (1.0860) loss_fgl_dn_1: 0.9664 (0.9526) loss_ddf_dn_1: 0.0197 (0.0264) loss_vfl_dn_2: 0.4556 (0.4590) loss_bbox_dn_2: 0.0366 (0.0382) loss_giou_dn_2: 1.0742 (1.0770) loss_fgl_dn_2: 0.9665 (0.9549) loss_ddf_dn_2: 0.0021 (0.0028) loss_vfl_dn_3: 0.4531 (0.4556) loss_bbox_dn_3: 0.0366 (0.0380) loss_giou_dn_3: 1.0748 (1.0764) loss_fgl_dn_3: 0.9664 (0.9551) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4536 (0.4545) loss_bbox_dn_4: 0.0365 (0.0380) loss_giou_dn_4: 1.0748 (1.0763) loss_fgl_dn_4: 0.9664 (0.9552) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4556 (0.4547) loss_bbox_dn_5: 0.0365 (0.0380) loss_giou_dn_5: 1.0748 (1.0763) loss_fgl_dn_5: 0.9664 (0.9552) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4236 (0.4149) loss_bbox_dn_pre: 0.0446 (0.0476) loss_giou_dn_pre: 1.1588 (1.1876)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7548 data: 0.5058 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4028 data: 0.1713 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4190 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.084\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.016\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.030\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.177\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.430\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.068\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.283\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.675\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.177\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.043\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [41] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 37.6367 (37.6367) loss_vfl: 0.1694 (0.1694) loss_bbox: 0.2280 (0.2280) loss_giou: 1.8182 (1.8182) loss_fgl: 0.4318 (0.4318) loss_vfl_aux_0: 0.1703 (0.1703) loss_bbox_aux_0: 0.2289 (0.2289) loss_giou_aux_0: 1.8395 (1.8395) loss_fgl_aux_0: 0.4336 (0.4336) loss_ddf_aux_0: 0.1077 (0.1077) loss_vfl_aux_1: 0.1738 (0.1738) loss_bbox_aux_1: 0.2296 (0.2296) loss_giou_aux_1: 1.8204 (1.8204) loss_fgl_aux_1: 0.4323 (0.4323) loss_ddf_aux_1: 0.0119 (0.0119) loss_vfl_aux_2: 0.1768 (0.1768) loss_bbox_aux_2: 0.2283 (0.2283) loss_giou_aux_2: 1.8189 (1.8189) loss_fgl_aux_2: 0.4323 (0.4323) loss_ddf_aux_2: 0.0019 (0.0019) loss_vfl_aux_3: 0.1700 (0.1700) loss_bbox_aux_3: 0.2279 (0.2279) loss_giou_aux_3: 1.8185 (1.8185) loss_fgl_aux_3: 0.4320 (0.4320) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1677 (0.1677) loss_bbox_aux_4: 0.2280 (0.2280) loss_giou_aux_4: 1.8183 (1.8183) loss_fgl_aux_4: 0.4318 (0.4318) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1667 (0.1667) loss_bbox_pre: 0.2330 (0.2330) loss_giou_pre: 1.8314 (1.8314) loss_vfl_enc_0: 0.1654 (0.1654) loss_bbox_enc_0: 0.2600 (0.2600) loss_giou_enc_0: 1.8589 (1.8589) loss_vfl_dn_0: 0.4351 (0.4351) loss_bbox_dn_0: 0.0437 (0.0437) loss_giou_dn_0: 1.1567 (1.1567) loss_fgl_dn_0: 0.9472 (0.9472) loss_ddf_dn_0: 0.2043 (0.2043) loss_vfl_dn_1: 0.4705 (0.4705) loss_bbox_dn_1: 0.0353 (0.0353) loss_giou_dn_1: 1.0601 (1.0601) loss_fgl_dn_1: 0.9676 (0.9676) loss_ddf_dn_1: 0.0188 (0.0188) loss_vfl_dn_2: 0.4744 (0.4744) loss_bbox_dn_2: 0.0342 (0.0342) loss_giou_dn_2: 1.0512 (1.0512) loss_fgl_dn_2: 0.9700 (0.9700) loss_ddf_dn_2: 0.0016 (0.0016) loss_vfl_dn_3: 0.4675 (0.4675) loss_bbox_dn_3: 0.0340 (0.0340) loss_giou_dn_3: 1.0513 (1.0513) loss_fgl_dn_3: 0.9698 (0.9698) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4666 (0.4666) loss_bbox_dn_4: 0.0339 (0.0339) loss_giou_dn_4: 1.0512 (1.0512) loss_fgl_dn_4: 0.9698 (0.9698) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4697 (0.4697) loss_bbox_dn_5: 0.0339 (0.0339) loss_giou_dn_5: 1.0512 (1.0512) loss_fgl_dn_5: 0.9699 (0.9699) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4343 (0.4343) loss_bbox_dn_pre: 0.0440 (0.0440) loss_giou_dn_pre: 1.1551 (1.1551) time: 1.8150 data: 0.8592 max mem: 29821\n", + "Epoch: [41] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.8089 (37.9732) loss_vfl: 0.1678 (0.1675) loss_bbox: 0.2708 (0.2743) loss_giou: 1.8430 (1.8114) loss_fgl: 0.4157 (0.4098) loss_vfl_aux_0: 0.1649 (0.1736) loss_bbox_aux_0: 0.2760 (0.2789) loss_giou_aux_0: 1.8522 (1.8247) loss_fgl_aux_0: 0.4141 (0.4096) loss_ddf_aux_0: 0.1358 (0.1382) loss_vfl_aux_1: 0.1681 (0.1756) loss_bbox_aux_1: 0.2713 (0.2749) loss_giou_aux_1: 1.8454 (1.8128) loss_fgl_aux_1: 0.4163 (0.4098) loss_ddf_aux_1: 0.0150 (0.0189) loss_vfl_aux_2: 0.1722 (0.1737) loss_bbox_aux_2: 0.2713 (0.2744) loss_giou_aux_2: 1.8432 (1.8116) loss_fgl_aux_2: 0.4158 (0.4097) loss_ddf_aux_2: 0.0020 (0.0027) loss_vfl_aux_3: 0.1696 (0.1701) loss_bbox_aux_3: 0.2709 (0.2742) loss_giou_aux_3: 1.8430 (1.8116) loss_fgl_aux_3: 0.4159 (0.4098) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1672 (0.1677) loss_bbox_aux_4: 0.2708 (0.2743) loss_giou_aux_4: 1.8429 (1.8114) loss_fgl_aux_4: 0.4157 (0.4098) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1616 (0.1707) loss_bbox_pre: 0.2814 (0.2826) loss_giou_pre: 1.8449 (1.8199) loss_vfl_enc_0: 0.1693 (0.1669) loss_bbox_enc_0: 0.2926 (0.3065) loss_giou_enc_0: 1.8896 (1.8676) loss_vfl_dn_0: 0.4077 (0.4213) loss_bbox_dn_0: 0.0507 (0.0512) loss_giou_dn_0: 1.2014 (1.1769) loss_fgl_dn_0: 0.9103 (0.9310) loss_ddf_dn_0: 0.2817 (0.2817) loss_vfl_dn_1: 0.4583 (0.4630) loss_bbox_dn_1: 0.0406 (0.0417) loss_giou_dn_1: 1.0782 (1.0741) loss_fgl_dn_1: 0.9442 (0.9591) loss_ddf_dn_1: 0.0307 (0.0279) loss_vfl_dn_2: 0.4568 (0.4621) loss_bbox_dn_2: 0.0383 (0.0403) loss_giou_dn_2: 1.0702 (1.0639) loss_fgl_dn_2: 0.9496 (0.9617) loss_ddf_dn_2: 0.0022 (0.0024) loss_vfl_dn_3: 0.4519 (0.4588) loss_bbox_dn_3: 0.0382 (0.0401) loss_giou_dn_3: 1.0695 (1.0633) loss_fgl_dn_3: 0.9501 (0.9619) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4514 (0.4576) loss_bbox_dn_4: 0.0382 (0.0401) loss_giou_dn_4: 1.0693 (1.0632) loss_fgl_dn_4: 0.9504 (0.9619) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4512 (0.4579) loss_bbox_dn_5: 0.0382 (0.0401) loss_giou_dn_5: 1.0694 (1.0632) loss_fgl_dn_5: 0.9504 (0.9620) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4062 (0.4197) loss_bbox_dn_pre: 0.0499 (0.0515) loss_giou_dn_pre: 1.2028 (1.1777) time: 0.8357 data: 0.0177 max mem: 29821\n", + "Epoch: [41] Total time: 0:01:11 (0.8555 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.8089 (37.9732) loss_vfl: 0.1678 (0.1675) loss_bbox: 0.2708 (0.2743) loss_giou: 1.8430 (1.8114) loss_fgl: 0.4157 (0.4098) loss_vfl_aux_0: 0.1649 (0.1736) loss_bbox_aux_0: 0.2760 (0.2789) loss_giou_aux_0: 1.8522 (1.8247) loss_fgl_aux_0: 0.4141 (0.4096) loss_ddf_aux_0: 0.1358 (0.1382) loss_vfl_aux_1: 0.1681 (0.1756) loss_bbox_aux_1: 0.2713 (0.2749) loss_giou_aux_1: 1.8454 (1.8128) loss_fgl_aux_1: 0.4163 (0.4098) loss_ddf_aux_1: 0.0150 (0.0189) loss_vfl_aux_2: 0.1722 (0.1737) loss_bbox_aux_2: 0.2713 (0.2744) loss_giou_aux_2: 1.8432 (1.8116) loss_fgl_aux_2: 0.4158 (0.4097) loss_ddf_aux_2: 0.0020 (0.0027) loss_vfl_aux_3: 0.1696 (0.1701) loss_bbox_aux_3: 0.2709 (0.2742) loss_giou_aux_3: 1.8430 (1.8116) loss_fgl_aux_3: 0.4159 (0.4098) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1672 (0.1677) loss_bbox_aux_4: 0.2708 (0.2743) loss_giou_aux_4: 1.8429 (1.8114) loss_fgl_aux_4: 0.4157 (0.4098) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1616 (0.1707) loss_bbox_pre: 0.2814 (0.2826) loss_giou_pre: 1.8449 (1.8199) loss_vfl_enc_0: 0.1693 (0.1669) loss_bbox_enc_0: 0.2926 (0.3065) loss_giou_enc_0: 1.8896 (1.8676) loss_vfl_dn_0: 0.4077 (0.4213) loss_bbox_dn_0: 0.0507 (0.0512) loss_giou_dn_0: 1.2014 (1.1769) loss_fgl_dn_0: 0.9103 (0.9310) loss_ddf_dn_0: 0.2817 (0.2817) loss_vfl_dn_1: 0.4583 (0.4630) loss_bbox_dn_1: 0.0406 (0.0417) loss_giou_dn_1: 1.0782 (1.0741) loss_fgl_dn_1: 0.9442 (0.9591) loss_ddf_dn_1: 0.0307 (0.0279) loss_vfl_dn_2: 0.4568 (0.4621) loss_bbox_dn_2: 0.0383 (0.0403) loss_giou_dn_2: 1.0702 (1.0639) loss_fgl_dn_2: 0.9496 (0.9617) loss_ddf_dn_2: 0.0022 (0.0024) loss_vfl_dn_3: 0.4519 (0.4588) loss_bbox_dn_3: 0.0382 (0.0401) loss_giou_dn_3: 1.0695 (1.0633) loss_fgl_dn_3: 0.9501 (0.9619) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4514 (0.4576) loss_bbox_dn_4: 0.0382 (0.0401) loss_giou_dn_4: 1.0693 (1.0632) loss_fgl_dn_4: 0.9504 (0.9619) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4512 (0.4579) loss_bbox_dn_5: 0.0382 (0.0401) loss_giou_dn_5: 1.0694 (1.0632) loss_fgl_dn_5: 0.9504 (0.9620) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4062 (0.4197) loss_bbox_dn_pre: 0.0499 (0.0515) loss_giou_dn_pre: 1.2028 (1.1777)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7494 data: 0.5039 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4001 data: 0.1710 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4151 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.085\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.017\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.194\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.305\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.065\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.082\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.079\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.338\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.300\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.177\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.039\n", + "best_stat: {'epoch': 35, 'coco_eval_bbox': 0.03588876627707357}\n", + "Epoch: [42] [ 0/84] eta: 0:02:24 lr: 0.000013 loss: 38.5971 (38.5971) loss_vfl: 0.1663 (0.1663) loss_bbox: 0.3126 (0.3126) loss_giou: 1.8128 (1.8128) loss_fgl: 0.4667 (0.4667) loss_vfl_aux_0: 0.1700 (0.1700) loss_bbox_aux_0: 0.3204 (0.3204) loss_giou_aux_0: 1.8123 (1.8123) loss_fgl_aux_0: 0.4647 (0.4647) loss_ddf_aux_0: 0.1230 (0.1230) loss_vfl_aux_1: 0.1774 (0.1774) loss_bbox_aux_1: 0.3129 (0.3129) loss_giou_aux_1: 1.8134 (1.8134) loss_fgl_aux_1: 0.4669 (0.4669) loss_ddf_aux_1: 0.0132 (0.0132) loss_vfl_aux_2: 0.1700 (0.1700) loss_bbox_aux_2: 0.3128 (0.3128) loss_giou_aux_2: 1.8131 (1.8131) loss_fgl_aux_2: 0.4670 (0.4670) loss_ddf_aux_2: 0.0019 (0.0019) loss_vfl_aux_3: 0.1642 (0.1642) loss_bbox_aux_3: 0.3127 (0.3127) loss_giou_aux_3: 1.8131 (1.8131) loss_fgl_aux_3: 0.4667 (0.4667) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1655 (0.1655) loss_bbox_aux_4: 0.3126 (0.3126) loss_giou_aux_4: 1.8129 (1.8129) loss_fgl_aux_4: 0.4667 (0.4667) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1666 (0.1666) loss_bbox_pre: 0.3273 (0.3273) loss_giou_pre: 1.8075 (1.8075) loss_vfl_enc_0: 0.1722 (0.1722) loss_bbox_enc_0: 0.3655 (0.3655) loss_giou_enc_0: 1.8643 (1.8643) loss_vfl_dn_0: 0.4050 (0.4050) loss_bbox_dn_0: 0.0579 (0.0579) loss_giou_dn_0: 1.1785 (1.1785) loss_fgl_dn_0: 0.9157 (0.9157) loss_ddf_dn_0: 0.4213 (0.4213) loss_vfl_dn_1: 0.4651 (0.4651) loss_bbox_dn_1: 0.0427 (0.0427) loss_giou_dn_1: 1.0491 (1.0491) loss_fgl_dn_1: 0.9569 (0.9569) loss_ddf_dn_1: 0.0265 (0.0265) loss_vfl_dn_2: 0.4644 (0.4644) loss_bbox_dn_2: 0.0420 (0.0420) loss_giou_dn_2: 1.0347 (1.0347) loss_fgl_dn_2: 0.9633 (0.9633) loss_ddf_dn_2: 0.0021 (0.0021) loss_vfl_dn_3: 0.4668 (0.4668) loss_bbox_dn_3: 0.0420 (0.0420) loss_giou_dn_3: 1.0339 (1.0339) loss_fgl_dn_3: 0.9637 (0.9637) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4680 (0.4680) loss_bbox_dn_4: 0.0421 (0.0421) loss_giou_dn_4: 1.0337 (1.0337) loss_fgl_dn_4: 0.9638 (0.9638) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4653 (0.4653) loss_bbox_dn_5: 0.0421 (0.0421) loss_giou_dn_5: 1.0336 (1.0336) loss_fgl_dn_5: 0.9638 (0.9638) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4070 (0.4070) loss_bbox_dn_pre: 0.0575 (0.0575) loss_giou_dn_pre: 1.1728 (1.1728) time: 1.7175 data: 0.8179 max mem: 29821\n", + "Epoch: [42] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.4431 (38.0899) loss_vfl: 0.1576 (0.1752) loss_bbox: 0.2463 (0.2700) loss_giou: 1.7460 (1.8147) loss_fgl: 0.4281 (0.4191) loss_vfl_aux_0: 0.1637 (0.1808) loss_bbox_aux_0: 0.2536 (0.2757) loss_giou_aux_0: 1.7563 (1.8282) loss_fgl_aux_0: 0.4263 (0.4182) loss_ddf_aux_0: 0.1427 (0.1424) loss_vfl_aux_1: 0.1671 (0.1835) loss_bbox_aux_1: 0.2477 (0.2713) loss_giou_aux_1: 1.7461 (1.8160) loss_fgl_aux_1: 0.4281 (0.4191) loss_ddf_aux_1: 0.0160 (0.0222) loss_vfl_aux_2: 0.1642 (0.1810) loss_bbox_aux_2: 0.2459 (0.2704) loss_giou_aux_2: 1.7459 (1.8146) loss_fgl_aux_2: 0.4279 (0.4189) loss_ddf_aux_2: 0.0022 (0.0036) loss_vfl_aux_3: 0.1616 (0.1774) loss_bbox_aux_3: 0.2461 (0.2700) loss_giou_aux_3: 1.7463 (1.8147) loss_fgl_aux_3: 0.4281 (0.4190) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1581 (0.1753) loss_bbox_aux_4: 0.2462 (0.2700) loss_giou_aux_4: 1.7461 (1.8147) loss_fgl_aux_4: 0.4281 (0.4191) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1616 (0.1781) loss_bbox_pre: 0.2563 (0.2789) loss_giou_pre: 1.7524 (1.8238) loss_vfl_enc_0: 0.1592 (0.1720) loss_bbox_enc_0: 0.2757 (0.3047) loss_giou_enc_0: 1.7820 (1.8696) loss_vfl_dn_0: 0.4302 (0.4240) loss_bbox_dn_0: 0.0471 (0.0506) loss_giou_dn_0: 1.1472 (1.1664) loss_fgl_dn_0: 0.9447 (0.9371) loss_ddf_dn_0: 0.2690 (0.2739) loss_vfl_dn_1: 0.4700 (0.4627) loss_bbox_dn_1: 0.0381 (0.0418) loss_giou_dn_1: 1.0636 (1.0754) loss_fgl_dn_1: 0.9648 (0.9613) loss_ddf_dn_1: 0.0314 (0.0336) loss_vfl_dn_2: 0.4644 (0.4611) loss_bbox_dn_2: 0.0372 (0.0404) loss_giou_dn_2: 1.0548 (1.0636) loss_fgl_dn_2: 0.9664 (0.9651) loss_ddf_dn_2: 0.0027 (0.0035) loss_vfl_dn_3: 0.4570 (0.4577) loss_bbox_dn_3: 0.0370 (0.0401) loss_giou_dn_3: 1.0541 (1.0628) loss_fgl_dn_3: 0.9666 (0.9654) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4568 (0.4568) loss_bbox_dn_4: 0.0370 (0.0401) loss_giou_dn_4: 1.0539 (1.0627) loss_fgl_dn_4: 0.9666 (0.9654) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4580 (0.4571) loss_bbox_dn_5: 0.0370 (0.0401) loss_giou_dn_5: 1.0539 (1.0627) loss_fgl_dn_5: 0.9666 (0.9654) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4302 (0.4227) loss_bbox_dn_pre: 0.0471 (0.0508) loss_giou_dn_pre: 1.1461 (1.1665) time: 0.8618 data: 0.0169 max mem: 29821\n", + "Epoch: [42] Total time: 0:01:11 (0.8531 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.4431 (38.0899) loss_vfl: 0.1576 (0.1752) loss_bbox: 0.2463 (0.2700) loss_giou: 1.7460 (1.8147) loss_fgl: 0.4281 (0.4191) loss_vfl_aux_0: 0.1637 (0.1808) loss_bbox_aux_0: 0.2536 (0.2757) loss_giou_aux_0: 1.7563 (1.8282) loss_fgl_aux_0: 0.4263 (0.4182) loss_ddf_aux_0: 0.1427 (0.1424) loss_vfl_aux_1: 0.1671 (0.1835) loss_bbox_aux_1: 0.2477 (0.2713) loss_giou_aux_1: 1.7461 (1.8160) loss_fgl_aux_1: 0.4281 (0.4191) loss_ddf_aux_1: 0.0160 (0.0222) loss_vfl_aux_2: 0.1642 (0.1810) loss_bbox_aux_2: 0.2459 (0.2704) loss_giou_aux_2: 1.7459 (1.8146) loss_fgl_aux_2: 0.4279 (0.4189) loss_ddf_aux_2: 0.0022 (0.0036) loss_vfl_aux_3: 0.1616 (0.1774) loss_bbox_aux_3: 0.2461 (0.2700) loss_giou_aux_3: 1.7463 (1.8147) loss_fgl_aux_3: 0.4281 (0.4190) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1581 (0.1753) loss_bbox_aux_4: 0.2462 (0.2700) loss_giou_aux_4: 1.7461 (1.8147) loss_fgl_aux_4: 0.4281 (0.4191) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1616 (0.1781) loss_bbox_pre: 0.2563 (0.2789) loss_giou_pre: 1.7524 (1.8238) loss_vfl_enc_0: 0.1592 (0.1720) loss_bbox_enc_0: 0.2757 (0.3047) loss_giou_enc_0: 1.7820 (1.8696) loss_vfl_dn_0: 0.4302 (0.4240) loss_bbox_dn_0: 0.0471 (0.0506) loss_giou_dn_0: 1.1472 (1.1664) loss_fgl_dn_0: 0.9447 (0.9371) loss_ddf_dn_0: 0.2690 (0.2739) loss_vfl_dn_1: 0.4700 (0.4627) loss_bbox_dn_1: 0.0381 (0.0418) loss_giou_dn_1: 1.0636 (1.0754) loss_fgl_dn_1: 0.9648 (0.9613) loss_ddf_dn_1: 0.0314 (0.0336) loss_vfl_dn_2: 0.4644 (0.4611) loss_bbox_dn_2: 0.0372 (0.0404) loss_giou_dn_2: 1.0548 (1.0636) loss_fgl_dn_2: 0.9664 (0.9651) loss_ddf_dn_2: 0.0027 (0.0035) loss_vfl_dn_3: 0.4570 (0.4577) loss_bbox_dn_3: 0.0370 (0.0401) loss_giou_dn_3: 1.0541 (1.0628) loss_fgl_dn_3: 0.9666 (0.9654) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4568 (0.4568) loss_bbox_dn_4: 0.0370 (0.0401) loss_giou_dn_4: 1.0539 (1.0627) loss_fgl_dn_4: 0.9666 (0.9654) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4580 (0.4571) loss_bbox_dn_5: 0.0370 (0.0401) loss_giou_dn_5: 1.0539 (1.0627) loss_fgl_dn_5: 0.9666 (0.9654) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4302 (0.4227) loss_bbox_dn_pre: 0.0471 (0.0508) loss_giou_dn_pre: 1.1461 (1.1665)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7596 data: 0.5111 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4014 data: 0.1706 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4168 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.087\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.032\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.205\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.643\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.085\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.309\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.700\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.049\n", + "best_stat: {'epoch': 42, 'coco_eval_bbox': 0.0368201782041263}\n", + "Epoch: [43] [ 0/84] eta: 0:02:25 lr: 0.000013 loss: 37.4087 (37.4087) loss_vfl: 0.1477 (0.1477) loss_bbox: 0.2415 (0.2415) loss_giou: 1.8105 (1.8105) loss_fgl: 0.4225 (0.4225) loss_vfl_aux_0: 0.1525 (0.1525) loss_bbox_aux_0: 0.2448 (0.2448) loss_giou_aux_0: 1.8235 (1.8235) loss_fgl_aux_0: 0.4266 (0.4266) loss_ddf_aux_0: 0.0838 (0.0838) loss_vfl_aux_1: 0.1533 (0.1533) loss_bbox_aux_1: 0.2426 (0.2426) loss_giou_aux_1: 1.8109 (1.8109) loss_fgl_aux_1: 0.4224 (0.4224) loss_ddf_aux_1: 0.0094 (0.0094) loss_vfl_aux_2: 0.1511 (0.1511) loss_bbox_aux_2: 0.2416 (0.2416) loss_giou_aux_2: 1.8102 (1.8102) loss_fgl_aux_2: 0.4224 (0.4224) loss_ddf_aux_2: 0.0009 (0.0009) loss_vfl_aux_3: 0.1487 (0.1487) loss_bbox_aux_3: 0.2414 (0.2414) loss_giou_aux_3: 1.8105 (1.8105) loss_fgl_aux_3: 0.4226 (0.4226) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1482 (0.1482) loss_bbox_aux_4: 0.2415 (0.2415) loss_giou_aux_4: 1.8105 (1.8105) loss_fgl_aux_4: 0.4225 (0.4225) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1503 (0.1503) loss_bbox_pre: 0.2496 (0.2496) loss_giou_pre: 1.8170 (1.8170) loss_vfl_enc_0: 0.1534 (0.1534) loss_bbox_enc_0: 0.2637 (0.2637) loss_giou_enc_0: 1.8564 (1.8564) loss_vfl_dn_0: 0.4321 (0.4321) loss_bbox_dn_0: 0.0458 (0.0458) loss_giou_dn_0: 1.1459 (1.1459) loss_fgl_dn_0: 0.9485 (0.9485) loss_ddf_dn_0: 0.2141 (0.2141) loss_vfl_dn_1: 0.4661 (0.4661) loss_bbox_dn_1: 0.0369 (0.0369) loss_giou_dn_1: 1.0651 (1.0651) loss_fgl_dn_1: 0.9690 (0.9690) loss_ddf_dn_1: 0.0210 (0.0210) loss_vfl_dn_2: 0.4548 (0.4548) loss_bbox_dn_2: 0.0366 (0.0366) loss_giou_dn_2: 1.0617 (1.0617) loss_fgl_dn_2: 0.9679 (0.9679) loss_ddf_dn_2: 0.0015 (0.0015) loss_vfl_dn_3: 0.4536 (0.4536) loss_bbox_dn_3: 0.0365 (0.0365) loss_giou_dn_3: 1.0615 (1.0615) loss_fgl_dn_3: 0.9680 (0.9680) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4543 (0.4543) loss_bbox_dn_4: 0.0365 (0.0365) loss_giou_dn_4: 1.0614 (1.0614) loss_fgl_dn_4: 0.9680 (0.9680) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4561 (0.4561) loss_bbox_dn_5: 0.0365 (0.0365) loss_giou_dn_5: 1.0615 (1.0615) loss_fgl_dn_5: 0.9680 (0.9680) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4309 (0.4309) loss_bbox_dn_pre: 0.0460 (0.0460) loss_giou_dn_pre: 1.1477 (1.1477) time: 1.7349 data: 0.8896 max mem: 29821\n", + "Epoch: [43] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3870 (37.8411) loss_vfl: 0.1799 (0.1693) loss_bbox: 0.2417 (0.2692) loss_giou: 1.7585 (1.8011) loss_fgl: 0.4038 (0.4132) loss_vfl_aux_0: 0.1854 (0.1737) loss_bbox_aux_0: 0.2505 (0.2739) loss_giou_aux_0: 1.7968 (1.8148) loss_fgl_aux_0: 0.4057 (0.4132) loss_ddf_aux_0: 0.1202 (0.1411) loss_vfl_aux_1: 0.1868 (0.1759) loss_bbox_aux_1: 0.2419 (0.2703) loss_giou_aux_1: 1.7620 (1.8021) loss_fgl_aux_1: 0.4036 (0.4132) loss_ddf_aux_1: 0.0125 (0.0179) loss_vfl_aux_2: 0.1832 (0.1753) loss_bbox_aux_2: 0.2414 (0.2693) loss_giou_aux_2: 1.7599 (1.8013) loss_fgl_aux_2: 0.4037 (0.4132) loss_ddf_aux_2: 0.0018 (0.0028) loss_vfl_aux_3: 0.1823 (0.1715) loss_bbox_aux_3: 0.2415 (0.2690) loss_giou_aux_3: 1.7592 (1.8013) loss_fgl_aux_3: 0.4037 (0.4132) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1807 (0.1696) loss_bbox_aux_4: 0.2416 (0.2691) loss_giou_aux_4: 1.7586 (1.8011) loss_fgl_aux_4: 0.4038 (0.4132) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1846 (0.1713) loss_bbox_pre: 0.2507 (0.2775) loss_giou_pre: 1.7918 (1.8102) loss_vfl_enc_0: 0.1759 (0.1659) loss_bbox_enc_0: 0.2858 (0.3024) loss_giou_enc_0: 1.8478 (1.8570) loss_vfl_dn_0: 0.4250 (0.4219) loss_bbox_dn_0: 0.0470 (0.0505) loss_giou_dn_0: 1.1609 (1.1689) loss_fgl_dn_0: 0.9463 (0.9339) loss_ddf_dn_0: 0.2713 (0.2826) loss_vfl_dn_1: 0.4683 (0.4654) loss_bbox_dn_1: 0.0396 (0.0404) loss_giou_dn_1: 1.0420 (1.0643) loss_fgl_dn_1: 0.9698 (0.9633) loss_ddf_dn_1: 0.0277 (0.0273) loss_vfl_dn_2: 0.4683 (0.4619) loss_bbox_dn_2: 0.0387 (0.0392) loss_giou_dn_2: 1.0340 (1.0554) loss_fgl_dn_2: 0.9727 (0.9650) loss_ddf_dn_2: 0.0027 (0.0028) loss_vfl_dn_3: 0.4639 (0.4594) loss_bbox_dn_3: 0.0385 (0.0389) loss_giou_dn_3: 1.0331 (1.0547) loss_fgl_dn_3: 0.9730 (0.9652) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4619 (0.4590) loss_bbox_dn_4: 0.0385 (0.0389) loss_giou_dn_4: 1.0332 (1.0546) loss_fgl_dn_4: 0.9732 (0.9653) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4646 (0.4589) loss_bbox_dn_5: 0.0386 (0.0389) loss_giou_dn_5: 1.0332 (1.0546) loss_fgl_dn_5: 0.9732 (0.9653) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4233 (0.4204) loss_bbox_dn_pre: 0.0473 (0.0508) loss_giou_dn_pre: 1.1614 (1.1696) time: 0.8327 data: 0.0175 max mem: 29821\n", + "Epoch: [43] Total time: 0:01:12 (0.8616 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3870 (37.8411) loss_vfl: 0.1799 (0.1693) loss_bbox: 0.2417 (0.2692) loss_giou: 1.7585 (1.8011) loss_fgl: 0.4038 (0.4132) loss_vfl_aux_0: 0.1854 (0.1737) loss_bbox_aux_0: 0.2505 (0.2739) loss_giou_aux_0: 1.7968 (1.8148) loss_fgl_aux_0: 0.4057 (0.4132) loss_ddf_aux_0: 0.1202 (0.1411) loss_vfl_aux_1: 0.1868 (0.1759) loss_bbox_aux_1: 0.2419 (0.2703) loss_giou_aux_1: 1.7620 (1.8021) loss_fgl_aux_1: 0.4036 (0.4132) loss_ddf_aux_1: 0.0125 (0.0179) loss_vfl_aux_2: 0.1832 (0.1753) loss_bbox_aux_2: 0.2414 (0.2693) loss_giou_aux_2: 1.7599 (1.8013) loss_fgl_aux_2: 0.4037 (0.4132) loss_ddf_aux_2: 0.0018 (0.0028) loss_vfl_aux_3: 0.1823 (0.1715) loss_bbox_aux_3: 0.2415 (0.2690) loss_giou_aux_3: 1.7592 (1.8013) loss_fgl_aux_3: 0.4037 (0.4132) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1807 (0.1696) loss_bbox_aux_4: 0.2416 (0.2691) loss_giou_aux_4: 1.7586 (1.8011) loss_fgl_aux_4: 0.4038 (0.4132) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1846 (0.1713) loss_bbox_pre: 0.2507 (0.2775) loss_giou_pre: 1.7918 (1.8102) loss_vfl_enc_0: 0.1759 (0.1659) loss_bbox_enc_0: 0.2858 (0.3024) loss_giou_enc_0: 1.8478 (1.8570) loss_vfl_dn_0: 0.4250 (0.4219) loss_bbox_dn_0: 0.0470 (0.0505) loss_giou_dn_0: 1.1609 (1.1689) loss_fgl_dn_0: 0.9463 (0.9339) loss_ddf_dn_0: 0.2713 (0.2826) loss_vfl_dn_1: 0.4683 (0.4654) loss_bbox_dn_1: 0.0396 (0.0404) loss_giou_dn_1: 1.0420 (1.0643) loss_fgl_dn_1: 0.9698 (0.9633) loss_ddf_dn_1: 0.0277 (0.0273) loss_vfl_dn_2: 0.4683 (0.4619) loss_bbox_dn_2: 0.0387 (0.0392) loss_giou_dn_2: 1.0340 (1.0554) loss_fgl_dn_2: 0.9727 (0.9650) loss_ddf_dn_2: 0.0027 (0.0028) loss_vfl_dn_3: 0.4639 (0.4594) loss_bbox_dn_3: 0.0385 (0.0389) loss_giou_dn_3: 1.0331 (1.0547) loss_fgl_dn_3: 0.9730 (0.9652) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4619 (0.4590) loss_bbox_dn_4: 0.0385 (0.0389) loss_giou_dn_4: 1.0332 (1.0546) loss_fgl_dn_4: 0.9732 (0.9653) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4646 (0.4589) loss_bbox_dn_5: 0.0386 (0.0389) loss_giou_dn_5: 1.0332 (1.0546) loss_fgl_dn_5: 0.9732 (0.9653) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4233 (0.4204) loss_bbox_dn_pre: 0.0473 (0.0508) loss_giou_dn_pre: 1.1614 (1.1696)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7480 data: 0.4980 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5383 data: 0.1675 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5560 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.090\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.034\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.187\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.552\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.008\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.070\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.088\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.084\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.287\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.725\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.180\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.066\n", + "best_stat: {'epoch': 42, 'coco_eval_bbox': 0.0368201782041263}\n", + "Epoch: [44] [ 0/84] eta: 0:02:25 lr: 0.000013 loss: 36.8697 (36.8697) loss_vfl: 0.1870 (0.1870) loss_bbox: 0.2219 (0.2219) loss_giou: 1.6968 (1.6968) loss_fgl: 0.4324 (0.4324) loss_vfl_aux_0: 0.1941 (0.1941) loss_bbox_aux_0: 0.2321 (0.2321) loss_giou_aux_0: 1.6935 (1.6935) loss_fgl_aux_0: 0.4336 (0.4336) loss_ddf_aux_0: 0.2410 (0.2410) loss_vfl_aux_1: 0.1941 (0.1941) loss_bbox_aux_1: 0.2235 (0.2235) loss_giou_aux_1: 1.6972 (1.6972) loss_fgl_aux_1: 0.4325 (0.4325) loss_ddf_aux_1: 0.0251 (0.0251) loss_vfl_aux_2: 0.1888 (0.1888) loss_bbox_aux_2: 0.2223 (0.2223) loss_giou_aux_2: 1.6971 (1.6971) loss_fgl_aux_2: 0.4324 (0.4324) loss_ddf_aux_2: 0.0043 (0.0043) loss_vfl_aux_3: 0.1871 (0.1871) loss_bbox_aux_3: 0.2218 (0.2218) loss_giou_aux_3: 1.6969 (1.6969) loss_fgl_aux_3: 0.4325 (0.4325) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1854 (0.1854) loss_bbox_aux_4: 0.2218 (0.2218) loss_giou_aux_4: 1.6969 (1.6969) loss_fgl_aux_4: 0.4325 (0.4325) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1917 (0.1917) loss_bbox_pre: 0.2357 (0.2357) loss_giou_pre: 1.6915 (1.6915) loss_vfl_enc_0: 0.1946 (0.1946) loss_bbox_enc_0: 0.2447 (0.2447) loss_giou_enc_0: 1.7416 (1.7416) loss_vfl_dn_0: 0.4414 (0.4414) loss_bbox_dn_0: 0.0447 (0.0447) loss_giou_dn_0: 1.1110 (1.1110) loss_fgl_dn_0: 0.9627 (0.9627) loss_ddf_dn_0: 0.2703 (0.2703) loss_vfl_dn_1: 0.4680 (0.4680) loss_bbox_dn_1: 0.0367 (0.0367) loss_giou_dn_1: 1.0365 (1.0365) loss_fgl_dn_1: 0.9795 (0.9795) loss_ddf_dn_1: 0.0186 (0.0186) loss_vfl_dn_2: 0.4714 (0.4714) loss_bbox_dn_2: 0.0356 (0.0356) loss_giou_dn_2: 1.0252 (1.0252) loss_fgl_dn_2: 0.9831 (0.9831) loss_ddf_dn_2: 0.0021 (0.0021) loss_vfl_dn_3: 0.4751 (0.4751) loss_bbox_dn_3: 0.0355 (0.0355) loss_giou_dn_3: 1.0243 (1.0243) loss_fgl_dn_3: 0.9835 (0.9835) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4758 (0.4758) loss_bbox_dn_4: 0.0355 (0.0355) loss_giou_dn_4: 1.0245 (1.0245) loss_fgl_dn_4: 0.9835 (0.9835) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4773 (0.4773) loss_bbox_dn_5: 0.0355 (0.0355) loss_giou_dn_5: 1.0246 (1.0246) loss_fgl_dn_5: 0.9834 (0.9834) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4392 (0.4392) loss_bbox_dn_pre: 0.0453 (0.0453) loss_giou_dn_pre: 1.1141 (1.1141) time: 1.7265 data: 0.9038 max mem: 29821\n", + "Epoch: [44] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.1208 (37.9822) loss_vfl: 0.1475 (0.1729) loss_bbox: 0.2456 (0.2662) loss_giou: 1.8045 (1.8066) loss_fgl: 0.4012 (0.4222) loss_vfl_aux_0: 0.1533 (0.1805) loss_bbox_aux_0: 0.2406 (0.2713) loss_giou_aux_0: 1.8162 (1.8182) loss_fgl_aux_0: 0.4038 (0.4221) loss_ddf_aux_0: 0.1356 (0.1486) loss_vfl_aux_1: 0.1577 (0.1829) loss_bbox_aux_1: 0.2437 (0.2667) loss_giou_aux_1: 1.8056 (1.8086) loss_fgl_aux_1: 0.4011 (0.4224) loss_ddf_aux_1: 0.0147 (0.0192) loss_vfl_aux_2: 0.1538 (0.1804) loss_bbox_aux_2: 0.2451 (0.2662) loss_giou_aux_2: 1.8047 (1.8071) loss_fgl_aux_2: 0.4012 (0.4222) loss_ddf_aux_2: 0.0021 (0.0029) loss_vfl_aux_3: 0.1508 (0.1765) loss_bbox_aux_3: 0.2454 (0.2661) loss_giou_aux_3: 1.8049 (1.8068) loss_fgl_aux_3: 0.4013 (0.4222) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1483 (0.1734) loss_bbox_aux_4: 0.2455 (0.2661) loss_giou_aux_4: 1.8046 (1.8067) loss_fgl_aux_4: 0.4013 (0.4222) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1512 (0.1780) loss_bbox_pre: 0.2421 (0.2745) loss_giou_pre: 1.8117 (1.8143) loss_vfl_enc_0: 0.1447 (0.1730) loss_bbox_enc_0: 0.2743 (0.3000) loss_giou_enc_0: 1.8702 (1.8605) loss_vfl_dn_0: 0.4207 (0.4238) loss_bbox_dn_0: 0.0466 (0.0494) loss_giou_dn_0: 1.1756 (1.1641) loss_fgl_dn_0: 0.9355 (0.9377) loss_ddf_dn_0: 0.3109 (0.2997) loss_vfl_dn_1: 0.4626 (0.4657) loss_bbox_dn_1: 0.0358 (0.0402) loss_giou_dn_1: 1.0703 (1.0618) loss_fgl_dn_1: 0.9598 (0.9656) loss_ddf_dn_1: 0.0274 (0.0323) loss_vfl_dn_2: 0.4543 (0.4629) loss_bbox_dn_2: 0.0350 (0.0389) loss_giou_dn_2: 1.0644 (1.0514) loss_fgl_dn_2: 0.9618 (0.9679) loss_ddf_dn_2: 0.0023 (0.0032) loss_vfl_dn_3: 0.4548 (0.4602) loss_bbox_dn_3: 0.0349 (0.0388) loss_giou_dn_3: 1.0642 (1.0506) loss_fgl_dn_3: 0.9620 (0.9681) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4543 (0.4595) loss_bbox_dn_4: 0.0349 (0.0387) loss_giou_dn_4: 1.0643 (1.0506) loss_fgl_dn_4: 0.9620 (0.9681) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4536 (0.4598) loss_bbox_dn_5: 0.0349 (0.0387) loss_giou_dn_5: 1.0644 (1.0506) loss_fgl_dn_5: 0.9619 (0.9681) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4192 (0.4225) loss_bbox_dn_pre: 0.0468 (0.0497) loss_giou_dn_pre: 1.1782 (1.1648) time: 0.8467 data: 0.0173 max mem: 29821\n", + "Epoch: [44] Total time: 0:01:12 (0.8582 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.1208 (37.9822) loss_vfl: 0.1475 (0.1729) loss_bbox: 0.2456 (0.2662) loss_giou: 1.8045 (1.8066) loss_fgl: 0.4012 (0.4222) loss_vfl_aux_0: 0.1533 (0.1805) loss_bbox_aux_0: 0.2406 (0.2713) loss_giou_aux_0: 1.8162 (1.8182) loss_fgl_aux_0: 0.4038 (0.4221) loss_ddf_aux_0: 0.1356 (0.1486) loss_vfl_aux_1: 0.1577 (0.1829) loss_bbox_aux_1: 0.2437 (0.2667) loss_giou_aux_1: 1.8056 (1.8086) loss_fgl_aux_1: 0.4011 (0.4224) loss_ddf_aux_1: 0.0147 (0.0192) loss_vfl_aux_2: 0.1538 (0.1804) loss_bbox_aux_2: 0.2451 (0.2662) loss_giou_aux_2: 1.8047 (1.8071) loss_fgl_aux_2: 0.4012 (0.4222) loss_ddf_aux_2: 0.0021 (0.0029) loss_vfl_aux_3: 0.1508 (0.1765) loss_bbox_aux_3: 0.2454 (0.2661) loss_giou_aux_3: 1.8049 (1.8068) loss_fgl_aux_3: 0.4013 (0.4222) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1483 (0.1734) loss_bbox_aux_4: 0.2455 (0.2661) loss_giou_aux_4: 1.8046 (1.8067) loss_fgl_aux_4: 0.4013 (0.4222) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1512 (0.1780) loss_bbox_pre: 0.2421 (0.2745) loss_giou_pre: 1.8117 (1.8143) loss_vfl_enc_0: 0.1447 (0.1730) loss_bbox_enc_0: 0.2743 (0.3000) loss_giou_enc_0: 1.8702 (1.8605) loss_vfl_dn_0: 0.4207 (0.4238) loss_bbox_dn_0: 0.0466 (0.0494) loss_giou_dn_0: 1.1756 (1.1641) loss_fgl_dn_0: 0.9355 (0.9377) loss_ddf_dn_0: 0.3109 (0.2997) loss_vfl_dn_1: 0.4626 (0.4657) loss_bbox_dn_1: 0.0358 (0.0402) loss_giou_dn_1: 1.0703 (1.0618) loss_fgl_dn_1: 0.9598 (0.9656) loss_ddf_dn_1: 0.0274 (0.0323) loss_vfl_dn_2: 0.4543 (0.4629) loss_bbox_dn_2: 0.0350 (0.0389) loss_giou_dn_2: 1.0644 (1.0514) loss_fgl_dn_2: 0.9618 (0.9679) loss_ddf_dn_2: 0.0023 (0.0032) loss_vfl_dn_3: 0.4548 (0.4602) loss_bbox_dn_3: 0.0349 (0.0388) loss_giou_dn_3: 1.0642 (1.0506) loss_fgl_dn_3: 0.9620 (0.9681) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4543 (0.4595) loss_bbox_dn_4: 0.0349 (0.0387) loss_giou_dn_4: 1.0643 (1.0506) loss_fgl_dn_4: 0.9620 (0.9681) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4536 (0.4598) loss_bbox_dn_5: 0.0349 (0.0387) loss_giou_dn_5: 1.0644 (1.0506) loss_fgl_dn_5: 0.9619 (0.9681) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4192 (0.4225) loss_bbox_dn_pre: 0.0468 (0.0497) loss_giou_dn_pre: 1.1782 (1.1648)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7309 data: 0.4828 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3937 data: 0.1630 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4085 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.039\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.089\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.225\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.444\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.020\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.069\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.088\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.081\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.345\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.183\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.053\n", + "best_stat: {'epoch': 44, 'coco_eval_bbox': 0.03912518198242201}\n", + "Epoch: [45] [ 0/84] eta: 0:02:50 lr: 0.000013 loss: 38.7655 (38.7655) loss_vfl: 0.0826 (0.0826) loss_bbox: 0.3570 (0.3570) loss_giou: 2.0804 (2.0804) loss_fgl: 0.2090 (0.2090) loss_vfl_aux_0: 0.0854 (0.0854) loss_bbox_aux_0: 0.3600 (0.3600) loss_giou_aux_0: 2.0937 (2.0937) loss_fgl_aux_0: 0.2055 (0.2055) loss_ddf_aux_0: 0.1325 (0.1325) loss_vfl_aux_1: 0.0866 (0.0866) loss_bbox_aux_1: 0.3578 (0.3578) loss_giou_aux_1: 2.0817 (2.0817) loss_fgl_aux_1: 0.2089 (0.2089) loss_ddf_aux_1: 0.0111 (0.0111) loss_vfl_aux_2: 0.0853 (0.0853) loss_bbox_aux_2: 0.3572 (0.3572) loss_giou_aux_2: 2.0806 (2.0806) loss_fgl_aux_2: 0.2091 (0.2091) loss_ddf_aux_2: 0.0017 (0.0017) loss_vfl_aux_3: 0.0836 (0.0836) loss_bbox_aux_3: 0.3570 (0.3570) loss_giou_aux_3: 2.0804 (2.0804) loss_fgl_aux_3: 0.2090 (0.2090) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.0833 (0.0833) loss_bbox_aux_4: 0.3570 (0.3570) loss_giou_aux_4: 2.0804 (2.0804) loss_fgl_aux_4: 0.2090 (0.2090) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.0839 (0.0839) loss_bbox_pre: 0.3639 (0.3639) loss_giou_pre: 2.0920 (2.0920) loss_vfl_enc_0: 0.0823 (0.0823) loss_bbox_enc_0: 0.3790 (0.3790) loss_giou_enc_0: 2.1293 (2.1293) loss_vfl_dn_0: 0.3948 (0.3948) loss_bbox_dn_0: 0.0360 (0.0360) loss_giou_dn_0: 1.2340 (1.2340) loss_fgl_dn_0: 0.8984 (0.8984) loss_ddf_dn_0: 0.2574 (0.2574) loss_vfl_dn_1: 0.4490 (0.4490) loss_bbox_dn_1: 0.0280 (0.0280) loss_giou_dn_1: 1.1131 (1.1131) loss_fgl_dn_1: 0.9365 (0.9365) loss_ddf_dn_1: 0.0197 (0.0197) loss_vfl_dn_2: 0.4397 (0.4397) loss_bbox_dn_2: 0.0277 (0.0277) loss_giou_dn_2: 1.1103 (1.1103) loss_fgl_dn_2: 0.9383 (0.9383) loss_ddf_dn_2: 0.0016 (0.0016) loss_vfl_dn_3: 0.4368 (0.4368) loss_bbox_dn_3: 0.0276 (0.0276) loss_giou_dn_3: 1.1103 (1.1103) loss_fgl_dn_3: 0.9384 (0.9384) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4368 (0.4368) loss_bbox_dn_4: 0.0275 (0.0275) loss_giou_dn_4: 1.1100 (1.1100) loss_fgl_dn_4: 0.9385 (0.9385) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4390 (0.4390) loss_bbox_dn_5: 0.0275 (0.0275) loss_giou_dn_5: 1.1100 (1.1100) loss_fgl_dn_5: 0.9385 (0.9385) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.3940 (0.3940) loss_bbox_dn_pre: 0.0361 (0.0361) loss_giou_dn_pre: 1.2327 (1.2327) time: 2.0279 data: 0.8741 max mem: 29821\n", + "Epoch: [45] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7185 (38.0907) loss_vfl: 0.1670 (0.1612) loss_bbox: 0.2583 (0.2771) loss_giou: 1.7860 (1.8354) loss_fgl: 0.4327 (0.4061) loss_vfl_aux_0: 0.1676 (0.1672) loss_bbox_aux_0: 0.2570 (0.2821) loss_giou_aux_0: 1.7965 (1.8484) loss_fgl_aux_0: 0.4332 (0.4063) loss_ddf_aux_0: 0.0995 (0.1531) loss_vfl_aux_1: 0.1735 (0.1691) loss_bbox_aux_1: 0.2592 (0.2784) loss_giou_aux_1: 1.7857 (1.8361) loss_fgl_aux_1: 0.4326 (0.4061) loss_ddf_aux_1: 0.0110 (0.0177) loss_vfl_aux_2: 0.1688 (0.1669) loss_bbox_aux_2: 0.2581 (0.2773) loss_giou_aux_2: 1.7862 (1.8356) loss_fgl_aux_2: 0.4326 (0.4061) loss_ddf_aux_2: 0.0023 (0.0028) loss_vfl_aux_3: 0.1675 (0.1637) loss_bbox_aux_3: 0.2582 (0.2771) loss_giou_aux_3: 1.7861 (1.8354) loss_fgl_aux_3: 0.4325 (0.4061) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1665 (0.1618) loss_bbox_aux_4: 0.2583 (0.2771) loss_giou_aux_4: 1.7860 (1.8354) loss_fgl_aux_4: 0.4327 (0.4061) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1665 (0.1646) loss_bbox_pre: 0.2613 (0.2858) loss_giou_pre: 1.7900 (1.8436) loss_vfl_enc_0: 0.1632 (0.1583) loss_bbox_enc_0: 0.2860 (0.3113) loss_giou_enc_0: 1.8519 (1.8868) loss_vfl_dn_0: 0.4285 (0.4185) loss_bbox_dn_0: 0.0458 (0.0477) loss_giou_dn_0: 1.1506 (1.1759) loss_fgl_dn_0: 0.9476 (0.9320) loss_ddf_dn_0: 0.2602 (0.2938) loss_vfl_dn_1: 0.4697 (0.4640) loss_bbox_dn_1: 0.0382 (0.0384) loss_giou_dn_1: 1.0441 (1.0685) loss_fgl_dn_1: 0.9769 (0.9610) loss_ddf_dn_1: 0.0234 (0.0267) loss_vfl_dn_2: 0.4648 (0.4606) loss_bbox_dn_2: 0.0371 (0.0374) loss_giou_dn_2: 1.0401 (1.0611) loss_fgl_dn_2: 0.9796 (0.9628) loss_ddf_dn_2: 0.0029 (0.0032) loss_vfl_dn_3: 0.4622 (0.4569) loss_bbox_dn_3: 0.0370 (0.0372) loss_giou_dn_3: 1.0392 (1.0605) loss_fgl_dn_3: 0.9798 (0.9630) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4604 (0.4558) loss_bbox_dn_4: 0.0369 (0.0372) loss_giou_dn_4: 1.0393 (1.0604) loss_fgl_dn_4: 0.9798 (0.9630) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4624 (0.4561) loss_bbox_dn_5: 0.0369 (0.0371) loss_giou_dn_5: 1.0392 (1.0604) loss_fgl_dn_5: 0.9798 (0.9630) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4263 (0.4175) loss_bbox_dn_pre: 0.0458 (0.0479) loss_giou_dn_pre: 1.1494 (1.1759) time: 0.8750 data: 0.0174 max mem: 29821\n", + "Epoch: [45] Total time: 0:01:13 (0.8733 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7185 (38.0907) loss_vfl: 0.1670 (0.1612) loss_bbox: 0.2583 (0.2771) loss_giou: 1.7860 (1.8354) loss_fgl: 0.4327 (0.4061) loss_vfl_aux_0: 0.1676 (0.1672) loss_bbox_aux_0: 0.2570 (0.2821) loss_giou_aux_0: 1.7965 (1.8484) loss_fgl_aux_0: 0.4332 (0.4063) loss_ddf_aux_0: 0.0995 (0.1531) loss_vfl_aux_1: 0.1735 (0.1691) loss_bbox_aux_1: 0.2592 (0.2784) loss_giou_aux_1: 1.7857 (1.8361) loss_fgl_aux_1: 0.4326 (0.4061) loss_ddf_aux_1: 0.0110 (0.0177) loss_vfl_aux_2: 0.1688 (0.1669) loss_bbox_aux_2: 0.2581 (0.2773) loss_giou_aux_2: 1.7862 (1.8356) loss_fgl_aux_2: 0.4326 (0.4061) loss_ddf_aux_2: 0.0023 (0.0028) loss_vfl_aux_3: 0.1675 (0.1637) loss_bbox_aux_3: 0.2582 (0.2771) loss_giou_aux_3: 1.7861 (1.8354) loss_fgl_aux_3: 0.4325 (0.4061) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1665 (0.1618) loss_bbox_aux_4: 0.2583 (0.2771) loss_giou_aux_4: 1.7860 (1.8354) loss_fgl_aux_4: 0.4327 (0.4061) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1665 (0.1646) loss_bbox_pre: 0.2613 (0.2858) loss_giou_pre: 1.7900 (1.8436) loss_vfl_enc_0: 0.1632 (0.1583) loss_bbox_enc_0: 0.2860 (0.3113) loss_giou_enc_0: 1.8519 (1.8868) loss_vfl_dn_0: 0.4285 (0.4185) loss_bbox_dn_0: 0.0458 (0.0477) loss_giou_dn_0: 1.1506 (1.1759) loss_fgl_dn_0: 0.9476 (0.9320) loss_ddf_dn_0: 0.2602 (0.2938) loss_vfl_dn_1: 0.4697 (0.4640) loss_bbox_dn_1: 0.0382 (0.0384) loss_giou_dn_1: 1.0441 (1.0685) loss_fgl_dn_1: 0.9769 (0.9610) loss_ddf_dn_1: 0.0234 (0.0267) loss_vfl_dn_2: 0.4648 (0.4606) loss_bbox_dn_2: 0.0371 (0.0374) loss_giou_dn_2: 1.0401 (1.0611) loss_fgl_dn_2: 0.9796 (0.9628) loss_ddf_dn_2: 0.0029 (0.0032) loss_vfl_dn_3: 0.4622 (0.4569) loss_bbox_dn_3: 0.0370 (0.0372) loss_giou_dn_3: 1.0392 (1.0605) loss_fgl_dn_3: 0.9798 (0.9630) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4604 (0.4558) loss_bbox_dn_4: 0.0369 (0.0372) loss_giou_dn_4: 1.0393 (1.0604) loss_fgl_dn_4: 0.9798 (0.9630) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4624 (0.4561) loss_bbox_dn_5: 0.0369 (0.0371) loss_giou_dn_5: 1.0392 (1.0604) loss_fgl_dn_5: 0.9798 (0.9630) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4263 (0.4175) loss_bbox_dn_pre: 0.0458 (0.0479) loss_giou_dn_pre: 1.1494 (1.1759)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7705 data: 0.5259 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4005 data: 0.1689 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4171 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.039\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.091\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.020\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.193\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.422\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.294\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.650\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.185\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.050\n", + "best_stat: {'epoch': 44, 'coco_eval_bbox': 0.03912518198242201}\n", + "Epoch: [46] [ 0/84] eta: 0:02:46 lr: 0.000013 loss: 37.3497 (37.3497) loss_vfl: 0.1376 (0.1376) loss_bbox: 0.2533 (0.2533) loss_giou: 1.7892 (1.7892) loss_fgl: 0.4011 (0.4011) loss_vfl_aux_0: 0.1471 (0.1471) loss_bbox_aux_0: 0.2574 (0.2574) loss_giou_aux_0: 1.8031 (1.8031) loss_fgl_aux_0: 0.4037 (0.4037) loss_ddf_aux_0: 0.1638 (0.1638) loss_vfl_aux_1: 0.1504 (0.1504) loss_bbox_aux_1: 0.2555 (0.2555) loss_giou_aux_1: 1.7891 (1.7891) loss_fgl_aux_1: 0.4006 (0.4006) loss_ddf_aux_1: 0.0221 (0.0221) loss_vfl_aux_2: 0.1449 (0.1449) loss_bbox_aux_2: 0.2535 (0.2535) loss_giou_aux_2: 1.7894 (1.7894) loss_fgl_aux_2: 0.4010 (0.4010) loss_ddf_aux_2: 0.0028 (0.0028) loss_vfl_aux_3: 0.1414 (0.1414) loss_bbox_aux_3: 0.2534 (0.2534) loss_giou_aux_3: 1.7893 (1.7893) loss_fgl_aux_3: 0.4011 (0.4011) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1381 (0.1381) loss_bbox_aux_4: 0.2533 (0.2533) loss_giou_aux_4: 1.7892 (1.7892) loss_fgl_aux_4: 0.4011 (0.4011) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1449 (0.1449) loss_bbox_pre: 0.2596 (0.2596) loss_giou_pre: 1.7996 (1.7996) loss_vfl_enc_0: 0.1444 (0.1444) loss_bbox_enc_0: 0.2742 (0.2742) loss_giou_enc_0: 1.8386 (1.8386) loss_vfl_dn_0: 0.4302 (0.4302) loss_bbox_dn_0: 0.0497 (0.0497) loss_giou_dn_0: 1.1436 (1.1436) loss_fgl_dn_0: 0.9473 (0.9473) loss_ddf_dn_0: 0.2815 (0.2815) loss_vfl_dn_1: 0.4695 (0.4695) loss_bbox_dn_1: 0.0420 (0.0420) loss_giou_dn_1: 1.0698 (1.0698) loss_fgl_dn_1: 0.9640 (0.9640) loss_ddf_dn_1: 0.0245 (0.0245) loss_vfl_dn_2: 0.4561 (0.4561) loss_bbox_dn_2: 0.0416 (0.0416) loss_giou_dn_2: 1.0640 (1.0640) loss_fgl_dn_2: 0.9653 (0.9653) loss_ddf_dn_2: 0.0031 (0.0031) loss_vfl_dn_3: 0.4531 (0.4531) loss_bbox_dn_3: 0.0416 (0.0416) loss_giou_dn_3: 1.0638 (1.0638) loss_fgl_dn_3: 0.9655 (0.9655) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4541 (0.4541) loss_bbox_dn_4: 0.0416 (0.0416) loss_giou_dn_4: 1.0637 (1.0637) loss_fgl_dn_4: 0.9656 (0.9656) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4578 (0.4578) loss_bbox_dn_5: 0.0416 (0.0416) loss_giou_dn_5: 1.0637 (1.0637) loss_fgl_dn_5: 0.9656 (0.9656) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4285 (0.4285) loss_bbox_dn_pre: 0.0502 (0.0502) loss_giou_dn_pre: 1.1462 (1.1462) time: 1.9833 data: 1.0228 max mem: 29821\n", + "Epoch: [46] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7085 (38.2200) loss_vfl: 0.1387 (0.1660) loss_bbox: 0.2592 (0.2914) loss_giou: 1.8177 (1.8268) loss_fgl: 0.3888 (0.4211) loss_vfl_aux_0: 0.1429 (0.1716) loss_bbox_aux_0: 0.2601 (0.2954) loss_giou_aux_0: 1.8355 (1.8395) loss_fgl_aux_0: 0.3842 (0.4207) loss_ddf_aux_0: 0.1283 (0.1453) loss_vfl_aux_1: 0.1475 (0.1738) loss_bbox_aux_1: 0.2585 (0.2926) loss_giou_aux_1: 1.8201 (1.8276) loss_fgl_aux_1: 0.3878 (0.4210) loss_ddf_aux_1: 0.0153 (0.0189) loss_vfl_aux_2: 0.1461 (0.1721) loss_bbox_aux_2: 0.2593 (0.2916) loss_giou_aux_2: 1.8179 (1.8270) loss_fgl_aux_2: 0.3887 (0.4211) loss_ddf_aux_2: 0.0018 (0.0027) loss_vfl_aux_3: 0.1427 (0.1684) loss_bbox_aux_3: 0.2591 (0.2914) loss_giou_aux_3: 1.8177 (1.8269) loss_fgl_aux_3: 0.3889 (0.4211) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1361 (0.1664) loss_bbox_aux_4: 0.2591 (0.2914) loss_giou_aux_4: 1.8177 (1.8268) loss_fgl_aux_4: 0.3888 (0.4211) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1400 (0.1690) loss_bbox_pre: 0.2648 (0.2993) loss_giou_pre: 1.8304 (1.8344) loss_vfl_enc_0: 0.1284 (0.1645) loss_bbox_enc_0: 0.2916 (0.3270) loss_giou_enc_0: 1.8843 (1.8819) loss_vfl_dn_0: 0.4226 (0.4271) loss_bbox_dn_0: 0.0438 (0.0469) loss_giou_dn_0: 1.1627 (1.1516) loss_fgl_dn_0: 0.9354 (0.9437) loss_ddf_dn_0: 0.2429 (0.2715) loss_vfl_dn_1: 0.4644 (0.4654) loss_bbox_dn_1: 0.0350 (0.0382) loss_giou_dn_1: 1.0667 (1.0587) loss_fgl_dn_1: 0.9605 (0.9704) loss_ddf_dn_1: 0.0226 (0.0245) loss_vfl_dn_2: 0.4568 (0.4622) loss_bbox_dn_2: 0.0339 (0.0373) loss_giou_dn_2: 1.0613 (1.0508) loss_fgl_dn_2: 0.9597 (0.9718) loss_ddf_dn_2: 0.0018 (0.0025) loss_vfl_dn_3: 0.4543 (0.4595) loss_bbox_dn_3: 0.0339 (0.0372) loss_giou_dn_3: 1.0611 (1.0502) loss_fgl_dn_3: 0.9602 (0.9720) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4529 (0.4587) loss_bbox_dn_4: 0.0338 (0.0372) loss_giou_dn_4: 1.0613 (1.0502) loss_fgl_dn_4: 0.9602 (0.9720) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4539 (0.4591) loss_bbox_dn_5: 0.0338 (0.0372) loss_giou_dn_5: 1.0613 (1.0502) loss_fgl_dn_5: 0.9602 (0.9721) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4216 (0.4257) loss_bbox_dn_pre: 0.0442 (0.0473) loss_giou_dn_pre: 1.1636 (1.1519) time: 0.8586 data: 0.0170 max mem: 29821\n", + "Epoch: [46] Total time: 0:01:13 (0.8792 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7085 (38.2200) loss_vfl: 0.1387 (0.1660) loss_bbox: 0.2592 (0.2914) loss_giou: 1.8177 (1.8268) loss_fgl: 0.3888 (0.4211) loss_vfl_aux_0: 0.1429 (0.1716) loss_bbox_aux_0: 0.2601 (0.2954) loss_giou_aux_0: 1.8355 (1.8395) loss_fgl_aux_0: 0.3842 (0.4207) loss_ddf_aux_0: 0.1283 (0.1453) loss_vfl_aux_1: 0.1475 (0.1738) loss_bbox_aux_1: 0.2585 (0.2926) loss_giou_aux_1: 1.8201 (1.8276) loss_fgl_aux_1: 0.3878 (0.4210) loss_ddf_aux_1: 0.0153 (0.0189) loss_vfl_aux_2: 0.1461 (0.1721) loss_bbox_aux_2: 0.2593 (0.2916) loss_giou_aux_2: 1.8179 (1.8270) loss_fgl_aux_2: 0.3887 (0.4211) loss_ddf_aux_2: 0.0018 (0.0027) loss_vfl_aux_3: 0.1427 (0.1684) loss_bbox_aux_3: 0.2591 (0.2914) loss_giou_aux_3: 1.8177 (1.8269) loss_fgl_aux_3: 0.3889 (0.4211) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1361 (0.1664) loss_bbox_aux_4: 0.2591 (0.2914) loss_giou_aux_4: 1.8177 (1.8268) loss_fgl_aux_4: 0.3888 (0.4211) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1400 (0.1690) loss_bbox_pre: 0.2648 (0.2993) loss_giou_pre: 1.8304 (1.8344) loss_vfl_enc_0: 0.1284 (0.1645) loss_bbox_enc_0: 0.2916 (0.3270) loss_giou_enc_0: 1.8843 (1.8819) loss_vfl_dn_0: 0.4226 (0.4271) loss_bbox_dn_0: 0.0438 (0.0469) loss_giou_dn_0: 1.1627 (1.1516) loss_fgl_dn_0: 0.9354 (0.9437) loss_ddf_dn_0: 0.2429 (0.2715) loss_vfl_dn_1: 0.4644 (0.4654) loss_bbox_dn_1: 0.0350 (0.0382) loss_giou_dn_1: 1.0667 (1.0587) loss_fgl_dn_1: 0.9605 (0.9704) loss_ddf_dn_1: 0.0226 (0.0245) loss_vfl_dn_2: 0.4568 (0.4622) loss_bbox_dn_2: 0.0339 (0.0373) loss_giou_dn_2: 1.0613 (1.0508) loss_fgl_dn_2: 0.9597 (0.9718) loss_ddf_dn_2: 0.0018 (0.0025) loss_vfl_dn_3: 0.4543 (0.4595) loss_bbox_dn_3: 0.0339 (0.0372) loss_giou_dn_3: 1.0611 (1.0502) loss_fgl_dn_3: 0.9602 (0.9720) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4529 (0.4587) loss_bbox_dn_4: 0.0338 (0.0372) loss_giou_dn_4: 1.0613 (1.0502) loss_fgl_dn_4: 0.9602 (0.9720) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4539 (0.4591) loss_bbox_dn_5: 0.0338 (0.0372) loss_giou_dn_5: 1.0613 (1.0502) loss_fgl_dn_5: 0.9602 (0.9721) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4216 (0.4257) loss_bbox_dn_pre: 0.0442 (0.0473) loss_giou_dn_pre: 1.1636 (1.1519)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7757 data: 0.5297 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4001 data: 0.1711 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4168 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.090\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.034\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.190\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.356\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.020\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.070\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.293\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.775\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.045\n", + "best_stat: {'epoch': 44, 'coco_eval_bbox': 0.03912518198242201}\n", + "Epoch: [47] [ 0/84] eta: 0:02:59 lr: 0.000013 loss: 37.2600 (37.2600) loss_vfl: 0.1302 (0.1302) loss_bbox: 0.2593 (0.2593) loss_giou: 1.7774 (1.7774) loss_fgl: 0.4312 (0.4312) loss_vfl_aux_0: 0.1361 (0.1361) loss_bbox_aux_0: 0.2626 (0.2626) loss_giou_aux_0: 1.7920 (1.7920) loss_fgl_aux_0: 0.4318 (0.4318) loss_ddf_aux_0: 0.1523 (0.1523) loss_vfl_aux_1: 0.1366 (0.1366) loss_bbox_aux_1: 0.2596 (0.2596) loss_giou_aux_1: 1.7788 (1.7788) loss_fgl_aux_1: 0.4306 (0.4306) loss_ddf_aux_1: 0.0202 (0.0202) loss_vfl_aux_2: 0.1350 (0.1350) loss_bbox_aux_2: 0.2598 (0.2598) loss_giou_aux_2: 1.7781 (1.7781) loss_fgl_aux_2: 0.4309 (0.4309) loss_ddf_aux_2: 0.0031 (0.0031) loss_vfl_aux_3: 0.1322 (0.1322) loss_bbox_aux_3: 0.2594 (0.2594) loss_giou_aux_3: 1.7777 (1.7777) loss_fgl_aux_3: 0.4311 (0.4311) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1301 (0.1301) loss_bbox_aux_4: 0.2593 (0.2593) loss_giou_aux_4: 1.7775 (1.7775) loss_fgl_aux_4: 0.4311 (0.4311) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1353 (0.1353) loss_bbox_pre: 0.2662 (0.2662) loss_giou_pre: 1.7853 (1.7853) loss_vfl_enc_0: 0.1334 (0.1334) loss_bbox_enc_0: 0.2957 (0.2957) loss_giou_enc_0: 1.8094 (1.8094) loss_vfl_dn_0: 0.4216 (0.4216) loss_bbox_dn_0: 0.0431 (0.0431) loss_giou_dn_0: 1.1549 (1.1549) loss_fgl_dn_0: 0.9460 (0.9460) loss_ddf_dn_0: 0.2194 (0.2194) loss_vfl_dn_1: 0.4653 (0.4653) loss_bbox_dn_1: 0.0355 (0.0355) loss_giou_dn_1: 1.0587 (1.0587) loss_fgl_dn_1: 0.9740 (0.9740) loss_ddf_dn_1: 0.0220 (0.0220) loss_vfl_dn_2: 0.4561 (0.4561) loss_bbox_dn_2: 0.0347 (0.0347) loss_giou_dn_2: 1.0511 (1.0511) loss_fgl_dn_2: 0.9734 (0.9734) loss_ddf_dn_2: 0.0022 (0.0022) loss_vfl_dn_3: 0.4583 (0.4583) loss_bbox_dn_3: 0.0345 (0.0345) loss_giou_dn_3: 1.0506 (1.0506) loss_fgl_dn_3: 0.9732 (0.9732) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4604 (0.4604) loss_bbox_dn_4: 0.0344 (0.0344) loss_giou_dn_4: 1.0506 (1.0506) loss_fgl_dn_4: 0.9731 (0.9731) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4602) loss_bbox_dn_5: 0.0344 (0.0344) loss_giou_dn_5: 1.0506 (1.0506) loss_fgl_dn_5: 0.9731 (0.9731) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4204 (0.4204) loss_bbox_dn_pre: 0.0434 (0.0434) loss_giou_dn_pre: 1.1544 (1.1544) time: 2.1396 data: 1.0924 max mem: 29821\n", + "Epoch: [47] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.8120 (38.2344) loss_vfl: 0.1324 (0.1640) loss_bbox: 0.2630 (0.2929) loss_giou: 1.8773 (1.8279) loss_fgl: 0.3520 (0.4097) loss_vfl_aux_0: 0.1389 (0.1700) loss_bbox_aux_0: 0.2611 (0.2963) loss_giou_aux_0: 1.8893 (1.8434) loss_fgl_aux_0: 0.3552 (0.4096) loss_ddf_aux_0: 0.1475 (0.1607) loss_vfl_aux_1: 0.1409 (0.1719) loss_bbox_aux_1: 0.2626 (0.2938) loss_giou_aux_1: 1.8769 (1.8292) loss_fgl_aux_1: 0.3521 (0.4098) loss_ddf_aux_1: 0.0118 (0.0214) loss_vfl_aux_2: 0.1398 (0.1704) loss_bbox_aux_2: 0.2627 (0.2930) loss_giou_aux_2: 1.8776 (1.8281) loss_fgl_aux_2: 0.3517 (0.4097) loss_ddf_aux_2: 0.0017 (0.0032) loss_vfl_aux_3: 0.1355 (0.1667) loss_bbox_aux_3: 0.2629 (0.2928) loss_giou_aux_3: 1.8774 (1.8280) loss_fgl_aux_3: 0.3520 (0.4098) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1327 (0.1642) loss_bbox_aux_4: 0.2629 (0.2928) loss_giou_aux_4: 1.8773 (1.8280) loss_fgl_aux_4: 0.3520 (0.4098) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1377 (0.1676) loss_bbox_pre: 0.2638 (0.3006) loss_giou_pre: 1.8788 (1.8383) loss_vfl_enc_0: 0.1259 (0.1606) loss_bbox_enc_0: 0.2916 (0.3288) loss_giou_enc_0: 1.9233 (1.8900) loss_vfl_dn_0: 0.4175 (0.4256) loss_bbox_dn_0: 0.0433 (0.0479) loss_giou_dn_0: 1.1816 (1.1642) loss_fgl_dn_0: 0.9272 (0.9412) loss_ddf_dn_0: 0.3006 (0.2906) loss_vfl_dn_1: 0.4607 (0.4650) loss_bbox_dn_1: 0.0380 (0.0393) loss_giou_dn_1: 1.0763 (1.0628) loss_fgl_dn_1: 0.9541 (0.9668) loss_ddf_dn_1: 0.0228 (0.0288) loss_vfl_dn_2: 0.4609 (0.4632) loss_bbox_dn_2: 0.0363 (0.0382) loss_giou_dn_2: 1.0725 (1.0524) loss_fgl_dn_2: 0.9551 (0.9693) loss_ddf_dn_2: 0.0015 (0.0027) loss_vfl_dn_3: 0.4553 (0.4595) loss_bbox_dn_3: 0.0363 (0.0380) loss_giou_dn_3: 1.0721 (1.0518) loss_fgl_dn_3: 0.9551 (0.9695) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4534 (0.4585) loss_bbox_dn_4: 0.0363 (0.0380) loss_giou_dn_4: 1.0720 (1.0517) loss_fgl_dn_4: 0.9551 (0.9695) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4548 (0.4590) loss_bbox_dn_5: 0.0363 (0.0380) loss_giou_dn_5: 1.0720 (1.0517) loss_fgl_dn_5: 0.9551 (0.9696) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4163 (0.4241) loss_bbox_dn_pre: 0.0436 (0.0484) loss_giou_dn_pre: 1.1816 (1.1649) time: 0.8708 data: 0.0173 max mem: 29821\n", + "Epoch: [47] Total time: 0:01:13 (0.8787 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.8120 (38.2344) loss_vfl: 0.1324 (0.1640) loss_bbox: 0.2630 (0.2929) loss_giou: 1.8773 (1.8279) loss_fgl: 0.3520 (0.4097) loss_vfl_aux_0: 0.1389 (0.1700) loss_bbox_aux_0: 0.2611 (0.2963) loss_giou_aux_0: 1.8893 (1.8434) loss_fgl_aux_0: 0.3552 (0.4096) loss_ddf_aux_0: 0.1475 (0.1607) loss_vfl_aux_1: 0.1409 (0.1719) loss_bbox_aux_1: 0.2626 (0.2938) loss_giou_aux_1: 1.8769 (1.8292) loss_fgl_aux_1: 0.3521 (0.4098) loss_ddf_aux_1: 0.0118 (0.0214) loss_vfl_aux_2: 0.1398 (0.1704) loss_bbox_aux_2: 0.2627 (0.2930) loss_giou_aux_2: 1.8776 (1.8281) loss_fgl_aux_2: 0.3517 (0.4097) loss_ddf_aux_2: 0.0017 (0.0032) loss_vfl_aux_3: 0.1355 (0.1667) loss_bbox_aux_3: 0.2629 (0.2928) loss_giou_aux_3: 1.8774 (1.8280) loss_fgl_aux_3: 0.3520 (0.4098) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1327 (0.1642) loss_bbox_aux_4: 0.2629 (0.2928) loss_giou_aux_4: 1.8773 (1.8280) loss_fgl_aux_4: 0.3520 (0.4098) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1377 (0.1676) loss_bbox_pre: 0.2638 (0.3006) loss_giou_pre: 1.8788 (1.8383) loss_vfl_enc_0: 0.1259 (0.1606) loss_bbox_enc_0: 0.2916 (0.3288) loss_giou_enc_0: 1.9233 (1.8900) loss_vfl_dn_0: 0.4175 (0.4256) loss_bbox_dn_0: 0.0433 (0.0479) loss_giou_dn_0: 1.1816 (1.1642) loss_fgl_dn_0: 0.9272 (0.9412) loss_ddf_dn_0: 0.3006 (0.2906) loss_vfl_dn_1: 0.4607 (0.4650) loss_bbox_dn_1: 0.0380 (0.0393) loss_giou_dn_1: 1.0763 (1.0628) loss_fgl_dn_1: 0.9541 (0.9668) loss_ddf_dn_1: 0.0228 (0.0288) loss_vfl_dn_2: 0.4609 (0.4632) loss_bbox_dn_2: 0.0363 (0.0382) loss_giou_dn_2: 1.0725 (1.0524) loss_fgl_dn_2: 0.9551 (0.9693) loss_ddf_dn_2: 0.0015 (0.0027) loss_vfl_dn_3: 0.4553 (0.4595) loss_bbox_dn_3: 0.0363 (0.0380) loss_giou_dn_3: 1.0721 (1.0518) loss_fgl_dn_3: 0.9551 (0.9695) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4534 (0.4585) loss_bbox_dn_4: 0.0363 (0.0380) loss_giou_dn_4: 1.0720 (1.0517) loss_fgl_dn_4: 0.9551 (0.9695) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4548 (0.4590) loss_bbox_dn_5: 0.0363 (0.0380) loss_giou_dn_5: 1.0720 (1.0517) loss_fgl_dn_5: 0.9551 (0.9696) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4163 (0.4241) loss_bbox_dn_pre: 0.0436 (0.0484) loss_giou_dn_pre: 1.1816 (1.1649)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7576 data: 0.5122 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4041 data: 0.1705 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4186 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.094\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.019\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.036\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.198\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.291\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.070\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.290\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.600\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.187\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.047\n", + "best_stat: {'epoch': 47, 'coco_eval_bbox': 0.039503500975091616}\n", + "Epoch: [48] [ 0/84] eta: 0:02:39 lr: 0.000013 loss: 36.4474 (36.4474) loss_vfl: 0.2257 (0.2257) loss_bbox: 0.1789 (0.1789) loss_giou: 1.6039 (1.6039) loss_fgl: 0.4856 (0.4856) loss_vfl_aux_0: 0.2389 (0.2389) loss_bbox_aux_0: 0.1832 (0.1832) loss_giou_aux_0: 1.6065 (1.6065) loss_fgl_aux_0: 0.4880 (0.4880) loss_ddf_aux_0: 0.1253 (0.1253) loss_vfl_aux_1: 0.2428 (0.2428) loss_bbox_aux_1: 0.1783 (0.1783) loss_giou_aux_1: 1.6047 (1.6047) loss_fgl_aux_1: 0.4861 (0.4861) loss_ddf_aux_1: 0.0114 (0.0114) loss_vfl_aux_2: 0.2445 (0.2445) loss_bbox_aux_2: 0.1788 (0.1788) loss_giou_aux_2: 1.6043 (1.6043) loss_fgl_aux_2: 0.4856 (0.4856) loss_ddf_aux_2: 0.0023 (0.0023) loss_vfl_aux_3: 0.2307 (0.2307) loss_bbox_aux_3: 0.1788 (0.1788) loss_giou_aux_3: 1.6042 (1.6042) loss_fgl_aux_3: 0.4856 (0.4856) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.2291 (0.2291) loss_bbox_aux_4: 0.1788 (0.1788) loss_giou_aux_4: 1.6040 (1.6040) loss_fgl_aux_4: 0.4857 (0.4857) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2375 (0.2375) loss_bbox_pre: 0.1862 (0.1862) loss_giou_pre: 1.6021 (1.6021) loss_vfl_enc_0: 0.2368 (0.2368) loss_bbox_enc_0: 0.1993 (0.1993) loss_giou_enc_0: 1.6196 (1.6196) loss_vfl_dn_0: 0.4319 (0.4319) loss_bbox_dn_0: 0.0514 (0.0514) loss_giou_dn_0: 1.1349 (1.1349) loss_fgl_dn_0: 0.9571 (0.9571) loss_ddf_dn_0: 0.3212 (0.3212) loss_vfl_dn_1: 0.4617 (0.4617) loss_bbox_dn_1: 0.0424 (0.0424) loss_giou_dn_1: 1.0567 (1.0567) loss_fgl_dn_1: 0.9760 (0.9760) loss_ddf_dn_1: 0.0245 (0.0245) loss_vfl_dn_2: 0.4656 (0.4656) loss_bbox_dn_2: 0.0406 (0.0406) loss_giou_dn_2: 1.0495 (1.0495) loss_fgl_dn_2: 0.9767 (0.9767) loss_ddf_dn_2: 0.0023 (0.0023) loss_vfl_dn_3: 0.4609 (0.4609) loss_bbox_dn_3: 0.0404 (0.0404) loss_giou_dn_3: 1.0490 (1.0490) loss_fgl_dn_3: 0.9763 (0.9763) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4604 (0.4604) loss_bbox_dn_4: 0.0405 (0.0405) loss_giou_dn_4: 1.0489 (1.0489) loss_fgl_dn_4: 0.9765 (0.9765) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4634 (0.4634) loss_bbox_dn_5: 0.0405 (0.0405) loss_giou_dn_5: 1.0489 (1.0489) loss_fgl_dn_5: 0.9765 (0.9765) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4316 (0.4316) loss_bbox_dn_pre: 0.0518 (0.0518) loss_giou_dn_pre: 1.1350 (1.1350) time: 1.9032 data: 1.1538 max mem: 29821\n", + "Epoch: [48] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7828 (37.7765) loss_vfl: 0.1646 (0.1699) loss_bbox: 0.2372 (0.2548) loss_giou: 1.7560 (1.8004) loss_fgl: 0.4593 (0.4217) loss_vfl_aux_0: 0.1768 (0.1750) loss_bbox_aux_0: 0.2420 (0.2587) loss_giou_aux_0: 1.7620 (1.8110) loss_fgl_aux_0: 0.4559 (0.4216) loss_ddf_aux_0: 0.1342 (0.1353) loss_vfl_aux_1: 0.1797 (0.1775) loss_bbox_aux_1: 0.2364 (0.2554) loss_giou_aux_1: 1.7571 (1.8021) loss_fgl_aux_1: 0.4584 (0.4218) loss_ddf_aux_1: 0.0139 (0.0179) loss_vfl_aux_2: 0.1796 (0.1759) loss_bbox_aux_2: 0.2362 (0.2548) loss_giou_aux_2: 1.7565 (1.8008) loss_fgl_aux_2: 0.4585 (0.4217) loss_ddf_aux_2: 0.0021 (0.0031) loss_vfl_aux_3: 0.1713 (0.1723) loss_bbox_aux_3: 0.2367 (0.2546) loss_giou_aux_3: 1.7560 (1.8007) loss_fgl_aux_3: 0.4591 (0.4217) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1669 (0.1702) loss_bbox_aux_4: 0.2370 (0.2547) loss_giou_aux_4: 1.7560 (1.8006) loss_fgl_aux_4: 0.4593 (0.4217) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1749 (0.1725) loss_bbox_pre: 0.2443 (0.2625) loss_giou_pre: 1.7590 (1.8061) loss_vfl_enc_0: 0.1804 (0.1695) loss_bbox_enc_0: 0.2711 (0.2871) loss_giou_enc_0: 1.8128 (1.8525) loss_vfl_dn_0: 0.4348 (0.4230) loss_bbox_dn_0: 0.0487 (0.0487) loss_giou_dn_0: 1.1459 (1.1663) loss_fgl_dn_0: 0.9472 (0.9378) loss_ddf_dn_0: 0.3160 (0.2861) loss_vfl_dn_1: 0.4751 (0.4631) loss_bbox_dn_1: 0.0371 (0.0399) loss_giou_dn_1: 1.0405 (1.0666) loss_fgl_dn_1: 0.9705 (0.9655) loss_ddf_dn_1: 0.0286 (0.0270) loss_vfl_dn_2: 0.4688 (0.4600) loss_bbox_dn_2: 0.0362 (0.0389) loss_giou_dn_2: 1.0290 (1.0581) loss_fgl_dn_2: 0.9724 (0.9675) loss_ddf_dn_2: 0.0022 (0.0028) loss_vfl_dn_3: 0.4666 (0.4569) loss_bbox_dn_3: 0.0360 (0.0387) loss_giou_dn_3: 1.0277 (1.0576) loss_fgl_dn_3: 0.9729 (0.9677) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4675 (0.4559) loss_bbox_dn_4: 0.0359 (0.0387) loss_giou_dn_4: 1.0275 (1.0576) loss_fgl_dn_4: 0.9729 (0.9678) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4668 (0.4561) loss_bbox_dn_5: 0.0359 (0.0387) loss_giou_dn_5: 1.0275 (1.0576) loss_fgl_dn_5: 0.9729 (0.9678) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4331 (0.4219) loss_bbox_dn_pre: 0.0481 (0.0490) loss_giou_dn_pre: 1.1445 (1.1663) time: 0.8386 data: 0.0244 max mem: 29821\n", + "Epoch: [48] Total time: 0:01:12 (0.8600 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7828 (37.7765) loss_vfl: 0.1646 (0.1699) loss_bbox: 0.2372 (0.2548) loss_giou: 1.7560 (1.8004) loss_fgl: 0.4593 (0.4217) loss_vfl_aux_0: 0.1768 (0.1750) loss_bbox_aux_0: 0.2420 (0.2587) loss_giou_aux_0: 1.7620 (1.8110) loss_fgl_aux_0: 0.4559 (0.4216) loss_ddf_aux_0: 0.1342 (0.1353) loss_vfl_aux_1: 0.1797 (0.1775) loss_bbox_aux_1: 0.2364 (0.2554) loss_giou_aux_1: 1.7571 (1.8021) loss_fgl_aux_1: 0.4584 (0.4218) loss_ddf_aux_1: 0.0139 (0.0179) loss_vfl_aux_2: 0.1796 (0.1759) loss_bbox_aux_2: 0.2362 (0.2548) loss_giou_aux_2: 1.7565 (1.8008) loss_fgl_aux_2: 0.4585 (0.4217) loss_ddf_aux_2: 0.0021 (0.0031) loss_vfl_aux_3: 0.1713 (0.1723) loss_bbox_aux_3: 0.2367 (0.2546) loss_giou_aux_3: 1.7560 (1.8007) loss_fgl_aux_3: 0.4591 (0.4217) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1669 (0.1702) loss_bbox_aux_4: 0.2370 (0.2547) loss_giou_aux_4: 1.7560 (1.8006) loss_fgl_aux_4: 0.4593 (0.4217) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1749 (0.1725) loss_bbox_pre: 0.2443 (0.2625) loss_giou_pre: 1.7590 (1.8061) loss_vfl_enc_0: 0.1804 (0.1695) loss_bbox_enc_0: 0.2711 (0.2871) loss_giou_enc_0: 1.8128 (1.8525) loss_vfl_dn_0: 0.4348 (0.4230) loss_bbox_dn_0: 0.0487 (0.0487) loss_giou_dn_0: 1.1459 (1.1663) loss_fgl_dn_0: 0.9472 (0.9378) loss_ddf_dn_0: 0.3160 (0.2861) loss_vfl_dn_1: 0.4751 (0.4631) loss_bbox_dn_1: 0.0371 (0.0399) loss_giou_dn_1: 1.0405 (1.0666) loss_fgl_dn_1: 0.9705 (0.9655) loss_ddf_dn_1: 0.0286 (0.0270) loss_vfl_dn_2: 0.4688 (0.4600) loss_bbox_dn_2: 0.0362 (0.0389) loss_giou_dn_2: 1.0290 (1.0581) loss_fgl_dn_2: 0.9724 (0.9675) loss_ddf_dn_2: 0.0022 (0.0028) loss_vfl_dn_3: 0.4666 (0.4569) loss_bbox_dn_3: 0.0360 (0.0387) loss_giou_dn_3: 1.0277 (1.0576) loss_fgl_dn_3: 0.9729 (0.9677) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4675 (0.4559) loss_bbox_dn_4: 0.0359 (0.0387) loss_giou_dn_4: 1.0275 (1.0576) loss_fgl_dn_4: 0.9729 (0.9678) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4668 (0.4561) loss_bbox_dn_5: 0.0359 (0.0387) loss_giou_dn_5: 1.0275 (1.0576) loss_fgl_dn_5: 0.9729 (0.9678) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4331 (0.4219) loss_bbox_dn_pre: 0.0481 (0.0490) loss_giou_dn_pre: 1.1445 (1.1663)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7965 data: 0.5509 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5480 data: 0.1778 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5674 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.095\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.200\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.495\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.067\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.300\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.775\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.188\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.049\n", + "best_stat: {'epoch': 48, 'coco_eval_bbox': 0.039881316315969896}\n", + "Epoch: [49] [ 0/84] eta: 0:02:48 lr: 0.000013 loss: 41.0351 (41.0351) loss_vfl: 0.1342 (0.1342) loss_bbox: 0.4364 (0.4364) loss_giou: 2.1746 (2.1746) loss_fgl: 0.2783 (0.2783) loss_vfl_aux_0: 0.1349 (0.1349) loss_bbox_aux_0: 0.4366 (0.4366) loss_giou_aux_0: 2.1830 (2.1830) loss_fgl_aux_0: 0.2761 (0.2761) loss_ddf_aux_0: 0.0901 (0.0901) loss_vfl_aux_1: 0.1387 (0.1387) loss_bbox_aux_1: 0.4373 (0.4373) loss_giou_aux_1: 2.1729 (2.1729) loss_fgl_aux_1: 0.2785 (0.2785) loss_ddf_aux_1: 0.0078 (0.0078) loss_vfl_aux_2: 0.1385 (0.1385) loss_bbox_aux_2: 0.4365 (0.4365) loss_giou_aux_2: 2.1746 (2.1746) loss_fgl_aux_2: 0.2784 (0.2784) loss_ddf_aux_2: 0.0008 (0.0008) loss_vfl_aux_3: 0.1368 (0.1368) loss_bbox_aux_3: 0.4363 (0.4363) loss_giou_aux_3: 2.1748 (2.1748) loss_fgl_aux_3: 0.2783 (0.2783) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1346 (0.1346) loss_bbox_aux_4: 0.4364 (0.4364) loss_giou_aux_4: 2.1746 (2.1746) loss_fgl_aux_4: 0.2783 (0.2783) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1328 (0.1328) loss_bbox_pre: 0.4405 (0.4405) loss_giou_pre: 2.1749 (2.1749) loss_vfl_enc_0: 0.1227 (0.1227) loss_bbox_enc_0: 0.4295 (0.4295) loss_giou_enc_0: 2.2380 (2.2380) loss_vfl_dn_0: 0.4285 (0.4285) loss_bbox_dn_0: 0.0449 (0.0449) loss_giou_dn_0: 1.1798 (1.1798) loss_fgl_dn_0: 0.9269 (0.9269) loss_ddf_dn_0: 0.2828 (0.2828) loss_vfl_dn_1: 0.4644 (0.4644) loss_bbox_dn_1: 0.0400 (0.0400) loss_giou_dn_1: 1.0876 (1.0876) loss_fgl_dn_1: 0.9566 (0.9566) loss_ddf_dn_1: 0.0241 (0.0241) loss_vfl_dn_2: 0.4604 (0.4604) loss_bbox_dn_2: 0.0395 (0.0395) loss_giou_dn_2: 1.0852 (1.0852) loss_fgl_dn_2: 0.9561 (0.9561) loss_ddf_dn_2: 0.0012 (0.0012) loss_vfl_dn_3: 0.4543 (0.4543) loss_bbox_dn_3: 0.0395 (0.0395) loss_giou_dn_3: 1.0853 (1.0853) loss_fgl_dn_3: 0.9560 (0.9560) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4543 (0.4543) loss_bbox_dn_4: 0.0396 (0.0396) loss_giou_dn_4: 1.0854 (1.0854) loss_fgl_dn_4: 0.9560 (0.9560) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4551 (0.4551) loss_bbox_dn_5: 0.0396 (0.0396) loss_giou_dn_5: 1.0854 (1.0854) loss_fgl_dn_5: 0.9560 (0.9560) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4272 (0.4272) loss_bbox_dn_pre: 0.0453 (0.0453) loss_giou_dn_pre: 1.1801 (1.1801) time: 2.0057 data: 1.0505 max mem: 29821\n", + "Epoch: [49] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7834 (38.0678) loss_vfl: 0.1351 (0.1664) loss_bbox: 0.2537 (0.2833) loss_giou: 1.8172 (1.8130) loss_fgl: 0.3942 (0.4135) loss_vfl_aux_0: 0.1394 (0.1719) loss_bbox_aux_0: 0.2543 (0.2871) loss_giou_aux_0: 1.8403 (1.8281) loss_fgl_aux_0: 0.3910 (0.4134) loss_ddf_aux_0: 0.1221 (0.1455) loss_vfl_aux_1: 0.1414 (0.1744) loss_bbox_aux_1: 0.2549 (0.2846) loss_giou_aux_1: 1.8199 (1.8146) loss_fgl_aux_1: 0.3948 (0.4134) loss_ddf_aux_1: 0.0137 (0.0194) loss_vfl_aux_2: 0.1416 (0.1725) loss_bbox_aux_2: 0.2539 (0.2835) loss_giou_aux_2: 1.8180 (1.8132) loss_fgl_aux_2: 0.3941 (0.4134) loss_ddf_aux_2: 0.0017 (0.0030) loss_vfl_aux_3: 0.1384 (0.1687) loss_bbox_aux_3: 0.2536 (0.2833) loss_giou_aux_3: 1.8177 (1.8131) loss_fgl_aux_3: 0.3943 (0.4135) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1353 (0.1667) loss_bbox_aux_4: 0.2537 (0.2833) loss_giou_aux_4: 1.8173 (1.8130) loss_fgl_aux_4: 0.3942 (0.4135) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1365 (0.1692) loss_bbox_pre: 0.2598 (0.2923) loss_giou_pre: 1.8317 (1.8218) loss_vfl_enc_0: 0.1278 (0.1649) loss_bbox_enc_0: 0.2942 (0.3197) loss_giou_enc_0: 1.9132 (1.8783) loss_vfl_dn_0: 0.4238 (0.4320) loss_bbox_dn_0: 0.0382 (0.0479) loss_giou_dn_0: 1.1662 (1.1442) loss_fgl_dn_0: 0.9394 (0.9513) loss_ddf_dn_0: 0.3112 (0.3071) loss_vfl_dn_1: 0.4639 (0.4693) loss_bbox_dn_1: 0.0337 (0.0391) loss_giou_dn_1: 1.0715 (1.0486) loss_fgl_dn_1: 0.9695 (0.9777) loss_ddf_dn_1: 0.0220 (0.0262) loss_vfl_dn_2: 0.4597 (0.4654) loss_bbox_dn_2: 0.0332 (0.0381) loss_giou_dn_2: 1.0663 (1.0407) loss_fgl_dn_2: 0.9727 (0.9791) loss_ddf_dn_2: 0.0016 (0.0026) loss_vfl_dn_3: 0.4578 (0.4626) loss_bbox_dn_3: 0.0334 (0.0379) loss_giou_dn_3: 1.0656 (1.0400) loss_fgl_dn_3: 0.9728 (0.9793) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4597 (0.4622) loss_bbox_dn_4: 0.0334 (0.0379) loss_giou_dn_4: 1.0655 (1.0399) loss_fgl_dn_4: 0.9728 (0.9793) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4612 (0.4626) loss_bbox_dn_5: 0.0334 (0.0379) loss_giou_dn_5: 1.0655 (1.0399) loss_fgl_dn_5: 0.9728 (0.9793) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4221 (0.4308) loss_bbox_dn_pre: 0.0386 (0.0482) loss_giou_dn_pre: 1.1650 (1.1444) time: 0.8945 data: 0.0169 max mem: 29821\n", + "Epoch: [49] Total time: 0:01:13 (0.8727 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7834 (38.0678) loss_vfl: 0.1351 (0.1664) loss_bbox: 0.2537 (0.2833) loss_giou: 1.8172 (1.8130) loss_fgl: 0.3942 (0.4135) loss_vfl_aux_0: 0.1394 (0.1719) loss_bbox_aux_0: 0.2543 (0.2871) loss_giou_aux_0: 1.8403 (1.8281) loss_fgl_aux_0: 0.3910 (0.4134) loss_ddf_aux_0: 0.1221 (0.1455) loss_vfl_aux_1: 0.1414 (0.1744) loss_bbox_aux_1: 0.2549 (0.2846) loss_giou_aux_1: 1.8199 (1.8146) loss_fgl_aux_1: 0.3948 (0.4134) loss_ddf_aux_1: 0.0137 (0.0194) loss_vfl_aux_2: 0.1416 (0.1725) loss_bbox_aux_2: 0.2539 (0.2835) loss_giou_aux_2: 1.8180 (1.8132) loss_fgl_aux_2: 0.3941 (0.4134) loss_ddf_aux_2: 0.0017 (0.0030) loss_vfl_aux_3: 0.1384 (0.1687) loss_bbox_aux_3: 0.2536 (0.2833) loss_giou_aux_3: 1.8177 (1.8131) loss_fgl_aux_3: 0.3943 (0.4135) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1353 (0.1667) loss_bbox_aux_4: 0.2537 (0.2833) loss_giou_aux_4: 1.8173 (1.8130) loss_fgl_aux_4: 0.3942 (0.4135) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1365 (0.1692) loss_bbox_pre: 0.2598 (0.2923) loss_giou_pre: 1.8317 (1.8218) loss_vfl_enc_0: 0.1278 (0.1649) loss_bbox_enc_0: 0.2942 (0.3197) loss_giou_enc_0: 1.9132 (1.8783) loss_vfl_dn_0: 0.4238 (0.4320) loss_bbox_dn_0: 0.0382 (0.0479) loss_giou_dn_0: 1.1662 (1.1442) loss_fgl_dn_0: 0.9394 (0.9513) loss_ddf_dn_0: 0.3112 (0.3071) loss_vfl_dn_1: 0.4639 (0.4693) loss_bbox_dn_1: 0.0337 (0.0391) loss_giou_dn_1: 1.0715 (1.0486) loss_fgl_dn_1: 0.9695 (0.9777) loss_ddf_dn_1: 0.0220 (0.0262) loss_vfl_dn_2: 0.4597 (0.4654) loss_bbox_dn_2: 0.0332 (0.0381) loss_giou_dn_2: 1.0663 (1.0407) loss_fgl_dn_2: 0.9727 (0.9791) loss_ddf_dn_2: 0.0016 (0.0026) loss_vfl_dn_3: 0.4578 (0.4626) loss_bbox_dn_3: 0.0334 (0.0379) loss_giou_dn_3: 1.0656 (1.0400) loss_fgl_dn_3: 0.9728 (0.9793) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4597 (0.4622) loss_bbox_dn_4: 0.0334 (0.0379) loss_giou_dn_4: 1.0655 (1.0399) loss_fgl_dn_4: 0.9728 (0.9793) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4612 (0.4626) loss_bbox_dn_5: 0.0334 (0.0379) loss_giou_dn_5: 1.0655 (1.0399) loss_fgl_dn_5: 0.9728 (0.9793) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4221 (0.4308) loss_bbox_dn_pre: 0.0386 (0.0482) loss_giou_dn_pre: 1.1650 (1.1444)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7629 data: 0.5138 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4049 data: 0.1709 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4210 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.041\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.093\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.203\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.313\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.066\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.084\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.078\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.282\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.875\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.179\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.046\n", + "best_stat: {'epoch': 49, 'coco_eval_bbox': 0.040527129924679134}\n", + "Epoch: [50] [ 0/84] eta: 0:02:28 lr: 0.000013 loss: 37.1050 (37.1050) loss_vfl: 0.1522 (0.1522) loss_bbox: 0.2451 (0.2451) loss_giou: 1.7936 (1.7936) loss_fgl: 0.4041 (0.4041) loss_vfl_aux_0: 0.1495 (0.1495) loss_bbox_aux_0: 0.2481 (0.2481) loss_giou_aux_0: 1.8025 (1.8025) loss_fgl_aux_0: 0.4019 (0.4019) loss_ddf_aux_0: 0.0613 (0.0613) loss_vfl_aux_1: 0.1545 (0.1545) loss_bbox_aux_1: 0.2450 (0.2450) loss_giou_aux_1: 1.7952 (1.7952) loss_fgl_aux_1: 0.4046 (0.4046) loss_ddf_aux_1: 0.0043 (0.0043) loss_vfl_aux_2: 0.1521 (0.1521) loss_bbox_aux_2: 0.2451 (0.2451) loss_giou_aux_2: 1.7940 (1.7940) loss_fgl_aux_2: 0.4041 (0.4041) loss_ddf_aux_2: 0.0005 (0.0005) loss_vfl_aux_3: 0.1521 (0.1521) loss_bbox_aux_3: 0.2450 (0.2450) loss_giou_aux_3: 1.7938 (1.7938) loss_fgl_aux_3: 0.4042 (0.4042) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1534 (0.1534) loss_bbox_aux_4: 0.2451 (0.2451) loss_giou_aux_4: 1.7936 (1.7936) loss_fgl_aux_4: 0.4042 (0.4042) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.1465 (0.1465) loss_bbox_pre: 0.2545 (0.2545) loss_giou_pre: 1.7948 (1.7948) loss_vfl_enc_0: 0.1375 (0.1375) loss_bbox_enc_0: 0.2702 (0.2702) loss_giou_enc_0: 1.8367 (1.8367) loss_vfl_dn_0: 0.4097 (0.4097) loss_bbox_dn_0: 0.0450 (0.0450) loss_giou_dn_0: 1.1825 (1.1825) loss_fgl_dn_0: 0.9067 (0.9067) loss_ddf_dn_0: 0.2405 (0.2405) loss_vfl_dn_1: 0.4600 (0.4600) loss_bbox_dn_1: 0.0354 (0.0354) loss_giou_dn_1: 1.0860 (1.0860) loss_fgl_dn_1: 0.9459 (0.9459) loss_ddf_dn_1: 0.0109 (0.0109) loss_vfl_dn_2: 0.4526 (0.4526) loss_bbox_dn_2: 0.0351 (0.0351) loss_giou_dn_2: 1.0753 (1.0753) loss_fgl_dn_2: 0.9502 (0.9502) loss_ddf_dn_2: 0.0008 (0.0008) loss_vfl_dn_3: 0.4509 (0.4509) loss_bbox_dn_3: 0.0352 (0.0352) loss_giou_dn_3: 1.0754 (1.0754) loss_fgl_dn_3: 0.9500 (0.9500) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4521 (0.4521) loss_bbox_dn_4: 0.0352 (0.0352) loss_giou_dn_4: 1.0754 (1.0754) loss_fgl_dn_4: 0.9501 (0.9501) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4541 (0.4541) loss_bbox_dn_5: 0.0351 (0.0351) loss_giou_dn_5: 1.0754 (1.0754) loss_fgl_dn_5: 0.9501 (0.9501) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4070 (0.4070) loss_bbox_dn_pre: 0.0456 (0.0456) loss_giou_dn_pre: 1.1867 (1.1867) time: 1.7704 data: 0.9477 max mem: 29821\n", + "Epoch: [50] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.6639 (37.6766) loss_vfl: 0.1595 (0.1587) loss_bbox: 0.2346 (0.2603) loss_giou: 1.7267 (1.7951) loss_fgl: 0.4601 (0.4174) loss_vfl_aux_0: 0.1631 (0.1657) loss_bbox_aux_0: 0.2363 (0.2640) loss_giou_aux_0: 1.7483 (1.8106) loss_fgl_aux_0: 0.4626 (0.4174) loss_ddf_aux_0: 0.1697 (0.1486) loss_vfl_aux_1: 0.1588 (0.1677) loss_bbox_aux_1: 0.2342 (0.2611) loss_giou_aux_1: 1.7311 (1.7973) loss_fgl_aux_1: 0.4615 (0.4174) loss_ddf_aux_1: 0.0242 (0.0187) loss_vfl_aux_2: 0.1594 (0.1652) loss_bbox_aux_2: 0.2351 (0.2604) loss_giou_aux_2: 1.7279 (1.7956) loss_fgl_aux_2: 0.4611 (0.4174) loss_ddf_aux_2: 0.0031 (0.0025) loss_vfl_aux_3: 0.1588 (0.1613) loss_bbox_aux_3: 0.2347 (0.2602) loss_giou_aux_3: 1.7275 (1.7953) loss_fgl_aux_3: 0.4604 (0.4175) loss_ddf_aux_3: 0.0003 (0.0002) loss_vfl_aux_4: 0.1571 (0.1591) loss_bbox_aux_4: 0.2346 (0.2602) loss_giou_aux_4: 1.7269 (1.7952) loss_fgl_aux_4: 0.4602 (0.4175) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1617 (0.1634) loss_bbox_pre: 0.2404 (0.2681) loss_giou_pre: 1.7436 (1.8057) loss_vfl_enc_0: 0.1603 (0.1578) loss_bbox_enc_0: 0.2654 (0.2961) loss_giou_enc_0: 1.8044 (1.8589) loss_vfl_dn_0: 0.4131 (0.4223) loss_bbox_dn_0: 0.0497 (0.0465) loss_giou_dn_0: 1.1745 (1.1598) loss_fgl_dn_0: 0.9316 (0.9371) loss_ddf_dn_0: 0.3192 (0.3134) loss_vfl_dn_1: 0.4619 (0.4653) loss_bbox_dn_1: 0.0390 (0.0375) loss_giou_dn_1: 1.0492 (1.0566) loss_fgl_dn_1: 0.9686 (0.9687) loss_ddf_dn_1: 0.0271 (0.0258) loss_vfl_dn_2: 0.4639 (0.4619) loss_bbox_dn_2: 0.0380 (0.0366) loss_giou_dn_2: 1.0387 (1.0482) loss_fgl_dn_2: 0.9712 (0.9706) loss_ddf_dn_2: 0.0024 (0.0022) loss_vfl_dn_3: 0.4570 (0.4585) loss_bbox_dn_3: 0.0375 (0.0364) loss_giou_dn_3: 1.0370 (1.0476) loss_fgl_dn_3: 0.9712 (0.9708) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4551 (0.4575) loss_bbox_dn_4: 0.0374 (0.0364) loss_giou_dn_4: 1.0369 (1.0476) loss_fgl_dn_4: 0.9711 (0.9709) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4553 (0.4574) loss_bbox_dn_5: 0.0374 (0.0364) loss_giou_dn_5: 1.0369 (1.0476) loss_fgl_dn_5: 0.9712 (0.9709) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4116 (0.4213) loss_bbox_dn_pre: 0.0500 (0.0468) loss_giou_dn_pre: 1.1758 (1.1600) time: 0.8460 data: 0.0203 max mem: 29821\n", + "Epoch: [50] Total time: 0:01:13 (0.8789 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.6639 (37.6766) loss_vfl: 0.1595 (0.1587) loss_bbox: 0.2346 (0.2603) loss_giou: 1.7267 (1.7951) loss_fgl: 0.4601 (0.4174) loss_vfl_aux_0: 0.1631 (0.1657) loss_bbox_aux_0: 0.2363 (0.2640) loss_giou_aux_0: 1.7483 (1.8106) loss_fgl_aux_0: 0.4626 (0.4174) loss_ddf_aux_0: 0.1697 (0.1486) loss_vfl_aux_1: 0.1588 (0.1677) loss_bbox_aux_1: 0.2342 (0.2611) loss_giou_aux_1: 1.7311 (1.7973) loss_fgl_aux_1: 0.4615 (0.4174) loss_ddf_aux_1: 0.0242 (0.0187) loss_vfl_aux_2: 0.1594 (0.1652) loss_bbox_aux_2: 0.2351 (0.2604) loss_giou_aux_2: 1.7279 (1.7956) loss_fgl_aux_2: 0.4611 (0.4174) loss_ddf_aux_2: 0.0031 (0.0025) loss_vfl_aux_3: 0.1588 (0.1613) loss_bbox_aux_3: 0.2347 (0.2602) loss_giou_aux_3: 1.7275 (1.7953) loss_fgl_aux_3: 0.4604 (0.4175) loss_ddf_aux_3: 0.0003 (0.0002) loss_vfl_aux_4: 0.1571 (0.1591) loss_bbox_aux_4: 0.2346 (0.2602) loss_giou_aux_4: 1.7269 (1.7952) loss_fgl_aux_4: 0.4602 (0.4175) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1617 (0.1634) loss_bbox_pre: 0.2404 (0.2681) loss_giou_pre: 1.7436 (1.8057) loss_vfl_enc_0: 0.1603 (0.1578) loss_bbox_enc_0: 0.2654 (0.2961) loss_giou_enc_0: 1.8044 (1.8589) loss_vfl_dn_0: 0.4131 (0.4223) loss_bbox_dn_0: 0.0497 (0.0465) loss_giou_dn_0: 1.1745 (1.1598) loss_fgl_dn_0: 0.9316 (0.9371) loss_ddf_dn_0: 0.3192 (0.3134) loss_vfl_dn_1: 0.4619 (0.4653) loss_bbox_dn_1: 0.0390 (0.0375) loss_giou_dn_1: 1.0492 (1.0566) loss_fgl_dn_1: 0.9686 (0.9687) loss_ddf_dn_1: 0.0271 (0.0258) loss_vfl_dn_2: 0.4639 (0.4619) loss_bbox_dn_2: 0.0380 (0.0366) loss_giou_dn_2: 1.0387 (1.0482) loss_fgl_dn_2: 0.9712 (0.9706) loss_ddf_dn_2: 0.0024 (0.0022) loss_vfl_dn_3: 0.4570 (0.4585) loss_bbox_dn_3: 0.0375 (0.0364) loss_giou_dn_3: 1.0370 (1.0476) loss_fgl_dn_3: 0.9712 (0.9708) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4551 (0.4575) loss_bbox_dn_4: 0.0374 (0.0364) loss_giou_dn_4: 1.0369 (1.0476) loss_fgl_dn_4: 0.9711 (0.9709) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4553 (0.4574) loss_bbox_dn_5: 0.0374 (0.0364) loss_giou_dn_5: 1.0369 (1.0476) loss_fgl_dn_5: 0.9712 (0.9709) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4116 (0.4213) loss_bbox_dn_pre: 0.0500 (0.0468) loss_giou_dn_pre: 1.1758 (1.1600)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7451 data: 0.4999 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3980 data: 0.1679 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4135 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.099\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.039\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.228\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.529\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.380\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.825\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.191\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.049\n", + "best_stat: {'epoch': 50, 'coco_eval_bbox': 0.0434274456294194}\n", + "Epoch: [51] [ 0/84] eta: 0:03:13 lr: 0.000013 loss: 39.1431 (39.1431) loss_vfl: 0.1191 (0.1191) loss_bbox: 0.3903 (0.3903) loss_giou: 1.9568 (1.9568) loss_fgl: 0.3091 (0.3091) loss_vfl_aux_0: 0.1284 (0.1284) loss_bbox_aux_0: 0.3882 (0.3882) loss_giou_aux_0: 1.9700 (1.9700) loss_fgl_aux_0: 0.3088 (0.3088) loss_ddf_aux_0: 0.1797 (0.1797) loss_vfl_aux_1: 0.1262 (0.1262) loss_bbox_aux_1: 0.3934 (0.3934) loss_giou_aux_1: 1.9558 (1.9558) loss_fgl_aux_1: 0.3085 (0.3085) loss_ddf_aux_1: 0.0255 (0.0255) loss_vfl_aux_2: 0.1228 (0.1228) loss_bbox_aux_2: 0.3907 (0.3907) loss_giou_aux_2: 1.9568 (1.9568) loss_fgl_aux_2: 0.3086 (0.3086) loss_ddf_aux_2: 0.0042 (0.0042) loss_vfl_aux_3: 0.1209 (0.1209) loss_bbox_aux_3: 0.3902 (0.3902) loss_giou_aux_3: 1.9565 (1.9565) loss_fgl_aux_3: 0.3090 (0.3090) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1190 (0.1190) loss_bbox_aux_4: 0.3902 (0.3902) loss_giou_aux_4: 1.9569 (1.9569) loss_fgl_aux_4: 0.3091 (0.3091) loss_ddf_aux_4: -0.0000 (-0.0000) loss_vfl_pre: 0.1256 (0.1256) loss_bbox_pre: 0.3947 (0.3947) loss_giou_pre: 1.9625 (1.9625) loss_vfl_enc_0: 0.1302 (0.1302) loss_bbox_enc_0: 0.4089 (0.4089) loss_giou_enc_0: 2.0452 (2.0452) loss_vfl_dn_0: 0.4092 (0.4092) loss_bbox_dn_0: 0.0476 (0.0476) loss_giou_dn_0: 1.1843 (1.1843) loss_fgl_dn_0: 0.9146 (0.9146) loss_ddf_dn_0: 0.3732 (0.3732) loss_vfl_dn_1: 0.4578 (0.4578) loss_bbox_dn_1: 0.0387 (0.0387) loss_giou_dn_1: 1.0868 (1.0868) loss_fgl_dn_1: 0.9449 (0.9449) loss_ddf_dn_1: 0.0281 (0.0281) loss_vfl_dn_2: 0.4453 (0.4453) loss_bbox_dn_2: 0.0386 (0.0386) loss_giou_dn_2: 1.0826 (1.0826) loss_fgl_dn_2: 0.9460 (0.9460) loss_ddf_dn_2: 0.0025 (0.0025) loss_vfl_dn_3: 0.4453 (0.4453) loss_bbox_dn_3: 0.0387 (0.0387) loss_giou_dn_3: 1.0823 (1.0823) loss_fgl_dn_3: 0.9463 (0.9463) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4438 (0.4438) loss_bbox_dn_4: 0.0386 (0.0386) loss_giou_dn_4: 1.0823 (1.0823) loss_fgl_dn_4: 0.9465 (0.9465) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4468 (0.4468) loss_bbox_dn_5: 0.0387 (0.0387) loss_giou_dn_5: 1.0824 (1.0824) loss_fgl_dn_5: 0.9465 (0.9465) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4072 (0.4072) loss_bbox_dn_pre: 0.0480 (0.0480) loss_giou_dn_pre: 1.1867 (1.1867) time: 2.3033 data: 1.0484 max mem: 29821\n", + "Epoch: [51] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.5449 (38.1645) loss_vfl: 0.1652 (0.1676) loss_bbox: 0.2568 (0.2747) loss_giou: 1.8312 (1.8188) loss_fgl: 0.3765 (0.4148) loss_vfl_aux_0: 0.1670 (0.1731) loss_bbox_aux_0: 0.2667 (0.2801) loss_giou_aux_0: 1.8554 (1.8344) loss_fgl_aux_0: 0.3773 (0.4145) loss_ddf_aux_0: 0.1252 (0.1685) loss_vfl_aux_1: 0.1672 (0.1759) loss_bbox_aux_1: 0.2598 (0.2755) loss_giou_aux_1: 1.8325 (1.8206) loss_fgl_aux_1: 0.3768 (0.4149) loss_ddf_aux_1: 0.0145 (0.0215) loss_vfl_aux_2: 0.1638 (0.1742) loss_bbox_aux_2: 0.2574 (0.2750) loss_giou_aux_2: 1.8311 (1.8190) loss_fgl_aux_2: 0.3765 (0.4147) loss_ddf_aux_2: 0.0020 (0.0029) loss_vfl_aux_3: 0.1652 (0.1703) loss_bbox_aux_3: 0.2569 (0.2747) loss_giou_aux_3: 1.8312 (1.8189) loss_fgl_aux_3: 0.3765 (0.4148) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1641 (0.1679) loss_bbox_aux_4: 0.2568 (0.2746) loss_giou_aux_4: 1.8313 (1.8189) loss_fgl_aux_4: 0.3765 (0.4148) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1637 (0.1708) loss_bbox_pre: 0.2704 (0.2846) loss_giou_pre: 1.8502 (1.8290) loss_vfl_enc_0: 0.1628 (0.1667) loss_bbox_enc_0: 0.2884 (0.3090) loss_giou_enc_0: 1.8975 (1.8810) loss_vfl_dn_0: 0.4094 (0.4200) loss_bbox_dn_0: 0.0496 (0.0491) loss_giou_dn_0: 1.1950 (1.1722) loss_fgl_dn_0: 0.9194 (0.9375) loss_ddf_dn_0: 0.3347 (0.3561) loss_vfl_dn_1: 0.4658 (0.4640) loss_bbox_dn_1: 0.0410 (0.0396) loss_giou_dn_1: 1.0583 (1.0617) loss_fgl_dn_1: 0.9579 (0.9689) loss_ddf_dn_1: 0.0249 (0.0321) loss_vfl_dn_2: 0.4573 (0.4601) loss_bbox_dn_2: 0.0404 (0.0385) loss_giou_dn_2: 1.0532 (1.0538) loss_fgl_dn_2: 0.9578 (0.9708) loss_ddf_dn_2: 0.0022 (0.0027) loss_vfl_dn_3: 0.4541 (0.4578) loss_bbox_dn_3: 0.0403 (0.0383) loss_giou_dn_3: 1.0523 (1.0530) loss_fgl_dn_3: 0.9574 (0.9710) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4529 (0.4571) loss_bbox_dn_4: 0.0402 (0.0383) loss_giou_dn_4: 1.0523 (1.0529) loss_fgl_dn_4: 0.9575 (0.9711) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4529 (0.4575) loss_bbox_dn_5: 0.0402 (0.0382) loss_giou_dn_5: 1.0524 (1.0529) loss_fgl_dn_5: 0.9575 (0.9711) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4084 (0.4187) loss_bbox_dn_pre: 0.0494 (0.0493) loss_giou_dn_pre: 1.1928 (1.1726) time: 0.8229 data: 0.0189 max mem: 29821\n", + "Epoch: [51] Total time: 0:01:12 (0.8621 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.5449 (38.1645) loss_vfl: 0.1652 (0.1676) loss_bbox: 0.2568 (0.2747) loss_giou: 1.8312 (1.8188) loss_fgl: 0.3765 (0.4148) loss_vfl_aux_0: 0.1670 (0.1731) loss_bbox_aux_0: 0.2667 (0.2801) loss_giou_aux_0: 1.8554 (1.8344) loss_fgl_aux_0: 0.3773 (0.4145) loss_ddf_aux_0: 0.1252 (0.1685) loss_vfl_aux_1: 0.1672 (0.1759) loss_bbox_aux_1: 0.2598 (0.2755) loss_giou_aux_1: 1.8325 (1.8206) loss_fgl_aux_1: 0.3768 (0.4149) loss_ddf_aux_1: 0.0145 (0.0215) loss_vfl_aux_2: 0.1638 (0.1742) loss_bbox_aux_2: 0.2574 (0.2750) loss_giou_aux_2: 1.8311 (1.8190) loss_fgl_aux_2: 0.3765 (0.4147) loss_ddf_aux_2: 0.0020 (0.0029) loss_vfl_aux_3: 0.1652 (0.1703) loss_bbox_aux_3: 0.2569 (0.2747) loss_giou_aux_3: 1.8312 (1.8189) loss_fgl_aux_3: 0.3765 (0.4148) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1641 (0.1679) loss_bbox_aux_4: 0.2568 (0.2746) loss_giou_aux_4: 1.8313 (1.8189) loss_fgl_aux_4: 0.3765 (0.4148) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1637 (0.1708) loss_bbox_pre: 0.2704 (0.2846) loss_giou_pre: 1.8502 (1.8290) loss_vfl_enc_0: 0.1628 (0.1667) loss_bbox_enc_0: 0.2884 (0.3090) loss_giou_enc_0: 1.8975 (1.8810) loss_vfl_dn_0: 0.4094 (0.4200) loss_bbox_dn_0: 0.0496 (0.0491) loss_giou_dn_0: 1.1950 (1.1722) loss_fgl_dn_0: 0.9194 (0.9375) loss_ddf_dn_0: 0.3347 (0.3561) loss_vfl_dn_1: 0.4658 (0.4640) loss_bbox_dn_1: 0.0410 (0.0396) loss_giou_dn_1: 1.0583 (1.0617) loss_fgl_dn_1: 0.9579 (0.9689) loss_ddf_dn_1: 0.0249 (0.0321) loss_vfl_dn_2: 0.4573 (0.4601) loss_bbox_dn_2: 0.0404 (0.0385) loss_giou_dn_2: 1.0532 (1.0538) loss_fgl_dn_2: 0.9578 (0.9708) loss_ddf_dn_2: 0.0022 (0.0027) loss_vfl_dn_3: 0.4541 (0.4578) loss_bbox_dn_3: 0.0403 (0.0383) loss_giou_dn_3: 1.0523 (1.0530) loss_fgl_dn_3: 0.9574 (0.9710) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4529 (0.4571) loss_bbox_dn_4: 0.0402 (0.0383) loss_giou_dn_4: 1.0523 (1.0529) loss_fgl_dn_4: 0.9575 (0.9711) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4529 (0.4575) loss_bbox_dn_5: 0.0402 (0.0382) loss_giou_dn_5: 1.0524 (1.0529) loss_fgl_dn_5: 0.9575 (0.9711) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4084 (0.4187) loss_bbox_dn_pre: 0.0494 (0.0493) loss_giou_dn_pre: 1.1928 (1.1726)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7666 data: 0.5220 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5403 data: 0.1726 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5589 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.044\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.096\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.208\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.457\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.085\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.293\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.053\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [52] [ 0/84] eta: 0:02:29 lr: 0.000013 loss: 38.6466 (38.6466) loss_vfl: 0.1287 (0.1287) loss_bbox: 0.3580 (0.3580) loss_giou: 1.8794 (1.8794) loss_fgl: 0.3767 (0.3767) loss_vfl_aux_0: 0.1421 (0.1421) loss_bbox_aux_0: 0.3702 (0.3702) loss_giou_aux_0: 1.8826 (1.8826) loss_fgl_aux_0: 0.3763 (0.3763) loss_ddf_aux_0: 0.2217 (0.2217) loss_vfl_aux_1: 0.1453 (0.1453) loss_bbox_aux_1: 0.3592 (0.3592) loss_giou_aux_1: 1.8819 (1.8819) loss_fgl_aux_1: 0.3763 (0.3763) loss_ddf_aux_1: 0.0284 (0.0284) loss_vfl_aux_2: 0.1412 (0.1412) loss_bbox_aux_2: 0.3586 (0.3586) loss_giou_aux_2: 1.8796 (1.8796) loss_fgl_aux_2: 0.3765 (0.3765) loss_ddf_aux_2: 0.0050 (0.0050) loss_vfl_aux_3: 0.1331 (0.1331) loss_bbox_aux_3: 0.3583 (0.3583) loss_giou_aux_3: 1.8792 (1.8792) loss_fgl_aux_3: 0.3766 (0.3766) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1287 (0.1287) loss_bbox_aux_4: 0.3579 (0.3579) loss_giou_aux_4: 1.8793 (1.8793) loss_fgl_aux_4: 0.3767 (0.3767) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1405 (0.1405) loss_bbox_pre: 0.3757 (0.3757) loss_giou_pre: 1.8773 (1.8773) loss_vfl_enc_0: 0.1467 (0.1467) loss_bbox_enc_0: 0.3898 (0.3898) loss_giou_enc_0: 1.9188 (1.9188) loss_vfl_dn_0: 0.4097 (0.4097) loss_bbox_dn_0: 0.0588 (0.0588) loss_giou_dn_0: 1.1645 (1.1645) loss_fgl_dn_0: 0.9378 (0.9378) loss_ddf_dn_0: 0.3390 (0.3390) loss_vfl_dn_1: 0.4568 (0.4568) loss_bbox_dn_1: 0.0459 (0.0459) loss_giou_dn_1: 1.0426 (1.0426) loss_fgl_dn_1: 0.9668 (0.9668) loss_ddf_dn_1: 0.0268 (0.0268) loss_vfl_dn_2: 0.4497 (0.4497) loss_bbox_dn_2: 0.0432 (0.0432) loss_giou_dn_2: 1.0292 (1.0292) loss_fgl_dn_2: 0.9669 (0.9669) loss_ddf_dn_2: 0.0030 (0.0030) loss_vfl_dn_3: 0.4451 (0.4451) loss_bbox_dn_3: 0.0431 (0.0431) loss_giou_dn_3: 1.0279 (1.0279) loss_fgl_dn_3: 0.9671 (0.9671) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4421 (0.4421) loss_bbox_dn_4: 0.0432 (0.0432) loss_giou_dn_4: 1.0281 (1.0281) loss_fgl_dn_4: 0.9670 (0.9670) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4419 (0.4419) loss_bbox_dn_5: 0.0432 (0.0432) loss_giou_dn_5: 1.0281 (1.0281) loss_fgl_dn_5: 0.9670 (0.9670) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4084 (0.4084) loss_bbox_dn_pre: 0.0590 (0.0590) loss_giou_dn_pre: 1.1673 (1.1673) time: 1.7792 data: 0.8174 max mem: 29821\n", + "Epoch: [52] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.5741 (37.9143) loss_vfl: 0.1500 (0.1674) loss_bbox: 0.2583 (0.2633) loss_giou: 1.8032 (1.8026) loss_fgl: 0.4089 (0.4217) loss_vfl_aux_0: 0.1616 (0.1728) loss_bbox_aux_0: 0.2566 (0.2674) loss_giou_aux_0: 1.8098 (1.8147) loss_fgl_aux_0: 0.4086 (0.4207) loss_ddf_aux_0: 0.1543 (0.1589) loss_vfl_aux_1: 0.1620 (0.1755) loss_bbox_aux_1: 0.2594 (0.2640) loss_giou_aux_1: 1.8044 (1.8044) loss_fgl_aux_1: 0.4090 (0.4217) loss_ddf_aux_1: 0.0215 (0.0235) loss_vfl_aux_2: 0.1598 (0.1731) loss_bbox_aux_2: 0.2581 (0.2636) loss_giou_aux_2: 1.8033 (1.8026) loss_fgl_aux_2: 0.4087 (0.4216) loss_ddf_aux_2: 0.0022 (0.0035) loss_vfl_aux_3: 0.1542 (0.1696) loss_bbox_aux_3: 0.2580 (0.2633) loss_giou_aux_3: 1.8035 (1.8026) loss_fgl_aux_3: 0.4089 (0.4217) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1503 (0.1674) loss_bbox_aux_4: 0.2583 (0.2632) loss_giou_aux_4: 1.8032 (1.8026) loss_fgl_aux_4: 0.4090 (0.4217) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1599 (0.1704) loss_bbox_pre: 0.2579 (0.2710) loss_giou_pre: 1.8080 (1.8107) loss_vfl_enc_0: 0.1526 (0.1669) loss_bbox_enc_0: 0.2782 (0.2952) loss_giou_enc_0: 1.8732 (1.8576) loss_vfl_dn_0: 0.4382 (0.4326) loss_bbox_dn_0: 0.0437 (0.0472) loss_giou_dn_0: 1.1305 (1.1381) loss_fgl_dn_0: 0.9592 (0.9552) loss_ddf_dn_0: 0.3213 (0.3187) loss_vfl_dn_1: 0.4719 (0.4681) loss_bbox_dn_1: 0.0338 (0.0385) loss_giou_dn_1: 1.0448 (1.0476) loss_fgl_dn_1: 0.9848 (0.9849) loss_ddf_dn_1: 0.0290 (0.0311) loss_vfl_dn_2: 0.4690 (0.4650) loss_bbox_dn_2: 0.0325 (0.0375) loss_giou_dn_2: 1.0361 (1.0396) loss_fgl_dn_2: 0.9873 (0.9869) loss_ddf_dn_2: 0.0031 (0.0036) loss_vfl_dn_3: 0.4675 (0.4615) loss_bbox_dn_3: 0.0322 (0.0373) loss_giou_dn_3: 1.0347 (1.0389) loss_fgl_dn_3: 0.9875 (0.9873) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4656 (0.4608) loss_bbox_dn_4: 0.0323 (0.0373) loss_giou_dn_4: 1.0345 (1.0388) loss_fgl_dn_4: 0.9876 (0.9874) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4658 (0.4609) loss_bbox_dn_5: 0.0322 (0.0373) loss_giou_dn_5: 1.0345 (1.0388) loss_fgl_dn_5: 0.9876 (0.9874) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4370 (0.4313) loss_bbox_dn_pre: 0.0440 (0.0475) loss_giou_dn_pre: 1.1332 (1.1392) time: 0.8561 data: 0.0168 max mem: 29821\n", + "Epoch: [52] Total time: 0:01:12 (0.8575 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.5741 (37.9143) loss_vfl: 0.1500 (0.1674) loss_bbox: 0.2583 (0.2633) loss_giou: 1.8032 (1.8026) loss_fgl: 0.4089 (0.4217) loss_vfl_aux_0: 0.1616 (0.1728) loss_bbox_aux_0: 0.2566 (0.2674) loss_giou_aux_0: 1.8098 (1.8147) loss_fgl_aux_0: 0.4086 (0.4207) loss_ddf_aux_0: 0.1543 (0.1589) loss_vfl_aux_1: 0.1620 (0.1755) loss_bbox_aux_1: 0.2594 (0.2640) loss_giou_aux_1: 1.8044 (1.8044) loss_fgl_aux_1: 0.4090 (0.4217) loss_ddf_aux_1: 0.0215 (0.0235) loss_vfl_aux_2: 0.1598 (0.1731) loss_bbox_aux_2: 0.2581 (0.2636) loss_giou_aux_2: 1.8033 (1.8026) loss_fgl_aux_2: 0.4087 (0.4216) loss_ddf_aux_2: 0.0022 (0.0035) loss_vfl_aux_3: 0.1542 (0.1696) loss_bbox_aux_3: 0.2580 (0.2633) loss_giou_aux_3: 1.8035 (1.8026) loss_fgl_aux_3: 0.4089 (0.4217) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1503 (0.1674) loss_bbox_aux_4: 0.2583 (0.2632) loss_giou_aux_4: 1.8032 (1.8026) loss_fgl_aux_4: 0.4090 (0.4217) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1599 (0.1704) loss_bbox_pre: 0.2579 (0.2710) loss_giou_pre: 1.8080 (1.8107) loss_vfl_enc_0: 0.1526 (0.1669) loss_bbox_enc_0: 0.2782 (0.2952) loss_giou_enc_0: 1.8732 (1.8576) loss_vfl_dn_0: 0.4382 (0.4326) loss_bbox_dn_0: 0.0437 (0.0472) loss_giou_dn_0: 1.1305 (1.1381) loss_fgl_dn_0: 0.9592 (0.9552) loss_ddf_dn_0: 0.3213 (0.3187) loss_vfl_dn_1: 0.4719 (0.4681) loss_bbox_dn_1: 0.0338 (0.0385) loss_giou_dn_1: 1.0448 (1.0476) loss_fgl_dn_1: 0.9848 (0.9849) loss_ddf_dn_1: 0.0290 (0.0311) loss_vfl_dn_2: 0.4690 (0.4650) loss_bbox_dn_2: 0.0325 (0.0375) loss_giou_dn_2: 1.0361 (1.0396) loss_fgl_dn_2: 0.9873 (0.9869) loss_ddf_dn_2: 0.0031 (0.0036) loss_vfl_dn_3: 0.4675 (0.4615) loss_bbox_dn_3: 0.0322 (0.0373) loss_giou_dn_3: 1.0347 (1.0389) loss_fgl_dn_3: 0.9875 (0.9873) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4656 (0.4608) loss_bbox_dn_4: 0.0323 (0.0373) loss_giou_dn_4: 1.0345 (1.0388) loss_fgl_dn_4: 0.9876 (0.9874) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4658 (0.4609) loss_bbox_dn_5: 0.0322 (0.0373) loss_giou_dn_5: 1.0345 (1.0388) loss_fgl_dn_5: 0.9876 (0.9874) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4370 (0.4313) loss_bbox_dn_pre: 0.0440 (0.0475) loss_giou_dn_pre: 1.1332 (1.1392)\n", + "Test: [0/4] eta: 0:00:03 time: 0.8120 data: 0.5666 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4171 data: 0.1903 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4320 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.041\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.097\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.036\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.194\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.343\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.093\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.273\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.074\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [53] [ 0/84] eta: 0:02:18 lr: 0.000013 loss: 38.0534 (38.0534) loss_vfl: 0.2292 (0.2292) loss_bbox: 0.2880 (0.2880) loss_giou: 1.6789 (1.6789) loss_fgl: 0.4797 (0.4797) loss_vfl_aux_0: 0.2343 (0.2343) loss_bbox_aux_0: 0.2955 (0.2955) loss_giou_aux_0: 1.6938 (1.6938) loss_fgl_aux_0: 0.4804 (0.4804) loss_ddf_aux_0: 0.1984 (0.1984) loss_vfl_aux_1: 0.2377 (0.2377) loss_bbox_aux_1: 0.2895 (0.2895) loss_giou_aux_1: 1.6790 (1.6790) loss_fgl_aux_1: 0.4793 (0.4793) loss_ddf_aux_1: 0.0233 (0.0233) loss_vfl_aux_2: 0.2363 (0.2363) loss_bbox_aux_2: 0.2881 (0.2881) loss_giou_aux_2: 1.6793 (1.6793) loss_fgl_aux_2: 0.4797 (0.4797) loss_ddf_aux_2: 0.0026 (0.0026) loss_vfl_aux_3: 0.2349 (0.2349) loss_bbox_aux_3: 0.2879 (0.2879) loss_giou_aux_3: 1.6793 (1.6793) loss_fgl_aux_3: 0.4798 (0.4798) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.2290 (0.2290) loss_bbox_aux_4: 0.2880 (0.2880) loss_giou_aux_4: 1.6789 (1.6789) loss_fgl_aux_4: 0.4797 (0.4797) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2324 (0.2324) loss_bbox_pre: 0.2989 (0.2989) loss_giou_pre: 1.6866 (1.6866) loss_vfl_enc_0: 0.2424 (0.2424) loss_bbox_enc_0: 0.3223 (0.3223) loss_giou_enc_0: 1.7455 (1.7455) loss_vfl_dn_0: 0.4346 (0.4346) loss_bbox_dn_0: 0.0578 (0.0578) loss_giou_dn_0: 1.0864 (1.0864) loss_fgl_dn_0: 0.9726 (0.9726) loss_ddf_dn_0: 0.4871 (0.4871) loss_vfl_dn_1: 0.4802 (0.4802) loss_bbox_dn_1: 0.0448 (0.0448) loss_giou_dn_1: 0.9912 (0.9912) loss_fgl_dn_1: 1.0005 (1.0005) loss_ddf_dn_1: 0.0363 (0.0363) loss_vfl_dn_2: 0.4753 (0.4753) loss_bbox_dn_2: 0.0434 (0.0434) loss_giou_dn_2: 0.9767 (0.9767) loss_fgl_dn_2: 1.0065 (1.0065) loss_ddf_dn_2: 0.0043 (0.0043) loss_vfl_dn_3: 0.4795 (0.4795) loss_bbox_dn_3: 0.0431 (0.0431) loss_giou_dn_3: 0.9760 (0.9760) loss_fgl_dn_3: 1.0071 (1.0071) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4802 (0.4802) loss_bbox_dn_4: 0.0430 (0.0430) loss_giou_dn_4: 0.9757 (0.9757) loss_fgl_dn_4: 1.0074 (1.0074) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4812 (0.4812) loss_bbox_dn_5: 0.0430 (0.0430) loss_giou_dn_5: 0.9757 (0.9757) loss_fgl_dn_5: 1.0073 (1.0073) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4338 (0.4338) loss_bbox_dn_pre: 0.0576 (0.0576) loss_giou_dn_pre: 1.0849 (1.0849) time: 1.6528 data: 0.8605 max mem: 29821\n", + "Epoch: [53] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.9474 (37.7391) loss_vfl: 0.1843 (0.1722) loss_bbox: 0.2049 (0.2525) loss_giou: 1.7263 (1.7847) loss_fgl: 0.4599 (0.4326) loss_vfl_aux_0: 0.1873 (0.1778) loss_bbox_aux_0: 0.2135 (0.2573) loss_giou_aux_0: 1.7451 (1.8000) loss_fgl_aux_0: 0.4602 (0.4314) loss_ddf_aux_0: 0.1369 (0.1586) loss_vfl_aux_1: 0.1907 (0.1812) loss_bbox_aux_1: 0.2071 (0.2533) loss_giou_aux_1: 1.7257 (1.7866) loss_fgl_aux_1: 0.4607 (0.4325) loss_ddf_aux_1: 0.0238 (0.0219) loss_vfl_aux_2: 0.1904 (0.1791) loss_bbox_aux_2: 0.2052 (0.2525) loss_giou_aux_2: 1.7262 (1.7853) loss_fgl_aux_2: 0.4599 (0.4326) loss_ddf_aux_2: 0.0036 (0.0031) loss_vfl_aux_3: 0.1857 (0.1753) loss_bbox_aux_3: 0.2049 (0.2523) loss_giou_aux_3: 1.7263 (1.7850) loss_fgl_aux_3: 0.4599 (0.4327) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1831 (0.1728) loss_bbox_aux_4: 0.2050 (0.2525) loss_giou_aux_4: 1.7263 (1.7847) loss_fgl_aux_4: 0.4599 (0.4326) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1843 (0.1753) loss_bbox_pre: 0.2168 (0.2611) loss_giou_pre: 1.7393 (1.7955) loss_vfl_enc_0: 0.1805 (0.1735) loss_bbox_enc_0: 0.2550 (0.2902) loss_giou_enc_0: 1.8007 (1.8472) loss_vfl_dn_0: 0.4363 (0.4318) loss_bbox_dn_0: 0.0448 (0.0476) loss_giou_dn_0: 1.1359 (1.1405) loss_fgl_dn_0: 0.9556 (0.9544) loss_ddf_dn_0: 0.2662 (0.2768) loss_vfl_dn_1: 0.4724 (0.4677) loss_bbox_dn_1: 0.0344 (0.0385) loss_giou_dn_1: 1.0470 (1.0441) loss_fgl_dn_1: 0.9804 (0.9828) loss_ddf_dn_1: 0.0246 (0.0269) loss_vfl_dn_2: 0.4673 (0.4645) loss_bbox_dn_2: 0.0343 (0.0375) loss_giou_dn_2: 1.0386 (1.0350) loss_fgl_dn_2: 0.9823 (0.9855) loss_ddf_dn_2: 0.0021 (0.0031) loss_vfl_dn_3: 0.4658 (0.4617) loss_bbox_dn_3: 0.0340 (0.0374) loss_giou_dn_3: 1.0388 (1.0342) loss_fgl_dn_3: 0.9830 (0.9859) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4661 (0.4607) loss_bbox_dn_4: 0.0339 (0.0374) loss_giou_dn_4: 1.0388 (1.0342) loss_fgl_dn_4: 0.9833 (0.9860) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4639 (0.4610) loss_bbox_dn_5: 0.0339 (0.0374) loss_giou_dn_5: 1.0389 (1.0342) loss_fgl_dn_5: 0.9834 (0.9860) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4343 (0.4305) loss_bbox_dn_pre: 0.0451 (0.0478) loss_giou_dn_pre: 1.1380 (1.1414) time: 0.7966 data: 0.0170 max mem: 29821\n", + "Epoch: [53] Total time: 0:01:12 (0.8612 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.9474 (37.7391) loss_vfl: 0.1843 (0.1722) loss_bbox: 0.2049 (0.2525) loss_giou: 1.7263 (1.7847) loss_fgl: 0.4599 (0.4326) loss_vfl_aux_0: 0.1873 (0.1778) loss_bbox_aux_0: 0.2135 (0.2573) loss_giou_aux_0: 1.7451 (1.8000) loss_fgl_aux_0: 0.4602 (0.4314) loss_ddf_aux_0: 0.1369 (0.1586) loss_vfl_aux_1: 0.1907 (0.1812) loss_bbox_aux_1: 0.2071 (0.2533) loss_giou_aux_1: 1.7257 (1.7866) loss_fgl_aux_1: 0.4607 (0.4325) loss_ddf_aux_1: 0.0238 (0.0219) loss_vfl_aux_2: 0.1904 (0.1791) loss_bbox_aux_2: 0.2052 (0.2525) loss_giou_aux_2: 1.7262 (1.7853) loss_fgl_aux_2: 0.4599 (0.4326) loss_ddf_aux_2: 0.0036 (0.0031) loss_vfl_aux_3: 0.1857 (0.1753) loss_bbox_aux_3: 0.2049 (0.2523) loss_giou_aux_3: 1.7263 (1.7850) loss_fgl_aux_3: 0.4599 (0.4327) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1831 (0.1728) loss_bbox_aux_4: 0.2050 (0.2525) loss_giou_aux_4: 1.7263 (1.7847) loss_fgl_aux_4: 0.4599 (0.4326) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1843 (0.1753) loss_bbox_pre: 0.2168 (0.2611) loss_giou_pre: 1.7393 (1.7955) loss_vfl_enc_0: 0.1805 (0.1735) loss_bbox_enc_0: 0.2550 (0.2902) loss_giou_enc_0: 1.8007 (1.8472) loss_vfl_dn_0: 0.4363 (0.4318) loss_bbox_dn_0: 0.0448 (0.0476) loss_giou_dn_0: 1.1359 (1.1405) loss_fgl_dn_0: 0.9556 (0.9544) loss_ddf_dn_0: 0.2662 (0.2768) loss_vfl_dn_1: 0.4724 (0.4677) loss_bbox_dn_1: 0.0344 (0.0385) loss_giou_dn_1: 1.0470 (1.0441) loss_fgl_dn_1: 0.9804 (0.9828) loss_ddf_dn_1: 0.0246 (0.0269) loss_vfl_dn_2: 0.4673 (0.4645) loss_bbox_dn_2: 0.0343 (0.0375) loss_giou_dn_2: 1.0386 (1.0350) loss_fgl_dn_2: 0.9823 (0.9855) loss_ddf_dn_2: 0.0021 (0.0031) loss_vfl_dn_3: 0.4658 (0.4617) loss_bbox_dn_3: 0.0340 (0.0374) loss_giou_dn_3: 1.0388 (1.0342) loss_fgl_dn_3: 0.9830 (0.9859) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4661 (0.4607) loss_bbox_dn_4: 0.0339 (0.0374) loss_giou_dn_4: 1.0388 (1.0342) loss_fgl_dn_4: 0.9833 (0.9860) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4639 (0.4610) loss_bbox_dn_5: 0.0339 (0.0374) loss_giou_dn_5: 1.0389 (1.0342) loss_fgl_dn_5: 0.9834 (0.9860) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4343 (0.4305) loss_bbox_dn_pre: 0.0451 (0.0478) loss_giou_dn_pre: 1.1380 (1.1414)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7462 data: 0.5008 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4004 data: 0.1714 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4152 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.096\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.202\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.314\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.093\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.284\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.675\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.184\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.073\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [54] [ 0/84] eta: 0:02:49 lr: 0.000013 loss: 38.9142 (38.9142) loss_vfl: 0.1624 (0.1624) loss_bbox: 0.3105 (0.3105) loss_giou: 1.9811 (1.9811) loss_fgl: 0.3440 (0.3440) loss_vfl_aux_0: 0.1674 (0.1674) loss_bbox_aux_0: 0.3121 (0.3121) loss_giou_aux_0: 1.9890 (1.9890) loss_fgl_aux_0: 0.3440 (0.3440) loss_ddf_aux_0: 0.0512 (0.0512) loss_vfl_aux_1: 0.1713 (0.1713) loss_bbox_aux_1: 0.3117 (0.3117) loss_giou_aux_1: 1.9810 (1.9810) loss_fgl_aux_1: 0.3438 (0.3438) loss_ddf_aux_1: 0.0054 (0.0054) loss_vfl_aux_2: 0.1677 (0.1677) loss_bbox_aux_2: 0.3103 (0.3103) loss_giou_aux_2: 1.9815 (1.9815) loss_fgl_aux_2: 0.3440 (0.3440) loss_ddf_aux_2: 0.0006 (0.0006) loss_vfl_aux_3: 0.1643 (0.1643) loss_bbox_aux_3: 0.3104 (0.3104) loss_giou_aux_3: 1.9812 (1.9812) loss_fgl_aux_3: 0.3440 (0.3440) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1624 (0.1624) loss_bbox_aux_4: 0.3105 (0.3105) loss_giou_aux_4: 1.9811 (1.9811) loss_fgl_aux_4: 0.3440 (0.3440) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.1633 (0.1633) loss_bbox_pre: 0.3160 (0.3160) loss_giou_pre: 1.9849 (1.9849) loss_vfl_enc_0: 0.1628 (0.1628) loss_bbox_enc_0: 0.3416 (0.3416) loss_giou_enc_0: 2.0103 (2.0103) loss_vfl_dn_0: 0.4270 (0.4270) loss_bbox_dn_0: 0.0361 (0.0361) loss_giou_dn_0: 1.1487 (1.1487) loss_fgl_dn_0: 0.9362 (0.9362) loss_ddf_dn_0: 0.2823 (0.2823) loss_vfl_dn_1: 0.4658 (0.4658) loss_bbox_dn_1: 0.0281 (0.0281) loss_giou_dn_1: 1.0606 (1.0606) loss_fgl_dn_1: 0.9690 (0.9690) loss_ddf_dn_1: 0.0209 (0.0209) loss_vfl_dn_2: 0.4712 (0.4712) loss_bbox_dn_2: 0.0282 (0.0282) loss_giou_dn_2: 1.0557 (1.0557) loss_fgl_dn_2: 0.9722 (0.9722) loss_ddf_dn_2: 0.0017 (0.0017) loss_vfl_dn_3: 0.4600 (0.4600) loss_bbox_dn_3: 0.0282 (0.0282) loss_giou_dn_3: 1.0549 (1.0549) loss_fgl_dn_3: 0.9727 (0.9727) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4585 (0.4585) loss_bbox_dn_4: 0.0282 (0.0282) loss_giou_dn_4: 1.0550 (1.0550) loss_fgl_dn_4: 0.9728 (0.9728) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4585 (0.4585) loss_bbox_dn_5: 0.0282 (0.0282) loss_giou_dn_5: 1.0550 (1.0550) loss_fgl_dn_5: 0.9729 (0.9729) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4260 (0.4260) loss_bbox_dn_pre: 0.0361 (0.0361) loss_giou_dn_pre: 1.1472 (1.1472) time: 2.0225 data: 1.0121 max mem: 29821\n", + "Epoch: [54] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.1003 (37.7657) loss_vfl: 0.1479 (0.1659) loss_bbox: 0.2241 (0.2579) loss_giou: 1.7344 (1.7885) loss_fgl: 0.4542 (0.4333) loss_vfl_aux_0: 0.1577 (0.1730) loss_bbox_aux_0: 0.2264 (0.2623) loss_giou_aux_0: 1.7499 (1.8018) loss_fgl_aux_0: 0.4547 (0.4337) loss_ddf_aux_0: 0.1978 (0.1498) loss_vfl_aux_1: 0.1602 (0.1743) loss_bbox_aux_1: 0.2251 (0.2596) loss_giou_aux_1: 1.7352 (1.7894) loss_fgl_aux_1: 0.4553 (0.4331) loss_ddf_aux_1: 0.0253 (0.0217) loss_vfl_aux_2: 0.1564 (0.1725) loss_bbox_aux_2: 0.2245 (0.2581) loss_giou_aux_2: 1.7338 (1.7887) loss_fgl_aux_2: 0.4543 (0.4332) loss_ddf_aux_2: 0.0021 (0.0025) loss_vfl_aux_3: 0.1523 (0.1689) loss_bbox_aux_3: 0.2242 (0.2579) loss_giou_aux_3: 1.7342 (1.7886) loss_fgl_aux_3: 0.4541 (0.4333) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1500 (0.1666) loss_bbox_aux_4: 0.2241 (0.2579) loss_giou_aux_4: 1.7344 (1.7885) loss_fgl_aux_4: 0.4542 (0.4333) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1556 (0.1705) loss_bbox_pre: 0.2297 (0.2659) loss_giou_pre: 1.7468 (1.7974) loss_vfl_enc_0: 0.1550 (0.1665) loss_bbox_enc_0: 0.2547 (0.2891) loss_giou_enc_0: 1.7923 (1.8451) loss_vfl_dn_0: 0.4263 (0.4298) loss_bbox_dn_0: 0.0449 (0.0471) loss_giou_dn_0: 1.1521 (1.1466) loss_fgl_dn_0: 0.9454 (0.9511) loss_ddf_dn_0: 0.3845 (0.2987) loss_vfl_dn_1: 0.4683 (0.4668) loss_bbox_dn_1: 0.0345 (0.0382) loss_giou_dn_1: 1.0379 (1.0504) loss_fgl_dn_1: 0.9731 (0.9777) loss_ddf_dn_1: 0.0294 (0.0295) loss_vfl_dn_2: 0.4636 (0.4632) loss_bbox_dn_2: 0.0335 (0.0372) loss_giou_dn_2: 1.0288 (1.0412) loss_fgl_dn_2: 0.9746 (0.9802) loss_ddf_dn_2: 0.0020 (0.0022) loss_vfl_dn_3: 0.4624 (0.4602) loss_bbox_dn_3: 0.0332 (0.0370) loss_giou_dn_3: 1.0281 (1.0406) loss_fgl_dn_3: 0.9740 (0.9804) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4600 (0.4593) loss_bbox_dn_4: 0.0332 (0.0370) loss_giou_dn_4: 1.0282 (1.0406) loss_fgl_dn_4: 0.9741 (0.9805) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4587 (0.4597) loss_bbox_dn_5: 0.0332 (0.0370) loss_giou_dn_5: 1.0282 (1.0406) loss_fgl_dn_5: 0.9741 (0.9805) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4255 (0.4289) loss_bbox_dn_pre: 0.0452 (0.0473) loss_giou_dn_pre: 1.1532 (1.1467) time: 0.8484 data: 0.0176 max mem: 29821\n", + "Epoch: [54] Total time: 0:01:12 (0.8580 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.1003 (37.7657) loss_vfl: 0.1479 (0.1659) loss_bbox: 0.2241 (0.2579) loss_giou: 1.7344 (1.7885) loss_fgl: 0.4542 (0.4333) loss_vfl_aux_0: 0.1577 (0.1730) loss_bbox_aux_0: 0.2264 (0.2623) loss_giou_aux_0: 1.7499 (1.8018) loss_fgl_aux_0: 0.4547 (0.4337) loss_ddf_aux_0: 0.1978 (0.1498) loss_vfl_aux_1: 0.1602 (0.1743) loss_bbox_aux_1: 0.2251 (0.2596) loss_giou_aux_1: 1.7352 (1.7894) loss_fgl_aux_1: 0.4553 (0.4331) loss_ddf_aux_1: 0.0253 (0.0217) loss_vfl_aux_2: 0.1564 (0.1725) loss_bbox_aux_2: 0.2245 (0.2581) loss_giou_aux_2: 1.7338 (1.7887) loss_fgl_aux_2: 0.4543 (0.4332) loss_ddf_aux_2: 0.0021 (0.0025) loss_vfl_aux_3: 0.1523 (0.1689) loss_bbox_aux_3: 0.2242 (0.2579) loss_giou_aux_3: 1.7342 (1.7886) loss_fgl_aux_3: 0.4541 (0.4333) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1500 (0.1666) loss_bbox_aux_4: 0.2241 (0.2579) loss_giou_aux_4: 1.7344 (1.7885) loss_fgl_aux_4: 0.4542 (0.4333) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1556 (0.1705) loss_bbox_pre: 0.2297 (0.2659) loss_giou_pre: 1.7468 (1.7974) loss_vfl_enc_0: 0.1550 (0.1665) loss_bbox_enc_0: 0.2547 (0.2891) loss_giou_enc_0: 1.7923 (1.8451) loss_vfl_dn_0: 0.4263 (0.4298) loss_bbox_dn_0: 0.0449 (0.0471) loss_giou_dn_0: 1.1521 (1.1466) loss_fgl_dn_0: 0.9454 (0.9511) loss_ddf_dn_0: 0.3845 (0.2987) loss_vfl_dn_1: 0.4683 (0.4668) loss_bbox_dn_1: 0.0345 (0.0382) loss_giou_dn_1: 1.0379 (1.0504) loss_fgl_dn_1: 0.9731 (0.9777) loss_ddf_dn_1: 0.0294 (0.0295) loss_vfl_dn_2: 0.4636 (0.4632) loss_bbox_dn_2: 0.0335 (0.0372) loss_giou_dn_2: 1.0288 (1.0412) loss_fgl_dn_2: 0.9746 (0.9802) loss_ddf_dn_2: 0.0020 (0.0022) loss_vfl_dn_3: 0.4624 (0.4602) loss_bbox_dn_3: 0.0332 (0.0370) loss_giou_dn_3: 1.0281 (1.0406) loss_fgl_dn_3: 0.9740 (0.9804) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4600 (0.4593) loss_bbox_dn_4: 0.0332 (0.0370) loss_giou_dn_4: 1.0282 (1.0406) loss_fgl_dn_4: 0.9741 (0.9805) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4587 (0.4597) loss_bbox_dn_5: 0.0332 (0.0370) loss_giou_dn_5: 1.0282 (1.0406) loss_fgl_dn_5: 0.9741 (0.9805) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4255 (0.4289) loss_bbox_dn_pre: 0.0452 (0.0473) loss_giou_dn_pre: 1.1532 (1.1467)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7394 data: 0.4925 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3986 data: 0.1664 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4134 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.042\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.096\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.195\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.269\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.070\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.085\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.290\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.650\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.188\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.050\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [55] [ 0/84] eta: 0:02:24 lr: 0.000013 loss: 36.9403 (36.9403) loss_vfl: 0.2180 (0.2180) loss_bbox: 0.1988 (0.1988) loss_giou: 1.6005 (1.6005) loss_fgl: 0.5075 (0.5075) loss_vfl_aux_0: 0.2334 (0.2334) loss_bbox_aux_0: 0.2046 (0.2046) loss_giou_aux_0: 1.6140 (1.6140) loss_fgl_aux_0: 0.5091 (0.5091) loss_ddf_aux_0: 0.3622 (0.3622) loss_vfl_aux_1: 0.2279 (0.2279) loss_bbox_aux_1: 0.1994 (0.1994) loss_giou_aux_1: 1.6009 (1.6009) loss_fgl_aux_1: 0.5071 (0.5071) loss_ddf_aux_1: 0.0704 (0.0704) loss_vfl_aux_2: 0.2217 (0.2217) loss_bbox_aux_2: 0.1995 (0.1995) loss_giou_aux_2: 1.6008 (1.6008) loss_fgl_aux_2: 0.5072 (0.5072) loss_ddf_aux_2: 0.0070 (0.0070) loss_vfl_aux_3: 0.2217 (0.2217) loss_bbox_aux_3: 0.1990 (0.1990) loss_giou_aux_3: 1.6007 (1.6007) loss_fgl_aux_3: 0.5076 (0.5076) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.2172 (0.2172) loss_bbox_aux_4: 0.1988 (0.1988) loss_giou_aux_4: 1.6005 (1.6005) loss_fgl_aux_4: 0.5076 (0.5076) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2305 (0.2305) loss_bbox_pre: 0.2044 (0.2044) loss_giou_pre: 1.6116 (1.6116) loss_vfl_enc_0: 0.2294 (0.2294) loss_bbox_enc_0: 0.2271 (0.2271) loss_giou_enc_0: 1.6836 (1.6836) loss_vfl_dn_0: 0.4355 (0.4355) loss_bbox_dn_0: 0.0579 (0.0579) loss_giou_dn_0: 1.1179 (1.1179) loss_fgl_dn_0: 0.9777 (0.9777) loss_ddf_dn_0: 0.3772 (0.3772) loss_vfl_dn_1: 0.4727 (0.4727) loss_bbox_dn_1: 0.0437 (0.0437) loss_giou_dn_1: 0.9885 (0.9885) loss_fgl_dn_1: 1.0028 (1.0028) loss_ddf_dn_1: 0.0358 (0.0358) loss_vfl_dn_2: 0.4714 (0.4714) loss_bbox_dn_2: 0.0427 (0.0427) loss_giou_dn_2: 0.9799 (0.9799) loss_fgl_dn_2: 1.0046 (1.0046) loss_ddf_dn_2: 0.0026 (0.0026) loss_vfl_dn_3: 0.4717 (0.4717) loss_bbox_dn_3: 0.0422 (0.0422) loss_giou_dn_3: 0.9797 (0.9797) loss_fgl_dn_3: 1.0049 (1.0049) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4680 (0.4680) loss_bbox_dn_4: 0.0421 (0.0421) loss_giou_dn_4: 0.9797 (0.9797) loss_fgl_dn_4: 1.0049 (1.0049) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4661 (0.4661) loss_bbox_dn_5: 0.0420 (0.0420) loss_giou_dn_5: 0.9798 (0.9798) loss_fgl_dn_5: 1.0049 (1.0049) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4348 (0.4348) loss_bbox_dn_pre: 0.0588 (0.0588) loss_giou_dn_pre: 1.1191 (1.1191) time: 1.7213 data: 0.9917 max mem: 29821\n", + "Epoch: [55] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.2946 (37.9996) loss_vfl: 0.1570 (0.1712) loss_bbox: 0.2683 (0.2562) loss_giou: 1.8419 (1.8016) loss_fgl: 0.4162 (0.4307) loss_vfl_aux_0: 0.1659 (0.1778) loss_bbox_aux_0: 0.2687 (0.2591) loss_giou_aux_0: 1.8686 (1.8166) loss_fgl_aux_0: 0.4173 (0.4313) loss_ddf_aux_0: 0.1489 (0.1779) loss_vfl_aux_1: 0.1665 (0.1792) loss_bbox_aux_1: 0.2698 (0.2572) loss_giou_aux_1: 1.8462 (1.8030) loss_fgl_aux_1: 0.4140 (0.4306) loss_ddf_aux_1: 0.0194 (0.0231) loss_vfl_aux_2: 0.1625 (0.1779) loss_bbox_aux_2: 0.2685 (0.2566) loss_giou_aux_2: 1.8435 (1.8017) loss_fgl_aux_2: 0.4153 (0.4307) loss_ddf_aux_2: 0.0025 (0.0029) loss_vfl_aux_3: 0.1591 (0.1739) loss_bbox_aux_3: 0.2684 (0.2563) loss_giou_aux_3: 1.8427 (1.8015) loss_fgl_aux_3: 0.4161 (0.4308) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1580 (0.1718) loss_bbox_aux_4: 0.2684 (0.2561) loss_giou_aux_4: 1.8419 (1.8016) loss_fgl_aux_4: 0.4161 (0.4308) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1630 (0.1748) loss_bbox_pre: 0.2754 (0.2646) loss_giou_pre: 1.8603 (1.8097) loss_vfl_enc_0: 0.1569 (0.1710) loss_bbox_enc_0: 0.3012 (0.2911) loss_giou_enc_0: 1.8933 (1.8578) loss_vfl_dn_0: 0.4241 (0.4245) loss_bbox_dn_0: 0.0452 (0.0472) loss_giou_dn_0: 1.1517 (1.1518) loss_fgl_dn_0: 0.9410 (0.9439) loss_ddf_dn_0: 0.4154 (0.4108) loss_vfl_dn_1: 0.4631 (0.4661) loss_bbox_dn_1: 0.0371 (0.0382) loss_giou_dn_1: 1.0480 (1.0466) loss_fgl_dn_1: 0.9778 (0.9764) loss_ddf_dn_1: 0.0301 (0.0365) loss_vfl_dn_2: 0.4609 (0.4627) loss_bbox_dn_2: 0.0361 (0.0372) loss_giou_dn_2: 1.0455 (1.0378) loss_fgl_dn_2: 0.9765 (0.9785) loss_ddf_dn_2: 0.0028 (0.0032) loss_vfl_dn_3: 0.4597 (0.4604) loss_bbox_dn_3: 0.0357 (0.0371) loss_giou_dn_3: 1.0444 (1.0370) loss_fgl_dn_3: 0.9766 (0.9788) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4585 (0.4593) loss_bbox_dn_4: 0.0357 (0.0370) loss_giou_dn_4: 1.0447 (1.0370) loss_fgl_dn_4: 0.9764 (0.9788) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4583 (0.4593) loss_bbox_dn_5: 0.0357 (0.0370) loss_giou_dn_5: 1.0449 (1.0370) loss_fgl_dn_5: 0.9762 (0.9787) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4248 (0.4235) loss_bbox_dn_pre: 0.0458 (0.0475) loss_giou_dn_pre: 1.1507 (1.1520) time: 0.8458 data: 0.0189 max mem: 29821\n", + "Epoch: [55] Total time: 0:01:12 (0.8640 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.2946 (37.9996) loss_vfl: 0.1570 (0.1712) loss_bbox: 0.2683 (0.2562) loss_giou: 1.8419 (1.8016) loss_fgl: 0.4162 (0.4307) loss_vfl_aux_0: 0.1659 (0.1778) loss_bbox_aux_0: 0.2687 (0.2591) loss_giou_aux_0: 1.8686 (1.8166) loss_fgl_aux_0: 0.4173 (0.4313) loss_ddf_aux_0: 0.1489 (0.1779) loss_vfl_aux_1: 0.1665 (0.1792) loss_bbox_aux_1: 0.2698 (0.2572) loss_giou_aux_1: 1.8462 (1.8030) loss_fgl_aux_1: 0.4140 (0.4306) loss_ddf_aux_1: 0.0194 (0.0231) loss_vfl_aux_2: 0.1625 (0.1779) loss_bbox_aux_2: 0.2685 (0.2566) loss_giou_aux_2: 1.8435 (1.8017) loss_fgl_aux_2: 0.4153 (0.4307) loss_ddf_aux_2: 0.0025 (0.0029) loss_vfl_aux_3: 0.1591 (0.1739) loss_bbox_aux_3: 0.2684 (0.2563) loss_giou_aux_3: 1.8427 (1.8015) loss_fgl_aux_3: 0.4161 (0.4308) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1580 (0.1718) loss_bbox_aux_4: 0.2684 (0.2561) loss_giou_aux_4: 1.8419 (1.8016) loss_fgl_aux_4: 0.4161 (0.4308) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1630 (0.1748) loss_bbox_pre: 0.2754 (0.2646) loss_giou_pre: 1.8603 (1.8097) loss_vfl_enc_0: 0.1569 (0.1710) loss_bbox_enc_0: 0.3012 (0.2911) loss_giou_enc_0: 1.8933 (1.8578) loss_vfl_dn_0: 0.4241 (0.4245) loss_bbox_dn_0: 0.0452 (0.0472) loss_giou_dn_0: 1.1517 (1.1518) loss_fgl_dn_0: 0.9410 (0.9439) loss_ddf_dn_0: 0.4154 (0.4108) loss_vfl_dn_1: 0.4631 (0.4661) loss_bbox_dn_1: 0.0371 (0.0382) loss_giou_dn_1: 1.0480 (1.0466) loss_fgl_dn_1: 0.9778 (0.9764) loss_ddf_dn_1: 0.0301 (0.0365) loss_vfl_dn_2: 0.4609 (0.4627) loss_bbox_dn_2: 0.0361 (0.0372) loss_giou_dn_2: 1.0455 (1.0378) loss_fgl_dn_2: 0.9765 (0.9785) loss_ddf_dn_2: 0.0028 (0.0032) loss_vfl_dn_3: 0.4597 (0.4604) loss_bbox_dn_3: 0.0357 (0.0371) loss_giou_dn_3: 1.0444 (1.0370) loss_fgl_dn_3: 0.9766 (0.9788) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4585 (0.4593) loss_bbox_dn_4: 0.0357 (0.0370) loss_giou_dn_4: 1.0447 (1.0370) loss_fgl_dn_4: 0.9764 (0.9788) loss_ddf_dn_4: 0.0001 (0.0002) loss_vfl_dn_5: 0.4583 (0.4593) loss_bbox_dn_5: 0.0357 (0.0370) loss_giou_dn_5: 1.0449 (1.0370) loss_fgl_dn_5: 0.9762 (0.9787) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4248 (0.4235) loss_bbox_dn_pre: 0.0458 (0.0475) loss_giou_dn_pre: 1.1507 (1.1520)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7398 data: 0.4907 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4004 data: 0.1659 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4159 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.098\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.206\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.173\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.085\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.318\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.400\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.049\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [56] [ 0/84] eta: 0:03:03 lr: 0.000013 loss: 37.4380 (37.4380) loss_vfl: 0.1096 (0.1096) loss_bbox: 0.2558 (0.2558) loss_giou: 1.8638 (1.8638) loss_fgl: 0.3719 (0.3719) loss_vfl_aux_0: 0.1166 (0.1166) loss_bbox_aux_0: 0.2481 (0.2481) loss_giou_aux_0: 1.8809 (1.8809) loss_fgl_aux_0: 0.3762 (0.3762) loss_ddf_aux_0: 0.0751 (0.0751) loss_vfl_aux_1: 0.1145 (0.1145) loss_bbox_aux_1: 0.2542 (0.2542) loss_giou_aux_1: 1.8660 (1.8660) loss_fgl_aux_1: 0.3727 (0.3727) loss_ddf_aux_1: 0.0089 (0.0089) loss_vfl_aux_2: 0.1145 (0.1145) loss_bbox_aux_2: 0.2554 (0.2554) loss_giou_aux_2: 1.8643 (1.8643) loss_fgl_aux_2: 0.3720 (0.3720) loss_ddf_aux_2: 0.0015 (0.0015) loss_vfl_aux_3: 0.1104 (0.1104) loss_bbox_aux_3: 0.2555 (0.2555) loss_giou_aux_3: 1.8641 (1.8641) loss_fgl_aux_3: 0.3720 (0.3720) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1099 (0.1099) loss_bbox_aux_4: 0.2557 (0.2557) loss_giou_aux_4: 1.8638 (1.8638) loss_fgl_aux_4: 0.3719 (0.3719) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1142 (0.1142) loss_bbox_pre: 0.2536 (0.2536) loss_giou_pre: 1.8735 (1.8735) loss_vfl_enc_0: 0.1104 (0.1104) loss_bbox_enc_0: 0.2690 (0.2690) loss_giou_enc_0: 1.9058 (1.9058) loss_vfl_dn_0: 0.4302 (0.4302) loss_bbox_dn_0: 0.0376 (0.0376) loss_giou_dn_0: 1.1569 (1.1569) loss_fgl_dn_0: 0.9486 (0.9486) loss_ddf_dn_0: 0.2768 (0.2768) loss_vfl_dn_1: 0.4583 (0.4583) loss_bbox_dn_1: 0.0329 (0.0329) loss_giou_dn_1: 1.0807 (1.0807) loss_fgl_dn_1: 0.9731 (0.9731) loss_ddf_dn_1: 0.0181 (0.0181) loss_vfl_dn_2: 0.4573 (0.4573) loss_bbox_dn_2: 0.0326 (0.0326) loss_giou_dn_2: 1.0734 (1.0734) loss_fgl_dn_2: 0.9748 (0.9748) loss_ddf_dn_2: 0.0021 (0.0021) loss_vfl_dn_3: 0.4556 (0.4556) loss_bbox_dn_3: 0.0325 (0.0325) loss_giou_dn_3: 1.0719 (1.0719) loss_fgl_dn_3: 0.9751 (0.9751) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4556 (0.4556) loss_bbox_dn_4: 0.0324 (0.0324) loss_giou_dn_4: 1.0717 (1.0717) loss_fgl_dn_4: 0.9753 (0.9753) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4583 (0.4583) loss_bbox_dn_5: 0.0324 (0.0324) loss_giou_dn_5: 1.0718 (1.0718) loss_fgl_dn_5: 0.9752 (0.9752) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4294 (0.4294) loss_bbox_dn_pre: 0.0377 (0.0377) loss_giou_dn_pre: 1.1574 (1.1574) time: 2.1812 data: 1.1616 max mem: 29821\n", + "Epoch: [56] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.7750 (37.7258) loss_vfl: 0.1575 (0.1784) loss_bbox: 0.2364 (0.2427) loss_giou: 1.8173 (1.7779) loss_fgl: 0.4073 (0.4365) loss_vfl_aux_0: 0.1545 (0.1846) loss_bbox_aux_0: 0.2329 (0.2453) loss_giou_aux_0: 1.8438 (1.7931) loss_fgl_aux_0: 0.4104 (0.4374) loss_ddf_aux_0: 0.1177 (0.1531) loss_vfl_aux_1: 0.1589 (0.1871) loss_bbox_aux_1: 0.2363 (0.2429) loss_giou_aux_1: 1.8190 (1.7803) loss_fgl_aux_1: 0.4077 (0.4367) loss_ddf_aux_1: 0.0125 (0.0211) loss_vfl_aux_2: 0.1597 (0.1844) loss_bbox_aux_2: 0.2361 (0.2428) loss_giou_aux_2: 1.8176 (1.7781) loss_fgl_aux_2: 0.4073 (0.4365) loss_ddf_aux_2: 0.0017 (0.0029) loss_vfl_aux_3: 0.1598 (0.1805) loss_bbox_aux_3: 0.2363 (0.2427) loss_giou_aux_3: 1.8172 (1.7779) loss_fgl_aux_3: 0.4073 (0.4365) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1593 (0.1781) loss_bbox_aux_4: 0.2364 (0.2426) loss_giou_aux_4: 1.8173 (1.7779) loss_fgl_aux_4: 0.4073 (0.4365) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1511 (0.1819) loss_bbox_pre: 0.2397 (0.2496) loss_giou_pre: 1.8351 (1.7874) loss_vfl_enc_0: 0.1536 (0.1794) loss_bbox_enc_0: 0.2580 (0.2728) loss_giou_enc_0: 1.8779 (1.8325) loss_vfl_dn_0: 0.4353 (0.4287) loss_bbox_dn_0: 0.0420 (0.0481) loss_giou_dn_0: 1.1443 (1.1477) loss_fgl_dn_0: 0.9524 (0.9510) loss_ddf_dn_0: 0.3073 (0.3611) loss_vfl_dn_1: 0.4680 (0.4678) loss_bbox_dn_1: 0.0343 (0.0387) loss_giou_dn_1: 1.0496 (1.0442) loss_fgl_dn_1: 0.9782 (0.9787) loss_ddf_dn_1: 0.0204 (0.0340) loss_vfl_dn_2: 0.4648 (0.4651) loss_bbox_dn_2: 0.0335 (0.0375) loss_giou_dn_2: 1.0364 (1.0338) loss_fgl_dn_2: 0.9813 (0.9818) loss_ddf_dn_2: 0.0021 (0.0030) loss_vfl_dn_3: 0.4580 (0.4616) loss_bbox_dn_3: 0.0335 (0.0373) loss_giou_dn_3: 1.0354 (1.0330) loss_fgl_dn_3: 0.9816 (0.9822) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4612 (0.4610) loss_bbox_dn_4: 0.0336 (0.0373) loss_giou_dn_4: 1.0352 (1.0330) loss_fgl_dn_4: 0.9816 (0.9822) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4629 (0.4617) loss_bbox_dn_5: 0.0336 (0.0373) loss_giou_dn_5: 1.0352 (1.0330) loss_fgl_dn_5: 0.9815 (0.9822) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4341 (0.4278) loss_bbox_dn_pre: 0.0422 (0.0483) loss_giou_dn_pre: 1.1431 (1.1478) time: 0.8562 data: 0.0199 max mem: 29821\n", + "Epoch: [56] Total time: 0:01:12 (0.8631 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.7750 (37.7258) loss_vfl: 0.1575 (0.1784) loss_bbox: 0.2364 (0.2427) loss_giou: 1.8173 (1.7779) loss_fgl: 0.4073 (0.4365) loss_vfl_aux_0: 0.1545 (0.1846) loss_bbox_aux_0: 0.2329 (0.2453) loss_giou_aux_0: 1.8438 (1.7931) loss_fgl_aux_0: 0.4104 (0.4374) loss_ddf_aux_0: 0.1177 (0.1531) loss_vfl_aux_1: 0.1589 (0.1871) loss_bbox_aux_1: 0.2363 (0.2429) loss_giou_aux_1: 1.8190 (1.7803) loss_fgl_aux_1: 0.4077 (0.4367) loss_ddf_aux_1: 0.0125 (0.0211) loss_vfl_aux_2: 0.1597 (0.1844) loss_bbox_aux_2: 0.2361 (0.2428) loss_giou_aux_2: 1.8176 (1.7781) loss_fgl_aux_2: 0.4073 (0.4365) loss_ddf_aux_2: 0.0017 (0.0029) loss_vfl_aux_3: 0.1598 (0.1805) loss_bbox_aux_3: 0.2363 (0.2427) loss_giou_aux_3: 1.8172 (1.7779) loss_fgl_aux_3: 0.4073 (0.4365) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1593 (0.1781) loss_bbox_aux_4: 0.2364 (0.2426) loss_giou_aux_4: 1.8173 (1.7779) loss_fgl_aux_4: 0.4073 (0.4365) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1511 (0.1819) loss_bbox_pre: 0.2397 (0.2496) loss_giou_pre: 1.8351 (1.7874) loss_vfl_enc_0: 0.1536 (0.1794) loss_bbox_enc_0: 0.2580 (0.2728) loss_giou_enc_0: 1.8779 (1.8325) loss_vfl_dn_0: 0.4353 (0.4287) loss_bbox_dn_0: 0.0420 (0.0481) loss_giou_dn_0: 1.1443 (1.1477) loss_fgl_dn_0: 0.9524 (0.9510) loss_ddf_dn_0: 0.3073 (0.3611) loss_vfl_dn_1: 0.4680 (0.4678) loss_bbox_dn_1: 0.0343 (0.0387) loss_giou_dn_1: 1.0496 (1.0442) loss_fgl_dn_1: 0.9782 (0.9787) loss_ddf_dn_1: 0.0204 (0.0340) loss_vfl_dn_2: 0.4648 (0.4651) loss_bbox_dn_2: 0.0335 (0.0375) loss_giou_dn_2: 1.0364 (1.0338) loss_fgl_dn_2: 0.9813 (0.9818) loss_ddf_dn_2: 0.0021 (0.0030) loss_vfl_dn_3: 0.4580 (0.4616) loss_bbox_dn_3: 0.0335 (0.0373) loss_giou_dn_3: 1.0354 (1.0330) loss_fgl_dn_3: 0.9816 (0.9822) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4612 (0.4610) loss_bbox_dn_4: 0.0336 (0.0373) loss_giou_dn_4: 1.0352 (1.0330) loss_fgl_dn_4: 0.9816 (0.9822) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4629 (0.4617) loss_bbox_dn_5: 0.0336 (0.0373) loss_giou_dn_5: 1.0352 (1.0330) loss_fgl_dn_5: 0.9815 (0.9822) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4341 (0.4278) loss_bbox_dn_pre: 0.0422 (0.0483) loss_giou_dn_pre: 1.1431 (1.1478)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7486 data: 0.4971 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5442 data: 0.1675 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5627 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.043\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.097\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.022\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.210\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.242\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.055\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.068\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.500\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.161\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.047\n", + "best_stat: {'epoch': 51, 'coco_eval_bbox': 0.04358917660514121}\n", + "Epoch: [57] [ 0/84] eta: 0:02:45 lr: 0.000013 loss: 37.2532 (37.2532) loss_vfl: 0.2166 (0.2166) loss_bbox: 0.2089 (0.2089) loss_giou: 1.6330 (1.6330) loss_fgl: 0.5198 (0.5198) loss_vfl_aux_0: 0.2341 (0.2341) loss_bbox_aux_0: 0.2126 (0.2126) loss_giou_aux_0: 1.6504 (1.6504) loss_fgl_aux_0: 0.5205 (0.5205) loss_ddf_aux_0: 0.2082 (0.2082) loss_vfl_aux_1: 0.2312 (0.2312) loss_bbox_aux_1: 0.2086 (0.2086) loss_giou_aux_1: 1.6358 (1.6358) loss_fgl_aux_1: 0.5201 (0.5201) loss_ddf_aux_1: 0.0301 (0.0301) loss_vfl_aux_2: 0.2245 (0.2245) loss_bbox_aux_2: 0.2086 (0.2086) loss_giou_aux_2: 1.6330 (1.6330) loss_fgl_aux_2: 0.5198 (0.5198) loss_ddf_aux_2: 0.0052 (0.0052) loss_vfl_aux_3: 0.2208 (0.2208) loss_bbox_aux_3: 0.2089 (0.2089) loss_giou_aux_3: 1.6331 (1.6331) loss_fgl_aux_3: 0.5199 (0.5199) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.2169 (0.2169) loss_bbox_aux_4: 0.2088 (0.2088) loss_giou_aux_4: 1.6331 (1.6331) loss_fgl_aux_4: 0.5198 (0.5198) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2305 (0.2305) loss_bbox_pre: 0.2162 (0.2162) loss_giou_pre: 1.6470 (1.6470) loss_vfl_enc_0: 0.2238 (0.2238) loss_bbox_enc_0: 0.2490 (0.2490) loss_giou_enc_0: 1.7016 (1.7016) loss_vfl_dn_0: 0.4434 (0.4434) loss_bbox_dn_0: 0.0450 (0.0450) loss_giou_dn_0: 1.0944 (1.0944) loss_fgl_dn_0: 0.9869 (0.9869) loss_ddf_dn_0: 0.5029 (0.5029) loss_vfl_dn_1: 0.4771 (0.4771) loss_bbox_dn_1: 0.0359 (0.0359) loss_giou_dn_1: 0.9897 (0.9897) loss_fgl_dn_1: 1.0132 (1.0132) loss_ddf_dn_1: 0.0396 (0.0396) loss_vfl_dn_2: 0.4729 (0.4729) loss_bbox_dn_2: 0.0339 (0.0339) loss_giou_dn_2: 0.9771 (0.9771) loss_fgl_dn_2: 1.0155 (1.0155) loss_ddf_dn_2: 0.0046 (0.0046) loss_vfl_dn_3: 0.4729 (0.4729) loss_bbox_dn_3: 0.0335 (0.0335) loss_giou_dn_3: 0.9758 (0.9758) loss_fgl_dn_3: 1.0157 (1.0157) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4717 (0.4717) loss_bbox_dn_4: 0.0334 (0.0334) loss_giou_dn_4: 0.9755 (0.9755) loss_fgl_dn_4: 1.0158 (1.0158) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4678 (0.4678) loss_bbox_dn_5: 0.0334 (0.0334) loss_giou_dn_5: 0.9755 (0.9755) loss_fgl_dn_5: 1.0158 (1.0158) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4421 (0.4421) loss_bbox_dn_pre: 0.0455 (0.0455) loss_giou_dn_pre: 1.0948 (1.0948) time: 1.9682 data: 1.0861 max mem: 29821\n", + "Epoch: [57] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.4123 (37.4880) loss_vfl: 0.1680 (0.1699) loss_bbox: 0.2261 (0.2369) loss_giou: 1.7779 (1.7659) loss_fgl: 0.4097 (0.4362) loss_vfl_aux_0: 0.1831 (0.1771) loss_bbox_aux_0: 0.2324 (0.2414) loss_giou_aux_0: 1.7931 (1.7785) loss_fgl_aux_0: 0.4088 (0.4367) loss_ddf_aux_0: 0.1485 (0.1502) loss_vfl_aux_1: 0.1820 (0.1791) loss_bbox_aux_1: 0.2270 (0.2377) loss_giou_aux_1: 1.7793 (1.7672) loss_fgl_aux_1: 0.4099 (0.4364) loss_ddf_aux_1: 0.0207 (0.0208) loss_vfl_aux_2: 0.1775 (0.1774) loss_bbox_aux_2: 0.2258 (0.2370) loss_giou_aux_2: 1.7779 (1.7661) loss_fgl_aux_2: 0.4100 (0.4362) loss_ddf_aux_2: 0.0033 (0.0028) loss_vfl_aux_3: 0.1753 (0.1732) loss_bbox_aux_3: 0.2261 (0.2368) loss_giou_aux_3: 1.7786 (1.7660) loss_fgl_aux_3: 0.4098 (0.4363) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1696 (0.1703) loss_bbox_aux_4: 0.2262 (0.2368) loss_giou_aux_4: 1.7780 (1.7659) loss_fgl_aux_4: 0.4097 (0.4363) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1798 (0.1745) loss_bbox_pre: 0.2360 (0.2454) loss_giou_pre: 1.7914 (1.7735) loss_vfl_enc_0: 0.1637 (0.1718) loss_bbox_enc_0: 0.2671 (0.2686) loss_giou_enc_0: 1.8717 (1.8220) loss_vfl_dn_0: 0.4382 (0.4287) loss_bbox_dn_0: 0.0478 (0.0466) loss_giou_dn_0: 1.1201 (1.1485) loss_fgl_dn_0: 0.9648 (0.9520) loss_ddf_dn_0: 0.2572 (0.3251) loss_vfl_dn_1: 0.4692 (0.4654) loss_bbox_dn_1: 0.0352 (0.0377) loss_giou_dn_1: 1.0370 (1.0492) loss_fgl_dn_1: 0.9813 (0.9781) loss_ddf_dn_1: 0.0245 (0.0334) loss_vfl_dn_2: 0.4658 (0.4621) loss_bbox_dn_2: 0.0341 (0.0367) loss_giou_dn_2: 1.0262 (1.0401) loss_fgl_dn_2: 0.9830 (0.9806) loss_ddf_dn_2: 0.0027 (0.0030) loss_vfl_dn_3: 0.4626 (0.4589) loss_bbox_dn_3: 0.0339 (0.0365) loss_giou_dn_3: 1.0258 (1.0394) loss_fgl_dn_3: 0.9835 (0.9809) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4626 (0.4580) loss_bbox_dn_4: 0.0339 (0.0365) loss_giou_dn_4: 1.0258 (1.0394) loss_fgl_dn_4: 0.9838 (0.9809) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4581) loss_bbox_dn_5: 0.0339 (0.0365) loss_giou_dn_5: 1.0258 (1.0394) loss_fgl_dn_5: 0.9838 (0.9810) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4368 (0.4278) loss_bbox_dn_pre: 0.0479 (0.0468) loss_giou_dn_pre: 1.1237 (1.1485) time: 0.8113 data: 0.0172 max mem: 29821\n", + "Epoch: [57] Total time: 0:01:11 (0.8487 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.4123 (37.4880) loss_vfl: 0.1680 (0.1699) loss_bbox: 0.2261 (0.2369) loss_giou: 1.7779 (1.7659) loss_fgl: 0.4097 (0.4362) loss_vfl_aux_0: 0.1831 (0.1771) loss_bbox_aux_0: 0.2324 (0.2414) loss_giou_aux_0: 1.7931 (1.7785) loss_fgl_aux_0: 0.4088 (0.4367) loss_ddf_aux_0: 0.1485 (0.1502) loss_vfl_aux_1: 0.1820 (0.1791) loss_bbox_aux_1: 0.2270 (0.2377) loss_giou_aux_1: 1.7793 (1.7672) loss_fgl_aux_1: 0.4099 (0.4364) loss_ddf_aux_1: 0.0207 (0.0208) loss_vfl_aux_2: 0.1775 (0.1774) loss_bbox_aux_2: 0.2258 (0.2370) loss_giou_aux_2: 1.7779 (1.7661) loss_fgl_aux_2: 0.4100 (0.4362) loss_ddf_aux_2: 0.0033 (0.0028) loss_vfl_aux_3: 0.1753 (0.1732) loss_bbox_aux_3: 0.2261 (0.2368) loss_giou_aux_3: 1.7786 (1.7660) loss_fgl_aux_3: 0.4098 (0.4363) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1696 (0.1703) loss_bbox_aux_4: 0.2262 (0.2368) loss_giou_aux_4: 1.7780 (1.7659) loss_fgl_aux_4: 0.4097 (0.4363) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1798 (0.1745) loss_bbox_pre: 0.2360 (0.2454) loss_giou_pre: 1.7914 (1.7735) loss_vfl_enc_0: 0.1637 (0.1718) loss_bbox_enc_0: 0.2671 (0.2686) loss_giou_enc_0: 1.8717 (1.8220) loss_vfl_dn_0: 0.4382 (0.4287) loss_bbox_dn_0: 0.0478 (0.0466) loss_giou_dn_0: 1.1201 (1.1485) loss_fgl_dn_0: 0.9648 (0.9520) loss_ddf_dn_0: 0.2572 (0.3251) loss_vfl_dn_1: 0.4692 (0.4654) loss_bbox_dn_1: 0.0352 (0.0377) loss_giou_dn_1: 1.0370 (1.0492) loss_fgl_dn_1: 0.9813 (0.9781) loss_ddf_dn_1: 0.0245 (0.0334) loss_vfl_dn_2: 0.4658 (0.4621) loss_bbox_dn_2: 0.0341 (0.0367) loss_giou_dn_2: 1.0262 (1.0401) loss_fgl_dn_2: 0.9830 (0.9806) loss_ddf_dn_2: 0.0027 (0.0030) loss_vfl_dn_3: 0.4626 (0.4589) loss_bbox_dn_3: 0.0339 (0.0365) loss_giou_dn_3: 1.0258 (1.0394) loss_fgl_dn_3: 0.9835 (0.9809) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4626 (0.4580) loss_bbox_dn_4: 0.0339 (0.0365) loss_giou_dn_4: 1.0258 (1.0394) loss_fgl_dn_4: 0.9838 (0.9809) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4581) loss_bbox_dn_5: 0.0339 (0.0365) loss_giou_dn_5: 1.0258 (1.0394) loss_fgl_dn_5: 0.9838 (0.9810) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4368 (0.4278) loss_bbox_dn_pre: 0.0479 (0.0468) loss_giou_dn_pre: 1.1237 (1.1485)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7707 data: 0.5199 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4130 data: 0.1773 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4281 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.044\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.099\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.211\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.417\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.059\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.079\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.328\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.164\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.048\n", + "best_stat: {'epoch': 57, 'coco_eval_bbox': 0.04362503105829931}\n", + "Epoch: [58] [ 0/84] eta: 0:02:36 lr: 0.000013 loss: 38.8638 (38.8638) loss_vfl: 0.0975 (0.0975) loss_bbox: 0.3901 (0.3901) loss_giou: 2.0074 (2.0074) loss_fgl: 0.2759 (0.2759) loss_vfl_aux_0: 0.0992 (0.0992) loss_bbox_aux_0: 0.3832 (0.3832) loss_giou_aux_0: 2.0363 (2.0363) loss_fgl_aux_0: 0.2780 (0.2780) loss_ddf_aux_0: 0.1157 (0.1157) loss_vfl_aux_1: 0.1020 (0.1020) loss_bbox_aux_1: 0.3899 (0.3899) loss_giou_aux_1: 2.0095 (2.0095) loss_fgl_aux_1: 0.2759 (0.2759) loss_ddf_aux_1: 0.0121 (0.0121) loss_vfl_aux_2: 0.0990 (0.0990) loss_bbox_aux_2: 0.3898 (0.3898) loss_giou_aux_2: 2.0079 (2.0079) loss_fgl_aux_2: 0.2760 (0.2760) loss_ddf_aux_2: 0.0016 (0.0016) loss_vfl_aux_3: 0.0966 (0.0966) loss_bbox_aux_3: 0.3897 (0.3897) loss_giou_aux_3: 2.0078 (2.0078) loss_fgl_aux_3: 0.2760 (0.2760) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.0964 (0.0964) loss_bbox_aux_4: 0.3901 (0.3901) loss_giou_aux_4: 2.0074 (2.0074) loss_fgl_aux_4: 0.2758 (0.2758) loss_ddf_aux_4: 0.0000 (0.0000) loss_vfl_pre: 0.0980 (0.0980) loss_bbox_pre: 0.3873 (0.3873) loss_giou_pre: 2.0327 (2.0327) loss_vfl_enc_0: 0.0901 (0.0901) loss_bbox_enc_0: 0.4080 (0.4080) loss_giou_enc_0: 2.1281 (2.1281) loss_vfl_dn_0: 0.4131 (0.4131) loss_bbox_dn_0: 0.0359 (0.0359) loss_giou_dn_0: 1.1678 (1.1678) loss_fgl_dn_0: 0.9169 (0.9169) loss_ddf_dn_0: 0.1989 (0.1989) loss_vfl_dn_1: 0.4519 (0.4519) loss_bbox_dn_1: 0.0283 (0.0283) loss_giou_dn_1: 1.1006 (1.1006) loss_fgl_dn_1: 0.9415 (0.9415) loss_ddf_dn_1: 0.0127 (0.0127) loss_vfl_dn_2: 0.4480 (0.4480) loss_bbox_dn_2: 0.0279 (0.0279) loss_giou_dn_2: 1.0954 (1.0954) loss_fgl_dn_2: 0.9430 (0.9430) loss_ddf_dn_2: 0.0013 (0.0013) loss_vfl_dn_3: 0.4438 (0.4438) loss_bbox_dn_3: 0.0276 (0.0276) loss_giou_dn_3: 1.0946 (1.0946) loss_fgl_dn_3: 0.9433 (0.9433) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4448 (0.4448) loss_bbox_dn_4: 0.0276 (0.0276) loss_giou_dn_4: 1.0946 (1.0946) loss_fgl_dn_4: 0.9434 (0.9434) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4458 (0.4458) loss_bbox_dn_5: 0.0276 (0.0276) loss_giou_dn_5: 1.0946 (1.0946) loss_fgl_dn_5: 0.9435 (0.9435) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4106 (0.4106) loss_bbox_dn_pre: 0.0364 (0.0364) loss_giou_dn_pre: 1.1706 (1.1706) time: 1.8655 data: 0.8216 max mem: 29821\n", + "Epoch: [58] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.0113 (37.4772) loss_vfl: 0.1571 (0.1673) loss_bbox: 0.2291 (0.2437) loss_giou: 1.7792 (1.7730) loss_fgl: 0.4008 (0.4276) loss_vfl_aux_0: 0.1547 (0.1731) loss_bbox_aux_0: 0.2312 (0.2479) loss_giou_aux_0: 1.7975 (1.7860) loss_fgl_aux_0: 0.3951 (0.4277) loss_ddf_aux_0: 0.1423 (0.1395) loss_vfl_aux_1: 0.1581 (0.1757) loss_bbox_aux_1: 0.2302 (0.2449) loss_giou_aux_1: 1.7814 (1.7741) loss_fgl_aux_1: 0.3984 (0.4275) loss_ddf_aux_1: 0.0141 (0.0177) loss_vfl_aux_2: 0.1578 (0.1735) loss_bbox_aux_2: 0.2297 (0.2439) loss_giou_aux_2: 1.7800 (1.7731) loss_fgl_aux_2: 0.4004 (0.4276) loss_ddf_aux_2: 0.0019 (0.0024) loss_vfl_aux_3: 0.1554 (0.1698) loss_bbox_aux_3: 0.2289 (0.2437) loss_giou_aux_3: 1.7794 (1.7731) loss_fgl_aux_3: 0.4007 (0.4276) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1560 (0.1679) loss_bbox_aux_4: 0.2290 (0.2437) loss_giou_aux_4: 1.7793 (1.7730) loss_fgl_aux_4: 0.4008 (0.4276) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1526 (0.1706) loss_bbox_pre: 0.2388 (0.2509) loss_giou_pre: 1.7943 (1.7819) loss_vfl_enc_0: 0.1562 (0.1692) loss_bbox_enc_0: 0.2580 (0.2709) loss_giou_enc_0: 1.8456 (1.8273) loss_vfl_dn_0: 0.4207 (0.4259) loss_bbox_dn_0: 0.0428 (0.0462) loss_giou_dn_0: 1.1662 (1.1546) loss_fgl_dn_0: 0.9486 (0.9496) loss_ddf_dn_0: 0.2829 (0.3052) loss_vfl_dn_1: 0.4641 (0.4649) loss_bbox_dn_1: 0.0355 (0.0372) loss_giou_dn_1: 1.0589 (1.0515) loss_fgl_dn_1: 0.9759 (0.9763) loss_ddf_dn_1: 0.0262 (0.0304) loss_vfl_dn_2: 0.4583 (0.4611) loss_bbox_dn_2: 0.0338 (0.0362) loss_giou_dn_2: 1.0493 (1.0426) loss_fgl_dn_2: 0.9790 (0.9789) loss_ddf_dn_2: 0.0027 (0.0028) loss_vfl_dn_3: 0.4561 (0.4578) loss_bbox_dn_3: 0.0335 (0.0360) loss_giou_dn_3: 1.0485 (1.0420) loss_fgl_dn_3: 0.9796 (0.9791) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4575 (0.4573) loss_bbox_dn_4: 0.0334 (0.0360) loss_giou_dn_4: 1.0483 (1.0419) loss_fgl_dn_4: 0.9796 (0.9792) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4578 (0.4574) loss_bbox_dn_5: 0.0334 (0.0360) loss_giou_dn_5: 1.0483 (1.0419) loss_fgl_dn_5: 0.9797 (0.9792) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4199 (0.4249) loss_bbox_dn_pre: 0.0427 (0.0463) loss_giou_dn_pre: 1.1655 (1.1548) time: 0.8423 data: 0.0176 max mem: 29821\n", + "Epoch: [58] Total time: 0:01:12 (0.8669 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.0113 (37.4772) loss_vfl: 0.1571 (0.1673) loss_bbox: 0.2291 (0.2437) loss_giou: 1.7792 (1.7730) loss_fgl: 0.4008 (0.4276) loss_vfl_aux_0: 0.1547 (0.1731) loss_bbox_aux_0: 0.2312 (0.2479) loss_giou_aux_0: 1.7975 (1.7860) loss_fgl_aux_0: 0.3951 (0.4277) loss_ddf_aux_0: 0.1423 (0.1395) loss_vfl_aux_1: 0.1581 (0.1757) loss_bbox_aux_1: 0.2302 (0.2449) loss_giou_aux_1: 1.7814 (1.7741) loss_fgl_aux_1: 0.3984 (0.4275) loss_ddf_aux_1: 0.0141 (0.0177) loss_vfl_aux_2: 0.1578 (0.1735) loss_bbox_aux_2: 0.2297 (0.2439) loss_giou_aux_2: 1.7800 (1.7731) loss_fgl_aux_2: 0.4004 (0.4276) loss_ddf_aux_2: 0.0019 (0.0024) loss_vfl_aux_3: 0.1554 (0.1698) loss_bbox_aux_3: 0.2289 (0.2437) loss_giou_aux_3: 1.7794 (1.7731) loss_fgl_aux_3: 0.4007 (0.4276) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1560 (0.1679) loss_bbox_aux_4: 0.2290 (0.2437) loss_giou_aux_4: 1.7793 (1.7730) loss_fgl_aux_4: 0.4008 (0.4276) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1526 (0.1706) loss_bbox_pre: 0.2388 (0.2509) loss_giou_pre: 1.7943 (1.7819) loss_vfl_enc_0: 0.1562 (0.1692) loss_bbox_enc_0: 0.2580 (0.2709) loss_giou_enc_0: 1.8456 (1.8273) loss_vfl_dn_0: 0.4207 (0.4259) loss_bbox_dn_0: 0.0428 (0.0462) loss_giou_dn_0: 1.1662 (1.1546) loss_fgl_dn_0: 0.9486 (0.9496) loss_ddf_dn_0: 0.2829 (0.3052) loss_vfl_dn_1: 0.4641 (0.4649) loss_bbox_dn_1: 0.0355 (0.0372) loss_giou_dn_1: 1.0589 (1.0515) loss_fgl_dn_1: 0.9759 (0.9763) loss_ddf_dn_1: 0.0262 (0.0304) loss_vfl_dn_2: 0.4583 (0.4611) loss_bbox_dn_2: 0.0338 (0.0362) loss_giou_dn_2: 1.0493 (1.0426) loss_fgl_dn_2: 0.9790 (0.9789) loss_ddf_dn_2: 0.0027 (0.0028) loss_vfl_dn_3: 0.4561 (0.4578) loss_bbox_dn_3: 0.0335 (0.0360) loss_giou_dn_3: 1.0485 (1.0420) loss_fgl_dn_3: 0.9796 (0.9791) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4575 (0.4573) loss_bbox_dn_4: 0.0334 (0.0360) loss_giou_dn_4: 1.0483 (1.0419) loss_fgl_dn_4: 0.9796 (0.9792) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4578 (0.4574) loss_bbox_dn_5: 0.0334 (0.0360) loss_giou_dn_5: 1.0483 (1.0419) loss_fgl_dn_5: 0.9797 (0.9792) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4199 (0.4249) loss_bbox_dn_pre: 0.0427 (0.0463) loss_giou_dn_pre: 1.1655 (1.1548)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7522 data: 0.5063 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4019 data: 0.1694 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4169 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.046\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.102\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.228\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.145\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.097\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.331\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.350\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.190\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.077\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [59] [ 0/84] eta: 0:02:40 lr: 0.000013 loss: 38.9577 (38.9577) loss_vfl: 0.1763 (0.1763) loss_bbox: 0.3455 (0.3455) loss_giou: 1.8669 (1.8669) loss_fgl: 0.3980 (0.3980) loss_vfl_aux_0: 0.1868 (0.1868) loss_bbox_aux_0: 0.3487 (0.3487) loss_giou_aux_0: 1.8770 (1.8770) loss_fgl_aux_0: 0.4003 (0.4003) loss_ddf_aux_0: 0.0820 (0.0820) loss_vfl_aux_1: 0.1862 (0.1862) loss_bbox_aux_1: 0.3469 (0.3469) loss_giou_aux_1: 1.8691 (1.8691) loss_fgl_aux_1: 0.3983 (0.3983) loss_ddf_aux_1: 0.0096 (0.0096) loss_vfl_aux_2: 0.1837 (0.1837) loss_bbox_aux_2: 0.3459 (0.3459) loss_giou_aux_2: 1.8666 (1.8666) loss_fgl_aux_2: 0.3980 (0.3980) loss_ddf_aux_2: 0.0014 (0.0014) loss_vfl_aux_3: 0.1803 (0.1803) loss_bbox_aux_3: 0.3456 (0.3456) loss_giou_aux_3: 1.8665 (1.8665) loss_fgl_aux_3: 0.3980 (0.3980) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1765 (0.1765) loss_bbox_aux_4: 0.3455 (0.3455) loss_giou_aux_4: 1.8668 (1.8668) loss_fgl_aux_4: 0.3980 (0.3980) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1838 (0.1838) loss_bbox_pre: 0.3552 (0.3552) loss_giou_pre: 1.8709 (1.8709) loss_vfl_enc_0: 0.1841 (0.1841) loss_bbox_enc_0: 0.3777 (0.3777) loss_giou_enc_0: 1.8989 (1.8989) loss_vfl_dn_0: 0.4287 (0.4287) loss_bbox_dn_0: 0.0493 (0.0493) loss_giou_dn_0: 1.1407 (1.1407) loss_fgl_dn_0: 0.9670 (0.9670) loss_ddf_dn_0: 0.3731 (0.3731) loss_vfl_dn_1: 0.4666 (0.4666) loss_bbox_dn_1: 0.0407 (0.0407) loss_giou_dn_1: 1.0428 (1.0428) loss_fgl_dn_1: 0.9819 (0.9819) loss_ddf_dn_1: 0.0395 (0.0395) loss_vfl_dn_2: 0.4680 (0.4680) loss_bbox_dn_2: 0.0382 (0.0382) loss_giou_dn_2: 1.0314 (1.0314) loss_fgl_dn_2: 0.9857 (0.9857) loss_ddf_dn_2: 0.0044 (0.0044) loss_vfl_dn_3: 0.4609 (0.4609) loss_bbox_dn_3: 0.0378 (0.0378) loss_giou_dn_3: 1.0302 (1.0302) loss_fgl_dn_3: 0.9858 (0.9858) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4604 (0.4604) loss_bbox_dn_4: 0.0378 (0.0378) loss_giou_dn_4: 1.0301 (1.0301) loss_fgl_dn_4: 0.9857 (0.9857) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4595 (0.4595) loss_bbox_dn_5: 0.0378 (0.0378) loss_giou_dn_5: 1.0301 (1.0301) loss_fgl_dn_5: 0.9858 (0.9858) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4270 (0.4270) loss_bbox_dn_pre: 0.0498 (0.0498) loss_giou_dn_pre: 1.1449 (1.1449) time: 1.9084 data: 0.8689 max mem: 29821\n", + "Epoch: [59] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.6033 (37.8649) loss_vfl: 0.1700 (0.1672) loss_bbox: 0.2274 (0.2633) loss_giou: 1.8114 (1.8017) loss_fgl: 0.4259 (0.4250) loss_vfl_aux_0: 0.1796 (0.1754) loss_bbox_aux_0: 0.2268 (0.2666) loss_giou_aux_0: 1.8259 (1.8164) loss_fgl_aux_0: 0.4309 (0.4259) loss_ddf_aux_0: 0.1676 (0.1643) loss_vfl_aux_1: 0.1788 (0.1760) loss_bbox_aux_1: 0.2283 (0.2644) loss_giou_aux_1: 1.8114 (1.8030) loss_fgl_aux_1: 0.4275 (0.4252) loss_ddf_aux_1: 0.0247 (0.0222) loss_vfl_aux_2: 0.1749 (0.1746) loss_bbox_aux_2: 0.2274 (0.2636) loss_giou_aux_2: 1.8113 (1.8016) loss_fgl_aux_2: 0.4258 (0.4249) loss_ddf_aux_2: 0.0024 (0.0029) loss_vfl_aux_3: 0.1710 (0.1710) loss_bbox_aux_3: 0.2274 (0.2633) loss_giou_aux_3: 1.8115 (1.8017) loss_fgl_aux_3: 0.4260 (0.4250) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1700 (0.1681) loss_bbox_aux_4: 0.2274 (0.2633) loss_giou_aux_4: 1.8114 (1.8016) loss_fgl_aux_4: 0.4260 (0.4250) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1776 (0.1725) loss_bbox_pre: 0.2304 (0.2713) loss_giou_pre: 1.8197 (1.8105) loss_vfl_enc_0: 0.1859 (0.1686) loss_bbox_enc_0: 0.2716 (0.3008) loss_giou_enc_0: 1.8625 (1.8563) loss_vfl_dn_0: 0.4353 (0.4339) loss_bbox_dn_0: 0.0401 (0.0445) loss_giou_dn_0: 1.1225 (1.1339) loss_fgl_dn_0: 0.9633 (0.9584) loss_ddf_dn_0: 0.2962 (0.2992) loss_vfl_dn_1: 0.4700 (0.4689) loss_bbox_dn_1: 0.0334 (0.0358) loss_giou_dn_1: 1.0324 (1.0406) loss_fgl_dn_1: 0.9909 (0.9838) loss_ddf_dn_1: 0.0256 (0.0309) loss_vfl_dn_2: 0.4651 (0.4656) loss_bbox_dn_2: 0.0325 (0.0349) loss_giou_dn_2: 1.0246 (1.0313) loss_fgl_dn_2: 0.9946 (0.9860) loss_ddf_dn_2: 0.0028 (0.0029) loss_vfl_dn_3: 0.4600 (0.4620) loss_bbox_dn_3: 0.0323 (0.0347) loss_giou_dn_3: 1.0238 (1.0307) loss_fgl_dn_3: 0.9957 (0.9862) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4595 (0.4609) loss_bbox_dn_4: 0.0322 (0.0347) loss_giou_dn_4: 1.0238 (1.0307) loss_fgl_dn_4: 0.9958 (0.9863) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4590 (0.4610) loss_bbox_dn_5: 0.0323 (0.0347) loss_giou_dn_5: 1.0238 (1.0307) loss_fgl_dn_5: 0.9958 (0.9863) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4346 (0.4326) loss_bbox_dn_pre: 0.0403 (0.0447) loss_giou_dn_pre: 1.1182 (1.1341) time: 0.8240 data: 0.0178 max mem: 29821\n", + "Epoch: [59] Total time: 0:01:12 (0.8672 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.6033 (37.8649) loss_vfl: 0.1700 (0.1672) loss_bbox: 0.2274 (0.2633) loss_giou: 1.8114 (1.8017) loss_fgl: 0.4259 (0.4250) loss_vfl_aux_0: 0.1796 (0.1754) loss_bbox_aux_0: 0.2268 (0.2666) loss_giou_aux_0: 1.8259 (1.8164) loss_fgl_aux_0: 0.4309 (0.4259) loss_ddf_aux_0: 0.1676 (0.1643) loss_vfl_aux_1: 0.1788 (0.1760) loss_bbox_aux_1: 0.2283 (0.2644) loss_giou_aux_1: 1.8114 (1.8030) loss_fgl_aux_1: 0.4275 (0.4252) loss_ddf_aux_1: 0.0247 (0.0222) loss_vfl_aux_2: 0.1749 (0.1746) loss_bbox_aux_2: 0.2274 (0.2636) loss_giou_aux_2: 1.8113 (1.8016) loss_fgl_aux_2: 0.4258 (0.4249) loss_ddf_aux_2: 0.0024 (0.0029) loss_vfl_aux_3: 0.1710 (0.1710) loss_bbox_aux_3: 0.2274 (0.2633) loss_giou_aux_3: 1.8115 (1.8017) loss_fgl_aux_3: 0.4260 (0.4250) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1700 (0.1681) loss_bbox_aux_4: 0.2274 (0.2633) loss_giou_aux_4: 1.8114 (1.8016) loss_fgl_aux_4: 0.4260 (0.4250) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1776 (0.1725) loss_bbox_pre: 0.2304 (0.2713) loss_giou_pre: 1.8197 (1.8105) loss_vfl_enc_0: 0.1859 (0.1686) loss_bbox_enc_0: 0.2716 (0.3008) loss_giou_enc_0: 1.8625 (1.8563) loss_vfl_dn_0: 0.4353 (0.4339) loss_bbox_dn_0: 0.0401 (0.0445) loss_giou_dn_0: 1.1225 (1.1339) loss_fgl_dn_0: 0.9633 (0.9584) loss_ddf_dn_0: 0.2962 (0.2992) loss_vfl_dn_1: 0.4700 (0.4689) loss_bbox_dn_1: 0.0334 (0.0358) loss_giou_dn_1: 1.0324 (1.0406) loss_fgl_dn_1: 0.9909 (0.9838) loss_ddf_dn_1: 0.0256 (0.0309) loss_vfl_dn_2: 0.4651 (0.4656) loss_bbox_dn_2: 0.0325 (0.0349) loss_giou_dn_2: 1.0246 (1.0313) loss_fgl_dn_2: 0.9946 (0.9860) loss_ddf_dn_2: 0.0028 (0.0029) loss_vfl_dn_3: 0.4600 (0.4620) loss_bbox_dn_3: 0.0323 (0.0347) loss_giou_dn_3: 1.0238 (1.0307) loss_fgl_dn_3: 0.9957 (0.9862) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4595 (0.4609) loss_bbox_dn_4: 0.0322 (0.0347) loss_giou_dn_4: 1.0238 (1.0307) loss_fgl_dn_4: 0.9958 (0.9863) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4590 (0.4610) loss_bbox_dn_5: 0.0323 (0.0347) loss_giou_dn_5: 1.0238 (1.0307) loss_fgl_dn_5: 0.9958 (0.9863) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4346 (0.4326) loss_bbox_dn_pre: 0.0403 (0.0447) loss_giou_dn_pre: 1.1182 (1.1341)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7766 data: 0.5324 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5479 data: 0.1777 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5659 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.045\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.099\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.035\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.212\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.069\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.084\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.299\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.200\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.187\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.047\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [60] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 36.1905 (36.1905) loss_vfl: 0.1647 (0.1647) loss_bbox: 0.2202 (0.2202) loss_giou: 1.5781 (1.5781) loss_fgl: 0.5100 (0.5100) loss_vfl_aux_0: 0.1918 (0.1918) loss_bbox_aux_0: 0.2220 (0.2220) loss_giou_aux_0: 1.6024 (1.6024) loss_fgl_aux_0: 0.5090 (0.5090) loss_ddf_aux_0: 0.2196 (0.2196) loss_vfl_aux_1: 0.1816 (0.1816) loss_bbox_aux_1: 0.2189 (0.2189) loss_giou_aux_1: 1.5807 (1.5807) loss_fgl_aux_1: 0.5116 (0.5116) loss_ddf_aux_1: 0.0264 (0.0264) loss_vfl_aux_2: 0.1782 (0.1782) loss_bbox_aux_2: 0.2202 (0.2202) loss_giou_aux_2: 1.5783 (1.5783) loss_fgl_aux_2: 0.5102 (0.5102) loss_ddf_aux_2: 0.0038 (0.0038) loss_vfl_aux_3: 0.1720 (0.1720) loss_bbox_aux_3: 0.2200 (0.2200) loss_giou_aux_3: 1.5781 (1.5781) loss_fgl_aux_3: 0.5102 (0.5102) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1658 (0.1658) loss_bbox_aux_4: 0.2202 (0.2202) loss_giou_aux_4: 1.5780 (1.5780) loss_fgl_aux_4: 0.5101 (0.5101) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1886 (0.1886) loss_bbox_pre: 0.2276 (0.2276) loss_giou_pre: 1.6016 (1.6016) loss_vfl_enc_0: 0.1765 (0.1765) loss_bbox_enc_0: 0.2446 (0.2446) loss_giou_enc_0: 1.6651 (1.6651) loss_vfl_dn_0: 0.4377 (0.4377) loss_bbox_dn_0: 0.0547 (0.0547) loss_giou_dn_0: 1.1136 (1.1136) loss_fgl_dn_0: 0.9495 (0.9495) loss_ddf_dn_0: 0.2622 (0.2622) loss_vfl_dn_1: 0.4592 (0.4592) loss_bbox_dn_1: 0.0420 (0.0420) loss_giou_dn_1: 1.0248 (1.0248) loss_fgl_dn_1: 0.9761 (0.9761) loss_ddf_dn_1: 0.0257 (0.0257) loss_vfl_dn_2: 0.4548 (0.4548) loss_bbox_dn_2: 0.0406 (0.0406) loss_giou_dn_2: 1.0194 (1.0194) loss_fgl_dn_2: 0.9778 (0.9778) loss_ddf_dn_2: 0.0032 (0.0032) loss_vfl_dn_3: 0.4492 (0.4492) loss_bbox_dn_3: 0.0402 (0.0402) loss_giou_dn_3: 1.0193 (1.0193) loss_fgl_dn_3: 0.9775 (0.9775) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4463 (0.4463) loss_bbox_dn_4: 0.0402 (0.0402) loss_giou_dn_4: 1.0194 (1.0194) loss_fgl_dn_4: 0.9774 (0.9774) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4468 (0.4468) loss_bbox_dn_5: 0.0402 (0.0402) loss_giou_dn_5: 1.0195 (1.0195) loss_fgl_dn_5: 0.9773 (0.9773) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4358 (0.4358) loss_bbox_dn_pre: 0.0554 (0.0554) loss_giou_dn_pre: 1.1185 (1.1185) time: 1.8208 data: 1.0330 max mem: 29821\n", + "Epoch: [60] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3438 (37.6968) loss_vfl: 0.1522 (0.1665) loss_bbox: 0.2142 (0.2532) loss_giou: 1.7864 (1.7857) loss_fgl: 0.4316 (0.4344) loss_vfl_aux_0: 0.1536 (0.1740) loss_bbox_aux_0: 0.2203 (0.2578) loss_giou_aux_0: 1.7978 (1.7992) loss_fgl_aux_0: 0.4325 (0.4335) loss_ddf_aux_0: 0.1217 (0.1536) loss_vfl_aux_1: 0.1584 (0.1760) loss_bbox_aux_1: 0.2163 (0.2545) loss_giou_aux_1: 1.7856 (1.7869) loss_fgl_aux_1: 0.4308 (0.4342) loss_ddf_aux_1: 0.0128 (0.0208) loss_vfl_aux_2: 0.1562 (0.1742) loss_bbox_aux_2: 0.2146 (0.2536) loss_giou_aux_2: 1.7852 (1.7857) loss_fgl_aux_2: 0.4311 (0.4343) loss_ddf_aux_2: 0.0021 (0.0029) loss_vfl_aux_3: 0.1558 (0.1697) loss_bbox_aux_3: 0.2145 (0.2533) loss_giou_aux_3: 1.7853 (1.7857) loss_fgl_aux_3: 0.4312 (0.4344) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1522 (0.1670) loss_bbox_aux_4: 0.2143 (0.2533) loss_giou_aux_4: 1.7863 (1.7856) loss_fgl_aux_4: 0.4315 (0.4344) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1517 (0.1713) loss_bbox_pre: 0.2256 (0.2613) loss_giou_pre: 1.7922 (1.7950) loss_vfl_enc_0: 0.1479 (0.1681) loss_bbox_enc_0: 0.2495 (0.2877) loss_giou_enc_0: 1.8443 (1.8471) loss_vfl_dn_0: 0.4429 (0.4295) loss_bbox_dn_0: 0.0453 (0.0476) loss_giou_dn_0: 1.1252 (1.1447) loss_fgl_dn_0: 0.9671 (0.9505) loss_ddf_dn_0: 0.2442 (0.2847) loss_vfl_dn_1: 0.4680 (0.4662) loss_bbox_dn_1: 0.0369 (0.0386) loss_giou_dn_1: 1.0471 (1.0473) loss_fgl_dn_1: 0.9900 (0.9787) loss_ddf_dn_1: 0.0223 (0.0282) loss_vfl_dn_2: 0.4626 (0.4622) loss_bbox_dn_2: 0.0360 (0.0375) loss_giou_dn_2: 1.0385 (1.0384) loss_fgl_dn_2: 0.9924 (0.9808) loss_ddf_dn_2: 0.0021 (0.0031) loss_vfl_dn_3: 0.4634 (0.4589) loss_bbox_dn_3: 0.0360 (0.0374) loss_giou_dn_3: 1.0371 (1.0377) loss_fgl_dn_3: 0.9918 (0.9809) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4600 (0.4578) loss_bbox_dn_4: 0.0360 (0.0373) loss_giou_dn_4: 1.0373 (1.0376) loss_fgl_dn_4: 0.9918 (0.9810) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4577) loss_bbox_dn_5: 0.0360 (0.0373) loss_giou_dn_5: 1.0373 (1.0376) loss_fgl_dn_5: 0.9918 (0.9809) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4407 (0.4284) loss_bbox_dn_pre: 0.0456 (0.0477) loss_giou_dn_pre: 1.1270 (1.1450) time: 0.7916 data: 0.0186 max mem: 29821\n", + "Epoch: [60] Total time: 0:01:11 (0.8542 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3438 (37.6968) loss_vfl: 0.1522 (0.1665) loss_bbox: 0.2142 (0.2532) loss_giou: 1.7864 (1.7857) loss_fgl: 0.4316 (0.4344) loss_vfl_aux_0: 0.1536 (0.1740) loss_bbox_aux_0: 0.2203 (0.2578) loss_giou_aux_0: 1.7978 (1.7992) loss_fgl_aux_0: 0.4325 (0.4335) loss_ddf_aux_0: 0.1217 (0.1536) loss_vfl_aux_1: 0.1584 (0.1760) loss_bbox_aux_1: 0.2163 (0.2545) loss_giou_aux_1: 1.7856 (1.7869) loss_fgl_aux_1: 0.4308 (0.4342) loss_ddf_aux_1: 0.0128 (0.0208) loss_vfl_aux_2: 0.1562 (0.1742) loss_bbox_aux_2: 0.2146 (0.2536) loss_giou_aux_2: 1.7852 (1.7857) loss_fgl_aux_2: 0.4311 (0.4343) loss_ddf_aux_2: 0.0021 (0.0029) loss_vfl_aux_3: 0.1558 (0.1697) loss_bbox_aux_3: 0.2145 (0.2533) loss_giou_aux_3: 1.7853 (1.7857) loss_fgl_aux_3: 0.4312 (0.4344) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1522 (0.1670) loss_bbox_aux_4: 0.2143 (0.2533) loss_giou_aux_4: 1.7863 (1.7856) loss_fgl_aux_4: 0.4315 (0.4344) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1517 (0.1713) loss_bbox_pre: 0.2256 (0.2613) loss_giou_pre: 1.7922 (1.7950) loss_vfl_enc_0: 0.1479 (0.1681) loss_bbox_enc_0: 0.2495 (0.2877) loss_giou_enc_0: 1.8443 (1.8471) loss_vfl_dn_0: 0.4429 (0.4295) loss_bbox_dn_0: 0.0453 (0.0476) loss_giou_dn_0: 1.1252 (1.1447) loss_fgl_dn_0: 0.9671 (0.9505) loss_ddf_dn_0: 0.2442 (0.2847) loss_vfl_dn_1: 0.4680 (0.4662) loss_bbox_dn_1: 0.0369 (0.0386) loss_giou_dn_1: 1.0471 (1.0473) loss_fgl_dn_1: 0.9900 (0.9787) loss_ddf_dn_1: 0.0223 (0.0282) loss_vfl_dn_2: 0.4626 (0.4622) loss_bbox_dn_2: 0.0360 (0.0375) loss_giou_dn_2: 1.0385 (1.0384) loss_fgl_dn_2: 0.9924 (0.9808) loss_ddf_dn_2: 0.0021 (0.0031) loss_vfl_dn_3: 0.4634 (0.4589) loss_bbox_dn_3: 0.0360 (0.0374) loss_giou_dn_3: 1.0371 (1.0377) loss_fgl_dn_3: 0.9918 (0.9809) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4600 (0.4578) loss_bbox_dn_4: 0.0360 (0.0373) loss_giou_dn_4: 1.0373 (1.0376) loss_fgl_dn_4: 0.9918 (0.9810) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4577) loss_bbox_dn_5: 0.0360 (0.0373) loss_giou_dn_5: 1.0373 (1.0376) loss_fgl_dn_5: 0.9918 (0.9809) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4407 (0.4284) loss_bbox_dn_pre: 0.0456 (0.0477) loss_giou_dn_pre: 1.1270 (1.1450)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7621 data: 0.5157 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4028 data: 0.1731 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4172 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.045\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.098\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.023\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.224\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.071\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.304\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.275\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.185\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.046\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [61] [ 0/84] eta: 0:02:34 lr: 0.000013 loss: 37.6974 (37.6974) loss_vfl: 0.1736 (0.1736) loss_bbox: 0.2316 (0.2316) loss_giou: 1.7633 (1.7633) loss_fgl: 0.4698 (0.4698) loss_vfl_aux_0: 0.1815 (0.1815) loss_bbox_aux_0: 0.2365 (0.2365) loss_giou_aux_0: 1.7817 (1.7817) loss_fgl_aux_0: 0.4730 (0.4730) loss_ddf_aux_0: 0.1735 (0.1735) loss_vfl_aux_1: 0.1871 (0.1871) loss_bbox_aux_1: 0.2328 (0.2328) loss_giou_aux_1: 1.7667 (1.7667) loss_fgl_aux_1: 0.4710 (0.4710) loss_ddf_aux_1: 0.0278 (0.0278) loss_vfl_aux_2: 0.1829 (0.1829) loss_bbox_aux_2: 0.2321 (0.2321) loss_giou_aux_2: 1.7633 (1.7633) loss_fgl_aux_2: 0.4705 (0.4705) loss_ddf_aux_2: 0.0051 (0.0051) loss_vfl_aux_3: 0.1779 (0.1779) loss_bbox_aux_3: 0.2318 (0.2318) loss_giou_aux_3: 1.7631 (1.7631) loss_fgl_aux_3: 0.4701 (0.4701) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.1738 (0.1738) loss_bbox_aux_4: 0.2316 (0.2316) loss_giou_aux_4: 1.7632 (1.7632) loss_fgl_aux_4: 0.4698 (0.4698) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1779 (0.1779) loss_bbox_pre: 0.2400 (0.2400) loss_giou_pre: 1.7769 (1.7769) loss_vfl_enc_0: 0.1726 (0.1726) loss_bbox_enc_0: 0.2798 (0.2798) loss_giou_enc_0: 1.8240 (1.8240) loss_vfl_dn_0: 0.4353 (0.4353) loss_bbox_dn_0: 0.0495 (0.0495) loss_giou_dn_0: 1.1382 (1.1382) loss_fgl_dn_0: 0.9632 (0.9632) loss_ddf_dn_0: 0.2697 (0.2697) loss_vfl_dn_1: 0.4729 (0.4729) loss_bbox_dn_1: 0.0390 (0.0390) loss_giou_dn_1: 1.0313 (1.0313) loss_fgl_dn_1: 0.9917 (0.9917) loss_ddf_dn_1: 0.0294 (0.0294) loss_vfl_dn_2: 0.4700 (0.4700) loss_bbox_dn_2: 0.0374 (0.0374) loss_giou_dn_2: 1.0211 (1.0211) loss_fgl_dn_2: 0.9937 (0.9937) loss_ddf_dn_2: 0.0034 (0.0034) loss_vfl_dn_3: 0.4678 (0.4678) loss_bbox_dn_3: 0.0371 (0.0371) loss_giou_dn_3: 1.0197 (1.0197) loss_fgl_dn_3: 0.9937 (0.9937) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4680 (0.4680) loss_bbox_dn_4: 0.0370 (0.0370) loss_giou_dn_4: 1.0196 (1.0196) loss_fgl_dn_4: 0.9936 (0.9936) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4675 (0.4675) loss_bbox_dn_5: 0.0370 (0.0370) loss_giou_dn_5: 1.0196 (1.0196) loss_fgl_dn_5: 0.9936 (0.9936) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4353 (0.4353) loss_bbox_dn_pre: 0.0492 (0.0492) loss_giou_dn_pre: 1.1362 (1.1362) time: 1.8410 data: 0.9103 max mem: 29821\n", + "Epoch: [61] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.6031 (37.7877) loss_vfl: 0.1531 (0.1699) loss_bbox: 0.2463 (0.2562) loss_giou: 1.7990 (1.7945) loss_fgl: 0.3806 (0.4272) loss_vfl_aux_0: 0.1566 (0.1772) loss_bbox_aux_0: 0.2513 (0.2605) loss_giou_aux_0: 1.8069 (1.8061) loss_fgl_aux_0: 0.3805 (0.4270) loss_ddf_aux_0: 0.1392 (0.1433) loss_vfl_aux_1: 0.1595 (0.1791) loss_bbox_aux_1: 0.2466 (0.2577) loss_giou_aux_1: 1.7988 (1.7957) loss_fgl_aux_1: 0.3812 (0.4271) loss_ddf_aux_1: 0.0183 (0.0206) loss_vfl_aux_2: 0.1582 (0.1766) loss_bbox_aux_2: 0.2466 (0.2565) loss_giou_aux_2: 1.7985 (1.7944) loss_fgl_aux_2: 0.3809 (0.4272) loss_ddf_aux_2: 0.0020 (0.0028) loss_vfl_aux_3: 0.1561 (0.1725) loss_bbox_aux_3: 0.2464 (0.2563) loss_giou_aux_3: 1.7986 (1.7944) loss_fgl_aux_3: 0.3807 (0.4273) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1517 (0.1703) loss_bbox_aux_4: 0.2463 (0.2562) loss_giou_aux_4: 1.7990 (1.7944) loss_fgl_aux_4: 0.3807 (0.4272) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1555 (0.1745) loss_bbox_pre: 0.2546 (0.2633) loss_giou_pre: 1.8022 (1.8020) loss_vfl_enc_0: 0.1411 (0.1712) loss_bbox_enc_0: 0.2828 (0.2869) loss_giou_enc_0: 1.8354 (1.8478) loss_vfl_dn_0: 0.4272 (0.4294) loss_bbox_dn_0: 0.0439 (0.0470) loss_giou_dn_0: 1.1495 (1.1446) loss_fgl_dn_0: 0.9543 (0.9522) loss_ddf_dn_0: 0.2792 (0.3113) loss_vfl_dn_1: 0.4636 (0.4657) loss_bbox_dn_1: 0.0359 (0.0381) loss_giou_dn_1: 1.0502 (1.0461) loss_fgl_dn_1: 0.9874 (0.9816) loss_ddf_dn_1: 0.0340 (0.0385) loss_vfl_dn_2: 0.4609 (0.4621) loss_bbox_dn_2: 0.0347 (0.0369) loss_giou_dn_2: 1.0394 (1.0362) loss_fgl_dn_2: 0.9910 (0.9844) loss_ddf_dn_2: 0.0019 (0.0034) loss_vfl_dn_3: 0.4563 (0.4590) loss_bbox_dn_3: 0.0346 (0.0367) loss_giou_dn_3: 1.0395 (1.0356) loss_fgl_dn_3: 0.9914 (0.9846) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4568 (0.4579) loss_bbox_dn_4: 0.0346 (0.0367) loss_giou_dn_4: 1.0396 (1.0356) loss_fgl_dn_4: 0.9913 (0.9846) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4531 (0.4579) loss_bbox_dn_5: 0.0345 (0.0367) loss_giou_dn_5: 1.0396 (1.0356) loss_fgl_dn_5: 0.9913 (0.9846) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4280 (0.4284) loss_bbox_dn_pre: 0.0436 (0.0471) loss_giou_dn_pre: 1.1470 (1.1447) time: 0.8433 data: 0.0182 max mem: 29821\n", + "Epoch: [61] Total time: 0:01:09 (0.8303 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.6031 (37.7877) loss_vfl: 0.1531 (0.1699) loss_bbox: 0.2463 (0.2562) loss_giou: 1.7990 (1.7945) loss_fgl: 0.3806 (0.4272) loss_vfl_aux_0: 0.1566 (0.1772) loss_bbox_aux_0: 0.2513 (0.2605) loss_giou_aux_0: 1.8069 (1.8061) loss_fgl_aux_0: 0.3805 (0.4270) loss_ddf_aux_0: 0.1392 (0.1433) loss_vfl_aux_1: 0.1595 (0.1791) loss_bbox_aux_1: 0.2466 (0.2577) loss_giou_aux_1: 1.7988 (1.7957) loss_fgl_aux_1: 0.3812 (0.4271) loss_ddf_aux_1: 0.0183 (0.0206) loss_vfl_aux_2: 0.1582 (0.1766) loss_bbox_aux_2: 0.2466 (0.2565) loss_giou_aux_2: 1.7985 (1.7944) loss_fgl_aux_2: 0.3809 (0.4272) loss_ddf_aux_2: 0.0020 (0.0028) loss_vfl_aux_3: 0.1561 (0.1725) loss_bbox_aux_3: 0.2464 (0.2563) loss_giou_aux_3: 1.7986 (1.7944) loss_fgl_aux_3: 0.3807 (0.4273) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1517 (0.1703) loss_bbox_aux_4: 0.2463 (0.2562) loss_giou_aux_4: 1.7990 (1.7944) loss_fgl_aux_4: 0.3807 (0.4272) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1555 (0.1745) loss_bbox_pre: 0.2546 (0.2633) loss_giou_pre: 1.8022 (1.8020) loss_vfl_enc_0: 0.1411 (0.1712) loss_bbox_enc_0: 0.2828 (0.2869) loss_giou_enc_0: 1.8354 (1.8478) loss_vfl_dn_0: 0.4272 (0.4294) loss_bbox_dn_0: 0.0439 (0.0470) loss_giou_dn_0: 1.1495 (1.1446) loss_fgl_dn_0: 0.9543 (0.9522) loss_ddf_dn_0: 0.2792 (0.3113) loss_vfl_dn_1: 0.4636 (0.4657) loss_bbox_dn_1: 0.0359 (0.0381) loss_giou_dn_1: 1.0502 (1.0461) loss_fgl_dn_1: 0.9874 (0.9816) loss_ddf_dn_1: 0.0340 (0.0385) loss_vfl_dn_2: 0.4609 (0.4621) loss_bbox_dn_2: 0.0347 (0.0369) loss_giou_dn_2: 1.0394 (1.0362) loss_fgl_dn_2: 0.9910 (0.9844) loss_ddf_dn_2: 0.0019 (0.0034) loss_vfl_dn_3: 0.4563 (0.4590) loss_bbox_dn_3: 0.0346 (0.0367) loss_giou_dn_3: 1.0395 (1.0356) loss_fgl_dn_3: 0.9914 (0.9846) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4568 (0.4579) loss_bbox_dn_4: 0.0346 (0.0367) loss_giou_dn_4: 1.0396 (1.0356) loss_fgl_dn_4: 0.9913 (0.9846) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4531 (0.4579) loss_bbox_dn_5: 0.0345 (0.0367) loss_giou_dn_5: 1.0396 (1.0356) loss_fgl_dn_5: 0.9913 (0.9846) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4280 (0.4284) loss_bbox_dn_pre: 0.0436 (0.0471) loss_giou_dn_pre: 1.1470 (1.1447)\n", + "Test: [0/4] eta: 0:00:05 time: 1.2799 data: 0.4896 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5228 data: 0.1603 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5402 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.045\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.099\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.037\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.219\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.056\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.093\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.308\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.275\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.185\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.069\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [62] [ 0/84] eta: 0:02:32 lr: 0.000013 loss: 36.7485 (36.7485) loss_vfl: 0.1570 (0.1570) loss_bbox: 0.1933 (0.1933) loss_giou: 1.6727 (1.6727) loss_fgl: 0.5062 (0.5062) loss_vfl_aux_0: 0.1727 (0.1727) loss_bbox_aux_0: 0.1968 (0.1968) loss_giou_aux_0: 1.6856 (1.6856) loss_fgl_aux_0: 0.5012 (0.5012) loss_ddf_aux_0: 0.2011 (0.2011) loss_vfl_aux_1: 0.1696 (0.1696) loss_bbox_aux_1: 0.1930 (0.1930) loss_giou_aux_1: 1.6761 (1.6761) loss_fgl_aux_1: 0.5047 (0.5047) loss_ddf_aux_1: 0.0268 (0.0268) loss_vfl_aux_2: 0.1661 (0.1661) loss_bbox_aux_2: 0.1936 (0.1936) loss_giou_aux_2: 1.6730 (1.6730) loss_fgl_aux_2: 0.5058 (0.5058) loss_ddf_aux_2: 0.0025 (0.0025) loss_vfl_aux_3: 0.1646 (0.1646) loss_bbox_aux_3: 0.1934 (0.1934) loss_giou_aux_3: 1.6728 (1.6728) loss_fgl_aux_3: 0.5061 (0.5061) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1588 (0.1588) loss_bbox_aux_4: 0.1934 (0.1934) loss_giou_aux_4: 1.6726 (1.6726) loss_fgl_aux_4: 0.5062 (0.5062) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1702 (0.1702) loss_bbox_pre: 0.2011 (0.2011) loss_giou_pre: 1.6807 (1.6807) loss_vfl_enc_0: 0.1608 (0.1608) loss_bbox_enc_0: 0.2220 (0.2220) loss_giou_enc_0: 1.7353 (1.7353) loss_vfl_dn_0: 0.4294 (0.4294) loss_bbox_dn_0: 0.0456 (0.0456) loss_giou_dn_0: 1.1259 (1.1259) loss_fgl_dn_0: 0.9655 (0.9655) loss_ddf_dn_0: 0.2766 (0.2766) loss_vfl_dn_1: 0.4597 (0.4597) loss_bbox_dn_1: 0.0394 (0.0394) loss_giou_dn_1: 1.0384 (1.0384) loss_fgl_dn_1: 0.9994 (0.9994) loss_ddf_dn_1: 0.0307 (0.0307) loss_vfl_dn_2: 0.4536 (0.4536) loss_bbox_dn_2: 0.0392 (0.0392) loss_giou_dn_2: 1.0291 (1.0291) loss_fgl_dn_2: 1.0055 (1.0055) loss_ddf_dn_2: 0.0024 (0.0024) loss_vfl_dn_3: 0.4517 (0.4517) loss_bbox_dn_3: 0.0391 (0.0391) loss_giou_dn_3: 1.0281 (1.0281) loss_fgl_dn_3: 1.0063 (1.0063) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4509 (0.4509) loss_bbox_dn_4: 0.0390 (0.0390) loss_giou_dn_4: 1.0277 (1.0277) loss_fgl_dn_4: 1.0066 (1.0066) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4482 (0.4482) loss_bbox_dn_5: 0.0390 (0.0390) loss_giou_dn_5: 1.0278 (1.0278) loss_fgl_dn_5: 1.0067 (1.0067) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4285 (0.4285) loss_bbox_dn_pre: 0.0455 (0.0455) loss_giou_dn_pre: 1.1266 (1.1266) time: 1.8204 data: 0.9389 max mem: 29821\n", + "Epoch: [62] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.1450 (37.5549) loss_vfl: 0.1462 (0.1643) loss_bbox: 0.2256 (0.2411) loss_giou: 1.7997 (1.7839) loss_fgl: 0.3936 (0.4329) loss_vfl_aux_0: 0.1534 (0.1724) loss_bbox_aux_0: 0.2319 (0.2463) loss_giou_aux_0: 1.8076 (1.7964) loss_fgl_aux_0: 0.3939 (0.4316) loss_ddf_aux_0: 0.1456 (0.1507) loss_vfl_aux_1: 0.1560 (0.1738) loss_bbox_aux_1: 0.2258 (0.2425) loss_giou_aux_1: 1.8002 (1.7854) loss_fgl_aux_1: 0.3935 (0.4321) loss_ddf_aux_1: 0.0202 (0.0218) loss_vfl_aux_2: 0.1504 (0.1716) loss_bbox_aux_2: 0.2255 (0.2415) loss_giou_aux_2: 1.7999 (1.7839) loss_fgl_aux_2: 0.3942 (0.4327) loss_ddf_aux_2: 0.0026 (0.0035) loss_vfl_aux_3: 0.1504 (0.1676) loss_bbox_aux_3: 0.2254 (0.2412) loss_giou_aux_3: 1.7998 (1.7837) loss_fgl_aux_3: 0.3939 (0.4329) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1471 (0.1648) loss_bbox_aux_4: 0.2254 (0.2411) loss_giou_aux_4: 1.7998 (1.7838) loss_fgl_aux_4: 0.3937 (0.4330) loss_ddf_aux_4: 0.0001 (0.0002) loss_vfl_pre: 0.1498 (0.1699) loss_bbox_pre: 0.2330 (0.2492) loss_giou_pre: 1.8041 (1.7925) loss_vfl_enc_0: 0.1483 (0.1670) loss_bbox_enc_0: 0.2618 (0.2710) loss_giou_enc_0: 1.8496 (1.8390) loss_vfl_dn_0: 0.4302 (0.4309) loss_bbox_dn_0: 0.0418 (0.0462) loss_giou_dn_0: 1.1371 (1.1396) loss_fgl_dn_0: 0.9466 (0.9538) loss_ddf_dn_0: 0.2381 (0.2775) loss_vfl_dn_1: 0.4631 (0.4663) loss_bbox_dn_1: 0.0342 (0.0371) loss_giou_dn_1: 1.0550 (1.0427) loss_fgl_dn_1: 0.9791 (0.9856) loss_ddf_dn_1: 0.0226 (0.0330) loss_vfl_dn_2: 0.4631 (0.4628) loss_bbox_dn_2: 0.0329 (0.0362) loss_giou_dn_2: 1.0457 (1.0342) loss_fgl_dn_2: 0.9809 (0.9891) loss_ddf_dn_2: 0.0027 (0.0042) loss_vfl_dn_3: 0.4607 (0.4593) loss_bbox_dn_3: 0.0329 (0.0361) loss_giou_dn_3: 1.0450 (1.0334) loss_fgl_dn_3: 0.9806 (0.9895) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4607 (0.4584) loss_bbox_dn_4: 0.0329 (0.0360) loss_giou_dn_4: 1.0448 (1.0334) loss_fgl_dn_4: 0.9805 (0.9896) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4607 (0.4584) loss_bbox_dn_5: 0.0329 (0.0361) loss_giou_dn_5: 1.0447 (1.0334) loss_fgl_dn_5: 0.9803 (0.9895) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4282 (0.4303) loss_bbox_dn_pre: 0.0415 (0.0462) loss_giou_dn_pre: 1.1348 (1.1399) time: 0.8692 data: 0.0178 max mem: 29821\n", + "Epoch: [62] Total time: 0:01:11 (0.8524 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.1450 (37.5549) loss_vfl: 0.1462 (0.1643) loss_bbox: 0.2256 (0.2411) loss_giou: 1.7997 (1.7839) loss_fgl: 0.3936 (0.4329) loss_vfl_aux_0: 0.1534 (0.1724) loss_bbox_aux_0: 0.2319 (0.2463) loss_giou_aux_0: 1.8076 (1.7964) loss_fgl_aux_0: 0.3939 (0.4316) loss_ddf_aux_0: 0.1456 (0.1507) loss_vfl_aux_1: 0.1560 (0.1738) loss_bbox_aux_1: 0.2258 (0.2425) loss_giou_aux_1: 1.8002 (1.7854) loss_fgl_aux_1: 0.3935 (0.4321) loss_ddf_aux_1: 0.0202 (0.0218) loss_vfl_aux_2: 0.1504 (0.1716) loss_bbox_aux_2: 0.2255 (0.2415) loss_giou_aux_2: 1.7999 (1.7839) loss_fgl_aux_2: 0.3942 (0.4327) loss_ddf_aux_2: 0.0026 (0.0035) loss_vfl_aux_3: 0.1504 (0.1676) loss_bbox_aux_3: 0.2254 (0.2412) loss_giou_aux_3: 1.7998 (1.7837) loss_fgl_aux_3: 0.3939 (0.4329) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1471 (0.1648) loss_bbox_aux_4: 0.2254 (0.2411) loss_giou_aux_4: 1.7998 (1.7838) loss_fgl_aux_4: 0.3937 (0.4330) loss_ddf_aux_4: 0.0001 (0.0002) loss_vfl_pre: 0.1498 (0.1699) loss_bbox_pre: 0.2330 (0.2492) loss_giou_pre: 1.8041 (1.7925) loss_vfl_enc_0: 0.1483 (0.1670) loss_bbox_enc_0: 0.2618 (0.2710) loss_giou_enc_0: 1.8496 (1.8390) loss_vfl_dn_0: 0.4302 (0.4309) loss_bbox_dn_0: 0.0418 (0.0462) loss_giou_dn_0: 1.1371 (1.1396) loss_fgl_dn_0: 0.9466 (0.9538) loss_ddf_dn_0: 0.2381 (0.2775) loss_vfl_dn_1: 0.4631 (0.4663) loss_bbox_dn_1: 0.0342 (0.0371) loss_giou_dn_1: 1.0550 (1.0427) loss_fgl_dn_1: 0.9791 (0.9856) loss_ddf_dn_1: 0.0226 (0.0330) loss_vfl_dn_2: 0.4631 (0.4628) loss_bbox_dn_2: 0.0329 (0.0362) loss_giou_dn_2: 1.0457 (1.0342) loss_fgl_dn_2: 0.9809 (0.9891) loss_ddf_dn_2: 0.0027 (0.0042) loss_vfl_dn_3: 0.4607 (0.4593) loss_bbox_dn_3: 0.0329 (0.0361) loss_giou_dn_3: 1.0450 (1.0334) loss_fgl_dn_3: 0.9806 (0.9895) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4607 (0.4584) loss_bbox_dn_4: 0.0329 (0.0360) loss_giou_dn_4: 1.0448 (1.0334) loss_fgl_dn_4: 0.9805 (0.9896) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4607 (0.4584) loss_bbox_dn_5: 0.0329 (0.0361) loss_giou_dn_5: 1.0447 (1.0334) loss_fgl_dn_5: 0.9803 (0.9895) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4282 (0.4303) loss_bbox_dn_pre: 0.0415 (0.0462) loss_giou_dn_pre: 1.1348 (1.1399)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7500 data: 0.5016 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3976 data: 0.1668 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4124 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.046\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.102\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.220\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.249\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.095\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.088\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.313\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.188\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.072\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [63] [ 0/84] eta: 0:02:25 lr: 0.000013 loss: 38.0043 (38.0043) loss_vfl: 0.2502 (0.2502) loss_bbox: 0.2465 (0.2465) loss_giou: 1.7076 (1.7076) loss_fgl: 0.5092 (0.5092) loss_vfl_aux_0: 0.2551 (0.2551) loss_bbox_aux_0: 0.2545 (0.2545) loss_giou_aux_0: 1.7119 (1.7119) loss_fgl_aux_0: 0.5039 (0.5039) loss_ddf_aux_0: 0.2026 (0.2026) loss_vfl_aux_1: 0.2603 (0.2603) loss_bbox_aux_1: 0.2482 (0.2482) loss_giou_aux_1: 1.7063 (1.7063) loss_fgl_aux_1: 0.5081 (0.5081) loss_ddf_aux_1: 0.0250 (0.0250) loss_vfl_aux_2: 0.2507 (0.2507) loss_bbox_aux_2: 0.2467 (0.2467) loss_giou_aux_2: 1.7067 (1.7067) loss_fgl_aux_2: 0.5087 (0.5087) loss_ddf_aux_2: 0.0035 (0.0035) loss_vfl_aux_3: 0.2500 (0.2500) loss_bbox_aux_3: 0.2467 (0.2467) loss_giou_aux_3: 1.7073 (1.7073) loss_fgl_aux_3: 0.5089 (0.5089) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.2515 (0.2515) loss_bbox_aux_4: 0.2465 (0.2465) loss_giou_aux_4: 1.7075 (1.7075) loss_fgl_aux_4: 0.5090 (0.5090) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.2534 (0.2534) loss_bbox_pre: 0.2576 (0.2576) loss_giou_pre: 1.7079 (1.7079) loss_vfl_enc_0: 0.2595 (0.2595) loss_bbox_enc_0: 0.2743 (0.2743) loss_giou_enc_0: 1.7552 (1.7552) loss_vfl_dn_0: 0.4409 (0.4409) loss_bbox_dn_0: 0.0550 (0.0550) loss_giou_dn_0: 1.0903 (1.0903) loss_fgl_dn_0: 0.9635 (0.9635) loss_ddf_dn_0: 0.3910 (0.3910) loss_vfl_dn_1: 0.4783 (0.4783) loss_bbox_dn_1: 0.0399 (0.0399) loss_giou_dn_1: 0.9706 (0.9706) loss_fgl_dn_1: 1.0043 (1.0043) loss_ddf_dn_1: 0.0262 (0.0262) loss_vfl_dn_2: 0.4680 (0.4680) loss_bbox_dn_2: 0.0387 (0.0387) loss_giou_dn_2: 0.9638 (0.9638) loss_fgl_dn_2: 1.0058 (1.0058) loss_ddf_dn_2: 0.0026 (0.0026) loss_vfl_dn_3: 0.4695 (0.4695) loss_bbox_dn_3: 0.0386 (0.0386) loss_giou_dn_3: 0.9633 (0.9633) loss_fgl_dn_3: 1.0060 (1.0060) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4731 (0.4731) loss_bbox_dn_4: 0.0385 (0.0385) loss_giou_dn_4: 0.9632 (0.9632) loss_fgl_dn_4: 1.0061 (1.0061) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4722 (0.4722) loss_bbox_dn_5: 0.0384 (0.0384) loss_giou_dn_5: 0.9632 (0.9632) loss_fgl_dn_5: 1.0060 (1.0060) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4409 (0.4409) loss_bbox_dn_pre: 0.0550 (0.0550) loss_giou_dn_pre: 1.0890 (1.0890) time: 1.7310 data: 0.9236 max mem: 29821\n", + "Epoch: [63] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.6530 (37.3604) loss_vfl: 0.1642 (0.1686) loss_bbox: 0.2409 (0.2340) loss_giou: 1.8176 (1.7631) loss_fgl: 0.4527 (0.4401) loss_vfl_aux_0: 0.1691 (0.1769) loss_bbox_aux_0: 0.2440 (0.2392) loss_giou_aux_0: 1.8293 (1.7758) loss_fgl_aux_0: 0.4492 (0.4380) loss_ddf_aux_0: 0.1168 (0.1309) loss_vfl_aux_1: 0.1711 (0.1780) loss_bbox_aux_1: 0.2435 (0.2360) loss_giou_aux_1: 1.8179 (1.7637) loss_fgl_aux_1: 0.4512 (0.4393) loss_ddf_aux_1: 0.0177 (0.0181) loss_vfl_aux_2: 0.1674 (0.1756) loss_bbox_aux_2: 0.2413 (0.2346) loss_giou_aux_2: 1.8174 (1.7629) loss_fgl_aux_2: 0.4516 (0.4399) loss_ddf_aux_2: 0.0028 (0.0028) loss_vfl_aux_3: 0.1649 (0.1708) loss_bbox_aux_3: 0.2411 (0.2344) loss_giou_aux_3: 1.8172 (1.7628) loss_fgl_aux_3: 0.4519 (0.4401) loss_ddf_aux_3: 0.0005 (0.0003) loss_vfl_aux_4: 0.1630 (0.1687) loss_bbox_aux_4: 0.2410 (0.2342) loss_giou_aux_4: 1.8172 (1.7629) loss_fgl_aux_4: 0.4522 (0.4401) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1660 (0.1746) loss_bbox_pre: 0.2498 (0.2419) loss_giou_pre: 1.8231 (1.7720) loss_vfl_enc_0: 0.1692 (0.1724) loss_bbox_enc_0: 0.2700 (0.2641) loss_giou_enc_0: 1.8433 (1.8199) loss_vfl_dn_0: 0.4321 (0.4298) loss_bbox_dn_0: 0.0485 (0.0466) loss_giou_dn_0: 1.1158 (1.1367) loss_fgl_dn_0: 0.9552 (0.9509) loss_ddf_dn_0: 0.3409 (0.3022) loss_vfl_dn_1: 0.4656 (0.4664) loss_bbox_dn_1: 0.0377 (0.0371) loss_giou_dn_1: 1.0318 (1.0376) loss_fgl_dn_1: 0.9835 (0.9830) loss_ddf_dn_1: 0.0319 (0.0338) loss_vfl_dn_2: 0.4639 (0.4622) loss_bbox_dn_2: 0.0369 (0.0360) loss_giou_dn_2: 1.0224 (1.0288) loss_fgl_dn_2: 0.9848 (0.9863) loss_ddf_dn_2: 0.0036 (0.0040) loss_vfl_dn_3: 0.4590 (0.4593) loss_bbox_dn_3: 0.0368 (0.0359) loss_giou_dn_3: 1.0223 (1.0281) loss_fgl_dn_3: 0.9851 (0.9866) loss_ddf_dn_3: 0.0006 (0.0005) loss_vfl_dn_4: 0.4592 (0.4584) loss_bbox_dn_4: 0.0367 (0.0358) loss_giou_dn_4: 1.0224 (1.0281) loss_fgl_dn_4: 0.9851 (0.9866) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4570 (0.4586) loss_bbox_dn_5: 0.0367 (0.0358) loss_giou_dn_5: 1.0225 (1.0281) loss_fgl_dn_5: 0.9851 (0.9866) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4312 (0.4290) loss_bbox_dn_pre: 0.0482 (0.0467) loss_giou_dn_pre: 1.1141 (1.1375) time: 0.8353 data: 0.0177 max mem: 29821\n", + "Epoch: [63] Total time: 0:01:11 (0.8521 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.6530 (37.3604) loss_vfl: 0.1642 (0.1686) loss_bbox: 0.2409 (0.2340) loss_giou: 1.8176 (1.7631) loss_fgl: 0.4527 (0.4401) loss_vfl_aux_0: 0.1691 (0.1769) loss_bbox_aux_0: 0.2440 (0.2392) loss_giou_aux_0: 1.8293 (1.7758) loss_fgl_aux_0: 0.4492 (0.4380) loss_ddf_aux_0: 0.1168 (0.1309) loss_vfl_aux_1: 0.1711 (0.1780) loss_bbox_aux_1: 0.2435 (0.2360) loss_giou_aux_1: 1.8179 (1.7637) loss_fgl_aux_1: 0.4512 (0.4393) loss_ddf_aux_1: 0.0177 (0.0181) loss_vfl_aux_2: 0.1674 (0.1756) loss_bbox_aux_2: 0.2413 (0.2346) loss_giou_aux_2: 1.8174 (1.7629) loss_fgl_aux_2: 0.4516 (0.4399) loss_ddf_aux_2: 0.0028 (0.0028) loss_vfl_aux_3: 0.1649 (0.1708) loss_bbox_aux_3: 0.2411 (0.2344) loss_giou_aux_3: 1.8172 (1.7628) loss_fgl_aux_3: 0.4519 (0.4401) loss_ddf_aux_3: 0.0005 (0.0003) loss_vfl_aux_4: 0.1630 (0.1687) loss_bbox_aux_4: 0.2410 (0.2342) loss_giou_aux_4: 1.8172 (1.7629) loss_fgl_aux_4: 0.4522 (0.4401) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1660 (0.1746) loss_bbox_pre: 0.2498 (0.2419) loss_giou_pre: 1.8231 (1.7720) loss_vfl_enc_0: 0.1692 (0.1724) loss_bbox_enc_0: 0.2700 (0.2641) loss_giou_enc_0: 1.8433 (1.8199) loss_vfl_dn_0: 0.4321 (0.4298) loss_bbox_dn_0: 0.0485 (0.0466) loss_giou_dn_0: 1.1158 (1.1367) loss_fgl_dn_0: 0.9552 (0.9509) loss_ddf_dn_0: 0.3409 (0.3022) loss_vfl_dn_1: 0.4656 (0.4664) loss_bbox_dn_1: 0.0377 (0.0371) loss_giou_dn_1: 1.0318 (1.0376) loss_fgl_dn_1: 0.9835 (0.9830) loss_ddf_dn_1: 0.0319 (0.0338) loss_vfl_dn_2: 0.4639 (0.4622) loss_bbox_dn_2: 0.0369 (0.0360) loss_giou_dn_2: 1.0224 (1.0288) loss_fgl_dn_2: 0.9848 (0.9863) loss_ddf_dn_2: 0.0036 (0.0040) loss_vfl_dn_3: 0.4590 (0.4593) loss_bbox_dn_3: 0.0368 (0.0359) loss_giou_dn_3: 1.0223 (1.0281) loss_fgl_dn_3: 0.9851 (0.9866) loss_ddf_dn_3: 0.0006 (0.0005) loss_vfl_dn_4: 0.4592 (0.4584) loss_bbox_dn_4: 0.0367 (0.0358) loss_giou_dn_4: 1.0224 (1.0281) loss_fgl_dn_4: 0.9851 (0.9866) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4570 (0.4586) loss_bbox_dn_5: 0.0367 (0.0358) loss_giou_dn_5: 1.0225 (1.0281) loss_fgl_dn_5: 0.9851 (0.9866) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4312 (0.4290) loss_bbox_dn_pre: 0.0482 (0.0467) loss_giou_dn_pre: 1.1141 (1.1375)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7435 data: 0.4962 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3994 data: 0.1707 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4144 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.046\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.103\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.228\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.243\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.072\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.092\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.086\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.315\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.450\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.187\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.049\n", + "best_stat: {'epoch': 58, 'coco_eval_bbox': 0.046290457162162124}\n", + "Epoch: [64] [ 0/84] eta: 0:02:45 lr: 0.000013 loss: 39.6094 (39.6094) loss_vfl: 0.2659 (0.2659) loss_bbox: 0.3159 (0.3159) loss_giou: 1.7302 (1.7302) loss_fgl: 0.6014 (0.6014) loss_vfl_aux_0: 0.2732 (0.2732) loss_bbox_aux_0: 0.3161 (0.3161) loss_giou_aux_0: 1.7431 (1.7431) loss_fgl_aux_0: 0.5976 (0.5976) loss_ddf_aux_0: 0.1273 (0.1273) loss_vfl_aux_1: 0.2791 (0.2791) loss_bbox_aux_1: 0.3163 (0.3163) loss_giou_aux_1: 1.7321 (1.7321) loss_fgl_aux_1: 0.5992 (0.5992) loss_ddf_aux_1: 0.0201 (0.0201) loss_vfl_aux_2: 0.2812 (0.2812) loss_bbox_aux_2: 0.3159 (0.3159) loss_giou_aux_2: 1.7305 (1.7305) loss_fgl_aux_2: 0.6006 (0.6006) loss_ddf_aux_2: 0.0030 (0.0030) loss_vfl_aux_3: 0.2734 (0.2734) loss_bbox_aux_3: 0.3158 (0.3158) loss_giou_aux_3: 1.7306 (1.7306) loss_fgl_aux_3: 0.6009 (0.6009) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.2671 (0.2671) loss_bbox_aux_4: 0.3159 (0.3159) loss_giou_aux_4: 1.7300 (1.7300) loss_fgl_aux_4: 0.6013 (0.6013) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2725 (0.2725) loss_bbox_pre: 0.3182 (0.3182) loss_giou_pre: 1.7356 (1.7356) loss_vfl_enc_0: 0.2773 (0.2773) loss_bbox_enc_0: 0.3314 (0.3314) loss_giou_enc_0: 1.7611 (1.7611) loss_vfl_dn_0: 0.4487 (0.4487) loss_bbox_dn_0: 0.0586 (0.0586) loss_giou_dn_0: 1.0746 (1.0746) loss_fgl_dn_0: 1.0051 (1.0051) loss_ddf_dn_0: 0.4233 (0.4233) loss_vfl_dn_1: 0.4888 (0.4888) loss_bbox_dn_1: 0.0501 (0.0501) loss_giou_dn_1: 0.9535 (0.9535) loss_fgl_dn_1: 1.0425 (1.0425) loss_ddf_dn_1: 0.0313 (0.0313) loss_vfl_dn_2: 0.4834 (0.4834) loss_bbox_dn_2: 0.0484 (0.0484) loss_giou_dn_2: 0.9396 (0.9396) loss_fgl_dn_2: 1.0468 (1.0468) loss_ddf_dn_2: 0.0031 (0.0031) loss_vfl_dn_3: 0.4846 (0.4846) loss_bbox_dn_3: 0.0481 (0.0481) loss_giou_dn_3: 0.9381 (0.9381) loss_fgl_dn_3: 1.0476 (1.0476) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4824 (0.4824) loss_bbox_dn_4: 0.0482 (0.0482) loss_giou_dn_4: 0.9375 (0.9375) loss_fgl_dn_4: 1.0478 (1.0478) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4807 (0.4807) loss_bbox_dn_5: 0.0482 (0.0482) loss_giou_dn_5: 0.9375 (0.9375) loss_fgl_dn_5: 1.0478 (1.0478) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4475 (0.4475) loss_bbox_dn_pre: 0.0585 (0.0585) loss_giou_dn_pre: 1.0763 (1.0763) time: 1.9752 data: 1.1182 max mem: 29821\n", + "Epoch: [64] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.1240 (37.5559) loss_vfl: 0.1431 (0.1674) loss_bbox: 0.2261 (0.2430) loss_giou: 1.8231 (1.7851) loss_fgl: 0.3995 (0.4275) loss_vfl_aux_0: 0.1500 (0.1750) loss_bbox_aux_0: 0.2334 (0.2487) loss_giou_aux_0: 1.8312 (1.7944) loss_fgl_aux_0: 0.3969 (0.4267) loss_ddf_aux_0: 0.1300 (0.1427) loss_vfl_aux_1: 0.1489 (0.1764) loss_bbox_aux_1: 0.2280 (0.2443) loss_giou_aux_1: 1.8244 (1.7855) loss_fgl_aux_1: 0.3997 (0.4269) loss_ddf_aux_1: 0.0108 (0.0176) loss_vfl_aux_2: 0.1462 (0.1742) loss_bbox_aux_2: 0.2269 (0.2435) loss_giou_aux_2: 1.8228 (1.7848) loss_fgl_aux_2: 0.3992 (0.4272) loss_ddf_aux_2: 0.0013 (0.0024) loss_vfl_aux_3: 0.1428 (0.1701) loss_bbox_aux_3: 0.2266 (0.2432) loss_giou_aux_3: 1.8226 (1.7848) loss_fgl_aux_3: 0.3993 (0.4274) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1439 (0.1680) loss_bbox_aux_4: 0.2262 (0.2430) loss_giou_aux_4: 1.8230 (1.7850) loss_fgl_aux_4: 0.3995 (0.4275) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1486 (0.1727) loss_bbox_pre: 0.2347 (0.2511) loss_giou_pre: 1.8279 (1.7913) loss_vfl_enc_0: 0.1464 (0.1705) loss_bbox_enc_0: 0.2579 (0.2730) loss_giou_enc_0: 1.8565 (1.8398) loss_vfl_dn_0: 0.4211 (0.4292) loss_bbox_dn_0: 0.0415 (0.0454) loss_giou_dn_0: 1.1646 (1.1440) loss_fgl_dn_0: 0.9459 (0.9514) loss_ddf_dn_0: 0.2984 (0.3180) loss_vfl_dn_1: 0.4622 (0.4660) loss_bbox_dn_1: 0.0331 (0.0365) loss_giou_dn_1: 1.0662 (1.0418) loss_fgl_dn_1: 0.9744 (0.9812) loss_ddf_dn_1: 0.0195 (0.0317) loss_vfl_dn_2: 0.4558 (0.4620) loss_bbox_dn_2: 0.0328 (0.0356) loss_giou_dn_2: 1.0575 (1.0338) loss_fgl_dn_2: 0.9756 (0.9843) loss_ddf_dn_2: 0.0022 (0.0030) loss_vfl_dn_3: 0.4521 (0.4584) loss_bbox_dn_3: 0.0323 (0.0354) loss_giou_dn_3: 1.0566 (1.0330) loss_fgl_dn_3: 0.9763 (0.9847) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4531 (0.4572) loss_bbox_dn_4: 0.0323 (0.0354) loss_giou_dn_4: 1.0566 (1.0329) loss_fgl_dn_4: 0.9765 (0.9847) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4570) loss_bbox_dn_5: 0.0323 (0.0354) loss_giou_dn_5: 1.0567 (1.0330) loss_fgl_dn_5: 0.9763 (0.9847) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4202 (0.4288) loss_bbox_dn_pre: 0.0414 (0.0453) loss_giou_dn_pre: 1.1679 (1.1443) time: 0.8627 data: 0.0197 max mem: 29821\n", + "Epoch: [64] Total time: 0:01:11 (0.8525 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.1240 (37.5559) loss_vfl: 0.1431 (0.1674) loss_bbox: 0.2261 (0.2430) loss_giou: 1.8231 (1.7851) loss_fgl: 0.3995 (0.4275) loss_vfl_aux_0: 0.1500 (0.1750) loss_bbox_aux_0: 0.2334 (0.2487) loss_giou_aux_0: 1.8312 (1.7944) loss_fgl_aux_0: 0.3969 (0.4267) loss_ddf_aux_0: 0.1300 (0.1427) loss_vfl_aux_1: 0.1489 (0.1764) loss_bbox_aux_1: 0.2280 (0.2443) loss_giou_aux_1: 1.8244 (1.7855) loss_fgl_aux_1: 0.3997 (0.4269) loss_ddf_aux_1: 0.0108 (0.0176) loss_vfl_aux_2: 0.1462 (0.1742) loss_bbox_aux_2: 0.2269 (0.2435) loss_giou_aux_2: 1.8228 (1.7848) loss_fgl_aux_2: 0.3992 (0.4272) loss_ddf_aux_2: 0.0013 (0.0024) loss_vfl_aux_3: 0.1428 (0.1701) loss_bbox_aux_3: 0.2266 (0.2432) loss_giou_aux_3: 1.8226 (1.7848) loss_fgl_aux_3: 0.3993 (0.4274) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1439 (0.1680) loss_bbox_aux_4: 0.2262 (0.2430) loss_giou_aux_4: 1.8230 (1.7850) loss_fgl_aux_4: 0.3995 (0.4275) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1486 (0.1727) loss_bbox_pre: 0.2347 (0.2511) loss_giou_pre: 1.8279 (1.7913) loss_vfl_enc_0: 0.1464 (0.1705) loss_bbox_enc_0: 0.2579 (0.2730) loss_giou_enc_0: 1.8565 (1.8398) loss_vfl_dn_0: 0.4211 (0.4292) loss_bbox_dn_0: 0.0415 (0.0454) loss_giou_dn_0: 1.1646 (1.1440) loss_fgl_dn_0: 0.9459 (0.9514) loss_ddf_dn_0: 0.2984 (0.3180) loss_vfl_dn_1: 0.4622 (0.4660) loss_bbox_dn_1: 0.0331 (0.0365) loss_giou_dn_1: 1.0662 (1.0418) loss_fgl_dn_1: 0.9744 (0.9812) loss_ddf_dn_1: 0.0195 (0.0317) loss_vfl_dn_2: 0.4558 (0.4620) loss_bbox_dn_2: 0.0328 (0.0356) loss_giou_dn_2: 1.0575 (1.0338) loss_fgl_dn_2: 0.9756 (0.9843) loss_ddf_dn_2: 0.0022 (0.0030) loss_vfl_dn_3: 0.4521 (0.4584) loss_bbox_dn_3: 0.0323 (0.0354) loss_giou_dn_3: 1.0566 (1.0330) loss_fgl_dn_3: 0.9763 (0.9847) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4531 (0.4572) loss_bbox_dn_4: 0.0323 (0.0354) loss_giou_dn_4: 1.0566 (1.0329) loss_fgl_dn_4: 0.9765 (0.9847) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4570) loss_bbox_dn_5: 0.0323 (0.0354) loss_giou_dn_5: 1.0567 (1.0330) loss_fgl_dn_5: 0.9763 (0.9847) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4202 (0.4288) loss_bbox_dn_pre: 0.0414 (0.0453) loss_giou_dn_pre: 1.1679 (1.1443)\n", + "Test: [0/4] eta: 0:00:03 time: 0.8023 data: 0.5548 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4145 data: 0.1817 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4302 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.047\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.104\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.039\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.230\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.262\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.020\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.094\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.321\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.475\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.189\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.053\n", + "best_stat: {'epoch': 64, 'coco_eval_bbox': 0.047491897575043886}\n", + "Epoch: [65] [ 0/84] eta: 0:02:46 lr: 0.000013 loss: 35.8682 (35.8682) loss_vfl: 0.1337 (0.1337) loss_bbox: 0.1787 (0.1787) loss_giou: 1.6119 (1.6119) loss_fgl: 0.5164 (0.5164) loss_vfl_aux_0: 0.1398 (0.1398) loss_bbox_aux_0: 0.1886 (0.1886) loss_giou_aux_0: 1.6241 (1.6241) loss_fgl_aux_0: 0.5139 (0.5139) loss_ddf_aux_0: 0.1123 (0.1123) loss_vfl_aux_1: 0.1418 (0.1418) loss_bbox_aux_1: 0.1807 (0.1807) loss_giou_aux_1: 1.6135 (1.6135) loss_fgl_aux_1: 0.5160 (0.5160) loss_ddf_aux_1: 0.0079 (0.0079) loss_vfl_aux_2: 0.1403 (0.1403) loss_bbox_aux_2: 0.1794 (0.1794) loss_giou_aux_2: 1.6120 (1.6120) loss_fgl_aux_2: 0.5162 (0.5162) loss_ddf_aux_2: 0.0011 (0.0011) loss_vfl_aux_3: 0.1356 (0.1356) loss_bbox_aux_3: 0.1790 (0.1790) loss_giou_aux_3: 1.6120 (1.6120) loss_fgl_aux_3: 0.5163 (0.5163) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1331 (0.1331) loss_bbox_aux_4: 0.1787 (0.1787) loss_giou_aux_4: 1.6120 (1.6120) loss_fgl_aux_4: 0.5165 (0.5165) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1384 (0.1384) loss_bbox_pre: 0.1925 (0.1925) loss_giou_pre: 1.6195 (1.6195) loss_vfl_enc_0: 0.1433 (0.1433) loss_bbox_enc_0: 0.2151 (0.2151) loss_giou_enc_0: 1.6612 (1.6612) loss_vfl_dn_0: 0.4138 (0.4138) loss_bbox_dn_0: 0.0509 (0.0509) loss_giou_dn_0: 1.1910 (1.1910) loss_fgl_dn_0: 0.9406 (0.9406) loss_ddf_dn_0: 0.2470 (0.2470) loss_vfl_dn_1: 0.4561 (0.4561) loss_bbox_dn_1: 0.0400 (0.0400) loss_giou_dn_1: 1.0628 (1.0628) loss_fgl_dn_1: 0.9681 (0.9681) loss_ddf_dn_1: 0.0143 (0.0143) loss_vfl_dn_2: 0.4473 (0.4473) loss_bbox_dn_2: 0.0388 (0.0388) loss_giou_dn_2: 1.0587 (1.0587) loss_fgl_dn_2: 0.9689 (0.9689) loss_ddf_dn_2: 0.0019 (0.0019) loss_vfl_dn_3: 0.4434 (0.4434) loss_bbox_dn_3: 0.0386 (0.0386) loss_giou_dn_3: 1.0581 (1.0581) loss_fgl_dn_3: 0.9689 (0.9689) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4463 (0.4463) loss_bbox_dn_4: 0.0386 (0.0386) loss_giou_dn_4: 1.0579 (1.0579) loss_fgl_dn_4: 0.9688 (0.9688) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4473 (0.4473) loss_bbox_dn_5: 0.0386 (0.0386) loss_giou_dn_5: 1.0579 (1.0579) loss_fgl_dn_5: 0.9688 (0.9688) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4141 (0.4141) loss_bbox_dn_pre: 0.0505 (0.0505) loss_giou_dn_pre: 1.1884 (1.1884) time: 1.9795 data: 1.0663 max mem: 29821\n", + "Epoch: [65] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.4764 (37.5716) loss_vfl: 0.1611 (0.1586) loss_bbox: 0.2146 (0.2547) loss_giou: 1.7966 (1.7941) loss_fgl: 0.4100 (0.4240) loss_vfl_aux_0: 0.1637 (0.1654) loss_bbox_aux_0: 0.2185 (0.2594) loss_giou_aux_0: 1.8005 (1.8064) loss_fgl_aux_0: 0.4108 (0.4243) loss_ddf_aux_0: 0.1227 (0.1410) loss_vfl_aux_1: 0.1649 (0.1666) loss_bbox_aux_1: 0.2170 (0.2555) loss_giou_aux_1: 1.7988 (1.7960) loss_fgl_aux_1: 0.4109 (0.4243) loss_ddf_aux_1: 0.0240 (0.0207) loss_vfl_aux_2: 0.1649 (0.1651) loss_bbox_aux_2: 0.2148 (0.2550) loss_giou_aux_2: 1.7972 (1.7941) loss_fgl_aux_2: 0.4103 (0.4240) loss_ddf_aux_2: 0.0031 (0.0028) loss_vfl_aux_3: 0.1611 (0.1613) loss_bbox_aux_3: 0.2146 (0.2547) loss_giou_aux_3: 1.7969 (1.7941) loss_fgl_aux_3: 0.4100 (0.4241) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1599 (0.1592) loss_bbox_aux_4: 0.2145 (0.2547) loss_giou_aux_4: 1.7967 (1.7941) loss_fgl_aux_4: 0.4100 (0.4240) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1609 (0.1629) loss_bbox_pre: 0.2199 (0.2623) loss_giou_pre: 1.7969 (1.8019) loss_vfl_enc_0: 0.1562 (0.1610) loss_bbox_enc_0: 0.2471 (0.2864) loss_giou_enc_0: 1.8211 (1.8477) loss_vfl_dn_0: 0.4346 (0.4315) loss_bbox_dn_0: 0.0411 (0.0439) loss_giou_dn_0: 1.1241 (1.1383) loss_fgl_dn_0: 0.9623 (0.9550) loss_ddf_dn_0: 0.2819 (0.2546) loss_vfl_dn_1: 0.4692 (0.4650) loss_bbox_dn_1: 0.0322 (0.0360) loss_giou_dn_1: 1.0353 (1.0464) loss_fgl_dn_1: 0.9836 (0.9793) loss_ddf_dn_1: 0.0349 (0.0291) loss_vfl_dn_2: 0.4639 (0.4616) loss_bbox_dn_2: 0.0315 (0.0351) loss_giou_dn_2: 1.0240 (1.0381) loss_fgl_dn_2: 0.9863 (0.9815) loss_ddf_dn_2: 0.0024 (0.0030) loss_vfl_dn_3: 0.4602 (0.4591) loss_bbox_dn_3: 0.0314 (0.0350) loss_giou_dn_3: 1.0226 (1.0375) loss_fgl_dn_3: 0.9860 (0.9817) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4595 (0.4584) loss_bbox_dn_4: 0.0314 (0.0350) loss_giou_dn_4: 1.0227 (1.0374) loss_fgl_dn_4: 0.9860 (0.9818) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4600 (0.4586) loss_bbox_dn_5: 0.0314 (0.0350) loss_giou_dn_5: 1.0227 (1.0374) loss_fgl_dn_5: 0.9861 (0.9818) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4336 (0.4308) loss_bbox_dn_pre: 0.0411 (0.0440) loss_giou_dn_pre: 1.1257 (1.1387) time: 0.8332 data: 0.0171 max mem: 29821\n", + "Epoch: [65] Total time: 0:01:12 (0.8658 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.4764 (37.5716) loss_vfl: 0.1611 (0.1586) loss_bbox: 0.2146 (0.2547) loss_giou: 1.7966 (1.7941) loss_fgl: 0.4100 (0.4240) loss_vfl_aux_0: 0.1637 (0.1654) loss_bbox_aux_0: 0.2185 (0.2594) loss_giou_aux_0: 1.8005 (1.8064) loss_fgl_aux_0: 0.4108 (0.4243) loss_ddf_aux_0: 0.1227 (0.1410) loss_vfl_aux_1: 0.1649 (0.1666) loss_bbox_aux_1: 0.2170 (0.2555) loss_giou_aux_1: 1.7988 (1.7960) loss_fgl_aux_1: 0.4109 (0.4243) loss_ddf_aux_1: 0.0240 (0.0207) loss_vfl_aux_2: 0.1649 (0.1651) loss_bbox_aux_2: 0.2148 (0.2550) loss_giou_aux_2: 1.7972 (1.7941) loss_fgl_aux_2: 0.4103 (0.4240) loss_ddf_aux_2: 0.0031 (0.0028) loss_vfl_aux_3: 0.1611 (0.1613) loss_bbox_aux_3: 0.2146 (0.2547) loss_giou_aux_3: 1.7969 (1.7941) loss_fgl_aux_3: 0.4100 (0.4241) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1599 (0.1592) loss_bbox_aux_4: 0.2145 (0.2547) loss_giou_aux_4: 1.7967 (1.7941) loss_fgl_aux_4: 0.4100 (0.4240) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1609 (0.1629) loss_bbox_pre: 0.2199 (0.2623) loss_giou_pre: 1.7969 (1.8019) loss_vfl_enc_0: 0.1562 (0.1610) loss_bbox_enc_0: 0.2471 (0.2864) loss_giou_enc_0: 1.8211 (1.8477) loss_vfl_dn_0: 0.4346 (0.4315) loss_bbox_dn_0: 0.0411 (0.0439) loss_giou_dn_0: 1.1241 (1.1383) loss_fgl_dn_0: 0.9623 (0.9550) loss_ddf_dn_0: 0.2819 (0.2546) loss_vfl_dn_1: 0.4692 (0.4650) loss_bbox_dn_1: 0.0322 (0.0360) loss_giou_dn_1: 1.0353 (1.0464) loss_fgl_dn_1: 0.9836 (0.9793) loss_ddf_dn_1: 0.0349 (0.0291) loss_vfl_dn_2: 0.4639 (0.4616) loss_bbox_dn_2: 0.0315 (0.0351) loss_giou_dn_2: 1.0240 (1.0381) loss_fgl_dn_2: 0.9863 (0.9815) loss_ddf_dn_2: 0.0024 (0.0030) loss_vfl_dn_3: 0.4602 (0.4591) loss_bbox_dn_3: 0.0314 (0.0350) loss_giou_dn_3: 1.0226 (1.0375) loss_fgl_dn_3: 0.9860 (0.9817) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4595 (0.4584) loss_bbox_dn_4: 0.0314 (0.0350) loss_giou_dn_4: 1.0227 (1.0374) loss_fgl_dn_4: 0.9860 (0.9818) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4600 (0.4586) loss_bbox_dn_5: 0.0314 (0.0350) loss_giou_dn_5: 1.0227 (1.0374) loss_fgl_dn_5: 0.9861 (0.9818) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4336 (0.4308) loss_bbox_dn_pre: 0.0411 (0.0440) loss_giou_dn_pre: 1.1257 (1.1387)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7426 data: 0.4965 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3978 data: 0.1667 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4137 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.050\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.108\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.042\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.232\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.186\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.024\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.096\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.308\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.500\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.190\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.072\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [66] [ 0/84] eta: 0:02:23 lr: 0.000013 loss: 36.0707 (36.0707) loss_vfl: 0.1888 (0.1888) loss_bbox: 0.1631 (0.1631) loss_giou: 1.6325 (1.6325) loss_fgl: 0.4800 (0.4800) loss_vfl_aux_0: 0.2075 (0.2075) loss_bbox_aux_0: 0.1670 (0.1670) loss_giou_aux_0: 1.6393 (1.6393) loss_fgl_aux_0: 0.4846 (0.4846) loss_ddf_aux_0: 0.1231 (0.1231) loss_vfl_aux_1: 0.2026 (0.2026) loss_bbox_aux_1: 0.1641 (0.1641) loss_giou_aux_1: 1.6341 (1.6341) loss_fgl_aux_1: 0.4811 (0.4811) loss_ddf_aux_1: 0.0187 (0.0187) loss_vfl_aux_2: 0.2001 (0.2001) loss_bbox_aux_2: 0.1634 (0.1634) loss_giou_aux_2: 1.6322 (1.6322) loss_fgl_aux_2: 0.4802 (0.4802) loss_ddf_aux_2: 0.0020 (0.0020) loss_vfl_aux_3: 0.1945 (0.1945) loss_bbox_aux_3: 0.1632 (0.1632) loss_giou_aux_3: 1.6326 (1.6326) loss_fgl_aux_3: 0.4799 (0.4799) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1915 (0.1915) loss_bbox_aux_4: 0.1630 (0.1630) loss_giou_aux_4: 1.6326 (1.6326) loss_fgl_aux_4: 0.4800 (0.4800) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2042 (0.2042) loss_bbox_pre: 0.1706 (0.1706) loss_giou_pre: 1.6348 (1.6348) loss_vfl_enc_0: 0.2028 (0.2028) loss_bbox_enc_0: 0.1959 (0.1959) loss_giou_enc_0: 1.6897 (1.6897) loss_vfl_dn_0: 0.4490 (0.4490) loss_bbox_dn_0: 0.0384 (0.0384) loss_giou_dn_0: 1.0868 (1.0868) loss_fgl_dn_0: 0.9829 (0.9829) loss_ddf_dn_0: 0.3475 (0.3475) loss_vfl_dn_1: 0.4736 (0.4736) loss_bbox_dn_1: 0.0319 (0.0319) loss_giou_dn_1: 0.9969 (0.9969) loss_fgl_dn_1: 0.9981 (0.9981) loss_ddf_dn_1: 0.0339 (0.0339) loss_vfl_dn_2: 0.4709 (0.4709) loss_bbox_dn_2: 0.0308 (0.0308) loss_giou_dn_2: 0.9890 (0.9890) loss_fgl_dn_2: 0.9999 (0.9999) loss_ddf_dn_2: 0.0035 (0.0035) loss_vfl_dn_3: 0.4692 (0.4692) loss_bbox_dn_3: 0.0307 (0.0307) loss_giou_dn_3: 0.9886 (0.9886) loss_fgl_dn_3: 1.0004 (1.0004) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4670 (0.4670) loss_bbox_dn_4: 0.0307 (0.0307) loss_giou_dn_4: 0.9885 (0.9885) loss_fgl_dn_4: 1.0006 (1.0006) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4666 (0.4666) loss_bbox_dn_5: 0.0307 (0.0307) loss_giou_dn_5: 0.9885 (0.9885) loss_fgl_dn_5: 1.0007 (1.0007) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4482 (0.4482) loss_bbox_dn_pre: 0.0385 (0.0385) loss_giou_dn_pre: 1.0878 (1.0878) time: 1.7135 data: 0.8702 max mem: 29821\n", + "Epoch: [66] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.9712 (37.5308) loss_vfl: 0.1460 (0.1624) loss_bbox: 0.2416 (0.2487) loss_giou: 1.7501 (1.7829) loss_fgl: 0.4226 (0.4302) loss_vfl_aux_0: 0.1564 (0.1703) loss_bbox_aux_0: 0.2480 (0.2533) loss_giou_aux_0: 1.7506 (1.7956) loss_fgl_aux_0: 0.4221 (0.4302) loss_ddf_aux_0: 0.1213 (0.1338) loss_vfl_aux_1: 0.1592 (0.1724) loss_bbox_aux_1: 0.2443 (0.2494) loss_giou_aux_1: 1.7531 (1.7848) loss_fgl_aux_1: 0.4229 (0.4303) loss_ddf_aux_1: 0.0237 (0.0210) loss_vfl_aux_2: 0.1556 (0.1703) loss_bbox_aux_2: 0.2429 (0.2488) loss_giou_aux_2: 1.7519 (1.7833) loss_fgl_aux_2: 0.4222 (0.4301) loss_ddf_aux_2: 0.0035 (0.0031) loss_vfl_aux_3: 0.1517 (0.1662) loss_bbox_aux_3: 0.2419 (0.2486) loss_giou_aux_3: 1.7509 (1.7831) loss_fgl_aux_3: 0.4225 (0.4302) loss_ddf_aux_3: 0.0003 (0.0002) loss_vfl_aux_4: 0.1477 (0.1631) loss_bbox_aux_4: 0.2416 (0.2486) loss_giou_aux_4: 1.7503 (1.7830) loss_fgl_aux_4: 0.4226 (0.4302) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1533 (0.1675) loss_bbox_pre: 0.2527 (0.2569) loss_giou_pre: 1.7448 (1.7902) loss_vfl_enc_0: 0.1447 (0.1662) loss_bbox_enc_0: 0.2758 (0.2806) loss_giou_enc_0: 1.8191 (1.8409) loss_vfl_dn_0: 0.4368 (0.4280) loss_bbox_dn_0: 0.0399 (0.0448) loss_giou_dn_0: 1.1240 (1.1401) loss_fgl_dn_0: 0.9629 (0.9490) loss_ddf_dn_0: 0.2583 (0.3066) loss_vfl_dn_1: 0.4670 (0.4662) loss_bbox_dn_1: 0.0341 (0.0361) loss_giou_dn_1: 1.0451 (1.0409) loss_fgl_dn_1: 0.9830 (0.9784) loss_ddf_dn_1: 0.0369 (0.0368) loss_vfl_dn_2: 0.4609 (0.4615) loss_bbox_dn_2: 0.0338 (0.0352) loss_giou_dn_2: 1.0424 (1.0335) loss_fgl_dn_2: 0.9873 (0.9805) loss_ddf_dn_2: 0.0045 (0.0040) loss_vfl_dn_3: 0.4580 (0.4588) loss_bbox_dn_3: 0.0333 (0.0351) loss_giou_dn_3: 1.0428 (1.0329) loss_fgl_dn_3: 0.9879 (0.9808) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4580 (0.4575) loss_bbox_dn_4: 0.0332 (0.0351) loss_giou_dn_4: 1.0427 (1.0329) loss_fgl_dn_4: 0.9879 (0.9808) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4546 (0.4575) loss_bbox_dn_5: 0.0332 (0.0351) loss_giou_dn_5: 1.0428 (1.0329) loss_fgl_dn_5: 0.9879 (0.9808) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4355 (0.4269) loss_bbox_dn_pre: 0.0400 (0.0450) loss_giou_dn_pre: 1.1253 (1.1405) time: 0.8567 data: 0.0178 max mem: 29821\n", + "Epoch: [66] Total time: 0:01:11 (0.8466 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.9712 (37.5308) loss_vfl: 0.1460 (0.1624) loss_bbox: 0.2416 (0.2487) loss_giou: 1.7501 (1.7829) loss_fgl: 0.4226 (0.4302) loss_vfl_aux_0: 0.1564 (0.1703) loss_bbox_aux_0: 0.2480 (0.2533) loss_giou_aux_0: 1.7506 (1.7956) loss_fgl_aux_0: 0.4221 (0.4302) loss_ddf_aux_0: 0.1213 (0.1338) loss_vfl_aux_1: 0.1592 (0.1724) loss_bbox_aux_1: 0.2443 (0.2494) loss_giou_aux_1: 1.7531 (1.7848) loss_fgl_aux_1: 0.4229 (0.4303) loss_ddf_aux_1: 0.0237 (0.0210) loss_vfl_aux_2: 0.1556 (0.1703) loss_bbox_aux_2: 0.2429 (0.2488) loss_giou_aux_2: 1.7519 (1.7833) loss_fgl_aux_2: 0.4222 (0.4301) loss_ddf_aux_2: 0.0035 (0.0031) loss_vfl_aux_3: 0.1517 (0.1662) loss_bbox_aux_3: 0.2419 (0.2486) loss_giou_aux_3: 1.7509 (1.7831) loss_fgl_aux_3: 0.4225 (0.4302) loss_ddf_aux_3: 0.0003 (0.0002) loss_vfl_aux_4: 0.1477 (0.1631) loss_bbox_aux_4: 0.2416 (0.2486) loss_giou_aux_4: 1.7503 (1.7830) loss_fgl_aux_4: 0.4226 (0.4302) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1533 (0.1675) loss_bbox_pre: 0.2527 (0.2569) loss_giou_pre: 1.7448 (1.7902) loss_vfl_enc_0: 0.1447 (0.1662) loss_bbox_enc_0: 0.2758 (0.2806) loss_giou_enc_0: 1.8191 (1.8409) loss_vfl_dn_0: 0.4368 (0.4280) loss_bbox_dn_0: 0.0399 (0.0448) loss_giou_dn_0: 1.1240 (1.1401) loss_fgl_dn_0: 0.9629 (0.9490) loss_ddf_dn_0: 0.2583 (0.3066) loss_vfl_dn_1: 0.4670 (0.4662) loss_bbox_dn_1: 0.0341 (0.0361) loss_giou_dn_1: 1.0451 (1.0409) loss_fgl_dn_1: 0.9830 (0.9784) loss_ddf_dn_1: 0.0369 (0.0368) loss_vfl_dn_2: 0.4609 (0.4615) loss_bbox_dn_2: 0.0338 (0.0352) loss_giou_dn_2: 1.0424 (1.0335) loss_fgl_dn_2: 0.9873 (0.9805) loss_ddf_dn_2: 0.0045 (0.0040) loss_vfl_dn_3: 0.4580 (0.4588) loss_bbox_dn_3: 0.0333 (0.0351) loss_giou_dn_3: 1.0428 (1.0329) loss_fgl_dn_3: 0.9879 (0.9808) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4580 (0.4575) loss_bbox_dn_4: 0.0332 (0.0351) loss_giou_dn_4: 1.0427 (1.0329) loss_fgl_dn_4: 0.9879 (0.9808) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4546 (0.4575) loss_bbox_dn_5: 0.0332 (0.0351) loss_giou_dn_5: 1.0428 (1.0329) loss_fgl_dn_5: 0.9879 (0.9808) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4355 (0.4269) loss_bbox_dn_pre: 0.0400 (0.0450) loss_giou_dn_pre: 1.1253 (1.1405)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7465 data: 0.4972 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.3960 data: 0.1667 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4123 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.050\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.109\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.041\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.225\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.305\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.097\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.317\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.192\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.074\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [67] [ 0/84] eta: 0:02:53 lr: 0.000013 loss: 38.6691 (38.6691) loss_vfl: 0.1255 (0.1255) loss_bbox: 0.3259 (0.3259) loss_giou: 2.0156 (2.0156) loss_fgl: 0.2705 (0.2705) loss_vfl_aux_0: 0.1312 (0.1312) loss_bbox_aux_0: 0.3262 (0.3262) loss_giou_aux_0: 2.0287 (2.0287) loss_fgl_aux_0: 0.2735 (0.2735) loss_ddf_aux_0: 0.1286 (0.1286) loss_vfl_aux_1: 0.1338 (0.1338) loss_bbox_aux_1: 0.3263 (0.3263) loss_giou_aux_1: 2.0163 (2.0163) loss_fgl_aux_1: 0.2700 (0.2700) loss_ddf_aux_1: 0.0221 (0.0221) loss_vfl_aux_2: 0.1355 (0.1355) loss_bbox_aux_2: 0.3254 (0.3254) loss_giou_aux_2: 2.0153 (2.0153) loss_fgl_aux_2: 0.2706 (0.2706) loss_ddf_aux_2: 0.0036 (0.0036) loss_vfl_aux_3: 0.1302 (0.1302) loss_bbox_aux_3: 0.3254 (0.3254) loss_giou_aux_3: 2.0156 (2.0156) loss_fgl_aux_3: 0.2705 (0.2705) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1274 (0.1274) loss_bbox_aux_4: 0.3257 (0.3257) loss_giou_aux_4: 2.0157 (2.0157) loss_fgl_aux_4: 0.2705 (0.2705) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1290 (0.1290) loss_bbox_pre: 0.3334 (0.3334) loss_giou_pre: 2.0204 (2.0204) loss_vfl_enc_0: 0.1333 (0.1333) loss_bbox_enc_0: 0.3535 (0.3535) loss_giou_enc_0: 2.0946 (2.0946) loss_vfl_dn_0: 0.4258 (0.4258) loss_bbox_dn_0: 0.0363 (0.0363) loss_giou_dn_0: 1.1563 (1.1563) loss_fgl_dn_0: 0.9430 (0.9430) loss_ddf_dn_0: 0.1996 (0.1996) loss_vfl_dn_1: 0.4553 (0.4553) loss_bbox_dn_1: 0.0325 (0.0325) loss_giou_dn_1: 1.0619 (1.0619) loss_fgl_dn_1: 0.9728 (0.9728) loss_ddf_dn_1: 0.0238 (0.0238) loss_vfl_dn_2: 0.4514 (0.4514) loss_bbox_dn_2: 0.0325 (0.0325) loss_giou_dn_2: 1.0601 (1.0601) loss_fgl_dn_2: 0.9725 (0.9725) loss_ddf_dn_2: 0.0042 (0.0042) loss_vfl_dn_3: 0.4482 (0.4482) loss_bbox_dn_3: 0.0322 (0.0322) loss_giou_dn_3: 1.0593 (1.0593) loss_fgl_dn_3: 0.9726 (0.9726) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4465 (0.4465) loss_bbox_dn_4: 0.0321 (0.0321) loss_giou_dn_4: 1.0592 (1.0592) loss_fgl_dn_4: 0.9726 (0.9726) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4458 (0.4458) loss_bbox_dn_5: 0.0322 (0.0322) loss_giou_dn_5: 1.0592 (1.0592) loss_fgl_dn_5: 0.9727 (0.9727) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4248 (0.4248) loss_bbox_dn_pre: 0.0363 (0.0363) loss_giou_dn_pre: 1.1568 (1.1568) time: 2.0615 data: 1.1904 max mem: 29821\n", + "Epoch: [67] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.4054 (37.9063) loss_vfl: 0.1294 (0.1659) loss_bbox: 0.2410 (0.2645) loss_giou: 1.8023 (1.7887) loss_fgl: 0.4002 (0.4353) loss_vfl_aux_0: 0.1320 (0.1728) loss_bbox_aux_0: 0.2447 (0.2675) loss_giou_aux_0: 1.8153 (1.8038) loss_fgl_aux_0: 0.3999 (0.4349) loss_ddf_aux_0: 0.1589 (0.1626) loss_vfl_aux_1: 0.1366 (0.1751) loss_bbox_aux_1: 0.2415 (0.2656) loss_giou_aux_1: 1.8037 (1.7899) loss_fgl_aux_1: 0.3989 (0.4348) loss_ddf_aux_1: 0.0419 (0.0368) loss_vfl_aux_2: 0.1343 (0.1730) loss_bbox_aux_2: 0.2403 (0.2646) loss_giou_aux_2: 1.8030 (1.7888) loss_fgl_aux_2: 0.4000 (0.4352) loss_ddf_aux_2: 0.0045 (0.0046) loss_vfl_aux_3: 0.1328 (0.1692) loss_bbox_aux_3: 0.2405 (0.2644) loss_giou_aux_3: 1.8026 (1.7888) loss_fgl_aux_3: 0.4005 (0.4353) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1301 (0.1664) loss_bbox_aux_4: 0.2408 (0.2644) loss_giou_aux_4: 1.8024 (1.7888) loss_fgl_aux_4: 0.4004 (0.4353) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1302 (0.1702) loss_bbox_pre: 0.2444 (0.2718) loss_giou_pre: 1.8151 (1.7985) loss_vfl_enc_0: 0.1313 (0.1705) loss_bbox_enc_0: 0.2779 (0.2996) loss_giou_enc_0: 1.8438 (1.8449) loss_vfl_dn_0: 0.4248 (0.4355) loss_bbox_dn_0: 0.0396 (0.0457) loss_giou_dn_0: 1.1439 (1.1264) loss_fgl_dn_0: 0.9478 (0.9640) loss_ddf_dn_0: 0.2621 (0.3215) loss_vfl_dn_1: 0.4597 (0.4678) loss_bbox_dn_1: 0.0334 (0.0373) loss_giou_dn_1: 1.0562 (1.0350) loss_fgl_dn_1: 0.9780 (0.9901) loss_ddf_dn_1: 0.0588 (0.0654) loss_vfl_dn_2: 0.4563 (0.4636) loss_bbox_dn_2: 0.0327 (0.0363) loss_giou_dn_2: 1.0499 (1.0268) loss_fgl_dn_2: 0.9813 (0.9936) loss_ddf_dn_2: 0.0054 (0.0098) loss_vfl_dn_3: 0.4539 (0.4603) loss_bbox_dn_3: 0.0327 (0.0361) loss_giou_dn_3: 1.0497 (1.0261) loss_fgl_dn_3: 0.9817 (0.9938) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4543 (0.4593) loss_bbox_dn_4: 0.0328 (0.0361) loss_giou_dn_4: 1.0496 (1.0260) loss_fgl_dn_4: 0.9815 (0.9937) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4548 (0.4594) loss_bbox_dn_5: 0.0328 (0.0361) loss_giou_dn_5: 1.0497 (1.0260) loss_fgl_dn_5: 0.9815 (0.9937) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4241 (0.4347) loss_bbox_dn_pre: 0.0400 (0.0459) loss_giou_dn_pre: 1.1462 (1.1265) time: 0.8814 data: 0.0179 max mem: 29821\n", + "Epoch: [67] Total time: 0:01:12 (0.8636 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.4054 (37.9063) loss_vfl: 0.1294 (0.1659) loss_bbox: 0.2410 (0.2645) loss_giou: 1.8023 (1.7887) loss_fgl: 0.4002 (0.4353) loss_vfl_aux_0: 0.1320 (0.1728) loss_bbox_aux_0: 0.2447 (0.2675) loss_giou_aux_0: 1.8153 (1.8038) loss_fgl_aux_0: 0.3999 (0.4349) loss_ddf_aux_0: 0.1589 (0.1626) loss_vfl_aux_1: 0.1366 (0.1751) loss_bbox_aux_1: 0.2415 (0.2656) loss_giou_aux_1: 1.8037 (1.7899) loss_fgl_aux_1: 0.3989 (0.4348) loss_ddf_aux_1: 0.0419 (0.0368) loss_vfl_aux_2: 0.1343 (0.1730) loss_bbox_aux_2: 0.2403 (0.2646) loss_giou_aux_2: 1.8030 (1.7888) loss_fgl_aux_2: 0.4000 (0.4352) loss_ddf_aux_2: 0.0045 (0.0046) loss_vfl_aux_3: 0.1328 (0.1692) loss_bbox_aux_3: 0.2405 (0.2644) loss_giou_aux_3: 1.8026 (1.7888) loss_fgl_aux_3: 0.4005 (0.4353) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1301 (0.1664) loss_bbox_aux_4: 0.2408 (0.2644) loss_giou_aux_4: 1.8024 (1.7888) loss_fgl_aux_4: 0.4004 (0.4353) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1302 (0.1702) loss_bbox_pre: 0.2444 (0.2718) loss_giou_pre: 1.8151 (1.7985) loss_vfl_enc_0: 0.1313 (0.1705) loss_bbox_enc_0: 0.2779 (0.2996) loss_giou_enc_0: 1.8438 (1.8449) loss_vfl_dn_0: 0.4248 (0.4355) loss_bbox_dn_0: 0.0396 (0.0457) loss_giou_dn_0: 1.1439 (1.1264) loss_fgl_dn_0: 0.9478 (0.9640) loss_ddf_dn_0: 0.2621 (0.3215) loss_vfl_dn_1: 0.4597 (0.4678) loss_bbox_dn_1: 0.0334 (0.0373) loss_giou_dn_1: 1.0562 (1.0350) loss_fgl_dn_1: 0.9780 (0.9901) loss_ddf_dn_1: 0.0588 (0.0654) loss_vfl_dn_2: 0.4563 (0.4636) loss_bbox_dn_2: 0.0327 (0.0363) loss_giou_dn_2: 1.0499 (1.0268) loss_fgl_dn_2: 0.9813 (0.9936) loss_ddf_dn_2: 0.0054 (0.0098) loss_vfl_dn_3: 0.4539 (0.4603) loss_bbox_dn_3: 0.0327 (0.0361) loss_giou_dn_3: 1.0497 (1.0261) loss_fgl_dn_3: 0.9817 (0.9938) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4543 (0.4593) loss_bbox_dn_4: 0.0328 (0.0361) loss_giou_dn_4: 1.0496 (1.0260) loss_fgl_dn_4: 0.9815 (0.9937) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4548 (0.4594) loss_bbox_dn_5: 0.0328 (0.0361) loss_giou_dn_5: 1.0497 (1.0260) loss_fgl_dn_5: 0.9815 (0.9937) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4241 (0.4347) loss_bbox_dn_pre: 0.0400 (0.0459) loss_giou_dn_pre: 1.1462 (1.1265)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7746 data: 0.5189 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4043 data: 0.1723 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4195 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.107\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.228\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.259\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.035\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.096\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.309\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.650\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.192\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.074\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [68] [ 0/84] eta: 0:02:42 lr: 0.000013 loss: 36.5164 (36.5164) loss_vfl: 0.1459 (0.1459) loss_bbox: 0.1978 (0.1978) loss_giou: 1.7863 (1.7863) loss_fgl: 0.3673 (0.3673) loss_vfl_aux_0: 0.1520 (0.1520) loss_bbox_aux_0: 0.2008 (0.2008) loss_giou_aux_0: 1.7945 (1.7945) loss_fgl_aux_0: 0.3632 (0.3632) loss_ddf_aux_0: 0.1695 (0.1695) loss_vfl_aux_1: 0.1538 (0.1538) loss_bbox_aux_1: 0.1988 (0.1988) loss_giou_aux_1: 1.7869 (1.7869) loss_fgl_aux_1: 0.3664 (0.3664) loss_ddf_aux_1: 0.0587 (0.0587) loss_vfl_aux_2: 0.1476 (0.1476) loss_bbox_aux_2: 0.1978 (0.1978) loss_giou_aux_2: 1.7867 (1.7867) loss_fgl_aux_2: 0.3673 (0.3673) loss_ddf_aux_2: 0.0029 (0.0029) loss_vfl_aux_3: 0.1439 (0.1439) loss_bbox_aux_3: 0.1977 (0.1977) loss_giou_aux_3: 1.7865 (1.7865) loss_fgl_aux_3: 0.3675 (0.3675) loss_ddf_aux_3: 0.0005 (0.0005) loss_vfl_aux_4: 0.1450 (0.1450) loss_bbox_aux_4: 0.1976 (0.1976) loss_giou_aux_4: 1.7866 (1.7866) loss_fgl_aux_4: 0.3674 (0.3674) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1495 (0.1495) loss_bbox_pre: 0.2023 (0.2023) loss_giou_pre: 1.7918 (1.7918) loss_vfl_enc_0: 0.1487 (0.1487) loss_bbox_enc_0: 0.2224 (0.2224) loss_giou_enc_0: 1.8305 (1.8305) loss_vfl_dn_0: 0.4302 (0.4302) loss_bbox_dn_0: 0.0277 (0.0277) loss_giou_dn_0: 1.1306 (1.1306) loss_fgl_dn_0: 0.9635 (0.9635) loss_ddf_dn_0: 0.2540 (0.2540) loss_vfl_dn_1: 0.4590 (0.4590) loss_bbox_dn_1: 0.0230 (0.0230) loss_giou_dn_1: 1.0288 (1.0288) loss_fgl_dn_1: 0.9943 (0.9943) loss_ddf_dn_1: 0.0499 (0.0499) loss_vfl_dn_2: 0.4558 (0.4558) loss_bbox_dn_2: 0.0226 (0.0226) loss_giou_dn_2: 1.0218 (1.0218) loss_fgl_dn_2: 0.9989 (0.9989) loss_ddf_dn_2: 0.0039 (0.0039) loss_vfl_dn_3: 0.4553 (0.4553) loss_bbox_dn_3: 0.0226 (0.0226) loss_giou_dn_3: 1.0209 (1.0209) loss_fgl_dn_3: 0.9994 (0.9994) loss_ddf_dn_3: 0.0007 (0.0007) loss_vfl_dn_4: 0.4514 (0.4514) loss_bbox_dn_4: 0.0226 (0.0226) loss_giou_dn_4: 1.0206 (1.0206) loss_fgl_dn_4: 0.9990 (0.9990) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4514 (0.4514) loss_bbox_dn_5: 0.0227 (0.0227) loss_giou_dn_5: 1.0205 (1.0205) loss_fgl_dn_5: 0.9986 (0.9986) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4302 (0.4302) loss_bbox_dn_pre: 0.0275 (0.0275) loss_giou_dn_pre: 1.1267 (1.1267) time: 1.9314 data: 0.9780 max mem: 29821\n", + "Epoch: [68] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3881 (37.7920) loss_vfl: 0.1604 (0.1712) loss_bbox: 0.2336 (0.2475) loss_giou: 1.7664 (1.7885) loss_fgl: 0.4382 (0.4326) loss_vfl_aux_0: 0.1699 (0.1778) loss_bbox_aux_0: 0.2421 (0.2544) loss_giou_aux_0: 1.7841 (1.7984) loss_fgl_aux_0: 0.4420 (0.4316) loss_ddf_aux_0: 0.1142 (0.1347) loss_vfl_aux_1: 0.1710 (0.1796) loss_bbox_aux_1: 0.2352 (0.2492) loss_giou_aux_1: 1.7674 (1.7895) loss_fgl_aux_1: 0.4391 (0.4320) loss_ddf_aux_1: 0.0168 (0.0228) loss_vfl_aux_2: 0.1656 (0.1788) loss_bbox_aux_2: 0.2341 (0.2478) loss_giou_aux_2: 1.7668 (1.7887) loss_fgl_aux_2: 0.4384 (0.4324) loss_ddf_aux_2: 0.0023 (0.0040) loss_vfl_aux_3: 0.1630 (0.1741) loss_bbox_aux_3: 0.2339 (0.2477) loss_giou_aux_3: 1.7667 (1.7883) loss_fgl_aux_3: 0.4383 (0.4326) loss_ddf_aux_3: 0.0004 (0.0006) loss_vfl_aux_4: 0.1610 (0.1718) loss_bbox_aux_4: 0.2336 (0.2475) loss_giou_aux_4: 1.7664 (1.7885) loss_fgl_aux_4: 0.4381 (0.4326) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1677 (0.1756) loss_bbox_pre: 0.2480 (0.2563) loss_giou_pre: 1.7753 (1.7945) loss_vfl_enc_0: 0.1654 (0.1733) loss_bbox_enc_0: 0.2711 (0.2816) loss_giou_enc_0: 1.8093 (1.8462) loss_vfl_dn_0: 0.4253 (0.4331) loss_bbox_dn_0: 0.0440 (0.0457) loss_giou_dn_0: 1.1464 (1.1349) loss_fgl_dn_0: 0.9507 (0.9592) loss_ddf_dn_0: 0.3214 (0.3734) loss_vfl_dn_1: 0.4653 (0.4672) loss_bbox_dn_1: 0.0349 (0.0369) loss_giou_dn_1: 1.0361 (1.0361) loss_fgl_dn_1: 0.9809 (0.9869) loss_ddf_dn_1: 0.0199 (0.0576) loss_vfl_dn_2: 0.4651 (0.4641) loss_bbox_dn_2: 0.0343 (0.0359) loss_giou_dn_2: 1.0306 (1.0282) loss_fgl_dn_2: 0.9848 (0.9906) loss_ddf_dn_2: 0.0026 (0.0100) loss_vfl_dn_3: 0.4575 (0.4610) loss_bbox_dn_3: 0.0342 (0.0357) loss_giou_dn_3: 1.0301 (1.0273) loss_fgl_dn_3: 0.9851 (0.9914) loss_ddf_dn_3: 0.0007 (0.0011) loss_vfl_dn_4: 0.4570 (0.4607) loss_bbox_dn_4: 0.0342 (0.0356) loss_giou_dn_4: 1.0297 (1.0273) loss_fgl_dn_4: 0.9851 (0.9909) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4570 (0.4611) loss_bbox_dn_5: 0.0342 (0.0356) loss_giou_dn_5: 1.0297 (1.0274) loss_fgl_dn_5: 0.9851 (0.9909) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4248 (0.4323) loss_bbox_dn_pre: 0.0437 (0.0458) loss_giou_dn_pre: 1.1484 (1.1350) time: 0.8601 data: 0.0180 max mem: 29821\n", + "Epoch: [68] Total time: 0:01:12 (0.8659 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3881 (37.7920) loss_vfl: 0.1604 (0.1712) loss_bbox: 0.2336 (0.2475) loss_giou: 1.7664 (1.7885) loss_fgl: 0.4382 (0.4326) loss_vfl_aux_0: 0.1699 (0.1778) loss_bbox_aux_0: 0.2421 (0.2544) loss_giou_aux_0: 1.7841 (1.7984) loss_fgl_aux_0: 0.4420 (0.4316) loss_ddf_aux_0: 0.1142 (0.1347) loss_vfl_aux_1: 0.1710 (0.1796) loss_bbox_aux_1: 0.2352 (0.2492) loss_giou_aux_1: 1.7674 (1.7895) loss_fgl_aux_1: 0.4391 (0.4320) loss_ddf_aux_1: 0.0168 (0.0228) loss_vfl_aux_2: 0.1656 (0.1788) loss_bbox_aux_2: 0.2341 (0.2478) loss_giou_aux_2: 1.7668 (1.7887) loss_fgl_aux_2: 0.4384 (0.4324) loss_ddf_aux_2: 0.0023 (0.0040) loss_vfl_aux_3: 0.1630 (0.1741) loss_bbox_aux_3: 0.2339 (0.2477) loss_giou_aux_3: 1.7667 (1.7883) loss_fgl_aux_3: 0.4383 (0.4326) loss_ddf_aux_3: 0.0004 (0.0006) loss_vfl_aux_4: 0.1610 (0.1718) loss_bbox_aux_4: 0.2336 (0.2475) loss_giou_aux_4: 1.7664 (1.7885) loss_fgl_aux_4: 0.4381 (0.4326) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1677 (0.1756) loss_bbox_pre: 0.2480 (0.2563) loss_giou_pre: 1.7753 (1.7945) loss_vfl_enc_0: 0.1654 (0.1733) loss_bbox_enc_0: 0.2711 (0.2816) loss_giou_enc_0: 1.8093 (1.8462) loss_vfl_dn_0: 0.4253 (0.4331) loss_bbox_dn_0: 0.0440 (0.0457) loss_giou_dn_0: 1.1464 (1.1349) loss_fgl_dn_0: 0.9507 (0.9592) loss_ddf_dn_0: 0.3214 (0.3734) loss_vfl_dn_1: 0.4653 (0.4672) loss_bbox_dn_1: 0.0349 (0.0369) loss_giou_dn_1: 1.0361 (1.0361) loss_fgl_dn_1: 0.9809 (0.9869) loss_ddf_dn_1: 0.0199 (0.0576) loss_vfl_dn_2: 0.4651 (0.4641) loss_bbox_dn_2: 0.0343 (0.0359) loss_giou_dn_2: 1.0306 (1.0282) loss_fgl_dn_2: 0.9848 (0.9906) loss_ddf_dn_2: 0.0026 (0.0100) loss_vfl_dn_3: 0.4575 (0.4610) loss_bbox_dn_3: 0.0342 (0.0357) loss_giou_dn_3: 1.0301 (1.0273) loss_fgl_dn_3: 0.9851 (0.9914) loss_ddf_dn_3: 0.0007 (0.0011) loss_vfl_dn_4: 0.4570 (0.4607) loss_bbox_dn_4: 0.0342 (0.0356) loss_giou_dn_4: 1.0297 (1.0273) loss_fgl_dn_4: 0.9851 (0.9909) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4570 (0.4611) loss_bbox_dn_5: 0.0342 (0.0356) loss_giou_dn_5: 1.0297 (1.0274) loss_fgl_dn_5: 0.9851 (0.9909) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4248 (0.4323) loss_bbox_dn_pre: 0.0437 (0.0458) loss_giou_dn_pre: 1.1484 (1.1350)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7592 data: 0.5013 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4064 data: 0.1697 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4229 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.048\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.107\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.024\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.225\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.432\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.021\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.094\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.306\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.700\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.193\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.051\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [69] [ 0/84] eta: 0:02:22 lr: 0.000013 loss: 38.3774 (38.3774) loss_vfl: 0.1559 (0.1559) loss_bbox: 0.1984 (0.1984) loss_giou: 1.8021 (1.8021) loss_fgl: 0.5115 (0.5115) loss_vfl_aux_0: 0.1615 (0.1615) loss_bbox_aux_0: 0.2023 (0.2023) loss_giou_aux_0: 1.8198 (1.8198) loss_fgl_aux_0: 0.5144 (0.5144) loss_ddf_aux_0: 0.2923 (0.2923) loss_vfl_aux_1: 0.1665 (0.1665) loss_bbox_aux_1: 0.1995 (0.1995) loss_giou_aux_1: 1.8039 (1.8039) loss_fgl_aux_1: 0.5111 (0.5111) loss_ddf_aux_1: 0.0745 (0.0745) loss_vfl_aux_2: 0.1577 (0.1577) loss_bbox_aux_2: 0.1987 (0.1987) loss_giou_aux_2: 1.8021 (1.8021) loss_fgl_aux_2: 0.5109 (0.5109) loss_ddf_aux_2: 0.0062 (0.0062) loss_vfl_aux_3: 0.1550 (0.1550) loss_bbox_aux_3: 0.1983 (0.1983) loss_giou_aux_3: 1.8013 (1.8013) loss_fgl_aux_3: 0.5110 (0.5110) loss_ddf_aux_3: 0.0007 (0.0007) loss_vfl_aux_4: 0.1555 (0.1555) loss_bbox_aux_4: 0.1983 (0.1983) loss_giou_aux_4: 1.8022 (1.8022) loss_fgl_aux_4: 0.5115 (0.5115) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1602 (0.1602) loss_bbox_pre: 0.2053 (0.2053) loss_giou_pre: 1.8110 (1.8110) loss_vfl_enc_0: 0.1637 (0.1637) loss_bbox_enc_0: 0.2411 (0.2411) loss_giou_enc_0: 1.8269 (1.8269) loss_vfl_dn_0: 0.4177 (0.4177) loss_bbox_dn_0: 0.0504 (0.0504) loss_giou_dn_0: 1.1657 (1.1657) loss_fgl_dn_0: 0.9483 (0.9483) loss_ddf_dn_0: 0.4947 (0.4947) loss_vfl_dn_1: 0.4697 (0.4697) loss_bbox_dn_1: 0.0429 (0.0429) loss_giou_dn_1: 1.0405 (1.0405) loss_fgl_dn_1: 0.9787 (0.9787) loss_ddf_dn_1: 0.1985 (0.1985) loss_vfl_dn_2: 0.4668 (0.4668) loss_bbox_dn_2: 0.0419 (0.0419) loss_giou_dn_2: 1.0313 (1.0313) loss_fgl_dn_2: 0.9813 (0.9813) loss_ddf_dn_2: 0.0041 (0.0041) loss_vfl_dn_3: 0.4727 (0.4727) loss_bbox_dn_3: 0.0414 (0.0414) loss_giou_dn_3: 1.0302 (1.0302) loss_fgl_dn_3: 0.9817 (0.9817) loss_ddf_dn_3: 0.0008 (0.0008) loss_vfl_dn_4: 0.4717 (0.4717) loss_bbox_dn_4: 0.0415 (0.0415) loss_giou_dn_4: 1.0304 (1.0304) loss_fgl_dn_4: 0.9818 (0.9818) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4753 (0.4753) loss_bbox_dn_5: 0.0415 (0.0415) loss_giou_dn_5: 1.0304 (1.0304) loss_fgl_dn_5: 0.9818 (0.9818) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4175 (0.4175) loss_bbox_dn_pre: 0.0491 (0.0491) loss_giou_dn_pre: 1.1653 (1.1653) time: 1.7024 data: 0.8569 max mem: 29821\n", + "Epoch: [69] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3396 (37.3869) loss_vfl: 0.1364 (0.1642) loss_bbox: 0.2310 (0.2333) loss_giou: 1.8148 (1.7751) loss_fgl: 0.4047 (0.4271) loss_vfl_aux_0: 0.1379 (0.1708) loss_bbox_aux_0: 0.2374 (0.2386) loss_giou_aux_0: 1.8184 (1.7867) loss_fgl_aux_0: 0.4030 (0.4271) loss_ddf_aux_0: 0.1305 (0.1391) loss_vfl_aux_1: 0.1428 (0.1729) loss_bbox_aux_1: 0.2317 (0.2343) loss_giou_aux_1: 1.8155 (1.7765) loss_fgl_aux_1: 0.4050 (0.4271) loss_ddf_aux_1: 0.0128 (0.0169) loss_vfl_aux_2: 0.1432 (0.1718) loss_bbox_aux_2: 0.2308 (0.2334) loss_giou_aux_2: 1.8151 (1.7753) loss_fgl_aux_2: 0.4048 (0.4271) loss_ddf_aux_2: 0.0019 (0.0028) loss_vfl_aux_3: 0.1390 (0.1672) loss_bbox_aux_3: 0.2309 (0.2333) loss_giou_aux_3: 1.8147 (1.7751) loss_fgl_aux_3: 0.4048 (0.4272) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1384 (0.1647) loss_bbox_aux_4: 0.2308 (0.2332) loss_giou_aux_4: 1.8148 (1.7752) loss_fgl_aux_4: 0.4048 (0.4272) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1354 (0.1687) loss_bbox_pre: 0.2448 (0.2408) loss_giou_pre: 1.8148 (1.7831) loss_vfl_enc_0: 0.1421 (0.1677) loss_bbox_enc_0: 0.2641 (0.2615) loss_giou_enc_0: 1.8507 (1.8292) loss_vfl_dn_0: 0.4158 (0.4283) loss_bbox_dn_0: 0.0431 (0.0457) loss_giou_dn_0: 1.1678 (1.1449) loss_fgl_dn_0: 0.9288 (0.9488) loss_ddf_dn_0: 0.4685 (0.3394) loss_vfl_dn_1: 0.4548 (0.4632) loss_bbox_dn_1: 0.0345 (0.0370) loss_giou_dn_1: 1.0535 (1.0472) loss_fgl_dn_1: 0.9598 (0.9763) loss_ddf_dn_1: 0.0420 (0.0375) loss_vfl_dn_2: 0.4565 (0.4604) loss_bbox_dn_2: 0.0335 (0.0360) loss_giou_dn_2: 1.0468 (1.0377) loss_fgl_dn_2: 0.9657 (0.9793) loss_ddf_dn_2: 0.0065 (0.0060) loss_vfl_dn_3: 0.4541 (0.4572) loss_bbox_dn_3: 0.0334 (0.0359) loss_giou_dn_3: 1.0464 (1.0369) loss_fgl_dn_3: 0.9659 (0.9796) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4531 (0.4556) loss_bbox_dn_4: 0.0334 (0.0358) loss_giou_dn_4: 1.0463 (1.0368) loss_fgl_dn_4: 0.9659 (0.9795) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4524 (0.4558) loss_bbox_dn_5: 0.0334 (0.0358) loss_giou_dn_5: 1.0469 (1.0368) loss_fgl_dn_5: 0.9659 (0.9795) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4155 (0.4274) loss_bbox_dn_pre: 0.0431 (0.0459) loss_giou_dn_pre: 1.1694 (1.1456) time: 0.8280 data: 0.0180 max mem: 29821\n", + "Epoch: [69] Total time: 0:01:10 (0.8432 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3396 (37.3869) loss_vfl: 0.1364 (0.1642) loss_bbox: 0.2310 (0.2333) loss_giou: 1.8148 (1.7751) loss_fgl: 0.4047 (0.4271) loss_vfl_aux_0: 0.1379 (0.1708) loss_bbox_aux_0: 0.2374 (0.2386) loss_giou_aux_0: 1.8184 (1.7867) loss_fgl_aux_0: 0.4030 (0.4271) loss_ddf_aux_0: 0.1305 (0.1391) loss_vfl_aux_1: 0.1428 (0.1729) loss_bbox_aux_1: 0.2317 (0.2343) loss_giou_aux_1: 1.8155 (1.7765) loss_fgl_aux_1: 0.4050 (0.4271) loss_ddf_aux_1: 0.0128 (0.0169) loss_vfl_aux_2: 0.1432 (0.1718) loss_bbox_aux_2: 0.2308 (0.2334) loss_giou_aux_2: 1.8151 (1.7753) loss_fgl_aux_2: 0.4048 (0.4271) loss_ddf_aux_2: 0.0019 (0.0028) loss_vfl_aux_3: 0.1390 (0.1672) loss_bbox_aux_3: 0.2309 (0.2333) loss_giou_aux_3: 1.8147 (1.7751) loss_fgl_aux_3: 0.4048 (0.4272) loss_ddf_aux_3: 0.0003 (0.0004) loss_vfl_aux_4: 0.1384 (0.1647) loss_bbox_aux_4: 0.2308 (0.2332) loss_giou_aux_4: 1.8148 (1.7752) loss_fgl_aux_4: 0.4048 (0.4272) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1354 (0.1687) loss_bbox_pre: 0.2448 (0.2408) loss_giou_pre: 1.8148 (1.7831) loss_vfl_enc_0: 0.1421 (0.1677) loss_bbox_enc_0: 0.2641 (0.2615) loss_giou_enc_0: 1.8507 (1.8292) loss_vfl_dn_0: 0.4158 (0.4283) loss_bbox_dn_0: 0.0431 (0.0457) loss_giou_dn_0: 1.1678 (1.1449) loss_fgl_dn_0: 0.9288 (0.9488) loss_ddf_dn_0: 0.4685 (0.3394) loss_vfl_dn_1: 0.4548 (0.4632) loss_bbox_dn_1: 0.0345 (0.0370) loss_giou_dn_1: 1.0535 (1.0472) loss_fgl_dn_1: 0.9598 (0.9763) loss_ddf_dn_1: 0.0420 (0.0375) loss_vfl_dn_2: 0.4565 (0.4604) loss_bbox_dn_2: 0.0335 (0.0360) loss_giou_dn_2: 1.0468 (1.0377) loss_fgl_dn_2: 0.9657 (0.9793) loss_ddf_dn_2: 0.0065 (0.0060) loss_vfl_dn_3: 0.4541 (0.4572) loss_bbox_dn_3: 0.0334 (0.0359) loss_giou_dn_3: 1.0464 (1.0369) loss_fgl_dn_3: 0.9659 (0.9796) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4531 (0.4556) loss_bbox_dn_4: 0.0334 (0.0358) loss_giou_dn_4: 1.0463 (1.0368) loss_fgl_dn_4: 0.9659 (0.9795) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4524 (0.4558) loss_bbox_dn_5: 0.0334 (0.0358) loss_giou_dn_5: 1.0469 (1.0368) loss_fgl_dn_5: 0.9659 (0.9795) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4155 (0.4274) loss_bbox_dn_pre: 0.0431 (0.0459) loss_giou_dn_pre: 1.1694 (1.1456)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7838 data: 0.5399 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4081 data: 0.1751 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4250 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.107\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.224\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.389\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.021\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.094\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.323\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.825\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.192\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.055\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [70] [ 0/84] eta: 0:02:34 lr: 0.000013 loss: 37.2481 (37.2481) loss_vfl: 0.2163 (0.2163) loss_bbox: 0.1906 (0.1906) loss_giou: 1.7347 (1.7347) loss_fgl: 0.4270 (0.4270) loss_vfl_aux_0: 0.2158 (0.2158) loss_bbox_aux_0: 0.1963 (0.1963) loss_giou_aux_0: 1.7477 (1.7477) loss_fgl_aux_0: 0.4236 (0.4236) loss_ddf_aux_0: 0.2906 (0.2906) loss_vfl_aux_1: 0.2313 (0.2313) loss_bbox_aux_1: 0.1916 (0.1916) loss_giou_aux_1: 1.7346 (1.7346) loss_fgl_aux_1: 0.4274 (0.4274) loss_ddf_aux_1: 0.0179 (0.0179) loss_vfl_aux_2: 0.2307 (0.2307) loss_bbox_aux_2: 0.1910 (0.1910) loss_giou_aux_2: 1.7347 (1.7347) loss_fgl_aux_2: 0.4272 (0.4272) loss_ddf_aux_2: 0.0025 (0.0025) loss_vfl_aux_3: 0.2214 (0.2214) loss_bbox_aux_3: 0.1907 (0.1907) loss_giou_aux_3: 1.7346 (1.7346) loss_fgl_aux_3: 0.4272 (0.4272) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.2188 (0.2188) loss_bbox_aux_4: 0.1907 (0.1907) loss_giou_aux_4: 1.7347 (1.7347) loss_fgl_aux_4: 0.4271 (0.4271) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2095 (0.2095) loss_bbox_pre: 0.2028 (0.2028) loss_giou_pre: 1.7438 (1.7438) loss_vfl_enc_0: 0.2214 (0.2214) loss_bbox_enc_0: 0.2169 (0.2169) loss_giou_enc_0: 1.7801 (1.7801) loss_vfl_dn_0: 0.4031 (0.4031) loss_bbox_dn_0: 0.0473 (0.0473) loss_giou_dn_0: 1.1668 (1.1668) loss_fgl_dn_0: 0.9129 (0.9129) loss_ddf_dn_0: 0.4980 (0.4980) loss_vfl_dn_1: 0.4553 (0.4553) loss_bbox_dn_1: 0.0349 (0.0349) loss_giou_dn_1: 1.0556 (1.0556) loss_fgl_dn_1: 0.9440 (0.9440) loss_ddf_dn_1: 0.0291 (0.0291) loss_vfl_dn_2: 0.4553 (0.4553) loss_bbox_dn_2: 0.0343 (0.0343) loss_giou_dn_2: 1.0487 (1.0487) loss_fgl_dn_2: 0.9469 (0.9469) loss_ddf_dn_2: 0.0038 (0.0038) loss_vfl_dn_3: 0.4514 (0.4514) loss_bbox_dn_3: 0.0346 (0.0346) loss_giou_dn_3: 1.0472 (1.0472) loss_fgl_dn_3: 0.9476 (0.9476) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4514 (0.4514) loss_bbox_dn_4: 0.0348 (0.0348) loss_giou_dn_4: 1.0469 (1.0469) loss_fgl_dn_4: 0.9476 (0.9476) loss_ddf_dn_4: 0.0001 (0.0001) loss_vfl_dn_5: 0.4497 (0.4497) loss_bbox_dn_5: 0.0348 (0.0348) loss_giou_dn_5: 1.0468 (1.0468) loss_fgl_dn_5: 0.9477 (0.9477) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4006 (0.4006) loss_bbox_dn_pre: 0.0479 (0.0479) loss_giou_dn_pre: 1.1705 (1.1705) time: 1.8364 data: 1.0956 max mem: 29821\n", + "Epoch: [70] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3173 (37.5367) loss_vfl: 0.1490 (0.1743) loss_bbox: 0.2174 (0.2374) loss_giou: 1.8229 (1.7582) loss_fgl: 0.3940 (0.4540) loss_vfl_aux_0: 0.1547 (0.1834) loss_bbox_aux_0: 0.2226 (0.2413) loss_giou_aux_0: 1.8344 (1.7727) loss_fgl_aux_0: 0.3951 (0.4549) loss_ddf_aux_0: 0.1300 (0.1598) loss_vfl_aux_1: 0.1534 (0.1849) loss_bbox_aux_1: 0.2178 (0.2383) loss_giou_aux_1: 1.8238 (1.7593) loss_fgl_aux_1: 0.3922 (0.4540) loss_ddf_aux_1: 0.0176 (0.0169) loss_vfl_aux_2: 0.1503 (0.1824) loss_bbox_aux_2: 0.2179 (0.2378) loss_giou_aux_2: 1.8223 (1.7581) loss_fgl_aux_2: 0.3941 (0.4539) loss_ddf_aux_2: 0.0032 (0.0036) loss_vfl_aux_3: 0.1505 (0.1777) loss_bbox_aux_3: 0.2178 (0.2376) loss_giou_aux_3: 1.8224 (1.7580) loss_fgl_aux_3: 0.3939 (0.4540) loss_ddf_aux_3: 0.0006 (0.0005) loss_vfl_aux_4: 0.1493 (0.1748) loss_bbox_aux_4: 0.2175 (0.2375) loss_giou_aux_4: 1.8225 (1.7581) loss_fgl_aux_4: 0.3940 (0.4540) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1517 (0.1809) loss_bbox_pre: 0.2267 (0.2444) loss_giou_pre: 1.8323 (1.7677) loss_vfl_enc_0: 0.1444 (0.1782) loss_bbox_enc_0: 0.2438 (0.2732) loss_giou_enc_0: 1.8957 (1.8189) loss_vfl_dn_0: 0.4395 (0.4372) loss_bbox_dn_0: 0.0393 (0.0450) loss_giou_dn_0: 1.1227 (1.1200) loss_fgl_dn_0: 0.9681 (0.9666) loss_ddf_dn_0: 0.2811 (0.3173) loss_vfl_dn_1: 0.4612 (0.4686) loss_bbox_dn_1: 0.0317 (0.0368) loss_giou_dn_1: 1.0502 (1.0309) loss_fgl_dn_1: 0.9868 (0.9890) loss_ddf_dn_1: 0.0249 (0.0377) loss_vfl_dn_2: 0.4597 (0.4624) loss_bbox_dn_2: 0.0313 (0.0360) loss_giou_dn_2: 1.0448 (1.0232) loss_fgl_dn_2: 0.9898 (0.9910) loss_ddf_dn_2: 0.0034 (0.0073) loss_vfl_dn_3: 0.4580 (0.4593) loss_bbox_dn_3: 0.0312 (0.0358) loss_giou_dn_3: 1.0439 (1.0224) loss_fgl_dn_3: 0.9898 (0.9914) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4580 (0.4581) loss_bbox_dn_4: 0.0312 (0.0357) loss_giou_dn_4: 1.0437 (1.0223) loss_fgl_dn_4: 0.9897 (0.9914) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4580 (0.4584) loss_bbox_dn_5: 0.0312 (0.0357) loss_giou_dn_5: 1.0436 (1.0224) loss_fgl_dn_5: 0.9897 (0.9913) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4382 (0.4362) loss_bbox_dn_pre: 0.0394 (0.0453) loss_giou_dn_pre: 1.1252 (1.1203) time: 0.8458 data: 0.0174 max mem: 29821\n", + "Epoch: [70] Total time: 0:01:11 (0.8470 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3173 (37.5367) loss_vfl: 0.1490 (0.1743) loss_bbox: 0.2174 (0.2374) loss_giou: 1.8229 (1.7582) loss_fgl: 0.3940 (0.4540) loss_vfl_aux_0: 0.1547 (0.1834) loss_bbox_aux_0: 0.2226 (0.2413) loss_giou_aux_0: 1.8344 (1.7727) loss_fgl_aux_0: 0.3951 (0.4549) loss_ddf_aux_0: 0.1300 (0.1598) loss_vfl_aux_1: 0.1534 (0.1849) loss_bbox_aux_1: 0.2178 (0.2383) loss_giou_aux_1: 1.8238 (1.7593) loss_fgl_aux_1: 0.3922 (0.4540) loss_ddf_aux_1: 0.0176 (0.0169) loss_vfl_aux_2: 0.1503 (0.1824) loss_bbox_aux_2: 0.2179 (0.2378) loss_giou_aux_2: 1.8223 (1.7581) loss_fgl_aux_2: 0.3941 (0.4539) loss_ddf_aux_2: 0.0032 (0.0036) loss_vfl_aux_3: 0.1505 (0.1777) loss_bbox_aux_3: 0.2178 (0.2376) loss_giou_aux_3: 1.8224 (1.7580) loss_fgl_aux_3: 0.3939 (0.4540) loss_ddf_aux_3: 0.0006 (0.0005) loss_vfl_aux_4: 0.1493 (0.1748) loss_bbox_aux_4: 0.2175 (0.2375) loss_giou_aux_4: 1.8225 (1.7581) loss_fgl_aux_4: 0.3940 (0.4540) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1517 (0.1809) loss_bbox_pre: 0.2267 (0.2444) loss_giou_pre: 1.8323 (1.7677) loss_vfl_enc_0: 0.1444 (0.1782) loss_bbox_enc_0: 0.2438 (0.2732) loss_giou_enc_0: 1.8957 (1.8189) loss_vfl_dn_0: 0.4395 (0.4372) loss_bbox_dn_0: 0.0393 (0.0450) loss_giou_dn_0: 1.1227 (1.1200) loss_fgl_dn_0: 0.9681 (0.9666) loss_ddf_dn_0: 0.2811 (0.3173) loss_vfl_dn_1: 0.4612 (0.4686) loss_bbox_dn_1: 0.0317 (0.0368) loss_giou_dn_1: 1.0502 (1.0309) loss_fgl_dn_1: 0.9868 (0.9890) loss_ddf_dn_1: 0.0249 (0.0377) loss_vfl_dn_2: 0.4597 (0.4624) loss_bbox_dn_2: 0.0313 (0.0360) loss_giou_dn_2: 1.0448 (1.0232) loss_fgl_dn_2: 0.9898 (0.9910) loss_ddf_dn_2: 0.0034 (0.0073) loss_vfl_dn_3: 0.4580 (0.4593) loss_bbox_dn_3: 0.0312 (0.0358) loss_giou_dn_3: 1.0439 (1.0224) loss_fgl_dn_3: 0.9898 (0.9914) loss_ddf_dn_3: 0.0007 (0.0008) loss_vfl_dn_4: 0.4580 (0.4581) loss_bbox_dn_4: 0.0312 (0.0357) loss_giou_dn_4: 1.0437 (1.0223) loss_fgl_dn_4: 0.9897 (0.9914) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4580 (0.4584) loss_bbox_dn_5: 0.0312 (0.0357) loss_giou_dn_5: 1.0436 (1.0224) loss_fgl_dn_5: 0.9897 (0.9913) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4382 (0.4362) loss_bbox_dn_pre: 0.0394 (0.0453) loss_giou_dn_pre: 1.1252 (1.1203)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7857 data: 0.5424 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.4048 data: 0.1740 max mem: 29821\n", + "Test: Total time: 0:00:01 (0.4214 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.107\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.041\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.227\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.543\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.074\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.095\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.312\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.850\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.192\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.056\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "Epoch: [71] [ 0/84] eta: 0:02:39 lr: 0.000013 loss: 35.8345 (35.8345) loss_vfl: 0.1005 (0.1005) loss_bbox: 0.2220 (0.2220) loss_giou: 1.7936 (1.7936) loss_fgl: 0.2884 (0.2884) loss_vfl_aux_0: 0.1014 (0.1014) loss_bbox_aux_0: 0.2231 (0.2231) loss_giou_aux_0: 1.8044 (1.8044) loss_fgl_aux_0: 0.2873 (0.2873) loss_ddf_aux_0: 0.0973 (0.0973) loss_vfl_aux_1: 0.1064 (0.1064) loss_bbox_aux_1: 0.2244 (0.2244) loss_giou_aux_1: 1.7938 (1.7938) loss_fgl_aux_1: 0.2883 (0.2883) loss_ddf_aux_1: 0.0119 (0.0119) loss_vfl_aux_2: 0.1068 (0.1068) loss_bbox_aux_2: 0.2236 (0.2236) loss_giou_aux_2: 1.7940 (1.7940) loss_fgl_aux_2: 0.2882 (0.2882) loss_ddf_aux_2: 0.0035 (0.0035) loss_vfl_aux_3: 0.1025 (0.1025) loss_bbox_aux_3: 0.2234 (0.2234) loss_giou_aux_3: 1.7937 (1.7937) loss_fgl_aux_3: 0.2881 (0.2881) loss_ddf_aux_3: 0.0006 (0.0006) loss_vfl_aux_4: 0.1006 (0.1006) loss_bbox_aux_4: 0.2220 (0.2220) loss_giou_aux_4: 1.7935 (1.7935) loss_fgl_aux_4: 0.2884 (0.2884) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1003 (0.1003) loss_bbox_pre: 0.2257 (0.2257) loss_giou_pre: 1.8037 (1.8037) loss_vfl_enc_0: 0.1057 (0.1057) loss_bbox_enc_0: 0.2421 (0.2421) loss_giou_enc_0: 1.8950 (1.8950) loss_vfl_dn_0: 0.4331 (0.4331) loss_bbox_dn_0: 0.0287 (0.0287) loss_giou_dn_0: 1.1249 (1.1249) loss_fgl_dn_0: 0.9416 (0.9416) loss_ddf_dn_0: 0.1959 (0.1959) loss_vfl_dn_1: 0.4731 (0.4731) loss_bbox_dn_1: 0.0240 (0.0240) loss_giou_dn_1: 1.0588 (1.0588) loss_fgl_dn_1: 0.9687 (0.9687) loss_ddf_dn_1: 0.0125 (0.0125) loss_vfl_dn_2: 0.4731 (0.4731) loss_bbox_dn_2: 0.0233 (0.0233) loss_giou_dn_2: 1.0527 (1.0527) loss_fgl_dn_2: 0.9704 (0.9704) loss_ddf_dn_2: 0.0025 (0.0025) loss_vfl_dn_3: 0.4658 (0.4658) loss_bbox_dn_3: 0.0229 (0.0229) loss_giou_dn_3: 1.0515 (1.0515) loss_fgl_dn_3: 0.9706 (0.9706) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.4602 (0.4602) loss_bbox_dn_4: 0.0228 (0.0228) loss_giou_dn_4: 1.0512 (1.0512) loss_fgl_dn_4: 0.9706 (0.9706) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4597 (0.4597) loss_bbox_dn_5: 0.0228 (0.0228) loss_giou_dn_5: 1.0512 (1.0512) loss_fgl_dn_5: 0.9706 (0.9706) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4329 (0.4329) loss_bbox_dn_pre: 0.0287 (0.0287) loss_giou_dn_pre: 1.1243 (1.1243) time: 1.9046 data: 0.9919 max mem: 29821\n", + "Epoch: [71] [83/84] eta: 0:00:00 lr: 0.000013 loss: 38.1294 (38.1196) loss_vfl: 0.1443 (0.1602) loss_bbox: 0.2943 (0.2899) loss_giou: 1.9054 (1.8202) loss_fgl: 0.3933 (0.4258) loss_vfl_aux_0: 0.1479 (0.1683) loss_bbox_aux_0: 0.2956 (0.2958) loss_giou_aux_0: 1.9189 (1.8322) loss_fgl_aux_0: 0.3918 (0.4264) loss_ddf_aux_0: 0.1617 (0.1564) loss_vfl_aux_1: 0.1498 (0.1700) loss_bbox_aux_1: 0.2955 (0.2921) loss_giou_aux_1: 1.9100 (1.8205) loss_fgl_aux_1: 0.3927 (0.4257) loss_ddf_aux_1: 0.0314 (0.0272) loss_vfl_aux_2: 0.1520 (0.1681) loss_bbox_aux_2: 0.2945 (0.2906) loss_giou_aux_2: 1.9060 (1.8200) loss_fgl_aux_2: 0.3932 (0.4257) loss_ddf_aux_2: 0.0073 (0.0065) loss_vfl_aux_3: 0.1466 (0.1636) loss_bbox_aux_3: 0.2943 (0.2902) loss_giou_aux_3: 1.9055 (1.8200) loss_fgl_aux_3: 0.3935 (0.4258) loss_ddf_aux_3: 0.0004 (0.0005) loss_vfl_aux_4: 0.1454 (0.1608) loss_bbox_aux_4: 0.2944 (0.2900) loss_giou_aux_4: 1.9054 (1.8202) loss_fgl_aux_4: 0.3933 (0.4258) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1459 (0.1658) loss_bbox_pre: 0.2971 (0.2975) loss_giou_pre: 1.9152 (1.8284) loss_vfl_enc_0: 0.1438 (0.1653) loss_bbox_enc_0: 0.3288 (0.3291) loss_giou_enc_0: 1.9558 (1.8802) loss_vfl_dn_0: 0.4250 (0.4358) loss_bbox_dn_0: 0.0394 (0.0442) loss_giou_dn_0: 1.1413 (1.1252) loss_fgl_dn_0: 0.9464 (0.9632) loss_ddf_dn_0: 0.2389 (0.2656) loss_vfl_dn_1: 0.4612 (0.4670) loss_bbox_dn_1: 0.0317 (0.0358) loss_giou_dn_1: 1.0452 (1.0334) loss_fgl_dn_1: 0.9698 (0.9862) loss_ddf_dn_1: 0.0234 (0.0383) loss_vfl_dn_2: 0.4551 (0.4631) loss_bbox_dn_2: 0.0317 (0.0349) loss_giou_dn_2: 1.0378 (1.0248) loss_fgl_dn_2: 0.9723 (0.9884) loss_ddf_dn_2: 0.0037 (0.0060) loss_vfl_dn_3: 0.4517 (0.4593) loss_bbox_dn_3: 0.0317 (0.0347) loss_giou_dn_3: 1.0370 (1.0242) loss_fgl_dn_3: 0.9724 (0.9886) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4504 (0.4579) loss_bbox_dn_4: 0.0317 (0.0347) loss_giou_dn_4: 1.0371 (1.0241) loss_fgl_dn_4: 0.9722 (0.9886) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4581) loss_bbox_dn_5: 0.0317 (0.0347) loss_giou_dn_5: 1.0370 (1.0242) loss_fgl_dn_5: 0.9721 (0.9886) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4233 (0.4348) loss_bbox_dn_pre: 0.0397 (0.0445) loss_giou_dn_pre: 1.1425 (1.1255) time: 0.8776 data: 0.0171 max mem: 29821\n", + "Epoch: [71] Total time: 0:01:13 (0.8746 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 38.1294 (38.1196) loss_vfl: 0.1443 (0.1602) loss_bbox: 0.2943 (0.2899) loss_giou: 1.9054 (1.8202) loss_fgl: 0.3933 (0.4258) loss_vfl_aux_0: 0.1479 (0.1683) loss_bbox_aux_0: 0.2956 (0.2958) loss_giou_aux_0: 1.9189 (1.8322) loss_fgl_aux_0: 0.3918 (0.4264) loss_ddf_aux_0: 0.1617 (0.1564) loss_vfl_aux_1: 0.1498 (0.1700) loss_bbox_aux_1: 0.2955 (0.2921) loss_giou_aux_1: 1.9100 (1.8205) loss_fgl_aux_1: 0.3927 (0.4257) loss_ddf_aux_1: 0.0314 (0.0272) loss_vfl_aux_2: 0.1520 (0.1681) loss_bbox_aux_2: 0.2945 (0.2906) loss_giou_aux_2: 1.9060 (1.8200) loss_fgl_aux_2: 0.3932 (0.4257) loss_ddf_aux_2: 0.0073 (0.0065) loss_vfl_aux_3: 0.1466 (0.1636) loss_bbox_aux_3: 0.2943 (0.2902) loss_giou_aux_3: 1.9055 (1.8200) loss_fgl_aux_3: 0.3935 (0.4258) loss_ddf_aux_3: 0.0004 (0.0005) loss_vfl_aux_4: 0.1454 (0.1608) loss_bbox_aux_4: 0.2944 (0.2900) loss_giou_aux_4: 1.9054 (1.8202) loss_fgl_aux_4: 0.3933 (0.4258) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1459 (0.1658) loss_bbox_pre: 0.2971 (0.2975) loss_giou_pre: 1.9152 (1.8284) loss_vfl_enc_0: 0.1438 (0.1653) loss_bbox_enc_0: 0.3288 (0.3291) loss_giou_enc_0: 1.9558 (1.8802) loss_vfl_dn_0: 0.4250 (0.4358) loss_bbox_dn_0: 0.0394 (0.0442) loss_giou_dn_0: 1.1413 (1.1252) loss_fgl_dn_0: 0.9464 (0.9632) loss_ddf_dn_0: 0.2389 (0.2656) loss_vfl_dn_1: 0.4612 (0.4670) loss_bbox_dn_1: 0.0317 (0.0358) loss_giou_dn_1: 1.0452 (1.0334) loss_fgl_dn_1: 0.9698 (0.9862) loss_ddf_dn_1: 0.0234 (0.0383) loss_vfl_dn_2: 0.4551 (0.4631) loss_bbox_dn_2: 0.0317 (0.0349) loss_giou_dn_2: 1.0378 (1.0248) loss_fgl_dn_2: 0.9723 (0.9884) loss_ddf_dn_2: 0.0037 (0.0060) loss_vfl_dn_3: 0.4517 (0.4593) loss_bbox_dn_3: 0.0317 (0.0347) loss_giou_dn_3: 1.0370 (1.0242) loss_fgl_dn_3: 0.9724 (0.9886) loss_ddf_dn_3: 0.0004 (0.0005) loss_vfl_dn_4: 0.4504 (0.4579) loss_bbox_dn_4: 0.0317 (0.0347) loss_giou_dn_4: 1.0371 (1.0241) loss_fgl_dn_4: 0.9722 (0.9886) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4521 (0.4581) loss_bbox_dn_5: 0.0317 (0.0347) loss_giou_dn_5: 1.0370 (1.0242) loss_fgl_dn_5: 0.9721 (0.9886) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4233 (0.4348) loss_bbox_dn_pre: 0.0397 (0.0445) loss_giou_dn_pre: 1.1425 (1.1255)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7498 data: 0.4917 max mem: 29821\n", + "Test: [3/4] eta: 0:00:00 time: 0.5503 data: 0.1767 max mem: 29821\n", + "Test: Total time: 0:00:02 (0.5678 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.048\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.105\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.025\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.238\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.376\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.073\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.094\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.087\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.625\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.190\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.053\n", + "best_stat: {'epoch': 65, 'coco_eval_bbox': 0.050347537111746846}\n", + "/content/D-FINE/src/solver/_solver.py:159: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " state = torch.load(path, map_location='cpu')\n", + "Load last_epoch\n", + "Load model.state_dict\n", + "Load criterion.state_dict\n", + "Load postprocessor.state_dict\n", + "Load ema.state_dict\n", + "Load scaler.state_dict\n", + "Load optimizer.state_dict\n", + "Load lr_scheduler.state_dict\n", + "Load lr_warmup_scheduler.state_dict\n", + "Refresh EMA at epoch 72 with decay 0.9999\n", + "Epoch: [72] [ 0/84] eta: 0:03:57 lr: 0.000013 loss: 36.7809 (36.7809) loss_vfl: 0.1781 (0.1781) loss_bbox: 0.2054 (0.2054) loss_giou: 1.6441 (1.6441) loss_fgl: 0.5296 (0.5296) loss_vfl_aux_0: 0.1952 (0.1952) loss_bbox_aux_0: 0.2108 (0.2108) loss_giou_aux_0: 1.6548 (1.6548) loss_fgl_aux_0: 0.5325 (0.5325) loss_ddf_aux_0: 0.0928 (0.0928) loss_vfl_aux_1: 0.1926 (0.1926) loss_bbox_aux_1: 0.2059 (0.2059) loss_giou_aux_1: 1.6442 (1.6442) loss_fgl_aux_1: 0.5298 (0.5298) loss_ddf_aux_1: 0.0149 (0.0149) loss_vfl_aux_2: 0.1884 (0.1884) loss_bbox_aux_2: 0.2058 (0.2058) loss_giou_aux_2: 1.6439 (1.6439) loss_fgl_aux_2: 0.5297 (0.5297) loss_ddf_aux_2: 0.0018 (0.0018) loss_vfl_aux_3: 0.1831 (0.1831) loss_bbox_aux_3: 0.2057 (0.2057) loss_giou_aux_3: 1.6441 (1.6441) loss_fgl_aux_3: 0.5295 (0.5295) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1793 (0.1793) loss_bbox_aux_4: 0.2054 (0.2054) loss_giou_aux_4: 1.6441 (1.6441) loss_fgl_aux_4: 0.5296 (0.5296) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1913 (0.1913) loss_bbox_pre: 0.2156 (0.2156) loss_giou_pre: 1.6541 (1.6541) loss_vfl_enc_0: 0.1830 (0.1830) loss_bbox_enc_0: 0.2503 (0.2503) loss_giou_enc_0: 1.7222 (1.7222) loss_vfl_dn_0: 0.4392 (0.4392) loss_bbox_dn_0: 0.0465 (0.0465) loss_giou_dn_0: 1.0963 (1.0963) loss_fgl_dn_0: 0.9779 (0.9779) loss_ddf_dn_0: 0.3889 (0.3889) loss_vfl_dn_1: 0.4690 (0.4690) loss_bbox_dn_1: 0.0362 (0.0362) loss_giou_dn_1: 0.9959 (0.9959) loss_fgl_dn_1: 0.9991 (0.9991) loss_ddf_dn_1: 0.0488 (0.0488) loss_vfl_dn_2: 0.4712 (0.4712) loss_bbox_dn_2: 0.0358 (0.0358) loss_giou_dn_2: 0.9886 (0.9886) loss_fgl_dn_2: 1.0009 (1.0009) loss_ddf_dn_2: 0.0053 (0.0053) loss_vfl_dn_3: 0.4663 (0.4663) loss_bbox_dn_3: 0.0356 (0.0356) loss_giou_dn_3: 0.9888 (0.9888) loss_fgl_dn_3: 1.0012 (1.0012) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4609 (0.4609) loss_bbox_dn_4: 0.0355 (0.0355) loss_giou_dn_4: 0.9886 (0.9886) loss_fgl_dn_4: 1.0014 (1.0014) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4597 (0.4597) loss_bbox_dn_5: 0.0355 (0.0355) loss_giou_dn_5: 0.9886 (0.9886) loss_fgl_dn_5: 1.0014 (1.0014) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4385 (0.4385) loss_bbox_dn_pre: 0.0463 (0.0463) loss_giou_dn_pre: 1.0950 (1.0950) time: 2.8264 data: 1.8439 max mem: 29821\n", + "Epoch: [72] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.9541 (37.1308) loss_vfl: 0.1560 (0.1783) loss_bbox: 0.1958 (0.2107) loss_giou: 1.6967 (1.6716) loss_fgl: 0.4966 (0.5286) loss_vfl_aux_0: 0.1627 (0.1921) loss_bbox_aux_0: 0.2005 (0.2153) loss_giou_aux_0: 1.7053 (1.6843) loss_fgl_aux_0: 0.4958 (0.5310) loss_ddf_aux_0: 0.1195 (0.1701) loss_vfl_aux_1: 0.1630 (0.1917) loss_bbox_aux_1: 0.1964 (0.2118) loss_giou_aux_1: 1.6995 (1.6731) loss_fgl_aux_1: 0.4961 (0.5287) loss_ddf_aux_1: 0.0250 (0.0276) loss_vfl_aux_2: 0.1628 (0.1887) loss_bbox_aux_2: 0.1953 (0.2109) loss_giou_aux_2: 1.6974 (1.6718) loss_fgl_aux_2: 0.4963 (0.5285) loss_ddf_aux_2: 0.0037 (0.0046) loss_vfl_aux_3: 0.1593 (0.1827) loss_bbox_aux_3: 0.1954 (0.2107) loss_giou_aux_3: 1.6970 (1.6717) loss_fgl_aux_3: 0.4965 (0.5286) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1570 (0.1792) loss_bbox_aux_4: 0.1957 (0.2107) loss_giou_aux_4: 1.6968 (1.6716) loss_fgl_aux_4: 0.4965 (0.5286) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1583 (0.1894) loss_bbox_pre: 0.2054 (0.2188) loss_giou_pre: 1.6994 (1.6791) loss_vfl_enc_0: 0.1649 (0.1952) loss_bbox_enc_0: 0.2246 (0.2403) loss_giou_enc_0: 1.7258 (1.7225) loss_vfl_dn_0: 0.4343 (0.4353) loss_bbox_dn_0: 0.0387 (0.0456) loss_giou_dn_0: 1.1190 (1.1115) loss_fgl_dn_0: 0.9679 (0.9694) loss_ddf_dn_0: 0.3903 (0.4007) loss_vfl_dn_1: 0.4631 (0.4680) loss_bbox_dn_1: 0.0313 (0.0358) loss_giou_dn_1: 1.0229 (1.0144) loss_fgl_dn_1: 0.9895 (0.9903) loss_ddf_dn_1: 0.0507 (0.0470) loss_vfl_dn_2: 0.4624 (0.4624) loss_bbox_dn_2: 0.0305 (0.0349) loss_giou_dn_2: 1.0137 (1.0069) loss_fgl_dn_2: 0.9905 (0.9913) loss_ddf_dn_2: 0.0059 (0.0054) loss_vfl_dn_3: 0.4587 (0.4588) loss_bbox_dn_3: 0.0304 (0.0346) loss_giou_dn_3: 1.0134 (1.0062) loss_fgl_dn_3: 0.9909 (0.9914) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4580 (0.4573) loss_bbox_dn_4: 0.0304 (0.0346) loss_giou_dn_4: 1.0133 (1.0062) loss_fgl_dn_4: 0.9909 (0.9915) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4575 (0.4576) loss_bbox_dn_5: 0.0304 (0.0346) loss_giou_dn_5: 1.0133 (1.0062) loss_fgl_dn_5: 0.9909 (0.9915) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4336 (0.4343) loss_bbox_dn_pre: 0.0389 (0.0458) loss_giou_dn_pre: 1.1194 (1.1117) time: 0.8990 data: 0.0169 max mem: 30164\n", + "Epoch: [72] Total time: 0:01:18 (0.9383 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.9541 (37.1308) loss_vfl: 0.1560 (0.1783) loss_bbox: 0.1958 (0.2107) loss_giou: 1.6967 (1.6716) loss_fgl: 0.4966 (0.5286) loss_vfl_aux_0: 0.1627 (0.1921) loss_bbox_aux_0: 0.2005 (0.2153) loss_giou_aux_0: 1.7053 (1.6843) loss_fgl_aux_0: 0.4958 (0.5310) loss_ddf_aux_0: 0.1195 (0.1701) loss_vfl_aux_1: 0.1630 (0.1917) loss_bbox_aux_1: 0.1964 (0.2118) loss_giou_aux_1: 1.6995 (1.6731) loss_fgl_aux_1: 0.4961 (0.5287) loss_ddf_aux_1: 0.0250 (0.0276) loss_vfl_aux_2: 0.1628 (0.1887) loss_bbox_aux_2: 0.1953 (0.2109) loss_giou_aux_2: 1.6974 (1.6718) loss_fgl_aux_2: 0.4963 (0.5285) loss_ddf_aux_2: 0.0037 (0.0046) loss_vfl_aux_3: 0.1593 (0.1827) loss_bbox_aux_3: 0.1954 (0.2107) loss_giou_aux_3: 1.6970 (1.6717) loss_fgl_aux_3: 0.4965 (0.5286) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1570 (0.1792) loss_bbox_aux_4: 0.1957 (0.2107) loss_giou_aux_4: 1.6968 (1.6716) loss_fgl_aux_4: 0.4965 (0.5286) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1583 (0.1894) loss_bbox_pre: 0.2054 (0.2188) loss_giou_pre: 1.6994 (1.6791) loss_vfl_enc_0: 0.1649 (0.1952) loss_bbox_enc_0: 0.2246 (0.2403) loss_giou_enc_0: 1.7258 (1.7225) loss_vfl_dn_0: 0.4343 (0.4353) loss_bbox_dn_0: 0.0387 (0.0456) loss_giou_dn_0: 1.1190 (1.1115) loss_fgl_dn_0: 0.9679 (0.9694) loss_ddf_dn_0: 0.3903 (0.4007) loss_vfl_dn_1: 0.4631 (0.4680) loss_bbox_dn_1: 0.0313 (0.0358) loss_giou_dn_1: 1.0229 (1.0144) loss_fgl_dn_1: 0.9895 (0.9903) loss_ddf_dn_1: 0.0507 (0.0470) loss_vfl_dn_2: 0.4624 (0.4624) loss_bbox_dn_2: 0.0305 (0.0349) loss_giou_dn_2: 1.0137 (1.0069) loss_fgl_dn_2: 0.9905 (0.9913) loss_ddf_dn_2: 0.0059 (0.0054) loss_vfl_dn_3: 0.4587 (0.4588) loss_bbox_dn_3: 0.0304 (0.0346) loss_giou_dn_3: 1.0134 (1.0062) loss_fgl_dn_3: 0.9909 (0.9914) loss_ddf_dn_3: 0.0003 (0.0004) loss_vfl_dn_4: 0.4580 (0.4573) loss_bbox_dn_4: 0.0304 (0.0346) loss_giou_dn_4: 1.0133 (1.0062) loss_fgl_dn_4: 0.9909 (0.9915) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4575 (0.4576) loss_bbox_dn_5: 0.0304 (0.0346) loss_giou_dn_5: 1.0133 (1.0062) loss_fgl_dn_5: 0.9909 (0.9915) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4336 (0.4343) loss_bbox_dn_pre: 0.0389 (0.0458) loss_giou_dn_pre: 1.1194 (1.1117)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7775 data: 0.5446 max mem: 30164\n", + "Test: [3/4] eta: 0:00:00 time: 0.3994 data: 0.1733 max mem: 30164\n", + "Test: Total time: 0:00:01 (0.4155 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.052\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.110\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.042\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.239\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.138\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.098\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.327\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.425\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.190\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.079\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Epoch: [73] [ 0/84] eta: 0:01:53 lr: 0.000013 loss: 35.9285 (35.9285) loss_vfl: 0.1500 (0.1500) loss_bbox: 0.1661 (0.1661) loss_giou: 1.5633 (1.5633) loss_fgl: 0.5695 (0.5695) loss_vfl_aux_0: 0.1597 (0.1597) loss_bbox_aux_0: 0.1714 (0.1714) loss_giou_aux_0: 1.5753 (1.5753) loss_fgl_aux_0: 0.5682 (0.5682) loss_ddf_aux_0: 0.1133 (0.1133) loss_vfl_aux_1: 0.1655 (0.1655) loss_bbox_aux_1: 0.1674 (0.1674) loss_giou_aux_1: 1.5645 (1.5645) loss_fgl_aux_1: 0.5693 (0.5693) loss_ddf_aux_1: 0.0178 (0.0178) loss_vfl_aux_2: 0.1588 (0.1588) loss_bbox_aux_2: 0.1667 (0.1667) loss_giou_aux_2: 1.5625 (1.5625) loss_fgl_aux_2: 0.5696 (0.5696) loss_ddf_aux_2: 0.0027 (0.0027) loss_vfl_aux_3: 0.1539 (0.1539) loss_bbox_aux_3: 0.1664 (0.1664) loss_giou_aux_3: 1.5628 (1.5628) loss_fgl_aux_3: 0.5695 (0.5695) loss_ddf_aux_3: 0.0002 (0.0002) loss_vfl_aux_4: 0.1503 (0.1503) loss_bbox_aux_4: 0.1661 (0.1661) loss_giou_aux_4: 1.5633 (1.5633) loss_fgl_aux_4: 0.5695 (0.5695) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.1578 (0.1578) loss_bbox_pre: 0.1752 (0.1752) loss_giou_pre: 1.5695 (1.5695) loss_vfl_enc_0: 0.1622 (0.1622) loss_bbox_enc_0: 0.1899 (0.1899) loss_giou_enc_0: 1.6002 (1.6002) loss_vfl_dn_0: 0.4355 (0.4355) loss_bbox_dn_0: 0.0395 (0.0395) loss_giou_dn_0: 1.1182 (1.1182) loss_fgl_dn_0: 0.9645 (0.9645) loss_ddf_dn_0: 0.4705 (0.4705) loss_vfl_dn_1: 0.4702 (0.4702) loss_bbox_dn_1: 0.0313 (0.0313) loss_giou_dn_1: 1.0062 (1.0062) loss_fgl_dn_1: 0.9917 (0.9917) loss_ddf_dn_1: 0.0961 (0.0961) loss_vfl_dn_2: 0.4680 (0.4680) loss_bbox_dn_2: 0.0311 (0.0311) loss_giou_dn_2: 1.0019 (1.0019) loss_fgl_dn_2: 0.9929 (0.9929) loss_ddf_dn_2: 0.0101 (0.0101) loss_vfl_dn_3: 0.4617 (0.4617) loss_bbox_dn_3: 0.0311 (0.0311) loss_giou_dn_3: 1.0018 (1.0018) loss_fgl_dn_3: 0.9929 (0.9929) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4646 (0.4646) loss_bbox_dn_4: 0.0312 (0.0312) loss_giou_dn_4: 1.0018 (1.0018) loss_fgl_dn_4: 0.9930 (0.9930) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4644 (0.4644) loss_bbox_dn_5: 0.0312 (0.0312) loss_giou_dn_5: 1.0018 (1.0018) loss_fgl_dn_5: 0.9931 (0.9931) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4358 (0.4358) loss_bbox_dn_pre: 0.0396 (0.0396) loss_giou_dn_pre: 1.1180 (1.1180) time: 1.3483 data: 0.3394 max mem: 30164\n", + "Epoch: [73] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.1351 (37.0342) loss_vfl: 0.1664 (0.1772) loss_bbox: 0.2147 (0.2078) loss_giou: 1.6376 (1.6508) loss_fgl: 0.5184 (0.5379) loss_vfl_aux_0: 0.1776 (0.1911) loss_bbox_aux_0: 0.2203 (0.2115) loss_giou_aux_0: 1.6568 (1.6637) loss_fgl_aux_0: 0.5214 (0.5412) loss_ddf_aux_0: 0.1712 (0.1905) loss_vfl_aux_1: 0.1743 (0.1899) loss_bbox_aux_1: 0.2145 (0.2091) loss_giou_aux_1: 1.6385 (1.6522) loss_fgl_aux_1: 0.5189 (0.5381) loss_ddf_aux_1: 0.0265 (0.0307) loss_vfl_aux_2: 0.1735 (0.1870) loss_bbox_aux_2: 0.2144 (0.2081) loss_giou_aux_2: 1.6377 (1.6509) loss_fgl_aux_2: 0.5185 (0.5378) loss_ddf_aux_2: 0.0031 (0.0050) loss_vfl_aux_3: 0.1696 (0.1813) loss_bbox_aux_3: 0.2145 (0.2080) loss_giou_aux_3: 1.6379 (1.6507) loss_fgl_aux_3: 0.5186 (0.5379) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1678 (0.1780) loss_bbox_aux_4: 0.2146 (0.2078) loss_giou_aux_4: 1.6377 (1.6508) loss_fgl_aux_4: 0.5185 (0.5379) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1757 (0.1885) loss_bbox_pre: 0.2222 (0.2145) loss_giou_pre: 1.6519 (1.6594) loss_vfl_enc_0: 0.1761 (0.1944) loss_bbox_enc_0: 0.2384 (0.2354) loss_giou_enc_0: 1.7065 (1.7017) loss_vfl_dn_0: 0.4214 (0.4366) loss_bbox_dn_0: 0.0400 (0.0451) loss_giou_dn_0: 1.1487 (1.1121) loss_fgl_dn_0: 0.9500 (0.9747) loss_ddf_dn_0: 0.4289 (0.4133) loss_vfl_dn_1: 0.4648 (0.4695) loss_bbox_dn_1: 0.0319 (0.0355) loss_giou_dn_1: 1.0287 (1.0108) loss_fgl_dn_1: 0.9726 (0.9937) loss_ddf_dn_1: 0.0423 (0.0464) loss_vfl_dn_2: 0.4580 (0.4638) loss_bbox_dn_2: 0.0311 (0.0344) loss_giou_dn_2: 1.0229 (1.0027) loss_fgl_dn_2: 0.9747 (0.9956) loss_ddf_dn_2: 0.0059 (0.0054) loss_vfl_dn_3: 0.4561 (0.4603) loss_bbox_dn_3: 0.0309 (0.0342) loss_giou_dn_3: 1.0221 (1.0020) loss_fgl_dn_3: 0.9750 (0.9959) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4534 (0.4586) loss_bbox_dn_4: 0.0309 (0.0342) loss_giou_dn_4: 1.0221 (1.0019) loss_fgl_dn_4: 0.9750 (0.9959) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4526 (0.4585) loss_bbox_dn_5: 0.0309 (0.0342) loss_giou_dn_5: 1.0221 (1.0019) loss_fgl_dn_5: 0.9750 (0.9960) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4199 (0.4358) loss_bbox_dn_pre: 0.0404 (0.0453) loss_giou_dn_pre: 1.1420 (1.1120) time: 0.9202 data: 0.0172 max mem: 30164\n", + "Epoch: [73] Total time: 0:01:17 (0.9171 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.1351 (37.0342) loss_vfl: 0.1664 (0.1772) loss_bbox: 0.2147 (0.2078) loss_giou: 1.6376 (1.6508) loss_fgl: 0.5184 (0.5379) loss_vfl_aux_0: 0.1776 (0.1911) loss_bbox_aux_0: 0.2203 (0.2115) loss_giou_aux_0: 1.6568 (1.6637) loss_fgl_aux_0: 0.5214 (0.5412) loss_ddf_aux_0: 0.1712 (0.1905) loss_vfl_aux_1: 0.1743 (0.1899) loss_bbox_aux_1: 0.2145 (0.2091) loss_giou_aux_1: 1.6385 (1.6522) loss_fgl_aux_1: 0.5189 (0.5381) loss_ddf_aux_1: 0.0265 (0.0307) loss_vfl_aux_2: 0.1735 (0.1870) loss_bbox_aux_2: 0.2144 (0.2081) loss_giou_aux_2: 1.6377 (1.6509) loss_fgl_aux_2: 0.5185 (0.5378) loss_ddf_aux_2: 0.0031 (0.0050) loss_vfl_aux_3: 0.1696 (0.1813) loss_bbox_aux_3: 0.2145 (0.2080) loss_giou_aux_3: 1.6379 (1.6507) loss_fgl_aux_3: 0.5186 (0.5379) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1678 (0.1780) loss_bbox_aux_4: 0.2146 (0.2078) loss_giou_aux_4: 1.6377 (1.6508) loss_fgl_aux_4: 0.5185 (0.5379) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1757 (0.1885) loss_bbox_pre: 0.2222 (0.2145) loss_giou_pre: 1.6519 (1.6594) loss_vfl_enc_0: 0.1761 (0.1944) loss_bbox_enc_0: 0.2384 (0.2354) loss_giou_enc_0: 1.7065 (1.7017) loss_vfl_dn_0: 0.4214 (0.4366) loss_bbox_dn_0: 0.0400 (0.0451) loss_giou_dn_0: 1.1487 (1.1121) loss_fgl_dn_0: 0.9500 (0.9747) loss_ddf_dn_0: 0.4289 (0.4133) loss_vfl_dn_1: 0.4648 (0.4695) loss_bbox_dn_1: 0.0319 (0.0355) loss_giou_dn_1: 1.0287 (1.0108) loss_fgl_dn_1: 0.9726 (0.9937) loss_ddf_dn_1: 0.0423 (0.0464) loss_vfl_dn_2: 0.4580 (0.4638) loss_bbox_dn_2: 0.0311 (0.0344) loss_giou_dn_2: 1.0229 (1.0027) loss_fgl_dn_2: 0.9747 (0.9956) loss_ddf_dn_2: 0.0059 (0.0054) loss_vfl_dn_3: 0.4561 (0.4603) loss_bbox_dn_3: 0.0309 (0.0342) loss_giou_dn_3: 1.0221 (1.0020) loss_fgl_dn_3: 0.9750 (0.9959) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4534 (0.4586) loss_bbox_dn_4: 0.0309 (0.0342) loss_giou_dn_4: 1.0221 (1.0019) loss_fgl_dn_4: 0.9750 (0.9959) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4526 (0.4585) loss_bbox_dn_5: 0.0309 (0.0342) loss_giou_dn_5: 1.0221 (1.0019) loss_fgl_dn_5: 0.9750 (0.9960) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4199 (0.4358) loss_bbox_dn_pre: 0.0404 (0.0453) loss_giou_dn_pre: 1.1420 (1.1120)\n", + "Test: [0/4] eta: 0:00:05 time: 1.3144 data: 0.5298 max mem: 30164\n", + "Test: [3/4] eta: 0:00:00 time: 0.5352 data: 0.1703 max mem: 30164\n", + "Test: Total time: 0:00:02 (0.5541 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.104\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.238\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.263\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.063\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.084\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.344\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.600\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.168\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.056\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Load last_epoch\n", + "Load model.state_dict\n", + "Load criterion.state_dict\n", + "Load postprocessor.state_dict\n", + "Load ema.state_dict\n", + "Load scaler.state_dict\n", + "Load optimizer.state_dict\n", + "Load lr_scheduler.state_dict\n", + "Load lr_warmup_scheduler.state_dict\n", + "Refresh EMA at epoch 73 with decay 0.9998\n", + "Epoch: [74] [ 0/84] eta: 0:01:36 lr: 0.000013 loss: 37.2312 (37.2312) loss_vfl: 0.3435 (0.3435) loss_bbox: 0.1843 (0.1843) loss_giou: 1.3433 (1.3433) loss_fgl: 0.7193 (0.7193) loss_vfl_aux_0: 0.3870 (0.3870) loss_bbox_aux_0: 0.1900 (0.1900) loss_giou_aux_0: 1.3599 (1.3599) loss_fgl_aux_0: 0.7290 (0.7290) loss_ddf_aux_0: 0.3490 (0.3490) loss_vfl_aux_1: 0.3716 (0.3716) loss_bbox_aux_1: 0.1832 (0.1832) loss_giou_aux_1: 1.3464 (1.3464) loss_fgl_aux_1: 0.7199 (0.7199) loss_ddf_aux_1: 0.0657 (0.0657) loss_vfl_aux_2: 0.3657 (0.3657) loss_bbox_aux_2: 0.1846 (0.1846) loss_giou_aux_2: 1.3439 (1.3439) loss_fgl_aux_2: 0.7192 (0.7192) loss_ddf_aux_2: 0.0102 (0.0102) loss_vfl_aux_3: 0.3542 (0.3542) loss_bbox_aux_3: 0.1842 (0.1842) loss_giou_aux_3: 1.3434 (1.3434) loss_fgl_aux_3: 0.7191 (0.7191) loss_ddf_aux_3: 0.0006 (0.0006) loss_vfl_aux_4: 0.3467 (0.3467) loss_bbox_aux_4: 0.1843 (0.1843) loss_giou_aux_4: 1.3433 (1.3433) loss_fgl_aux_4: 0.7193 (0.7193) loss_ddf_aux_4: 0.0002 (0.0002) loss_vfl_pre: 0.3826 (0.3826) loss_bbox_pre: 0.1936 (0.1936) loss_giou_pre: 1.3605 (1.3605) loss_vfl_enc_0: 0.3679 (0.3679) loss_bbox_enc_0: 0.2317 (0.2317) loss_giou_enc_0: 1.4479 (1.4479) loss_vfl_dn_0: 0.4895 (0.4895) loss_bbox_dn_0: 0.0743 (0.0743) loss_giou_dn_0: 0.9589 (0.9589) loss_fgl_dn_0: 1.0578 (1.0578) loss_ddf_dn_0: 0.6268 (0.6268) loss_vfl_dn_1: 0.5205 (0.5205) loss_bbox_dn_1: 0.0559 (0.0559) loss_giou_dn_1: 0.8363 (0.8363) loss_fgl_dn_1: 1.0635 (1.0635) loss_ddf_dn_1: 0.0823 (0.0823) loss_vfl_dn_2: 0.5117 (0.5117) loss_bbox_dn_2: 0.0566 (0.0566) loss_giou_dn_2: 0.8358 (0.8358) loss_fgl_dn_2: 1.0607 (1.0607) loss_ddf_dn_2: 0.0096 (0.0096) loss_vfl_dn_3: 0.5093 (0.5093) loss_bbox_dn_3: 0.0561 (0.0561) loss_giou_dn_3: 0.8352 (0.8352) loss_fgl_dn_3: 1.0613 (1.0613) loss_ddf_dn_3: 0.0006 (0.0006) loss_vfl_dn_4: 0.5034 (0.5034) loss_bbox_dn_4: 0.0562 (0.0562) loss_giou_dn_4: 0.8357 (0.8357) loss_fgl_dn_4: 1.0612 (1.0612) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.5020 (0.5020) loss_bbox_dn_5: 0.0562 (0.0562) loss_giou_dn_5: 0.8357 (0.8357) loss_fgl_dn_5: 1.0612 (1.0612) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4885 (0.4885) loss_bbox_dn_pre: 0.0742 (0.0742) loss_giou_dn_pre: 0.9591 (0.9591) time: 1.1506 data: 0.3354 max mem: 30164\n", + "Epoch: [74] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.7424 (37.0340) loss_vfl: 0.1595 (0.1758) loss_bbox: 0.2134 (0.2111) loss_giou: 1.7058 (1.6686) loss_fgl: 0.5122 (0.5296) loss_vfl_aux_0: 0.1713 (0.1894) loss_bbox_aux_0: 0.2153 (0.2151) loss_giou_aux_0: 1.7221 (1.6806) loss_fgl_aux_0: 0.5181 (0.5328) loss_ddf_aux_0: 0.1341 (0.1623) loss_vfl_aux_1: 0.1718 (0.1890) loss_bbox_aux_1: 0.2133 (0.2121) loss_giou_aux_1: 1.7083 (1.6703) loss_fgl_aux_1: 0.5126 (0.5298) loss_ddf_aux_1: 0.0165 (0.0233) loss_vfl_aux_2: 0.1671 (0.1860) loss_bbox_aux_2: 0.2132 (0.2113) loss_giou_aux_2: 1.7062 (1.6689) loss_fgl_aux_2: 0.5125 (0.5296) loss_ddf_aux_2: 0.0022 (0.0036) loss_vfl_aux_3: 0.1621 (0.1801) loss_bbox_aux_3: 0.2131 (0.2110) loss_giou_aux_3: 1.7063 (1.6688) loss_fgl_aux_3: 0.5123 (0.5297) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1602 (0.1768) loss_bbox_aux_4: 0.2131 (0.2110) loss_giou_aux_4: 1.7061 (1.6688) loss_fgl_aux_4: 0.5123 (0.5297) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1682 (0.1867) loss_bbox_pre: 0.2194 (0.2187) loss_giou_pre: 1.7182 (1.6751) loss_vfl_enc_0: 0.1727 (0.1918) loss_bbox_enc_0: 0.2380 (0.2393) loss_giou_enc_0: 1.7605 (1.7170) loss_vfl_dn_0: 0.4329 (0.4353) loss_bbox_dn_0: 0.0424 (0.0452) loss_giou_dn_0: 1.1180 (1.1111) loss_fgl_dn_0: 0.9642 (0.9691) loss_ddf_dn_0: 0.3247 (0.3808) loss_vfl_dn_1: 0.4648 (0.4684) loss_bbox_dn_1: 0.0341 (0.0357) loss_giou_dn_1: 1.0187 (1.0126) loss_fgl_dn_1: 0.9894 (0.9902) loss_ddf_dn_1: 0.0264 (0.0357) loss_vfl_dn_2: 0.4604 (0.4637) loss_bbox_dn_2: 0.0324 (0.0348) loss_giou_dn_2: 1.0100 (1.0044) loss_fgl_dn_2: 0.9881 (0.9916) loss_ddf_dn_2: 0.0019 (0.0035) loss_vfl_dn_3: 0.4563 (0.4600) loss_bbox_dn_3: 0.0321 (0.0346) loss_giou_dn_3: 1.0099 (1.0037) loss_fgl_dn_3: 0.9881 (0.9918) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4565 (0.4583) loss_bbox_dn_4: 0.0322 (0.0346) loss_giou_dn_4: 1.0100 (1.0037) loss_fgl_dn_4: 0.9882 (0.9918) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4568 (0.4582) loss_bbox_dn_5: 0.0322 (0.0346) loss_giou_dn_5: 1.0101 (1.0037) loss_fgl_dn_5: 0.9881 (0.9918) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4329 (0.4343) loss_bbox_dn_pre: 0.0425 (0.0454) loss_giou_dn_pre: 1.1170 (1.1111) time: 0.9178 data: 0.0173 max mem: 31559\n", + "Epoch: [74] Total time: 0:01:17 (0.9257 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.7424 (37.0340) loss_vfl: 0.1595 (0.1758) loss_bbox: 0.2134 (0.2111) loss_giou: 1.7058 (1.6686) loss_fgl: 0.5122 (0.5296) loss_vfl_aux_0: 0.1713 (0.1894) loss_bbox_aux_0: 0.2153 (0.2151) loss_giou_aux_0: 1.7221 (1.6806) loss_fgl_aux_0: 0.5181 (0.5328) loss_ddf_aux_0: 0.1341 (0.1623) loss_vfl_aux_1: 0.1718 (0.1890) loss_bbox_aux_1: 0.2133 (0.2121) loss_giou_aux_1: 1.7083 (1.6703) loss_fgl_aux_1: 0.5126 (0.5298) loss_ddf_aux_1: 0.0165 (0.0233) loss_vfl_aux_2: 0.1671 (0.1860) loss_bbox_aux_2: 0.2132 (0.2113) loss_giou_aux_2: 1.7062 (1.6689) loss_fgl_aux_2: 0.5125 (0.5296) loss_ddf_aux_2: 0.0022 (0.0036) loss_vfl_aux_3: 0.1621 (0.1801) loss_bbox_aux_3: 0.2131 (0.2110) loss_giou_aux_3: 1.7063 (1.6688) loss_fgl_aux_3: 0.5123 (0.5297) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1602 (0.1768) loss_bbox_aux_4: 0.2131 (0.2110) loss_giou_aux_4: 1.7061 (1.6688) loss_fgl_aux_4: 0.5123 (0.5297) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1682 (0.1867) loss_bbox_pre: 0.2194 (0.2187) loss_giou_pre: 1.7182 (1.6751) loss_vfl_enc_0: 0.1727 (0.1918) loss_bbox_enc_0: 0.2380 (0.2393) loss_giou_enc_0: 1.7605 (1.7170) loss_vfl_dn_0: 0.4329 (0.4353) loss_bbox_dn_0: 0.0424 (0.0452) loss_giou_dn_0: 1.1180 (1.1111) loss_fgl_dn_0: 0.9642 (0.9691) loss_ddf_dn_0: 0.3247 (0.3808) loss_vfl_dn_1: 0.4648 (0.4684) loss_bbox_dn_1: 0.0341 (0.0357) loss_giou_dn_1: 1.0187 (1.0126) loss_fgl_dn_1: 0.9894 (0.9902) loss_ddf_dn_1: 0.0264 (0.0357) loss_vfl_dn_2: 0.4604 (0.4637) loss_bbox_dn_2: 0.0324 (0.0348) loss_giou_dn_2: 1.0100 (1.0044) loss_fgl_dn_2: 0.9881 (0.9916) loss_ddf_dn_2: 0.0019 (0.0035) loss_vfl_dn_3: 0.4563 (0.4600) loss_bbox_dn_3: 0.0321 (0.0346) loss_giou_dn_3: 1.0099 (1.0037) loss_fgl_dn_3: 0.9881 (0.9918) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4565 (0.4583) loss_bbox_dn_4: 0.0322 (0.0346) loss_giou_dn_4: 1.0100 (1.0037) loss_fgl_dn_4: 0.9882 (0.9918) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4568 (0.4582) loss_bbox_dn_5: 0.0322 (0.0346) loss_giou_dn_5: 1.0101 (1.0037) loss_fgl_dn_5: 0.9881 (0.9918) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4329 (0.4343) loss_bbox_dn_pre: 0.0425 (0.0454) loss_giou_dn_pre: 1.1170 (1.1111)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7162 data: 0.4840 max mem: 31559\n", + "Test: [3/4] eta: 0:00:00 time: 0.3856 data: 0.1589 max mem: 31559\n", + "Test: Total time: 0:00:01 (0.4018 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.052\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.109\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.041\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.241\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.216\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.098\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.315\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.191\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.077\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Epoch: [75] [ 0/84] eta: 0:02:08 lr: 0.000013 loss: 37.5589 (37.5589) loss_vfl: 0.1125 (0.1125) loss_bbox: 0.2657 (0.2657) loss_giou: 1.8786 (1.8786) loss_fgl: 0.3813 (0.3813) loss_vfl_aux_0: 0.1181 (0.1181) loss_bbox_aux_0: 0.2711 (0.2711) loss_giou_aux_0: 1.8880 (1.8880) loss_fgl_aux_0: 0.3770 (0.3770) loss_ddf_aux_0: 0.1248 (0.1248) loss_vfl_aux_1: 0.1215 (0.1215) loss_bbox_aux_1: 0.2666 (0.2666) loss_giou_aux_1: 1.8799 (1.8799) loss_fgl_aux_1: 0.3812 (0.3812) loss_ddf_aux_1: 0.0183 (0.0183) loss_vfl_aux_2: 0.1169 (0.1169) loss_bbox_aux_2: 0.2656 (0.2656) loss_giou_aux_2: 1.8786 (1.8786) loss_fgl_aux_2: 0.3813 (0.3813) loss_ddf_aux_2: 0.0021 (0.0021) loss_vfl_aux_3: 0.1147 (0.1147) loss_bbox_aux_3: 0.2655 (0.2655) loss_giou_aux_3: 1.8786 (1.8786) loss_fgl_aux_3: 0.3813 (0.3813) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1124 (0.1124) loss_bbox_aux_4: 0.2656 (0.2656) loss_giou_aux_4: 1.8788 (1.8788) loss_fgl_aux_4: 0.3813 (0.3813) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1155 (0.1155) loss_bbox_pre: 0.2757 (0.2757) loss_giou_pre: 1.8844 (1.8844) loss_vfl_enc_0: 0.1181 (0.1181) loss_bbox_enc_0: 0.2834 (0.2834) loss_giou_enc_0: 1.9224 (1.9224) loss_vfl_dn_0: 0.4121 (0.4121) loss_bbox_dn_0: 0.0426 (0.0426) loss_giou_dn_0: 1.1576 (1.1576) loss_fgl_dn_0: 0.9141 (0.9141) loss_ddf_dn_0: 0.3381 (0.3381) loss_vfl_dn_1: 0.4612 (0.4612) loss_bbox_dn_1: 0.0316 (0.0316) loss_giou_dn_1: 1.0541 (1.0541) loss_fgl_dn_1: 0.9525 (0.9525) loss_ddf_dn_1: 0.0258 (0.0258) loss_vfl_dn_2: 0.4563 (0.4563) loss_bbox_dn_2: 0.0313 (0.0313) loss_giou_dn_2: 1.0483 (1.0483) loss_fgl_dn_2: 0.9551 (0.9551) loss_ddf_dn_2: 0.0018 (0.0018) loss_vfl_dn_3: 0.4519 (0.4519) loss_bbox_dn_3: 0.0312 (0.0312) loss_giou_dn_3: 1.0479 (1.0479) loss_fgl_dn_3: 0.9552 (0.9552) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4509 (0.4509) loss_bbox_dn_4: 0.0311 (0.0311) loss_giou_dn_4: 1.0479 (1.0479) loss_fgl_dn_4: 0.9553 (0.9553) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4517 (0.4517) loss_bbox_dn_5: 0.0312 (0.0312) loss_giou_dn_5: 1.0479 (1.0479) loss_fgl_dn_5: 0.9553 (0.9553) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4104 (0.4104) loss_bbox_dn_pre: 0.0427 (0.0427) loss_giou_dn_pre: 1.1583 (1.1583) time: 1.5313 data: 0.3212 max mem: 31559\n", + "Epoch: [75] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.9735 (37.1443) loss_vfl: 0.1510 (0.1770) loss_bbox: 0.2000 (0.2151) loss_giou: 1.7301 (1.6583) loss_fgl: 0.4942 (0.5342) loss_vfl_aux_0: 0.1575 (0.1896) loss_bbox_aux_0: 0.2065 (0.2203) loss_giou_aux_0: 1.7406 (1.6719) loss_fgl_aux_0: 0.4909 (0.5365) loss_ddf_aux_0: 0.1727 (0.2136) loss_vfl_aux_1: 0.1593 (0.1903) loss_bbox_aux_1: 0.2017 (0.2162) loss_giou_aux_1: 1.7318 (1.6603) loss_fgl_aux_1: 0.4943 (0.5344) loss_ddf_aux_1: 0.0267 (0.0332) loss_vfl_aux_2: 0.1578 (0.1870) loss_bbox_aux_2: 0.2004 (0.2152) loss_giou_aux_2: 1.7288 (1.6587) loss_fgl_aux_2: 0.4943 (0.5341) loss_ddf_aux_2: 0.0041 (0.0047) loss_vfl_aux_3: 0.1539 (0.1817) loss_bbox_aux_3: 0.2002 (0.2151) loss_giou_aux_3: 1.7294 (1.6584) loss_fgl_aux_3: 0.4941 (0.5342) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1517 (0.1781) loss_bbox_aux_4: 0.2000 (0.2150) loss_giou_aux_4: 1.7301 (1.6584) loss_fgl_aux_4: 0.4942 (0.5342) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1573 (0.1872) loss_bbox_pre: 0.2106 (0.2232) loss_giou_pre: 1.7357 (1.6675) loss_vfl_enc_0: 0.1637 (0.1928) loss_bbox_enc_0: 0.2459 (0.2493) loss_giou_enc_0: 1.7921 (1.7139) loss_vfl_dn_0: 0.4336 (0.4382) loss_bbox_dn_0: 0.0394 (0.0449) loss_giou_dn_0: 1.1174 (1.1037) loss_fgl_dn_0: 0.9688 (0.9770) loss_ddf_dn_0: 0.3197 (0.4078) loss_vfl_dn_1: 0.4631 (0.4691) loss_bbox_dn_1: 0.0321 (0.0354) loss_giou_dn_1: 1.0225 (1.0088) loss_fgl_dn_1: 0.9939 (0.9946) loss_ddf_dn_1: 0.0480 (0.0504) loss_vfl_dn_2: 0.4575 (0.4636) loss_bbox_dn_2: 0.0312 (0.0343) loss_giou_dn_2: 1.0138 (0.9999) loss_fgl_dn_2: 0.9940 (0.9968) loss_ddf_dn_2: 0.0038 (0.0056) loss_vfl_dn_3: 0.4570 (0.4602) loss_bbox_dn_3: 0.0311 (0.0341) loss_giou_dn_3: 1.0140 (0.9991) loss_fgl_dn_3: 0.9939 (0.9970) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4575 (0.4585) loss_bbox_dn_4: 0.0311 (0.0341) loss_giou_dn_4: 1.0139 (0.9990) loss_fgl_dn_4: 0.9939 (0.9971) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4583 (0.4586) loss_bbox_dn_5: 0.0311 (0.0341) loss_giou_dn_5: 1.0139 (0.9990) loss_fgl_dn_5: 0.9939 (0.9971) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4324 (0.4372) loss_bbox_dn_pre: 0.0394 (0.0451) loss_giou_dn_pre: 1.1163 (1.1037) time: 0.9841 data: 0.0168 max mem: 31559\n", + "Epoch: [75] Total time: 0:01:18 (0.9319 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.9735 (37.1443) loss_vfl: 0.1510 (0.1770) loss_bbox: 0.2000 (0.2151) loss_giou: 1.7301 (1.6583) loss_fgl: 0.4942 (0.5342) loss_vfl_aux_0: 0.1575 (0.1896) loss_bbox_aux_0: 0.2065 (0.2203) loss_giou_aux_0: 1.7406 (1.6719) loss_fgl_aux_0: 0.4909 (0.5365) loss_ddf_aux_0: 0.1727 (0.2136) loss_vfl_aux_1: 0.1593 (0.1903) loss_bbox_aux_1: 0.2017 (0.2162) loss_giou_aux_1: 1.7318 (1.6603) loss_fgl_aux_1: 0.4943 (0.5344) loss_ddf_aux_1: 0.0267 (0.0332) loss_vfl_aux_2: 0.1578 (0.1870) loss_bbox_aux_2: 0.2004 (0.2152) loss_giou_aux_2: 1.7288 (1.6587) loss_fgl_aux_2: 0.4943 (0.5341) loss_ddf_aux_2: 0.0041 (0.0047) loss_vfl_aux_3: 0.1539 (0.1817) loss_bbox_aux_3: 0.2002 (0.2151) loss_giou_aux_3: 1.7294 (1.6584) loss_fgl_aux_3: 0.4941 (0.5342) loss_ddf_aux_3: 0.0002 (0.0003) loss_vfl_aux_4: 0.1517 (0.1781) loss_bbox_aux_4: 0.2000 (0.2150) loss_giou_aux_4: 1.7301 (1.6584) loss_fgl_aux_4: 0.4942 (0.5342) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1573 (0.1872) loss_bbox_pre: 0.2106 (0.2232) loss_giou_pre: 1.7357 (1.6675) loss_vfl_enc_0: 0.1637 (0.1928) loss_bbox_enc_0: 0.2459 (0.2493) loss_giou_enc_0: 1.7921 (1.7139) loss_vfl_dn_0: 0.4336 (0.4382) loss_bbox_dn_0: 0.0394 (0.0449) loss_giou_dn_0: 1.1174 (1.1037) loss_fgl_dn_0: 0.9688 (0.9770) loss_ddf_dn_0: 0.3197 (0.4078) loss_vfl_dn_1: 0.4631 (0.4691) loss_bbox_dn_1: 0.0321 (0.0354) loss_giou_dn_1: 1.0225 (1.0088) loss_fgl_dn_1: 0.9939 (0.9946) loss_ddf_dn_1: 0.0480 (0.0504) loss_vfl_dn_2: 0.4575 (0.4636) loss_bbox_dn_2: 0.0312 (0.0343) loss_giou_dn_2: 1.0138 (0.9999) loss_fgl_dn_2: 0.9940 (0.9968) loss_ddf_dn_2: 0.0038 (0.0056) loss_vfl_dn_3: 0.4570 (0.4602) loss_bbox_dn_3: 0.0311 (0.0341) loss_giou_dn_3: 1.0140 (0.9991) loss_fgl_dn_3: 0.9939 (0.9970) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4575 (0.4585) loss_bbox_dn_4: 0.0311 (0.0341) loss_giou_dn_4: 1.0139 (0.9990) loss_fgl_dn_4: 0.9939 (0.9971) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4583 (0.4586) loss_bbox_dn_5: 0.0311 (0.0341) loss_giou_dn_5: 1.0139 (0.9990) loss_fgl_dn_5: 0.9939 (0.9971) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4324 (0.4372) loss_bbox_dn_pre: 0.0394 (0.0451) loss_giou_dn_pre: 1.1163 (1.1037)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7837 data: 0.5501 max mem: 31559\n", + "Test: [3/4] eta: 0:00:00 time: 0.4029 data: 0.1746 max mem: 31559\n", + "Test: Total time: 0:00:01 (0.4231 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.103\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.038\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.236\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.222\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.064\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.085\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.319\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.169\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.058\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Load last_epoch\n", + "Load model.state_dict\n", + "Load criterion.state_dict\n", + "Load postprocessor.state_dict\n", + "Load ema.state_dict\n", + "Load scaler.state_dict\n", + "Load optimizer.state_dict\n", + "Load lr_scheduler.state_dict\n", + "Load lr_warmup_scheduler.state_dict\n", + "Refresh EMA at epoch 75 with decay 0.9997\n", + "Epoch: [76] [ 0/84] eta: 0:01:42 lr: 0.000013 loss: 35.8548 (35.8548) loss_vfl: 0.1598 (0.1598) loss_bbox: 0.1621 (0.1621) loss_giou: 1.6381 (1.6381) loss_fgl: 0.4881 (0.4881) loss_vfl_aux_0: 0.1725 (0.1725) loss_bbox_aux_0: 0.1667 (0.1667) loss_giou_aux_0: 1.6479 (1.6479) loss_fgl_aux_0: 0.4838 (0.4838) loss_ddf_aux_0: 0.0809 (0.0809) loss_vfl_aux_1: 0.1727 (0.1727) loss_bbox_aux_1: 0.1634 (0.1634) loss_giou_aux_1: 1.6400 (1.6400) loss_fgl_aux_1: 0.4867 (0.4867) loss_ddf_aux_1: 0.0135 (0.0135) loss_vfl_aux_2: 0.1731 (0.1731) loss_bbox_aux_2: 0.1627 (0.1627) loss_giou_aux_2: 1.6390 (1.6390) loss_fgl_aux_2: 0.4873 (0.4873) loss_ddf_aux_2: 0.0016 (0.0016) loss_vfl_aux_3: 0.1663 (0.1663) loss_bbox_aux_3: 0.1624 (0.1624) loss_giou_aux_3: 1.6385 (1.6385) loss_fgl_aux_3: 0.4875 (0.4875) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1625 (0.1625) loss_bbox_aux_4: 0.1621 (0.1621) loss_giou_aux_4: 1.6382 (1.6382) loss_fgl_aux_4: 0.4881 (0.4881) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1682 (0.1682) loss_bbox_pre: 0.1701 (0.1701) loss_giou_pre: 1.6479 (1.6479) loss_vfl_enc_0: 0.1660 (0.1660) loss_bbox_enc_0: 0.1960 (0.1960) loss_giou_enc_0: 1.6977 (1.6977) loss_vfl_dn_0: 0.4321 (0.4321) loss_bbox_dn_0: 0.0379 (0.0379) loss_giou_dn_0: 1.1290 (1.1290) loss_fgl_dn_0: 0.9539 (0.9539) loss_ddf_dn_0: 0.2348 (0.2348) loss_vfl_dn_1: 0.4634 (0.4634) loss_bbox_dn_1: 0.0309 (0.0309) loss_giou_dn_1: 1.0392 (1.0392) loss_fgl_dn_1: 0.9837 (0.9837) loss_ddf_dn_1: 0.0236 (0.0236) loss_vfl_dn_2: 0.4644 (0.4644) loss_bbox_dn_2: 0.0307 (0.0307) loss_giou_dn_2: 1.0332 (1.0332) loss_fgl_dn_2: 0.9860 (0.9860) loss_ddf_dn_2: 0.0022 (0.0022) loss_vfl_dn_3: 0.4602 (0.4602) loss_bbox_dn_3: 0.0306 (0.0306) loss_giou_dn_3: 1.0330 (1.0330) loss_fgl_dn_3: 0.9860 (0.9860) loss_ddf_dn_3: 0.0002 (0.0002) loss_vfl_dn_4: 0.4563 (0.4563) loss_bbox_dn_4: 0.0306 (0.0306) loss_giou_dn_4: 1.0329 (1.0329) loss_fgl_dn_4: 0.9860 (0.9860) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4541 (0.4541) loss_bbox_dn_5: 0.0306 (0.0306) loss_giou_dn_5: 1.0329 (1.0329) loss_fgl_dn_5: 0.9860 (0.9860) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4312 (0.4312) loss_bbox_dn_pre: 0.0378 (0.0378) loss_giou_dn_pre: 1.1298 (1.1298) time: 1.2241 data: 0.3244 max mem: 31559\n", + "Epoch: [76] [83/84] eta: 0:00:00 lr: 0.000013 loss: 37.3437 (37.2090) loss_vfl: 0.1733 (0.1766) loss_bbox: 0.2157 (0.2190) loss_giou: 1.6028 (1.6763) loss_fgl: 0.5428 (0.5289) loss_vfl_aux_0: 0.1802 (0.1892) loss_bbox_aux_0: 0.2219 (0.2237) loss_giou_aux_0: 1.6112 (1.6876) loss_fgl_aux_0: 0.5474 (0.5317) loss_ddf_aux_0: 0.1803 (0.1788) loss_vfl_aux_1: 0.1787 (0.1890) loss_bbox_aux_1: 0.2161 (0.2205) loss_giou_aux_1: 1.6044 (1.6775) loss_fgl_aux_1: 0.5431 (0.5290) loss_ddf_aux_1: 0.0297 (0.0260) loss_vfl_aux_2: 0.1764 (0.1864) loss_bbox_aux_2: 0.2155 (0.2194) loss_giou_aux_2: 1.6031 (1.6763) loss_fgl_aux_2: 0.5433 (0.5288) loss_ddf_aux_2: 0.0042 (0.0037) loss_vfl_aux_3: 0.1740 (0.1806) loss_bbox_aux_3: 0.2155 (0.2191) loss_giou_aux_3: 1.6029 (1.6762) loss_fgl_aux_3: 0.5430 (0.5289) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1730 (0.1773) loss_bbox_aux_4: 0.2156 (0.2190) loss_giou_aux_4: 1.6028 (1.6763) loss_fgl_aux_4: 0.5428 (0.5290) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1781 (0.1866) loss_bbox_pre: 0.2234 (0.2269) loss_giou_pre: 1.6107 (1.6830) loss_vfl_enc_0: 0.1866 (0.1933) loss_bbox_enc_0: 0.2509 (0.2486) loss_giou_enc_0: 1.6667 (1.7244) loss_vfl_dn_0: 0.4429 (0.4382) loss_bbox_dn_0: 0.0419 (0.0448) loss_giou_dn_0: 1.0952 (1.1050) loss_fgl_dn_0: 0.9835 (0.9746) loss_ddf_dn_0: 0.3591 (0.3861) loss_vfl_dn_1: 0.4705 (0.4689) loss_bbox_dn_1: 0.0330 (0.0353) loss_giou_dn_1: 1.0136 (1.0121) loss_fgl_dn_1: 0.9959 (0.9940) loss_ddf_dn_1: 0.0302 (0.0421) loss_vfl_dn_2: 0.4644 (0.4645) loss_bbox_dn_2: 0.0322 (0.0344) loss_giou_dn_2: 1.0047 (1.0041) loss_fgl_dn_2: 0.9970 (0.9954) loss_ddf_dn_2: 0.0033 (0.0042) loss_vfl_dn_3: 0.4609 (0.4608) loss_bbox_dn_3: 0.0320 (0.0342) loss_giou_dn_3: 1.0040 (1.0034) loss_fgl_dn_3: 0.9972 (0.9956) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4609 (0.4593) loss_bbox_dn_4: 0.0320 (0.0342) loss_giou_dn_4: 1.0038 (1.0034) loss_fgl_dn_4: 0.9973 (0.9956) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4592) loss_bbox_dn_5: 0.0320 (0.0342) loss_giou_dn_5: 1.0038 (1.0034) loss_fgl_dn_5: 0.9973 (0.9956) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4414 (0.4372) loss_bbox_dn_pre: 0.0421 (0.0450) loss_giou_dn_pre: 1.0934 (1.1053) time: 0.9429 data: 0.0168 max mem: 31559\n", + "Epoch: [76] Total time: 0:01:18 (0.9372 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 37.3437 (37.2090) loss_vfl: 0.1733 (0.1766) loss_bbox: 0.2157 (0.2190) loss_giou: 1.6028 (1.6763) loss_fgl: 0.5428 (0.5289) loss_vfl_aux_0: 0.1802 (0.1892) loss_bbox_aux_0: 0.2219 (0.2237) loss_giou_aux_0: 1.6112 (1.6876) loss_fgl_aux_0: 0.5474 (0.5317) loss_ddf_aux_0: 0.1803 (0.1788) loss_vfl_aux_1: 0.1787 (0.1890) loss_bbox_aux_1: 0.2161 (0.2205) loss_giou_aux_1: 1.6044 (1.6775) loss_fgl_aux_1: 0.5431 (0.5290) loss_ddf_aux_1: 0.0297 (0.0260) loss_vfl_aux_2: 0.1764 (0.1864) loss_bbox_aux_2: 0.2155 (0.2194) loss_giou_aux_2: 1.6031 (1.6763) loss_fgl_aux_2: 0.5433 (0.5288) loss_ddf_aux_2: 0.0042 (0.0037) loss_vfl_aux_3: 0.1740 (0.1806) loss_bbox_aux_3: 0.2155 (0.2191) loss_giou_aux_3: 1.6029 (1.6762) loss_fgl_aux_3: 0.5430 (0.5289) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1730 (0.1773) loss_bbox_aux_4: 0.2156 (0.2190) loss_giou_aux_4: 1.6028 (1.6763) loss_fgl_aux_4: 0.5428 (0.5290) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1781 (0.1866) loss_bbox_pre: 0.2234 (0.2269) loss_giou_pre: 1.6107 (1.6830) loss_vfl_enc_0: 0.1866 (0.1933) loss_bbox_enc_0: 0.2509 (0.2486) loss_giou_enc_0: 1.6667 (1.7244) loss_vfl_dn_0: 0.4429 (0.4382) loss_bbox_dn_0: 0.0419 (0.0448) loss_giou_dn_0: 1.0952 (1.1050) loss_fgl_dn_0: 0.9835 (0.9746) loss_ddf_dn_0: 0.3591 (0.3861) loss_vfl_dn_1: 0.4705 (0.4689) loss_bbox_dn_1: 0.0330 (0.0353) loss_giou_dn_1: 1.0136 (1.0121) loss_fgl_dn_1: 0.9959 (0.9940) loss_ddf_dn_1: 0.0302 (0.0421) loss_vfl_dn_2: 0.4644 (0.4645) loss_bbox_dn_2: 0.0322 (0.0344) loss_giou_dn_2: 1.0047 (1.0041) loss_fgl_dn_2: 0.9970 (0.9954) loss_ddf_dn_2: 0.0033 (0.0042) loss_vfl_dn_3: 0.4609 (0.4608) loss_bbox_dn_3: 0.0320 (0.0342) loss_giou_dn_3: 1.0040 (1.0034) loss_fgl_dn_3: 0.9972 (0.9956) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4609 (0.4593) loss_bbox_dn_4: 0.0320 (0.0342) loss_giou_dn_4: 1.0038 (1.0034) loss_fgl_dn_4: 0.9973 (0.9956) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4602 (0.4592) loss_bbox_dn_5: 0.0320 (0.0342) loss_giou_dn_5: 1.0038 (1.0034) loss_fgl_dn_5: 0.9973 (0.9956) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4414 (0.4372) loss_bbox_dn_pre: 0.0421 (0.0450) loss_giou_dn_pre: 1.0934 (1.1053)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7652 data: 0.5267 max mem: 31559\n", + "Test: [3/4] eta: 0:00:00 time: 0.4107 data: 0.1827 max mem: 31559\n", + "Test: Total time: 0:00:01 (0.4255 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.049\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.107\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.040\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.231\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.264\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.009\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.097\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.089\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.314\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.550\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.191\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.074\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Epoch: [77] [ 0/84] eta: 0:01:57 lr: 0.000013 loss: 37.0568 (37.0568) loss_vfl: 0.1998 (0.1998) loss_bbox: 0.2270 (0.2270) loss_giou: 1.5220 (1.5220) loss_fgl: 0.6302 (0.6302) loss_vfl_aux_0: 0.2140 (0.2140) loss_bbox_aux_0: 0.2290 (0.2290) loss_giou_aux_0: 1.5354 (1.5354) loss_fgl_aux_0: 0.6279 (0.6279) loss_ddf_aux_0: 0.1577 (0.1577) loss_vfl_aux_1: 0.2141 (0.2141) loss_bbox_aux_1: 0.2287 (0.2287) loss_giou_aux_1: 1.5239 (1.5239) loss_fgl_aux_1: 0.6296 (0.6296) loss_ddf_aux_1: 0.0273 (0.0273) loss_vfl_aux_2: 0.2123 (0.2123) loss_bbox_aux_2: 0.2280 (0.2280) loss_giou_aux_2: 1.5230 (1.5230) loss_fgl_aux_2: 0.6295 (0.6295) loss_ddf_aux_2: 0.0046 (0.0046) loss_vfl_aux_3: 0.2040 (0.2040) loss_bbox_aux_3: 0.2274 (0.2274) loss_giou_aux_3: 1.5220 (1.5220) loss_fgl_aux_3: 0.6301 (0.6301) loss_ddf_aux_3: 0.0004 (0.0004) loss_vfl_aux_4: 0.2017 (0.2017) loss_bbox_aux_4: 0.2270 (0.2270) loss_giou_aux_4: 1.5221 (1.5221) loss_fgl_aux_4: 0.6303 (0.6303) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.2115 (0.2115) loss_bbox_pre: 0.2324 (0.2324) loss_giou_pre: 1.5332 (1.5332) loss_vfl_enc_0: 0.2158 (0.2158) loss_bbox_enc_0: 0.2646 (0.2646) loss_giou_enc_0: 1.5944 (1.5944) loss_vfl_dn_0: 0.4583 (0.4583) loss_bbox_dn_0: 0.0530 (0.0530) loss_giou_dn_0: 1.0610 (1.0610) loss_fgl_dn_0: 1.0042 (1.0042) loss_ddf_dn_0: 0.5422 (0.5422) loss_vfl_dn_1: 0.4932 (0.4932) loss_bbox_dn_1: 0.0443 (0.0443) loss_giou_dn_1: 0.9587 (0.9587) loss_fgl_dn_1: 1.0195 (1.0195) loss_ddf_dn_1: 0.0936 (0.0936) loss_vfl_dn_2: 0.4836 (0.4836) loss_bbox_dn_2: 0.0429 (0.0429) loss_giou_dn_2: 0.9515 (0.9515) loss_fgl_dn_2: 1.0206 (1.0206) loss_ddf_dn_2: 0.0058 (0.0058) loss_vfl_dn_3: 0.4768 (0.4768) loss_bbox_dn_3: 0.0425 (0.0425) loss_giou_dn_3: 0.9503 (0.9503) loss_fgl_dn_3: 1.0210 (1.0210) loss_ddf_dn_3: 0.0005 (0.0005) loss_vfl_dn_4: 0.4768 (0.4768) loss_bbox_dn_4: 0.0425 (0.0425) loss_giou_dn_4: 0.9501 (0.9501) loss_fgl_dn_4: 1.0211 (1.0211) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4768 (0.4768) loss_bbox_dn_5: 0.0425 (0.0425) loss_giou_dn_5: 0.9501 (0.9501) loss_fgl_dn_5: 1.0211 (1.0211) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4568 (0.4568) loss_bbox_dn_pre: 0.0532 (0.0532) loss_giou_dn_pre: 1.0608 (1.0608) time: 1.3931 data: 0.3326 max mem: 31559\n", + "Epoch: [77] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.8868 (37.2079) loss_vfl: 0.1504 (0.1792) loss_bbox: 0.2094 (0.2156) loss_giou: 1.6754 (1.6605) loss_fgl: 0.5165 (0.5354) loss_vfl_aux_0: 0.1597 (0.1922) loss_bbox_aux_0: 0.2111 (0.2202) loss_giou_aux_0: 1.6850 (1.6740) loss_fgl_aux_0: 0.5207 (0.5377) loss_ddf_aux_0: 0.1853 (0.1907) loss_vfl_aux_1: 0.1589 (0.1930) loss_bbox_aux_1: 0.2091 (0.2168) loss_giou_aux_1: 1.6784 (1.6620) loss_fgl_aux_1: 0.5184 (0.5354) loss_ddf_aux_1: 0.0281 (0.0310) loss_vfl_aux_2: 0.1571 (0.1894) loss_bbox_aux_2: 0.2095 (0.2157) loss_giou_aux_2: 1.6759 (1.6608) loss_fgl_aux_2: 0.5168 (0.5352) loss_ddf_aux_2: 0.0055 (0.0051) loss_vfl_aux_3: 0.1542 (0.1836) loss_bbox_aux_3: 0.2093 (0.2155) loss_giou_aux_3: 1.6756 (1.6606) loss_fgl_aux_3: 0.5166 (0.5354) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1519 (0.1804) loss_bbox_aux_4: 0.2094 (0.2155) loss_giou_aux_4: 1.6754 (1.6605) loss_fgl_aux_4: 0.5166 (0.5354) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1580 (0.1897) loss_bbox_pre: 0.2149 (0.2233) loss_giou_pre: 1.6810 (1.6690) loss_vfl_enc_0: 0.1622 (0.1953) loss_bbox_enc_0: 0.2411 (0.2493) loss_giou_enc_0: 1.7373 (1.7153) loss_vfl_dn_0: 0.4348 (0.4384) loss_bbox_dn_0: 0.0403 (0.0451) loss_giou_dn_0: 1.1180 (1.1102) loss_fgl_dn_0: 0.9702 (0.9767) loss_ddf_dn_0: 0.3239 (0.4115) loss_vfl_dn_1: 0.4607 (0.4705) loss_bbox_dn_1: 0.0331 (0.0357) loss_giou_dn_1: 1.0390 (1.0106) loss_fgl_dn_1: 0.9867 (0.9962) loss_ddf_dn_1: 0.0303 (0.0515) loss_vfl_dn_2: 0.4587 (0.4648) loss_bbox_dn_2: 0.0318 (0.0347) loss_giou_dn_2: 1.0305 (1.0024) loss_fgl_dn_2: 0.9902 (0.9982) loss_ddf_dn_2: 0.0043 (0.0070) loss_vfl_dn_3: 0.4573 (0.4605) loss_bbox_dn_3: 0.0317 (0.0345) loss_giou_dn_3: 1.0297 (1.0016) loss_fgl_dn_3: 0.9907 (0.9984) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4561 (0.4590) loss_bbox_dn_4: 0.0316 (0.0344) loss_giou_dn_4: 1.0297 (1.0015) loss_fgl_dn_4: 0.9907 (0.9985) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4558 (0.4589) loss_bbox_dn_5: 0.0316 (0.0345) loss_giou_dn_5: 1.0298 (1.0015) loss_fgl_dn_5: 0.9907 (0.9985) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4338 (0.4378) loss_bbox_dn_pre: 0.0405 (0.0453) loss_giou_dn_pre: 1.1215 (1.1097) time: 0.9515 data: 0.0167 max mem: 31828\n", + "Epoch: [77] Total time: 0:01:18 (0.9352 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.8868 (37.2079) loss_vfl: 0.1504 (0.1792) loss_bbox: 0.2094 (0.2156) loss_giou: 1.6754 (1.6605) loss_fgl: 0.5165 (0.5354) loss_vfl_aux_0: 0.1597 (0.1922) loss_bbox_aux_0: 0.2111 (0.2202) loss_giou_aux_0: 1.6850 (1.6740) loss_fgl_aux_0: 0.5207 (0.5377) loss_ddf_aux_0: 0.1853 (0.1907) loss_vfl_aux_1: 0.1589 (0.1930) loss_bbox_aux_1: 0.2091 (0.2168) loss_giou_aux_1: 1.6784 (1.6620) loss_fgl_aux_1: 0.5184 (0.5354) loss_ddf_aux_1: 0.0281 (0.0310) loss_vfl_aux_2: 0.1571 (0.1894) loss_bbox_aux_2: 0.2095 (0.2157) loss_giou_aux_2: 1.6759 (1.6608) loss_fgl_aux_2: 0.5168 (0.5352) loss_ddf_aux_2: 0.0055 (0.0051) loss_vfl_aux_3: 0.1542 (0.1836) loss_bbox_aux_3: 0.2093 (0.2155) loss_giou_aux_3: 1.6756 (1.6606) loss_fgl_aux_3: 0.5166 (0.5354) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1519 (0.1804) loss_bbox_aux_4: 0.2094 (0.2155) loss_giou_aux_4: 1.6754 (1.6605) loss_fgl_aux_4: 0.5166 (0.5354) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1580 (0.1897) loss_bbox_pre: 0.2149 (0.2233) loss_giou_pre: 1.6810 (1.6690) loss_vfl_enc_0: 0.1622 (0.1953) loss_bbox_enc_0: 0.2411 (0.2493) loss_giou_enc_0: 1.7373 (1.7153) loss_vfl_dn_0: 0.4348 (0.4384) loss_bbox_dn_0: 0.0403 (0.0451) loss_giou_dn_0: 1.1180 (1.1102) loss_fgl_dn_0: 0.9702 (0.9767) loss_ddf_dn_0: 0.3239 (0.4115) loss_vfl_dn_1: 0.4607 (0.4705) loss_bbox_dn_1: 0.0331 (0.0357) loss_giou_dn_1: 1.0390 (1.0106) loss_fgl_dn_1: 0.9867 (0.9962) loss_ddf_dn_1: 0.0303 (0.0515) loss_vfl_dn_2: 0.4587 (0.4648) loss_bbox_dn_2: 0.0318 (0.0347) loss_giou_dn_2: 1.0305 (1.0024) loss_fgl_dn_2: 0.9902 (0.9982) loss_ddf_dn_2: 0.0043 (0.0070) loss_vfl_dn_3: 0.4573 (0.4605) loss_bbox_dn_3: 0.0317 (0.0345) loss_giou_dn_3: 1.0297 (1.0016) loss_fgl_dn_3: 0.9907 (0.9984) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4561 (0.4590) loss_bbox_dn_4: 0.0316 (0.0344) loss_giou_dn_4: 1.0297 (1.0015) loss_fgl_dn_4: 0.9907 (0.9985) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4558 (0.4589) loss_bbox_dn_5: 0.0316 (0.0345) loss_giou_dn_5: 1.0298 (1.0015) loss_fgl_dn_5: 0.9907 (0.9985) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4338 (0.4378) loss_bbox_dn_pre: 0.0405 (0.0453) loss_giou_dn_pre: 1.1215 (1.1097)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7185 data: 0.4815 max mem: 31828\n", + "Test: [3/4] eta: 0:00:00 time: 0.3887 data: 0.1622 max mem: 31828\n", + "Test: Total time: 0:00:01 (0.4038 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.051\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.108\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.029\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.042\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.232\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.266\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.097\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.090\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.324\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.475\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.191\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.077\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Epoch: [78] [ 0/84] eta: 0:02:29 lr: 0.000013 loss: 37.1916 (37.1916) loss_vfl: 0.1233 (0.1233) loss_bbox: 0.2309 (0.2309) loss_giou: 1.7295 (1.7295) loss_fgl: 0.5007 (0.5007) loss_vfl_aux_0: 0.1317 (0.1317) loss_bbox_aux_0: 0.2395 (0.2395) loss_giou_aux_0: 1.7428 (1.7428) loss_fgl_aux_0: 0.4995 (0.4995) loss_ddf_aux_0: 0.0954 (0.0954) loss_vfl_aux_1: 0.1304 (0.1304) loss_bbox_aux_1: 0.2325 (0.2325) loss_giou_aux_1: 1.7320 (1.7320) loss_fgl_aux_1: 0.5008 (0.5008) loss_ddf_aux_1: 0.0171 (0.0171) loss_vfl_aux_2: 0.1289 (0.1289) loss_bbox_aux_2: 0.2316 (0.2316) loss_giou_aux_2: 1.7291 (1.7291) loss_fgl_aux_2: 0.5009 (0.5009) loss_ddf_aux_2: 0.0031 (0.0031) loss_vfl_aux_3: 0.1255 (0.1255) loss_bbox_aux_3: 0.2311 (0.2311) loss_giou_aux_3: 1.7294 (1.7294) loss_fgl_aux_3: 0.5008 (0.5008) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1241 (0.1241) loss_bbox_aux_4: 0.2310 (0.2310) loss_giou_aux_4: 1.7296 (1.7296) loss_fgl_aux_4: 0.5008 (0.5008) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1295 (0.1295) loss_bbox_pre: 0.2438 (0.2438) loss_giou_pre: 1.7400 (1.7400) loss_vfl_enc_0: 0.1294 (0.1294) loss_bbox_enc_0: 0.2660 (0.2660) loss_giou_enc_0: 1.7774 (1.7774) loss_vfl_dn_0: 0.4250 (0.4250) loss_bbox_dn_0: 0.0436 (0.0436) loss_giou_dn_0: 1.1471 (1.1471) loss_fgl_dn_0: 0.9568 (0.9568) loss_ddf_dn_0: 0.4045 (0.4045) loss_vfl_dn_1: 0.4507 (0.4507) loss_bbox_dn_1: 0.0366 (0.0366) loss_giou_dn_1: 1.0491 (1.0491) loss_fgl_dn_1: 0.9760 (0.9760) loss_ddf_dn_1: 0.1088 (0.1088) loss_vfl_dn_2: 0.4561 (0.4561) loss_bbox_dn_2: 0.0348 (0.0348) loss_giou_dn_2: 1.0318 (1.0318) loss_fgl_dn_2: 0.9831 (0.9831) loss_ddf_dn_2: 0.0213 (0.0213) loss_vfl_dn_3: 0.4495 (0.4495) loss_bbox_dn_3: 0.0345 (0.0345) loss_giou_dn_3: 1.0300 (1.0300) loss_fgl_dn_3: 0.9840 (0.9840) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4492 (0.4492) loss_bbox_dn_4: 0.0345 (0.0345) loss_giou_dn_4: 1.0299 (1.0299) loss_fgl_dn_4: 0.9842 (0.9842) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4482 (0.4482) loss_bbox_dn_5: 0.0345 (0.0345) loss_giou_dn_5: 1.0299 (1.0299) loss_fgl_dn_5: 0.9843 (0.9843) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4246 (0.4246) loss_bbox_dn_pre: 0.0436 (0.0436) loss_giou_dn_pre: 1.1467 (1.1467) time: 1.7788 data: 0.3355 max mem: 31828\n", + "Epoch: [78] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.6044 (36.9079) loss_vfl: 0.1754 (0.1837) loss_bbox: 0.1799 (0.2005) loss_giou: 1.5977 (1.6300) loss_fgl: 0.5458 (0.5485) loss_vfl_aux_0: 0.1870 (0.1974) loss_bbox_aux_0: 0.1785 (0.2047) loss_giou_aux_0: 1.6086 (1.6430) loss_fgl_aux_0: 0.5501 (0.5510) loss_ddf_aux_0: 0.1317 (0.1949) loss_vfl_aux_1: 0.1886 (0.1975) loss_bbox_aux_1: 0.1788 (0.2016) loss_giou_aux_1: 1.6009 (1.6317) loss_fgl_aux_1: 0.5462 (0.5485) loss_ddf_aux_1: 0.0128 (0.0312) loss_vfl_aux_2: 0.1853 (0.1946) loss_bbox_aux_2: 0.1792 (0.2005) loss_giou_aux_2: 1.5984 (1.6306) loss_fgl_aux_2: 0.5463 (0.5485) loss_ddf_aux_2: 0.0024 (0.0041) loss_vfl_aux_3: 0.1791 (0.1882) loss_bbox_aux_3: 0.1793 (0.2003) loss_giou_aux_3: 1.5979 (1.6303) loss_fgl_aux_3: 0.5464 (0.5486) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1759 (0.1844) loss_bbox_aux_4: 0.1796 (0.2004) loss_giou_aux_4: 1.5978 (1.6301) loss_fgl_aux_4: 0.5461 (0.5486) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1842 (0.1950) loss_bbox_pre: 0.1813 (0.2077) loss_giou_pre: 1.6030 (1.6385) loss_vfl_enc_0: 0.1908 (0.2010) loss_bbox_enc_0: 0.2108 (0.2292) loss_giou_enc_0: 1.6404 (1.6788) loss_vfl_dn_0: 0.4480 (0.4421) loss_bbox_dn_0: 0.0399 (0.0442) loss_giou_dn_0: 1.0796 (1.0918) loss_fgl_dn_0: 0.9858 (0.9838) loss_ddf_dn_0: 0.3319 (0.4050) loss_vfl_dn_1: 0.4690 (0.4693) loss_bbox_dn_1: 0.0319 (0.0350) loss_giou_dn_1: 1.0004 (1.0023) loss_fgl_dn_1: 0.9976 (1.0006) loss_ddf_dn_1: 0.0299 (0.0619) loss_vfl_dn_2: 0.4670 (0.4645) loss_bbox_dn_2: 0.0311 (0.0340) loss_giou_dn_2: 0.9912 (0.9927) loss_fgl_dn_2: 1.0008 (1.0038) loss_ddf_dn_2: 0.0035 (0.0073) loss_vfl_dn_3: 0.4612 (0.4603) loss_bbox_dn_3: 0.0311 (0.0337) loss_giou_dn_3: 0.9908 (0.9917) loss_fgl_dn_3: 1.0010 (1.0044) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4602 (0.4587) loss_bbox_dn_4: 0.0311 (0.0337) loss_giou_dn_4: 0.9906 (0.9916) loss_fgl_dn_4: 1.0010 (1.0044) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4600 (0.4587) loss_bbox_dn_5: 0.0312 (0.0337) loss_giou_dn_5: 0.9907 (0.9916) loss_fgl_dn_5: 1.0009 (1.0044) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4468 (0.4414) loss_bbox_dn_pre: 0.0398 (0.0444) loss_giou_dn_pre: 1.0807 (1.0921) time: 0.9186 data: 0.0171 max mem: 32919\n", + "Epoch: [78] Total time: 0:01:17 (0.9271 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.6044 (36.9079) loss_vfl: 0.1754 (0.1837) loss_bbox: 0.1799 (0.2005) loss_giou: 1.5977 (1.6300) loss_fgl: 0.5458 (0.5485) loss_vfl_aux_0: 0.1870 (0.1974) loss_bbox_aux_0: 0.1785 (0.2047) loss_giou_aux_0: 1.6086 (1.6430) loss_fgl_aux_0: 0.5501 (0.5510) loss_ddf_aux_0: 0.1317 (0.1949) loss_vfl_aux_1: 0.1886 (0.1975) loss_bbox_aux_1: 0.1788 (0.2016) loss_giou_aux_1: 1.6009 (1.6317) loss_fgl_aux_1: 0.5462 (0.5485) loss_ddf_aux_1: 0.0128 (0.0312) loss_vfl_aux_2: 0.1853 (0.1946) loss_bbox_aux_2: 0.1792 (0.2005) loss_giou_aux_2: 1.5984 (1.6306) loss_fgl_aux_2: 0.5463 (0.5485) loss_ddf_aux_2: 0.0024 (0.0041) loss_vfl_aux_3: 0.1791 (0.1882) loss_bbox_aux_3: 0.1793 (0.2003) loss_giou_aux_3: 1.5979 (1.6303) loss_fgl_aux_3: 0.5464 (0.5486) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1759 (0.1844) loss_bbox_aux_4: 0.1796 (0.2004) loss_giou_aux_4: 1.5978 (1.6301) loss_fgl_aux_4: 0.5461 (0.5486) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1842 (0.1950) loss_bbox_pre: 0.1813 (0.2077) loss_giou_pre: 1.6030 (1.6385) loss_vfl_enc_0: 0.1908 (0.2010) loss_bbox_enc_0: 0.2108 (0.2292) loss_giou_enc_0: 1.6404 (1.6788) loss_vfl_dn_0: 0.4480 (0.4421) loss_bbox_dn_0: 0.0399 (0.0442) loss_giou_dn_0: 1.0796 (1.0918) loss_fgl_dn_0: 0.9858 (0.9838) loss_ddf_dn_0: 0.3319 (0.4050) loss_vfl_dn_1: 0.4690 (0.4693) loss_bbox_dn_1: 0.0319 (0.0350) loss_giou_dn_1: 1.0004 (1.0023) loss_fgl_dn_1: 0.9976 (1.0006) loss_ddf_dn_1: 0.0299 (0.0619) loss_vfl_dn_2: 0.4670 (0.4645) loss_bbox_dn_2: 0.0311 (0.0340) loss_giou_dn_2: 0.9912 (0.9927) loss_fgl_dn_2: 1.0008 (1.0038) loss_ddf_dn_2: 0.0035 (0.0073) loss_vfl_dn_3: 0.4612 (0.4603) loss_bbox_dn_3: 0.0311 (0.0337) loss_giou_dn_3: 0.9908 (0.9917) loss_fgl_dn_3: 1.0010 (1.0044) loss_ddf_dn_3: 0.0004 (0.0004) loss_vfl_dn_4: 0.4602 (0.4587) loss_bbox_dn_4: 0.0311 (0.0337) loss_giou_dn_4: 0.9906 (0.9916) loss_fgl_dn_4: 1.0010 (1.0044) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4600 (0.4587) loss_bbox_dn_5: 0.0312 (0.0337) loss_giou_dn_5: 0.9907 (0.9916) loss_fgl_dn_5: 1.0009 (1.0044) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4468 (0.4414) loss_bbox_dn_pre: 0.0398 (0.0444) loss_giou_dn_pre: 1.0807 (1.0921)\n", + "Test: [0/4] eta: 0:00:02 time: 0.7423 data: 0.5002 max mem: 32919\n", + "Test: [3/4] eta: 0:00:00 time: 0.3998 data: 0.1686 max mem: 32919\n", + "Test: Total time: 0:00:01 (0.4151 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.048\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.102\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.039\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.232\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.305\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.010\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.062\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.083\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.076\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.323\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.167\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.054\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Load last_epoch\n", + "Load model.state_dict\n", + "Load criterion.state_dict\n", + "Load postprocessor.state_dict\n", + "Load ema.state_dict\n", + "Load scaler.state_dict\n", + "Load optimizer.state_dict\n", + "Load lr_scheduler.state_dict\n", + "Load lr_warmup_scheduler.state_dict\n", + "Refresh EMA at epoch 78 with decay 0.9996\n", + "Epoch: [79] [ 0/84] eta: 0:02:30 lr: 0.000013 loss: 37.7048 (37.7048) loss_vfl: 0.1086 (0.1086) loss_bbox: 0.2490 (0.2490) loss_giou: 1.9012 (1.9012) loss_fgl: 0.4019 (0.4019) loss_vfl_aux_0: 0.1133 (0.1133) loss_bbox_aux_0: 0.2547 (0.2547) loss_giou_aux_0: 1.9058 (1.9058) loss_fgl_aux_0: 0.4012 (0.4012) loss_ddf_aux_0: 0.0590 (0.0590) loss_vfl_aux_1: 0.1112 (0.1112) loss_bbox_aux_1: 0.2497 (0.2497) loss_giou_aux_1: 1.9011 (1.9011) loss_fgl_aux_1: 0.4015 (0.4015) loss_ddf_aux_1: 0.0088 (0.0088) loss_vfl_aux_2: 0.1130 (0.1130) loss_bbox_aux_2: 0.2496 (0.2496) loss_giou_aux_2: 1.9009 (1.9009) loss_fgl_aux_2: 0.4016 (0.4016) loss_ddf_aux_2: 0.0009 (0.0009) loss_vfl_aux_3: 0.1111 (0.1111) loss_bbox_aux_3: 0.2493 (0.2493) loss_giou_aux_3: 1.9011 (1.9011) loss_fgl_aux_3: 0.4016 (0.4016) loss_ddf_aux_3: 0.0001 (0.0001) loss_vfl_aux_4: 0.1097 (0.1097) loss_bbox_aux_4: 0.2490 (0.2490) loss_giou_aux_4: 1.9012 (1.9012) loss_fgl_aux_4: 0.4019 (0.4019) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1105 (0.1105) loss_bbox_pre: 0.2599 (0.2599) loss_giou_pre: 1.9022 (1.9022) loss_vfl_enc_0: 0.1039 (0.1039) loss_bbox_enc_0: 0.2960 (0.2960) loss_giou_enc_0: 1.9371 (1.9371) loss_vfl_dn_0: 0.4253 (0.4253) loss_bbox_dn_0: 0.0362 (0.0362) loss_giou_dn_0: 1.1491 (1.1491) loss_fgl_dn_0: 0.9448 (0.9448) loss_ddf_dn_0: 0.2800 (0.2800) loss_vfl_dn_1: 0.4541 (0.4541) loss_bbox_dn_1: 0.0299 (0.0299) loss_giou_dn_1: 1.0674 (1.0674) loss_fgl_dn_1: 0.9689 (0.9689) loss_ddf_dn_1: 0.0278 (0.0278) loss_vfl_dn_2: 0.4519 (0.4519) loss_bbox_dn_2: 0.0296 (0.0296) loss_giou_dn_2: 1.0597 (1.0597) loss_fgl_dn_2: 0.9715 (0.9715) loss_ddf_dn_2: 0.0025 (0.0025) loss_vfl_dn_3: 0.4514 (0.4514) loss_bbox_dn_3: 0.0295 (0.0295) loss_giou_dn_3: 1.0594 (1.0594) loss_fgl_dn_3: 0.9717 (0.9717) loss_ddf_dn_3: 0.0003 (0.0003) loss_vfl_dn_4: 0.4480 (0.4480) loss_bbox_dn_4: 0.0295 (0.0295) loss_giou_dn_4: 1.0594 (1.0594) loss_fgl_dn_4: 0.9718 (0.9718) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4470 (0.4470) loss_bbox_dn_5: 0.0295 (0.0295) loss_giou_dn_5: 1.0594 (1.0594) loss_fgl_dn_5: 0.9718 (0.9718) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4243 (0.4243) loss_bbox_dn_pre: 0.0360 (0.0360) loss_giou_dn_pre: 1.1489 (1.1489) time: 1.7894 data: 0.3276 max mem: 32919\n", + "Epoch: [79] [83/84] eta: 0:00:00 lr: 0.000013 loss: 36.9421 (37.0464) loss_vfl: 0.1910 (0.1762) loss_bbox: 0.2145 (0.2115) loss_giou: 1.6483 (1.6684) loss_fgl: 0.5111 (0.5266) loss_vfl_aux_0: 0.2013 (0.1891) loss_bbox_aux_0: 0.2144 (0.2163) loss_giou_aux_0: 1.6693 (1.6808) loss_fgl_aux_0: 0.5140 (0.5289) loss_ddf_aux_0: 0.1965 (0.1723) loss_vfl_aux_1: 0.2009 (0.1889) loss_bbox_aux_1: 0.2151 (0.2129) loss_giou_aux_1: 1.6512 (1.6698) loss_fgl_aux_1: 0.5101 (0.5266) loss_ddf_aux_1: 0.0325 (0.0262) loss_vfl_aux_2: 0.1960 (0.1861) loss_bbox_aux_2: 0.2146 (0.2118) loss_giou_aux_2: 1.6482 (1.6684) loss_fgl_aux_2: 0.5105 (0.5264) loss_ddf_aux_2: 0.0048 (0.0038) loss_vfl_aux_3: 0.1951 (0.1804) loss_bbox_aux_3: 0.2146 (0.2115) loss_giou_aux_3: 1.6484 (1.6684) loss_fgl_aux_3: 0.5111 (0.5266) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1902 (0.1769) loss_bbox_aux_4: 0.2144 (0.2114) loss_giou_aux_4: 1.6484 (1.6685) loss_fgl_aux_4: 0.5111 (0.5267) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1985 (0.1865) loss_bbox_pre: 0.2199 (0.2192) loss_giou_pre: 1.6664 (1.6762) loss_vfl_enc_0: 0.2075 (0.1914) loss_bbox_enc_0: 0.2419 (0.2424) loss_giou_enc_0: 1.7115 (1.7217) loss_vfl_dn_0: 0.4365 (0.4330) loss_bbox_dn_0: 0.0470 (0.0454) loss_giou_dn_0: 1.1082 (1.1160) loss_fgl_dn_0: 0.9730 (0.9663) loss_ddf_dn_0: 0.3890 (0.3810) loss_vfl_dn_1: 0.4683 (0.4679) loss_bbox_dn_1: 0.0360 (0.0357) loss_giou_dn_1: 1.0003 (1.0140) loss_fgl_dn_1: 0.9928 (0.9898) loss_ddf_dn_1: 0.0388 (0.0389) loss_vfl_dn_2: 0.4609 (0.4626) loss_bbox_dn_2: 0.0350 (0.0347) loss_giou_dn_2: 0.9909 (1.0059) loss_fgl_dn_2: 0.9942 (0.9913) loss_ddf_dn_2: 0.0039 (0.0036) loss_vfl_dn_3: 0.4568 (0.4590) loss_bbox_dn_3: 0.0346 (0.0346) loss_giou_dn_3: 0.9896 (1.0052) loss_fgl_dn_3: 0.9945 (0.9915) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4543 (0.4571) loss_bbox_dn_4: 0.0346 (0.0345) loss_giou_dn_4: 0.9895 (1.0052) loss_fgl_dn_4: 0.9944 (0.9915) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4539 (0.4572) loss_bbox_dn_5: 0.0346 (0.0345) loss_giou_dn_5: 0.9895 (1.0052) loss_fgl_dn_5: 0.9943 (0.9915) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4358 (0.4320) loss_bbox_dn_pre: 0.0472 (0.0456) loss_giou_dn_pre: 1.1078 (1.1161) time: 0.8736 data: 0.0172 max mem: 32919\n", + "Epoch: [79] Total time: 0:01:19 (0.9426 s / it)\n", + "Averaged stats: lr: 0.000013 loss: 36.9421 (37.0464) loss_vfl: 0.1910 (0.1762) loss_bbox: 0.2145 (0.2115) loss_giou: 1.6483 (1.6684) loss_fgl: 0.5111 (0.5266) loss_vfl_aux_0: 0.2013 (0.1891) loss_bbox_aux_0: 0.2144 (0.2163) loss_giou_aux_0: 1.6693 (1.6808) loss_fgl_aux_0: 0.5140 (0.5289) loss_ddf_aux_0: 0.1965 (0.1723) loss_vfl_aux_1: 0.2009 (0.1889) loss_bbox_aux_1: 0.2151 (0.2129) loss_giou_aux_1: 1.6512 (1.6698) loss_fgl_aux_1: 0.5101 (0.5266) loss_ddf_aux_1: 0.0325 (0.0262) loss_vfl_aux_2: 0.1960 (0.1861) loss_bbox_aux_2: 0.2146 (0.2118) loss_giou_aux_2: 1.6482 (1.6684) loss_fgl_aux_2: 0.5105 (0.5264) loss_ddf_aux_2: 0.0048 (0.0038) loss_vfl_aux_3: 0.1951 (0.1804) loss_bbox_aux_3: 0.2146 (0.2115) loss_giou_aux_3: 1.6484 (1.6684) loss_fgl_aux_3: 0.5111 (0.5266) loss_ddf_aux_3: 0.0003 (0.0003) loss_vfl_aux_4: 0.1902 (0.1769) loss_bbox_aux_4: 0.2144 (0.2114) loss_giou_aux_4: 1.6484 (1.6685) loss_fgl_aux_4: 0.5111 (0.5267) loss_ddf_aux_4: 0.0001 (0.0001) loss_vfl_pre: 0.1985 (0.1865) loss_bbox_pre: 0.2199 (0.2192) loss_giou_pre: 1.6664 (1.6762) loss_vfl_enc_0: 0.2075 (0.1914) loss_bbox_enc_0: 0.2419 (0.2424) loss_giou_enc_0: 1.7115 (1.7217) loss_vfl_dn_0: 0.4365 (0.4330) loss_bbox_dn_0: 0.0470 (0.0454) loss_giou_dn_0: 1.1082 (1.1160) loss_fgl_dn_0: 0.9730 (0.9663) loss_ddf_dn_0: 0.3890 (0.3810) loss_vfl_dn_1: 0.4683 (0.4679) loss_bbox_dn_1: 0.0360 (0.0357) loss_giou_dn_1: 1.0003 (1.0140) loss_fgl_dn_1: 0.9928 (0.9898) loss_ddf_dn_1: 0.0388 (0.0389) loss_vfl_dn_2: 0.4609 (0.4626) loss_bbox_dn_2: 0.0350 (0.0347) loss_giou_dn_2: 0.9909 (1.0059) loss_fgl_dn_2: 0.9942 (0.9913) loss_ddf_dn_2: 0.0039 (0.0036) loss_vfl_dn_3: 0.4568 (0.4590) loss_bbox_dn_3: 0.0346 (0.0346) loss_giou_dn_3: 0.9896 (1.0052) loss_fgl_dn_3: 0.9945 (0.9915) loss_ddf_dn_3: 0.0004 (0.0003) loss_vfl_dn_4: 0.4543 (0.4571) loss_bbox_dn_4: 0.0346 (0.0345) loss_giou_dn_4: 0.9895 (1.0052) loss_fgl_dn_4: 0.9944 (0.9915) loss_ddf_dn_4: 0.0002 (0.0002) loss_vfl_dn_5: 0.4539 (0.4572) loss_bbox_dn_5: 0.0346 (0.0345) loss_giou_dn_5: 0.9895 (1.0052) loss_fgl_dn_5: 0.9943 (0.9915) loss_ddf_dn_5: 0.0000 (0.0000) loss_vfl_dn_pre: 0.4358 (0.4320) loss_bbox_dn_pre: 0.0472 (0.0456) loss_giou_dn_pre: 1.1078 (1.1161)\n", + "Test: [0/4] eta: 0:00:03 time: 0.7636 data: 0.5302 max mem: 32919\n", + "Test: [3/4] eta: 0:00:00 time: 0.4043 data: 0.1767 max mem: 32919\n", + "Test: Total time: 0:00:01 (0.4199 s / it)\n", + "Averaged stats: \n", + "Accumulating evaluation results...\n", + "COCOeval_opt.accumulate() finished...\n", + "DONE (t=0.06s).\n", + "IoU metric: bbox\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.052\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.110\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.026\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.043\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.238\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.216\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.098\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.091\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.313\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.193\n", + " Average Recall (AR) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.075\n", + "best_stat: {'epoch': 72, 'coco_eval_bbox': 0.05215868535188683}\n", + "Training time 1:45:35\n" + ] + } + ], + "source": [ + "!CUDA_VISIBLE_DEVICES=0 torchrun --master_port=7777 --nproc_per_node=1 D-FINE/train.py -c D-FINE/configs/dfine/custom/dfine_hgnetv2_l_custom.yml --use-amp --seed=0" + ] + }, + { + "cell_type": "code", + "source": [ + "%tensorboard --logdir /content/output/dfine_hgnetv2_l_custom/summary" + ], + "metadata": { + "colab": { + "resources": { + "https://localhost:6007/?tensorboardColab=true": { + "data": "<!doctype html><meta name="tb-relative-root" content="./"><!doctype html><!--
@license
Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--><html><head><meta charset="utf-8">
<title>TensorBoard</title>
<link rel="shortcut icon" href="data:image/png;base64,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">
<link rel="apple-touch-icon" href="data:image/png;base64,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">

<style>
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/uYECMKoHcO9x1wdmbyHIm3-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/sTdaA6j0Psb920Vjv-mrzH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/_VYFx-s824kXq_Ul2BHqYH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/tnj4SB6DNbdaQnsM8CFqBX-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/Ks_cVxiCiwUWVsFWFA3Bjn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/NJ4vxlgWwWbEsv18dAhqnn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/isZ-wbCXNKAbnjo6_TwHToX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/77FXFjRbGzN4aCrSFhlh3oX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/jSN2CGVDbcVyCnfJfjSdfIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/UX6i4JxQDm3fVTc1CPuwqoX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/97uahxiqZRoncBaCEI3aW4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/PwZc-YbIL414wB9rB1IAPYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcCwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/OpXUqTo0UgQQhGj_SFdLWBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/WxrXJa0C3KdtC7lMafG4dRkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/cDKhRaXnQTOVbaoxwdOr9xkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/1hZf02POANh32k2VkgEoUBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vSzulfKSK0LLjjfeaxcREhkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/K23cxWVTrIFD6DJsEVi07RkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Fl4y0QdOxyyTHEGMXX8kcYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/0eC6fl06luXEYWpBSJvXCIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/I3S1wsgSg9YCurV6PUkTOYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/-L14Jk06m6pUHB-5mXQQnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Hgo13k-tfSpn0qi1SFdUfZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Pru33qjShpZSmG3z6VYwnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/NYDWBdD4gIq26G5XYbHsFIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0atwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oHi30kwQWvpCWqAhzHcCSIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/ZLqKeelYbATG60EpZBSDy4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mx9Uck6uB63VIKFYnEMXrYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/rGvHdJnr2l75qb0YND9NyIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oOeFwZNlrTefzLYmlVV1UIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mbmhprMH69Zi6eEPBYVFhYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0V4sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0fZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Qt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0VBW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Ygp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0aE8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0dDiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpYwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1x-M1I1w5OMiqnVF8xBLhU.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59FzwXaAXup5mZlfK6xRLrhsco.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fzwn6Wqxo-xwxilDXPU8chVU.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1T7aJLK6nKpn36IMwTcMMc.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz_79_ZuUxCigM2DespTnFaw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz4gd9OEPUCN3AdYW0e8tat4.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz8bIQSYZnWLaWC9QNCpTK_U.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
</style>



<style>.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale3d(0, 0, 0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-h1,.mat-headline,.mat-typography .mat-h1,.mat-typography .mat-headline,.mat-typography h1{font-size:24px;font-weight:400;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography .mat-h2,.mat-typography .mat-title,.mat-typography h2{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography .mat-h3,.mat-typography .mat-subheading-2,.mat-typography h3{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography .mat-h4,.mat-typography .mat-subheading-1,.mat-typography h4{font-size:15px;font-weight:400;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2,.mat-typography .mat-body-strong,.mat-typography .mat-body-2{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography .mat-body,.mat-typography .mat-body-1,.mat-typography{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography .mat-body p,.mat-typography .mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font-size:12px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font-size:112px;font-weight:300;line-height:112px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font-size:56px;font-weight:400;line-height:56px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font-size:45px;font-weight:400;line-height:48px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font-size:34px;font-weight:400;line-height:40px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-bottom-sheet-container{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font-size:14px;font-weight:500;line-height:24px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-datepicker-content .mdc-button{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, "Helvetica Neue", sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 14px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, normal);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}input.mat-input-element{margin-top:-0.0625em}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid rgba(0,0,0,0)}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-dialog-title{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline-5,.mat-typography .mat-h1,.mat-typography .mat-headline-5,.mat-typography h1{font-size:24px;font-weight:400;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-headline-6,.mat-typography .mat-h2,.mat-typography .mat-headline-6,.mat-typography h2{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:.0125em;margin:0 0 16px}.mat-h3,.mat-subtitle-1,.mat-typography .mat-h3,.mat-typography .mat-subtitle-1,.mat-typography h3{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, sans-serif;letter-spacing:.009375em;margin:0 0 16px}.mat-h4,.mat-body-1,.mat-typography .mat-h4,.mat-typography .mat-body-1,.mat-typography h4{font-size:16px;font-weight:400;line-height:24px;font-family:Roboto, sans-serif;letter-spacing:.03125em;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, sans-serif;margin:0 0 12px}.mat-body-strong,.mat-subtitle-2,.mat-typography .mat-body-strong,.mat-typography .mat-subtitle-2{font-size:14px;font-weight:500;line-height:22px;font-family:Roboto, sans-serif;letter-spacing:.0071428571em}.mat-body,.mat-body-2,.mat-typography .mat-body,.mat-typography .mat-body-2,.mat-typography{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-body p,.mat-body-2 p,.mat-typography .mat-body p,.mat-typography .mat-body-2 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font-size:12px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0333333333em}.mat-headline-1,.mat-typography .mat-headline-1{font-size:96px;font-weight:300;line-height:96px;font-family:Roboto, sans-serif;letter-spacing:-0.015625em;margin:0 0 56px}.mat-headline-2,.mat-typography .mat-headline-2{font-size:60px;font-weight:300;line-height:60px;font-family:Roboto, sans-serif;letter-spacing:-.0083333333em;margin:0 0 64px}.mat-headline-3,.mat-typography .mat-headline-3{font-size:48px;font-weight:400;line-height:50px;font-family:Roboto, sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-headline-4,.mat-typography .mat-headline-4{font-size:34px;font-weight:400;line-height:40px;font-family:Roboto, sans-serif;letter-spacing:.0073529412em;margin:0 0 64px}.mat-bottom-sheet-container{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-button-toggle{font-family:Roboto, sans-serif}.mat-calendar{font-family:Roboto, sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-expansion-panel-header{font-family:Roboto, sans-serif;font-size:14px;font-weight:500}.mat-expansion-panel-content{font-size:14px;font-weight:400;line-height:20px;font-family:Roboto, sans-serif;letter-spacing:.0178571429em}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:16px}.mat-step-label-selected{font-size:16px;font-weight:400}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font-size:20px;font-weight:500;line-height:32px;font-family:Roboto, sans-serif;letter-spacing:.0125em;margin:0}.mat-tree{font-family:Roboto, sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-mdc-option{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em)}.mat-mdc-card-title{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-headline6-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-headline6-font-size, 20px);line-height:var(--mdc-typography-headline6-line-height, 32px);font-weight:var(--mdc-typography-headline6-font-weight, 500);letter-spacing:var(--mdc-typography-headline6-letter-spacing, 0.0125em);text-decoration:var(--mdc-typography-headline6-text-decoration, inherit);text-transform:var(--mdc-typography-headline6-text-transform, none)}.mat-mdc-card-subtitle{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle2-font-size, 14px);line-height:var(--mdc-typography-subtitle2-line-height, 22px);font-weight:var(--mdc-typography-subtitle2-font-weight, 500);letter-spacing:var(--mdc-typography-subtitle2-letter-spacing, 0.0071428571em);text-decoration:var(--mdc-typography-subtitle2-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle2-text-transform, none)}.mat-mdc-tooltip{--mdc-plain-tooltip-supporting-text-font:Roboto, sans-serif;--mdc-plain-tooltip-supporting-text-size:12px;--mdc-plain-tooltip-supporting-text-weight:400;--mdc-plain-tooltip-supporting-text-tracking:0.0333333333em}.mdc-text-field__input{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mdc-text-field__affix{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mdc-text-field--textarea .mdc-text-field__input{line-height:1.5rem}.mdc-floating-label{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none)}.mat-mdc-form-field-subscript-wrapper,.mat-mdc-form-field-bottom-align::before{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-caption-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-caption-font-size, 12px);line-height:var(--mdc-typography-caption-line-height, 20px);font-weight:var(--mdc-typography-caption-font-weight, 400);letter-spacing:var(--mdc-typography-caption-letter-spacing, 0.0333333333em);text-decoration:var(--mdc-typography-caption-text-decoration, inherit);text-transform:var(--mdc-typography-caption-text-transform, none)}.mat-mdc-form-field,.mat-mdc-floating-label{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-form-field .mdc-text-field--outlined .mdc-floating-label--float-above{font-size:calc(16px * var(--mat-mdc-form-field-floating-label-scale, 0.75))}.mat-mdc-form-field .mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:16px}.mat-mdc-select-panel{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-select{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-autocomplete-panel{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-dialog-container{--mdc-dialog-subhead-font:Roboto, sans-serif;--mdc-dialog-subhead-line-height:32px;--mdc-dialog-subhead-size:20px;--mdc-dialog-subhead-weight:500;--mdc-dialog-subhead-tracking:0.0125em;--mdc-dialog-supporting-text-font:Roboto, sans-serif;--mdc-dialog-supporting-text-line-height:24px;--mdc-dialog-supporting-text-size:16px;--mdc-dialog-supporting-text-weight:400;--mdc-dialog-supporting-text-tracking:0.03125em}.mat-mdc-standard-chip{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mat-mdc-slider{--mdc-slider-label-label-text-font:Roboto, sans-serif;--mdc-slider-label-label-text-size:14px;--mdc-slider-label-label-text-line-height:22px;--mdc-slider-label-label-text-tracking:0.0071428571em;--mdc-slider-label-label-text-weight:500}.mat-mdc-menu-content{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle1-font-size, 16px);line-height:var(--mdc-typography-subtitle1-line-height, 28px);font-weight:var(--mdc-typography-subtitle1-font-weight, 400);letter-spacing:var(--mdc-typography-subtitle1-letter-spacing, 0.009375em);text-decoration:var(--mdc-typography-subtitle1-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle1-text-transform, none);line-height:24px}.mat-mdc-menu-content,.mat-mdc-menu-content .mat-mdc-menu-item .mdc-list-item__primary-text{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body1-font-size, 16px);line-height:var(--mdc-typography-body1-line-height, 24px);font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:var(--mdc-typography-body1-text-transform, none)}.mat-mdc-list-base{--mdc-list-list-item-label-text-font:Roboto, sans-serif;--mdc-list-list-item-label-text-line-height:24px;--mdc-list-list-item-label-text-size:16px;--mdc-list-list-item-label-text-tracking:0.03125em;--mdc-list-list-item-label-text-weight:400;--mdc-list-list-item-supporting-text-font:Roboto, sans-serif;--mdc-list-list-item-supporting-text-line-height:20px;--mdc-list-list-item-supporting-text-size:14px;--mdc-list-list-item-supporting-text-tracking:0.0178571429em;--mdc-list-list-item-supporting-text-weight:400;--mdc-list-list-item-trailing-supporting-text-font:Roboto, sans-serif;--mdc-list-list-item-trailing-supporting-text-line-height:20px;--mdc-list-list-item-trailing-supporting-text-size:12px;--mdc-list-list-item-trailing-supporting-text-tracking:0.0333333333em;--mdc-list-list-item-trailing-supporting-text-weight:400}.mdc-list-group__subheader{font-size:16px;font-weight:400;line-height:28px;font-family:Roboto, sans-serif;letter-spacing:.009375em}.mat-mdc-paginator{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-caption-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-caption-font-size, 12px);line-height:var(--mdc-typography-caption-line-height, 20px);font-weight:var(--mdc-typography-caption-font-weight, 400);letter-spacing:var(--mdc-typography-caption-letter-spacing, 0.0333333333em);text-decoration:var(--mdc-typography-caption-text-decoration, inherit);text-transform:var(--mdc-typography-caption-text-transform, none)}.mat-mdc-paginator .mat-mdc-select-value{font-size:12px}.mdc-tab{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}@media all and (-ms-high-contrast: none){.mdc-checkbox .mdc-checkbox__focus-ring{display:none}}.mdc-form-field{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-button{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mdc-fab--extended{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-button-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-button-font-size, 14px);line-height:var(--mdc-typography-button-line-height, 36px);font-weight:var(--mdc-typography-button-font-weight, 500);letter-spacing:var(--mdc-typography-button-letter-spacing, 0.0892857143em);text-decoration:var(--mdc-typography-button-text-decoration, none);text-transform:var(--mdc-typography-button-text-transform, none)}.mat-mdc-snack-bar-container{--mdc-snackbar-supporting-text-font:Roboto, sans-serif;--mdc-snackbar-supporting-text-line-height:20px;--mdc-snackbar-supporting-text-size:14px;--mdc-snackbar-supporting-text-weight:400}.mdc-data-table__content{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-data-table__cell{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-body2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-body2-font-size, 14px);line-height:var(--mdc-typography-body2-line-height, 20px);font-weight:var(--mdc-typography-body2-font-weight, 400);letter-spacing:var(--mdc-typography-body2-letter-spacing, 0.0178571429em);text-decoration:var(--mdc-typography-body2-text-decoration, inherit);text-transform:var(--mdc-typography-body2-text-transform, none)}.mdc-data-table__header-cell{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:var(--mdc-typography-subtitle2-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:var(--mdc-typography-subtitle2-font-size, 14px);line-height:var(--mdc-typography-subtitle2-line-height, 22px);font-weight:var(--mdc-typography-subtitle2-font-weight, 500);letter-spacing:var(--mdc-typography-subtitle2-letter-spacing, 0.0071428571em);text-decoration:var(--mdc-typography-subtitle2-text-decoration, inherit);text-transform:var(--mdc-typography-subtitle2-text-transform, none)}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-option:hover:not(.mdc-list-item--disabled),.mat-mdc-option:focus:not(.mdc-list-item--disabled),.mat-mdc-option.mat-mdc-option-active,.mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(0,0,0,.04)}.mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ff9800)}.mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}.mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0,.mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1,.mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2,.mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3,.mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4,.mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5,.mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6,.mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7,.mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8,.mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9,.mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10,.mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11,.mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12,.mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13,.mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14,.mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15,.mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16,.mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17,.mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18,.mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19,.mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20,.mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21,.mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22,.mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23,.mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24,.mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#fff}.mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#e0e0e0}.mat-mdc-card-subtitle{color:#616161}.mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#f57c00}.mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(245, 124, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(245, 124, 0, 0.25)}.mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ff9800}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(255, 152, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(255, 152, 0, 0.25)}.mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}.mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(0, 0, 0, 0.87)}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.6)}}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.6)}}.mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field--filled .mdc-text-field__ripple::before,.mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(0, 0, 0, 0.87))}.mdc-text-field--filled:hover .mdc-text-field__ripple::before,.mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:whitesmoke}.mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.42)}.mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.38)}.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined .mdc-text-field__ripple::before,.mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}.mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(245, 124, 0, 0.87)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--disabled .mdc-text-field__input{color:rgba(0, 0, 0, 0.38)}@media all{.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.38)}}@media all{.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.38)}}.mdc-text-field--disabled .mdc-floating-label{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.06)}.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}.mdc-text-field--disabled.mdc-text-field--filled{background-color:#fafafa}.mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field-focus-overlay{background-color:rgba(0,0,0,.87)}.mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.04}.mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.12}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.54)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(245,124,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(255,152,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}.mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.38)}.mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 152, 0, 0.87)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}[dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}.mat-mdc-form-field-infix{min-height:56px}.mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}.mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-select-value{color:rgba(0,0,0,.87)}.mat-mdc-select-placeholder{color:rgba(0,0,0,.6)}.mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(0,0,0,.38)}.mat-mdc-select-arrow{color:rgba(0,0,0,.54)}.mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(245,124,0,.87)}.mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(255,152,0,.87)}.mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(0,0,0,.38)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-dialog-container{--mdc-dialog-container-color:white;--mdc-dialog-with-divider-divider-color:rgba(0, 0, 0, 0.12);--mdc-dialog-subhead-color:rgba(0, 0, 0, 0.87);--mdc-dialog-supporting-text-color:rgba(0, 0, 0, 0.6)}.mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#e0e0e0;--mdc-chip-elevated-disabled-container-color:#e0e0e0;--mdc-chip-label-text-color:#212121;--mdc-chip-disabled-label-text-color:#212121;--mdc-chip-with-icon-icon-color:#212121;--mdc-chip-with-icon-disabled-icon-color:#212121;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#212121;--mdc-chip-with-trailing-icon-trailing-icon-color:#212121;--mdc-chip-with-icon-selected-icon-color:#212121}.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f57c00;--mdc-chip-elevated-disabled-container-color:#f57c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ff9800;--mdc-chip-elevated-disabled-container-color:#ff9800;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-chip-focus-overlay{background:#000}.mat-mdc-chip{height:32px}.mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#424242;--mdc-switch-disabled-unselected-handle-color:#424242;--mdc-switch-disabled-selected-track-color:#424242;--mdc-switch-disabled-unselected-track-color:#424242;--mdc-switch-unselected-focus-state-layer-color:#424242;--mdc-switch-unselected-pressed-state-layer-color:#424242;--mdc-switch-unselected-hover-state-layer-color:#424242;--mdc-switch-unselected-focus-track-color:#e0e0e0;--mdc-switch-unselected-hover-track-color:#e0e0e0;--mdc-switch-unselected-pressed-track-color:#e0e0e0;--mdc-switch-unselected-track-color:#e0e0e0;--mdc-switch-unselected-focus-handle-color:#212121;--mdc-switch-unselected-hover-handle-color:#212121;--mdc-switch-unselected-pressed-handle-color:#212121;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#616161;--mdc-switch-selected-icon-color:#fff;--mdc-switch-disabled-selected-icon-color:#fff;--mdc-switch-disabled-unselected-icon-color:#fff;--mdc-switch-unselected-icon-color:#fff}.mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#757575}.mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e53935;--mdc-switch-selected-handle-color:#e53935;--mdc-switch-selected-hover-state-layer-color:#e53935;--mdc-switch-selected-pressed-state-layer-color:#e53935;--mdc-switch-selected-focus-handle-color:#b71c1c;--mdc-switch-selected-hover-handle-color:#b71c1c;--mdc-switch-selected-pressed-handle-color:#b71c1c;--mdc-switch-selected-focus-track-color:#e57373;--mdc-switch-selected-hover-track-color:#e57373;--mdc-switch-selected-pressed-track-color:#e57373;--mdc-switch-selected-track-color:#e57373}.mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}.mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}.mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}.mat-mdc-slider{--mdc-slider-label-container-color:black;--mdc-slider-label-label-text-color:white;--mdc-slider-disabled-handle-color:#000;--mdc-slider-disabled-active-track-color:#000;--mdc-slider-disabled-inactive-track-color:#000;--mdc-slider-with-tick-marks-disabled-container-color:#000;--mat-mdc-slider-value-indicator-opacity: 0.6}.mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#f57c00;--mdc-slider-focus-handle-color:#f57c00;--mdc-slider-hover-handle-color:#f57c00;--mdc-slider-active-track-color:#f57c00;--mdc-slider-inactive-track-color:#f57c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#f57c00;--mat-mdc-slider-ripple-color: #f57c00;--mat-mdc-slider-hover-ripple-color: rgba(245, 124, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(245, 124, 0, 0.2)}.mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ff9800;--mdc-slider-focus-handle-color:#ff9800;--mdc-slider-hover-handle-color:#ff9800;--mdc-slider-active-track-color:#ff9800;--mdc-slider-inactive-track-color:#ff9800;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ff9800;--mat-mdc-slider-ripple-color: #ff9800;--mat-mdc-slider-hover-ripple-color: rgba(255, 152, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(255, 152, 0, 0.2)}.mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-menu-item[disabled],.mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,.mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(0, 0, 0, 0.38))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-menu-item:hover:not([disabled]),.mat-mdc-menu-item.cdk-program-focused:not([disabled]),.mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),.mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-mdc-list-base{--mdc-list-list-item-label-text-color:#212121;--mdc-list-list-item-supporting-text-color:#616161;--mdc-list-list-item-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-supporting-text-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-selected-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-disabled-label-text-color:black;--mdc-list-list-item-disabled-leading-icon-color:black;--mdc-list-list-item-disabled-trailing-icon-color:black;--mdc-list-list-item-hover-label-text-color:#212121;--mdc-list-list-item-hover-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-hover-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-focus-label-text-color:#212121;--mdc-list-list-item-hover-state-layer-color:black;--mdc-list-list-item-hover-state-layer-opacity:0.04;--mdc-list-list-item-focus-state-layer-color:black;--mdc-list-list-item-focus-state-layer-opacity:0.12}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#f57c00}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#f57c00}.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}.mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}.mat-mdc-paginator{background:#fff;color:rgba(0,0,0,.87)}.mat-mdc-paginator-icon{fill:rgba(0,0,0,.54)}.mat-mdc-paginator-decrement,.mat-mdc-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-mdc-paginator-first,.mat-mdc-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(0,0,0,.12)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(0,0,0,.12)}.mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}.mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}.mat-mdc-paginator-container{min-height:56px}.mat-mdc-tab,.mat-mdc-tab-link{background-color:rgba(0,0,0,0)}.mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-link .mdc-tab__text-label{color:rgba(0, 0, 0, 0.6)}.mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,.mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(0,0,0,.38)}.mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f57c00}.mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f57c00)}.mdc-tab__ripple::before,.mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-link .mat-ripple-element{background-color:#f57c00}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ff9800}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ff9800)}.mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ff9800}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}.mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}.mat-mdc-tab-group.mat-background-primary,.mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #f57c00;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-accent,.mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ff9800;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-warn,.mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}.mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #000)}.mat-mdc-tab-header .mdc-tab{height:48px}.mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-checkbox .mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-checkbox .mdc-checkbox__ripple{background:#000}.mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(245,124,0,.1)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f57c00}.mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(255,152,0,.1)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ff9800}.mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}.mat-mdc-checkbox-disabled label{color:#757575}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}.mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-button,.mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button.mat-primary,.mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-button.mat-accent,.mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-button.mat-warn,.mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-raised-button,.mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button.mat-primary,.mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-accent,.mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-warn,.mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-fab,.mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-fab.mat-unthemed,.mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#fff;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#f57c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ff9800;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}.mat-mdc-fab[disabled][disabled],.mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(0, 0, 0, 0.12);--mdc-fab-icon-color:rgba(0, 0, 0, 0.38);--mat-mdc-fab-color: rgba(0, 0, 0, 0.38)}.mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: #ff9800;--mdc-snackbar-container-color:#333333;--mdc-snackbar-supporting-text-color:rgba(255, 255, 255, 0.87)}.mdc-data-table{background-color:var(--mdc-theme-surface, #fff);border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row{background-color:inherit}.mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #fff)}.mdc-data-table__row--selected{background-color:rgba(245, 124, 0, 0.04)}.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__cell,.mdc-data-table__header-cell{border-bottom-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__pagination{border-top-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(0, 0, 0, 0.04)}.mdc-data-table__header-cell{color:rgba(0, 0, 0, 0.87)}.mdc-data-table__pagination-total,.mdc-data-table__pagination-rows-per-page-label,.mdc-data-table__cell{color:rgba(0, 0, 0, 0.87)}.mat-mdc-table{background:#fff}.mat-mdc-table .mdc-data-table__row{height:52px}.mat-mdc-table .mdc-data-table__pagination{min-height:52px}.mat-mdc-table .mdc-data-table__header-row{height:56px}.mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#f57c00}.mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ff9800}.mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}.mat-badge{position:relative}.mat-badge.mat-badge{overflow:visible}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-datepicker-content .mat-mdc-button,.mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-button.mat-primary,.mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-accent,.mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-button.mat-warn,.mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-raised-button,.mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-raised-button.mat-primary,.mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-accent,.mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-raised-button.mat-warn,.mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,.mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-progress-bar-background{fill:#fddebf}.mat-progress-bar-buffer{background-color:#fddebf}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-form-field-disabled .mat-form-field-prefix,.mat-form-field-disabled .mat-form-field-suffix{color:#757575}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fff}.mat-checkbox-checkmark-path{stroke:#fff !important}.mat-checkbox-mixedmark{background-color:#fff}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:rgba(0,0,0,.38)}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-primary .mat-slider-track-fill,.mat-slider.mat-primary .mat-slider-thumb,.mat-slider.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-slider.mat-accent .mat-slider-track-fill,.mat-slider.mat-accent .mat-slider-thumb,.mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-slider.mat-warn .mat-slider-track-fill,.mat-slider.mat-warn .mat-slider-thumb,.mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-disabled .mat-slider-track-background,.mat-slider.mat-slider-disabled .mat-slider-track-fill,.mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:rgba(0,0,0,0)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:rgba(0,0,0,0);color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled] .mat-menu-submenu-icon,.mat-menu-item[disabled] .mat-icon-no-color{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-submenu-icon{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-base .mat-list-item-disabled{background-color:#eee;color:#757575}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-]>.mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-primary>.mat-tab-header,.mat-tab-group.mat-background-primary>.mat-tab-link-container,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-accent>.mat-tab-header,.mat-tab-group.mat-background-accent>.mat-tab-link-container,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(0,0,0,.1)}.mat-tab-group.mat-background-warn>.mat-tab-header,.mat-tab-group.mat-background-warn>.mat-tab-link-container,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-option:hover:not(.mdc-list-item--disabled),.mat-mdc-option:focus:not(.mdc-list-item--disabled),.mat-mdc-option.mat-mdc-option-active,.mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(0,0,0,.04)}.mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ff9800)}.mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}.mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-pseudo-checkbox-full{color:#616161}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f57c00}.mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ff9800}.mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}.mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,.mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#fff}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#b0b0b0}.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,.mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0,.mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1,.mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2,.mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3,.mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4,.mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5,.mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6,.mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7,.mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8,.mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9,.mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10,.mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11,.mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12,.mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13,.mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14,.mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15,.mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16,.mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17,.mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18,.mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19,.mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20,.mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21,.mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22,.mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23,.mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24,.mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#fff}.mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#e0e0e0}.mat-mdc-card-subtitle{color:#616161}.mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#f57c00}.mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(245, 124, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(245, 124, 0, 0.25)}.mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ff9800}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(255, 152, 0, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(255, 152, 0, 0.25)}.mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}.mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}.mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(0, 0, 0, 0.87)}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.6)}}@media all{.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.6)}}.mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,.mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}.mdc-text-field--filled .mdc-text-field__ripple::before,.mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(0, 0, 0, 0.87))}.mdc-text-field--filled:hover .mdc-text-field__ripple::before,.mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:whitesmoke}.mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.42)}.mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.38)}.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.87)}.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #f57c00)}.mdc-text-field--outlined .mdc-text-field__ripple::before,.mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}.mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(245, 124, 0, 0.87)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mdc-text-field--disabled .mdc-text-field__input{color:rgba(0, 0, 0, 0.38)}@media all{.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(0, 0, 0, 0.38)}}@media all{.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(0, 0, 0, 0.38)}}.mdc-text-field--disabled .mdc-floating-label{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(0, 0, 0, 0.06)}.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field-character-counter,.mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-text-field--disabled .mdc-notched-outline__leading,.mdc-text-field--disabled .mdc-notched-outline__notch,.mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}.mdc-text-field--disabled.mdc-text-field--filled{background-color:#fafafa}.mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field-focus-overlay{background-color:rgba(0,0,0,.87)}.mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.04}.mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.12}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.54)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(245,124,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(255,152,0,.87)}.mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}.mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(0,0,0,.38)}.mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 152, 0, 0.87)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ff9800)}.mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,.mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}[dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}.mat-mdc-form-field-infix{min-height:56px}.mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}.mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-select-value{color:rgba(0,0,0,.87)}.mat-mdc-select-placeholder{color:rgba(0,0,0,.6)}.mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(0,0,0,.38)}.mat-mdc-select-arrow{color:rgba(0,0,0,.54)}.mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(245,124,0,.87)}.mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(255,152,0,.87)}.mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}.mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(0,0,0,.38)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-dialog-container{--mdc-dialog-container-color:white;--mdc-dialog-with-divider-divider-color:rgba(0, 0, 0, 0.12);--mdc-dialog-subhead-color:rgba(0, 0, 0, 0.87);--mdc-dialog-supporting-text-color:rgba(0, 0, 0, 0.6)}.mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#e0e0e0;--mdc-chip-elevated-disabled-container-color:#e0e0e0;--mdc-chip-label-text-color:#212121;--mdc-chip-disabled-label-text-color:#212121;--mdc-chip-with-icon-icon-color:#212121;--mdc-chip-with-icon-disabled-icon-color:#212121;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#212121;--mdc-chip-with-trailing-icon-trailing-icon-color:#212121;--mdc-chip-with-icon-selected-icon-color:#212121}.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f57c00;--mdc-chip-elevated-disabled-container-color:#f57c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ff9800;--mdc-chip-elevated-disabled-container-color:#ff9800;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,.mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}.mat-mdc-chip-focus-overlay{background:#000}.mat-mdc-chip{height:32px}.mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#424242;--mdc-switch-disabled-unselected-handle-color:#424242;--mdc-switch-disabled-selected-track-color:#424242;--mdc-switch-disabled-unselected-track-color:#424242;--mdc-switch-unselected-focus-state-layer-color:#424242;--mdc-switch-unselected-pressed-state-layer-color:#424242;--mdc-switch-unselected-hover-state-layer-color:#424242;--mdc-switch-unselected-focus-track-color:#e0e0e0;--mdc-switch-unselected-hover-track-color:#e0e0e0;--mdc-switch-unselected-pressed-track-color:#e0e0e0;--mdc-switch-unselected-track-color:#e0e0e0;--mdc-switch-unselected-focus-handle-color:#212121;--mdc-switch-unselected-hover-handle-color:#212121;--mdc-switch-unselected-pressed-handle-color:#212121;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#616161;--mdc-switch-selected-icon-color:#fff;--mdc-switch-disabled-selected-icon-color:#fff;--mdc-switch-disabled-unselected-icon-color:#fff;--mdc-switch-unselected-icon-color:#fff}.mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#757575}.mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#fb8c00;--mdc-switch-selected-handle-color:#fb8c00;--mdc-switch-selected-hover-state-layer-color:#fb8c00;--mdc-switch-selected-pressed-state-layer-color:#fb8c00;--mdc-switch-selected-focus-handle-color:#e65100;--mdc-switch-selected-hover-handle-color:#e65100;--mdc-switch-selected-pressed-handle-color:#e65100;--mdc-switch-selected-focus-track-color:#ffb74d;--mdc-switch-selected-hover-track-color:#ffb74d;--mdc-switch-selected-pressed-track-color:#ffb74d;--mdc-switch-selected-track-color:#ffb74d}.mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e53935;--mdc-switch-selected-handle-color:#e53935;--mdc-switch-selected-hover-state-layer-color:#e53935;--mdc-switch-selected-pressed-state-layer-color:#e53935;--mdc-switch-selected-focus-handle-color:#b71c1c;--mdc-switch-selected-hover-handle-color:#b71c1c;--mdc-switch-selected-pressed-handle-color:#b71c1c;--mdc-switch-selected-focus-track-color:#e57373;--mdc-switch-selected-hover-track-color:#e57373;--mdc-switch-selected-pressed-track-color:#e57373;--mdc-switch-selected-track-color:#e57373}.mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}.mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#757575}.mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}.mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}.mat-mdc-slider{--mdc-slider-label-container-color:black;--mdc-slider-label-label-text-color:white;--mdc-slider-disabled-handle-color:#000;--mdc-slider-disabled-active-track-color:#000;--mdc-slider-disabled-inactive-track-color:#000;--mdc-slider-with-tick-marks-disabled-container-color:#000;--mat-mdc-slider-value-indicator-opacity: 0.6}.mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#f57c00;--mdc-slider-focus-handle-color:#f57c00;--mdc-slider-hover-handle-color:#f57c00;--mdc-slider-active-track-color:#f57c00;--mdc-slider-inactive-track-color:#f57c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#f57c00;--mat-mdc-slider-ripple-color: #f57c00;--mat-mdc-slider-hover-ripple-color: rgba(245, 124, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(245, 124, 0, 0.2)}.mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ff9800;--mdc-slider-focus-handle-color:#ff9800;--mdc-slider-hover-handle-color:#ff9800;--mdc-slider-active-track-color:#ff9800;--mdc-slider-inactive-track-color:#ff9800;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ff9800;--mat-mdc-slider-ripple-color: #ff9800;--mat-mdc-slider-hover-ripple-color: rgba(255, 152, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(255, 152, 0, 0.2)}.mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}.mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #fff);color:var(--mdc-theme-on-surface, #000)}.mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(0, 0, 0, 0.54))}.mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(0, 0, 0, 0.38))}.mdc-list-item--disabled .mdc-list-item__start,.mdc-list-item--disabled .mdc-list-item__content,.mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}.mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #000)}.mdc-list-item--selected .mdc-list-item__primary-text,.mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #f57c00)}.mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #f57c00)}.mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mdc-list-divider::after{border-bottom-color:white}.mdc-list-divider{background-color:rgba(0, 0, 0, 0.12)}.mat-mdc-menu-item[disabled],.mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,.mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(0, 0, 0, 0.38))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-menu-item:hover:not([disabled]),.mat-mdc-menu-item.cdk-program-focused:not([disabled]),.mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),.mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-mdc-list-base{--mdc-list-list-item-label-text-color:#212121;--mdc-list-list-item-supporting-text-color:#616161;--mdc-list-list-item-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-supporting-text-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-selected-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-disabled-label-text-color:black;--mdc-list-list-item-disabled-leading-icon-color:black;--mdc-list-list-item-disabled-trailing-icon-color:black;--mdc-list-list-item-hover-label-text-color:#212121;--mdc-list-list-item-hover-leading-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-hover-trailing-icon-color:rgba(0, 0, 0, 0.38);--mdc-list-list-item-focus-label-text-color:#212121;--mdc-list-list-item-hover-state-layer-color:black;--mdc-list-list-item-hover-state-layer-opacity:0.04;--mdc-list-list-item-focus-state-layer-color:black;--mdc-list-list-item-focus-state-layer-opacity:0.12}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option .mdc-list-item__start,.mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f57c00;--mdc-radio-selected-hover-icon-color:#f57c00;--mdc-radio-selected-icon-color:#f57c00;--mdc-radio-selected-pressed-icon-color:#f57c00;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f57c00}.mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-accent .mdc-list-item__start,.mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#ff9800;--mdc-radio-selected-hover-icon-color:#ff9800;--mdc-radio-selected-icon-color:#ff9800;--mdc-radio-selected-pressed-icon-color:#ff9800;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #ff9800}.mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-list-option.mat-warn .mdc-list-item__start,.mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#000;--mdc-radio-disabled-unselected-icon-color:#000;--mdc-radio-unselected-focus-icon-color:#212121;--mdc-radio-unselected-hover-icon-color:#212121;--mdc-radio-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #000;--mat-mdc-radio-checked-ripple-color: #f44336}.mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,.mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#757575}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#f57c00}.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,.mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#f57c00}.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,.mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}.mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}.mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,.mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}.mat-mdc-paginator{background:#fff;color:rgba(0,0,0,.87)}.mat-mdc-paginator-icon{fill:rgba(0,0,0,.54)}.mat-mdc-paginator-decrement,.mat-mdc-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-mdc-paginator-first,.mat-mdc-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,.mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(0,0,0,.12)}.mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(0,0,0,.12)}.mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}.mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}.mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}.mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}.mat-mdc-paginator-container{min-height:56px}.mat-mdc-tab,.mat-mdc-tab-link{background-color:rgba(0,0,0,0)}.mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-link .mdc-tab__text-label{color:rgba(0, 0, 0, 0.6)}.mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,.mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,.mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(0,0,0,.38)}.mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f57c00}.mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f57c00)}.mdc-tab__ripple::before,.mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-link .mat-ripple-element{background-color:#f57c00}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ff9800}.mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ff9800)}.mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ff9800}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}.mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}.mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}.mat-mdc-tab-group.mat-background-primary,.mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #f57c00;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-accent,.mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ff9800;--mat-mdc-tab-header-with-background-foreground-color: #000}.mat-mdc-tab-group.mat-background-warn,.mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}.mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #000)}.mat-mdc-tab-header .mdc-tab{height:48px}.mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, rgba(0, 0, 0, 0.87))}.mat-mdc-checkbox .mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-mdc-checkbox .mdc-checkbox__ripple{background:#000}.mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#f57c00;--mdc-checkbox-selected-hover-icon-color:#f57c00;--mdc-checkbox-selected-icon-color:#f57c00;--mdc-checkbox-selected-pressed-icon-color:#f57c00;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(245,124,0,.1)}.mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f57c00}.mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ff9800;--mdc-checkbox-selected-hover-icon-color:#ff9800;--mdc-checkbox-selected-icon-color:#ff9800;--mdc-checkbox-selected-pressed-icon-color:#ff9800;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(255,152,0,.1)}.mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ff9800}.mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#212121;--mdc-checkbox-unselected-hover-icon-color:#212121;--mdc-checkbox-disabled-selected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(0, 0, 0, 0.38);--mdc-checkbox-unselected-icon-color:rgba(0, 0, 0, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(0, 0, 0, 0.54)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}.mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}.mat-mdc-checkbox-disabled label{color:#757575}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}.mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#000}.mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#f57c00}.mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ff9800}.mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}.mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-text-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#fff;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#f57c00;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ff9800;--mdc-filled-button-label-text-color:#000}.mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}.mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-filled-button-container-color:rgba(0, 0, 0, 0.12);--mdc-filled-button-label-text-color:rgba(0, 0, 0, 0.38)}.mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#fff;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#f57c00;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ff9800;--mdc-protected-button-label-text-color:#000}.mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}.mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-color:rgba(0, 0, 0, 0.12);--mdc-protected-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-protected-button-container-elevation:0}.mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#000}.mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#f57c00}.mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ff9800}.mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}.mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-disabled-label-text-color:rgba(0, 0, 0, 0.38);--mdc-outlined-button-outline-color:rgba(0, 0, 0, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(0, 0, 0, 0.12)}.mat-mdc-button,.mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-button.mat-primary,.mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-button.mat-accent,.mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-button.mat-warn,.mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-raised-button,.mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-raised-button.mat-primary,.mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-accent,.mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-raised-button.mat-warn,.mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{height:36px}.mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #f57c00;--mat-mdc-button-ripple-color: rgba(245, 124, 0, 0.1)}.mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ff9800;--mat-mdc-button-ripple-color: rgba(255, 152, 0, 0.1)}.mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}.mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#f57c00}.mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ff9800}.mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}.mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(0, 0, 0, 0.38);--mdc-icon-button-disabled-icon-color:rgba(0, 0, 0, 0.38)}.mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-fab,.mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.04}.mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,.mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.12}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}.mat-mdc-fab.mat-unthemed,.mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#fff;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-primary,.mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#f57c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-accent,.mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ff9800;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}.mat-mdc-fab.mat-warn,.mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}.mat-mdc-fab[disabled][disabled],.mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(0, 0, 0, 0.12);--mdc-fab-icon-color:rgba(0, 0, 0, 0.38);--mat-mdc-fab-color: rgba(0, 0, 0, 0.38)}.mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: #ff9800;--mdc-snackbar-container-color:#333333;--mdc-snackbar-supporting-text-color:rgba(255, 255, 255, 0.87)}.mdc-data-table{background-color:var(--mdc-theme-surface, #fff);border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row{background-color:inherit}.mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #fff)}.mdc-data-table__row--selected{background-color:rgba(245, 124, 0, 0.04)}.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,.mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__cell,.mdc-data-table__header-cell{border-bottom-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__pagination{border-top-color:rgba(0, 0, 0, 0.12)}.mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(0, 0, 0, 0.04)}.mdc-data-table__header-cell{color:rgba(0, 0, 0, 0.87)}.mdc-data-table__pagination-total,.mdc-data-table__pagination-rows-per-page-label,.mdc-data-table__cell{color:rgba(0, 0, 0, 0.87)}.mat-mdc-table{background:#fff}.mat-mdc-table .mdc-data-table__row{height:52px}.mat-mdc-table .mdc-data-table__pagination{min-height:52px}.mat-mdc-table .mdc-data-table__header-row{height:56px}.mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#f57c00}.mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ff9800}.mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}.mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}body{overflow:hidden}.cdk-overlay-container{contain:strict}.cdk-overlay-container .mat-mdc-dialog-surface{padding:16px}a:not(.mdc-button,.mdc-icon-button){color:#1976d2}a:not(.mdc-button,.mdc-icon-button):visited{color:#7b1fa2}body mat-slider,body.dark-mode mat-slider{--mdc-slider-handle-width: 12px;--mdc-slider-handle-height: 12px;--mdc-slider-active-track-height: 2px;--mdc-slider-inactive-track-height: 2px}body a,body button.mat-mdc-button-base,body.dark-mode a,body.dark-mode button.mat-mdc-button-base{--tb-icon-width: 24px;--tb-icon-height: 24px;--tb-icon-button-width: 40px;--tb-icon-button-height: 40px;--mdc-text-button-label-text-tracking: normal;--mdc-filled-button-label-text-tracking: normal;--mdc-outlined-button-label-text-tracking: normal;--mdc-protected-button-label-text-tracking: normal}body a[mat-icon-button].mat-mdc-icon-button,body button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button,body.dark-mode a[mat-icon-button].mat-mdc-icon-button,body.dark-mode button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button{width:var(--tb-icon-button-width);height:var(--tb-icon-button-height);display:inline-flex;justify-content:center;align-items:center}body a[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body.dark-mode a[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target,body.dark-mode button.mat-mdc-button-base[mat-icon-button].mat-mdc-icon-button .mat-mdc-button-touch-target{height:100%;width:100%}body a mat-icon.mat-icon,body button.mat-mdc-button-base mat-icon.mat-icon,body.dark-mode a mat-icon.mat-icon,body.dark-mode button.mat-mdc-button-base mat-icon.mat-icon{flex-shrink:0}body a mat-icon.mat-icon,body a svg,body button.mat-mdc-button-base mat-icon.mat-icon,body button.mat-mdc-button-base svg,body.dark-mode a mat-icon.mat-icon,body.dark-mode a svg,body.dark-mode button.mat-mdc-button-base mat-icon.mat-icon,body.dark-mode button.mat-mdc-button-base svg{width:var(--tb-icon-size, var(--tb-icon-width));height:var(--tb-icon-size, var(--tb-icon-height));line-height:var(--tb-icon-size, var(--tb-icon-height))}body.dark-mode{background-color:#303030}body.dark-mode a:not(.mdc-button,.mdc-icon-button){color:#42a5f5}body.dark-mode a:not(.mdc-button,.mdc-icon-button):visited{color:#ba68c8}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-mdc-option{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-option:hover:not(.mdc-list-item--disabled),body.dark-mode .mat-mdc-option:focus:not(.mdc-list-item--disabled),body.dark-mode .mat-mdc-option.mat-mdc-option-active,body.dark-mode .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple):not(.mdc-list-item--disabled){background:rgba(255,255,255,.08)}body.dark-mode .mat-primary .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mat-accent .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-warn .mat-mdc-option.mdc-list-item--selected:not(.mdc-list-item--disabled) .mdc-list-item__primary-text{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-optgroup-label{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-pseudo-checkbox-full{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#686868}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24,body.dark-mode .mat-mdc-elevation-specific.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-mdc-card{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);--mdc-elevated-card-container-color:#424242}body.dark-mode .mat-mdc-card-outlined{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12);--mdc-outlined-card-outline-color:#595959}body.dark-mode .mat-mdc-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-mdc-progress-bar{--mdc-linear-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-bar .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(239, 108, 0, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar .mdc-linear-progress__buffer-bar{background-color:rgba(239, 108, 0, 0.25)}body.dark-mode .mat-mdc-progress-bar.mat-accent{--mdc-linear-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(239, 108, 0, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar.mat-accent .mdc-linear-progress__buffer-bar{background-color:rgba(239, 108, 0, 0.25)}body.dark-mode .mat-mdc-progress-bar.mat-warn{--mdc-linear-progress-active-indicator-color:#f44336}body.dark-mode .mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-dots{background-image:url("data:image/svg+xml,%3Csvg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' enable-background='new 0 0 5 2' xml:space='preserve' viewBox='0 0 5 2' preserveAspectRatio='none slice'%3E%3Ccircle cx='1' cy='1' r='1' fill='rgba(244, 67, 54, 0.25)'/%3E%3C/svg%3E")}body.dark-mode .mat-mdc-progress-bar.mat-warn .mdc-linear-progress__buffer-bar{background-color:rgba(244, 67, 54, 0.25)}body.dark-mode .mat-mdc-tooltip{--mdc-plain-tooltip-container-color:#616161;--mdc-plain-tooltip-supporting-text-color:white}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(255, 255, 255, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input{color:rgba(255, 255, 255, 0.87)}@media all{body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input::placeholder{color:rgba(255, 255, 255, 0.6)}}@media all{body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__input:-ms-input-placeholder{color:rgba(255, 255, 255, 0.6)}}body.dark-mode .mdc-text-field .mdc-text-field__input{caret-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field-character-counter,body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled)+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.54)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.54)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field:not(.mdc-text-field--disabled) .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.6)}body.dark-mode .mdc-text-field--filled .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, rgba(255, 255, 255, 0.87))}body.dark-mode .mdc-text-field--filled:hover .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled.mdc-ripple-surface--hover .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-hover-opacity, 0.08)}body.dark-mode .mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{opacity:var(--mdc-ripple-focus-opacity, 0.24)}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:#4a4a4a}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.42)}body.dark-mode .mdc-text-field--filled:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-text-field--filled .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.38)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-text-field--outlined .mdc-text-field__ripple::before,body.dark-mode .mdc-text-field--outlined .mdc-text-field__ripple::after{background-color:var(--mdc-ripple-color, transparent)}body.dark-mode .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(239, 108, 0, 0.87)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__input{color:rgba(255, 255, 255, 0.38)}@media all{body.dark-mode .mdc-text-field--disabled .mdc-text-field__input::placeholder{color:rgba(255, 255, 255, 0.38)}}@media all{body.dark-mode .mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:rgba(255, 255, 255, 0.38)}}body.dark-mode .mdc-text-field--disabled .mdc-floating-label{color:rgba(255, 255, 255, 0.38)}body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field-character-counter,body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--leading{color:rgba(0, 0, 0, 0.3)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--trailing{color:rgba(0, 0, 0, 0.3)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--prefix{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--suffix{color:rgba(0, 0, 0, 0.38)}body.dark-mode .mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:rgba(255, 255, 255, 0.06)}body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.06)}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__input::placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__input:-ms-input-placeholder{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-floating-label{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-helper-text{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field-character-counter,body.dark-mode .mdc-text-field--disabled+.mdc-text-field-helper-line .mdc-text-field-character-counter{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--leading{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__icon--trailing{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--prefix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-text-field__affix--suffix{color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-line-ripple::before{border-bottom-color:GrayText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__leading,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__notch,body.dark-mode .mdc-text-field--disabled .mdc-notched-outline__trailing{border-color:GrayText}}body.dark-mode .mdc-text-field--disabled.mdc-text-field--filled{background-color:#464646}body.dark-mode .mat-mdc-form-field-error{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field-focus-overlay{background-color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-form-field:hover .mat-mdc-form-field-focus-overlay{opacity:.08}body.dark-mode .mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:.24}body.dark-mode select.mat-mdc-form-field-input-control:not(.mat-mdc-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode select.mat-mdc-form-field-input-control:not(.mat-mdc-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{color:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-primary .mat-mdc-form-field-infix::after{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-accent .mat-mdc-form-field-infix::after{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-focused.mat-warn .mat-mdc-form-field-infix::after{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field-type-mat-native-select.mat-form-field-disabled .mat-mdc-form-field-infix::after{color:rgba(255,255,255,.38)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field__input{caret-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-accent:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(239, 108, 0, 0.87)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-accent .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-secondary, #ef6c00)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--focused:not(.mdc-text-field--disabled) .mdc-floating-label{color:rgba(244, 67, 54, 0.87)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):hover .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::after{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-floating-label{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid .mdc-text-field__input{caret-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-text-field__icon--trailing{color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-bottom-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled):not(.mdc-text-field--focused):hover .mdc-notched-outline .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--invalid:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__leading,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__notch,body.dark-mode .mat-mdc-form-field.mat-warn .mdc-text-field--outlined:not(.mdc-text-field--disabled).mdc-text-field--focused .mdc-notched-outline__trailing{border-color:var(--mdc-theme-error, #f44336)}body.dark-mode .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:1px solid rgba(0,0,0,0)}body.dark-mode [dir=rtl] .mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field.mat-mdc-form-field .mdc-notched-outline__notch{border-left:none;border-right:1px solid rgba(0,0,0,0)}body.dark-mode .mat-mdc-form-field-infix{min-height:56px}body.dark-mode .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:28px}body.dark-mode .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -34.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}body.dark-mode .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}body.dark-mode .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:24px;padding-bottom:8px}body.dark-mode .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:16px;padding-bottom:16px}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-select-value{color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-select-placeholder{color:rgba(255,255,255,.6)}body.dark-mode .mat-mdc-select-disabled .mat-mdc-select-value{color:rgba(255,255,255,.38)}body.dark-mode .mat-mdc-select-arrow{color:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-primary .mat-mdc-select-arrow{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-accent .mat-mdc-select-arrow{color:rgba(239,108,0,.87)}body.dark-mode .mat-mdc-form-field.mat-focused.mat-warn .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field .mat-mdc-select.mat-mdc-select-invalid .mat-mdc-select-arrow{color:rgba(244,67,54,.87)}body.dark-mode .mat-mdc-form-field .mat-mdc-select.mat-mdc-select-disabled .mat-mdc-select-arrow{color:rgba(255,255,255,.38)}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-dialog-container{--mdc-dialog-container-color:#424242;--mdc-dialog-with-divider-divider-color:rgba(255, 255, 255, 0.12);--mdc-dialog-subhead-color:rgba(255, 255, 255, 0.87);--mdc-dialog-supporting-text-color:rgba(255, 255, 255, 0.6)}body.dark-mode .mat-mdc-standard-chip{--mdc-chip-elevated-container-color:#595959;--mdc-chip-elevated-disabled-container-color:#595959;--mdc-chip-label-text-color:#fafafa;--mdc-chip-disabled-label-text-color:#fafafa;--mdc-chip-with-icon-icon-color:#fafafa;--mdc-chip-with-icon-disabled-icon-color:#fafafa;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:#fafafa;--mdc-chip-with-trailing-icon-trailing-icon-color:#fafafa;--mdc-chip-with-icon-selected-icon-color:#fafafa}body.dark-mode .mat-mdc-standard-chip.mat-primary.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-primary.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ef6c00;--mdc-chip-elevated-disabled-container-color:#ef6c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-standard-chip.mat-accent.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-accent.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#ef6c00;--mdc-chip-elevated-disabled-container-color:#ef6c00;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-standard-chip.mat-warn.mat-mdc-chip-selected,body.dark-mode .mat-mdc-standard-chip.mat-warn.mat-mdc-chip-highlighted{--mdc-chip-elevated-container-color:#f44336;--mdc-chip-elevated-disabled-container-color:#f44336;--mdc-chip-label-text-color:white;--mdc-chip-disabled-label-text-color:white;--mdc-chip-with-icon-icon-color:white;--mdc-chip-with-icon-disabled-icon-color:white;--mdc-chip-with-trailing-icon-disabled-trailing-icon-color:white;--mdc-chip-with-trailing-icon-trailing-icon-color:white;--mdc-chip-with-icon-selected-icon-color:white}body.dark-mode .mat-mdc-chip-focus-overlay{background:#fff}body.dark-mode .mat-mdc-chip{height:32px}body.dark-mode .mat-mdc-slide-toggle{--mdc-switch-disabled-selected-handle-color:#000;--mdc-switch-disabled-unselected-handle-color:#000;--mdc-switch-disabled-selected-track-color:#f5f5f5;--mdc-switch-disabled-unselected-track-color:#f5f5f5;--mdc-switch-unselected-focus-state-layer-color:#f5f5f5;--mdc-switch-unselected-pressed-state-layer-color:#f5f5f5;--mdc-switch-unselected-hover-state-layer-color:#f5f5f5;--mdc-switch-unselected-focus-track-color:#616161;--mdc-switch-unselected-hover-track-color:#616161;--mdc-switch-unselected-pressed-track-color:#616161;--mdc-switch-unselected-track-color:#616161;--mdc-switch-unselected-focus-handle-color:#fafafa;--mdc-switch-unselected-hover-handle-color:#fafafa;--mdc-switch-unselected-pressed-handle-color:#fafafa;--mdc-switch-handle-surface-color:var(--mdc-theme-surface, #fff);--mdc-switch-unselected-handle-color:#9e9e9e;--mdc-switch-selected-icon-color:#212121;--mdc-switch-disabled-selected-icon-color:#212121;--mdc-switch-disabled-unselected-icon-color:#212121;--mdc-switch-unselected-icon-color:#212121}body.dark-mode .mat-mdc-slide-toggle .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-slide-toggle .mdc-switch--disabled+label{color:#616161}body.dark-mode .mat-mdc-slide-toggle.mat-primary{--mdc-switch-selected-focus-state-layer-color:#ffb74d;--mdc-switch-selected-handle-color:#ffb74d;--mdc-switch-selected-hover-state-layer-color:#ffb74d;--mdc-switch-selected-pressed-state-layer-color:#ffb74d;--mdc-switch-selected-focus-handle-color:#ffcc80;--mdc-switch-selected-hover-handle-color:#ffcc80;--mdc-switch-selected-pressed-handle-color:#ffcc80;--mdc-switch-selected-focus-track-color:#fb8c00;--mdc-switch-selected-hover-track-color:#fb8c00;--mdc-switch-selected-pressed-track-color:#fb8c00;--mdc-switch-selected-track-color:#fb8c00}body.dark-mode .mat-mdc-slide-toggle.mat-accent{--mdc-switch-selected-focus-state-layer-color:#ffb74d;--mdc-switch-selected-handle-color:#ffb74d;--mdc-switch-selected-hover-state-layer-color:#ffb74d;--mdc-switch-selected-pressed-state-layer-color:#ffb74d;--mdc-switch-selected-focus-handle-color:#ffcc80;--mdc-switch-selected-hover-handle-color:#ffcc80;--mdc-switch-selected-pressed-handle-color:#ffcc80;--mdc-switch-selected-focus-track-color:#fb8c00;--mdc-switch-selected-hover-track-color:#fb8c00;--mdc-switch-selected-pressed-track-color:#fb8c00;--mdc-switch-selected-track-color:#fb8c00}body.dark-mode .mat-mdc-slide-toggle.mat-warn{--mdc-switch-selected-focus-state-layer-color:#e57373;--mdc-switch-selected-handle-color:#e57373;--mdc-switch-selected-hover-state-layer-color:#e57373;--mdc-switch-selected-pressed-state-layer-color:#e57373;--mdc-switch-selected-focus-handle-color:#ef9a9a;--mdc-switch-selected-hover-handle-color:#ef9a9a;--mdc-switch-selected-pressed-handle-color:#ef9a9a;--mdc-switch-selected-focus-track-color:#e53935;--mdc-switch-selected-hover-track-color:#e53935;--mdc-switch-selected-pressed-track-color:#e53935;--mdc-switch-selected-track-color:#e53935}body.dark-mode .mat-mdc-slide-toggle{--mdc-switch-state-layer-size:48px}body.dark-mode .mat-mdc-radio-button .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-radio-button.mat-primary{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-radio-button.mat-primary .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button.mat-accent{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-radio-button.mat-accent .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button.mat-warn{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #f44336}body.dark-mode .mat-mdc-radio-button.mat-warn .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-radio-button .mdc-radio{padding:calc((40px - 20px) / 2)}body.dark-mode .mat-mdc-radio-button .mdc-radio .mdc-radio__background::before{top:calc(-1 * (40px - 20px) / 2);left:calc(-1 * (40px - 20px) / 2);width:40px;height:40px}body.dark-mode .mat-mdc-radio-button .mdc-radio .mdc-radio__native-control{top:calc((40px - 40px) / 2);right:calc((40px - 40px) / 2);left:calc((40px - 40px) / 2);width:40px;height:40px}body.dark-mode .mat-mdc-slider{--mdc-slider-label-container-color:white;--mdc-slider-label-label-text-color:black;--mdc-slider-disabled-handle-color:#fff;--mdc-slider-disabled-active-track-color:#fff;--mdc-slider-disabled-inactive-track-color:#fff;--mdc-slider-with-tick-marks-disabled-container-color:#fff;--mat-mdc-slider-value-indicator-opacity: 0.9}body.dark-mode .mat-mdc-slider.mat-primary{--mdc-slider-handle-color:#ef6c00;--mdc-slider-focus-handle-color:#ef6c00;--mdc-slider-hover-handle-color:#ef6c00;--mdc-slider-active-track-color:#ef6c00;--mdc-slider-inactive-track-color:#ef6c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ef6c00;--mat-mdc-slider-ripple-color: #ef6c00;--mat-mdc-slider-hover-ripple-color: rgba(239, 108, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(239, 108, 0, 0.2)}body.dark-mode .mat-mdc-slider.mat-accent{--mdc-slider-handle-color:#ef6c00;--mdc-slider-focus-handle-color:#ef6c00;--mdc-slider-hover-handle-color:#ef6c00;--mdc-slider-active-track-color:#ef6c00;--mdc-slider-inactive-track-color:#ef6c00;--mdc-slider-with-tick-marks-active-container-color:#000;--mdc-slider-with-tick-marks-inactive-container-color:#ef6c00;--mat-mdc-slider-ripple-color: #ef6c00;--mat-mdc-slider-hover-ripple-color: rgba(239, 108, 0, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(239, 108, 0, 0.2)}body.dark-mode .mat-mdc-slider.mat-warn{--mdc-slider-handle-color:#f44336;--mdc-slider-focus-handle-color:#f44336;--mdc-slider-hover-handle-color:#f44336;--mdc-slider-active-track-color:#f44336;--mdc-slider-inactive-track-color:#f44336;--mdc-slider-with-tick-marks-active-container-color:#fff;--mdc-slider-with-tick-marks-inactive-container-color:#f44336;--mat-mdc-slider-ripple-color: #f44336;--mat-mdc-slider-hover-ripple-color: rgba(244, 67, 54, 0.05);--mat-mdc-slider-focus-ripple-color: rgba(244, 67, 54, 0.2)}body.dark-mode .mdc-menu-surface{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12);background-color:var(--mdc-theme-surface, #424242);color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item__primary-text{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-item__secondary-text{color:var(--mdc-theme-text-secondary-on-background, rgba(255, 255, 255, 0.7))}body.dark-mode .mdc-list-item__overline-text{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{background-color:transparent}body.dark-mode .mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-text-icon-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item__end{color:var(--mdc-theme-text-hint-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mdc-list-item--disabled .mdc-list-item__end{opacity:0.38}body.dark-mode .mdc-list-item--disabled .mdc-list-item__primary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__secondary-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled .mdc-list-item__overline-text{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-icon .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--disabled.mdc-list-item--with-trailing-meta .mdc-list-item__end{color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mdc-list-item--activated .mdc-list-item__primary-text{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:var(--mdc-theme-primary, #ef6c00)}body.dark-mode .mdc-deprecated-list-group__subheader{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mdc-list-divider::after{border-bottom-color:white}body.dark-mode .mdc-list-divider{background-color:rgba(255, 255, 255, 0.2)}body.dark-mode .mat-mdc-menu-item[disabled],body.dark-mode .mat-mdc-menu-item[disabled] .mat-mdc-menu-submenu-icon,body.dark-mode .mat-mdc-menu-item[disabled] .mat-icon-no-color{color:var(--mdc-theme-text-disabled-on-background, rgba(255, 255, 255, 0.5))}body.dark-mode .mat-mdc-menu-item .mat-icon-no-color,body.dark-mode .mat-mdc-menu-submenu-icon{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-menu-item:hover:not([disabled]),body.dark-mode .mat-mdc-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-mdc-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-mdc-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.08)}body.dark-mode .mat-mdc-list-base{--mdc-list-list-item-label-text-color:white;--mdc-list-list-item-supporting-text-color:rgba(255, 255, 255, 0.7);--mdc-list-list-item-leading-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-trailing-supporting-text-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-selected-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-disabled-label-text-color:white;--mdc-list-list-item-disabled-leading-icon-color:white;--mdc-list-list-item-disabled-trailing-icon-color:white;--mdc-list-list-item-hover-label-text-color:white;--mdc-list-list-item-hover-leading-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-hover-trailing-icon-color:rgba(255, 255, 255, 0.5);--mdc-list-list-item-focus-label-text-color:white;--mdc-list-list-item-hover-state-layer-color:white;--mdc-list-list-item-hover-state-layer-opacity:0.08;--mdc-list-list-item-focus-state-layer-color:white;--mdc-list-list-item-focus-state-layer-opacity:0.24}body.dark-mode .mat-mdc-list-option .mdc-list-item__start,body.dark-mode .mat-mdc-list-option .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option .mdc-list-item__start,body.dark-mode .mat-mdc-list-option .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-list-option .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#ef6c00;--mdc-radio-selected-hover-icon-color:#ef6c00;--mdc-radio-selected-icon-color:#ef6c00;--mdc-radio-selected-pressed-icon-color:#ef6c00;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #ef6c00}body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option.mat-accent .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end{--mdc-radio-disabled-selected-icon-color:#fff;--mdc-radio-disabled-unselected-icon-color:#fff;--mdc-radio-unselected-focus-icon-color:#eeeeee;--mdc-radio-unselected-hover-icon-color:#eeeeee;--mdc-radio-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54);--mdc-radio-selected-focus-icon-color:#f44336;--mdc-radio-selected-hover-icon-color:#f44336;--mdc-radio-selected-icon-color:#f44336;--mdc-radio-selected-pressed-icon-color:#f44336;--mat-mdc-radio-ripple-color: #fff;--mat-mdc-radio-checked-ripple-color: #f44336}body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__start .mdc-radio--disabled+label,body.dark-mode .mat-mdc-list-option.mat-warn .mdc-list-item__end .mdc-radio--disabled+label{color:#616161}body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected .mdc-list-item__primary-text,body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated .mdc-list-item__primary-text{color:#ef6c00}body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--selected.mdc-list-item--with-leading-icon .mdc-list-item__start,body.dark-mode .mat-mdc-list-base.mat-mdc-list-base .mdc-list-item--activated.mdc-list-item--with-leading-icon .mdc-list-item__start{color:#ef6c00}body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__start,body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__content,body.dark-mode .mat-mdc-list-base .mdc-list-item--disabled .mdc-list-item__end{opacity:1}body.dark-mode .mat-mdc-list-base{--mdc-list-list-item-one-line-container-height:48px;--mdc-list-list-item-two-line-container-height:64px;--mdc-list-list-item-three-line-container-height:88px}body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-one-line,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-one-line,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-one-line{height:56px}body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-avatar.mdc-list-item--with-two-lines,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-checkbox.mdc-list-item--with-two-lines,body.dark-mode .mat-mdc-list-item.mdc-list-item--with-leading-icon.mdc-list-item--with-two-lines{height:72px}body.dark-mode .mat-mdc-paginator{background:#424242;color:rgba(255,255,255,.87)}body.dark-mode .mat-mdc-paginator-icon{fill:rgba(255,255,255,.54)}body.dark-mode .mat-mdc-paginator-decrement,body.dark-mode .mat-mdc-paginator-increment{border-top:2px solid rgba(255,255,255,.54);border-right:2px solid rgba(255,255,255,.54)}body.dark-mode .mat-mdc-paginator-first,body.dark-mode .mat-mdc-paginator-last{border-top:2px solid rgba(255,255,255,.54)}body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-decrement,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-increment,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-first,body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-last{border-color:rgba(255,255,255,.12)}body.dark-mode .mat-mdc-icon-button[disabled] .mat-mdc-paginator-icon{fill:rgba(255,255,255,.12)}body.dark-mode .mat-mdc-paginator .mat-mdc-form-field-infix{min-height:40px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper .mat-mdc-form-field-flex .mat-mdc-floating-label{top:20px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{--mat-mdc-form-field-label-transform: translateY( -26.75px) scale(var(--mat-mdc-form-field-floating-label-scale, 0.75));transform:var(--mat-mdc-form-field-label-transform)}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper.mdc-text-field--outlined .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mdc-text-field--no-label:not(.mdc-text-field--outlined):not(.mdc-text-field--textarea) .mat-mdc-form-field-infix{padding-top:8px;padding-bottom:8px}body.dark-mode .mat-mdc-paginator .mat-mdc-text-field-wrapper:not(.mdc-text-field--outlined) .mat-mdc-floating-label{display:none}body.dark-mode .mat-mdc-paginator-container{min-height:56px}body.dark-mode .mat-mdc-tab,body.dark-mode .mat-mdc-tab-link{background-color:rgba(0,0,0,0)}body.dark-mode .mat-mdc-tab .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-link .mdc-tab__text-label{color:rgba(255, 255, 255, 0.6)}body.dark-mode .mat-mdc-tab.mat-mdc-tab-disabled .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab.mat-mdc-tab-disabled .mat-ripple-element,body.dark-mode .mat-mdc-tab-link.mat-mdc-tab-disabled .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-link.mat-mdc-tab-disabled .mat-ripple-element{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ef6c00}body.dark-mode .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ef6c00)}body.dark-mode .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-link .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #ef6c00)}body.dark-mode .mat-mdc-tab-group.mat-accent .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-accent .mat-mdc-tab-link .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-accent .mat-mdc-tab-link .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:#f44336}body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:var(--mdc-tab-indicator-active-indicator-color, #f44336)}body.dark-mode .mat-mdc-tab-group.mat-warn .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-group.mat-warn .mat-mdc-tab-link .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mdc-tab__ripple::before,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-mdc-tab-nav-bar.mat-warn .mat-mdc-tab-link .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-mdc-tab-group.mat-background-primary,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-primary{--mat-mdc-tab-header-with-background-background-color: #ef6c00;--mat-mdc-tab-header-with-background-foreground-color: #000}body.dark-mode .mat-mdc-tab-group.mat-background-accent,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-accent{--mat-mdc-tab-header-with-background-background-color: #ef6c00;--mat-mdc-tab-header-with-background-foreground-color: #000}body.dark-mode .mat-mdc-tab-group.mat-background-warn,body.dark-mode .mat-mdc-tab-nav-bar.mat-background-warn{--mat-mdc-tab-header-with-background-background-color: #f44336;--mat-mdc-tab-header-with-background-foreground-color: #fff}body.dark-mode .mat-mdc-tab-header-pagination-chevron{border-color:var(--mdc-theme-on-surface, #fff)}body.dark-mode .mat-mdc-tab-header .mdc-tab{height:48px}body.dark-mode .mat-mdc-checkbox .mdc-form-field{color:var(--mdc-theme-text-primary-on-background, white)}body.dark-mode .mat-mdc-checkbox .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox__ripple{background:#fff}body.dark-mode .mat-mdc-checkbox.mat-primary{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(239,108,0,.1)}body.dark-mode .mat-mdc-checkbox.mat-primary .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ef6c00}body.dark-mode .mat-mdc-checkbox.mat-accent{--mdc-checkbox-selected-checkmark-color:#000;--mdc-checkbox-selected-focus-icon-color:#ef6c00;--mdc-checkbox-selected-hover-icon-color:#ef6c00;--mdc-checkbox-selected-icon-color:#ef6c00;--mdc-checkbox-selected-pressed-icon-color:#ef6c00;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(239,108,0,.1)}body.dark-mode .mat-mdc-checkbox.mat-accent .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#ef6c00}body.dark-mode .mat-mdc-checkbox.mat-warn{--mdc-checkbox-selected-checkmark-color:#fff;--mdc-checkbox-selected-focus-icon-color:#f44336;--mdc-checkbox-selected-hover-icon-color:#f44336;--mdc-checkbox-selected-icon-color:#f44336;--mdc-checkbox-selected-pressed-icon-color:#f44336;--mdc-checkbox-unselected-focus-icon-color:#eeeeee;--mdc-checkbox-unselected-hover-icon-color:#eeeeee;--mdc-checkbox-disabled-selected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-disabled-unselected-icon-color:rgba(255, 255, 255, 0.38);--mdc-checkbox-unselected-icon-color:rgba(255, 255, 255, 0.54);--mdc-checkbox-unselected-pressed-icon-color:rgba(255, 255, 255, 0.54)}body.dark-mode .mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mat-mdc-checkbox-ripple .mat-ripple-element{background-color:rgba(244,67,54,.1)}body.dark-mode .mat-mdc-checkbox.mat-warn .mdc-checkbox--selected~.mdc-checkbox__ripple{background:#f44336}body.dark-mode .mat-mdc-checkbox-disabled label{color:#616161}body.dark-mode .mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-touch-target-size, 40px) - 40px) / 2)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-ripple-size, 40px) - 18px) / 2)}body.dark-mode .mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);right:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);left:calc((40px - var(--mdc-checkbox-touch-target-size, 40px)) / 2);width:var(--mdc-checkbox-touch-target-size, 40px);height:var(--mdc-checkbox-touch-target-size, 40px)}body.dark-mode .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#fff}body.dark-mode .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}body.dark-mode .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-text-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#424242;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-filled-button-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#424242;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-elevation:0}body.dark-mode .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#fff}body.dark-mode .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}body.dark-mode .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-mdc-button,body.dark-mode .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-button.mat-primary,body.dark-mode .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-button.mat-accent,body.dark-mode .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-button.mat-warn,body.dark-mode .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-mdc-raised-button,body.dark-mode .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-raised-button.mat-primary,body.dark-mode .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-raised-button.mat-accent,body.dark-mode .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-raised-button.mat-warn,body.dark-mode .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-button.mat-mdc-button-base,body.dark-mode .mat-mdc-raised-button.mat-mdc-button-base,body.dark-mode .mat-mdc-unelevated-button.mat-mdc-button-base,body.dark-mode .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}body.dark-mode .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}body.dark-mode .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(255, 255, 255, 0.5);--mdc-icon-button-disabled-icon-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}body.dark-mode .mat-mdc-fab,body.dark-mode .mat-mdc-mini-fab{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-fab:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-mdc-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-fab:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-mdc-mini-fab:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-mdc-fab.mat-primary,body.dark-mode .mat-mdc-mini-fab.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-fab.mat-accent,body.dark-mode .mat-mdc-mini-fab.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-mdc-fab.mat-warn,body.dark-mode .mat-mdc-mini-fab.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-mdc-fab.mat-unthemed,body.dark-mode .mat-mdc-mini-fab.mat-unthemed{--mdc-fab-container-color:#424242;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}body.dark-mode .mat-mdc-fab.mat-primary,body.dark-mode .mat-mdc-mini-fab.mat-primary{--mdc-fab-container-color:#ef6c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}body.dark-mode .mat-mdc-fab.mat-accent,body.dark-mode .mat-mdc-mini-fab.mat-accent{--mdc-fab-container-color:#ef6c00;--mdc-fab-icon-color:#000;--mat-mdc-fab-color: #000}body.dark-mode .mat-mdc-fab.mat-warn,body.dark-mode .mat-mdc-mini-fab.mat-warn{--mdc-fab-container-color:#f44336;--mdc-fab-icon-color:#fff;--mat-mdc-fab-color: #fff}body.dark-mode .mat-mdc-fab[disabled][disabled],body.dark-mode .mat-mdc-mini-fab[disabled][disabled]{--mdc-fab-container-color:rgba(255, 255, 255, 0.12);--mdc-fab-icon-color:rgba(255, 255, 255, 0.5);--mat-mdc-fab-color: rgba(255, 255, 255, 0.5)}body.dark-mode .mat-mdc-snack-bar-container{--mat-mdc-snack-bar-button-color: rgba(0, 0, 0, 0.87);--mdc-snackbar-container-color:#d9d9d9;--mdc-snackbar-supporting-text-color:rgba(66, 66, 66, 0.87)}body.dark-mode .mdc-data-table{background-color:var(--mdc-theme-surface, #424242);border-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__row{background-color:inherit}body.dark-mode .mdc-data-table__header-cell{background-color:var(--mdc-theme-surface, #424242)}body.dark-mode .mdc-data-table__row--selected{background-color:rgba(239, 108, 0, 0.04)}body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__leading,body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__notch,body.dark-mode .mdc-data-table__pagination-rows-per-page-select--outlined:not(.mdc-select--disabled) .mdc-notched-outline__trailing{border-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__cell,body.dark-mode .mdc-data-table__header-cell{border-bottom-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__pagination{border-top-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mdc-data-table__row:not(.mdc-data-table__row--selected):hover{background-color:rgba(255, 255, 255, 0.04)}body.dark-mode .mdc-data-table__header-cell{color:rgba(255, 255, 255, 0.87)}body.dark-mode .mdc-data-table__pagination-total,body.dark-mode .mdc-data-table__pagination-rows-per-page-label,body.dark-mode .mdc-data-table__cell{color:rgba(255, 255, 255, 0.87)}body.dark-mode .mat-mdc-table{background:#424242}body.dark-mode .mat-mdc-table .mdc-data-table__row{height:52px}body.dark-mode .mat-mdc-table .mdc-data-table__pagination{min-height:52px}body.dark-mode .mat-mdc-table .mdc-data-table__header-row{height:56px}body.dark-mode .mat-mdc-progress-spinner{--mdc-circular-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-spinner.mat-accent{--mdc-circular-progress-active-indicator-color:#ef6c00}body.dark-mode .mat-mdc-progress-spinner.mat-warn{--mdc-circular-progress-active-indicator-color:#f44336}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}body.dark-mode .mat-button,body.dark-mode .mat-icon-button,body.dark-mode .mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}body.dark-mode .mat-button.mat-primary,body.dark-mode .mat-icon-button.mat-primary,body.dark-mode .mat-stroked-button.mat-primary{color:#ef6c00}body.dark-mode .mat-button.mat-accent,body.dark-mode .mat-icon-button.mat-accent,body.dark-mode .mat-stroked-button.mat-accent{color:#ef6c00}body.dark-mode .mat-button.mat-warn,body.dark-mode .mat-icon-button.mat-warn,body.dark-mode .mat-stroked-button.mat-warn{color:#f44336}body.dark-mode .mat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-icon-button.mat-primary.mat-button-disabled,body.dark-mode .mat-icon-button.mat-accent.mat-button-disabled,body.dark-mode .mat-icon-button.mat-warn.mat-button-disabled,body.dark-mode .mat-icon-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-primary.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-accent.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-warn.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}body.dark-mode .mat-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}body.dark-mode .mat-button .mat-ripple-element,body.dark-mode .mat-icon-button .mat-ripple-element,body.dark-mode .mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}body.dark-mode .mat-button-focus-overlay{background:#fff}body.dark-mode .mat-stroked-button:not(.mat-button-disabled){border-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button,body.dark-mode .mat-raised-button,body.dark-mode .mat-fab,body.dark-mode .mat-mini-fab{color:#fff;background-color:#424242}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{color:#fff}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{color:#fff}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{color:#fff}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{background-color:#f44336}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button.mat-primary .mat-ripple-element,body.dark-mode .mat-raised-button.mat-primary .mat-ripple-element,body.dark-mode .mat-fab.mat-primary .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-accent .mat-ripple-element,body.dark-mode .mat-raised-button.mat-accent .mat-ripple-element,body.dark-mode .mat-fab.mat-accent .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-warn .mat-ripple-element,body.dark-mode .mat-raised-button.mat-warn .mat-ripple-element,body.dark-mode .mat-fab.mat-warn .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-stroked-button:not([class*=mat-elevation-z]),body.dark-mode .mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-unthemed{--mdc-text-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent{--mdc-text-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn{--mdc-text-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-button[disabled][disabled]{--mdc-text-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-text-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-unthemed{--mdc-filled-button-container-color:#424242;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mdc-filled-button-container-color:#ef6c00;--mdc-filled-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mdc-filled-button-container-color:#f44336;--mdc-filled-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button[disabled][disabled]{--mdc-filled-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-filled-button-container-color:rgba(255, 255, 255, 0.12);--mdc-filled-button-label-text-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-unthemed{--mdc-protected-button-container-color:#424242;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent{--mdc-protected-button-container-color:#ef6c00;--mdc-protected-button-label-text-color:#000}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn{--mdc-protected-button-container-color:#f44336;--mdc-protected-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button[disabled][disabled]{--mdc-protected-button-disabled-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-color:rgba(255, 255, 255, 0.12);--mdc-protected-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-protected-button-container-elevation:0}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-unthemed{--mdc-outlined-button-label-text-color:#fff}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mdc-outlined-button-label-text-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mdc-outlined-button-label-text-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button[disabled][disabled]{--mdc-outlined-button-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-disabled-label-text-color:rgba(255, 255, 255, 0.5);--mdc-outlined-button-outline-color:rgba(255, 255, 255, 0.12);--mdc-outlined-button-disabled-outline-color:rgba(255, 255, 255, 0.12)}body.dark-mode .mat-datepicker-content .mat-mdc-button,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:hover .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button:active .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-primary,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-accent,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #000;--mat-mdc-button-ripple-color: rgba(0, 0, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-warn,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button{--mat-mdc-button-persistent-ripple-color: #fff;--mat-mdc-button-ripple-color: rgba(255, 255, 255, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:hover .mat-mdc-button-persistent-ripple::before{opacity:.08}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-program-focused .mat-mdc-button-persistent-ripple::before,body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.cdk-keyboard-focused .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button:active .mat-mdc-button-persistent-ripple::before{opacity:.24}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mat-mdc-button-persistent-ripple-color: #ef6c00;--mat-mdc-button-ripple-color: rgba(239, 108, 0, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mat-mdc-button-persistent-ripple-color: #f44336;--mat-mdc-button-ripple-color: rgba(244, 67, 54, 0.1)}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-primary{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-accent{--mdc-icon-button-icon-color:#ef6c00}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-warn{--mdc-icon-button-icon-color:#f44336}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button[disabled][disabled]{--mdc-icon-button-icon-color:rgba(255, 255, 255, 0.5);--mdc-icon-button-disabled-icon-color:rgba(255, 255, 255, 0.5)}body.dark-mode .mat-datepicker-content .mat-mdc-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-raised-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-unelevated-button.mat-mdc-button-base,body.dark-mode .mat-datepicker-content .mat-mdc-outlined-button.mat-mdc-button-base{height:36px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base{width:48px;height:48px;padding:12px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-datepicker-content .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}body.dark-mode .mat-option{color:#fff}body.dark-mode .mat-option:hover:not(.mat-option-disabled),body.dark-mode .mat-option:focus:not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-active{background:rgba(255,255,255,.04);color:#fff}body.dark-mode .mat-option.mat-option-disabled{color:rgba(255,255,255,.5)}body.dark-mode .mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}body.dark-mode .mat-optgroup-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-optgroup-disabled .mat-optgroup-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-pseudo-checkbox-full{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox-full.mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#ef6c00}body.dark-mode .mat-accent .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#f44336}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full::after,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-minimal::after,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-minimal::after{color:#686868}body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-full,body.dark-mode .mat-pseudo-checkbox-disabled.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-full{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 5px 8px 0px rgba(0, 0, 0, 0.14), 0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2), 0px 7px 10px 1px rgba(0, 0, 0, 0.14), 0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2), 0px 9px 12px 1px rgba(0, 0, 0, 0.14), 0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2), 0px 10px 14px 1px rgba(0, 0, 0, 0.14), 0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2), 0px 11px 15px 1px rgba(0, 0, 0, 0.14), 0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 12px 17px 2px rgba(0, 0, 0, 0.14), 0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2), 0px 13px 19px 2px rgba(0, 0, 0, 0.14), 0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2), 0px 14px 21px 2px rgba(0, 0, 0, 0.14), 0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2), 0px 15px 22px 2px rgba(0, 0, 0, 0.14), 0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2), 0px 17px 26px 2px rgba(0, 0, 0, 0.14), 0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2), 0px 18px 28px 2px rgba(0, 0, 0, 0.14), 0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2), 0px 19px 29px 2px rgba(0, 0, 0, 0.14), 0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 20px 31px 3px rgba(0, 0, 0, 0.14), 0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2), 0px 21px 33px 3px rgba(0, 0, 0, 0.14), 0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2), 0px 22px 35px 3px rgba(0, 0, 0, 0.14), 0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2), 0px 23px 36px 3px rgba(0, 0, 0, 0.14), 0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-card{background:#424242;color:#fff}body.dark-mode .mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}body.dark-mode .mat-progress-spinner circle,body.dark-mode .mat-spinner circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-accent circle,body.dark-mode .mat-spinner.mat-accent circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-warn circle,body.dark-mode .mat-spinner.mat-warn circle{stroke:#f44336}body.dark-mode .mat-tooltip{background:rgba(97,97,97,.9)}body.dark-mode .mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-input-element:disabled,body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#616161}body.dark-mode .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-input-element::placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-moz-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-webkit-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:-ms-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-form-field.mat-accent .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-form-field.mat-warn .mat-input-element,body.dark-mode .mat-form-field-invalid .mat-input-element{caret-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field-disabled .mat-form-field-prefix,body.dark-mode .mat-form-field-disabled .mat-form-field-suffix{color:#616161}body.dark-mode .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}body.dark-mode .mat-focused .mat-form-field-required-marker{color:#ef6c00}body.dark-mode .mat-form-field-ripple{background-color:#fff}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}body.dark-mode .mat-error{color:#f44336}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(255,255,255,.05)}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(255,255,255,.3)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline-thick{color:#fff}body.dark-mode .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(255,255,255,.15)}body.dark-mode .mat-select-value{color:#fff}body.dark-mode .mat-select-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-select-disabled .mat-select-value{color:#616161}body.dark-mode .mat-select-arrow{color:rgba(255,255,255,.7)}body.dark-mode .mat-select-panel{background:#424242}body.dark-mode .mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(255,255,255,.12)}body.dark-mode .mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#616161}body.dark-mode .mat-checkbox-frame{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-checkbox-checkmark{fill:#303030}body.dark-mode .mat-checkbox-checkmark-path{stroke:#303030 !important}body.dark-mode .mat-checkbox-mixedmark{background-color:#303030}body.dark-mode .mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}body.dark-mode .mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,body.dark-mode .mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#686868}body.dark-mode .mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#686868}body.dark-mode .mat-checkbox-disabled .mat-checkbox-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-checkbox .mat-ripple-element{background-color:#fff}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}body.dark-mode .mat-autocomplete-panel{background:#424242;color:#fff}body.dark-mode .mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#424242}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#fff}body.dark-mode .mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-chip.mat-standard-chip{background-color:#616161;color:#fff}body.dark-mode .mat-chip.mat-standard-chip .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2), 0px 3px 4px 0px rgba(0, 0, 0, 0.14), 0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}body.dark-mode .mat-chip.mat-standard-chip::after{background:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#bdbdbd}body.dark-mode .mat-slide-toggle-bar{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-outer-circle{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-primary .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}body.dark-mode .mat-radio-button.mat-warn .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}body.dark-mode .mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-primary .mat-slider-track-fill,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-accent .mat-slider-track-fill,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-warn .mat-slider-track-fill,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}body.dark-mode .mat-slider:hover .mat-slider-track-background,body.dark-mode .mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-background,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-fill,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:#fff}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(255,255,255,.3);background-color:rgba(0,0,0,0)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-menu-panel{background:#424242}body.dark-mode .mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-menu-item{background:rgba(0,0,0,0);color:#fff}body.dark-mode .mat-menu-item[disabled],body.dark-mode .mat-menu-item[disabled] .mat-menu-submenu-icon,body.dark-mode .mat-menu-item[disabled] .mat-icon-no-color{color:rgba(255,255,255,.5)}body.dark-mode .mat-menu-item .mat-icon-no-color,body.dark-mode .mat-menu-submenu-icon{color:#fff}body.dark-mode .mat-menu-item:hover:not([disabled]),body.dark-mode .mat-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.04)}body.dark-mode .mat-list-base .mat-list-item{color:#fff}body.dark-mode .mat-list-base .mat-list-option{color:#fff}body.dark-mode .mat-list-base .mat-subheader{color:rgba(255,255,255,.7)}body.dark-mode .mat-list-base .mat-list-item-disabled{background-color:rgba(255,255,255,.12);color:#616161}body.dark-mode .mat-list-option:hover,body.dark-mode .mat-list-option:focus,body.dark-mode .mat-nav-list .mat-list-item:hover,body.dark-mode .mat-nav-list .mat-list-item:focus,body.dark-mode .mat-action-list .mat-list-item:hover,body.dark-mode .mat-action-list .mat-list-item:focus{background:rgba(255,255,255,.04)}body.dark-mode .mat-list-single-selected-option,body.dark-mode .mat-list-single-selected-option:hover,body.dark-mode .mat-list-single-selected-option:focus{background:rgba(255,255,255,.12)}body.dark-mode .mat-paginator{background:#424242}body.dark-mode .mat-paginator,body.dark-mode .mat-paginator-page-size .mat-select-trigger{color:rgba(255,255,255,.7)}body.dark-mode .mat-paginator-decrement,body.dark-mode .mat-paginator-increment{border-top:2px solid #fff;border-right:2px solid #fff}body.dark-mode .mat-paginator-first,body.dark-mode .mat-paginator-last{border-top:2px solid #fff}body.dark-mode .mat-icon-button[disabled] .mat-paginator-decrement,body.dark-mode .mat-icon-button[disabled] .mat-paginator-increment,body.dark-mode .mat-icon-button[disabled] .mat-paginator-first,body.dark-mode .mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-paginator-container{min-height:56px}body.dark-mode .mat-tab-nav-bar,body.dark-mode .mat-tab-header{border-bottom:1px solid rgba(255,255,255,.12)}body.dark-mode .mat-tab-group-inverted-header .mat-tab-nav-bar,body.dark-mode .mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(255,255,255,.12);border-bottom:none}body.dark-mode .mat-tab-label,body.dark-mode .mat-tab-link{color:#fff}body.dark-mode .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-link.mat-tab-disabled{color:#616161}body.dark-mode .mat-tab-header-pagination-chevron{border-color:#fff}body.dark-mode .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#616161}body.dark-mode .mat-tab-group[class*=mat-background-]>.mat-tab-header,body.dark-mode .mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-primary .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-accent .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-warn .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused{background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused{background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused.mat-tab-disabled{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-snack-bar-container{color:rgba(0,0,0,.87);background:#fafafa;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-simple-snackbar-action{color:inherit}body.dark-mode .mat-table{background:#424242}body.dark-mode .mat-table thead,body.dark-mode .mat-table tbody,body.dark-mode .mat-table tfoot,body.dark-mode mat-header-row,body.dark-mode mat-row,body.dark-mode mat-footer-row,body.dark-mode [mat-header-row],body.dark-mode [mat-row],body.dark-mode [mat-footer-row],body.dark-mode .mat-table-sticky{background:inherit}body.dark-mode mat-row,body.dark-mode mat-header-row,body.dark-mode mat-footer-row,body.dark-mode th.mat-header-cell,body.dark-mode td.mat-cell,body.dark-mode td.mat-footer-cell{border-bottom-color:rgba(255,255,255,.12)}body.dark-mode .mat-header-cell{color:rgba(255,255,255,.7)}body.dark-mode .mat-cell,body.dark-mode .mat-footer-cell{color:#fff}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base{width:40px;height:40px;padding:8px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:0px;margin-bottom:0px;margin-right:0px;margin-left:0px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mdc-icon-button__touch{position:absolute;top:50%;height:40px;left:50%;width:40px;transform:translate(-50%, -50%)}body.dark-mode .mat-calendar-controls .mat-mdc-icon-button.mat-mdc-button-base .mat-mdc-button-touch-target{display:none}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2), 0px 16px 24px 2px rgba(0, 0, 0, 0.14), 0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}
</style>

<style>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
    color: var(--primary-text-color);

    /* Legacy mechanism to avoid issues with subpixel anti-aliasing on macOS.
     *
     * In the past [1], macOS subpixel AA caused excessive bolding for light-on-dark text; this rule
     * avoids that by requesting non-subpixel AA always, rather than the default behavior, which is
     * to use subpixel AA when available. The original issue was "fixed" by removing subpixel AA in
     * macOS 14 (Mojave), but for legacy reasons they preserved the bolding effect as an option.
     * Chrome then in turn updated its font rendering to apply that bolding effect [2], which means
     * that even though the `-webkit-font-smoothing` docs [3] suggest that setting `antialiased`
     * would have no effect for recent versions of macOS, it still is needed to avoid the bolding.
     *
     * [1]: http://www.lighterra.com/articles/macosxtextaabug/
     * [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=858861
     * [3]: https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth
     *
     */

    -webkit-font-smoothing: antialiased;
  }
  noscript {
    display: block;
    margin: 0 auto;
    max-width: 600px;
    padding: 10px;
  }
</style>

</head><body><noscript>
    <h1>TensorBoard requires JavaScript</h1>
    <p>Please enable JavaScript and reload this page.</p>
  </noscript><tb-webapp></tb-webapp><script src="index.js?_file_hash=5caa02f5"></script></body></html>", + "ok": true, + "headers": [ + [ + "content-length", + "533863" + ], + [ + "content-type", + "text/html; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "10771" + ], + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/index.js?_file_hash=5caa02f5": { + "data": "var CLOSURE_NO_DEPS = true;
window.polymerSkipLoadingFontRoboto = true;
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.

!function(){var a={},b={},c={};!function(a,b){function c(a){if("number"==typeof a)return a;var b={};for(var c in a)b[c]=a[c];return b}function d(){this._delay=0,this._endDelay=0,this._fill="none",this._iterationStart=0,this._iterations=1,this._duration=0,this._playbackRate=1,this._direction="normal",this._easing="linear",this._easingFunction=x}function e(){return a.isDeprecated("Invalid timing inputs","2016-03-02","TypeError exceptions will be thrown instead.",!0)}function f(b,c,e){var f=new d;return c&&(f.fill="both",f.duration="auto"),"number"!=typeof b||isNaN(b)?void 0!==b&&Object.getOwnPropertyNames(b).forEach(function(c){if("auto"!=b[c]){if(("number"==typeof f[c]||"duration"==c)&&("number"!=typeof b[c]||isNaN(b[c])))return;if("fill"==c&&-1==v.indexOf(b[c]))return;if("direction"==c&&-1==w.indexOf(b[c]))return;if("playbackRate"==c&&1!==b[c]&&a.isDeprecated("AnimationEffectTiming.playbackRate","2014-11-28","Use Animation.playbackRate instead."))return;f[c]=b[c]}}):f.duration=b,f}function g(a){return"number"==typeof a&&(a=isNaN(a)?{duration:0}:{duration:a}),a}function h(b,c){return b=a.numericTimingToObject(b),f(b,c)}function i(a,b,c,d){return a<0||a>1||c<0||c>1?x:function(e){function f(a,b,c){return 3*a*(1-c)*(1-c)*c+3*b*(1-c)*c*c+c*c*c}if(e<=0){var g=0;return a>0?g=b/a:!b&&c>0&&(g=d/c),g*e}if(e>=1){var h=0;return c<1?h=(d-1)/(c-1):1==c&&a<1&&(h=(b-1)/(a-1)),1+h*(e-1)}for(var i=0,j=1;i<j;){var k=(i+j)/2,l=f(a,c,k);if(Math.abs(e-l)<1e-5)return f(b,d,k);l<e?i=k:j=k}return f(b,d,k)}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return(c+=b*d)-c%d}}function k(a){C||(C=document.createElement("div").style),C.animationTimingFunction="",C.animationTimingFunction=a;var b=C.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");return b}function l(a){if("linear"==a)return x;var b=E.exec(a);if(b)return i.apply(this,b.slice(1).map(Number));var c=F.exec(a);if(c)return j(Number(c[1]),A);var d=G.exec(a);return d?j(Number(d[1]),{start:y,middle:z,end:A}[d[2]]):B[a]||x}function m(a){return Math.abs(n(a)/a.playbackRate)}function n(a){return 0===a.duration||0===a.iterations?0:a.duration*a.iterations}function o(a,b,c){if(null==b)return H;var d=c.delay+a+c.endDelay;return b<Math.min(c.delay,d)?I:b>=Math.min(c.delay+a,d)?J:K}function p(a,b,c,d,e){switch(d){case I:return"backwards"==b||"both"==b?0:null;case K:return c-e;case J:return"forwards"==b||"both"==b?a:null;case H:return null}}function q(a,b,c,d,e){var f=e;return 0===a?b!==I&&(f+=c):f+=d/a,f}function r(a,b,c,d,e,f){var g=a===1/0?b%1:a%1;return 0!==g||c!==J||0===d||0===e&&0!==f||(g=1),g}function s(a,b,c,d){return a===J&&b===1/0?1/0:1===c?Math.floor(d)-1:Math.floor(d)}function t(a,b,c){var d=a;if("normal"!==a&&"reverse"!==a){var e=b;"alternate-reverse"===a&&(e+=1),d="normal",e!==1/0&&e%2!=0&&(d="reverse")}return"normal"===d?c:1-c}function u(a,b,c){var d=o(a,b,c),e=p(a,c.fill,b,d,c.delay);if(null===e)return null;var f=q(c.duration,d,c.iterations,e,c.iterationStart),g=r(f,c.iterationStart,d,c.iterations,e,c.duration),h=s(d,c.iterations,g,f),i=t(c.direction,h,g);return c._easingFunction(i)}var v="backwards|forwards|both|none".split("|"),w="reverse|alternate|alternate-reverse".split("|"),x=function(a){return a};d.prototype={_setMember:function(b,c){this["_"+b]=c,this._effect&&(this._effect._timingInput[b]=c,this._effect._timing=a.normalizeTimingInput(this._effect._timingInput),this._effect.activeDuration=a.calculateActiveDuration(this._effect._timing),this._effect._animation&&this._effect._animation._rebuildUnderlyingAnimation())},get playbackRate(){return this._playbackRate},set delay(a){this._setMember("delay",a)},get delay(){return this._delay},set endDelay(a){this._setMember("endDelay",a)},get endDelay(){return this._endDelay},set fill(a){this._setMember("fill",a)},get fill(){return this._fill},set iterationStart(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+a);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||a<0)&&e())throw new TypeError("duration must be non-negative or auto, received: "+a);this._setMember("duration",a)},get duration(){return this._duration},set direction(a){this._setMember("direction",a)},get direction(){return this._direction},set easing(a){this._easingFunction=l(k(a)),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var y=1,z=.5,A=0,B={ease:i(.25,.1,.25,1),"ease-in":i(.42,0,1,1),"ease-out":i(0,0,.58,1),"ease-in-out":i(.42,0,.58,1),"step-start":j(1,y),"step-middle":j(1,z),"step-end":j(1,A)},C=null,D="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",E=new RegExp("cubic-bezier\\("+D+","+D+","+D+","+D+"\\)"),F=/steps\(\s*(\d+)\s*\)/,G=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,H=0,I=1,J=2,K=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=m,a.calculateIterationProgress=u,a.calculatePhase=o,a.normalizeEasing=k,a.parseEasingFunction=l}(a),function(a,b){function c(a,b){return a in k?k[a][b]||b:b}function d(a){return"display"===a||0===a.lastIndexOf("animation",0)||0===a.lastIndexOf("transition",0)}function e(a,b,e){if(!d(a)){var f=h[a];if(f){i.style[a]=b;for(var g in f){var j=f[g],k=i.style[j];e[j]=c(j,k)}}else e[a]=c(a,b)}}function f(a){var b=[];for(var c in a)if(!(c in["easing","offset","composite"])){var d=a[c];Array.isArray(d)||(d=[d]);for(var e,f=d.length,g=0;g<f;g++)e={},e.offset="offset"in a?a.offset:1==f?1:g/(f-1),"easing"in a&&(e.easing=a.easing),"composite"in a&&(e.composite=a.composite),e[c]=d[g],b.push(e)}return b.sort(function(a,b){return a.offset-b.offset}),b}function g(b){function c(){var a=d.length;null==d[a-1].offset&&(d[a-1].offset=1),a>1&&null==d[0].offset&&(d[0].offset=0);for(var b=0,c=d[0].offset,e=1;e<a;e++){var f=d[e].offset;if(null!=f){for(var g=1;g<e-b;g++)d[b+g].offset=c+(f-c)*g/(e-b);b=e,c=f}}}if(null==b)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||(b=f(b));for(var d=b.map(function(b){var c={};for(var d in b){var f=b[d];if("offset"==d){if(null!=f){if(f=Number(f),!isFinite(f))throw new TypeError("Keyframe offsets must be numbers.");if(f<0||f>1)throw new TypeError("Keyframe offsets must be between 0 and 1.")}}else if("composite"==d){if("add"==f||"accumulate"==f)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};if("replace"!=f)throw new TypeError("Invalid composite mode "+f+".")}else f="easing"==d?a.normalizeEasing(f):""+f;e(d,f,c)}return void 0==c.offset&&(c.offset=null),void 0==c.easing&&(c.easing="linear"),c}),g=!0,h=-1/0,i=0;i<d.length;i++){var j=d[i].offset;if(null!=j){if(j<h)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");h=j}else g=!1}return d=d.filter(function(a){return a.offset>=0&&a.offset<=1}),g||c(),d}var h={background:["backgroundImage","backgroundPosition","backgroundSize","backgroundRepeat","backgroundAttachment","backgroundOrigin","backgroundClip","backgroundColor"],border:["borderTopColor","borderTopStyle","borderTopWidth","borderRightColor","borderRightStyle","borderRightWidth","borderBottomColor","borderBottomStyle","borderBottomWidth","borderLeftColor","borderLeftStyle","borderLeftWidth"],borderBottom:["borderBottomWidth","borderBottomStyle","borderBottomColor"],borderColor:["borderTopColor","borderRightColor","borderBottomColor","borderLeftColor"],borderLeft:["borderLeftWidth","borderLeftStyle","borderLeftColor"],borderRadius:["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],borderRight:["borderRightWidth","borderRightStyle","borderRightColor"],borderTop:["borderTopWidth","borderTopStyle","borderTopColor"],borderWidth:["borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth"],flex:["flexGrow","flexShrink","flexBasis"],font:["fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineHeight"],margin:["marginTop","marginRight","marginBottom","marginLeft"],outline:["outlineColor","outlineStyle","outlineWidth"],padding:["paddingTop","paddingRight","paddingBottom","paddingLeft"]},i=document.createElementNS("http://www.w3.org/1999/xhtml","div"),j={thin:"1px",medium:"3px",thick:"5px"},k={borderBottomWidth:j,borderLeftWidth:j,borderRightWidth:j,borderTopWidth:j,fontSize:{"xx-small":"60%","x-small":"75%",small:"89%",medium:"100%",large:"120%","x-large":"150%","xx-large":"200%"},fontWeight:{normal:"400",bold:"700"},outlineWidth:j,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=f,a.normalizeKeyframes=g}(a),function(a){var b={};a.isDeprecated=function(a,c,d,e){var f=e?"are":"is",g=new Date,h=new Date(c);return h.setMonth(h.getMonth()+3),!(g<h&&(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,1))},a.deprecated=function(b,c,d,e){var f=e?"are":"is";if(a.isDeprecated(b,c,d,e))throw new Error(b+" "+f+" no longer supported. "+d)}}(a),function(){if(document.documentElement.animate){var c=document.documentElement.animate([],0),d=!0;if(c&&(d=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(a){void 0===c[a]&&(d=!0)})),!d)return}!function(a,b,c){function d(a){for(var b={},c=0;c<a.length;c++)for(var d in a[c])if("offset"!=d&&"easing"!=d&&"composite"!=d){var e={offset:a[c].offset,easing:a[c].easing,value:a[c][d]};b[d]=b[d]||[],b[d].push(e)}for(var f in b){var g=b[f];if(0!=g[0].offset||1!=g[g.length-1].offset)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"Partial keyframes are not supported"}}return b}function e(c){var d=[];for(var e in c)for(var f=c[e],g=0;g<f.length-1;g++){var h=g,i=g+1,j=f[h].offset,k=f[i].offset,l=j,m=k;0==g&&(l=-1/0,0==k&&(i=h)),g==f.length-2&&(m=1/0,1==j&&(h=i)),d.push({applyFrom:l,applyTo:m,startOffset:f[h].offset,endOffset:f[i].offset,easingFunction:a.parseEasingFunction(f[h].easing),property:e,interpolation:b.propertyInterpolation(e,f[h].value,f[i].value)})}return d.sort(function(a,b){return a.startOffset-b.startOffset}),d}b.convertEffectInput=function(c){var f=a.normalizeKeyframes(c),g=d(f),h=e(g);return function(a,c){if(null!=c)h.filter(function(a){return c>=a.applyFrom&&c<a.applyTo}).forEach(function(d){var e=c-d.startOffset,f=d.endOffset-d.startOffset,g=0==f?0:d.easingFunction(e/f);b.apply(a,d.property,d.interpolation(g))});else for(var d in g)"offset"!=d&&"easing"!=d&&"composite"!=d&&b.clear(a,d)}}}(a,b),function(a,b,c){function d(a){return a.replace(/-(.)/g,function(a,b){return b.toUpperCase()})}function e(a,b,c){h[c]=h[c]||[],h[c].push([a,b])}function f(a,b,c){for(var f=0;f<c.length;f++){e(a,b,d(c[f]))}}function g(c,e,f){var g=c;/-/.test(c)&&!a.isDeprecated("Hyphenated property names","2016-03-22","Use camelCase instead.",!0)&&(g=d(c)),"initial"!=e&&"initial"!=f||("initial"==e&&(e=i[g]),"initial"==f&&(f=i[g]));for(var j=e==f?[]:h[g],k=0;j&&k<j.length;k++){var l=j[k][0](e),m=j[k][0](f);if(void 0!==l&&void 0!==m){var n=j[k][1](l,m);if(n){var o=b.Interpolation.apply(null,n);return function(a){return 0==a?e:1==a?f:o(a)}}}}return b.Interpolation(!1,!0,function(a){return a?f:e})}var h={};b.addPropertiesHandler=f;var i={backgroundColor:"transparent",backgroundPosition:"0% 0%",borderBottomColor:"currentColor",borderBottomLeftRadius:"0px",borderBottomRightRadius:"0px",borderBottomWidth:"3px",borderLeftColor:"currentColor",borderLeftWidth:"3px",borderRightColor:"currentColor",borderRightWidth:"3px",borderSpacing:"2px",borderTopColor:"currentColor",borderTopLeftRadius:"0px",borderTopRightRadius:"0px",borderTopWidth:"3px",bottom:"auto",clip:"rect(0px, 0px, 0px, 0px)",color:"black",fontSize:"100%",fontWeight:"400",height:"auto",left:"auto",letterSpacing:"normal",lineHeight:"120%",marginBottom:"0px",marginLeft:"0px",marginRight:"0px",marginTop:"0px",maxHeight:"none",maxWidth:"none",minHeight:"0px",minWidth:"0px",opacity:"1.0",outlineColor:"invert",outlineOffset:"0px",outlineWidth:"3px",paddingBottom:"0px",paddingLeft:"0px",paddingRight:"0px",paddingTop:"0px",right:"auto",strokeDasharray:"none",strokeDashoffset:"0px",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(a,b),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateIterationProgress(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d}b.KeyframeEffect=function(c,e,f,g){var h,i=d(a.normalizeTimingInput(f)),j=b.convertEffectInput(e),k=function(){j(c,h)};return k._update=function(a){return null!==(h=i(a))},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._target=c,k._totalDuration=i._totalDuration,k._id=g,k}}(a,b),function(a,b){a.apply=function(b,c,d){b.style[a.propertyName(c)]=d},a.clear=function(b,c){b.style[a.propertyName(c)]=""}}(b),function(a){window.Element.prototype.animate=function(b,c){var d="";return c&&c.id&&(d=c.id),a.timeline._play(a.KeyframeEffect(this,b,c,d))}}(b),function(a,b){function c(a,b,d){if("number"==typeof a&&"number"==typeof b)return a*(1-d)+b*d;if("boolean"==typeof a&&"boolean"==typeof b)return d<.5?a:b;if(a.length==b.length){for(var e=[],f=0;f<a.length;f++)e.push(c(a[f],b[f],d));return e}throw"Mismatched interpolation arguments "+a+":"+b}a.Interpolation=function(a,b,d){return function(e){return d(c(a,b,e))}}}(b),function(a,b,c){a.sequenceNumber=0;var d=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="finish",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()};b.Animation=function(b){this.id="",b&&b._id&&(this.id=b._id),this._sequenceNumber=a.sequenceNumber++,this._currentTime=0,this._startTime=null,this._paused=!1,this._playbackRate=1,this._inTimeline=!0,this._finishedFlag=!0,this.onfinish=null,this._finishHandlers=[],this._effect=b,this._inEffect=this._effect._update(0),this._idle=!0,this._currentTimePending=!1},b.Animation.prototype={_ensureAlive:function(){this.playbackRate<0&&0===this.currentTime?this._inEffect=this._effect._update(-1):this._inEffect=this._effect._update(this.currentTime),this._inTimeline||!this._inEffect&&this._finishedFlag||(this._inTimeline=!0,b.timeline._animations.push(this))},_tickCurrentTime:function(a,b){a!=this._currentTime&&(this._currentTime=a,this._isFinished&&!b&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this._ensureAlive())},get currentTime(){return this._idle||this._currentTimePending?null:this._currentTime},set currentTime(a){a=+a,isNaN(a)||(b.restart(),this._paused||null==this._startTime||(this._startTime=this._timeline.currentTime-a/this._playbackRate),this._currentTimePending=!1,this._currentTime!=a&&(this._idle&&(this._idle=!1,this._paused=!0),this._tickCurrentTime(a,!0),b.applyDirtiedAnimation(this)))},get startTime(){return this._startTime},set startTime(a){a=+a,isNaN(a)||this._paused||this._idle||(this._startTime=a,this._tickCurrentTime((this._timeline.currentTime-this._startTime)*this.playbackRate),b.applyDirtiedAnimation(this))},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var c=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&(this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)),null!=c&&(this.currentTime=c)}},get _isFinished(){return!this._idle&&(this._playbackRate>0&&this._currentTime>=this._totalDuration||this._playbackRate<0&&this._currentTime<=0)},get _totalDuration(){return this._effect._totalDuration},get playState(){return this._idle?"idle":null==this._startTime&&!this._paused&&0!=this.playbackRate||this._currentTimePending?"pending":this._paused?"paused":this._isFinished?"finished":"running"},_rewind:function(){if(this._playbackRate>=0)this._currentTime=0;else{if(!(this._totalDuration<1/0))throw new DOMException("Unable to rewind negative playback rate animation with infinite duration","InvalidStateError");this._currentTime=this._totalDuration}},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)},pause:function(){this._isFinished||this._paused||this._idle?this._idle&&(this._rewind(),this._idle=!1):this._currentTimePending=!0,this._startTime=null,this._paused=!0},finish:function(){this._idle||(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this._currentTimePending=!1,b.applyDirtiedAnimation(this))},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this._effect._update(null),b.applyDirtiedAnimation(this))},reverse:function(){this.playbackRate*=-1,this.play()},addEventListener:function(a,b){"function"==typeof b&&"finish"==a&&this._finishHandlers.push(b)},removeEventListener:function(a,b){if("finish"==a){var c=this._finishHandlers.indexOf(b);c>=0&&this._finishHandlers.splice(c,1)}},_fireEvents:function(a){if(this._isFinished){if(!this._finishedFlag){var b=new d(this,this._currentTime,a),c=this._finishHandlers.concat(this.onfinish?[this.onfinish]:[]);setTimeout(function(){c.forEach(function(a){a.call(b.target,b)})},0),this._finishedFlag=!0}}else this._finishedFlag=!1},_tick:function(a,b){this._idle||this._paused||(null==this._startTime?b&&(this.startTime=a-this._currentTime/this.playbackRate):this._isFinished||this._tickCurrentTime((a-this._startTime)*this.playbackRate)),b&&(this._currentTimePending=!1,this._fireEvents(a))},get _needsTick(){return this.playState in{pending:1,running:1}||!this._finishedFlag},_targetAnimations:function(){var a=this._effect._target;return a._activeAnimations||(a._activeAnimations=[]),a._activeAnimations},_markTarget:function(){var a=this._targetAnimations();-1===a.indexOf(this)&&a.push(this)},_unmarkTarget:function(){var a=this._targetAnimations(),b=a.indexOf(this);-1!==b&&a.splice(b,1)}}}(a,b),function(a,b,c){function d(a){var b=j;j=[],a<q.currentTime&&(a=q.currentTime),q._animations.sort(e),q._animations=h(a,!0,q._animations)[0],b.forEach(function(b){b[1](a)}),g(),l=void 0}function e(a,b){return a._sequenceNumber-b._sequenceNumber}function f(){this._animations=[],this.currentTime=window.performance&&performance.now?performance.now():0}function g(){o.forEach(function(a){a()}),o.length=0}function h(a,c,d){p=!0,n=!1,b.timeline.currentTime=a,m=!1;var e=[],f=[],g=[],h=[];return d.forEach(function(b){b._tick(a,c),b._inEffect?(f.push(b._effect),b._markTarget()):(e.push(b._effect),b._unmarkTarget()),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;b._inTimeline=d,d?g.push(b):h.push(b)}),o.push.apply(o,e),o.push.apply(o,f),m&&requestAnimationFrame(function(){}),p=!1,[g,h]}var i=window.requestAnimationFrame,j=[],k=0;window.requestAnimationFrame=function(a){var b=k++;return 0==j.length&&i(d),j.push([b,a]),b},window.cancelAnimationFrame=function(a){j.forEach(function(b){b[0]==a&&(b[1]=function(){})})},f.prototype={_play:function(c){c._timing=a.normalizeTimingInput(c.timing);var d=new b.Animation(c);return d._idle=!1,d._timeline=this,this._animations.push(d),b.restart(),b.applyDirtiedAnimation(d),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.applyDirtiedAnimation=function(a){if(!p){a._markTarget();var c=a._targetAnimations();c.sort(e),h(b.timeline.currentTime,!1,c.slice())[1].forEach(function(a){var b=q._animations.indexOf(a);-1!==b&&q._animations.splice(b,1)}),g()}};var o=[],p=!1,q=new f;b.timeline=q}(a,b),function(a){function b(a,b){var c=a.exec(b);if(c)return c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);if(c)return[c[0],c[1].replace(/^\s*/,"")]}function d(a,d,e){a=c.bind(null,a);for(var f=[];;){var g=a(e);if(!g)return[f,e];if(f.push(g[0]),e=g[1],!(g=b(d,e))||""==g[1])return[f,e];e=g[1]}}function e(a,b){for(var c=0,d=0;d<b.length&&(!/\s|,/.test(b[d])||0!=c);d++)if("("==b[d])c++;else if(")"==b[d]&&(c--,0==c&&d++,c<=0))break;var e=a(b.substr(0,d));return void 0==e?void 0:[e,b.substr(d)]}function f(a,b){for(var c=a,d=b;c&&d;)c>d?c%=d:d%=c;return c=a*b/(c+d)}function g(a){return function(b){var c=a(b);return c&&(c[0]=void 0),c}}function h(a,b){return function(c){return a(c)||[b,c]}}function i(b,c){for(var d=[],e=0;e<b.length;e++){var f=a.consumeTrimmed(b[e],c);if(!f||""==f[0])return;void 0!==f[0]&&d.push(f[0]),c=f[1]}if(""==c)return d}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;k<j;k++){var l=b(d[k%d.length],e[k%e.length]);if(!l)return;g.push(l[0]),h.push(l[1]),i.push(l[2])}return[g,h,function(b){var d=b.map(function(a,b){return i[b](a)}).join(c);return a?a(d):d}]}function k(a,b,c){for(var d=[],e=[],f=[],g=0,h=0;h<c.length;h++)if("function"==typeof c[h]){var i=c[h](a[g],b[g++]);d.push(i[0]),e.push(i[1]),f.push(i[2])}else!function(a){d.push(!1),e.push(!1),f.push(function(){return c[a]})}(h);return[d,e,function(a){for(var b="",c=0;c<a.length;c++)b+=f[c](a[c]);return b}]}a.consumeToken=b,a.consumeTrimmed=c,a.consumeRepeated=d,a.consumeParenthesised=e,a.ignore=g,a.optional=h,a.consumeList=i,a.mergeNestedRepeated=j.bind(null,null),a.mergeWrappedNestedRepeated=j,a.mergeList=k}(b),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);return c?(d.inset=!0,c):(c=a.consumeLengthOrPercent(b))?(d.lengths.push(c[0]),c):(c=a.consumeColor(b),c?(d.color=c[0],c):void 0)}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);if(e&&e[0].length)return[d,e[1]]}function c(c){var d=a.consumeRepeated(b,/^,/,c);if(d&&""==d[1])return d[0]}function d(b,c){for(;b.lengths.length<Math.max(b.lengths.length,c.lengths.length);)b.lengths.push({px:0});for(;c.lengths.length<Math.max(b.lengths.length,c.lengths.length);)c.lengths.push({px:0});if(b.inset==c.inset&&!!b.color==!!c.color){for(var d,e=[],f=[[],0],g=[[],0],h=0;h<b.lengths.length;h++){var i=a.mergeDimensions(b.lengths[h],c.lengths[h],2==h);f[0].push(i[0]),g[0].push(i[1]),e.push(i[2])}if(b.color&&c.color){var j=a.mergeColors(b.color,c.color);f[1]=j[0],g[1]=j[1],d=j[2]}return[f,g,function(a){for(var c=b.inset?"inset ":" ",f=0;f<e.length;f++)c+=e[f](a[0][f])+" ";return d&&(c+=d(a[1])),c}]}}function e(b,c,d,e){function f(a){return{inset:a,color:[0,0,0,0],lengths:[{px:0},{px:0},{px:0},{px:0}]}}for(var g=[],h=[],i=0;i<d.length||i<e.length;i++){var j=d[i]||f(e[i].inset),k=e[i]||f(d[i].inset);g.push(j),h.push(k)}return a.mergeNestedRepeated(b,c,g,h)}var f=e.bind(null,d,", ");a.addPropertiesHandler(c,f,["box-shadow","text-shadow"])}(b),function(a,b){function c(a){return a.toFixed(3).replace(/0+$/,"").replace(/\.$/,"")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){if(/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a))return Number(a)}function f(a,b){return[a,b,c]}function g(a,b){if(0!=a)return i(0,1/0)(a,b)}function h(a,b){return[a,b,function(a){return Math.round(d(1,1/0,a))}]}function i(a,b){return function(e,f){return[e,f,function(e){return c(d(a,b,e))}]}}function j(a){var b=a.trim().split(/\s*[\s,]\s*/);if(0!==b.length){for(var c=[],d=0;d<b.length;d++){var f=e(b[d]);if(void 0===f)return;c.push(f)}return c}}function k(a,b){if(a.length==b.length)return[a,b,function(a){return a.map(c).join(" ")}]}function l(a,b){return[a,b,Math.round]}a.clamp=d,a.addPropertiesHandler(j,k,["stroke-dasharray"]),a.addPropertiesHandler(e,i(0,1/0),["border-image-width","line-height"]),a.addPropertiesHandler(e,i(0,1),["opacity","shape-image-threshold"]),a.addPropertiesHandler(e,g,["flex-grow","flex-shrink"]),a.addPropertiesHandler(e,h,["orphans","widows"]),a.addPropertiesHandler(e,l,["z-index"]),a.parseNumber=e,a.parseNumberList=j,a.mergeNumbers=f,a.numberToString=c}(b),function(a,b){function c(a,b){if("visible"==a||"visible"==b)return[0,1,function(c){return c<=0?a:c>=1?b:"visible"}]}a.addPropertiesHandler(String,c,["visibility"])}(b),function(a,b){function c(a){a=a.trim(),f.fillStyle="#000",f.fillStyle=a;var b=f.fillStyle;if(f.fillStyle="#fff",f.fillStyle=a,b==f.fillStyle){f.fillRect(0,0,1,1);var c=f.getImageData(0,0,1,1).data;f.clearRect(0,0,1,1);var d=c[3]/255;return[c[0]*d,c[1]*d,c[2]*d,d]}}function d(b,c){return[b,c,function(b){function c(a){return Math.max(0,Math.min(255,a))}if(b[3])for(var d=0;d<3;d++)b[d]=Math.round(c(b[d]/b[3]));return b[3]=a.numberToString(a.clamp(0,1,b[3])),"rgba("+b.join(",")+")"}]}var e=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");e.width=e.height=1;var f=e.getContext("2d");a.addPropertiesHandler(c,d,["background-color","border-bottom-color","border-left-color","border-right-color","border-top-color","color","fill","flood-color","lighting-color","outline-color","stop-color","stroke","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(b),function(a,b){function c(a){function b(){var b=h.exec(a);g=b?b[0]:void 0}function c(){var a=Number(g);return b(),a}function d(){if("("!==g)return c();b();var a=f();return")"!==g?NaN:(b(),a)}function e(){for(var a=d();"*"===g||"/"===g;){var c=g;b();var e=d();"*"===c?a*=e:a/=e}return a}function f(){for(var a=e();"+"===g||"-"===g;){var c=g;b();var d=e();"+"===c?a+=d:a-=d}return a}var g,h=/([\+\-\w\.]+|[\(\)\*\/])/g;return b(),f()}function d(a,b){if("0"==(b=b.trim().toLowerCase())&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var d={};b=b.replace(a,function(a){return d[a]=null,"U"+a});for(var e="U("+a.source+")",f=b.replace(/[-+]?(\d*\.)?\d+([Ee][-+]?\d+)?/g,"N").replace(new RegExp("N"+e,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),g=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],h=0;h<g.length;)g[h].test(f)?(f=f.replace(g[h],"$1"),h=0):h++;if("D"==f){for(var i in d){var j=c(b.replace(new RegExp("U"+i,"g"),"").replace(new RegExp(e,"g"),"*0"));if(!isFinite(j))return;d[i]=j}return d}}}function e(a,b){return f(a,b,!0)}function f(b,c,d){var e,f=[];for(e in b)f.push(e);for(e in c)f.indexOf(e)<0&&f.push(e);return b=f.map(function(a){return b[a]||0}),c=f.map(function(a){return c[a]||0}),[b,c,function(b){var c=b.map(function(c,e){return 1==b.length&&d&&(c=Math.max(c,0)),a.numberToString(c)+f[e]}).join(" + ");return b.length>1?"calc("+c+")":c}]}var g="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",h=d.bind(null,new RegExp(g,"g")),i=d.bind(null,new RegExp(g+"|%","g")),j=d.bind(null,/deg|rad|grad|turn/g);a.parseLength=h,a.parseLengthOrPercent=i,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,i),a.parseAngle=j,a.mergeDimensions=f;var k=a.consumeParenthesised.bind(null,h),l=a.consumeRepeated.bind(void 0,k,/^/),m=a.consumeRepeated.bind(void 0,l,/^,/);a.consumeSizePairList=m;var n=function(a){var b=m(a);if(b&&""==b[1])return b[0]},o=a.mergeNestedRepeated.bind(void 0,e," "),p=a.mergeNestedRepeated.bind(void 0,o,",");a.mergeNonNegativeSizePair=o,a.addPropertiesHandler(n,p,["background-size"]),a.addPropertiesHandler(i,e,["border-bottom-width","border-image-width","border-left-width","border-right-width","border-top-width","flex-basis","font-size","height","line-height","max-height","max-width","outline-width","width"]),a.addPropertiesHandler(i,f,["border-bottom-left-radius","border-bottom-right-radius","border-top-left-radius","border-top-right-radius","bottom","left","letter-spacing","margin-bottom","margin-left","margin-right","margin-top","min-height","min-width","outline-offset","padding-bottom","padding-left","padding-right","padding-top","perspective","right","shape-margin","stroke-dashoffset","text-indent","top","vertical-align","word-spacing"])}(b),function(a,b){function c(b){return a.consumeLengthOrPercent(b)||a.consumeToken(/^auto/,b)}function d(b){var d=a.consumeList([a.ignore(a.consumeToken.bind(null,/^rect/)),a.ignore(a.consumeToken.bind(null,/^\(/)),a.consumeRepeated.bind(null,c,/^,/),a.ignore(a.consumeToken.bind(null,/^\)/))],b);if(d&&4==d[0].length)return d[0]}function e(b,c){return"auto"==b||"auto"==c?[!0,!1,function(d){var e=d?b:c;if("auto"==e)return"auto";var f=a.mergeDimensions(e,e);return f[2](f[0])}]:a.mergeDimensions(b,c)}function f(a){return"rect("+a+")"}var g=a.mergeWrappedNestedRepeated.bind(null,f,e,", ");a.parseBox=d,a.mergeBoxes=g,a.addPropertiesHandler(d,g,["clip"])}(b),function(a,b){function c(a){return function(b){var c=0;return a.map(function(a){return a===k?b[c++]:a})}}function d(a){return a}function e(b){if("none"==(b=b.toLowerCase().trim()))return[];for(var c,d=/\s*(\w+)\(([^)]*)\)/g,e=[],f=0;c=d.exec(b);){if(c.index!=f)return;f=c.index+c[0].length;var g=c[1],h=n[g];if(!h)return;var i=c[2].split(","),j=h[0];if(j.length<i.length)return;for(var k=[],o=0;o<j.length;o++){var p,q=i[o],r=j[o];if(void 0===(p=q?{A:function(b){return"0"==b.trim()?m:a.parseAngle(b)},N:a.parseNumber,T:a.parseLengthOrPercent,L:a.parseLength}[r.toUpperCase()](q):{a:m,n:k[0],t:l}[r]))return;k.push(p)}if(e.push({t:g,d:k}),d.lastIndex==b.length)return e}}function f(a){return a.toFixed(6).replace(".000000","")}function g(b,c){if(b.decompositionPair!==c){b.decompositionPair=c;var d=a.makeMatrixDecomposition(b)}if(c.decompositionPair!==b){c.decompositionPair=b;var e=a.makeMatrixDecomposition(c)}return null==d[0]||null==e[0]?[[!1],[!0],function(a){return a?c[0].d:b[0].d}]:(d[0].push(0),e[0].push(1),[d,e,function(b){var c=a.quat(d[0][3],e[0][3],b[5]);return a.composeMatrix(b[0],b[1],b[2],c,b[4]).map(f).join(",")}])}function h(a){return a.replace(/[xy]/,"")}function i(a){return a.replace(/(x|y|z|3d)?$/,"3d")}function j(b,c){var d=a.makeMatrixDecomposition&&!0,e=!1;if(!b.length||!c.length){b.length||(e=!0,b=c,c=[]);for(var f=0;f<b.length;f++){var j=b[f].t,k=b[f].d,l="scale"==j.substr(0,5)?1:0;c.push({t:j,d:k.map(function(a){if("number"==typeof a)return l;var b={};for(var c in a)b[c]=l;return b})})}}var m=function(a,b){return"perspective"==a&&"perspective"==b||("matrix"==a||"matrix3d"==a)&&("matrix"==b||"matrix3d"==b)},o=[],p=[],q=[];if(b.length!=c.length){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]]}else for(var f=0;f<b.length;f++){var j,s=b[f].t,t=c[f].t,u=b[f].d,v=c[f].d,w=n[s],x=n[t];if(m(s,t)){if(!d)return;var r=g([b[f]],[c[f]]);o.push(r[0]),p.push(r[1]),q.push(["matrix",[r[2]]])}else{if(s==t)j=s;else if(w[2]&&x[2]&&h(s)==h(t))j=h(s),u=w[2](u),v=x[2](v);else{if(!w[1]||!x[1]||i(s)!=i(t)){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]];break}j=i(s),u=w[1](u),v=x[1](v)}for(var y=[],z=[],A=[],B=0;B<u.length;B++){var C="number"==typeof u[B]?a.mergeNumbers:a.mergeDimensions,r=C(u[B],v[B]);y[B]=r[0],z[B]=r[1],A.push(r[2])}o.push(y),p.push(z),q.push([j,A])}}if(e){var D=o;o=p,p=D}return[o,p,function(a){return a.map(function(a,b){var c=a.map(function(a,c){return q[b][1][c](a)}).join(",");return"matrix"==q[b][0]&&16==c.split(",").length&&(q[b][0]="matrix3d"),q[b][0]+"("+c+")"}).join(" ")}]}var k=null,l={px:0},m={deg:0},n={matrix:["NNNNNN",[k,k,0,0,k,k,0,0,0,0,1,0,k,k,0,1],d],matrix3d:["NNNNNNNNNNNNNNNN",d],rotate:["A"],rotatex:["A"],rotatey:["A"],rotatez:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",c([k,k,1]),d],scalex:["N",c([k,1,1]),c([k,1])],scaley:["N",c([1,k,1]),c([1,k])],scalez:["N",c([1,1,k])],scale3d:["NNN",d],skew:["Aa",null,d],skewx:["A",null,c([k,m])],skewy:["A",null,c([m,k])],translate:["Tt",c([k,k,l]),d],translatex:["T",c([k,l,l]),c([k,l])],translatey:["T",c([l,k,l]),c([l,k])],translatez:["L",c([l,l,k])],translate3d:["TTL",d]};a.addPropertiesHandler(e,j,["transform"]),a.transformToSvgMatrix=function(b){var c=a.transformListToMatrix(e(b));return"matrix("+f(c[0])+" "+f(c[1])+" "+f(c[4])+" "+f(c[5])+" "+f(c[12])+" "+f(c[13])+")"}}(b),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b),e[b]=a})}var d={},e={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a},a.unprefixedPropertyName=function(a){return e[a]||a}}(b)}(),function(){if(void 0===document.createElement("div").animate([]).oncancel){var a;if(window.performance&&performance.now)var a=function(){return performance.now()};else var a=function(){return Date.now()};var b=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="cancel",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()},c=window.Element.prototype.animate;window.Element.prototype.animate=function(d,e){var f=c.call(this,d,e);f._cancelHandlers=[],f.oncancel=null;var g=f.cancel;f.cancel=function(){g.call(this);var c=new b(this,null,a()),d=this._cancelHandlers.concat(this.oncancel?[this.oncancel]:[]);setTimeout(function(){d.forEach(function(a){a.call(c.target,c)})},0)};var h=f.addEventListener;f.addEventListener=function(a,b){"function"==typeof b&&"cancel"==a?this._cancelHandlers.push(b):h.call(this,a,b)};var i=f.removeEventListener;return f.removeEventListener=function(a,b){if("cancel"==a){var c=this._cancelHandlers.indexOf(b);c>=0&&this._cancelHandlers.splice(c,1)}else i.call(this,a,b)},f}}}(),function(a){var b=document.documentElement,c=null,d=!1;try{var e=getComputedStyle(b).getPropertyValue("opacity"),f="0"==e?"1":"0";c=b.animate({opacity:[f,f]},{duration:1}),c.currentTime=0,d=getComputedStyle(b).getPropertyValue("opacity")==f}catch(a){}finally{c&&c.cancel()}if(!d){var g=window.Element.prototype.animate;window.Element.prototype.animate=function(b,c){return window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||null===b||(b=a.convertToArrayForm(b)),g.call(this,b,c)}}}(a),function(a,b,c){function d(a){var c=b.timeline;c.currentTime=a,c._discardAnimations(),0==c._animations.length?f=!1:requestAnimationFrame(d)}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(c){b.timeline._updateAnimationsPromises(),a(c),b.timeline._updateAnimationsPromises()})},b.AnimationTimeline=function(){this._animations=[],this.currentTime=void 0},b.AnimationTimeline.prototype={getAnimations:function(){return this._discardAnimations(),this._animations.slice()},_updateAnimationsPromises:function(){b.animationsWithPromises=b.animationsWithPromises.filter(function(a){return a._updatePromises()})},_discardAnimations:function(){this._updateAnimationsPromises(),this._animations=this._animations.filter(function(a){return"finished"!=a.playState&&"idle"!=a.playState})},_play:function(a){var c=new b.Animation(a,this);return this._animations.push(c),b.restartWebAnimationsNextTick(),c._updatePromises(),c._animation.play(),c._updatePromises(),c},play:function(a){return a&&a.remove(),this._play(a)}};var f=!1;b.restartWebAnimationsNextTick=function(){f||(f=!0,requestAnimationFrame(d))};var g=new b.AnimationTimeline;b.timeline=g;try{Object.defineProperty(window.document,"timeline",{configurable:!0,get:function(){return g}})}catch(a){}try{window.document.timeline=g}catch(a){}}(0,c),function(a,b,c){b.animationsWithPromises=[],b.Animation=function(b,c){if(this.id="",b&&b._id&&(this.id=b._id),this.effect=b,b&&(b._animation=this),!c)throw new Error("Animation with null timeline is not supported");this._timeline=c,this._sequenceNumber=a.sequenceNumber++,this._holdTime=0,this._paused=!1,this._isGroup=!1,this._animation=null,this._childAnimations=[],this._callback=null,this._oldPlayState="idle",this._rebuildUnderlyingAnimation(),this._animation.cancel(),this._updatePromises()},b.Animation.prototype={_updatePromises:function(){var a=this._oldPlayState,b=this.playState;return this._readyPromise&&b!==a&&("idle"==b?(this._rejectReadyPromise(),this._readyPromise=void 0):"pending"==a?this._resolveReadyPromise():"pending"==b&&(this._readyPromise=void 0)),this._finishedPromise&&b!==a&&("idle"==b?(this._rejectFinishedPromise(),this._finishedPromise=void 0):"finished"==b?this._resolveFinishedPromise():"finished"==a&&(this._finishedPromise=void 0)),this._oldPlayState=this.playState,this._readyPromise||this._finishedPromise},_rebuildUnderlyingAnimation:function(){this._updatePromises();var a,c,d,e,f=!!this._animation;f&&(a=this.playbackRate,c=this._paused,d=this.startTime,e=this.currentTime,this._animation.cancel(),this._animation._wrapper=null,this._animation=null),(!this.effect||this.effect instanceof window.KeyframeEffect)&&(this._animation=b.newUnderlyingAnimationForKeyframeEffect(this.effect),b.bindAnimationForKeyframeEffect(this)),(this.effect instanceof window.SequenceEffect||this.effect instanceof window.GroupEffect)&&(this._animation=b.newUnderlyingAnimationForGroup(this.effect),b.bindAnimationForGroup(this)),this.effect&&this.effect._onsample&&b.bindAnimationForCustomEffect(this),f&&(1!=a&&(this.playbackRate=a),null!==d?this.startTime=d:null!==e?this.currentTime=e:null!==this._holdTime&&(this.currentTime=this._holdTime),c&&this.pause()),this._updatePromises()},_updateChildren:function(){if(this.effect&&"idle"!=this.playState){var a=this.effect._timing.delay;this._childAnimations.forEach(function(c){this._arrangeChildren(c,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c.effect))}.bind(this))}},_setExternalAnimation:function(a){if(this.effect&&this._isGroup)for(var b=0;b<this.effect.children.length;b++)this.effect.children[b]._animation=a,this._childAnimations[b]._setExternalAnimation(a)},_constructChildAnimations:function(){if(this.effect&&this._isGroup){var a=this.effect._timing.delay;this._removeChildAnimations(),this.effect.children.forEach(function(c){var d=b.timeline._play(c);this._childAnimations.push(d),d.playbackRate=this.playbackRate,this._paused&&d.pause(),c._animation=this.effect._animation,this._arrangeChildren(d,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c))}.bind(this))}},_arrangeChildren:function(a,b){null===this.startTime?a.currentTime=this.currentTime-b/this.playbackRate:a.startTime!==this.startTime+b/this.playbackRate&&(a.startTime=this.startTime+b/this.playbackRate)},get timeline(){return this._timeline},get playState(){return this._animation?this._animation.playState:"idle"},get finished(){return window.Promise?(this._finishedPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._finishedPromise=new Promise(function(a,b){this._resolveFinishedPromise=function(){a(this)},this._rejectFinishedPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"finished"==this.playState&&this._resolveFinishedPromise()),this._finishedPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get ready(){return window.Promise?(this._readyPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._readyPromise=new Promise(function(a,b){this._resolveReadyPromise=function(){a(this)},this._rejectReadyPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"pending"!==this.playState&&this._resolveReadyPromise()),this._readyPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get onfinish(){return this._animation.onfinish},set onfinish(a){this._animation.onfinish="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get oncancel(){return this._animation.oncancel},set oncancel(a){this._animation.oncancel="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get currentTime(){this._updatePromises();var a=this._animation.currentTime;return this._updatePromises(),a},set currentTime(a){this._updatePromises(),this._animation.currentTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.currentTime=a-c}),this._updatePromises()},get startTime(){return this._animation.startTime},set startTime(a){this._updatePromises(),this._animation.startTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.startTime=a+c}),this._updatePromises()},get playbackRate(){return this._animation.playbackRate},set playbackRate(a){this._updatePromises();var b=this.currentTime;this._animation.playbackRate=a,this._forEachChild(function(b){b.playbackRate=a}),null!==b&&(this.currentTime=b),this._updatePromises()},play:function(){this._updatePromises(),this._paused=!1,this._animation.play(),-1==this._timeline._animations.indexOf(this)&&this._timeline._animations.push(this),this._register(),b.awaitStartTime(this),this._forEachChild(function(a){var b=a.currentTime;a.play(),a.currentTime=b}),this._updatePromises()},pause:function(){this._updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),this._animation.pause(),this._register(),this._forEachChild(function(a){a.pause()}),this._paused=!0,this._updatePromises()},finish:function(){this._updatePromises(),this._animation.finish(),this._register(),this._updatePromises()},cancel:function(){this._updatePromises(),this._animation.cancel(),this._register(),this._removeChildAnimations(),this._updatePromises()},reverse:function(){this._updatePromises();var a=this.currentTime;this._animation.reverse(),this._forEachChild(function(a){a.reverse()}),null!==a&&(this.currentTime=a),this._updatePromises()},addEventListener:function(a,b){var c=b;"function"==typeof b&&(c=function(a){a.target=this,b.call(this,a)}.bind(this),b._wrapper=c),this._animation.addEventListener(a,c)},removeEventListener:function(a,b){this._animation.removeEventListener(a,b&&b._wrapper||b)},_removeChildAnimations:function(){for(;this._childAnimations.length;)this._childAnimations.pop().cancel()},_forEachChild:function(b){var c=0;if(this.effect.children&&this._childAnimations.length<this.effect.children.length&&this._constructChildAnimations(),this._childAnimations.forEach(function(a){b.call(this,a,c),this.effect instanceof window.SequenceEffect&&(c+=a.effect.activeDuration)}.bind(this)),"pending"!=this.playState){var d=this.effect._timing,e=this.currentTime;null!==e&&(e=a.calculateIterationProgress(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(a,c),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;)i.shift()._updateChildren(),a=!0;return a}var f=function(a){if(a._animation=void 0,a instanceof window.SequenceEffect||a instanceof window.GroupEffect)for(var b=0;b<a.children.length;b++)f(a.children[b])};b.removeMulti=function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c];d._parent?(-1==b.indexOf(d._parent)&&b.push(d._parent),d._parent.children.splice(d._parent.children.indexOf(d),1),d._parent=null,f(d)):d._animation&&d._animation.effect==d&&(d._animation.cancel(),d._animation.effect=new KeyframeEffect(null,[]),d._animation._callback&&(d._animation._callback._animation=null),d._animation._rebuildUnderlyingAnimation(),f(d))}for(c=0;c<b.length;c++)b[c]._rebuild()},b.KeyframeEffect=function(b,c,e,f){return this.target=b,this._parent=null,e=a.numericTimingToObject(e),this._timingInput=a.cloneTimingInput(e),this._timing=a.normalizeTimingInput(e),this.timing=a.makeTiming(e,!1,this),this.timing._effect=this,"function"==typeof c?(a.deprecated("Custom KeyframeEffect","2015-06-22","Use KeyframeEffect.onsample instead."),this._normalizedKeyframes=c):this._normalizedKeyframes=new d(c),this._keyframes=c,this.activeDuration=a.calculateActiveDuration(this._timing),this._id=f,this},b.KeyframeEffect.prototype={getFrames:function(){return"function"==typeof this._normalizedKeyframes?this._normalizedKeyframes:this._normalizedKeyframes._frames},set onsample(a){if("function"==typeof this.getFrames())throw new Error("Setting onsample on custom effect KeyframeEffect is not supported.");this._onsample=a,this._animation&&this._animation._rebuildUnderlyingAnimation()},get parent(){return this._parent},clone:function(){if("function"==typeof this.getFrames())throw new Error("Cloning custom effects is not supported.");var b=new KeyframeEffect(this.target,[],a.cloneTimingInput(this._timingInput),this._id);return b._normalizedKeyframes=this._normalizedKeyframes,b._keyframes=this._keyframes,b},remove:function(){b.removeMulti([this])}};var g=Element.prototype.animate;Element.prototype.animate=function(a,c){var d="";return c&&c.id&&(d=c.id),b.timeline._play(new b.KeyframeEffect(this,a,c,d))};var h=document.createElementNS("http://www.w3.org/1999/xhtml","div");b.newUnderlyingAnimationForKeyframeEffect=function(a){if(a){var b=a.target||h,c=a._keyframes;"function"==typeof c&&(c=[]);var d=a._timingInput;d.id=a._id}else var b=h,c=[],d=0;return g.apply(b,[c,d])},b.bindAnimationForKeyframeEffect=function(a){a.effect&&"function"==typeof a.effect._normalizedKeyframes&&b.bindAnimationForCustomEffect(a)};var i=[];b.awaitStartTime=function(a){null===a.startTime&&a._isGroup&&(0==i.length&&requestAnimationFrame(e),i.push(a))};var j=window.getComputedStyle;Object.defineProperty(window,"getComputedStyle",{configurable:!0,enumerable:!0,value:function(){b.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),b.timeline._updateAnimationsPromises(),a}}),window.KeyframeEffect=b.KeyframeEffect,window.Element.prototype.getAnimations=function(){return document.timeline.getAnimations().filter(function(a){return null!==a.effect&&a.effect.target==this}.bind(this))}}(a,c),function(a,b,c){function d(a){a._registered||(a._registered=!0,g.push(a),h||(h=!0,requestAnimationFrame(e)))}function e(a){var b=g;g=[],b.sort(function(a,b){return a._sequenceNumber-b._sequenceNumber}),b=b.filter(function(a){a();var b=a._animation?a._animation.playState:"idle";return"running"!=b&&"pending"!=b&&(a._registered=!1),a._registered}),g.push.apply(g,b),g.length?(h=!0,requestAnimationFrame(e)):h=!1}var f=(document.createElementNS("http://www.w3.org/1999/xhtml","div"),0);b.bindAnimationForCustomEffect=function(b){var c,e=b.effect.target,g="function"==typeof b.effect.getFrames();c=g?b.effect.getFrames():b.effect._onsample;var h=b.effect.timing,i=null;h=a.normalizeTimingInput(h);var j=function(){var d=j._animation?j._animation.currentTime:null;null!==d&&(d=a.calculateIterationProgress(a.calculateActiveDuration(h),d,h),isNaN(d)&&(d=null)),d!==i&&(g?c(d,e,b.effect):c(d,b.effect,b.effect._animation)),i=d};j._animation=b,j._registered=!1,j._sequenceNumber=f++,b._callback=j,d(j)};var g=[],h=!1;b.Animation.prototype._register=function(){this._callback&&d(this._callback)}}(a,c),function(a,b,c){function d(a){return a._timing.delay+a.activeDuration+a._timing.endDelay}function e(b,c,d){this._id=d,this._parent=null,this.children=b||[],this._reparent(this.children),c=a.numericTimingToObject(c),this._timingInput=a.cloneTimingInput(c),this._timing=a.normalizeTimingInput(c,!0),this.timing=a.makeTiming(c,!0,this),this.timing._effect=this,"auto"===this._timing.duration&&(this._timing.duration=this.activeDuration)}window.SequenceEffect=function(){e.apply(this,arguments)},window.GroupEffect=function(){e.apply(this,arguments)},e.prototype={_isAncestor:function(a){for(var b=this;null!==b;){if(b==a)return!0;b=b._parent}return!1},_rebuild:function(){for(var a=this;a;)"auto"===a.timing.duration&&(a._timing.duration=a.activeDuration),a=a._parent;this._animation&&this._animation._rebuildUnderlyingAnimation()},_reparent:function(a){b.removeMulti(a);for(var c=0;c<a.length;c++)a[c]._parent=this},_putChild:function(a,b){for(var c=b?"Cannot append an ancestor or self":"Cannot prepend an ancestor or self",d=0;d<a.length;d++)if(this._isAncestor(a[d]))throw{type:DOMException.HIERARCHY_REQUEST_ERR,name:"HierarchyRequestError",message:c};for(var d=0;d<a.length;d++)b?this.children.push(a[d]):this.children.unshift(a[d]);this._reparent(a),this._rebuild()},append:function(){this._putChild(arguments,!0)},prepend:function(){this._putChild(arguments,!1)},get parent(){return this._parent},get firstChild(){return this.children.length?this.children[0]:null},get lastChild(){return this.children.length?this.children[this.children.length-1]:null},clone:function(){for(var b=a.cloneTimingInput(this._timingInput),c=[],d=0;d<this.children.length;d++)c.push(this.children[d].clone());return this instanceof GroupEffect?new GroupEffect(c,b):new SequenceEffect(c,b)},remove:function(){b.removeMulti([this])}},window.SequenceEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.SequenceEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a+=d(b)}),Math.max(a,0)}}),window.GroupEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.GroupEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a=Math.max(a,d(b))}),a}}),b.newUnderlyingAnimationForGroup=function(c){var d,e=null,f=function(b){var c=d._wrapper;if(c&&"pending"!=c.playState&&c.effect)return null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateIterationProgress(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0},g=new KeyframeEffect(null,[],c._timing,c._id);return g.onsample=f,d=b.timeline._play(g)},b.bindAnimationForGroup=function(a){a._animation._wrapper=a,a._isGroup=!0,b.awaitStartTime(a),a._constructChildAnimations(),a._setExternalAnimation(a)},b.groupChildDuration=d}(a,c)}();(()=>{var vve=Object.create;var BM=Object.defineProperty,xve=Object.defineProperties,bve=Object.getOwnPropertyDescriptor,wve=Object.getOwnPropertyDescriptors,Sve=Object.getOwnPropertyNames,hdt=Object.getOwnPropertySymbols,Mve=Object.getPrototypeOf,pdt=Object.prototype.hasOwnProperty,Eve=Object.prototype.propertyIsEnumerable;var TI=Math.pow,fdt=(e,t,r)=>t in e?BM(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,ia=(e,t)=>{for(var r in t||(t={}))pdt.call(t,r)&&fdt(e,r,t[r]);if(hdt)for(var r of hdt(t))Eve.call(t,r)&&fdt(e,r,t[r]);return e},yh=(e,t)=>xve(e,wve(t));var Ex=(e=>typeof require!="undefined"?require:typeof Proxy!="undefined"?new Proxy(e,{get:(t,r)=>(typeof require!="undefined"?require:t)[r]}):e)(function(e){if(typeof require!="undefined")return require.apply(this,arguments);throw new Error('Dynamic require of "'+e+'" is not supported')});var M=(e,t)=>()=>(e&&(t=e(e=0)),t);var H=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Zs=(e,t)=>{for(var r in t)BM(e,r,{get:t[r],enumerable:!0})},ddt=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Sve(t))!pdt.call(e,i)&&i!==r&&BM(e,i,{get:()=>t[i],enumerable:!(n=bve(t,i))||n.enumerable});return e};var Ee=(e,t,r)=>(r=e!=null?vve(Mve(e)):{},ddt(t||!e||!e.__esModule?BM(r,"default",{value:e,enumerable:!0}):r,e)),Ut=e=>ddt(BM({},"__esModule",{value:!0}),e);var Ri=(e,t,r)=>new Promise((n,i)=>{var o=l=>{try{s(r.next(l))}catch(c){i(c)}},a=l=>{try{s(r.throw(l))}catch(c){i(c)}},s=l=>l.done?n(l.value):Promise.resolve(l.value).then(o,a);s((r=r.apply(e,t)).next())});var Hdt=H((p_r,PI)=>{var mdt,gdt,_dt,ydt,vdt,xdt,bdt,wdt,Sdt,Mdt,Edt,Tdt,Cdt,CI,hG,Adt,Pdt,Idt,Tx,Ldt,kdt,Rdt,Ndt,Ddt,Odt,zdt,Fdt,Bdt,AI;(function(e){var t=typeof global=="object"?global:typeof self=="object"?self:typeof this=="object"?this:{};typeof define=="function"&&define.amd?define("tslib",["exports"],function(n){e(r(t,r(n)))}):typeof PI=="object"&&typeof PI.exports=="object"?e(r(t,r(PI.exports))):e(r(t));function r(n,i){return n!==t&&(typeof Object.create=="function"?Object.defineProperty(n,"__esModule",{value:!0}):n.__esModule=!0),function(o,a){return n[o]=i?i(o,a):a}}})(function(e){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,i){n.__proto__=i}||function(n,i){for(var o in i)Object.prototype.hasOwnProperty.call(i,o)&&(n[o]=i[o])};mdt=function(n,i){if(typeof i!="function"&&i!==null)throw new TypeError("Class extends value "+String(i)+" is not a constructor or null");t(n,i);function o(){this.constructor=n}n.prototype=i===null?Object.create(i):(o.prototype=i.prototype,new o)},gdt=Object.assign||function(n){for(var i,o=1,a=arguments.length;o<a;o++){i=arguments[o];for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&(n[s]=i[s])}return n},_dt=function(n,i){var o={};for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&i.indexOf(a)<0&&(o[a]=n[a]);if(n!=null&&typeof Object.getOwnPropertySymbols=="function")for(var s=0,a=Object.getOwnPropertySymbols(n);s<a.length;s++)i.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(n,a[s])&&(o[a[s]]=n[a[s]]);return o},ydt=function(n,i,o,a){var s=arguments.length,l=s<3?i:a===null?a=Object.getOwnPropertyDescriptor(i,o):a,c;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")l=Reflect.decorate(n,i,o,a);else for(var u=n.length-1;u>=0;u--)(c=n[u])&&(l=(s<3?c(l):s>3?c(i,o,l):c(i,o))||l);return s>3&&l&&Object.defineProperty(i,o,l),l},vdt=function(n,i){return function(o,a){i(o,a,n)}},xdt=function(n,i,o,a,s,l){function c(S){if(S!==void 0&&typeof S!="function")throw new TypeError("Function expected");return S}for(var u=a.kind,h=u==="getter"?"get":u==="setter"?"set":"value",f=!i&&n?a.static?n:n.prototype:null,p=i||(f?Object.getOwnPropertyDescriptor(f,a.name):{}),d,g=!1,_=o.length-1;_>=0;_--){var y={};for(var x in a)y[x]=x==="access"?{}:a[x];for(var x in a.access)y.access[x]=a.access[x];y.addInitializer=function(S){if(g)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(S||null))};var b=(0,o[_])(u==="accessor"?{get:p.get,set:p.set}:p[h],y);if(u==="accessor"){if(b===void 0)continue;if(b===null||typeof b!="object")throw new TypeError("Object expected");(d=c(b.get))&&(p.get=d),(d=c(b.set))&&(p.set=d),(d=c(b.init))&&s.push(d)}else(d=c(b))&&(u==="field"?s.push(d):p[h]=d)}f&&Object.defineProperty(f,a.name,p),g=!0},bdt=function(n,i,o){for(var a=arguments.length>2,s=0;s<i.length;s++)o=a?i[s].call(n,o):i[s].call(n);return a?o:void 0},wdt=function(n){return typeof n=="symbol"?n:"".concat(n)},Sdt=function(n,i,o){return typeof i=="symbol"&&(i=i.description?"[".concat(i.description,"]"):""),Object.defineProperty(n,"name",{configurable:!0,value:o?"".concat(o," ",i):i})},Mdt=function(n,i){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(n,i)},Edt=function(n,i,o,a){function s(l){return l instanceof o?l:new o(function(c){c(l)})}return new(o||(o=Promise))(function(l,c){function u(p){try{f(a.next(p))}catch(d){c(d)}}function h(p){try{f(a.throw(p))}catch(d){c(d)}}function f(p){p.done?l(p.value):s(p.value).then(u,h)}f((a=a.apply(n,i||[])).next())})},Tdt=function(n,i){var o={label:0,sent:function(){if(l[0]&1)throw l[1];return l[1]},trys:[],ops:[]},a,s,l,c;return c={next:u(0),throw:u(1),return:u(2)},typeof Symbol=="function"&&(c[Symbol.iterator]=function(){return this}),c;function u(f){return function(p){return h([f,p])}}function h(f){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,f[0]&&(o=0)),o;)try{if(a=1,s&&(l=f[0]&2?s.return:f[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,f[1])).done)return l;switch(s=0,l&&(f=[f[0]&2,l.value]),f[0]){case 0:case 1:l=f;break;case 4:return o.label++,{value:f[1],done:!1};case 5:o.label++,s=f[1],f=[0];continue;case 7:f=o.ops.pop(),o.trys.pop();continue;default:if(l=o.trys,!(l=l.length>0&&l[l.length-1])&&(f[0]===6||f[0]===2)){o=0;continue}if(f[0]===3&&(!l||f[1]>l[0]&&f[1]<l[3])){o.label=f[1];break}if(f[0]===6&&o.label<l[1]){o.label=l[1],l=f;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(f);break}l[2]&&o.ops.pop(),o.trys.pop();continue}f=i.call(n,o)}catch(p){f=[6,p],s=0}finally{a=l=0}if(f[0]&5)throw f[1];return{value:f[0]?f[1]:void 0,done:!0}}},Cdt=function(n,i){for(var o in n)o!=="default"&&!Object.prototype.hasOwnProperty.call(i,o)&&AI(i,n,o)},AI=Object.create?function(n,i,o,a){a===void 0&&(a=o);var s=Object.getOwnPropertyDescriptor(i,o);(!s||("get"in s?!i.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return i[o]}}),Object.defineProperty(n,a,s)}:function(n,i,o,a){a===void 0&&(a=o),n[a]=i[o]},CI=function(n){var i=typeof Symbol=="function"&&Symbol.iterator,o=i&&n[i],a=0;if(o)return o.call(n);if(n&&typeof n.length=="number")return{next:function(){return n&&a>=n.length&&(n=void 0),{value:n&&n[a++],done:!n}}};throw new TypeError(i?"Object is not iterable.":"Symbol.iterator is not defined.")},hG=function(n,i){var o=typeof Symbol=="function"&&n[Symbol.iterator];if(!o)return n;var a=o.call(n),s,l=[],c;try{for(;(i===void 0||i-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(u){c={error:u}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},Adt=function(){for(var n=[],i=0;i<arguments.length;i++)n=n.concat(hG(arguments[i]));return n},Pdt=function(){for(var n=0,i=0,o=arguments.length;i<o;i++)n+=arguments[i].length;for(var a=Array(n),s=0,i=0;i<o;i++)for(var l=arguments[i],c=0,u=l.length;c<u;c++,s++)a[s]=l[c];return a},Idt=function(n,i,o){if(o||arguments.length===2)for(var a=0,s=i.length,l;a<s;a++)(l||!(a in i))&&(l||(l=Array.prototype.slice.call(i,0,a)),l[a]=i[a]);return n.concat(l||Array.prototype.slice.call(i))},Tx=function(n){return this instanceof Tx?(this.v=n,this):new Tx(n)},Ldt=function(n,i,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a=o.apply(n,i||[]),s,l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(g){a[g]&&(s[g]=function(_){return new Promise(function(y,x){l.push([g,_,y,x])>1||u(g,_)})})}function u(g,_){try{h(a[g](_))}catch(y){d(l[0][3],y)}}function h(g){g.value instanceof Tx?Promise.resolve(g.value.v).then(f,p):d(l[0][2],g)}function f(g){u("next",g)}function p(g){u("throw",g)}function d(g,_){g(_),l.shift(),l.length&&u(l[0][0],l[0][1])}},kdt=function(n){var i,o;return i={},a("next"),a("throw",function(s){throw s}),a("return"),i[Symbol.iterator]=function(){return this},i;function a(s,l){i[s]=n[s]?function(c){return(o=!o)?{value:Tx(n[s](c)),done:!1}:l?l(c):c}:l}},Rdt=function(n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var i=n[Symbol.asyncIterator],o;return i?i.call(n):(n=typeof CI=="function"?CI(n):n[Symbol.iterator](),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=n[l]&&function(c){return new Promise(function(u,h){c=n[l](c),s(u,h,c.done,c.value)})}}function s(l,c,u,h){Promise.resolve(h).then(function(f){l({value:f,done:u})},c)}},Ndt=function(n,i){return Object.defineProperty?Object.defineProperty(n,"raw",{value:i}):n.raw=i,n};var r=Object.create?function(n,i){Object.defineProperty(n,"default",{enumerable:!0,value:i})}:function(n,i){n.default=i};Ddt=function(n){if(n&&n.__esModule)return n;var i={};if(n!=null)for(var o in n)o!=="default"&&Object.prototype.hasOwnProperty.call(n,o)&&AI(i,n,o);return r(i,n),i},Odt=function(n){return n&&n.__esModule?n:{default:n}},zdt=function(n,i,o,a){if(o==="a"&&!a)throw new TypeError("Private accessor was defined without a getter");if(typeof i=="function"?n!==i||!a:!i.has(n))throw new TypeError("Cannot read private member from an object whose class did not declare it");return o==="m"?a:o==="a"?a.call(n):a?a.value:i.get(n)},Fdt=function(n,i,o,a,s){if(a==="m")throw new TypeError("Private method is not writable");if(a==="a"&&!s)throw new TypeError("Private accessor was defined without a setter");if(typeof i=="function"?n!==i||!s:!i.has(n))throw new TypeError("Cannot write private member to an object whose class did not declare it");return a==="a"?s.call(n,o):s?s.value=o:i.set(n,o),o},Bdt=function(n,i){if(i===null||typeof i!="object"&&typeof i!="function")throw new TypeError("Cannot use 'in' operator on non-object");return typeof n=="function"?i===n:n.has(i)},e("__extends",mdt),e("__assign",gdt),e("__rest",_dt),e("__decorate",ydt),e("__param",vdt),e("__esDecorate",xdt),e("__runInitializers",bdt),e("__propKey",wdt),e("__setFunctionName",Sdt),e("__metadata",Mdt),e("__awaiter",Edt),e("__generator",Tdt),e("__exportStar",Cdt),e("__createBinding",AI),e("__values",CI),e("__read",hG),e("__spread",Adt),e("__spreadArrays",Pdt),e("__spreadArray",Idt),e("__await",Tx),e("__asyncGenerator",Ldt),e("__asyncDelegator",kdt),e("__asyncValues",Rdt),e("__makeTemplateObject",Ndt),e("__importStar",Ddt),e("__importDefault",Odt),e("__classPrivateFieldGet",zdt),e("__classPrivateFieldSet",Fdt),e("__classPrivateFieldIn",Bdt)})});var Oe=H((Rx,$M)=>{(function(){var e,t="4.17.21",r=200,n="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",i="Expected a function",o="Invalid `variable` option passed into `_.template`",a="__lodash_hash_undefined__",s=500,l="__lodash_placeholder__",c=1,u=2,h=4,f=1,p=2,d=1,g=2,_=4,y=8,x=16,b=32,S=64,C=128,P=256,k=512,O=30,D="...",B=800,I=16,L=1,R=2,F=3,z=1/0,U=9007199254740991,W=17976931348623157e292,Z=0/0,rt=4294967295,ot=rt-1,st=rt>>>1,St=[["ary",C],["bind",d],["bindKey",g],["curry",y],["curryRight",x],["flip",k],["partial",b],["partialRight",S],["rearg",P]],bt="[object Arguments]",Mt="[object Array]",lt="[object AsyncFunction]",Kt="[object Boolean]",_t="[object Date]",ct="[object DOMException]",X="[object Error]",et="[object Function]",dt="[object GeneratorFunction]",q="[object Map]",pt="[object Number]",ht="[object Null]",wt="[object Object]",kt="[object Promise]",ie="[object Proxy]",ee="[object RegExp]",Le="[object Set]",ar="[object String]",fr="[object Symbol]",tt="[object Undefined]",$="[object WeakMap]",It="[object WeakSet]",$t="[object ArrayBuffer]",he="[object DataView]",Tt="[object Float32Array]",be="[object Float64Array]",nt="[object Int8Array]",Ct="[object Int16Array]",Wt="[object Int32Array]",fe="[object Uint8Array]",at="[object Uint8ClampedArray]",se="[object Uint16Array]",Qt="[object Uint32Array]",Ce=/\b__p \+= '';/g,Pt=/\b(__p \+=) '' \+/g,Nt=/(__e\(.*?\)|\b__t\)) \+\n'';/g,ze=/&(?:amp|lt|gt|quot|#39);/g,yn=/[&<>"']/g,Wi=RegExp(ze.source),Ar=RegExp(yn.source),Ia=/<%-([\s\S]+?)%>/g,ho=/<%([\s\S]+?)%>/g,La=/<%=([\s\S]+?)%>/g,cx=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,um=/^\w*$/,Q0=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,cn=/[\\^$.*+?()[\]{}|]/g,ux=RegExp(cn.source),np=/^\s+/,K=/\s/,gt=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Et=/\{\n\/\* \[wrapped with (.+)\] \*/,xt=/,? & /,Ft=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Ve=/[()=,{}\[\]\/\s]/,Ue=/\\(\\)?/g,tr=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,Ke=/\w*$/,Xr=/^[-+]0x[0-9a-f]+$/i,_r=/^0b[01]+$/i,Pr=/^\[object .+?Constructor\]$/,Xn=/^0o[0-7]+$/i,ip=/^(?:0|[1-9]\d*)$/,hm=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,mr=/($^)/,Bl=/['\n\r\u2028\u2029\\]/g,$n="\\ud800-\\udfff",Hl="\\u0300-\\u036f",hx="\\ufe20-\\ufe2f",Vl="\\u20d0-\\u20ff",Ul=Hl+hx+Vl,Yi="\\u2700-\\u27bf",fm="a-z\\xdf-\\xf6\\xf8-\\xff",Gs="\\xac\\xb1\\xd7\\xf7",gpe="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",_pe="\\u2000-\\u206f",ype=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",qht="A-Z\\xc0-\\xd6\\xd8-\\xde",Ght="\\ufe0e\\ufe0f",Wht=Gs+gpe+_pe+ype,eq="['\u2019]",vpe="["+$n+"]",Yht="["+Wht+"]",H6="["+Ul+"]",jht="\\d+",xpe="["+Yi+"]",Xht="["+fm+"]",$ht="[^"+$n+Wht+jht+Yi+fm+qht+"]",rq="\\ud83c[\\udffb-\\udfff]",bpe="(?:"+H6+"|"+rq+")",Kht="[^"+$n+"]",nq="(?:\\ud83c[\\udde6-\\uddff]){2}",iq="[\\ud800-\\udbff][\\udc00-\\udfff]",fx="["+qht+"]",Zht="\\u200d",Jht="(?:"+Xht+"|"+$ht+")",wpe="(?:"+fx+"|"+$ht+")",Qht="(?:"+eq+"(?:d|ll|m|re|s|t|ve))?",tft="(?:"+eq+"(?:D|LL|M|RE|S|T|VE))?",eft=bpe+"?",rft="["+Ght+"]?",Spe="(?:"+Zht+"(?:"+[Kht,nq,iq].join("|")+")"+rft+eft+")*",Mpe="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Epe="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",nft=rft+eft+Spe,Tpe="(?:"+[xpe,nq,iq].join("|")+")"+nft,Cpe="(?:"+[Kht+H6+"?",H6,nq,iq,vpe].join("|")+")",Ape=RegExp(eq,"g"),Ppe=RegExp(H6,"g"),oq=RegExp(rq+"(?="+rq+")|"+Cpe+nft,"g"),Ipe=RegExp([fx+"?"+Xht+"+"+Qht+"(?="+[Yht,fx,"$"].join("|")+")",wpe+"+"+tft+"(?="+[Yht,fx+Jht,"$"].join("|")+")",fx+"?"+Jht+"+"+Qht,fx+"+"+tft,Epe,Mpe,jht,Tpe].join("|"),"g"),Lpe=RegExp("["+Zht+$n+Ul+Ght+"]"),kpe=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Rpe=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],Npe=-1,Rn={};Rn[Tt]=Rn[be]=Rn[nt]=Rn[Ct]=Rn[Wt]=Rn[fe]=Rn[at]=Rn[se]=Rn[Qt]=!0,Rn[bt]=Rn[Mt]=Rn[$t]=Rn[Kt]=Rn[he]=Rn[_t]=Rn[X]=Rn[et]=Rn[q]=Rn[pt]=Rn[wt]=Rn[ee]=Rn[Le]=Rn[ar]=Rn[$]=!1;var Tn={};Tn[bt]=Tn[Mt]=Tn[$t]=Tn[he]=Tn[Kt]=Tn[_t]=Tn[Tt]=Tn[be]=Tn[nt]=Tn[Ct]=Tn[Wt]=Tn[q]=Tn[pt]=Tn[wt]=Tn[ee]=Tn[Le]=Tn[ar]=Tn[fr]=Tn[fe]=Tn[at]=Tn[se]=Tn[Qt]=!0,Tn[X]=Tn[et]=Tn[$]=!1;var Dpe={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},Ope={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},zpe={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},Fpe={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Bpe=parseFloat,Hpe=parseInt,ift=typeof global=="object"&&global&&global.Object===Object&&global,Vpe=typeof self=="object"&&self&&self.Object===Object&&self,fo=ift||Vpe||Function("return this")(),aq=typeof Rx=="object"&&Rx&&!Rx.nodeType&&Rx,t_=aq&&typeof $M=="object"&&$M&&!$M.nodeType&&$M,oft=t_&&t_.exports===aq,sq=oft&&ift.process,ql=function(){try{var ut=t_&&t_.require&&t_.require("util").types;return ut||sq&&sq.binding&&sq.binding("util")}catch(At){}}(),aft=ql&&ql.isArrayBuffer,sft=ql&&ql.isDate,lft=ql&&ql.isMap,cft=ql&&ql.isRegExp,uft=ql&&ql.isSet,hft=ql&&ql.isTypedArray;function Ws(ut,At,vt){switch(vt.length){case 0:return ut.call(At);case 1:return ut.call(At,vt[0]);case 2:return ut.call(At,vt[0],vt[1]);case 3:return ut.call(At,vt[0],vt[1],vt[2])}return ut.apply(At,vt)}function Upe(ut,At,vt,ge){for(var We=-1,$r=ut==null?0:ut.length;++We<$r;){var ji=ut[We];At(ge,ji,vt(ji),ut)}return ge}function Gl(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge&&At(ut[vt],vt,ut)!==!1;);return ut}function qpe(ut,At){for(var vt=ut==null?0:ut.length;vt--&&At(ut[vt],vt,ut)!==!1;);return ut}function fft(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(!At(ut[vt],vt,ut))return!1;return!0}function pm(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];At(ji,vt,ut)&&($r[We++]=ji)}return $r}function V6(ut,At){var vt=ut==null?0:ut.length;return!!vt&&px(ut,At,0)>-1}function lq(ut,At,vt){for(var ge=-1,We=ut==null?0:ut.length;++ge<We;)if(vt(At,ut[ge]))return!0;return!1}function Kn(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=Array(ge);++vt<ge;)We[vt]=At(ut[vt],vt,ut);return We}function dm(ut,At){for(var vt=-1,ge=At.length,We=ut.length;++vt<ge;)ut[We+vt]=At[vt];return ut}function cq(ut,At,vt,ge){var We=-1,$r=ut==null?0:ut.length;for(ge&&$r&&(vt=ut[++We]);++We<$r;)vt=At(vt,ut[We],We,ut);return vt}function Gpe(ut,At,vt,ge){var We=ut==null?0:ut.length;for(ge&&We&&(vt=ut[--We]);We--;)vt=At(vt,ut[We],We,ut);return vt}function uq(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(At(ut[vt],vt,ut))return!0;return!1}var Wpe=hq("length");function Ype(ut){return ut.split("")}function jpe(ut){return ut.match(Ft)||[]}function pft(ut,At,vt){var ge;return vt(ut,function(We,$r,ji){if(At(We,$r,ji))return ge=$r,!1}),ge}function U6(ut,At,vt,ge){for(var We=ut.length,$r=vt+(ge?1:-1);ge?$r--:++$r<We;)if(At(ut[$r],$r,ut))return $r;return-1}function px(ut,At,vt){return At===At?ode(ut,At,vt):U6(ut,dft,vt)}function Xpe(ut,At,vt,ge){for(var We=vt-1,$r=ut.length;++We<$r;)if(ge(ut[We],At))return We;return-1}function dft(ut){return ut!==ut}function mft(ut,At){var vt=ut==null?0:ut.length;return vt?pq(ut,At)/vt:Z}function hq(ut){return function(At){return At==null?e:At[ut]}}function fq(ut){return function(At){return ut==null?e:ut[At]}}function gft(ut,At,vt,ge,We){return We(ut,function($r,ji,vn){vt=ge?(ge=!1,$r):At(vt,$r,ji,vn)}),vt}function $pe(ut,At){var vt=ut.length;for(ut.sort(At);vt--;)ut[vt]=ut[vt].value;return ut}function pq(ut,At){for(var vt,ge=-1,We=ut.length;++ge<We;){var $r=At(ut[ge]);$r!==e&&(vt=vt===e?$r:vt+$r)}return vt}function dq(ut,At){for(var vt=-1,ge=Array(ut);++vt<ut;)ge[vt]=At(vt);return ge}function Kpe(ut,At){return Kn(At,function(vt){return[vt,ut[vt]]})}function _ft(ut){return ut&&ut.slice(0,bft(ut)+1).replace(np,"")}function Ys(ut){return function(At){return ut(At)}}function mq(ut,At){return Kn(At,function(vt){return ut[vt]})}function MM(ut,At){return ut.has(At)}function yft(ut,At){for(var vt=-1,ge=ut.length;++vt<ge&&px(At,ut[vt],0)>-1;);return vt}function vft(ut,At){for(var vt=ut.length;vt--&&px(At,ut[vt],0)>-1;);return vt}function Zpe(ut,At){for(var vt=ut.length,ge=0;vt--;)ut[vt]===At&&++ge;return ge}var Jpe=fq(Dpe),Qpe=fq(Ope);function tde(ut){return"\\"+Fpe[ut]}function ede(ut,At){return ut==null?e:ut[At]}function dx(ut){return Lpe.test(ut)}function rde(ut){return kpe.test(ut)}function nde(ut){for(var At,vt=[];!(At=ut.next()).done;)vt.push(At.value);return vt}function gq(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge,We){vt[++At]=[We,ge]}),vt}function xft(ut,At){return function(vt){return ut(At(vt))}}function mm(ut,At){for(var vt=-1,ge=ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];(ji===At||ji===l)&&(ut[vt]=l,$r[We++]=vt)}return $r}function q6(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=ge}),vt}function ide(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=[ge,ge]}),vt}function ode(ut,At,vt){for(var ge=vt-1,We=ut.length;++ge<We;)if(ut[ge]===At)return ge;return-1}function ade(ut,At,vt){for(var ge=vt+1;ge--;)if(ut[ge]===At)return ge;return ge}function mx(ut){return dx(ut)?lde(ut):Wpe(ut)}function tu(ut){return dx(ut)?cde(ut):Ype(ut)}function bft(ut){for(var At=ut.length;At--&&K.test(ut.charAt(At)););return At}var sde=fq(zpe);function lde(ut){for(var At=oq.lastIndex=0;oq.test(ut);)++At;return At}function cde(ut){return ut.match(oq)||[]}function ude(ut){return ut.match(Ipe)||[]}var hde=function ut(At){At=At==null?fo:gm.defaults(fo.Object(),At,gm.pick(fo,Rpe));var vt=At.Array,ge=At.Date,We=At.Error,$r=At.Function,ji=At.Math,vn=At.Object,_q=At.RegExp,fde=At.String,Wl=At.TypeError,G6=vt.prototype,pde=$r.prototype,gx=vn.prototype,W6=At["__core-js_shared__"],Y6=pde.toString,un=gx.hasOwnProperty,dde=0,wft=function(){var m=/[^.]+$/.exec(W6&&W6.keys&&W6.keys.IE_PROTO||"");return m?"Symbol(src)_1."+m:""}(),j6=gx.toString,mde=Y6.call(vn),gde=fo._,_de=_q("^"+Y6.call(un).replace(cn,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),X6=oft?At.Buffer:e,_m=At.Symbol,$6=At.Uint8Array,Sft=X6?X6.allocUnsafe:e,K6=xft(vn.getPrototypeOf,vn),Mft=vn.create,Eft=gx.propertyIsEnumerable,Z6=G6.splice,Tft=_m?_m.isConcatSpreadable:e,EM=_m?_m.iterator:e,e_=_m?_m.toStringTag:e,J6=function(){try{var m=a_(vn,"defineProperty");return m({},"",{}),m}catch(v){}}(),yde=At.clearTimeout!==fo.clearTimeout&&At.clearTimeout,vde=ge&&ge.now!==fo.Date.now&&ge.now,xde=At.setTimeout!==fo.setTimeout&&At.setTimeout,Q6=ji.ceil,tI=ji.floor,yq=vn.getOwnPropertySymbols,bde=X6?X6.isBuffer:e,Cft=At.isFinite,wde=G6.join,Sde=xft(vn.keys,vn),Xi=ji.max,ra=ji.min,Mde=ge.now,Ede=At.parseInt,Aft=ji.random,Tde=G6.reverse,vq=a_(At,"DataView"),TM=a_(At,"Map"),xq=a_(At,"Promise"),_x=a_(At,"Set"),CM=a_(At,"WeakMap"),AM=a_(vn,"create"),eI=CM&&new CM,yx={},Cde=s_(vq),Ade=s_(TM),Pde=s_(xq),Ide=s_(_x),Lde=s_(CM),rI=_m?_m.prototype:e,PM=rI?rI.valueOf:e,Pft=rI?rI.toString:e;function G(m){if(si(m)&&!$e(m)&&!(m instanceof gr)){if(m instanceof Yl)return m;if(un.call(m,"__wrapped__"))return Ipt(m)}return new Yl(m)}var vx=function(){function m(){}return function(v){if(!ei(v))return{};if(Mft)return Mft(v);m.prototype=v;var T=new m;return m.prototype=e,T}}();function nI(){}function Yl(m,v){this.__wrapped__=m,this.__actions__=[],this.__chain__=!!v,this.__index__=0,this.__values__=e}G.templateSettings={escape:Ia,evaluate:ho,interpolate:La,variable:"",imports:{_:G}},G.prototype=nI.prototype,G.prototype.constructor=G,Yl.prototype=vx(nI.prototype),Yl.prototype.constructor=Yl;function gr(m){this.__wrapped__=m,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=rt,this.__views__=[]}function kde(){var m=new gr(this.__wrapped__);return m.__actions__=ds(this.__actions__),m.__dir__=this.__dir__,m.__filtered__=this.__filtered__,m.__iteratees__=ds(this.__iteratees__),m.__takeCount__=this.__takeCount__,m.__views__=ds(this.__views__),m}function Rde(){if(this.__filtered__){var m=new gr(this);m.__dir__=-1,m.__filtered__=!0}else m=this.clone(),m.__dir__*=-1;return m}function Nde(){var m=this.__wrapped__.value(),v=this.__dir__,T=$e(m),N=v<0,V=T?m.length:0,Y=Yme(0,V,this.__views__),J=Y.start,it=Y.end,ft=it-J,Dt=N?it:J-1,Ot=this.__iteratees__,Vt=Ot.length,oe=0,Te=ra(ft,this.__takeCount__);if(!T||!N&&V==ft&&Te==ft)return Qft(m,this.__actions__);var Ne=[];t:for(;ft--&&oe<Te;){Dt+=v;for(var er=-1,De=m[Dt];++er<Vt;){var pr=Ot[er],yr=pr.iteratee,$s=pr.type,Na=yr(De);if($s==R)De=Na;else if(!Na){if($s==L)continue t;break t}}Ne[oe++]=De}return Ne}gr.prototype=vx(nI.prototype),gr.prototype.constructor=gr;function r_(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Dde(){this.__data__=AM?AM(null):{},this.size=0}function Ode(m){var v=this.has(m)&&delete this.__data__[m];return this.size-=v?1:0,v}function zde(m){var v=this.__data__;if(AM){var T=v[m];return T===a?e:T}return un.call(v,m)?v[m]:e}function Fde(m){var v=this.__data__;return AM?v[m]!==e:un.call(v,m)}function Bde(m,v){var T=this.__data__;return this.size+=this.has(m)?0:1,T[m]=AM&&v===e?a:v,this}r_.prototype.clear=Dde,r_.prototype.delete=Ode,r_.prototype.get=zde,r_.prototype.has=Fde,r_.prototype.set=Bde;function op(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Hde(){this.__data__=[],this.size=0}function Vde(m){var v=this.__data__,T=iI(v,m);if(T<0)return!1;var N=v.length-1;return T==N?v.pop():Z6.call(v,T,1),--this.size,!0}function Ude(m){var v=this.__data__,T=iI(v,m);return T<0?e:v[T][1]}function qde(m){return iI(this.__data__,m)>-1}function Gde(m,v){var T=this.__data__,N=iI(T,m);return N<0?(++this.size,T.push([m,v])):T[N][1]=v,this}op.prototype.clear=Hde,op.prototype.delete=Vde,op.prototype.get=Ude,op.prototype.has=qde,op.prototype.set=Gde;function ap(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Wde(){this.size=0,this.__data__={hash:new r_,map:new(TM||op),string:new r_}}function Yde(m){var v=gI(this,m).delete(m);return this.size-=v?1:0,v}function jde(m){return gI(this,m).get(m)}function Xde(m){return gI(this,m).has(m)}function $de(m,v){var T=gI(this,m),N=T.size;return T.set(m,v),this.size+=T.size==N?0:1,this}ap.prototype.clear=Wde,ap.prototype.delete=Yde,ap.prototype.get=jde,ap.prototype.has=Xde,ap.prototype.set=$de;function n_(m){var v=-1,T=m==null?0:m.length;for(this.__data__=new ap;++v<T;)this.add(m[v])}function Kde(m){return this.__data__.set(m,a),this}function Zde(m){return this.__data__.has(m)}n_.prototype.add=n_.prototype.push=Kde,n_.prototype.has=Zde;function eu(m){var v=this.__data__=new op(m);this.size=v.size}function Jde(){this.__data__=new op,this.size=0}function Qde(m){var v=this.__data__,T=v.delete(m);return this.size=v.size,T}function tme(m){return this.__data__.get(m)}function eme(m){return this.__data__.has(m)}function rme(m,v){var T=this.__data__;if(T instanceof op){var N=T.__data__;if(!TM||N.length<r-1)return N.push([m,v]),this.size=++T.size,this;T=this.__data__=new ap(N)}return T.set(m,v),this.size=T.size,this}eu.prototype.clear=Jde,eu.prototype.delete=Qde,eu.prototype.get=tme,eu.prototype.has=eme,eu.prototype.set=rme;function Ift(m,v){var T=$e(m),N=!T&&l_(m),V=!T&&!N&&wm(m),Y=!T&&!N&&!V&&Sx(m),J=T||N||V||Y,it=J?dq(m.length,fde):[],ft=it.length;for(var Dt in m)(v||un.call(m,Dt))&&!(J&&(Dt=="length"||V&&(Dt=="offset"||Dt=="parent")||Y&&(Dt=="buffer"||Dt=="byteLength"||Dt=="byteOffset")||up(Dt,ft)))&&it.push(Dt);return it}function Lft(m){var v=m.length;return v?m[Lq(0,v-1)]:e}function nme(m,v){return _I(ds(m),i_(v,0,m.length))}function ime(m){return _I(ds(m))}function bq(m,v,T){(T!==e&&!ru(m[v],T)||T===e&&!(v in m))&&sp(m,v,T)}function IM(m,v,T){var N=m[v];(!(un.call(m,v)&&ru(N,T))||T===e&&!(v in m))&&sp(m,v,T)}function iI(m,v){for(var T=m.length;T--;)if(ru(m[T][0],v))return T;return-1}function ome(m,v,T,N){return ym(m,function(V,Y,J){v(N,V,T(V),J)}),N}function kft(m,v){return m&&gh(v,po(v),m)}function ame(m,v){return m&&gh(v,gs(v),m)}function sp(m,v,T){v=="__proto__"&&J6?J6(m,v,{configurable:!0,enumerable:!0,value:T,writable:!0}):m[v]=T}function wq(m,v){for(var T=-1,N=v.length,V=vt(N),Y=m==null;++T<N;)V[T]=Y?e:rG(m,v[T]);return V}function i_(m,v,T){return m===m&&(T!==e&&(m=m<=T?m:T),v!==e&&(m=m>=v?m:v)),m}function jl(m,v,T,N,V,Y){var J,it=v&c,ft=v&u,Dt=v&h;if(T&&(J=V?T(m,N,V,Y):T(m)),J!==e)return J;if(!ei(m))return m;var Ot=$e(m);if(Ot){if(J=Xme(m),!it)return ds(m,J)}else{var Vt=na(m),oe=Vt==et||Vt==dt;if(wm(m))return rpt(m,it);if(Vt==wt||Vt==bt||oe&&!V){if(J=ft||oe?{}:bpt(m),!it)return ft?zme(m,ame(J,m)):Ome(m,kft(J,m))}else{if(!Tn[Vt])return V?m:{};J=$me(m,Vt,it)}}Y||(Y=new eu);var Te=Y.get(m);if(Te)return Te;Y.set(m,J),Kpt(m)?m.forEach(function(De){J.add(jl(De,v,T,De,m,Y))}):Xpt(m)&&m.forEach(function(De,pr){J.set(pr,jl(De,v,T,pr,m,Y))});var Ne=Dt?ft?Uq:Vq:ft?gs:po,er=Ot?e:Ne(m);return Gl(er||m,function(De,pr){er&&(pr=De,De=m[pr]),IM(J,pr,jl(De,v,T,pr,m,Y))}),J}function sme(m){var v=po(m);return function(T){return Rft(T,m,v)}}function Rft(m,v,T){var N=T.length;if(m==null)return!N;for(m=vn(m);N--;){var V=T[N],Y=v[V],J=m[V];if(J===e&&!(V in m)||!Y(J))return!1}return!0}function Nft(m,v,T){if(typeof m!="function")throw new Wl(i);return zM(function(){m.apply(e,T)},v)}function LM(m,v,T,N){var V=-1,Y=V6,J=!0,it=m.length,ft=[],Dt=v.length;if(!it)return ft;T&&(v=Kn(v,Ys(T))),N?(Y=lq,J=!1):v.length>=r&&(Y=MM,J=!1,v=new n_(v));t:for(;++V<it;){var Ot=m[V],Vt=T==null?Ot:T(Ot);if(Ot=N||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=Dt;oe--;)if(v[oe]===Vt)continue t;ft.push(Ot)}else Y(v,Vt,N)||ft.push(Ot)}return ft}var ym=spt(mh),Dft=spt(Mq,!0);function lme(m,v){var T=!0;return ym(m,function(N,V,Y){return T=!!v(N,V,Y),T}),T}function oI(m,v,T){for(var N=-1,V=m.length;++N<V;){var Y=m[N],J=v(Y);if(J!=null&&(it===e?J===J&&!Xs(J):T(J,it)))var it=J,ft=Y}return ft}function cme(m,v,T,N){var V=m.length;for(T=Qe(T),T<0&&(T=-T>V?0:V+T),N=N===e||N>V?V:Qe(N),N<0&&(N+=V),N=T>N?0:Jpt(N);T<N;)m[T++]=v;return m}function Oft(m,v){var T=[];return ym(m,function(N,V,Y){v(N,V,Y)&&T.push(N)}),T}function Ro(m,v,T,N,V){var Y=-1,J=m.length;for(T||(T=Zme),V||(V=[]);++Y<J;){var it=m[Y];v>0&&T(it)?v>1?Ro(it,v-1,T,N,V):dm(V,it):N||(V[V.length]=it)}return V}var Sq=lpt(),zft=lpt(!0);function mh(m,v){return m&&Sq(m,v,po)}function Mq(m,v){return m&&zft(m,v,po)}function aI(m,v){return pm(v,function(T){return hp(m[T])})}function o_(m,v){v=xm(v,m);for(var T=0,N=v.length;m!=null&&T<N;)m=m[_h(v[T++])];return T&&T==N?m:e}function Fft(m,v,T){var N=v(m);return $e(m)?N:dm(N,T(m))}function ka(m){return m==null?m===e?tt:ht:e_&&e_ in vn(m)?Wme(m):ige(m)}function Eq(m,v){return m>v}function ume(m,v){return m!=null&&un.call(m,v)}function hme(m,v){return m!=null&&v in vn(m)}function fme(m,v,T){return m>=ra(v,T)&&m<Xi(v,T)}function Tq(m,v,T){for(var N=T?lq:V6,V=m[0].length,Y=m.length,J=Y,it=vt(Y),ft=1/0,Dt=[];J--;){var Ot=m[J];J&&v&&(Ot=Kn(Ot,Ys(v))),ft=ra(Ot.length,ft),it[J]=!T&&(v||V>=120&&Ot.length>=120)?new n_(J&&Ot):e}Ot=m[0];var Vt=-1,oe=it[0];t:for(;++Vt<V&&Dt.length<ft;){var Te=Ot[Vt],Ne=v?v(Te):Te;if(Te=T||Te!==0?Te:0,!(oe?MM(oe,Ne):N(Dt,Ne,T))){for(J=Y;--J;){var er=it[J];if(!(er?MM(er,Ne):N(m[J],Ne,T)))continue t}oe&&oe.push(Ne),Dt.push(Te)}}return Dt}function pme(m,v,T,N){return mh(m,function(V,Y,J){v(N,T(V),Y,J)}),N}function kM(m,v,T){v=xm(v,m),m=Ept(m,v);var N=m==null?m:m[_h($l(v))];return N==null?e:Ws(N,m,T)}function Bft(m){return si(m)&&ka(m)==bt}function dme(m){return si(m)&&ka(m)==$t}function mme(m){return si(m)&&ka(m)==_t}function RM(m,v,T,N,V){return m===v?!0:m==null||v==null||!si(m)&&!si(v)?m!==m&&v!==v:gme(m,v,T,N,RM,V)}function gme(m,v,T,N,V,Y){var J=$e(m),it=$e(v),ft=J?Mt:na(m),Dt=it?Mt:na(v);ft=ft==bt?wt:ft,Dt=Dt==bt?wt:Dt;var Ot=ft==wt,Vt=Dt==wt,oe=ft==Dt;if(oe&&wm(m)){if(!wm(v))return!1;J=!0,Ot=!1}if(oe&&!Ot)return Y||(Y=new eu),J||Sx(m)?ypt(m,v,T,N,V,Y):qme(m,v,ft,T,N,V,Y);if(!(T&f)){var Te=Ot&&un.call(m,"__wrapped__"),Ne=Vt&&un.call(v,"__wrapped__");if(Te||Ne){var er=Te?m.value():m,De=Ne?v.value():v;return Y||(Y=new eu),V(er,De,T,N,Y)}}return oe?(Y||(Y=new eu),Gme(m,v,T,N,V,Y)):!1}function _me(m){return si(m)&&na(m)==q}function Cq(m,v,T,N){var V=T.length,Y=V,J=!N;if(m==null)return!Y;for(m=vn(m);V--;){var it=T[V];if(J&&it[2]?it[1]!==m[it[0]]:!(it[0]in m))return!1}for(;++V<Y;){it=T[V];var ft=it[0],Dt=m[ft],Ot=it[1];if(J&&it[2]){if(Dt===e&&!(ft in m))return!1}else{var Vt=new eu;if(N)var oe=N(Dt,Ot,ft,m,v,Vt);if(!(oe===e?RM(Ot,Dt,f|p,N,Vt):oe))return!1}}return!0}function Hft(m){if(!ei(m)||Qme(m))return!1;var v=hp(m)?_de:Pr;return v.test(s_(m))}function yme(m){return si(m)&&ka(m)==ee}function vme(m){return si(m)&&na(m)==Le}function xme(m){return si(m)&&SI(m.length)&&!!Rn[ka(m)]}function Vft(m){return typeof m=="function"?m:m==null?_s:typeof m=="object"?$e(m)?Gft(m[0],m[1]):qft(m):cdt(m)}function Aq(m){if(!OM(m))return Sde(m);var v=[];for(var T in vn(m))un.call(m,T)&&T!="constructor"&&v.push(T);return v}function bme(m){if(!ei(m))return nge(m);var v=OM(m),T=[];for(var N in m)N=="constructor"&&(v||!un.call(m,N))||T.push(N);return T}function Pq(m,v){return m<v}function Uft(m,v){var T=-1,N=ms(m)?vt(m.length):[];return ym(m,function(V,Y,J){N[++T]=v(V,Y,J)}),N}function qft(m){var v=Gq(m);return v.length==1&&v[0][2]?Spt(v[0][0],v[0][1]):function(T){return T===m||Cq(T,m,v)}}function Gft(m,v){return Yq(m)&&wpt(v)?Spt(_h(m),v):function(T){var N=rG(T,m);return N===e&&N===v?nG(T,m):RM(v,N,f|p)}}function sI(m,v,T,N,V){m!==v&&Sq(v,function(Y,J){if(V||(V=new eu),ei(Y))wme(m,v,J,T,sI,N,V);else{var it=N?N(Xq(m,J),Y,J+"",m,v,V):e;it===e&&(it=Y),bq(m,J,it)}},gs)}function wme(m,v,T,N,V,Y,J){var it=Xq(m,T),ft=Xq(v,T),Dt=J.get(ft);if(Dt){bq(m,T,Dt);return}var Ot=Y?Y(it,ft,T+"",m,v,J):e,Vt=Ot===e;if(Vt){var oe=$e(ft),Te=!oe&&wm(ft),Ne=!oe&&!Te&&Sx(ft);Ot=ft,oe||Te||Ne?$e(it)?Ot=it:xi(it)?Ot=ds(it):Te?(Vt=!1,Ot=rpt(ft,!0)):Ne?(Vt=!1,Ot=npt(ft,!0)):Ot=[]:FM(ft)||l_(ft)?(Ot=it,l_(it)?Ot=Qpt(it):(!ei(it)||hp(it))&&(Ot=bpt(ft))):Vt=!1}Vt&&(J.set(ft,Ot),V(Ot,ft,N,Y,J),J.delete(ft)),bq(m,T,Ot)}function Wft(m,v){var T=m.length;if(!!T)return v+=v<0?T:0,up(v,T)?m[v]:e}function Yft(m,v,T){v.length?v=Kn(v,function(Y){return $e(Y)?function(J){return o_(J,Y.length===1?Y[0]:Y)}:Y}):v=[_s];var N=-1;v=Kn(v,Ys(ke()));var V=Uft(m,function(Y,J,it){var ft=Kn(v,function(Dt){return Dt(Y)});return{criteria:ft,index:++N,value:Y}});return $pe(V,function(Y,J){return Dme(Y,J,T)})}function Sme(m,v){return jft(m,v,function(T,N){return nG(m,N)})}function jft(m,v,T){for(var N=-1,V=v.length,Y={};++N<V;){var J=v[N],it=o_(m,J);T(it,J)&&NM(Y,xm(J,m),it)}return Y}function Mme(m){return function(v){return o_(v,m)}}function Iq(m,v,T,N){var V=N?Xpe:px,Y=-1,J=v.length,it=m;for(m===v&&(v=ds(v)),T&&(it=Kn(m,Ys(T)));++Y<J;)for(var ft=0,Dt=v[Y],Ot=T?T(Dt):Dt;(ft=V(it,Ot,ft,N))>-1;)it!==m&&Z6.call(it,ft,1),Z6.call(m,ft,1);return m}function Xft(m,v){for(var T=m?v.length:0,N=T-1;T--;){var V=v[T];if(T==N||V!==Y){var Y=V;up(V)?Z6.call(m,V,1):Nq(m,V)}}return m}function Lq(m,v){return m+tI(Aft()*(v-m+1))}function Eme(m,v,T,N){for(var V=-1,Y=Xi(Q6((v-m)/(T||1)),0),J=vt(Y);Y--;)J[N?Y:++V]=m,m+=T;return J}function kq(m,v){var T="";if(!m||v<1||v>U)return T;do v%2&&(T+=m),v=tI(v/2),v&&(m+=m);while(v);return T}function nr(m,v){return $q(Mpt(m,v,_s),m+"")}function Tme(m){return Lft(Mx(m))}function Cme(m,v){var T=Mx(m);return _I(T,i_(v,0,T.length))}function NM(m,v,T,N){if(!ei(m))return m;v=xm(v,m);for(var V=-1,Y=v.length,J=Y-1,it=m;it!=null&&++V<Y;){var ft=_h(v[V]),Dt=T;if(ft==="__proto__"||ft==="constructor"||ft==="prototype")return m;if(V!=J){var Ot=it[ft];Dt=N?N(Ot,ft,it):e,Dt===e&&(Dt=ei(Ot)?Ot:up(v[V+1])?[]:{})}IM(it,ft,Dt),it=it[ft]}return m}var $ft=eI?function(m,v){return eI.set(m,v),m}:_s,Ame=J6?function(m,v){return J6(m,"toString",{configurable:!0,enumerable:!1,value:oG(v),writable:!0})}:_s;function Pme(m){return _I(Mx(m))}function Xl(m,v,T){var N=-1,V=m.length;v<0&&(v=-v>V?0:V+v),T=T>V?V:T,T<0&&(T+=V),V=v>T?0:T-v>>>0,v>>>=0;for(var Y=vt(V);++N<V;)Y[N]=m[N+v];return Y}function Ime(m,v){var T;return ym(m,function(N,V,Y){return T=v(N,V,Y),!T}),!!T}function lI(m,v,T){var N=0,V=m==null?N:m.length;if(typeof v=="number"&&v===v&&V<=st){for(;N<V;){var Y=N+V>>>1,J=m[Y];J!==null&&!Xs(J)&&(T?J<=v:J<v)?N=Y+1:V=Y}return V}return Rq(m,v,_s,T)}function Rq(m,v,T,N){var V=0,Y=m==null?0:m.length;if(Y===0)return 0;v=T(v);for(var J=v!==v,it=v===null,ft=Xs(v),Dt=v===e;V<Y;){var Ot=tI((V+Y)/2),Vt=T(m[Ot]),oe=Vt!==e,Te=Vt===null,Ne=Vt===Vt,er=Xs(Vt);if(J)var De=N||Ne;else Dt?De=Ne&&(N||oe):it?De=Ne&&oe&&(N||!Te):ft?De=Ne&&oe&&!Te&&(N||!er):Te||er?De=!1:De=N?Vt<=v:Vt<v;De?V=Ot+1:Y=Ot}return ra(Y,ot)}function Kft(m,v){for(var T=-1,N=m.length,V=0,Y=[];++T<N;){var J=m[T],it=v?v(J):J;if(!T||!ru(it,ft)){var ft=it;Y[V++]=J===0?0:J}}return Y}function Zft(m){return typeof m=="number"?m:Xs(m)?Z:+m}function js(m){if(typeof m=="string")return m;if($e(m))return Kn(m,js)+"";if(Xs(m))return Pft?Pft.call(m):"";var v=m+"";return v=="0"&&1/m==-z?"-0":v}function vm(m,v,T){var N=-1,V=V6,Y=m.length,J=!0,it=[],ft=it;if(T)J=!1,V=lq;else if(Y>=r){var Dt=v?null:Vme(m);if(Dt)return q6(Dt);J=!1,V=MM,ft=new n_}else ft=v?[]:it;t:for(;++N<Y;){var Ot=m[N],Vt=v?v(Ot):Ot;if(Ot=T||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=ft.length;oe--;)if(ft[oe]===Vt)continue t;v&&ft.push(Vt),it.push(Ot)}else V(ft,Vt,T)||(ft!==it&&ft.push(Vt),it.push(Ot))}return it}function Nq(m,v){return v=xm(v,m),m=Ept(m,v),m==null||delete m[_h($l(v))]}function Jft(m,v,T,N){return NM(m,v,T(o_(m,v)),N)}function cI(m,v,T,N){for(var V=m.length,Y=N?V:-1;(N?Y--:++Y<V)&&v(m[Y],Y,m););return T?Xl(m,N?0:Y,N?Y+1:V):Xl(m,N?Y+1:0,N?V:Y)}function Qft(m,v){var T=m;return T instanceof gr&&(T=T.value()),cq(v,function(N,V){return V.func.apply(V.thisArg,dm([N],V.args))},T)}function Dq(m,v,T){var N=m.length;if(N<2)return N?vm(m[0]):[];for(var V=-1,Y=vt(N);++V<N;)for(var J=m[V],it=-1;++it<N;)it!=V&&(Y[V]=LM(Y[V]||J,m[it],v,T));return vm(Ro(Y,1),v,T)}function tpt(m,v,T){for(var N=-1,V=m.length,Y=v.length,J={};++N<V;){var it=N<Y?v[N]:e;T(J,m[N],it)}return J}function Oq(m){return xi(m)?m:[]}function zq(m){return typeof m=="function"?m:_s}function xm(m,v){return $e(m)?m:Yq(m,v)?[m]:Ppt(on(m))}var Lme=nr;function bm(m,v,T){var N=m.length;return T=T===e?N:T,!v&&T>=N?m:Xl(m,v,T)}var ept=yde||function(m){return fo.clearTimeout(m)};function rpt(m,v){if(v)return m.slice();var T=m.length,N=Sft?Sft(T):new m.constructor(T);return m.copy(N),N}function Fq(m){var v=new m.constructor(m.byteLength);return new $6(v).set(new $6(m)),v}function kme(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.byteLength)}function Rme(m){var v=new m.constructor(m.source,Ke.exec(m));return v.lastIndex=m.lastIndex,v}function Nme(m){return PM?vn(PM.call(m)):{}}function npt(m,v){var T=v?Fq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.length)}function ipt(m,v){if(m!==v){var T=m!==e,N=m===null,V=m===m,Y=Xs(m),J=v!==e,it=v===null,ft=v===v,Dt=Xs(v);if(!it&&!Dt&&!Y&&m>v||Y&&J&&ft&&!it&&!Dt||N&&J&&ft||!T&&ft||!V)return 1;if(!N&&!Y&&!Dt&&m<v||Dt&&T&&V&&!N&&!Y||it&&T&&V||!J&&V||!ft)return-1}return 0}function Dme(m,v,T){for(var N=-1,V=m.criteria,Y=v.criteria,J=V.length,it=T.length;++N<J;){var ft=ipt(V[N],Y[N]);if(ft){if(N>=it)return ft;var Dt=T[N];return ft*(Dt=="desc"?-1:1)}}return m.index-v.index}function opt(m,v,T,N){for(var V=-1,Y=m.length,J=T.length,it=-1,ft=v.length,Dt=Xi(Y-J,0),Ot=vt(ft+Dt),Vt=!N;++it<ft;)Ot[it]=v[it];for(;++V<J;)(Vt||V<Y)&&(Ot[T[V]]=m[V]);for(;Dt--;)Ot[it++]=m[V++];return Ot}function apt(m,v,T,N){for(var V=-1,Y=m.length,J=-1,it=T.length,ft=-1,Dt=v.length,Ot=Xi(Y-it,0),Vt=vt(Ot+Dt),oe=!N;++V<Ot;)Vt[V]=m[V];for(var Te=V;++ft<Dt;)Vt[Te+ft]=v[ft];for(;++J<it;)(oe||V<Y)&&(Vt[Te+T[J]]=m[V++]);return Vt}function ds(m,v){var T=-1,N=m.length;for(v||(v=vt(N));++T<N;)v[T]=m[T];return v}function gh(m,v,T,N){var V=!T;T||(T={});for(var Y=-1,J=v.length;++Y<J;){var it=v[Y],ft=N?N(T[it],m[it],it,T,m):e;ft===e&&(ft=m[it]),V?sp(T,it,ft):IM(T,it,ft)}return T}function Ome(m,v){return gh(m,Wq(m),v)}function zme(m,v){return gh(m,vpt(m),v)}function uI(m,v){return function(T,N){var V=$e(T)?Upe:ome,Y=v?v():{};return V(T,m,ke(N,2),Y)}}function xx(m){return nr(function(v,T){var N=-1,V=T.length,Y=V>1?T[V-1]:e,J=V>2?T[2]:e;for(Y=m.length>3&&typeof Y=="function"?(V--,Y):e,J&&Ra(T[0],T[1],J)&&(Y=V<3?e:Y,V=1),v=vn(v);++N<V;){var it=T[N];it&&m(v,it,N,Y)}return v})}function spt(m,v){return function(T,N){if(T==null)return T;if(!ms(T))return m(T,N);for(var V=T.length,Y=v?V:-1,J=vn(T);(v?Y--:++Y<V)&&N(J[Y],Y,J)!==!1;);return T}}function lpt(m){return function(v,T,N){for(var V=-1,Y=vn(v),J=N(v),it=J.length;it--;){var ft=J[m?it:++V];if(T(Y[ft],ft,Y)===!1)break}return v}}function Fme(m,v,T){var N=v&d,V=DM(m);function Y(){var J=this&&this!==fo&&this instanceof Y?V:m;return J.apply(N?T:this,arguments)}return Y}function cpt(m){return function(v){v=on(v);var T=dx(v)?tu(v):e,N=T?T[0]:v.charAt(0),V=T?bm(T,1).join(""):v.slice(1);return N[m]()+V}}function bx(m){return function(v){return cq(sdt(adt(v).replace(Ape,"")),m,"")}}function DM(m){return function(){var v=arguments;switch(v.length){case 0:return new m;case 1:return new m(v[0]);case 2:return new m(v[0],v[1]);case 3:return new m(v[0],v[1],v[2]);case 4:return new m(v[0],v[1],v[2],v[3]);case 5:return new m(v[0],v[1],v[2],v[3],v[4]);case 6:return new m(v[0],v[1],v[2],v[3],v[4],v[5]);case 7:return new m(v[0],v[1],v[2],v[3],v[4],v[5],v[6])}var T=vx(m.prototype),N=m.apply(T,v);return ei(N)?N:T}}function Bme(m,v,T){var N=DM(m);function V(){for(var Y=arguments.length,J=vt(Y),it=Y,ft=wx(V);it--;)J[it]=arguments[it];var Dt=Y<3&&J[0]!==ft&&J[Y-1]!==ft?[]:mm(J,ft);if(Y-=Dt.length,Y<T)return dpt(m,v,hI,V.placeholder,e,J,Dt,e,e,T-Y);var Ot=this&&this!==fo&&this instanceof V?N:m;return Ws(Ot,this,J)}return V}function upt(m){return function(v,T,N){var V=vn(v);if(!ms(v)){var Y=ke(T,3);v=po(v),T=function(it){return Y(V[it],it,V)}}var J=m(v,T,N);return J>-1?V[Y?v[J]:J]:e}}function hpt(m){return cp(function(v){var T=v.length,N=T,V=Yl.prototype.thru;for(m&&v.reverse();N--;){var Y=v[N];if(typeof Y!="function")throw new Wl(i);if(V&&!J&&mI(Y)=="wrapper")var J=new Yl([],!0)}for(N=J?N:T;++N<T;){Y=v[N];var it=mI(Y),ft=it=="wrapper"?qq(Y):e;ft&&jq(ft[0])&&ft[1]==(C|y|b|P)&&!ft[4].length&&ft[9]==1?J=J[mI(ft[0])].apply(J,ft[3]):J=Y.length==1&&jq(Y)?J[it]():J.thru(Y)}return function(){var Dt=arguments,Ot=Dt[0];if(J&&Dt.length==1&&$e(Ot))return J.plant(Ot).value();for(var Vt=0,oe=T?v[Vt].apply(this,Dt):Ot;++Vt<T;)oe=v[Vt].call(this,oe);return oe}})}function hI(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&C,Vt=v&d,oe=v&g,Te=v&(y|x),Ne=v&k,er=oe?e:DM(m);function De(){for(var pr=arguments.length,yr=vt(pr),$s=pr;$s--;)yr[$s]=arguments[$s];if(Te)var Na=wx(De),Ks=Zpe(yr,Na);if(N&&(yr=opt(yr,N,V,Te)),Y&&(yr=apt(yr,Y,J,Te)),pr-=Ks,Te&&pr<Dt){var bi=mm(yr,Na);return dpt(m,v,hI,De.placeholder,T,yr,bi,it,ft,Dt-pr)}var nu=Vt?T:this,pp=oe?nu[m]:m;return pr=yr.length,it?yr=oge(yr,it):Ne&&pr>1&&yr.reverse(),Ot&&ft<pr&&(yr.length=ft),this&&this!==fo&&this instanceof De&&(pp=er||DM(pp)),pp.apply(nu,yr)}return De}function fpt(m,v){return function(T,N){return pme(T,m,v(N),{})}}function fI(m,v){return function(T,N){var V;if(T===e&&N===e)return v;if(T!==e&&(V=T),N!==e){if(V===e)return N;typeof T=="string"||typeof N=="string"?(T=js(T),N=js(N)):(T=Zft(T),N=Zft(N)),V=m(T,N)}return V}}function Bq(m){return cp(function(v){return v=Kn(v,Ys(ke())),nr(function(T){var N=this;return m(v,function(V){return Ws(V,N,T)})})})}function pI(m,v){v=v===e?" ":js(v);var T=v.length;if(T<2)return T?kq(v,m):v;var N=kq(v,Q6(m/mx(v)));return dx(v)?bm(tu(N),0,m).join(""):N.slice(0,m)}function Hme(m,v,T,N){var V=v&d,Y=DM(m);function J(){for(var it=-1,ft=arguments.length,Dt=-1,Ot=N.length,Vt=vt(Ot+ft),oe=this&&this!==fo&&this instanceof J?Y:m;++Dt<Ot;)Vt[Dt]=N[Dt];for(;ft--;)Vt[Dt++]=arguments[++it];return Ws(oe,V?T:this,Vt)}return J}function ppt(m){return function(v,T,N){return N&&typeof N!="number"&&Ra(v,T,N)&&(T=N=e),v=fp(v),T===e?(T=v,v=0):T=fp(T),N=N===e?v<T?1:-1:fp(N),Eme(v,T,N,m)}}function dI(m){return function(v,T){return typeof v=="string"&&typeof T=="string"||(v=Kl(v),T=Kl(T)),m(v,T)}}function dpt(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&y,Vt=Ot?J:e,oe=Ot?e:J,Te=Ot?Y:e,Ne=Ot?e:Y;v|=Ot?b:S,v&=~(Ot?S:b),v&_||(v&=~(d|g));var er=[m,v,V,Te,Vt,Ne,oe,it,ft,Dt],De=T.apply(e,er);return jq(m)&&Tpt(De,er),De.placeholder=N,Cpt(De,m,v)}function Hq(m){var v=ji[m];return function(T,N){if(T=Kl(T),N=N==null?0:ra(Qe(N),292),N&&Cft(T)){var V=(on(T)+"e").split("e"),Y=v(V[0]+"e"+(+V[1]+N));return V=(on(Y)+"e").split("e"),+(V[0]+"e"+(+V[1]-N))}return v(T)}}var Vme=_x&&1/q6(new _x([,-0]))[1]==z?function(m){return new _x(m)}:lG;function mpt(m){return function(v){var T=na(v);return T==q?gq(v):T==Le?ide(v):Kpe(v,m(v))}}function lp(m,v,T,N,V,Y,J,it){var ft=v&g;if(!ft&&typeof m!="function")throw new Wl(i);var Dt=N?N.length:0;if(Dt||(v&=~(b|S),N=V=e),J=J===e?J:Xi(Qe(J),0),it=it===e?it:Qe(it),Dt-=V?V.length:0,v&S){var Ot=N,Vt=V;N=V=e}var oe=ft?e:qq(m),Te=[m,v,T,N,V,Ot,Vt,Y,J,it];if(oe&&rge(Te,oe),m=Te[0],v=Te[1],T=Te[2],N=Te[3],V=Te[4],it=Te[9]=Te[9]===e?ft?0:m.length:Xi(Te[9]-Dt,0),!it&&v&(y|x)&&(v&=~(y|x)),!v||v==d)var Ne=Fme(m,v,T);else v==y||v==x?Ne=Bme(m,v,it):(v==b||v==(d|b))&&!V.length?Ne=Hme(m,v,T,N):Ne=hI.apply(e,Te);var er=oe?$ft:Tpt;return Cpt(er(Ne,Te),m,v)}function gpt(m,v,T,N){return m===e||ru(m,gx[T])&&!un.call(N,T)?v:m}function _pt(m,v,T,N,V,Y){return ei(m)&&ei(v)&&(Y.set(v,m),sI(m,v,e,_pt,Y),Y.delete(v)),m}function Ume(m){return FM(m)?e:m}function ypt(m,v,T,N,V,Y){var J=T&f,it=m.length,ft=v.length;if(it!=ft&&!(J&&ft>it))return!1;var Dt=Y.get(m),Ot=Y.get(v);if(Dt&&Ot)return Dt==v&&Ot==m;var Vt=-1,oe=!0,Te=T&p?new n_:e;for(Y.set(m,v),Y.set(v,m);++Vt<it;){var Ne=m[Vt],er=v[Vt];if(N)var De=J?N(er,Ne,Vt,v,m,Y):N(Ne,er,Vt,m,v,Y);if(De!==e){if(De)continue;oe=!1;break}if(Te){if(!uq(v,function(pr,yr){if(!MM(Te,yr)&&(Ne===pr||V(Ne,pr,T,N,Y)))return Te.push(yr)})){oe=!1;break}}else if(!(Ne===er||V(Ne,er,T,N,Y))){oe=!1;break}}return Y.delete(m),Y.delete(v),oe}function qme(m,v,T,N,V,Y,J){switch(T){case he:if(m.byteLength!=v.byteLength||m.byteOffset!=v.byteOffset)return!1;m=m.buffer,v=v.buffer;case $t:return!(m.byteLength!=v.byteLength||!Y(new $6(m),new $6(v)));case Kt:case _t:case pt:return ru(+m,+v);case X:return m.name==v.name&&m.message==v.message;case ee:case ar:return m==v+"";case q:var it=gq;case Le:var ft=N&f;if(it||(it=q6),m.size!=v.size&&!ft)return!1;var Dt=J.get(m);if(Dt)return Dt==v;N|=p,J.set(m,v);var Ot=ypt(it(m),it(v),N,V,Y,J);return J.delete(m),Ot;case fr:if(PM)return PM.call(m)==PM.call(v)}return!1}function Gme(m,v,T,N,V,Y){var J=T&f,it=Vq(m),ft=it.length,Dt=Vq(v),Ot=Dt.length;if(ft!=Ot&&!J)return!1;for(var Vt=ft;Vt--;){var oe=it[Vt];if(!(J?oe in v:un.call(v,oe)))return!1}var Te=Y.get(m),Ne=Y.get(v);if(Te&&Ne)return Te==v&&Ne==m;var er=!0;Y.set(m,v),Y.set(v,m);for(var De=J;++Vt<ft;){oe=it[Vt];var pr=m[oe],yr=v[oe];if(N)var $s=J?N(yr,pr,oe,v,m,Y):N(pr,yr,oe,m,v,Y);if(!($s===e?pr===yr||V(pr,yr,T,N,Y):$s)){er=!1;break}De||(De=oe=="constructor")}if(er&&!De){var Na=m.constructor,Ks=v.constructor;Na!=Ks&&"constructor"in m&&"constructor"in v&&!(typeof Na=="function"&&Na instanceof Na&&typeof Ks=="function"&&Ks instanceof Ks)&&(er=!1)}return Y.delete(m),Y.delete(v),er}function cp(m){return $q(Mpt(m,e,Rpt),m+"")}function Vq(m){return Fft(m,po,Wq)}function Uq(m){return Fft(m,gs,vpt)}var qq=eI?function(m){return eI.get(m)}:lG;function mI(m){for(var v=m.name+"",T=yx[v],N=un.call(yx,v)?T.length:0;N--;){var V=T[N],Y=V.func;if(Y==null||Y==m)return V.name}return v}function wx(m){var v=un.call(G,"placeholder")?G:m;return v.placeholder}function ke(){var m=G.iteratee||aG;return m=m===aG?Vft:m,arguments.length?m(arguments[0],arguments[1]):m}function gI(m,v){var T=m.__data__;return Jme(v)?T[typeof v=="string"?"string":"hash"]:T.map}function Gq(m){for(var v=po(m),T=v.length;T--;){var N=v[T],V=m[N];v[T]=[N,V,wpt(V)]}return v}function a_(m,v){var T=ede(m,v);return Hft(T)?T:e}function Wme(m){var v=un.call(m,e_),T=m[e_];try{m[e_]=e;var N=!0}catch(Y){}var V=j6.call(m);return N&&(v?m[e_]=T:delete m[e_]),V}var Wq=yq?function(m){return m==null?[]:(m=vn(m),pm(yq(m),function(v){return Eft.call(m,v)}))}:cG,vpt=yq?function(m){for(var v=[];m;)dm(v,Wq(m)),m=K6(m);return v}:cG,na=ka;(vq&&na(new vq(new ArrayBuffer(1)))!=he||TM&&na(new TM)!=q||xq&&na(xq.resolve())!=kt||_x&&na(new _x)!=Le||CM&&na(new CM)!=$)&&(na=function(m){var v=ka(m),T=v==wt?m.constructor:e,N=T?s_(T):"";if(N)switch(N){case Cde:return he;case Ade:return q;case Pde:return kt;case Ide:return Le;case Lde:return $}return v});function Yme(m,v,T){for(var N=-1,V=T.length;++N<V;){var Y=T[N],J=Y.size;switch(Y.type){case"drop":m+=J;break;case"dropRight":v-=J;break;case"take":v=ra(v,m+J);break;case"takeRight":m=Xi(m,v-J);break}}return{start:m,end:v}}function jme(m){var v=m.match(Et);return v?v[1].split(xt):[]}function xpt(m,v,T){v=xm(v,m);for(var N=-1,V=v.length,Y=!1;++N<V;){var J=_h(v[N]);if(!(Y=m!=null&&T(m,J)))break;m=m[J]}return Y||++N!=V?Y:(V=m==null?0:m.length,!!V&&SI(V)&&up(J,V)&&($e(m)||l_(m)))}function Xme(m){var v=m.length,T=new m.constructor(v);return v&&typeof m[0]=="string"&&un.call(m,"index")&&(T.index=m.index,T.input=m.input),T}function bpt(m){return typeof m.constructor=="function"&&!OM(m)?vx(K6(m)):{}}function $me(m,v,T){var N=m.constructor;switch(v){case $t:return Fq(m);case Kt:case _t:return new N(+m);case he:return kme(m,T);case Tt:case be:case nt:case Ct:case Wt:case fe:case at:case se:case Qt:return npt(m,T);case q:return new N;case pt:case ar:return new N(m);case ee:return Rme(m);case Le:return new N;case fr:return Nme(m)}}function Kme(m,v){var T=v.length;if(!T)return m;var N=T-1;return v[N]=(T>1?"& ":"")+v[N],v=v.join(T>2?", ":" "),m.replace(gt,`{
/* [wrapped with `+v+`] */
`)}function Zme(m){return $e(m)||l_(m)||!!(Tft&&m&&m[Tft])}function up(m,v){var T=typeof m;return v=v==null?U:v,!!v&&(T=="number"||T!="symbol"&&ip.test(m))&&m>-1&&m%1==0&&m<v}function Ra(m,v,T){if(!ei(T))return!1;var N=typeof v;return(N=="number"?ms(T)&&up(v,T.length):N=="string"&&v in T)?ru(T[v],m):!1}function Yq(m,v){if($e(m))return!1;var T=typeof m;return T=="number"||T=="symbol"||T=="boolean"||m==null||Xs(m)?!0:um.test(m)||!cx.test(m)||v!=null&&m in vn(v)}function Jme(m){var v=typeof m;return v=="string"||v=="number"||v=="symbol"||v=="boolean"?m!=="__proto__":m===null}function jq(m){var v=mI(m),T=G[v];if(typeof T!="function"||!(v in gr.prototype))return!1;if(m===T)return!0;var N=qq(T);return!!N&&m===N[0]}function Qme(m){return!!wft&&wft in m}var tge=W6?hp:uG;function OM(m){var v=m&&m.constructor,T=typeof v=="function"&&v.prototype||gx;return m===T}function wpt(m){return m===m&&!ei(m)}function Spt(m,v){return function(T){return T==null?!1:T[m]===v&&(v!==e||m in vn(T))}}function ege(m){var v=bI(m,function(N){return T.size===s&&T.clear(),N}),T=v.cache;return v}function rge(m,v){var T=m[1],N=v[1],V=T|N,Y=V<(d|g|C),J=N==C&&T==y||N==C&&T==P&&m[7].length<=v[8]||N==(C|P)&&v[7].length<=v[8]&&T==y;if(!(Y||J))return m;N&d&&(m[2]=v[2],V|=T&d?0:_);var it=v[3];if(it){var ft=m[3];m[3]=ft?opt(ft,it,v[4]):it,m[4]=ft?mm(m[3],l):v[4]}return it=v[5],it&&(ft=m[5],m[5]=ft?apt(ft,it,v[6]):it,m[6]=ft?mm(m[5],l):v[6]),it=v[7],it&&(m[7]=it),N&C&&(m[8]=m[8]==null?v[8]:ra(m[8],v[8])),m[9]==null&&(m[9]=v[9]),m[0]=v[0],m[1]=V,m}function nge(m){var v=[];if(m!=null)for(var T in vn(m))v.push(T);return v}function ige(m){return j6.call(m)}function Mpt(m,v,T){return v=Xi(v===e?m.length-1:v,0),function(){for(var N=arguments,V=-1,Y=Xi(N.length-v,0),J=vt(Y);++V<Y;)J[V]=N[v+V];V=-1;for(var it=vt(v+1);++V<v;)it[V]=N[V];return it[v]=T(J),Ws(m,this,it)}}function Ept(m,v){return v.length<2?m:o_(m,Xl(v,0,-1))}function oge(m,v){for(var T=m.length,N=ra(v.length,T),V=ds(m);N--;){var Y=v[N];m[N]=up(Y,T)?V[Y]:e}return m}function Xq(m,v){if(!(v==="constructor"&&typeof m[v]=="function")&&v!="__proto__")return m[v]}var Tpt=Apt($ft),zM=xde||function(m,v){return fo.setTimeout(m,v)},$q=Apt(Ame);function Cpt(m,v,T){var N=v+"";return $q(m,Kme(N,age(jme(N),T)))}function Apt(m){var v=0,T=0;return function(){var N=Mde(),V=I-(N-T);if(T=N,V>0){if(++v>=B)return arguments[0]}else v=0;return m.apply(e,arguments)}}function _I(m,v){var T=-1,N=m.length,V=N-1;for(v=v===e?N:v;++T<v;){var Y=Lq(T,V),J=m[Y];m[Y]=m[T],m[T]=J}return m.length=v,m}var Ppt=ege(function(m){var v=[];return m.charCodeAt(0)===46&&v.push(""),m.replace(Q0,function(T,N,V,Y){v.push(V?Y.replace(Ue,"$1"):N||T)}),v});function _h(m){if(typeof m=="string"||Xs(m))return m;var v=m+"";return v=="0"&&1/m==-z?"-0":v}function s_(m){if(m!=null){try{return Y6.call(m)}catch(v){}try{return m+""}catch(v){}}return""}function age(m,v){return Gl(St,function(T){var N="_."+T[0];v&T[1]&&!V6(m,N)&&m.push(N)}),m.sort()}function Ipt(m){if(m instanceof gr)return m.clone();var v=new Yl(m.__wrapped__,m.__chain__);return v.__actions__=ds(m.__actions__),v.__index__=m.__index__,v.__values__=m.__values__,v}function sge(m,v,T){(T?Ra(m,v,T):v===e)?v=1:v=Xi(Qe(v),0);var N=m==null?0:m.length;if(!N||v<1)return[];for(var V=0,Y=0,J=vt(Q6(N/v));V<N;)J[Y++]=Xl(m,V,V+=v);return J}function lge(m){for(var v=-1,T=m==null?0:m.length,N=0,V=[];++v<T;){var Y=m[v];Y&&(V[N++]=Y)}return V}function cge(){var m=arguments.length;if(!m)return[];for(var v=vt(m-1),T=arguments[0],N=m;N--;)v[N-1]=arguments[N];return dm($e(T)?ds(T):[T],Ro(v,1))}var uge=nr(function(m,v){return xi(m)?LM(m,Ro(v,1,xi,!0)):[]}),hge=nr(function(m,v){var T=$l(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),ke(T,2)):[]}),fge=nr(function(m,v){var T=$l(v);return xi(T)&&(T=e),xi(m)?LM(m,Ro(v,1,xi,!0),e,T):[]});function pge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),Xl(m,v<0?0:v,N)):[]}function dge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,Xl(m,0,v<0?0:v)):[]}function mge(m,v){return m&&m.length?cI(m,ke(v,3),!0,!0):[]}function gge(m,v){return m&&m.length?cI(m,ke(v,3),!0):[]}function _ge(m,v,T,N){var V=m==null?0:m.length;return V?(T&&typeof T!="number"&&Ra(m,v,T)&&(T=0,N=V),cme(m,v,T,N)):[]}function Lpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),U6(m,ke(v,3),V)}function kpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N-1;return T!==e&&(V=Qe(T),V=T<0?Xi(N+V,0):ra(V,N-1)),U6(m,ke(v,3),V,!0)}function Rpt(m){var v=m==null?0:m.length;return v?Ro(m,1):[]}function yge(m){var v=m==null?0:m.length;return v?Ro(m,z):[]}function vge(m,v){var T=m==null?0:m.length;return T?(v=v===e?1:Qe(v),Ro(m,v)):[]}function xge(m){for(var v=-1,T=m==null?0:m.length,N={};++v<T;){var V=m[v];N[V[0]]=V[1]}return N}function Npt(m){return m&&m.length?m[0]:e}function bge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),px(m,v,V)}function wge(m){var v=m==null?0:m.length;return v?Xl(m,0,-1):[]}var Sge=nr(function(m){var v=Kn(m,Oq);return v.length&&v[0]===m[0]?Tq(v):[]}),Mge=nr(function(m){var v=$l(m),T=Kn(m,Oq);return v===$l(T)?v=e:T.pop(),T.length&&T[0]===m[0]?Tq(T,ke(v,2)):[]}),Ege=nr(function(m){var v=$l(m),T=Kn(m,Oq);return v=typeof v=="function"?v:e,v&&T.pop(),T.length&&T[0]===m[0]?Tq(T,e,v):[]});function Tge(m,v){return m==null?"":wde.call(m,v)}function $l(m){var v=m==null?0:m.length;return v?m[v-1]:e}function Cge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N;return T!==e&&(V=Qe(T),V=V<0?Xi(N+V,0):ra(V,N-1)),v===v?ade(m,v,V):U6(m,dft,V,!0)}function Age(m,v){return m&&m.length?Wft(m,Qe(v)):e}var Pge=nr(Dpt);function Dpt(m,v){return m&&m.length&&v&&v.length?Iq(m,v):m}function Ige(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,ke(T,2)):m}function Lge(m,v,T){return m&&m.length&&v&&v.length?Iq(m,v,e,T):m}var kge=cp(function(m,v){var T=m==null?0:m.length,N=wq(m,v);return Xft(m,Kn(v,function(V){return up(V,T)?+V:V}).sort(ipt)),N});function Rge(m,v){var T=[];if(!(m&&m.length))return T;var N=-1,V=[],Y=m.length;for(v=ke(v,3);++N<Y;){var J=m[N];v(J,N,m)&&(T.push(J),V.push(N))}return Xft(m,V),T}function Kq(m){return m==null?m:Tde.call(m)}function Nge(m,v,T){var N=m==null?0:m.length;return N?(T&&typeof T!="number"&&Ra(m,v,T)?(v=0,T=N):(v=v==null?0:Qe(v),T=T===e?N:Qe(T)),Xl(m,v,T)):[]}function Dge(m,v){return lI(m,v)}function Oge(m,v,T){return Rq(m,v,ke(T,2))}function zge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v);if(N<T&&ru(m[N],v))return N}return-1}function Fge(m,v){return lI(m,v,!0)}function Bge(m,v,T){return Rq(m,v,ke(T,2),!0)}function Hge(m,v){var T=m==null?0:m.length;if(T){var N=lI(m,v,!0)-1;if(ru(m[N],v))return N}return-1}function Vge(m){return m&&m.length?Kft(m):[]}function Uge(m,v){return m&&m.length?Kft(m,ke(v,2)):[]}function qge(m){var v=m==null?0:m.length;return v?Xl(m,1,v):[]}function Gge(m,v,T){return m&&m.length?(v=T||v===e?1:Qe(v),Xl(m,0,v<0?0:v)):[]}function Wge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,Xl(m,v<0?0:v,N)):[]}function Yge(m,v){return m&&m.length?cI(m,ke(v,3),!1,!0):[]}function jge(m,v){return m&&m.length?cI(m,ke(v,3)):[]}var Xge=nr(function(m){return vm(Ro(m,1,xi,!0))}),$ge=nr(function(m){var v=$l(m);return xi(v)&&(v=e),vm(Ro(m,1,xi,!0),ke(v,2))}),Kge=nr(function(m){var v=$l(m);return v=typeof v=="function"?v:e,vm(Ro(m,1,xi,!0),e,v)});function Zge(m){return m&&m.length?vm(m):[]}function Jge(m,v){return m&&m.length?vm(m,ke(v,2)):[]}function Qge(m,v){return v=typeof v=="function"?v:e,m&&m.length?vm(m,e,v):[]}function Zq(m){if(!(m&&m.length))return[];var v=0;return m=pm(m,function(T){if(xi(T))return v=Xi(T.length,v),!0}),dq(v,function(T){return Kn(m,hq(T))})}function Opt(m,v){if(!(m&&m.length))return[];var T=Zq(m);return v==null?T:Kn(T,function(N){return Ws(v,e,N)})}var t0e=nr(function(m,v){return xi(m)?LM(m,v):[]}),e0e=nr(function(m){return Dq(pm(m,xi))}),r0e=nr(function(m){var v=$l(m);return xi(v)&&(v=e),Dq(pm(m,xi),ke(v,2))}),n0e=nr(function(m){var v=$l(m);return v=typeof v=="function"?v:e,Dq(pm(m,xi),e,v)}),i0e=nr(Zq);function o0e(m,v){return tpt(m||[],v||[],IM)}function a0e(m,v){return tpt(m||[],v||[],NM)}var s0e=nr(function(m){var v=m.length,T=v>1?m[v-1]:e;return T=typeof T=="function"?(m.pop(),T):e,Opt(m,T)});function zpt(m){var v=G(m);return v.__chain__=!0,v}function l0e(m,v){return v(m),m}function yI(m,v){return v(m)}var c0e=cp(function(m){var v=m.length,T=v?m[0]:0,N=this.__wrapped__,V=function(Y){return wq(Y,m)};return v>1||this.__actions__.length||!(N instanceof gr)||!up(T)?this.thru(V):(N=N.slice(T,+T+(v?1:0)),N.__actions__.push({func:yI,args:[V],thisArg:e}),new Yl(N,this.__chain__).thru(function(Y){return v&&!Y.length&&Y.push(e),Y}))});function u0e(){return zpt(this)}function h0e(){return new Yl(this.value(),this.__chain__)}function f0e(){this.__values__===e&&(this.__values__=Zpt(this.value()));var m=this.__index__>=this.__values__.length,v=m?e:this.__values__[this.__index__++];return{done:m,value:v}}function p0e(){return this}function d0e(m){for(var v,T=this;T instanceof nI;){var N=Ipt(T);N.__index__=0,N.__values__=e,v?V.__wrapped__=N:v=N;var V=N;T=T.__wrapped__}return V.__wrapped__=m,v}function m0e(){var m=this.__wrapped__;if(m instanceof gr){var v=m;return this.__actions__.length&&(v=new gr(this)),v=v.reverse(),v.__actions__.push({func:yI,args:[Kq],thisArg:e}),new Yl(v,this.__chain__)}return this.thru(Kq)}function g0e(){return Qft(this.__wrapped__,this.__actions__)}var _0e=uI(function(m,v,T){un.call(m,T)?++m[T]:sp(m,T,1)});function y0e(m,v,T){var N=$e(m)?fft:lme;return T&&Ra(m,v,T)&&(v=e),N(m,ke(v,3))}function v0e(m,v){var T=$e(m)?pm:Oft;return T(m,ke(v,3))}var x0e=upt(Lpt),b0e=upt(kpt);function w0e(m,v){return Ro(vI(m,v),1)}function S0e(m,v){return Ro(vI(m,v),z)}function M0e(m,v,T){return T=T===e?1:Qe(T),Ro(vI(m,v),T)}function Fpt(m,v){var T=$e(m)?Gl:ym;return T(m,ke(v,3))}function Bpt(m,v){var T=$e(m)?qpe:Dft;return T(m,ke(v,3))}var E0e=uI(function(m,v,T){un.call(m,T)?m[T].push(v):sp(m,T,[v])});function T0e(m,v,T,N){m=ms(m)?m:Mx(m),T=T&&!N?Qe(T):0;var V=m.length;return T<0&&(T=Xi(V+T,0)),MI(m)?T<=V&&m.indexOf(v,T)>-1:!!V&&px(m,v,T)>-1}var C0e=nr(function(m,v,T){var N=-1,V=typeof v=="function",Y=ms(m)?vt(m.length):[];return ym(m,function(J){Y[++N]=V?Ws(v,J,T):kM(J,v,T)}),Y}),A0e=uI(function(m,v,T){sp(m,T,v)});function vI(m,v){var T=$e(m)?Kn:Uft;return T(m,ke(v,3))}function P0e(m,v,T,N){return m==null?[]:($e(v)||(v=v==null?[]:[v]),T=N?e:T,$e(T)||(T=T==null?[]:[T]),Yft(m,v,T))}var I0e=uI(function(m,v,T){m[T?0:1].push(v)},function(){return[[],[]]});function L0e(m,v,T){var N=$e(m)?cq:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,ym)}function k0e(m,v,T){var N=$e(m)?Gpe:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,Dft)}function R0e(m,v){var T=$e(m)?pm:Oft;return T(m,wI(ke(v,3)))}function N0e(m){var v=$e(m)?Lft:Tme;return v(m)}function D0e(m,v,T){(T?Ra(m,v,T):v===e)?v=1:v=Qe(v);var N=$e(m)?nme:Cme;return N(m,v)}function O0e(m){var v=$e(m)?ime:Pme;return v(m)}function z0e(m){if(m==null)return 0;if(ms(m))return MI(m)?mx(m):m.length;var v=na(m);return v==q||v==Le?m.size:Aq(m).length}function F0e(m,v,T){var N=$e(m)?uq:Ime;return T&&Ra(m,v,T)&&(v=e),N(m,ke(v,3))}var B0e=nr(function(m,v){if(m==null)return[];var T=v.length;return T>1&&Ra(m,v[0],v[1])?v=[]:T>2&&Ra(v[0],v[1],v[2])&&(v=[v[0]]),Yft(m,Ro(v,1),[])}),xI=vde||function(){return fo.Date.now()};function H0e(m,v){if(typeof v!="function")throw new Wl(i);return m=Qe(m),function(){if(--m<1)return v.apply(this,arguments)}}function Hpt(m,v,T){return v=T?e:v,v=m&&v==null?m.length:v,lp(m,C,e,e,e,e,v)}function Vpt(m,v){var T;if(typeof v!="function")throw new Wl(i);return m=Qe(m),function(){return--m>0&&(T=v.apply(this,arguments)),m<=1&&(v=e),T}}var Jq=nr(function(m,v,T){var N=d;if(T.length){var V=mm(T,wx(Jq));N|=b}return lp(m,N,v,T,V)}),Upt=nr(function(m,v,T){var N=d|g;if(T.length){var V=mm(T,wx(Upt));N|=b}return lp(v,N,m,T,V)});function qpt(m,v,T){v=T?e:v;var N=lp(m,y,e,e,e,e,e,v);return N.placeholder=qpt.placeholder,N}function Gpt(m,v,T){v=T?e:v;var N=lp(m,x,e,e,e,e,e,v);return N.placeholder=Gpt.placeholder,N}function Wpt(m,v,T){var N,V,Y,J,it,ft,Dt=0,Ot=!1,Vt=!1,oe=!0;if(typeof m!="function")throw new Wl(i);v=Kl(v)||0,ei(T)&&(Ot=!!T.leading,Vt="maxWait"in T,Y=Vt?Xi(Kl(T.maxWait)||0,v):Y,oe="trailing"in T?!!T.trailing:oe);function Te(bi){var nu=N,pp=V;return N=V=e,Dt=bi,J=m.apply(pp,nu),J}function Ne(bi){return Dt=bi,it=zM(pr,v),Ot?Te(bi):J}function er(bi){var nu=bi-ft,pp=bi-Dt,udt=v-nu;return Vt?ra(udt,Y-pp):udt}function De(bi){var nu=bi-ft,pp=bi-Dt;return ft===e||nu>=v||nu<0||Vt&&pp>=Y}function pr(){var bi=xI();if(De(bi))return yr(bi);it=zM(pr,er(bi))}function yr(bi){return it=e,oe&&N?Te(bi):(N=V=e,J)}function $s(){it!==e&&ept(it),Dt=0,N=ft=V=it=e}function Na(){return it===e?J:yr(xI())}function Ks(){var bi=xI(),nu=De(bi);if(N=arguments,V=this,ft=bi,nu){if(it===e)return Ne(ft);if(Vt)return ept(it),it=zM(pr,v),Te(ft)}return it===e&&(it=zM(pr,v)),J}return Ks.cancel=$s,Ks.flush=Na,Ks}var V0e=nr(function(m,v){return Nft(m,1,v)}),U0e=nr(function(m,v,T){return Nft(m,Kl(v)||0,T)});function q0e(m){return lp(m,k)}function bI(m,v){if(typeof m!="function"||v!=null&&typeof v!="function")throw new Wl(i);var T=function(){var N=arguments,V=v?v.apply(this,N):N[0],Y=T.cache;if(Y.has(V))return Y.get(V);var J=m.apply(this,N);return T.cache=Y.set(V,J)||Y,J};return T.cache=new(bI.Cache||ap),T}bI.Cache=ap;function wI(m){if(typeof m!="function")throw new Wl(i);return function(){var v=arguments;switch(v.length){case 0:return!m.call(this);case 1:return!m.call(this,v[0]);case 2:return!m.call(this,v[0],v[1]);case 3:return!m.call(this,v[0],v[1],v[2])}return!m.apply(this,v)}}function G0e(m){return Vpt(2,m)}var W0e=Lme(function(m,v){v=v.length==1&&$e(v[0])?Kn(v[0],Ys(ke())):Kn(Ro(v,1),Ys(ke()));var T=v.length;return nr(function(N){for(var V=-1,Y=ra(N.length,T);++V<Y;)N[V]=v[V].call(this,N[V]);return Ws(m,this,N)})}),Qq=nr(function(m,v){var T=mm(v,wx(Qq));return lp(m,b,e,v,T)}),Ypt=nr(function(m,v){var T=mm(v,wx(Ypt));return lp(m,S,e,v,T)}),Y0e=cp(function(m,v){return lp(m,P,e,e,e,v)});function j0e(m,v){if(typeof m!="function")throw new Wl(i);return v=v===e?v:Qe(v),nr(m,v)}function X0e(m,v){if(typeof m!="function")throw new Wl(i);return v=v==null?0:Xi(Qe(v),0),nr(function(T){var N=T[v],V=bm(T,0,v);return N&&dm(V,N),Ws(m,this,V)})}function $0e(m,v,T){var N=!0,V=!0;if(typeof m!="function")throw new Wl(i);return ei(T)&&(N="leading"in T?!!T.leading:N,V="trailing"in T?!!T.trailing:V),Wpt(m,v,{leading:N,maxWait:v,trailing:V})}function K0e(m){return Hpt(m,1)}function Z0e(m,v){return Qq(zq(v),m)}function J0e(){if(!arguments.length)return[];var m=arguments[0];return $e(m)?m:[m]}function Q0e(m){return jl(m,h)}function t_e(m,v){return v=typeof v=="function"?v:e,jl(m,h,v)}function e_e(m){return jl(m,c|h)}function r_e(m,v){return v=typeof v=="function"?v:e,jl(m,c|h,v)}function n_e(m,v){return v==null||Rft(m,v,po(v))}function ru(m,v){return m===v||m!==m&&v!==v}var i_e=dI(Eq),o_e=dI(function(m,v){return m>=v}),l_=Bft(function(){return arguments}())?Bft:function(m){return si(m)&&un.call(m,"callee")&&!Eft.call(m,"callee")},$e=vt.isArray,a_e=aft?Ys(aft):dme;function ms(m){return m!=null&&SI(m.length)&&!hp(m)}function xi(m){return si(m)&&ms(m)}function s_e(m){return m===!0||m===!1||si(m)&&ka(m)==Kt}var wm=bde||uG,l_e=sft?Ys(sft):mme;function c_e(m){return si(m)&&m.nodeType===1&&!FM(m)}function u_e(m){if(m==null)return!0;if(ms(m)&&($e(m)||typeof m=="string"||typeof m.splice=="function"||wm(m)||Sx(m)||l_(m)))return!m.length;var v=na(m);if(v==q||v==Le)return!m.size;if(OM(m))return!Aq(m).length;for(var T in m)if(un.call(m,T))return!1;return!0}function h_e(m,v){return RM(m,v)}function f_e(m,v,T){T=typeof T=="function"?T:e;var N=T?T(m,v):e;return N===e?RM(m,v,e,T):!!N}function tG(m){if(!si(m))return!1;var v=ka(m);return v==X||v==ct||typeof m.message=="string"&&typeof m.name=="string"&&!FM(m)}function p_e(m){return typeof m=="number"&&Cft(m)}function hp(m){if(!ei(m))return!1;var v=ka(m);return v==et||v==dt||v==lt||v==ie}function jpt(m){return typeof m=="number"&&m==Qe(m)}function SI(m){return typeof m=="number"&&m>-1&&m%1==0&&m<=U}function ei(m){var v=typeof m;return m!=null&&(v=="object"||v=="function")}function si(m){return m!=null&&typeof m=="object"}var Xpt=lft?Ys(lft):_me;function d_e(m,v){return m===v||Cq(m,v,Gq(v))}function m_e(m,v,T){return T=typeof T=="function"?T:e,Cq(m,v,Gq(v),T)}function g_e(m){return $pt(m)&&m!=+m}function __e(m){if(tge(m))throw new We(n);return Hft(m)}function y_e(m){return m===null}function v_e(m){return m==null}function $pt(m){return typeof m=="number"||si(m)&&ka(m)==pt}function FM(m){if(!si(m)||ka(m)!=wt)return!1;var v=K6(m);if(v===null)return!0;var T=un.call(v,"constructor")&&v.constructor;return typeof T=="function"&&T instanceof T&&Y6.call(T)==mde}var eG=cft?Ys(cft):yme;function x_e(m){return jpt(m)&&m>=-U&&m<=U}var Kpt=uft?Ys(uft):vme;function MI(m){return typeof m=="string"||!$e(m)&&si(m)&&ka(m)==ar}function Xs(m){return typeof m=="symbol"||si(m)&&ka(m)==fr}var Sx=hft?Ys(hft):xme;function b_e(m){return m===e}function w_e(m){return si(m)&&na(m)==$}function S_e(m){return si(m)&&ka(m)==It}var M_e=dI(Pq),E_e=dI(function(m,v){return m<=v});function Zpt(m){if(!m)return[];if(ms(m))return MI(m)?tu(m):ds(m);if(EM&&m[EM])return nde(m[EM]());var v=na(m),T=v==q?gq:v==Le?q6:Mx;return T(m)}function fp(m){if(!m)return m===0?m:0;if(m=Kl(m),m===z||m===-z){var v=m<0?-1:1;return v*W}return m===m?m:0}function Qe(m){var v=fp(m),T=v%1;return v===v?T?v-T:v:0}function Jpt(m){return m?i_(Qe(m),0,rt):0}function Kl(m){if(typeof m=="number")return m;if(Xs(m))return Z;if(ei(m)){var v=typeof m.valueOf=="function"?m.valueOf():m;m=ei(v)?v+"":v}if(typeof m!="string")return m===0?m:+m;m=_ft(m);var T=_r.test(m);return T||Xn.test(m)?Hpe(m.slice(2),T?2:8):Xr.test(m)?Z:+m}function Qpt(m){return gh(m,gs(m))}function T_e(m){return m?i_(Qe(m),-U,U):m===0?m:0}function on(m){return m==null?"":js(m)}var C_e=xx(function(m,v){if(OM(v)||ms(v)){gh(v,po(v),m);return}for(var T in v)un.call(v,T)&&IM(m,T,v[T])}),tdt=xx(function(m,v){gh(v,gs(v),m)}),EI=xx(function(m,v,T,N){gh(v,gs(v),m,N)}),A_e=xx(function(m,v,T,N){gh(v,po(v),m,N)}),P_e=cp(wq);function I_e(m,v){var T=vx(m);return v==null?T:kft(T,v)}var L_e=nr(function(m,v){m=vn(m);var T=-1,N=v.length,V=N>2?v[2]:e;for(V&&Ra(v[0],v[1],V)&&(N=1);++T<N;)for(var Y=v[T],J=gs(Y),it=-1,ft=J.length;++it<ft;){var Dt=J[it],Ot=m[Dt];(Ot===e||ru(Ot,gx[Dt])&&!un.call(m,Dt))&&(m[Dt]=Y[Dt])}return m}),k_e=nr(function(m){return m.push(e,_pt),Ws(edt,e,m)});function R_e(m,v){return pft(m,ke(v,3),mh)}function N_e(m,v){return pft(m,ke(v,3),Mq)}function D_e(m,v){return m==null?m:Sq(m,ke(v,3),gs)}function O_e(m,v){return m==null?m:zft(m,ke(v,3),gs)}function z_e(m,v){return m&&mh(m,ke(v,3))}function F_e(m,v){return m&&Mq(m,ke(v,3))}function B_e(m){return m==null?[]:aI(m,po(m))}function H_e(m){return m==null?[]:aI(m,gs(m))}function rG(m,v,T){var N=m==null?e:o_(m,v);return N===e?T:N}function V_e(m,v){return m!=null&&xpt(m,v,ume)}function nG(m,v){return m!=null&&xpt(m,v,hme)}var U_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),m[v]=T},oG(_s)),q_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=j6.call(v)),un.call(m,v)?m[v].push(T):m[v]=[T]},ke),G_e=nr(kM);function po(m){return ms(m)?Ift(m):Aq(m)}function gs(m){return ms(m)?Ift(m,!0):bme(m)}function W_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){sp(T,v(N,V,Y),N)}),T}function Y_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){sp(T,V,v(N,V,Y))}),T}var j_e=xx(function(m,v,T){sI(m,v,T)}),edt=xx(function(m,v,T,N){sI(m,v,T,N)}),X_e=cp(function(m,v){var T={};if(m==null)return T;var N=!1;v=Kn(v,function(Y){return Y=xm(Y,m),N||(N=Y.length>1),Y}),gh(m,Uq(m),T),N&&(T=jl(T,c|u|h,Ume));for(var V=v.length;V--;)Nq(T,v[V]);return T});function $_e(m,v){return rdt(m,wI(ke(v)))}var K_e=cp(function(m,v){return m==null?{}:Sme(m,v)});function rdt(m,v){if(m==null)return{};var T=Kn(Uq(m),function(N){return[N]});return v=ke(v),jft(m,T,function(N,V){return v(N,V[0])})}function Z_e(m,v,T){v=xm(v,m);var N=-1,V=v.length;for(V||(V=1,m=e);++N<V;){var Y=m==null?e:m[_h(v[N])];Y===e&&(N=V,Y=T),m=hp(Y)?Y.call(m):Y}return m}function J_e(m,v,T){return m==null?m:NM(m,v,T)}function Q_e(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:NM(m,v,T,N)}var ndt=mpt(po),idt=mpt(gs);function tye(m,v,T){var N=$e(m),V=N||wm(m)||Sx(m);if(v=ke(v,4),T==null){var Y=m&&m.constructor;V?T=N?new Y:[]:ei(m)?T=hp(Y)?vx(K6(m)):{}:T={}}return(V?Gl:mh)(m,function(J,it,ft){return v(T,J,it,ft)}),T}function eye(m,v){return m==null?!0:Nq(m,v)}function rye(m,v,T){return m==null?m:Jft(m,v,zq(T))}function nye(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:Jft(m,v,zq(T),N)}function Mx(m){return m==null?[]:mq(m,po(m))}function iye(m){return m==null?[]:mq(m,gs(m))}function oye(m,v,T){return T===e&&(T=v,v=e),T!==e&&(T=Kl(T),T=T===T?T:0),v!==e&&(v=Kl(v),v=v===v?v:0),i_(Kl(m),v,T)}function aye(m,v,T){return v=fp(v),T===e?(T=v,v=0):T=fp(T),m=Kl(m),fme(m,v,T)}function sye(m,v,T){if(T&&typeof T!="boolean"&&Ra(m,v,T)&&(v=T=e),T===e&&(typeof v=="boolean"?(T=v,v=e):typeof m=="boolean"&&(T=m,m=e)),m===e&&v===e?(m=0,v=1):(m=fp(m),v===e?(v=m,m=0):v=fp(v)),m>v){var N=m;m=v,v=N}if(T||m%1||v%1){var V=Aft();return ra(m+V*(v-m+Bpe("1e-"+((V+"").length-1))),v)}return Lq(m,v)}var lye=bx(function(m,v,T){return v=v.toLowerCase(),m+(T?odt(v):v)});function odt(m){return iG(on(m).toLowerCase())}function adt(m){return m=on(m),m&&m.replace(hm,Jpe).replace(Ppe,"")}function cye(m,v,T){m=on(m),v=js(v);var N=m.length;T=T===e?N:i_(Qe(T),0,N);var V=T;return T-=v.length,T>=0&&m.slice(T,V)==v}function uye(m){return m=on(m),m&&Ar.test(m)?m.replace(yn,Qpe):m}function hye(m){return m=on(m),m&&ux.test(m)?m.replace(cn,"\\$&"):m}var fye=bx(function(m,v,T){return m+(T?"-":"")+v.toLowerCase()}),pye=bx(function(m,v,T){return m+(T?" ":"")+v.toLowerCase()}),dye=cpt("toLowerCase");function mye(m,v,T){m=on(m),v=Qe(v);var N=v?mx(m):0;if(!v||N>=v)return m;var V=(v-N)/2;return pI(tI(V),T)+m+pI(Q6(V),T)}function gye(m,v,T){m=on(m),v=Qe(v);var N=v?mx(m):0;return v&&N<v?m+pI(v-N,T):m}function _ye(m,v,T){m=on(m),v=Qe(v);var N=v?mx(m):0;return v&&N<v?pI(v-N,T)+m:m}function yye(m,v,T){return T||v==null?v=0:v&&(v=+v),Ede(on(m).replace(np,""),v||0)}function vye(m,v,T){return(T?Ra(m,v,T):v===e)?v=1:v=Qe(v),kq(on(m),v)}function xye(){var m=arguments,v=on(m[0]);return m.length<3?v:v.replace(m[1],m[2])}var bye=bx(function(m,v,T){return m+(T?"_":"")+v.toLowerCase()});function wye(m,v,T){return T&&typeof T!="number"&&Ra(m,v,T)&&(v=T=e),T=T===e?rt:T>>>0,T?(m=on(m),m&&(typeof v=="string"||v!=null&&!eG(v))&&(v=js(v),!v&&dx(m))?bm(tu(m),0,T):m.split(v,T)):[]}var Sye=bx(function(m,v,T){return m+(T?" ":"")+iG(v)});function Mye(m,v,T){return m=on(m),T=T==null?0:i_(Qe(T),0,m.length),v=js(v),m.slice(T,T+v.length)==v}function Eye(m,v,T){var N=G.templateSettings;T&&Ra(m,v,T)&&(v=e),m=on(m),v=EI({},v,N,gpt);var V=EI({},v.imports,N.imports,gpt),Y=po(V),J=mq(V,Y),it,ft,Dt=0,Ot=v.interpolate||mr,Vt="__p += '",oe=_q((v.escape||mr).source+"|"+Ot.source+"|"+(Ot===La?tr:mr).source+"|"+(v.evaluate||mr).source+"|$","g"),Te="//# sourceURL="+(un.call(v,"sourceURL")?(v.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++Npe+"]")+`
`;m.replace(oe,function(De,pr,yr,$s,Na,Ks){return yr||(yr=$s),Vt+=m.slice(Dt,Ks).replace(Bl,tde),pr&&(it=!0,Vt+=`' +
__e(`+pr+`) +
'`),Na&&(ft=!0,Vt+=`';
`+Na+`;
__p += '`),yr&&(Vt+=`' +
((__t = (`+yr+`)) == null ? '' : __t) +
'`),Dt=Ks+De.length,De}),Vt+=`';
`;var Ne=un.call(v,"variable")&&v.variable;if(!Ne)Vt=`with (obj) {
`+Vt+`
}
`;else if(Ve.test(Ne))throw new We(o);Vt=(ft?Vt.replace(Ce,""):Vt).replace(Pt,"$1").replace(Nt,"$1;"),Vt="function("+(Ne||"obj")+`) {
`+(Ne?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(it?", __e = _.escape":"")+(ft?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+Vt+`return __p
}`;var er=ldt(function(){return $r(Y,Te+"return "+Vt).apply(e,J)});if(er.source=Vt,tG(er))throw er;return er}function Tye(m){return on(m).toLowerCase()}function Cye(m){return on(m).toUpperCase()}function Aye(m,v,T){if(m=on(m),m&&(T||v===e))return _ft(m);if(!m||!(v=js(v)))return m;var N=tu(m),V=tu(v),Y=yft(N,V),J=vft(N,V)+1;return bm(N,Y,J).join("")}function Pye(m,v,T){if(m=on(m),m&&(T||v===e))return m.slice(0,bft(m)+1);if(!m||!(v=js(v)))return m;var N=tu(m),V=vft(N,tu(v))+1;return bm(N,0,V).join("")}function Iye(m,v,T){if(m=on(m),m&&(T||v===e))return m.replace(np,"");if(!m||!(v=js(v)))return m;var N=tu(m),V=yft(N,tu(v));return bm(N,V).join("")}function Lye(m,v){var T=O,N=D;if(ei(v)){var V="separator"in v?v.separator:V;T="length"in v?Qe(v.length):T,N="omission"in v?js(v.omission):N}m=on(m);var Y=m.length;if(dx(m)){var J=tu(m);Y=J.length}if(T>=Y)return m;var it=T-mx(N);if(it<1)return N;var ft=J?bm(J,0,it).join(""):m.slice(0,it);if(V===e)return ft+N;if(J&&(it+=ft.length-it),eG(V)){if(m.slice(it).search(V)){var Dt,Ot=ft;for(V.global||(V=_q(V.source,on(Ke.exec(V))+"g")),V.lastIndex=0;Dt=V.exec(Ot);)var Vt=Dt.index;ft=ft.slice(0,Vt===e?it:Vt)}}else if(m.indexOf(js(V),it)!=it){var oe=ft.lastIndexOf(V);oe>-1&&(ft=ft.slice(0,oe))}return ft+N}function kye(m){return m=on(m),m&&Wi.test(m)?m.replace(ze,sde):m}var Rye=bx(function(m,v,T){return m+(T?" ":"")+v.toUpperCase()}),iG=cpt("toUpperCase");function sdt(m,v,T){return m=on(m),v=T?e:v,v===e?rde(m)?ude(m):jpe(m):m.match(v)||[]}var ldt=nr(function(m,v){try{return Ws(m,e,v)}catch(T){return tG(T)?T:new We(T)}}),Nye=cp(function(m,v){return Gl(v,function(T){T=_h(T),sp(m,T,Jq(m[T],m))}),m});function Dye(m){var v=m==null?0:m.length,T=ke();return m=v?Kn(m,function(N){if(typeof N[1]!="function")throw new Wl(i);return[T(N[0]),N[1]]}):[],nr(function(N){for(var V=-1;++V<v;){var Y=m[V];if(Ws(Y[0],this,N))return Ws(Y[1],this,N)}})}function Oye(m){return sme(jl(m,c))}function oG(m){return function(){return m}}function zye(m,v){return m==null||m!==m?v:m}var Fye=hpt(),Bye=hpt(!0);function _s(m){return m}function aG(m){return Vft(typeof m=="function"?m:jl(m,c))}function Hye(m){return qft(jl(m,c))}function Vye(m,v){return Gft(m,jl(v,c))}var Uye=nr(function(m,v){return function(T){return kM(T,m,v)}}),qye=nr(function(m,v){return function(T){return kM(m,T,v)}});function sG(m,v,T){var N=po(v),V=aI(v,N);T==null&&!(ei(v)&&(V.length||!N.length))&&(T=v,v=m,m=this,V=aI(v,po(v)));var Y=!(ei(T)&&"chain"in T)||!!T.chain,J=hp(m);return Gl(V,function(it){var ft=v[it];m[it]=ft,J&&(m.prototype[it]=function(){var Dt=this.__chain__;if(Y||Dt){var Ot=m(this.__wrapped__),Vt=Ot.__actions__=ds(this.__actions__);return Vt.push({func:ft,args:arguments,thisArg:m}),Ot.__chain__=Dt,Ot}return ft.apply(m,dm([this.value()],arguments))})}),m}function Gye(){return fo._===this&&(fo._=gde),this}function lG(){}function Wye(m){return m=Qe(m),nr(function(v){return Wft(v,m)})}var Yye=Bq(Kn),jye=Bq(fft),Xye=Bq(uq);function cdt(m){return Yq(m)?hq(_h(m)):Mme(m)}function $ye(m){return function(v){return m==null?e:o_(m,v)}}var Kye=ppt(),Zye=ppt(!0);function cG(){return[]}function uG(){return!1}function Jye(){return{}}function Qye(){return""}function tve(){return!0}function eve(m,v){if(m=Qe(m),m<1||m>U)return[];var T=rt,N=ra(m,rt);v=ke(v),m-=rt;for(var V=dq(N,v);++T<m;)v(T);return V}function rve(m){return $e(m)?Kn(m,_h):Xs(m)?[m]:ds(Ppt(on(m)))}function nve(m){var v=++dde;return on(m)+v}var ive=fI(function(m,v){return m+v},0),ove=Hq("ceil"),ave=fI(function(m,v){return m/v},1),sve=Hq("floor");function lve(m){return m&&m.length?oI(m,_s,Eq):e}function cve(m,v){return m&&m.length?oI(m,ke(v,2),Eq):e}function uve(m){return mft(m,_s)}function hve(m,v){return mft(m,ke(v,2))}function fve(m){return m&&m.length?oI(m,_s,Pq):e}function pve(m,v){return m&&m.length?oI(m,ke(v,2),Pq):e}var dve=fI(function(m,v){return m*v},1),mve=Hq("round"),gve=fI(function(m,v){return m-v},0);function _ve(m){return m&&m.length?pq(m,_s):0}function yve(m,v){return m&&m.length?pq(m,ke(v,2)):0}return G.after=H0e,G.ary=Hpt,G.assign=C_e,G.assignIn=tdt,G.assignInWith=EI,G.assignWith=A_e,G.at=P_e,G.before=Vpt,G.bind=Jq,G.bindAll=Nye,G.bindKey=Upt,G.castArray=J0e,G.chain=zpt,G.chunk=sge,G.compact=lge,G.concat=cge,G.cond=Dye,G.conforms=Oye,G.constant=oG,G.countBy=_0e,G.create=I_e,G.curry=qpt,G.curryRight=Gpt,G.debounce=Wpt,G.defaults=L_e,G.defaultsDeep=k_e,G.defer=V0e,G.delay=U0e,G.difference=uge,G.differenceBy=hge,G.differenceWith=fge,G.drop=pge,G.dropRight=dge,G.dropRightWhile=mge,G.dropWhile=gge,G.fill=_ge,G.filter=v0e,G.flatMap=w0e,G.flatMapDeep=S0e,G.flatMapDepth=M0e,G.flatten=Rpt,G.flattenDeep=yge,G.flattenDepth=vge,G.flip=q0e,G.flow=Fye,G.flowRight=Bye,G.fromPairs=xge,G.functions=B_e,G.functionsIn=H_e,G.groupBy=E0e,G.initial=wge,G.intersection=Sge,G.intersectionBy=Mge,G.intersectionWith=Ege,G.invert=U_e,G.invertBy=q_e,G.invokeMap=C0e,G.iteratee=aG,G.keyBy=A0e,G.keys=po,G.keysIn=gs,G.map=vI,G.mapKeys=W_e,G.mapValues=Y_e,G.matches=Hye,G.matchesProperty=Vye,G.memoize=bI,G.merge=j_e,G.mergeWith=edt,G.method=Uye,G.methodOf=qye,G.mixin=sG,G.negate=wI,G.nthArg=Wye,G.omit=X_e,G.omitBy=$_e,G.once=G0e,G.orderBy=P0e,G.over=Yye,G.overArgs=W0e,G.overEvery=jye,G.overSome=Xye,G.partial=Qq,G.partialRight=Ypt,G.partition=I0e,G.pick=K_e,G.pickBy=rdt,G.property=cdt,G.propertyOf=$ye,G.pull=Pge,G.pullAll=Dpt,G.pullAllBy=Ige,G.pullAllWith=Lge,G.pullAt=kge,G.range=Kye,G.rangeRight=Zye,G.rearg=Y0e,G.reject=R0e,G.remove=Rge,G.rest=j0e,G.reverse=Kq,G.sampleSize=D0e,G.set=J_e,G.setWith=Q_e,G.shuffle=O0e,G.slice=Nge,G.sortBy=B0e,G.sortedUniq=Vge,G.sortedUniqBy=Uge,G.split=wye,G.spread=X0e,G.tail=qge,G.take=Gge,G.takeRight=Wge,G.takeRightWhile=Yge,G.takeWhile=jge,G.tap=l0e,G.throttle=$0e,G.thru=yI,G.toArray=Zpt,G.toPairs=ndt,G.toPairsIn=idt,G.toPath=rve,G.toPlainObject=Qpt,G.transform=tye,G.unary=K0e,G.union=Xge,G.unionBy=$ge,G.unionWith=Kge,G.uniq=Zge,G.uniqBy=Jge,G.uniqWith=Qge,G.unset=eye,G.unzip=Zq,G.unzipWith=Opt,G.update=rye,G.updateWith=nye,G.values=Mx,G.valuesIn=iye,G.without=t0e,G.words=sdt,G.wrap=Z0e,G.xor=e0e,G.xorBy=r0e,G.xorWith=n0e,G.zip=i0e,G.zipObject=o0e,G.zipObjectDeep=a0e,G.zipWith=s0e,G.entries=ndt,G.entriesIn=idt,G.extend=tdt,G.extendWith=EI,sG(G,G),G.add=ive,G.attempt=ldt,G.camelCase=lye,G.capitalize=odt,G.ceil=ove,G.clamp=oye,G.clone=Q0e,G.cloneDeep=e_e,G.cloneDeepWith=r_e,G.cloneWith=t_e,G.conformsTo=n_e,G.deburr=adt,G.defaultTo=zye,G.divide=ave,G.endsWith=cye,G.eq=ru,G.escape=uye,G.escapeRegExp=hye,G.every=y0e,G.find=x0e,G.findIndex=Lpt,G.findKey=R_e,G.findLast=b0e,G.findLastIndex=kpt,G.findLastKey=N_e,G.floor=sve,G.forEach=Fpt,G.forEachRight=Bpt,G.forIn=D_e,G.forInRight=O_e,G.forOwn=z_e,G.forOwnRight=F_e,G.get=rG,G.gt=i_e,G.gte=o_e,G.has=V_e,G.hasIn=nG,G.head=Npt,G.identity=_s,G.includes=T0e,G.indexOf=bge,G.inRange=aye,G.invoke=G_e,G.isArguments=l_,G.isArray=$e,G.isArrayBuffer=a_e,G.isArrayLike=ms,G.isArrayLikeObject=xi,G.isBoolean=s_e,G.isBuffer=wm,G.isDate=l_e,G.isElement=c_e,G.isEmpty=u_e,G.isEqual=h_e,G.isEqualWith=f_e,G.isError=tG,G.isFinite=p_e,G.isFunction=hp,G.isInteger=jpt,G.isLength=SI,G.isMap=Xpt,G.isMatch=d_e,G.isMatchWith=m_e,G.isNaN=g_e,G.isNative=__e,G.isNil=v_e,G.isNull=y_e,G.isNumber=$pt,G.isObject=ei,G.isObjectLike=si,G.isPlainObject=FM,G.isRegExp=eG,G.isSafeInteger=x_e,G.isSet=Kpt,G.isString=MI,G.isSymbol=Xs,G.isTypedArray=Sx,G.isUndefined=b_e,G.isWeakMap=w_e,G.isWeakSet=S_e,G.join=Tge,G.kebabCase=fye,G.last=$l,G.lastIndexOf=Cge,G.lowerCase=pye,G.lowerFirst=dye,G.lt=M_e,G.lte=E_e,G.max=lve,G.maxBy=cve,G.mean=uve,G.meanBy=hve,G.min=fve,G.minBy=pve,G.stubArray=cG,G.stubFalse=uG,G.stubObject=Jye,G.stubString=Qye,G.stubTrue=tve,G.multiply=dve,G.nth=Age,G.noConflict=Gye,G.noop=lG,G.now=xI,G.pad=mye,G.padEnd=gye,G.padStart=_ye,G.parseInt=yye,G.random=sye,G.reduce=L0e,G.reduceRight=k0e,G.repeat=vye,G.replace=xye,G.result=Z_e,G.round=mve,G.runInContext=ut,G.sample=N0e,G.size=z0e,G.snakeCase=bye,G.some=F0e,G.sortedIndex=Dge,G.sortedIndexBy=Oge,G.sortedIndexOf=zge,G.sortedLastIndex=Fge,G.sortedLastIndexBy=Bge,G.sortedLastIndexOf=Hge,G.startCase=Sye,G.startsWith=Mye,G.subtract=gve,G.sum=_ve,G.sumBy=yve,G.template=Eye,G.times=eve,G.toFinite=fp,G.toInteger=Qe,G.toLength=Jpt,G.toLower=Tye,G.toNumber=Kl,G.toSafeInteger=T_e,G.toString=on,G.toUpper=Cye,G.trim=Aye,G.trimEnd=Pye,G.trimStart=Iye,G.truncate=Lye,G.unescape=kye,G.uniqueId=nve,G.upperCase=Rye,G.upperFirst=iG,G.each=Fpt,G.eachRight=Bpt,G.first=Npt,sG(G,function(){var m={};return mh(G,function(v,T){un.call(G.prototype,T)||(m[T]=v)}),m}(),{chain:!1}),G.VERSION=t,Gl(["bind","bindKey","curry","curryRight","partial","partialRight"],function(m){G[m].placeholder=G}),Gl(["drop","take"],function(m,v){gr.prototype[m]=function(T){T=T===e?1:Xi(Qe(T),0);var N=this.__filtered__&&!v?new gr(this):this.clone();return N.__filtered__?N.__takeCount__=ra(T,N.__takeCount__):N.__views__.push({size:ra(T,rt),type:m+(N.__dir__<0?"Right":"")}),N},gr.prototype[m+"Right"]=function(T){return this.reverse()[m](T).reverse()}}),Gl(["filter","map","takeWhile"],function(m,v){var T=v+1,N=T==L||T==F;gr.prototype[m]=function(V){var Y=this.clone();return Y.__iteratees__.push({iteratee:ke(V,3),type:T}),Y.__filtered__=Y.__filtered__||N,Y}}),Gl(["head","last"],function(m,v){var T="take"+(v?"Right":"");gr.prototype[m]=function(){return this[T](1).value()[0]}}),Gl(["initial","tail"],function(m,v){var T="drop"+(v?"":"Right");gr.prototype[m]=function(){return this.__filtered__?new gr(this):this[T](1)}}),gr.prototype.compact=function(){return this.filter(_s)},gr.prototype.find=function(m){return this.filter(m).head()},gr.prototype.findLast=function(m){return this.reverse().find(m)},gr.prototype.invokeMap=nr(function(m,v){return typeof m=="function"?new gr(this):this.map(function(T){return kM(T,m,v)})}),gr.prototype.reject=function(m){return this.filter(wI(ke(m)))},gr.prototype.slice=function(m,v){m=Qe(m);var T=this;return T.__filtered__&&(m>0||v<0)?new gr(T):(m<0?T=T.takeRight(-m):m&&(T=T.drop(m)),v!==e&&(v=Qe(v),T=v<0?T.dropRight(-v):T.take(v-m)),T)},gr.prototype.takeRightWhile=function(m){return this.reverse().takeWhile(m).reverse()},gr.prototype.toArray=function(){return this.take(rt)},mh(gr.prototype,function(m,v){var T=/^(?:filter|find|map|reject)|While$/.test(v),N=/^(?:head|last)$/.test(v),V=G[N?"take"+(v=="last"?"Right":""):v],Y=N||/^find/.test(v);!V||(G.prototype[v]=function(){var J=this.__wrapped__,it=N?[1]:arguments,ft=J instanceof gr,Dt=it[0],Ot=ft||$e(J),Vt=function(pr){var yr=V.apply(G,dm([pr],it));return N&&oe?yr[0]:yr};Ot&&T&&typeof Dt=="function"&&Dt.length!=1&&(ft=Ot=!1);var oe=this.__chain__,Te=!!this.__actions__.length,Ne=Y&&!oe,er=ft&&!Te;if(!Y&&Ot){J=er?J:new gr(this);var De=m.apply(J,it);return De.__actions__.push({func:yI,args:[Vt],thisArg:e}),new Yl(De,oe)}return Ne&&er?m.apply(this,it):(De=this.thru(Vt),Ne?N?De.value()[0]:De.value():De)})}),Gl(["pop","push","shift","sort","splice","unshift"],function(m){var v=G6[m],T=/^(?:push|sort|unshift)$/.test(m)?"tap":"thru",N=/^(?:pop|shift)$/.test(m);G.prototype[m]=function(){var V=arguments;if(N&&!this.__chain__){var Y=this.value();return v.apply($e(Y)?Y:[],V)}return this[T](function(J){return v.apply($e(J)?J:[],V)})}}),mh(gr.prototype,function(m,v){var T=G[v];if(T){var N=T.name+"";un.call(yx,N)||(yx[N]=[]),yx[N].push({name:v,func:T})}}),yx[hI(e,g).name]=[{name:"wrapper",func:e}],gr.prototype.clone=kde,gr.prototype.reverse=Rde,gr.prototype.value=Nde,G.prototype.at=c0e,G.prototype.chain=u0e,G.prototype.commit=h0e,G.prototype.next=f0e,G.prototype.plant=d0e,G.prototype.reverse=m0e,G.prototype.toJSON=G.prototype.valueOf=G.prototype.value=g0e,G.prototype.first=G.prototype.head,EM&&(G.prototype[EM]=p0e),G},gm=hde();typeof define=="function"&&typeof define.amd=="object"&&define.amd?(fo._=gm,define(function(){return gm})):t_?((t_.exports=gm)._=gm,aq._=gm):fo._=gm}).call(Rx)});function __t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new J9(r)}function J9(e){this._=e}function g2e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _2e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function g_t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=m2e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var m2e,xs,y_t=M(()=>{m2e={value:function(){}};J9.prototype=__t.prototype={constructor:J9,on:function(e,t){var r=this._,n=g2e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_2e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=g_t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=g_t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new J9(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};xs=__t});var Rm=M(()=>{y_t()});function _Y(e){return+e}var Cvt=M(()=>{});function yY(e){return e*e}function vY(e){return e*(2-e)}function IL(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var Avt=M(()=>{});function xY(e){return e*e*e}function bY(e){return--e*e*e+1}function bs(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var Pvt=M(()=>{});var wY,SY,MY,LL,Ivt=M(()=>{wY=3,SY=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(wY),MY=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(wY),LL=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(wY)});function EY(e){return+e==1?1:1-Math.cos(e*kvt)}function TY(e){return Math.sin(e*kvt)}function kL(e){return(1-Math.cos(Lvt*e))/2}var Lvt,kvt,Rvt=M(()=>{Lvt=Math.PI,kvt=Lvt/2});function Oh(e){return(Math.pow(2,-10*e)-.0009765625)*1.0009775171065494}var CY=M(()=>{});function AY(e){return Oh(1-+e)}function PY(e){return 1-Oh(e)}function RL(e){return((e*=2)<=1?Oh(1-e):2-Oh(e-1))/2}var Nvt=M(()=>{CY()});function IY(e){return 1-Math.sqrt(1-e*e)}function LY(e){return Math.sqrt(1- --e*e)}function NL(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var Dvt=M(()=>{});function RY(e){return 1-I_(1-e)}function I_(e){return(e=+e)<kY?DL*e*e:e<uSe?DL*(e-=cSe)*e+hSe:e<pSe?DL*(e-=fSe)*e+dSe:DL*(e-=mSe)*e+gSe}function NY(e){return((e*=2)<=1?1-I_(1-e):I_(e-1)+1)/2}var kY,cSe,uSe,hSe,fSe,pSe,dSe,mSe,gSe,DL,Ovt=M(()=>{kY=.36363636363636365,cSe=6/11,uSe=8/11,hSe=3/4,fSe=9/11,pSe=10/11,dSe=15/16,mSe=21/22,gSe=63/64,DL=1/kY/kY});var DY,OY,zY,OL,zvt=M(()=>{DY=1.70158,OY=function e(t){t=+t;function r(n){return(n=+n)*n*(t*(n-1)+n)}return r.overshoot=e,r}(DY),zY=function e(t){t=+t;function r(n){return--n*n*((n+1)*t+n)+1}return r.overshoot=e,r}(DY),OL=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DY)});var Sb,FY,BY,HY,zL,VY,Fvt=M(()=>{CY();Sb=2*Math.PI,FY=1,BY=.3,HY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return t*Oh(- --o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),zL=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return 1-t*Oh(o=+o)*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY),VY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return((o=o*2-1)<0?t*Oh(-o)*Math.sin((n-o)/r):2-t*Oh(o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(FY,BY)});var Bvt={};Zs(Bvt,{easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>I_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>I_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>bs,easeCubicIn:()=>xY,easeCubicInOut:()=>bs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY});var L_=M(()=>{Cvt();Avt();Pvt();Ivt();Rvt();Nvt();Dvt();Ovt();zvt();Fvt()});function YL(){}function Qvt(e,t){var r=new YL;if(e instanceof YL)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var rl,Ji,jL=M(()=>{rl="$";YL.prototype=Qvt.prototype={constructor:YL,has:function(e){return rl+e in this},get:function(e){return this[rl+e]},set:function(e,t){return this[rl+e]=t,this},remove:function(e){var t=rl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===rl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===rl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===rl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===rl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===rl&&++e;return e},empty:function(){for(var e in this)if(e[0]===rl)return!1;return!0},each:function(e){for(var t in this)t[0]===rl&&e(this[t],t.slice(1),this)}};Ji=Qvt});function r1t(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=Ji(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,NSe,DSe)},map:function(s){return o(s,0,t1t,e1t)},entries:function(s){return a(o(s,0,t1t,e1t),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function NSe(){return{}}function DSe(e,t,r){e[t]=r}function t1t(){return Ji()}function e1t(e,t,r){e.set(t,r)}var n1t=M(()=>{jL()});function XL(){}function i1t(e,t){var r=new XL;if(e instanceof XL)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var R_,o1t,a1t=M(()=>{jL();R_=Ji.prototype;XL.prototype=i1t.prototype={constructor:XL,has:R_.has,add:function(e){return e+="",this[rl+e]=e,this},remove:R_.remove,clear:R_.clear,values:R_.keys,size:R_.size,empty:R_.empty,each:R_.each};o1t=i1t});function $L(e){var t=[];for(var r in e)t.push(r);return t}var s1t=M(()=>{});function l1t(e){var t=[];for(var r in e)t.push(e[r]);return t}var c1t=M(()=>{});function u1t(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var h1t=M(()=>{});var Tb=M(()=>{n1t();a1t();jL();s1t();c1t();h1t()});function v1t(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+'] || ""'}).join(",")+"}")}function GSe(e,t){var r=v1t(e);return function(n,i){return t(r(n),i,e)}}function y1t(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function Ss(e,t){var r=e+"",n=r.length;return n<t?new Array(t-n+1).join(0)+r:r}function WSe(e){return e<0?"-"+Ss(-e,6):e>9999?"+"+Ss(e,6):Ss(e,4)}function YSe(e){var t=e.getUTCHours(),r=e.getUTCMinutes(),n=e.getUTCSeconds(),i=e.getUTCMilliseconds();return isNaN(e)?"Invalid Date":WSe(e.getUTCFullYear(),4)+"-"+Ss(e.getUTCMonth()+1,2)+"-"+Ss(e.getUTCDate(),2)+(i?"T"+Ss(t,2)+":"+Ss(r,2)+":"+Ss(n,2)+"."+Ss(i,3)+"Z":n?"T"+Ss(t,2)+":"+Ss(r,2)+":"+Ss(n,2)+"Z":r||t?"T"+Ss(t,2)+":"+Ss(r,2)+"Z":"")}function Ym(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(h,f){var p,d,g=i(h,function(_,y){if(p)return p(_,y-1);d=_,p=f?GSe(_,f):v1t(_)});return g.columns=d||[],g}function i(h,f){var p=[],d=h.length,g=0,_=0,y,x=d<=0,b=!1;h.charCodeAt(d-1)===UE&&--d,h.charCodeAt(d-1)===nj&&--d;function S(){if(x)return ej;if(b)return b=!1,_1t;var P,k=g,O;if(h.charCodeAt(k)===rj){for(;g++<d&&h.charCodeAt(g)!==rj||h.charCodeAt(++g)===rj;);return(P=g)>=d?x=!0:(O=h.charCodeAt(g++))===UE?b=!0:O===nj&&(b=!0,h.charCodeAt(g)===UE&&++g),h.slice(k+1,P-1).replace(/""/g,'"')}for(;g<d;){if((O=h.charCodeAt(P=g++))===UE)b=!0;else if(O===nj)b=!0,h.charCodeAt(g)===UE&&++g;else if(O!==r)continue;return h.slice(k,P)}return x=!0,h.slice(k,d)}for(;(y=S())!==ej;){for(var C=[];y!==_1t&&y!==ej;)C.push(y),y=S();f&&(C=f(C,_++))==null||p.push(C)}return p}function o(h,f){return h.map(function(p){return f.map(function(d){return u(p[d])}).join(e)})}function a(h,f){return f==null&&(f=y1t(h)),[f.map(u).join(e)].concat(o(h,f)).join(`
`)}function s(h,f){return f==null&&(f=y1t(h)),o(h,f).join(`
`)}function l(h){return h.map(c).join(`
`)}function c(h){return h.map(u).join(e)}function u(h){return h==null?"":h instanceof Date?YSe(h):t.test(h+="")?'"'+h.replace(/"/g,'""')+'"':h}return{parse:n,parseRows:i,format:a,formatBody:s,formatRows:l,formatRow:c,formatValue:u}}var _1t,ej,rj,UE,nj,tk=M(()=>{_1t={},ej={},rj=34,UE=10,nj=13});var N_,Cb,x1t,b1t,w1t,S1t,M1t,E1t,T1t=M(()=>{tk();N_=Ym(","),Cb=N_.parse,x1t=N_.parseRows,b1t=N_.format,w1t=N_.formatBody,S1t=N_.formatRows,M1t=N_.formatRow,E1t=N_.formatValue});var D_,Ab,C1t,A1t,P1t,I1t,L1t,k1t,R1t=M(()=>{tk();D_=Ym("	"),Ab=D_.parse,C1t=D_.parseRows,A1t=D_.format,P1t=D_.formatBody,I1t=D_.formatRows,L1t=D_.formatRow,k1t=D_.formatValue});function ij(e){for(var t in e){var r=e[t].trim(),n,i;if(!r)r=null;else if(r==="true")r=!0;else if(r==="false")r=!1;else if(r==="NaN")r=NaN;else if(!isNaN(n=+r))r=n;else if(i=r.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))jSe&&!!i[4]&&!i[7]&&(r=r.replace(/-/g,"/").replace(/T/," ")),r=new Date(r);else continue;e[t]=r}return e}var jSe,N1t=M(()=>{jSe=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours()});var qE=M(()=>{tk();T1t();R1t();N1t()});var pe={};Zs(pe,{__assign:()=>y5e,__asyncDelegator:()=>A5e,__asyncGenerator:()=>C5e,__asyncValues:()=>P5e,__await:()=>U5,__awaiter:()=>S5e,__decorate:()=>x5e,__exportStar:()=>E5e,__extends:()=>_5e,__generator:()=>M5e,__makeTemplateObject:()=>I5e,__metadata:()=>w5e,__param:()=>b5e,__read:()=>nMt,__rest:()=>v5e,__spread:()=>T5e,__values:()=>y$});function _5e(e,t){g5e(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function v5e(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,n=Object.getOwnPropertySymbols(e);i<n.length;i++)t.indexOf(n[i])<0&&(r[n[i]]=e[n[i]]);return r}function x5e(e,t,r,n){var i=arguments.length,o=i<3?t:n===null?n=Object.getOwnPropertyDescriptor(t,r):n,a;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")o=Reflect.decorate(e,t,r,n);else for(var s=e.length-1;s>=0;s--)(a=e[s])&&(o=(i<3?a(o):i>3?a(t,r,o):a(t,r))||o);return i>3&&o&&Object.defineProperty(t,r,o),o}function b5e(e,t){return function(r,n){t(r,n,e)}}function w5e(e,t){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(e,t)}function S5e(e,t,r,n){return new(r||(r=Promise))(function(i,o){function a(c){try{l(n.next(c))}catch(u){o(u)}}function s(c){try{l(n.throw(c))}catch(u){o(u)}}function l(c){c.done?i(c.value):new r(function(u){u(c.value)}).then(a,s)}l((n=n.apply(e,t||[])).next())})}function M5e(e,t){var r={label:0,sent:function(){if(o[0]&1)throw o[1];return o[1]},trys:[],ops:[]},n,i,o,a;return a={next:s(0),throw:s(1),return:s(2)},typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(c){return function(u){return l([c,u])}}function l(c){if(n)throw new TypeError("Generator is already executing.");for(;r;)try{if(n=1,i&&(o=i[c[0]&2?"return":c[0]?"throw":"next"])&&!(o=o.call(i,c[1])).done)return o;switch(i=0,o&&(c=[0,o.value]),c[0]){case 0:case 1:o=c;break;case 4:return r.label++,{value:c[1],done:!1};case 5:r.label++,i=c[1],c=[0];continue;case 7:c=r.ops.pop(),r.trys.pop();continue;default:if(o=r.trys,!(o=o.length>0&&o[o.length-1])&&(c[0]===6||c[0]===2)){r=0;continue}if(c[0]===3&&(!o||c[1]>o[0]&&c[1]<o[3])){r.label=c[1];break}if(c[0]===6&&r.label<o[1]){r.label=o[1],o=c;break}if(o&&r.label<o[2]){r.label=o[2],r.ops.push(c);break}o[2]&&r.ops.pop(),r.trys.pop();continue}c=t.call(e,r)}catch(u){c=[6,u],i=0}finally{n=o=0}if(c[0]&5)throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}}function E5e(e,t){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}function y$(e){var t=typeof Symbol=="function"&&e[Symbol.iterator],r=0;return t?t.call(e):{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}function nMt(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),i,o=[],a;try{for(;(t===void 0||t-- >0)&&!(i=n.next()).done;)o.push(i.value)}catch(s){a={error:s}}finally{try{i&&!i.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return o}function T5e(){for(var e=[],t=0;t<arguments.length;t++)e=e.concat(nMt(arguments[t]));return e}function U5(e){return this instanceof U5?(this.v=e,this):new U5(e)}function C5e(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),i,o=[];return i={},a("next"),a("throw"),a("return"),i[Symbol.asyncIterator]=function(){return this},i;function a(f){n[f]&&(i[f]=function(p){return new Promise(function(d,g){o.push([f,p,d,g])>1||s(f,p)})})}function s(f,p){try{l(n[f](p))}catch(d){h(o[0][3],d)}}function l(f){f.value instanceof U5?Promise.resolve(f.value.v).then(c,u):h(o[0][2],f)}function c(f){s("next",f)}function u(f){s("throw",f)}function h(f,p){f(p),o.shift(),o.length&&s(o[0][0],o[0][1])}}function A5e(e){var t,r;return t={},n("next"),n("throw",function(i){throw i}),n("return"),t[Symbol.iterator]=function(){return this},t;function n(i,o){e[i]&&(t[i]=function(a){return(r=!r)?{value:U5(e[i](a)),done:i==="return"}:o?o(a):a})}}function P5e(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator];return t?t.call(e):typeof y$=="function"?y$(e):e[Symbol.iterator]()}function I5e(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}var g5e,y5e,de=M(()=>{g5e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])};y5e=Object.assign||function(t){for(var r,n=1,i=arguments.length;n<i;n++){r=arguments[n];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(t[o]=r[o])}return t}});var iMt,oMt=M(()=>{iMt="4.13.0"});function _c(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var dy=M(()=>{});function aR(e){return e.length===1&&(e=L5e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function L5e(e){return function(t,r){return _c(e(t),r)}}var v$=M(()=>{dy()});var aMt,x$,sMt,sR,b$=M(()=>{dy();v$();aMt=aR(_c),x$=aMt.right,sMt=aMt.left,sR=x$});function lMt(e,t){t==null&&(t=w$);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function w$(e,t){return[e,t]}var S$=M(()=>{});function cMt(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=w$),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}var uMt=M(()=>{S$()});function hMt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var fMt=M(()=>{});function sl(e){return e===null?NaN:+e}var l2=M(()=>{});function lR(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=sl(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=sl(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}var M$=M(()=>{l2()});function cR(e,t){var r=lR(e,t);return r&&Math.sqrt(r)}var E$=M(()=>{M$()});function uR(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var T$=M(()=>{});var pMt,dMt,mMt,C$=M(()=>{pMt=Array.prototype,dMt=pMt.slice,mMt=pMt.map});function q5(e){return function(){return e}}var gMt=M(()=>{});function _Mt(e){return e}var yMt=M(()=>{});function hR(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var A$=M(()=>{});function vMt(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=k$(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function k$(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=P$?10:o>=I$?5:o>=L$?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=P$?10:o>=I$?5:o>=L$?2:1)}function fR(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=P$?i*=10:o>=I$?i*=5:o>=L$&&(i*=2),t<e?-i:i}var P$,I$,L$,R$=M(()=>{P$=Math.sqrt(50),I$=Math.sqrt(10),L$=Math.sqrt(2)});function pR(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}var N$=M(()=>{});function xMt(){var e=_Mt,t=uR,r=pR;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=fR(u,h,f),f=hR(Math.ceil(u/f)*f,Math.floor(h/f)*f,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[sR(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:q5(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:q5([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?q5(dMt.call(i)):q5(i),n):r},n}var bMt=M(()=>{C$();b$();gMt();T$();yMt();A$();R$();N$()});function my(e,t,r){if(r==null&&(r=sl),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var dR=M(()=>{l2()});function wMt(e,t,r){return e=mMt.call(e,sl).sort(_c),Math.ceil((r-t)/(2*(my(e,.75)-my(e,.25))*Math.pow(e.length,-1/3)))}var SMt=M(()=>{C$();dy();l2();dR()});function MMt(e,t,r){return Math.ceil((r-t)/(3.5*cR(e)*Math.pow(e.length,-1/3)))}var EMt=M(()=>{E$()});function TMt(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}var CMt=M(()=>{});function AMt(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=sl(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=sl(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}var PMt=M(()=>{l2()});function IMt(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=sl(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=sl(t(e[n],n,e)))||o.push(i);return my(o.sort(_c),.5)}var LMt=M(()=>{dy();l2();dR()});function kMt(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var RMt=M(()=>{});function mR(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}var D$=M(()=>{});function NMt(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}var DMt=M(()=>{});function OMt(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=_c);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}var zMt=M(()=>{dy()});function FMt(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}var BMt=M(()=>{});function HMt(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}var VMt=M(()=>{});function gR(e){if(!(o=e.length))return[];for(var t=-1,r=mR(e,k5e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function k5e(e){return e.length}var O$=M(()=>{D$()});function UMt(){return gR(arguments)}var qMt=M(()=>{O$()});var GMt=M(()=>{b$();dy();v$();uMt();fMt();E$();T$();bMt();SMt();EMt();N$();CMt();PMt();LMt();RMt();D$();S$();DMt();dR();A$();zMt();BMt();VMt();R$();O$();M$();qMt()});var _R,WMt=M(()=>{_R=Array.prototype.slice});function YMt(e){return e}var jMt=M(()=>{});function R5e(e){return"translate("+(e+.5)+",0)"}function N5e(e){return"translate(0,"+(e+.5)+")"}function D5e(e){return function(t){return+e(t)}}function O5e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function z5e(){return!this.__axis}function xR(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===yR||e===G5?-1:1,c=e===G5||e===vR?"x":"y",u=e===yR||e===z$?R5e:N5e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):YMt:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?O5e:D5e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","#000").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","#000").attr(c,l*g).attr("dy",e===yR?"0em":e===z$?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",XMt).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",XMt).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===G5||e==vR?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M"+y+","+l*a+"V0.5H"+x+"V"+l*a),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(z5e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===vR?"start":e===G5?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=_R.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:_R.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:_R.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function $Mt(e){return xR(yR,e)}function KMt(e){return xR(vR,e)}function ZMt(e){return xR(z$,e)}function JMt(e){return xR(G5,e)}var yR,vR,z$,G5,XMt,QMt=M(()=>{WMt();jMt();yR=1,vR=2,z$=3,G5=4,XMt=1e-6});var tEt=M(()=>{QMt()});function rEt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new bR(r)}function bR(e){this._=e}function B5e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function H5e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function eEt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=F5e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var F5e,W5,nEt=M(()=>{F5e={value:function(){}};bR.prototype=rEt.prototype={constructor:bR,on:function(e,t){var r=this._,n=B5e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=H5e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=eEt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=eEt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new bR(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};W5=rEt});var F$=M(()=>{nEt()});var wR,B$,H$=M(()=>{wR="http://www.w3.org/1999/xhtml",B$={svg:"http://www.w3.org/2000/svg",xhtml:wR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Up(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),B$.hasOwnProperty(t)?{space:B$[t],local:e}:e}var SR=M(()=>{H$()});function V5e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===wR&&t.documentElement.namespaceURI===wR?t.createElement(e):t.createElementNS(r,e)}}function U5e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function MR(e){var t=Up(e);return(t.local?U5e:V5e)(t)}var V$=M(()=>{SR();H$()});function q5e(){}function gy(e){return e==null?q5e:function(){return this.querySelector(e)}}var ER=M(()=>{});function iEt(e){typeof e!="function"&&(e=gy(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new fi(n,this._parents)}var oEt=M(()=>{wu();ER()});function G5e(){return[]}function Y5(e){return e==null?G5e:function(){return this.querySelectorAll(e)}}var U$=M(()=>{});function aEt(e){typeof e!="function"&&(e=Y5(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new fi(n,i)}var sEt=M(()=>{wu();U$()});function j5(e){return function(){return this.matches(e)}}var q$=M(()=>{});function lEt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new fi(n,this._parents)}var cEt=M(()=>{wu();q$()});function TR(e){return new Array(e.length)}var G$=M(()=>{});function uEt(){return new fi(this._enter||this._groups.map(TR),this._parents)}function X5(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var W$=M(()=>{G$();wu();X5.prototype={constructor:X5,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function hEt(e){return function(){return e}}var fEt=M(()=>{});function W5e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new X5(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function Y5e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=pEt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=pEt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new X5(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function dEt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?Y5e:W5e,n=this._parents,i=this._groups;typeof e!="function"&&(e=hEt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new fi(a,n),a._enter=s,a._exit=l,a}var pEt,mEt=M(()=>{wu();W$();fEt();pEt="$"});function gEt(){return new fi(this._exit||this._groups.map(TR),this._parents)}var _Et=M(()=>{G$();wu()});function yEt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var vEt=M(()=>{});function xEt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new fi(a,this._parents)}var bEt=M(()=>{wu()});function wEt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var SEt=M(()=>{});function MEt(e){e||(e=j5e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new fi(i,this._parents).order()}function j5e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var EEt=M(()=>{wu()});function TEt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var CEt=M(()=>{});function AEt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var PEt=M(()=>{});function IEt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var LEt=M(()=>{});function kEt(){var e=0;return this.each(function(){++e}),e}var REt=M(()=>{});function NEt(){return!this.node()}var DEt=M(()=>{});function OEt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var zEt=M(()=>{});function X5e(e){return function(){this.removeAttribute(e)}}function $5e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function K5e(e,t){return function(){this.setAttribute(e,t)}}function Z5e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function J5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function Q5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function FEt(e,t){var r=Up(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?$5e:X5e:typeof t=="function"?r.local?Q5e:J5e:r.local?Z5e:K5e)(r,t))}var BEt=M(()=>{SR()});function CR(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Y$=M(()=>{});function tTe(e){return function(){this.style.removeProperty(e)}}function eTe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function rTe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function HEt(e,t,r){return arguments.length>1?this.each((t==null?tTe:typeof t=="function"?rTe:eTe)(e,t,r==null?"":r)):sg(this.node(),e)}function sg(e,t){return e.style.getPropertyValue(t)||CR(e).getComputedStyle(e,null).getPropertyValue(t)}var j$=M(()=>{Y$()});function nTe(e){return function(){delete this[e]}}function iTe(e,t){return function(){this[e]=t}}function oTe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function VEt(e,t){return arguments.length>1?this.each((t==null?nTe:typeof t=="function"?oTe:iTe)(e,t)):this.node()[e]}var UEt=M(()=>{});function qEt(e){return e.trim().split(/^|\s+/)}function X$(e){return e.classList||new GEt(e)}function GEt(e){this._node=e,this._names=qEt(e.getAttribute("class")||"")}function WEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function YEt(e,t){for(var r=X$(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function aTe(e){return function(){WEt(this,e)}}function sTe(e){return function(){YEt(this,e)}}function lTe(e,t){return function(){(t.apply(this,arguments)?WEt:YEt)(this,e)}}function jEt(e,t){var r=qEt(e+"");if(arguments.length<2){for(var n=X$(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?lTe:t?aTe:sTe)(r,t))}var XEt=M(()=>{GEt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function cTe(){this.textContent=""}function uTe(e){return function(){this.textContent=e}}function hTe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function $Et(e){return arguments.length?this.each(e==null?cTe:(typeof e=="function"?hTe:uTe)(e)):this.node().textContent}var KEt=M(()=>{});function fTe(){this.innerHTML=""}function pTe(e){return function(){this.innerHTML=e}}function dTe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function ZEt(e){return arguments.length?this.each(e==null?fTe:(typeof e=="function"?dTe:pTe)(e)):this.node().innerHTML}var JEt=M(()=>{});function mTe(){this.nextSibling&&this.parentNode.appendChild(this)}function QEt(){return this.each(mTe)}var t5t=M(()=>{});function gTe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function e5t(){return this.each(gTe)}var r5t=M(()=>{});function n5t(e){var t=typeof e=="function"?e:MR(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var i5t=M(()=>{V$()});function _Te(){return null}function o5t(e,t){var r=typeof e=="function"?e:MR(e),n=t==null?_Te:typeof t=="function"?t:gy(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var a5t=M(()=>{V$();ER()});function yTe(){var e=this.parentNode;e&&e.removeChild(this)}function s5t(){return this.each(yTe)}var l5t=M(()=>{});function vTe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function xTe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function c5t(e){return this.select(e?xTe:vTe)}var u5t=M(()=>{});function h5t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var f5t=M(()=>{});function bTe(e,t,r){return e=m5t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function m5t(e,t,r){return function(n){var i=wr;wr=n;try{e.call(this,this.__data__,t,r)}finally{wr=i}}}function wTe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function STe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function MTe(e,t,r){var n=d5t.hasOwnProperty(e.type)?bTe:m5t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function g5t(e,t,r){var n=wTe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?MTe:STe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function $$(e,t,r,n){var i=wr;e.sourceEvent=wr,wr=e;try{return t.apply(r,n)}finally{wr=i}}var d5t,wr,p5t,AR=M(()=>{d5t={},wr=null;typeof document!="undefined"&&(p5t=document.documentElement,"onmouseenter"in p5t||(d5t={mouseenter:"mouseover",mouseleave:"mouseout"}))});function _5t(e,t,r){var n=CR(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function ETe(e,t){return function(){return _5t(this,e,t)}}function TTe(e,t){return function(){return _5t(this,e,t.apply(this,arguments))}}function y5t(e,t){return this.each((typeof t=="function"?TTe:ETe)(e,t))}var v5t=M(()=>{Y$()});function fi(e,t){this._groups=e,this._parents=t}function x5t(){return new fi([[document.documentElement]],K$)}var K$,qp,wu=M(()=>{oEt();sEt();cEt();mEt();W$();_Et();vEt();bEt();SEt();EEt();CEt();PEt();LEt();REt();DEt();zEt();BEt();j$();UEt();XEt();KEt();JEt();t5t();r5t();i5t();a5t();l5t();u5t();f5t();AR();v5t();K$=[null];fi.prototype=x5t.prototype={constructor:fi,select:iEt,selectAll:aEt,filter:lEt,data:dEt,enter:uEt,exit:gEt,join:yEt,merge:xEt,order:wEt,sort:MEt,call:TEt,nodes:AEt,node:IEt,size:kEt,empty:NEt,each:OEt,attr:FEt,style:HEt,property:VEt,classed:jEt,text:$Et,html:ZEt,raise:QEt,lower:e5t,append:n5t,insert:o5t,remove:s5t,clone:c5t,datum:h5t,on:g5t,dispatch:y5t};qp=x5t});function Gp(e){return typeof e=="string"?new fi([[document.querySelector(e)]],[document.documentElement]):new fi([[e]],K$)}var b5t=M(()=>{wu()});function w5t(){for(var e=wr,t;t=e.sourceEvent;)e=t;return e}var S5t=M(()=>{AR()});function M5t(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var E5t=M(()=>{});function PR(e){var t=w5t();return t.changedTouches&&(t=t.changedTouches[0]),M5t(e,t)}var T5t=M(()=>{S5t();E5t()});var Ts=M(()=>{q$();T5t();SR();b5t();wu();ER();U$();j$();AR()});function IR(){wr.preventDefault(),wr.stopImmediatePropagation()}var C5t=M(()=>{Ts()});function Z$(e){var t=e.document.documentElement,r=Gp(e).on("dragstart.drag",IR,!0);"onselectstart"in t?r.on("selectstart.drag",IR,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function J$(e,t){var r=e.document.documentElement,n=Gp(e).on("dragstart.drag",null);t&&(n.on("click.drag",IR,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var A5t=M(()=>{Ts();C5t()});var P5t=M(()=>{A5t()});function LR(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Q$(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var I5t=M(()=>{});function Z5(){}function k5t(){return this.rgb().formatHex()}function NTe(){return F5t(this).formatHsl()}function R5t(){return this.rgb().formatRgb()}function Su(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=CTe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?N5t(t):r===3?new ll(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?kR(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?kR(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=ATe.exec(e))?new ll(t[1],t[2],t[3],1):(t=PTe.exec(e))?new ll(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=ITe.exec(e))?kR(t[1],t[2],t[3],t[4]):(t=LTe.exec(e))?kR(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=kTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,1):(t=RTe.exec(e))?z5t(t[1],t[2]/100,t[3]/100,t[4]):L5t.hasOwnProperty(e)?N5t(L5t[e]):e==="transparent"?new ll(NaN,NaN,NaN,0):null}function N5t(e){return new ll(e>>16&255,e>>8&255,e&255,1)}function kR(e,t,r,n){return n<=0&&(e=t=r=NaN),new ll(e,t,r,n)}function DTe(e){return e instanceof Z5||(e=Su(e)),e?(e=e.rgb(),new ll(e.r,e.g,e.b,e.opacity)):new ll}function u2(e,t,r,n){return arguments.length===1?DTe(e):new ll(e,t,r,n==null?1:n)}function ll(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function D5t(){return"#"+tK(this.r)+tK(this.g)+tK(this.b)}function O5t(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function tK(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function z5t(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Zh(e,t,r,n)}function F5t(e){if(e instanceof Zh)return new Zh(e.h,e.s,e.l,e.opacity);if(e instanceof Z5||(e=Su(e)),!e)return new Zh;if(e instanceof Zh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Zh(a,s,l,e.opacity)}function B5t(e,t,r,n){return arguments.length===1?F5t(e):new Zh(e,t,r,n==null?1:n)}function Zh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function eK(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var $5,RR,c2,K5,Jh,CTe,ATe,PTe,ITe,LTe,kTe,RTe,L5t,H5t=M(()=>{I5t();$5=.7,RR=1/$5,c2="\\s*([+-]?\\d+)\\s*",K5="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Jh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",CTe=/^#([0-9a-f]{3,8})$/,ATe=new RegExp("^rgb\\("+[c2,c2,c2]+"\\)$"),PTe=new RegExp("^rgb\\("+[Jh,Jh,Jh]+"\\)$"),ITe=new RegExp("^rgba\\("+[c2,c2,c2,K5]+"\\)$"),LTe=new RegExp("^rgba\\("+[Jh,Jh,Jh,K5]+"\\)$"),kTe=new RegExp("^hsl\\("+[K5,Jh,Jh]+"\\)$"),RTe=new RegExp("^hsla\\("+[K5,Jh,Jh,K5]+"\\)$"),L5t={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};LR(Z5,Su,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:k5t,formatHex:k5t,formatHsl:NTe,formatRgb:R5t,toString:R5t});LR(ll,u2,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new ll(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new ll(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:D5t,formatHex:D5t,formatRgb:O5t,toString:O5t}));LR(Zh,B5t,Q$(Z5,{brighter:function(e){return e=e==null?RR:Math.pow(RR,e),new Zh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?$5:Math.pow($5,e),new Zh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ll(eK(e>=240?e-240:e+120,i,n),eK(e,i,n),eK(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var NR=M(()=>{H5t()});function rK(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function V5t(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return rK((r-n/t)*t,a,i,o,s)}}var nK=M(()=>{});function U5t(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return rK((r-n/t)*t,i,o,a,s)}}var q5t=M(()=>{nK()});function J5(e){return function(){return e}}var iK=M(()=>{});function OTe(e,t){return function(r){return e+r*t}}function zTe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function G5t(e){return(e=+e)==1?DR:function(t,r){return r-t?zTe(t,r,e):J5(isNaN(t)?r:t)}}function DR(e,t){var r=t-e;return r?OTe(e,r):J5(isNaN(e)?t:e)}var W5t=M(()=>{iK()});function Y5t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=u2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var _y,FTe,BTe,oK=M(()=>{NR();nK();q5t();W5t();_y=function e(t){var r=G5t(t);function n(i,o){var a=r((i=u2(i)).r,(o=u2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=DR(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);FTe=Y5t(V5t),BTe=Y5t(U5t)});function j5t(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function X5t(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var $5t=M(()=>{});function K5t(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=yy(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var Z5t=M(()=>{OR()});function J5t(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var Q5t=M(()=>{});function qa(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var Q5=M(()=>{});function tTt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=yy(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var eTt=M(()=>{OR()});function HTe(e){return function(){return e}}function VTe(e){return function(t){return e(t)+""}}function tT(e,t){var r=sK.lastIndex=aK.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=sK.exec(e))&&(i=aK.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:qa(n,i)})),r=aK.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?VTe(l[0].x):HTe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var sK,aK,lK=M(()=>{Q5();sK=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,aK=new RegExp(sK.source,"g")});function yy(e,t){var r=typeof t,n;return t==null||r==="boolean"?J5(t):(r==="number"?qa:r==="string"?(n=Su(t))?(t=n,_y):tT:t instanceof Su?_y:t instanceof Date?J5t:X5t(t)?j5t:Array.isArray(t)?K5t:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?tTt:qa)(e,t)}var OR=M(()=>{NR();oK();Z5t();Q5t();Q5();eTt();lK();iK();$5t()});function cK(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*rTt,skewX:Math.atan(l)*rTt,scaleX:a,scaleY:s}}var rTt,zR,nTt=M(()=>{rTt=180/Math.PI,zR={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function oTt(e){return e==="none"?zR:(eT||(eT=document.createElement("DIV"),uK=document.documentElement,iTt=document.defaultView),eT.style.transform=e,e=iTt.getComputedStyle(uK.appendChild(eT),null).getPropertyValue("transform"),uK.removeChild(eT),e=e.slice(7,-1).split(","),cK(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function aTt(e){return e==null?zR:(FR||(FR=document.createElementNS("http://www.w3.org/2000/svg","g")),FR.setAttribute("transform",e),(e=FR.transform.baseVal.consolidate())?(e=e.matrix,cK(e.a,e.b,e.c,e.d,e.e,e.f)):zR)}var eT,uK,iTt,FR,sTt=M(()=>{nTt()});function lTt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:qa(c,h)},{i:g-2,x:qa(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:qa(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:qa(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:qa(c,h)},{i:g-2,x:qa(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var hK,fK,cTt=M(()=>{Q5();sTt();hK=lTt(oTt,"px, ","px)","deg)"),fK=lTt(aTt,", ",")",")")});var rT=M(()=>{OR();Q5();lK();cTt();oK()});function f2(){return vy||(fTt(UTe),vy=aT.now()+VR)}function UTe(){vy=0}function sT(){this._call=this._time=this._next=null}function UR(e,t,r){var n=new sT;return n.restart(e,t,r),n}function pTt(){f2(),++h2;for(var e=BR,t;e;)(t=vy-e._time)>=0&&e._call.call(null,t),e=e._next;--h2}function uTt(){vy=(HR=aT.now())+VR,h2=iT=0;try{pTt()}finally{h2=0,GTe(),vy=0}}function qTe(){var e=aT.now(),t=e-HR;t>hTt&&(VR-=t,HR=e)}function GTe(){for(var e,t=BR,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:BR=r);oT=e,pK(n)}function pK(e){if(!h2){iT&&(iT=clearTimeout(iT));var t=e-vy;t>24?(e<1/0&&(iT=setTimeout(uTt,e-aT.now()-VR)),nT&&(nT=clearInterval(nT))):(nT||(HR=aT.now(),nT=setInterval(qTe,hTt)),h2=1,fTt(uTt))}}var h2,iT,nT,hTt,BR,oT,HR,vy,VR,aT,fTt,dK=M(()=>{h2=0,iT=0,nT=0,hTt=1e3,HR=0,vy=0,VR=0,aT=typeof performance=="object"&&performance.now?performance:Date,fTt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};sT.prototype=UR.prototype={constructor:sT,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?f2():+r)+(t==null?0:+t),!this._next&&oT!==this&&(oT?oT._next=this:BR=this,oT=this),this._call=e,this._time=r,pK()},stop:function(){this._call&&(this._call=null,this._time=1/0,pK())}}});function qR(e,t,r){var n=new sT;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var dTt=M(()=>{dK()});var mK=M(()=>{dK();dTt()});function lg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;jTe(e,r,{name:t,index:n,group:i,on:WTe,tween:YTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:gTt})}function cT(e,t){var r=Qi(e,t);if(r.state>gTt)throw new Error("too late; already scheduled");return r}function Ga(e,t){var r=Qi(e,t);if(r.state>GR)throw new Error("too late; already running");return r}function Qi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function jTe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=UR(o,0,r.time);function o(c){r.state=gK,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==gK)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===GR)return qR(a);p.state===mTt?(p.state=lT,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=lT,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(qR(function(){r.state===GR&&(r.state=mTt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=WR,r.on.call("start",e,e.__data__,r.index,r.group),r.state===WR){for(r.state=GR,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=YR,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===YR&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=lT,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var WTe,YTe,gTt,gK,WR,GR,mTt,YR,lT,Cs=M(()=>{F$();mK();WTe=W5("start","end","cancel","interrupt"),YTe=[],gTt=0,gK=1,WR=2,GR=3,mTt=4,YR=5,lT=6});function p2(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>WR&&n.state<YR,n.state=lT,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var _K=M(()=>{Cs()});function _Tt(e){return this.each(function(){p2(this,e)})}var yTt=M(()=>{_K()});function XTe(e,t){var r,n;return function(){var i=Ga(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function $Te(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Ga(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function vTt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Qi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?XTe:$Te)(r,e,t))}function d2(e,t,r){var n=e._id;return e.each(function(){var i=Ga(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Qi(i,n).value[t]}}var uT=M(()=>{Cs()});function jR(e,t){var r;return(typeof t=="number"?qa:t instanceof Su?_y:(r=Su(t))?(t=r,_y):tT)(e,t)}var yK=M(()=>{NR();rT()});function KTe(e){return function(){this.removeAttribute(e)}}function ZTe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function JTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function QTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function tCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function eCe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function xTt(e,t){var r=Up(e),n=r==="transform"?fK:jR;return this.attrTween(e,typeof t=="function"?(r.local?eCe:tCe)(r,n,d2(this,"attr."+e,t)):t==null?(r.local?ZTe:KTe)(r):(r.local?QTe:JTe)(r,n,t))}var bTt=M(()=>{rT();Ts();uT();yK()});function rCe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function nCe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function iCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&nCe(e,o)),r}return i._value=t,i}function oCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&rCe(e,o)),r}return i._value=t,i}function wTt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Up(e);return this.tween(r,(n.local?iCe:oCe)(n,t))}var STt=M(()=>{Ts()});function aCe(e,t){return function(){cT(this,e).delay=+t.apply(this,arguments)}}function sCe(e,t){return t=+t,function(){cT(this,e).delay=t}}function MTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?aCe:sCe)(t,e)):Qi(this.node(),t).delay}var ETt=M(()=>{Cs()});function lCe(e,t){return function(){Ga(this,e).duration=+t.apply(this,arguments)}}function cCe(e,t){return t=+t,function(){Ga(this,e).duration=t}}function TTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?lCe:cCe)(t,e)):Qi(this.node(),t).duration}var CTt=M(()=>{Cs()});function uCe(e,t){if(typeof t!="function")throw new Error;return function(){Ga(this,e).ease=t}}function ATt(e){var t=this._id;return arguments.length?this.each(uCe(t,e)):Qi(this.node(),t).ease}var PTt=M(()=>{Cs()});function ITt(e){typeof e!="function"&&(e=j5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new ha(n,this._parents,this._name,this._id)}var LTt=M(()=>{Ts();Wp()});function kTt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new ha(a,this._parents,this._name,this._id)}var RTt=M(()=>{Wp()});function hCe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function fCe(e,t,r){var n,i,o=hCe(t)?cT:Ga;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function NTt(e,t){var r=this._id;return arguments.length<2?Qi(this.node(),r).on.on(e):this.each(fCe(r,e,t))}var DTt=M(()=>{Cs()});function pCe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function OTt(){return this.on("end.remove",pCe(this._id))}var zTt=M(()=>{});function FTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=gy(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,lg(c[f],t,r,f,c,Qi(u,r)));return new ha(o,this._parents,t,r)}var BTt=M(()=>{Ts();Wp();Cs()});function HTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Y5(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Qi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&lg(p,t,r,g,f,d);o.push(f),a.push(u)}return new ha(o,a,t,r)}var VTt=M(()=>{Ts();Wp();Cs()});function UTt(){return new dCe(this._groups,this._parents)}var dCe,qTt=M(()=>{Ts();dCe=qp.prototype.constructor});function mCe(e,t){var r,n,i;return function(){var o=sg(this,e),a=(this.style.removeProperty(e),sg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function GTt(e){return function(){this.style.removeProperty(e)}}function gCe(e,t,r){var n,i=r+"",o;return function(){var a=sg(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function _Ce(e,t,r){var n,i,o;return function(){var a=sg(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),sg(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function yCe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Ga(this,e),c=l.on,u=l.value[o]==null?s||(s=GTt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function WTt(e,t,r){var n=(e+="")=="transform"?hK:jR;return t==null?this.styleTween(e,mCe(e,n)).on("end.style."+e,GTt(e)):typeof t=="function"?this.styleTween(e,_Ce(e,n,d2(this,"style."+e,t))).each(yCe(this._id,e)):this.styleTween(e,gCe(e,n,t),r).on("end.style."+e,null)}var YTt=M(()=>{rT();Ts();Cs();uT();yK()});function vCe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function xCe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&vCe(e,a,r)),n}return o._value=t,o}function jTt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,xCe(e,t,r==null?"":r))}var XTt=M(()=>{});function bCe(e){return function(){this.textContent=e}}function wCe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function $Tt(e){return this.tween("text",typeof e=="function"?wCe(d2(this,"text",e)):bCe(e==null?"":e+""))}var KTt=M(()=>{uT()});function SCe(e){return function(t){this.textContent=e.call(this,t)}}function MCe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&SCe(i)),t}return n._value=e,n}function ZTt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,MCe(e))}var JTt=M(()=>{});function QTt(){for(var e=this._name,t=this._id,r=XR(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Qi(l,t);lg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new ha(n,this._parents,e,r)}var tCt=M(()=>{Wp();Cs()});function eCt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Ga(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var rCt=M(()=>{Cs()});function ha(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function vK(e){return qp().transition(e)}function XR(){return++ECe}var ECe,m2,Wp=M(()=>{Ts();bTt();STt();ETt();CTt();PTt();LTt();RTt();DTt();zTt();BTt();VTt();qTt();YTt();XTt();KTt();JTt();tCt();uT();rCt();ECe=0;m2=qp.prototype;ha.prototype=vK.prototype={constructor:ha,select:FTt,selectAll:HTt,filter:ITt,merge:kTt,selection:UTt,transition:QTt,call:m2.call,nodes:m2.nodes,node:m2.node,size:m2.size,empty:m2.empty,each:m2.each,on:NTt,attr:xTt,attrTween:wTt,style:WTt,styleTween:jTt,text:$Tt,textTween:ZTt,remove:OTt,tween:vTt,delay:MTt,duration:TTt,ease:ATt,end:eCt}});function TCe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return xK.time=f2(),xK;return r}function nCt(e){var t,r;e instanceof ha?(t=e._id,e=e._name):(t=XR(),(r=xK).time=f2(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&lg(l,e,t,c,a,r||TCe(l,t));return new ha(n,this._parents,e,t)}var xK,iCt=M(()=>{Wp();Cs();L_();mK();xK={time:null,delay:0,duration:250,ease:bs}});var oCt=M(()=>{Ts();yTt();iCt();qp.prototype.interrupt=_Tt;qp.prototype.transition=nCt});var aCt=M(()=>{Wp();Cs()});var sCt=M(()=>{oCt();Wp();aCt();_K()});function bK(e){return function(){return e}}var lCt=M(()=>{});function cCt(e,t,r){this.target=e,this.type=t,this.selection=r}var uCt=M(()=>{});function wK(){wr.stopImmediatePropagation()}function hT(){wr.preventDefault(),wr.stopImmediatePropagation()}var hCt=M(()=>{Ts()});function fT(e){return{type:e}}function ICe(){return!wr.button}function LCe(){var e=this.ownerSVGElement||this;return[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function MK(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function EK(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function mCt(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function gCt(){return TK($R)}function _Ct(){return TK(KR)}function yCt(){return TK(CCe)}function TK(e){var t=LCe,r=ICe,n=W5(a,"start","brush","end"),i=6,o;function a(f){var p=f.property("__brush",h).selectAll(".overlay").data([fT("overlay")]);p.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Yp.overlay).merge(p).each(function(){var g=MK(this).extent;Gp(this).attr("x",g[0][0]).attr("y",g[0][1]).attr("width",g[1][0]-g[0][0]).attr("height",g[1][1]-g[0][1])}),f.selectAll(".selection").data([fT("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Yp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var d=f.selectAll(".handle").data(e.handles,function(g){return g.type});d.exit().remove(),d.enter().append("rect").attr("class",function(g){return"handle handle--"+g.type}).attr("cursor",function(g){return Yp[g.type]}),f.each(s).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}a.move=function(f,p){f.selection?f.on("start.brush",function(){l(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){l(this,arguments).end()}).tween("brush",function(){var d=this,g=d.__brush,_=l(d,arguments),y=g.selection,x=e.input(typeof p=="function"?p.apply(this,arguments):p,g.extent),b=yy(y,x);function S(C){g.selection=C===1&&EK(x)?null:b(C),s.call(d),_.brush()}return y&&x?S:S(1)}):f.each(function(){var d=this,g=arguments,_=d.__brush,y=e.input(typeof p=="function"?p.apply(d,g):p,_.extent),x=l(d,g).beforestart();p2(d),_.selection=y==null||EK(y)?null:y,s.call(d),x.start().brush().end()})};function s(){var f=Gp(this),p=MK(this).selection;p?(f.selectAll(".selection").style("display",null).attr("x",p[0][0]).attr("y",p[0][1]).attr("width",p[1][0]-p[0][0]).attr("height",p[1][1]-p[0][1]),f.selectAll(".handle").style("display",null).attr("x",function(d){return d.type[d.type.length-1]==="e"?p[1][0]-i/2:p[0][0]-i/2}).attr("y",function(d){return d.type[0]==="s"?p[1][1]-i/2:p[0][1]-i/2}).attr("width",function(d){return d.type==="n"||d.type==="s"?p[1][0]-p[0][0]+i:i}).attr("height",function(d){return d.type==="e"||d.type==="w"?p[1][1]-p[0][1]+i:i})):f.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function l(f,p){return f.__brush.emitter||new c(f,p)}function c(f,p){this.that=f,this.args=p,this.state=f.__brush,this.active=0}c.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(f){$$(new cCt(a,f,e.output(this.state.selection)),n.apply,n,[f,this.that,this.args])}};function u(){if(wr.touches){if(wr.changedTouches.length<wr.touches.length)return hT()}else if(o)return;if(!r.apply(this,arguments))return;var f=this,p=wr.target.__data__.type,d=(wr.metaKey?p="overlay":p)==="selection"?fCt:wr.altKey?_2:g2,g=e===KR?null:ACe[p],_=e===$R?null:PCe[p],y=MK(f),x=y.extent,b=y.selection,S=x[0][0],C,P,k=x[0][1],O,D,B=x[1][0],I,L,R=x[1][1],F,z,U,W,Z,rt=g&&_&&wr.shiftKey,ot,st,St=PR(f),bt=St,Mt=l(f,arguments).beforestart();p==="overlay"?y.selection=b=[[C=e===KR?S:St[0],O=e===$R?k:St[1]],[I=e===KR?B:C,F=e===$R?R:O]]:(C=b[0][0],O=b[0][1],I=b[1][0],F=b[1][1]),P=C,D=O,L=I,z=F;var lt=Gp(f).attr("pointer-events","none"),Kt=lt.selectAll(".overlay").attr("cursor",Yp[p]);if(wr.touches)lt.on("touchmove.brush",ct,!0).on("touchend.brush touchcancel.brush",et,!0);else{var _t=Gp(wr.view).on("keydown.brush",dt,!0).on("keyup.brush",q,!0).on("mousemove.brush",ct,!0).on("mouseup.brush",et,!0);Z$(wr.view)}wK(),p2(f),s.call(f),Mt.start();function ct(){var pt=PR(f);rt&&!ot&&!st&&(Math.abs(pt[0]-bt[0])>Math.abs(pt[1]-bt[1])?st=!0:ot=!0),bt=pt,Z=!0,hT(),X()}function X(){var pt;switch(U=bt[0]-St[0],W=bt[1]-St[1],d){case SK:case fCt:{g&&(U=Math.max(S-C,Math.min(B-I,U)),P=C+U,L=I+U),_&&(W=Math.max(k-O,Math.min(R-F,W)),D=O+W,z=F+W);break}case g2:{g<0?(U=Math.max(S-C,Math.min(B-C,U)),P=C+U,L=I):g>0&&(U=Math.max(S-I,Math.min(B-I,U)),P=C,L=I+U),_<0?(W=Math.max(k-O,Math.min(R-O,W)),D=O+W,z=F):_>0&&(W=Math.max(k-F,Math.min(R-F,W)),D=O,z=F+W);break}case _2:{g&&(P=Math.max(S,Math.min(B,C-U*g)),L=Math.max(S,Math.min(B,I+U*g))),_&&(D=Math.max(k,Math.min(R,O-W*_)),z=Math.max(k,Math.min(R,F+W*_)));break}}L<P&&(g*=-1,pt=C,C=I,I=pt,pt=P,P=L,L=pt,p in pCt&&Kt.attr("cursor",Yp[p=pCt[p]])),z<D&&(_*=-1,pt=O,O=F,F=pt,pt=D,D=z,z=pt,p in dCt&&Kt.attr("cursor",Yp[p=dCt[p]])),y.selection&&(b=y.selection),ot&&(P=b[0][0],L=b[1][0]),st&&(D=b[0][1],z=b[1][1]),(b[0][0]!==P||b[0][1]!==D||b[1][0]!==L||b[1][1]!==z)&&(y.selection=[[P,D],[L,z]],s.call(f),Mt.brush())}function et(){if(wK(),wr.touches){if(wr.touches.length)return;o&&clearTimeout(o),o=setTimeout(function(){o=null},500),lt.on("touchmove.brush touchend.brush touchcancel.brush",null)}else J$(wr.view,Z),_t.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);lt.attr("pointer-events","all"),Kt.attr("cursor",Yp.overlay),y.selection&&(b=y.selection),EK(b)&&(y.selection=null,s.call(f)),Mt.end()}function dt(){switch(wr.keyCode){case 16:{rt=g&&_;break}case 18:{d===g2&&(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2,X());break}case 32:{(d===g2||d===_2)&&(g<0?I=L-U:g>0&&(C=P-U),_<0?F=z-W:_>0&&(O=D-W),d=SK,Kt.attr("cursor",Yp.selection),X());break}default:return}hT()}function q(){switch(wr.keyCode){case 16:{rt&&(ot=st=rt=!1,X());break}case 18:{d===_2&&(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2,X());break}case 32:{d===SK&&(wr.altKey?(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2):(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2),Kt.attr("cursor",Yp[p]),X());break}default:return}hT()}}function h(){var f=this.__brush||{selection:null};return f.extent=t.apply(this,arguments),f.dim=e,f}return a.extent=function(f){return arguments.length?(t=typeof f=="function"?f:bK([[+f[0][0],+f[0][1]],[+f[1][0],+f[1][1]]]),a):t},a.filter=function(f){return arguments.length?(r=typeof f=="function"?f:bK(!!f),a):r},a.handleSize=function(f){return arguments.length?(i=+f,a):i},a.on=function(){var f=n.on.apply(n,arguments);return f===n?a:f},a}var fCt,SK,g2,_2,$R,KR,CCe,Yp,pCt,dCt,ACe,PCe,vCt=M(()=>{F$();P5t();rT();Ts();sCt();lCt();uCt();hCt();fCt={name:"drag"},SK={name:"space"},g2={name:"handle"},_2={name:"center"},$R={name:"x",handles:["e","w"].map(fT),input:function(e,t){return e&&[[e[0],t[0][1]],[e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},KR={name:"y",handles:["n","s"].map(fT),input:function(e,t){return e&&[[t[0][0],e[0]],[t[1][0],e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},CCe={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(fT),input:function(e){return e},output:function(e){return e}},Yp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},pCt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},dCt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},ACe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},PCe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1}});var xCt=M(()=>{vCt()});function cg(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var xy=M(()=>{});function CK(e){return e.length===1&&(e=kCe(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function kCe(e){return function(t,r){return cg(e(t),r)}}var AK=M(()=>{xy()});var bCt,RCe,NCe,PK=M(()=>{xy();AK();bCt=CK(cg),RCe=bCt.right,NCe=bCt.left});var IK=M(()=>{});var wCt=M(()=>{IK()});var SCt=M(()=>{});var y2=M(()=>{});var LK=M(()=>{y2()});var kK=M(()=>{LK()});var RK=M(()=>{});var MCt,OCe,zCe,NK=M(()=>{MCt=Array.prototype,OCe=MCt.slice,zCe=MCt.map});var ECt=M(()=>{});var TCt=M(()=>{});function pT(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var DK=M(()=>{});var Sln,Mln,Eln,OK=M(()=>{Sln=Math.sqrt(50),Mln=Math.sqrt(10),Eln=Math.sqrt(2)});var zK=M(()=>{});var CCt=M(()=>{NK();PK();ECt();RK();TCt();DK();OK();zK()});var JR=M(()=>{y2()});var PCt=M(()=>{NK();xy();y2();JR()});var ICt=M(()=>{kK()});var LCt=M(()=>{});var kCt=M(()=>{y2()});var RCt=M(()=>{xy();y2();JR()});var NCt=M(()=>{});var FK=M(()=>{});var DCt=M(()=>{});var OCt=M(()=>{xy()});var zCt=M(()=>{});var FCt=M(()=>{});var BK=M(()=>{FK()});var BCt=M(()=>{BK()});var HCt=M(()=>{PK();xy();AK();wCt();SCt();kK();RK();CCt();PCt();ICt();zK();LCt();kCt();RCt();NCt();FK();IK();DCt();JR();DK();OCt();zCt();FCt();OK();BK();LK();BCt()});var HK,VK,VCt,dT,UK,qK,GK=M(()=>{HK=Math.cos,VK=Math.sin,VCt=Math.PI,dT=VCt/2,UK=VCt*2,qK=Math.max});function WCe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function UCt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=pT(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(pT(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=qK(0,UK-e*a)/p,_=p?e:UK/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=qK(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=WCe(o))._=o,i):n&&n._},i}var qCt=M(()=>{HCt();GK()});var GCt,WCt=M(()=>{GCt=Array.prototype.slice});function QR(e){return function(){return e}}var YCt=M(()=>{});function jK(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function jCt(){return new jK}var WK,YK,by,YCe,XK,XCt=M(()=>{WK=Math.PI,YK=2*WK,by=1e-6,YCe=YK-by;jK.prototype=jCt.prototype={constructor:jK,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>by)if(!(Math.abs(u*s-l*c)>by)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((WK-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>by&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>by||Math.abs(this._y1-c)>by)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%YK+YK),h>YCe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>by&&(this._+="A"+r+","+r+",0,"+ +(h>=WK)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};XK=jCt});var $Ct=M(()=>{XCt()});function jCe(e){return e.source}function XCe(e){return e.target}function $Ce(e){return e.radius}function KCe(e){return e.startAngle}function ZCe(e){return e.endAngle}function KCt(){var e=jCe,t=XCe,r=$Ce,n=KCe,i=ZCe,o=null;function a(){var s,l=GCt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-dT,p=i.apply(this,l)-dT,d=h*HK(f),g=h*VK(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-dT,x=i.apply(this,l)-dT;if(o||(o=s=XK()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*HK(y),_*VK(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:QR(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:QR(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:QR(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}var ZCt=M(()=>{WCt();YCt();GK();$Ct()});var JCt=M(()=>{qCt();ZCt()});function tN(){}function QCt(e,t){var r=new tN;if(e instanceof tN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var cl,wy,eN=M(()=>{cl="$";tN.prototype=QCt.prototype={constructor:tN,has:function(e){return cl+e in this},get:function(e){return this[cl+e]},set:function(e,t){return this[cl+e]=t,this},remove:function(e){var t=cl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===cl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===cl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===cl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===cl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===cl&&++e;return e},empty:function(){for(var e in this)if(e[0]===cl)return!1;return!0},each:function(e){for(var t in this)t[0]===cl&&e(this[t],t.slice(1),this)}};wy=QCt});function rAt(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=wy(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,JCe,QCe)},map:function(s){return o(s,0,tAt,eAt)},entries:function(s){return a(o(s,0,tAt,eAt),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function JCe(){return{}}function QCe(e,t,r){e[t]=r}function tAt(){return wy()}function eAt(e,t,r){e.set(t,r)}var nAt=M(()=>{eN()});function rN(){}function iAt(e,t){var r=new rN;if(e instanceof rN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Sy,oAt,aAt=M(()=>{eN();Sy=wy.prototype;rN.prototype=iAt.prototype={constructor:rN,has:Sy.has,add:function(e){return e+="",this[cl+e]=e,this},remove:Sy.remove,clear:Sy.clear,values:Sy.keys,size:Sy.size,empty:Sy.empty,each:Sy.each};oAt=iAt});function sAt(e){var t=[];for(var r in e)t.push(r);return t}var lAt=M(()=>{});function cAt(e){var t=[];for(var r in e)t.push(e[r]);return t}var uAt=M(()=>{});function hAt(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var fAt=M(()=>{});var pAt=M(()=>{nAt();aAt();eN();lAt();uAt();fAt()});function jp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function ug(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var nN=M(()=>{});function ef(){}function x2(e){var t;return e=(e+"").trim().toLowerCase(),(t=tAe.exec(e))?(t=parseInt(t[1],16),new to(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1)):(t=eAe.exec(e))?mAt(parseInt(t[1],16)):(t=rAe.exec(e))?new to(t[1],t[2],t[3],1):(t=nAe.exec(e))?new to(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=iAe.exec(e))?gAt(t[1],t[2],t[3],t[4]):(t=oAe.exec(e))?gAt(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=aAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,1):(t=sAe.exec(e))?_At(t[1],t[2]/100,t[3]/100,t[4]):dAt.hasOwnProperty(e)?mAt(dAt[e]):e==="transparent"?new to(NaN,NaN,NaN,0):null}function mAt(e){return new to(e>>16&255,e>>8&255,e&255,1)}function gAt(e,t,r,n){return n<=0&&(e=t=r=NaN),new to(e,t,r,n)}function gT(e){return e instanceof ef||(e=x2(e)),e?(e=e.rgb(),new to(e.r,e.g,e.b,e.opacity)):new to}function KK(e,t,r,n){return arguments.length===1?gT(e):new to(e,t,r,n==null?1:n)}function to(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function _At(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Qh(e,t,r,n)}function lAe(e){if(e instanceof Qh)return new Qh(e.h,e.s,e.l,e.opacity);if(e instanceof ef||(e=x2(e)),!e)return new Qh;if(e instanceof Qh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Qh(a,s,l,e.opacity)}function ZK(e,t,r,n){return arguments.length===1?lAe(e):new Qh(e,t,r,n==null?1:n)}function Qh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function $K(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var hg,My,v2,mT,tf,tAe,eAe,rAe,nAe,iAe,oAe,aAe,sAe,dAt,iN=M(()=>{nN();hg=.7,My=1/hg,v2="\\s*([+-]?\\d+)\\s*",mT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",tf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",tAe=/^#([0-9a-f]{3})$/,eAe=/^#([0-9a-f]{6})$/,rAe=new RegExp("^rgb\\("+[v2,v2,v2]+"\\)$"),nAe=new RegExp("^rgb\\("+[tf,tf,tf]+"\\)$"),iAe=new RegExp("^rgba\\("+[v2,v2,v2,mT]+"\\)$"),oAe=new RegExp("^rgba\\("+[tf,tf,tf,mT]+"\\)$"),aAe=new RegExp("^hsl\\("+[mT,tf,tf]+"\\)$"),sAe=new RegExp("^hsla\\("+[mT,tf,tf,mT]+"\\)$"),dAt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};jp(ef,x2,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}});jp(to,KK,ug(ef,{brighter:function(e){return e=e==null?My:Math.pow(My,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?hg:Math.pow(hg,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}}));jp(Qh,ZK,ug(ef,{brighter:function(e){return e=e==null?My:Math.pow(My,e),new Qh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?hg:Math.pow(hg,e),new Qh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new to($K(e>=240?e-240:e+120,i,n),$K(e,i,n),$K(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}))});var oN,aN,JK=M(()=>{oN=Math.PI/180,aN=180/Math.PI});function nZ(e){if(e instanceof Xp)return new Xp(e.l,e.a,e.b,e.opacity);if(e instanceof fg){var t=e.h*oN;return new Xp(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}e instanceof to||(e=gT(e));var r=rZ(e.r),n=rZ(e.g),i=rZ(e.b),o=QK((.4124564*r+.3575761*n+.1804375*i)/yAt),a=QK((.2126729*r+.7151522*n+.072175*i)/vAt),s=QK((.0193339*r+.119192*n+.9503041*i)/xAt);return new Xp(116*a-16,500*(o-a),200*(a-s),e.opacity)}function lN(e,t,r,n){return arguments.length===1?nZ(e):new Xp(e,t,r,n==null?1:n)}function Xp(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function QK(e){return e>cAe?Math.pow(e,1/3):e/wAt+bAt}function tZ(e){return e>b2?e*e*e:wAt*(e-bAt)}function eZ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function rZ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function uAe(e){if(e instanceof fg)return new fg(e.h,e.c,e.l,e.opacity);e instanceof Xp||(e=nZ(e));var t=Math.atan2(e.b,e.a)*aN;return new fg(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function iZ(e,t,r,n){return arguments.length===1?uAe(e):new fg(e,t,r,n==null?1:n)}function fg(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}var sN,yAt,vAt,xAt,bAt,b2,wAt,cAe,SAt=M(()=>{nN();iN();JK();sN=18,yAt=.95047,vAt=1,xAt=1.08883,bAt=4/29,b2=6/29,wAt=3*b2*b2,cAe=b2*b2*b2;jp(Xp,lN,ug(ef,{brighter:function(e){return new Xp(this.l+sN*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new Xp(this.l-sN*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return e=vAt*tZ(e),t=yAt*tZ(t),r=xAt*tZ(r),new to(eZ(3.2404542*t-1.5371385*e-.4985314*r),eZ(-.969266*t+1.8760108*e+.041556*r),eZ(.0556434*t-.2040259*e+1.0572252*r),this.opacity)}}));jp(fg,iZ,ug(ef,{brighter:function(e){return new fg(this.h,this.c,this.l+sN*(e==null?1:e),this.opacity)},darker:function(e){return new fg(this.h,this.c,this.l-sN*(e==null?1:e),this.opacity)},rgb:function(){return nZ(this).rgb()}}))});function hAe(e){if(e instanceof Ey)return new Ey(e.h,e.s,e.l,e.opacity);e instanceof to||(e=gT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(TAt*n+MAt*t-EAt*r)/(TAt+MAt-EAt),o=n-i,a=(_T*(r-i)-aZ*o)/cN,s=Math.sqrt(a*a+o*o)/(_T*i*(1-i)),l=s?Math.atan2(a,o)*aN-120:NaN;return new Ey(l<0?l+360:l,s,i,e.opacity)}function uN(e,t,r,n){return arguments.length===1?hAe(e):new Ey(e,t,r,n==null?1:n)}function Ey(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var CAt,oZ,aZ,cN,_T,MAt,EAt,TAt,AAt=M(()=>{nN();iN();JK();CAt=-.14861,oZ=1.78277,aZ=-.29227,cN=-.90649,_T=1.97294,MAt=_T*cN,EAt=_T*oZ,TAt=oZ*aZ-cN*CAt;jp(Ey,uN,ug(ef,{brighter:function(e){return e=e==null?My:Math.pow(My,e),new Ey(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?hg:Math.pow(hg,e),new Ey(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oN,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new to(255*(t+r*(CAt*n+oZ*i)),255*(t+r*(aZ*n+cN*i)),255*(t+r*(_T*n)),this.opacity)}}))});var PAt=M(()=>{iN();SAt();AAt()});function LAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r)throw new Error("illegal type: "+n);r[n]=[]}return new hN(r)}function hN(e){this._=e}function pAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function dAe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function IAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=fAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var fAe,kAt,RAt=M(()=>{fAe={value:function(){}};hN.prototype=LAt.prototype={constructor:hN,on:function(e,t){var r=this._,n=pAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=dAe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=IAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=IAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new hN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};kAt=LAt});var NAt=M(()=>{RAt()});function OAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new fN(r)}function fN(e){this._=e}function gAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function _Ae(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function DAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=mAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var mAe,sZ,zAt=M(()=>{mAe={value:function(){}};fN.prototype=OAt.prototype={constructor:fN,on:function(e,t){var r=this._,n=gAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=_Ae(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=DAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=DAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new fN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};sZ=OAt});var FAt=M(()=>{zAt()});var pN,lZ,cZ=M(()=>{pN="http://www.w3.org/1999/xhtml",lZ={svg:"http://www.w3.org/2000/svg",xhtml:pN,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function dN(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),lZ.hasOwnProperty(t)?{space:lZ[t],local:e}:e}var uZ=M(()=>{cZ()});function yAe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===pN&&t.documentElement.namespaceURI===pN?t.createElement(e):t.createElementNS(r,e)}}function vAe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function mN(e){var t=dN(e);return(t.local?vAe:yAe)(t)}var hZ=M(()=>{uZ();cZ()});function xAe(){}function gN(e){return e==null?xAe:function(){return this.querySelector(e)}}var fZ=M(()=>{});function BAt(e){typeof e!="function"&&(e=gN(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new pi(n,this._parents)}var HAt=M(()=>{rf();fZ()});function bAe(){return[]}function VAt(e){return e==null?bAe:function(){return this.querySelectorAll(e)}}var UAt=M(()=>{});function qAt(e){typeof e!="function"&&(e=VAt(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new pi(n,i)}var GAt=M(()=>{rf();UAt()});function WAt(e){return function(){return this.matches(e)}}var YAt=M(()=>{});function jAt(e){typeof e!="function"&&(e=WAt(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new pi(n,this._parents)}var XAt=M(()=>{rf();YAt()});function _N(e){return new Array(e.length)}var pZ=M(()=>{});function $At(){return new pi(this._enter||this._groups.map(_N),this._parents)}function yT(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var dZ=M(()=>{pZ();rf();yT.prototype={constructor:yT,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function KAt(e){return function(){return e}}var ZAt=M(()=>{});function wAe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new yT(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function SAe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=JAt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=JAt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new yT(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function QAt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?SAe:wAe,n=this._parents,i=this._groups;typeof e!="function"&&(e=KAt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new pi(a,n),a._enter=s,a._exit=l,a}var JAt,t4t=M(()=>{rf();dZ();ZAt();JAt="$"});function e4t(){return new pi(this._exit||this._groups.map(_N),this._parents)}var r4t=M(()=>{pZ();rf()});function n4t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var i4t=M(()=>{});function o4t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new pi(a,this._parents)}var a4t=M(()=>{rf()});function s4t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var l4t=M(()=>{});function c4t(e){e||(e=MAe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new pi(i,this._parents).order()}function MAe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var u4t=M(()=>{rf()});function h4t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var f4t=M(()=>{});function p4t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var d4t=M(()=>{});function m4t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var g4t=M(()=>{});function _4t(){var e=0;return this.each(function(){++e}),e}var y4t=M(()=>{});function v4t(){return!this.node()}var x4t=M(()=>{});function b4t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var w4t=M(()=>{});function EAe(e){return function(){this.removeAttribute(e)}}function TAe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function CAe(e,t){return function(){this.setAttribute(e,t)}}function AAe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function PAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function IAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function S4t(e,t){var r=dN(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?TAe:EAe:typeof t=="function"?r.local?IAe:PAe:r.local?AAe:CAe)(r,t))}var M4t=M(()=>{uZ()});function yN(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var mZ=M(()=>{});function LAe(e){return function(){this.style.removeProperty(e)}}function kAe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function RAe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function E4t(e,t,r){return arguments.length>1?this.each((t==null?LAe:typeof t=="function"?RAe:kAe)(e,t,r==null?"":r)):NAe(this.node(),e)}function NAe(e,t){return e.style.getPropertyValue(t)||yN(e).getComputedStyle(e,null).getPropertyValue(t)}var T4t=M(()=>{mZ()});function DAe(e){return function(){delete this[e]}}function OAe(e,t){return function(){this[e]=t}}function zAe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function C4t(e,t){return arguments.length>1?this.each((t==null?DAe:typeof t=="function"?zAe:OAe)(e,t)):this.node()[e]}var A4t=M(()=>{});function P4t(e){return e.trim().split(/^|\s+/)}function gZ(e){return e.classList||new I4t(e)}function I4t(e){this._node=e,this._names=P4t(e.getAttribute("class")||"")}function L4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function k4t(e,t){for(var r=gZ(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function FAe(e){return function(){L4t(this,e)}}function BAe(e){return function(){k4t(this,e)}}function HAe(e,t){return function(){(t.apply(this,arguments)?L4t:k4t)(this,e)}}function R4t(e,t){var r=P4t(e+"");if(arguments.length<2){for(var n=gZ(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?HAe:t?FAe:BAe)(r,t))}var N4t=M(()=>{I4t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function VAe(){this.textContent=""}function UAe(e){return function(){this.textContent=e}}function qAe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function D4t(e){return arguments.length?this.each(e==null?VAe:(typeof e=="function"?qAe:UAe)(e)):this.node().textContent}var O4t=M(()=>{});function GAe(){this.innerHTML=""}function WAe(e){return function(){this.innerHTML=e}}function YAe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function z4t(e){return arguments.length?this.each(e==null?GAe:(typeof e=="function"?YAe:WAe)(e)):this.node().innerHTML}var F4t=M(()=>{});function jAe(){this.nextSibling&&this.parentNode.appendChild(this)}function B4t(){return this.each(jAe)}var H4t=M(()=>{});function XAe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function V4t(){return this.each(XAe)}var U4t=M(()=>{});function q4t(e){var t=typeof e=="function"?e:mN(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var G4t=M(()=>{hZ()});function $Ae(){return null}function W4t(e,t){var r=typeof e=="function"?e:mN(e),n=t==null?$Ae:typeof t=="function"?t:gN(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var Y4t=M(()=>{hZ();fZ()});function KAe(){var e=this.parentNode;e&&e.removeChild(this)}function j4t(){return this.each(KAe)}var X4t=M(()=>{});function ZAe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function JAe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function $4t(e){return this.select(e?JAe:ZAe)}var K4t=M(()=>{});function Z4t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var J4t=M(()=>{});function QAe(e,t,r){return e=ePt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ePt(e,t,r){return function(n){var i=sn;sn=n;try{e.call(this,this.__data__,t,r)}finally{sn=i}}}function t4e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function e4e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function r4e(e,t,r){var n=tPt.hasOwnProperty(e.type)?QAe:ePt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function rPt(e,t,r){var n=t4e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?r4e:e4e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function vN(e,t,r,n){var i=sn;e.sourceEvent=sn,sn=e;try{return t.apply(r,n)}finally{sn=i}}var tPt,sn,Q4t,xN=M(()=>{tPt={},sn=null;typeof document!="undefined"&&(Q4t=document.documentElement,"onmouseenter"in Q4t||(tPt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function nPt(e,t,r){var n=yN(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function n4e(e,t){return function(){return nPt(this,e,t)}}function i4e(e,t){return function(){return nPt(this,e,t.apply(this,arguments))}}function iPt(e,t){return this.each((typeof t=="function"?i4e:n4e)(e,t))}var oPt=M(()=>{mZ()});function pi(e,t){this._groups=e,this._parents=t}function o4e(){return new pi([[document.documentElement]],_Z)}var _Z,rf=M(()=>{HAt();GAt();XAt();t4t();dZ();r4t();i4t();a4t();l4t();u4t();f4t();d4t();g4t();y4t();x4t();w4t();M4t();T4t();A4t();N4t();O4t();F4t();H4t();U4t();G4t();Y4t();X4t();K4t();J4t();xN();oPt();_Z=[null];pi.prototype=o4e.prototype={constructor:pi,select:BAt,selectAll:qAt,filter:jAt,data:QAt,enter:$At,exit:e4t,join:n4t,merge:o4t,order:s4t,sort:c4t,call:h4t,nodes:p4t,node:m4t,size:_4t,empty:v4t,each:b4t,attr:S4t,style:E4t,property:C4t,classed:R4t,text:D4t,html:z4t,raise:B4t,lower:V4t,append:q4t,insert:W4t,remove:j4t,clone:$4t,datum:Z4t,on:rPt,dispatch:iPt}});function Ty(e){return typeof e=="string"?new pi([[document.querySelector(e)]],[document.documentElement]):new pi([[e]],_Z)}var aPt=M(()=>{rf()});function bN(){for(var e=sn,t;t=e.sourceEvent;)e=t;return e}var yZ=M(()=>{xN()});function wN(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var vZ=M(()=>{});function xZ(e){var t=bN();return t.changedTouches&&(t=t.changedTouches[0]),wN(e,t)}var sPt=M(()=>{yZ();vZ()});function bZ(e,t,r){arguments.length<3&&(r=t,t=bN().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return wN(e,o);return null}var lPt=M(()=>{yZ();vZ()});var SN=M(()=>{sPt();aPt();lPt();xN()});function MN(){sn.stopImmediatePropagation()}function pg(){sn.preventDefault(),sn.stopImmediatePropagation()}var wZ=M(()=>{SN()});function EN(e){var t=e.document.documentElement,r=Ty(e).on("dragstart.drag",pg,!0);"onselectstart"in t?r.on("selectstart.drag",pg,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function TN(e,t){var r=e.document.documentElement,n=Ty(e).on("dragstart.drag",null);t&&(n.on("click.drag",pg,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var SZ=M(()=>{SN();wZ()});function vT(e){return function(){return e}}var cPt=M(()=>{});function xT(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}var uPt=M(()=>{xT.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e}});function a4e(){return!sn.button}function s4e(){return this.parentNode}function l4e(e){return e==null?{x:sn.x,y:sn.y}:e}function c4e(){return"ontouchstart"in this}function hPt(){var e=a4e,t=s4e,r=l4e,n=c4e,i={},o=sZ("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),xZ,this,arguments);!S||(Ty(sn.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),EN(sn.view),MN(),c=!1,s=sn.clientX,l=sn.clientY,S("start"))}}function d(){if(pg(),!c){var S=sn.clientX-s,C=sn.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ty(sn.view).on("mousemove.drag mouseup.drag",null),TN(sn.view,c),pg(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=sn.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,bZ,this,arguments))&&(MN(),O("start"))}}function y(){var S=sn.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(pg(),k("drag"))}function x(){var S=sn.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(MN(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!vN(new xT(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(sn.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}vN(new xT(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:vT(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:vT(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:vT(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:vT(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}var fPt=M(()=>{FAt();SN();SZ();wZ();cPt();uPt()});var pPt=M(()=>{fPt();SZ()});function mPt(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+"]"}).join(",")+"}")}function u4e(e,t){var r=mPt(e);return function(n,i){return t(r(n),i,e)}}function h4e(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function w2(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(c,u){var h,f,p=i(c,function(d,g){if(h)return h(d,g-1);f=d,h=u?u4e(d,u):mPt(d)});return p.columns=f||[],p}function i(c,u){var h=[],f=c.length,p=0,d=0,g,_=f<=0,y=!1;c.charCodeAt(f-1)===bT&&--f,c.charCodeAt(f-1)===TZ&&--f;function x(){if(_)return MZ;if(y)return y=!1,dPt;var S,C=p,P;if(c.charCodeAt(C)===EZ){for(;p++<f&&c.charCodeAt(p)!==EZ||c.charCodeAt(++p)===EZ;);return(S=p)>=f?_=!0:(P=c.charCodeAt(p++))===bT?y=!0:P===TZ&&(y=!0,c.charCodeAt(p)===bT&&++p),c.slice(C+1,S-1).replace(/""/g,'"')}for(;p<f;){if((P=c.charCodeAt(S=p++))===bT)y=!0;else if(P===TZ)y=!0,c.charCodeAt(p)===bT&&++p;else if(P!==r)continue;return c.slice(C,S)}return _=!0,c.slice(C,f)}for(;(g=x())!==MZ;){for(var b=[];g!==dPt&&g!==MZ;)b.push(g),g=x();u&&(b=u(b,d++))==null||h.push(b)}return h}function o(c,u){return u==null&&(u=h4e(c)),[u.map(l).join(e)].concat(c.map(function(h){return u.map(function(f){return l(h[f])}).join(e)})).join(`
`)}function a(c){return c.map(s).join(`
`)}function s(c){return c.map(l).join(e)}function l(c){return c==null?"":t.test(c+="")?'"'+c.replace(/"/g,'""')+'"':c}return{parse:n,parseRows:i,format:o,formatRows:a}}var dPt,MZ,EZ,bT,TZ,CN=M(()=>{dPt={},MZ={},EZ=34,bT=10,TZ=13});var AN,gPt,_Pt,yPt,vPt,xPt=M(()=>{CN();AN=w2(","),gPt=AN.parse,_Pt=AN.parseRows,yPt=AN.format,vPt=AN.formatRows});var PN,bPt,wPt,SPt,MPt,EPt=M(()=>{CN();PN=w2("	"),bPt=PN.parse,wPt=PN.parseRows,SPt=PN.format,MPt=PN.formatRows});var TPt=M(()=>{CN();xPt();EPt()});function CPt(e){return+e}var APt=M(()=>{});function PPt(e){return e*e}function IPt(e){return e*(2-e)}function CZ(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var LPt=M(()=>{});function kPt(e){return e*e*e}function RPt(e){return--e*e*e+1}function AZ(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var NPt=M(()=>{});var PZ,DPt,OPt,IZ,zPt=M(()=>{PZ=3,DPt=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(PZ),OPt=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(PZ),IZ=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(PZ)});function HPt(e){return 1-Math.cos(e*BPt)}function VPt(e){return Math.sin(e*BPt)}function LZ(e){return(1-Math.cos(FPt*e))/2}var FPt,BPt,UPt=M(()=>{FPt=Math.PI,BPt=FPt/2});function qPt(e){return Math.pow(2,10*e-10)}function GPt(e){return 1-Math.pow(2,-10*e)}function kZ(e){return((e*=2)<=1?Math.pow(2,10*e-10):2-Math.pow(2,10-10*e))/2}var WPt=M(()=>{});function YPt(e){return 1-Math.sqrt(1-e*e)}function jPt(e){return Math.sqrt(1- --e*e)}function RZ(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var XPt=M(()=>{});function $Pt(e){return 1-S2(1-e)}function S2(e){return(e=+e)<NZ?IN*e*e:e<p4e?IN*(e-=f4e)*e+d4e:e<g4e?IN*(e-=m4e)*e+_4e:IN*(e-=y4e)*e+v4e}function KPt(e){return((e*=2)<=1?1-S2(1-e):S2(e-1)+1)/2}var NZ,f4e,p4e,d4e,m4e,g4e,_4e,y4e,v4e,IN,ZPt=M(()=>{NZ=.36363636363636365,f4e=6/11,p4e=8/11,d4e=3/4,m4e=9/11,g4e=10/11,_4e=15/16,y4e=21/22,v4e=63/64,IN=1/NZ/NZ});var DZ,JPt,QPt,OZ,t6t=M(()=>{DZ=1.70158,JPt=function e(t){t=+t;function r(n){return n*n*((t+1)*n-t)}return r.overshoot=e,r}(DZ),QPt=function e(t){t=+t;function r(n){return--n*n*((t+1)*n+t)+1}return r.overshoot=e,r}(DZ),OZ=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(DZ)});var M2,zZ,FZ,e6t,BZ,r6t,n6t=M(()=>{M2=2*Math.PI,zZ=1,FZ=.3,e6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return t*Math.pow(2,10*--o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),BZ=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return 1-t*Math.pow(2,-10*(o=+o))*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ),r6t=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return((o=o*2-1)<0?t*Math.pow(2,10*o)*Math.sin((n-o)/r):2-t*Math.pow(2,-10*o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(zZ,FZ)});var i6t=M(()=>{APt();LPt();NPt();zPt();UPt();WPt();XPt();ZPt();t6t();n6t()});function o6t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}var a6t=M(()=>{});function Fn(e){return function(){return e}}var Cy=M(()=>{});function Mu(){return(Math.random()-.5)*1e-6}var LN=M(()=>{});function s6t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return l6t(this.cover(t,r),t,r,e)}function l6t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function c6t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)l6t(this,a[r],s[r],e[r]);return this}var u6t=M(()=>{});function h6t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var f6t=M(()=>{});function p6t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var d6t=M(()=>{});function m6t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var g6t=M(()=>{});function So(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var kN=M(()=>{});function _6t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new So(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new So(p[3],_,y,l,c),new So(p[2],a,y,_,c),new So(p[1],_,s,l,y),new So(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var y6t=M(()=>{kN()});function v6t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function x6t(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var b6t=M(()=>{});function w6t(){return this._root}var S6t=M(()=>{});function M6t(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var E6t=M(()=>{});function T6t(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new So(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new So(i,c,u,s,l)),(i=n[2])&&t.push(new So(i,o,u,c,l)),(i=n[1])&&t.push(new So(i,c,a,s,u)),(i=n[0])&&t.push(new So(i,o,a,c,u))}return this}var C6t=M(()=>{kN()});function A6t(e){var t=[],r=[],n;for(this._root&&t.push(new So(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new So(o,a,s,u,h)),(o=i[1])&&t.push(new So(o,u,s,l,h)),(o=i[2])&&t.push(new So(o,a,h,u,c)),(o=i[3])&&t.push(new So(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var P6t=M(()=>{kN()});function I6t(e){return e[0]}function L6t(e){return arguments.length?(this._x=e,this):this._x}var k6t=M(()=>{});function R6t(e){return e[1]}function N6t(e){return arguments.length?(this._y=e,this):this._y}var D6t=M(()=>{});function Ay(e,t,r){var n=new HZ(t==null?I6t:t,r==null?R6t:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function HZ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function O6t(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Wa,z6t=M(()=>{u6t();f6t();d6t();g6t();y6t();b6t();S6t();E6t();C6t();P6t();k6t();D6t();Wa=Ay.prototype=HZ.prototype;Wa.copy=function(){var e=new HZ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=O6t(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=O6t(n));return e};Wa.add=s6t;Wa.addAll=c6t;Wa.cover=h6t;Wa.data=p6t;Wa.extent=m6t;Wa.find=_6t;Wa.remove=v6t;Wa.removeAll=x6t;Wa.root=w6t;Wa.size=M6t;Wa.visit=T6t;Wa.visitAfter=A6t;Wa.x=L6t;Wa.y=N6t});var VZ=M(()=>{z6t()});function x4e(e){return e.x+e.vx}function b4e(e){return e.y+e.vy}function F6t(e){var t,r,n=1,i=1;typeof e!="function"&&(e=Fn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=Ay(t,x4e,b4e).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=Mu(),L+=B*B),I===0&&(I=Mu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:Fn(+l),s(),o):e},o}var B6t=M(()=>{Cy();LN();VZ()});function RN(){}function H6t(e,t){var r=new RN;if(e instanceof RN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var ul,dg,NN=M(()=>{ul="$";RN.prototype=H6t.prototype={constructor:RN,has:function(e){return ul+e in this},get:function(e){return this[ul+e]},set:function(e,t){return this[ul+e]=t,this},remove:function(e){var t=ul+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===ul&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===ul&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===ul&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===ul&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===ul&&++e;return e},empty:function(){for(var e in this)if(e[0]===ul)return!1;return!0},each:function(e){for(var t in this)t[0]===ul&&e(this[t],t.slice(1),this)}};dg=H6t});var V6t=M(()=>{NN()});function DN(){}function w4e(e,t){var r=new DN;if(e instanceof DN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Py,U6t=M(()=>{NN();Py=dg.prototype;DN.prototype=w4e.prototype={constructor:DN,has:Py.has,add:function(e){return e+="",this[ul+e]=e,this},remove:Py.remove,clear:Py.clear,values:Py.keys,size:Py.size,empty:Py.empty,each:Py.each}});var q6t=M(()=>{});var G6t=M(()=>{});var W6t=M(()=>{});var UZ=M(()=>{V6t();U6t();NN();q6t();G6t();W6t()});function S4e(e){return e.index}function Y6t(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function j6t(e){var t=S4e,r=u,n,i=Fn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||Mu(),k=C.y+C.vy-S.y-S.vy||Mu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=dg(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=Y6t(x,b.source)),typeof b.target!="object"&&(b.target=Y6t(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:Fn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:Fn(+g),d(),h):i},h}var X6t=M(()=>{Cy();LN();UZ()});function K6t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new ON(r)}function ON(e){this._=e}function E4e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function T4e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function $6t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=M4e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var M4e,qZ,Z6t=M(()=>{M4e={value:function(){}};ON.prototype=K6t.prototype={constructor:ON,on:function(e,t){var r=this._,n=E4e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=T4e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=$6t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=$6t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new ON(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};qZ=K6t});var J6t=M(()=>{Z6t()});function YZ(){return Iy||(eIt(C4e),Iy=ET.now()+BN)}function C4e(){Iy=0}function GZ(){this._call=this._time=this._next=null}function HN(e,t,r){var n=new GZ;return n.restart(e,t,r),n}function rIt(){YZ(),++E2;for(var e=zN,t;e;)(t=Iy-e._time)>=0&&e._call.call(null,t),e=e._next;--E2}function Q6t(){Iy=(FN=ET.now())+BN,E2=ST=0;try{rIt()}finally{E2=0,P4e(),Iy=0}}function A4e(){var e=ET.now(),t=e-FN;t>tIt&&(BN-=t,FN=e)}function P4e(){for(var e,t=zN,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:zN=r);MT=e,WZ(n)}function WZ(e){if(!E2){ST&&(ST=clearTimeout(ST));var t=e-Iy;t>24?(e<1/0&&(ST=setTimeout(Q6t,e-ET.now()-BN)),wT&&(wT=clearInterval(wT))):(wT||(FN=ET.now(),wT=setInterval(A4e,tIt)),E2=1,eIt(Q6t))}}var E2,ST,wT,tIt,zN,MT,FN,Iy,BN,ET,eIt,nIt=M(()=>{E2=0,ST=0,wT=0,tIt=1e3,FN=0,Iy=0,BN=0,ET=typeof performance=="object"&&performance.now?performance:Date,eIt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};GZ.prototype=HN.prototype={constructor:GZ,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?YZ():+r)+(t==null?0:+t),!this._next&&MT!==this&&(MT?MT._next=this:zN=this,MT=this),this._call=e,this._time=r,WZ()},stop:function(){this._call&&(this._call=null,this._time=1/0,WZ())}}});var iIt=M(()=>{nIt()});function oIt(e){return e.x}function aIt(e){return e.y}function sIt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=dg(),l=HN(u),c=qZ("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(){var d,g=e.length,_;for(r+=(o-r)*i,s.each(function(y){y(r)}),d=0;d<g;++d)_=e[d],_.fx==null?_.x+=_.vx*=a:(_.x=_.fx,_.vx=0),_.fy==null?_.y+=_.vy*=a:(_.y=_.fy,_.vy=0)}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,isNaN(_.x)||isNaN(_.y)){var y=I4e*Math.sqrt(d),x=d*L4e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}var I4e,L4e,jZ=M(()=>{J6t();UZ();iIt();I4e=10,L4e=Math.PI*(3-Math.sqrt(5))});function lIt(){var e,t,r,n=Fn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=Ay(e,oIt,aIt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:Fn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}var cIt=M(()=>{Cy();LN();VZ();jZ()});function uIt(e,t,r){var n,i=Fn(.1),o,a;typeof e!="function"&&(e=Fn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:Fn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:Fn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}var hIt=M(()=>{Cy()});function fIt(e){var t=Fn(.1),r,n,i;typeof e!="function"&&(e=Fn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Fn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:Fn(+s),a(),o):e},o}var pIt=M(()=>{Cy()});function dIt(e){var t=Fn(.1),r,n,i;typeof e!="function"&&(e=Fn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Fn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:Fn(+s),a(),o):e},o}var mIt=M(()=>{Cy()});var gIt=M(()=>{a6t();B6t();X6t();cIt();hIt();jZ();pIt();mIt()});function Ly(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var VN=M(()=>{});function nf(e){return e=Ly(Math.abs(e)),e?e[1]:NaN}var TT=M(()=>{VN()});function _It(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var yIt=M(()=>{});function vIt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var xIt=M(()=>{});function bIt(e,t){e=e.toPrecision(t);t:for(var r=e.length,n=1,i=-1,o;n<r;++n)switch(e[n]){case".":i=o=n;break;case"0":i===0&&(i=n),o=n;break;case"e":break t;default:i>0&&(i=0);break}return i>0?e.slice(0,i)+e.slice(o+1):e}var wIt=M(()=>{});function SIt(e,t){var r=Ly(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(XZ=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+Ly(e,Math.max(0,t+o-1))[0]}var XZ,$Z=M(()=>{VN()});function KZ(e,t){var r=Ly(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var MIt=M(()=>{VN()});var UN,ZZ=M(()=>{wIt();$Z();MIt();UN={"":bIt,"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:function(e){return Math.round(e).toString(10)},e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return KZ(e*100,t)},r:KZ,s:SIt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function ky(e){return new JZ(e)}function JZ(e){if(!(t=k4e.exec(e)))throw new Error("invalid format: "+e);var t,r=t[1]||" ",n=t[2]||">",i=t[3]||"-",o=t[4]||"",a=!!t[5],s=t[6]&&+t[6],l=!!t[7],c=t[8]&&+t[8].slice(1),u=t[9]||"";u==="n"?(l=!0,u="g"):UN[u]||(u=""),(a||r==="0"&&n==="=")&&(a=!0,r="0",n="="),this.fill=r,this.align=n,this.sign=i,this.symbol=o,this.zero=a,this.width=s,this.comma=l,this.precision=c,this.type=u}var k4e,QZ=M(()=>{ZZ();k4e=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;ky.prototype=JZ.prototype;JZ.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width==null?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision==null?"":"."+Math.max(0,this.precision|0))+this.type}});function tJ(e){return e}var EIt=M(()=>{});function qN(e){var t=e.grouping&&e.thousands?_It(e.grouping,e.thousands):tJ,r=e.currency,n=e.decimal,i=e.numerals?vIt(e.numerals):tJ,o=e.percent||"%";function a(l){l=ky(l);var c=l.fill,u=l.align,h=l.sign,f=l.symbol,p=l.zero,d=l.width,g=l.comma,_=l.precision,y=l.type,x=f==="$"?r[0]:f==="#"&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b=f==="$"?r[1]:/[%p]/.test(y)?o:"",S=UN[y],C=!y||/[defgprs%]/.test(y);_=_==null?y?6:12:/[gprs]/.test(y)?Math.max(1,Math.min(21,_)):Math.max(0,Math.min(20,_));function P(k){var O=x,D=b,B,I,L;if(y==="c")D=S(k)+D,k="";else{k=+k;var R=k<0;if(k=S(Math.abs(k),_),R&&+k==0&&(R=!1),O=(R?h==="("?h:"-":h==="-"||h==="("?"":h)+O,D=(y==="s"?TIt[8+XZ/3]:"")+D+(R&&h==="("?")":""),C){for(B=-1,I=k.length;++B<I;)if(L=k.charCodeAt(B),48>L||L>57){D=(L===46?n+k.slice(B+1):k.slice(B))+D,k=k.slice(0,B);break}}}g&&!p&&(k=t(k,1/0));var F=O.length+k.length+D.length,z=F<d?new Array(d-F+1).join(c):"";switch(g&&p&&(k=t(z+k,z.length?d-D.length:1/0),z=""),u){case"<":k=O+k+D+z;break;case"=":k=O+z+k+D;break;case"^":k=z.slice(0,F=z.length>>1)+O+k+D+z.slice(F);break;default:k=z+O+k+D;break}return i(k)}return P.toString=function(){return l+""},P}function s(l,c){var u=a((l=ky(l),l.type="f",l)),h=Math.max(-8,Math.min(8,Math.floor(nf(c)/3)))*3,f=Math.pow(10,-h),p=TIt[8+h/3];return function(d){return u(f*d)+p}}return{format:a,formatPrefix:s}}var TIt,eJ=M(()=>{TT();yIt();xIt();QZ();ZZ();$Z();EIt();TIt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function WN(e){return GN=qN(e),rJ=GN.format,nJ=GN.formatPrefix,GN}var GN,rJ,nJ,CIt=M(()=>{eJ();WN({decimal:".",thousands:",",grouping:[3],currency:["$",""]})});function AIt(e){return Math.max(0,-nf(Math.abs(e)))}var PIt=M(()=>{TT()});function IIt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(nf(t)/3)))*3-nf(Math.abs(e)))}var LIt=M(()=>{TT()});function kIt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,nf(t)-nf(e))+1}var RIt=M(()=>{TT()});var NIt=M(()=>{CIt();eJ();QZ();PIt();LIt();RIt()});function As(){return new jN}function jN(){this.reset()}function DIt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var YN,Ry=M(()=>{jN.prototype={constructor:jN,reset:function(){this.s=this.t=0},add:function(e){DIt(YN,e,this.t),DIt(this,YN.s,this.s),this.s?this.t+=YN.t:this.s=YN.t},valueOf:function(){return this.s}};YN=new jN});function KN(e){return e>1?0:e<-1?rr:Math.acos(e)}function Jn(e){return e>1?Bn:e<-1?-Bn:Math.asin(e)}function oJ(e){return(e=Jt(e/2))*e}var ce,iJ,rr,Bn,T2,Bi,Ur,we,Ye,yc,Sn,ae,CT,XN,Ny,$N,Jt,mg,Rr,C2,lr=M(()=>{ce=1e-6,iJ=1e-12,rr=Math.PI,Bn=rr/2,T2=rr/4,Bi=rr*2,Ur=180/rr,we=rr/180,Ye=Math.abs,yc=Math.atan,Sn=Math.atan2,ae=Math.cos,CT=Math.ceil,XN=Math.exp,Ny=Math.log,$N=Math.pow,Jt=Math.sin,mg=Math.sign||function(e){return e>0?1:e<0?-1:0},Rr=Math.sqrt,C2=Math.tan});function qr(){}var $p=M(()=>{});function ZN(e,t){e&&zIt.hasOwnProperty(e.type)&&zIt[e.type](e,t)}function aJ(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function FIt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)aJ(e[r],t,1);t.polygonEnd()}function Mo(e,t){e&&OIt.hasOwnProperty(e.type)?OIt[e.type](e,t):ZN(e,t)}var OIt,zIt,gg=M(()=>{OIt={Feature:function(e,t){ZN(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)ZN(r[n].geometry,t)}},zIt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){aJ(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)aJ(r[n],t,0)},Polygon:function(e,t){FIt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)FIt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)ZN(r[n],t)}}});function R4e(){Eu.point=D4e}function N4e(){VIt(BIt,HIt)}function D4e(e,t){Eu.point=VIt,BIt=e,HIt=t,e*=we,t*=we,sJ=e,lJ=ae(t=t/2+T2),cJ=Jt(t)}function VIt(e,t){e*=we,t*=we,t=t/2+T2;var r=e-sJ,n=r>=0?1:-1,i=n*r,o=ae(t),a=Jt(t),s=cJ*a,l=lJ*o+s*ae(i),c=s*n*Jt(i);AT.add(Sn(c,l)),sJ=e,lJ=o,cJ=a}function UIt(e){return JN.reset(),Mo(e,Eu),JN*2}var AT,JN,BIt,HIt,sJ,lJ,cJ,Eu,uJ=M(()=>{Ry();lr();$p();gg();AT=As(),JN=As(),Eu={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){AT.reset(),Eu.lineStart=R4e,Eu.lineEnd=N4e},polygonEnd:function(){var e=+AT;JN.add(e<0?Bi+e:e),this.lineStart=this.lineEnd=this.point=qr},sphere:function(){JN.add(Bi)}}});function Dy(e){return[Sn(e[1],e[0]),Jn(e[2])]}function vc(e){var t=e[0],r=e[1],n=ae(r);return[n*ae(t),n*Jt(t),Jt(r)]}function PT(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Kp(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function QN(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function IT(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function Oy(e){var t=Rr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var A2=M(()=>{lr()});function hJ(e,t){_g.push(Jp=[di=e,Ei=e]),t<fl&&(fl=t),t>xc&&(xc=t)}function XIt(e,t){var r=vc([e*we,t*we]);if(P2){var n=Kp(P2,r),i=[n[1],-n[0],0],o=Kp(i,n);Oy(o),o=Dy(o);var a=e-zy,s=a>0?1:-1,l=o[0]*Ur*s,c,u=Ye(a)>180;u^(s*zy<l&&l<s*e)?(c=o[1]*Ur,c>xc&&(xc=c)):(l=(l+360)%360-180,u^(s*zy<l&&l<s*e)?(c=-o[1]*Ur,c<fl&&(fl=c)):(t<fl&&(fl=t),t>xc&&(xc=t))),u?e<zy?hl(di,e)>hl(di,Ei)&&(Ei=e):hl(e,Ei)>hl(di,Ei)&&(di=e):Ei>=di?(e<di&&(di=e),e>Ei&&(Ei=e)):e>zy?hl(di,e)>hl(di,Ei)&&(Ei=e):hl(e,Ei)>hl(di,Ei)&&(di=e)}else _g.push(Jp=[di=e,Ei=e]);t<fl&&(fl=t),t>xc&&(xc=t),P2=r,zy=e}function qIt(){Zp.point=XIt}function GIt(){Jp[0]=di,Jp[1]=Ei,Zp.point=hJ,P2=null}function $It(e,t){if(P2){var r=e-zy;LT.add(Ye(r)>180?r+(r>0?360:-360):r)}else YIt=e,jIt=t;Eu.point(e,t),XIt(e,t)}function O4e(){Eu.lineStart()}function z4e(){$It(YIt,jIt),Eu.lineEnd(),Ye(LT)>ce&&(di=-(Ei=180)),Jp[0]=di,Jp[1]=Ei,P2=null}function hl(e,t){return(t-=e)<0?t+360:t}function F4e(e,t){return e[0]-t[0]}function WIt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function KIt(e){var t,r,n,i,o,a,s;if(xc=Ei=-(di=fl=1/0),_g=[],Mo(e,Zp),r=_g.length){for(_g.sort(F4e),t=1,n=_g[0],o=[n];t<r;++t)i=_g[t],WIt(n,i[0])||WIt(n,i[1])?(hl(n[0],i[1])>hl(n[0],n[1])&&(n[1]=i[1]),hl(i[0],n[1])>hl(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=hl(n[1],i[0]))>a&&(a=s,di=i[0],Ei=n[1])}return _g=Jp=null,di===1/0||fl===1/0?[[NaN,NaN],[NaN,NaN]]:[[di,fl],[Ei,xc]]}var di,fl,Ei,xc,zy,YIt,jIt,P2,LT,_g,Jp,Zp,ZIt=M(()=>{Ry();uJ();A2();lr();gg();LT=As(),Zp={point:hJ,lineStart:qIt,lineEnd:GIt,polygonStart:function(){Zp.point=$It,Zp.lineStart=O4e,Zp.lineEnd=z4e,LT.reset(),Eu.polygonStart()},polygonEnd:function(){Eu.polygonEnd(),Zp.point=hJ,Zp.lineStart=qIt,Zp.lineEnd=GIt,AT<0?(di=-(Ei=180),fl=-(xc=90)):LT>ce?xc=90:LT<-ce&&(fl=-90),Jp[0]=di,Jp[1]=Ei}}});function mJ(e,t){e*=we,t*=we;var r=ae(t);RT(r*ae(e),r*Jt(e),Jt(t))}function RT(e,t,r){++kT,eD+=(e-eD)/kT,rD+=(t-rD)/kT,nD+=(r-nD)/kT}function JIt(){Tu.point=B4e}function B4e(e,t){e*=we,t*=we;var r=ae(t);Ya=r*ae(e),ja=r*Jt(e),Xa=Jt(t),Tu.point=H4e,RT(Ya,ja,Xa)}function H4e(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Sn(Rr((a=ja*o-Xa*i)*a+(a=Xa*n-Ya*o)*a+(a=Ya*i-ja*n)*a),Ya*n+ja*i+Xa*o);tD+=a,iD+=a*(Ya+(Ya=n)),oD+=a*(ja+(ja=i)),aD+=a*(Xa+(Xa=o)),RT(Ya,ja,Xa)}function QIt(){Tu.point=mJ}function V4e(){Tu.point=q4e}function U4e(){r9t(t9t,e9t),Tu.point=mJ}function q4e(e,t){t9t=e,e9t=t,e*=we,t*=we,Tu.point=r9t;var r=ae(t);Ya=r*ae(e),ja=r*Jt(e),Xa=Jt(t),RT(Ya,ja,Xa)}function r9t(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=ja*o-Xa*i,s=Xa*n-Ya*o,l=Ya*i-ja*n,c=Rr(a*a+s*s+l*l),u=Jn(c),h=c&&-u/c;fJ+=h*a,pJ+=h*s,dJ+=h*l,tD+=u,iD+=u*(Ya+(Ya=n)),oD+=u*(ja+(ja=i)),aD+=u*(Xa+(Xa=o)),RT(Ya,ja,Xa)}function n9t(e){kT=tD=eD=rD=nD=iD=oD=aD=fJ=pJ=dJ=0,Mo(e,Tu);var t=fJ,r=pJ,n=dJ,i=t*t+r*r+n*n;return i<iJ&&(t=iD,r=oD,n=aD,tD<ce&&(t=eD,r=rD,n=nD),i=t*t+r*r+n*n,i<iJ)?[NaN,NaN]:[Sn(r,t)*Ur,Jn(n/Rr(i))*Ur]}var kT,tD,eD,rD,nD,iD,oD,aD,fJ,pJ,dJ,t9t,e9t,Ya,ja,Xa,Tu,i9t=M(()=>{lr();$p();gg();Tu={sphere:qr,point:mJ,lineStart:JIt,lineEnd:QIt,polygonStart:function(){Tu.lineStart=V4e,Tu.lineEnd=U4e},polygonEnd:function(){Tu.lineStart=JIt,Tu.lineEnd=QIt}}});function Fy(e){return function(){return e}}var o9t=M(()=>{});function sD(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}var gJ=M(()=>{});function _J(e,t){return[e>rr?e-Bi:e<-rr?e+Bi:e,t]}function NT(e,t,r){return(e%=Bi)?t||r?sD(s9t(e),l9t(t,r)):s9t(e):t||r?l9t(t,r):_J}function a9t(e){return function(t,r){return t+=e,[t>rr?t-Bi:t<-rr?t+Bi:t,r]}}function s9t(e){var t=a9t(e);return t.invert=a9t(-e),t}function l9t(e,t){var r=ae(e),n=Jt(e),i=ae(t),o=Jt(t);function a(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*r+u*n;return[Sn(h*i-p*o,u*r-f*n),Jn(p*i+h*o)]}return a.invert=function(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*i-h*o;return[Sn(h*i+f*o,u*r+p*n),Jn(p*r-u*n)]},a}function lD(e){e=NT(e[0]*we,e[1]*we,e.length>2?e[2]*we:0);function t(r){return r=e(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r}return t.invert=function(r){return r=e.invert(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r},t}var DT=M(()=>{gJ();lr();_J.invert=_J});function yJ(e,t,r,n,i,o){if(!!r){var a=ae(t),s=Jt(t),l=n*r;i==null?(i=t+n*Bi,o=t-l/2):(i=c9t(a,i),o=c9t(a,o),(n>0?i<o:i>o)&&(i+=n*Bi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=Dy([a,-s*ae(u),-s*Jt(u)]),e.point(c[0],c[1])}}function c9t(e,t){t=vc(t),t[0]-=e,Oy(t);var r=KN(-t[1]);return((-t[2]<0?-r:r)+Bi-ce)%Bi}function u9t(){var e=Fy([0,0]),t=Fy(90),r=Fy(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=Ur,l[1]*=Ur}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*we,u=r.apply(this,arguments)*we;return n=[],i=NT(-l[0]*we,-l[1]*we,0).invert,yJ(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:Fy([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:Fy(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:Fy(+l),s):r},s}var vJ=M(()=>{A2();o9t();lr();DT()});function cD(){var e=[],t;return{point:function(r,n){t.push([r,n])},lineStart:function(){e.push(t=[])},lineEnd:qr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}var xJ=M(()=>{$p()});function I2(e,t){return Ye(e[0]-t[0])<ce&&Ye(e[1]-t[1])<ce}var bJ=M(()=>{lr()});function uD(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function hD(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(I2(_,y)){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}o.push(x=new uD(_,d,null,!0)),a.push(x.o=new uD(_,null,x,!1)),o.push(x=new uD(y,d,null,!1)),a.push(x.o=new uD(y,null,x,!0))}}),!!o.length){for(a.sort(t),h9t(o),h9t(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function h9t(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var wJ=M(()=>{bJ()});function fD(e,t){var r=t[0],n=t[1],i=[Jt(r),-ae(r),0],o=0,a=0;SJ.reset();for(var s=0,l=e.length;s<l;++s)if(!!(u=(c=e[s]).length))for(var c,u,h=c[u-1],f=h[0],p=h[1]/2+T2,d=Jt(p),g=ae(p),_=0;_<u;++_,f=x,d=S,g=C,h=y){var y=c[_],x=y[0],b=y[1]/2+T2,S=Jt(b),C=ae(b),P=x-f,k=P>=0?1:-1,O=k*P,D=O>rr,B=d*S;if(SJ.add(Sn(B*k*Jt(O),g*C+B*ae(O))),o+=D?P+k*Bi:P,D^f>=r^x>=r){var I=Kp(vc(h),vc(y));Oy(I);var L=Kp(i,I);Oy(L);var R=(D^P>=0?-1:1)*Jn(L[2]);(n>R||n===R&&(I[0]||I[1]))&&(a+=D^P>=0?1:-1)}}return(o<-ce||o<ce&&SJ<-ce)^a&1}var SJ,MJ=M(()=>{Ry();A2();lr();SJ=As()});function yg(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var By=M(()=>{});function EJ(e){return e.length===1&&(e=G4e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function G4e(e){return function(t,r){return yg(e(t),r)}}var TJ=M(()=>{By()});var f9t,W4e,Y4e,CJ=M(()=>{By();TJ();f9t=EJ(yg),W4e=f9t.right,Y4e=f9t.left});var AJ=M(()=>{});var p9t=M(()=>{AJ()});var d9t=M(()=>{});var L2=M(()=>{});var PJ=M(()=>{L2()});var IJ=M(()=>{PJ()});var LJ=M(()=>{});var m9t,X4e,$4e,kJ=M(()=>{m9t=Array.prototype,X4e=m9t.slice,$4e=m9t.map});var g9t=M(()=>{});var _9t=M(()=>{});function Qp(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var RJ=M(()=>{});var k0n,R0n,N0n,NJ=M(()=>{k0n=Math.sqrt(50),R0n=Math.sqrt(10),N0n=Math.sqrt(2)});var DJ=M(()=>{});var y9t=M(()=>{kJ();CJ();g9t();LJ();_9t();RJ();NJ();DJ()});var dD=M(()=>{L2()});var x9t=M(()=>{kJ();By();L2();dD()});var b9t=M(()=>{IJ()});var w9t=M(()=>{});var S9t=M(()=>{L2()});var M9t=M(()=>{By();L2();dD()});function OT(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var E9t=M(()=>{});var OJ=M(()=>{});var T9t=M(()=>{});var C9t=M(()=>{By()});var A9t=M(()=>{});var P9t=M(()=>{});var zJ=M(()=>{OJ()});var I9t=M(()=>{zJ()});var mD=M(()=>{CJ();By();TJ();p9t();d9t();IJ();LJ();y9t();x9t();b9t();DJ();w9t();S9t();M9t();E9t();OJ();AJ();T9t();dD();RJ();C9t();A9t();P9t();NJ();zJ();PJ();I9t()});function gD(e,t,r,n){return function(i){var o=t(i),a=cD(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=OT(u);var S=fD(c,n);u.length?(l||(i.polygonStart(),l=!0),hD(u,iPe,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(nPe))}}return f}}function nPe(e){return e.length>1}function iPe(e,t){return((e=e.x)[0]<0?e[1]-Bn-ce:Bn-e[1])-((t=t.x)[0]<0?t[1]-Bn-ce:Bn-t[1])}var FJ=M(()=>{xJ();wJ();lr();MJ();mD()});function oPe(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?rr:-rr,l=Ye(o-t);Ye(l-rr)<ce?(e.point(t,r=(r+a)/2>0?Bn:-Bn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=rr&&(Ye(t-n)<ce&&(t-=n*ce),Ye(o-s)<ce&&(o-=s*ce),r=aPe(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function aPe(e,t,r,n){var i,o,a=Jt(e-r);return Ye(a)>ce?yc((Jt(t)*(o=ae(n))*Jt(r)-Jt(n)*(i=ae(t))*Jt(e))/(i*o*a)):(t+n)/2}function sPe(e,t,r,n){var i;if(e==null)i=r*Bn,n.point(-rr,i),n.point(0,i),n.point(rr,i),n.point(rr,0),n.point(rr,-i),n.point(0,-i),n.point(-rr,-i),n.point(-rr,0),n.point(-rr,i);else if(Ye(e[0]-t[0])>ce){var o=e[0]<t[0]?rr:-rr;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}var zT,BJ=M(()=>{FJ();lr();zT=gD(function(){return!0},oPe,sPe,[-rr,-Bn])});function _D(e){var t=ae(e),r=6*we,n=t>0,i=Ye(t)>ce;function o(u,h,f,p){yJ(p,e,r,f,u,h)}function a(u,h){return ae(u)*ae(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?rr:-rr),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||I2(h,b)||I2(x,b))&&(x[0]+=ce,x[1]+=ce,S=a(x[0],x[1]))),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1]),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1])))}S&&(!h||!I2(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=vc(u),d=vc(h),g=[1,0,0],_=Kp(p,d),y=PT(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=Kp(g,_),k=IT(g,S),O=IT(_,C);QN(k,O);var D=P,B=PT(k,D),I=PT(D,D),L=B*B-I*(PT(k,k)-1);if(!(L<0)){var R=Rr(L),F=IT(D,(-B-R)/I);if(QN(F,k),F=Dy(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Ye(ot-rr)<ce,St=st||ot<ce;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Ye(F[0]-z)<ce?W:Z):W<=F[1]&&F[1]<=Z:ot>rr^(z<=F[0]&&F[0]<=U)){var bt=IT(D,(-B+R)/I);return QN(bt,k),[F,Dy(bt)]}}}function c(u,h){var f=n?e:rr-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return gD(a,s,o,n?[0,-e]:[-rr,e-rr])}var HJ=M(()=>{A2();vJ();lr();bJ();FJ()});function L9t(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var k9t=M(()=>{});function td(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Ye(c[0]-e)<ce?u>0?0:3:Ye(c[0]-r)<ce?u>0?2:1:Ye(c[1]-t)<ce?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=cD(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=OT(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&hD(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(yD,Math.min(FT,x)),b=Math.max(yD,Math.min(FT,b))],rt=[z=Math.max(yD,Math.min(FT,z)),U=Math.max(yD,Math.min(FT,U))];L9t(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}var FT,yD,BT=M(()=>{lr();xJ();k9t();wJ();mD();FT=1e9,yD=-FT});function R9t(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=td(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var N9t=M(()=>{BT()});function lPe(){k2.point=uPe,k2.lineEnd=cPe}function cPe(){k2.point=k2.lineEnd=qr}function uPe(e,t){e*=we,t*=we,UJ=e,vD=Jt(t),xD=ae(t),k2.point=hPe}function hPe(e,t){e*=we,t*=we;var r=Jt(t),n=ae(t),i=Ye(e-UJ),o=ae(i),a=Jt(i),s=n*a,l=xD*r-vD*n*o,c=vD*r+xD*n*o;VJ.add(Sn(Rr(s*s+l*l),c)),UJ=e,vD=r,xD=n}function bD(e){return VJ.reset(),Mo(e,k2),+VJ}var VJ,UJ,vD,xD,k2,qJ=M(()=>{Ry();lr();$p();gg();VJ=As(),k2={sphere:qr,point:qr,lineStart:lPe,lineEnd:qr,polygonStart:qr,polygonEnd:qr}});function Hy(e,t){return GJ[0]=e,GJ[1]=t,bD(fPe)}var GJ,fPe,WJ=M(()=>{qJ();GJ=[null,null],fPe={type:"LineString",coordinates:GJ}});function wD(e,t){return e&&O9t.hasOwnProperty(e.type)?O9t[e.type](e,t):!1}function z9t(e,t){return Hy(e,t)===0}function F9t(e,t){var r=Hy(e[0],e[1]),n=Hy(e[0],t),i=Hy(t,e[1]);return n+i<=r+ce}function B9t(e,t){return!!fD(e.map(pPe),H9t(t))}function pPe(e){return e=e.map(H9t),e.pop(),e}function H9t(e){return[e[0]*we,e[1]*we]}function V9t(e,t){return(e&&D9t.hasOwnProperty(e.type)?D9t[e.type]:wD)(e,t)}var D9t,O9t,U9t=M(()=>{MJ();WJ();lr();D9t={Feature:function(e,t){return wD(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(wD(r[n].geometry,t))return!0;return!1}},O9t={Sphere:function(){return!0},Point:function(e,t){return z9t(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(z9t(r[n],t))return!0;return!1},LineString:function(e,t){return F9t(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(F9t(r[n],t))return!0;return!1},Polygon:function(e,t){return B9t(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(B9t(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(wD(r[n],t))return!0;return!1}}});function q9t(e,t,r){var n=Qp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function G9t(e,t,r){var n=Qp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function SD(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Qp(CT(n/u)*u,r,u).map(d).concat(Qp(CT(s/h)*h,a,h).map(g)).concat(Qp(CT(t/l)*l,e,l).filter(function(b){return Ye(b%u)>ce}).map(f)).concat(Qp(CT(o/c)*c,i,c).filter(function(b){return Ye(b%h)>ce}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=q9t(o,i,90),p=G9t(t,e,_),d=q9t(s,a,90),g=G9t(n,r,_),y):_},y.extentMajor([[-180,-90+ce],[180,90-ce]]).extentMinor([[-180,-80-ce],[180,80+ce]])}function W9t(){return SD()()}var Y9t=M(()=>{mD();lr()});function j9t(e,t){var r=e[0]*we,n=e[1]*we,i=t[0]*we,o=t[1]*we,a=ae(n),s=Jt(n),l=ae(o),c=Jt(o),u=a*ae(r),h=a*Jt(r),f=l*ae(i),p=l*Jt(i),d=2*Jn(Rr(oJ(o-n)+a*l*oJ(i-r))),g=Jt(d),_=d?function(y){var x=Jt(y*=d)/g,b=Jt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[Sn(C,S)*Ur,Sn(P,Rr(S*S+C*C))*Ur]}:function(){return[r*Ur,n*Ur]};return _.distance=d,_}var X9t=M(()=>{lr()});function of(e){return e}var MD=M(()=>{});function dPe(){vg.point=mPe}function mPe(e,t){vg.point=Z9t,$9t=XJ=e,K9t=$J=t}function Z9t(e,t){jJ.add($J*e-XJ*t),XJ=e,$J=t}function gPe(){Z9t($9t,K9t)}var YJ,jJ,$9t,K9t,XJ,$J,vg,KJ,J9t=M(()=>{Ry();lr();$p();YJ=As(),jJ=As(),vg={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){vg.lineStart=dPe,vg.lineEnd=gPe},polygonEnd:function(){vg.lineStart=vg.lineEnd=vg.point=qr,YJ.add(Ye(jJ)),jJ.reset()},result:function(){var e=YJ/2;return YJ.reset(),e}};KJ=vg});function yPe(e,t){e<R2&&(R2=e),e>HT&&(HT=e),t<ED&&(ED=t),t>TD&&(TD=t)}var R2,ED,HT,TD,_Pe,N2,ZJ=M(()=>{$p();R2=1/0,ED=R2,HT=-R2,TD=HT,_Pe={point:yPe,lineStart:qr,lineEnd:qr,polygonStart:qr,polygonEnd:qr,result:function(){var e=[[R2,ED],[HT,TD]];return HT=TD=-(ED=R2=1/0),e}};N2=_Pe});function Vy(e,t){JJ+=e,QJ+=t,++VT}function Q9t(){Cu.point=vPe}function vPe(e,t){Cu.point=xPe,Vy(af=e,sf=t)}function xPe(e,t){var r=e-af,n=t-sf,i=Rr(r*r+n*n);CD+=i*(af+e)/2,AD+=i*(sf+t)/2,D2+=i,Vy(af=e,sf=t)}function tLt(){Cu.point=Vy}function bPe(){Cu.point=SPe}function wPe(){nLt(eLt,rLt)}function SPe(e,t){Cu.point=nLt,Vy(eLt=af=e,rLt=sf=t)}function nLt(e,t){var r=e-af,n=t-sf,i=Rr(r*r+n*n);CD+=i*(af+e)/2,AD+=i*(sf+t)/2,D2+=i,i=sf*e-af*t,tQ+=i*(af+e),eQ+=i*(sf+t),UT+=i*3,Vy(af=e,sf=t)}var JJ,QJ,VT,CD,AD,D2,tQ,eQ,UT,eLt,rLt,af,sf,Cu,rQ,iLt=M(()=>{lr();JJ=0,QJ=0,VT=0,CD=0,AD=0,D2=0,tQ=0,eQ=0,UT=0,Cu={point:Vy,lineStart:Q9t,lineEnd:tLt,polygonStart:function(){Cu.lineStart=bPe,Cu.lineEnd=wPe},polygonEnd:function(){Cu.point=Vy,Cu.lineStart=Q9t,Cu.lineEnd=tLt},result:function(){var e=UT?[tQ/UT,eQ/UT]:D2?[CD/D2,AD/D2]:VT?[JJ/VT,QJ/VT]:[NaN,NaN];return JJ=QJ=VT=CD=AD=D2=tQ=eQ=UT=0,e}};rQ=Cu});function PD(e){this._context=e}var oLt=M(()=>{lr();$p();PD.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,Bi);break}}},result:qr}});function MPe(e,t){ID.point=lLt,aLt=qT=e,sLt=GT=t}function lLt(e,t){qT-=e,GT-=t,iQ.add(Rr(qT*qT+GT*GT)),qT=e,GT=t}var iQ,nQ,aLt,sLt,qT,GT,ID,oQ,cLt=M(()=>{Ry();lr();$p();iQ=As(),ID={point:qr,lineStart:function(){ID.point=MPe},lineEnd:function(){nQ&&lLt(aLt,sLt),ID.point=qr},polygonStart:function(){nQ=!0},polygonEnd:function(){nQ=null},result:function(){var e=+iQ;return iQ.reset(),e}};oQ=ID});function LD(){this._string=[]}function uLt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}var hLt=M(()=>{LD.prototype={_radius:4.5,_circle:uLt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=uLt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}}});function fLt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),Mo(a,n(i))),i.result()}return o.area=function(a){return Mo(a,n(KJ)),KJ.result()},o.measure=function(a){return Mo(a,n(oQ)),oQ.result()},o.bounds=function(a){return Mo(a,n(N2)),N2.result()},o.centroid=function(a){return Mo(a,n(rQ)),rQ.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,of):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new LD):new PD(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}var pLt=M(()=>{MD();gg();J9t();ZJ();iLt();oLt();cLt();hLt()});function dLt(e){return{stream:xg(e)}}function xg(e){return function(t){var r=new aQ;for(var n in e)r[n]=e[n];return r.stream=t,r}}function aQ(){}var WT=M(()=>{aQ.prototype={constructor:aQ,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}}});function sQ(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),Mo(r,e.stream(N2)),t(N2.result()),n!=null&&e.clipExtent(n),e}function Uy(e,t,r){return sQ(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function O2(e,t,r){return Uy(e,[[0,0],t],r)}function z2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function F2(e,t,r){return sQ(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var kD=M(()=>{gg();ZJ()});function lQ(e,t){return+t?CPe(e,t):TPe(e)}function TPe(e){return xg({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function CPe(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=Rr(S*S+C*C+P*P),O=Jn(P/=k),D=Ye(Ye(P)-1)<ce||Ye(o-h)<ce?(o+h)/2:Sn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Ye((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<EPe)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=vc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],mLt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,mLt,n),_.lineEnd=S,S()}return _}}var mLt,EPe,gLt=M(()=>{A2();lr();WT();mLt=16,EPe=ae(30*we)});function PPe(e){return xg({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function eo(e){return YT(function(){return e})()}function YT(e){var t,r=150,n=480,i=250,o,a,s=0,l=0,c=0,u=0,h=0,f,p,d=null,g=zT,_=null,y,x,b,S=of,C=.5,P=lQ(I,C),k,O;function D(F){return F=p(F[0]*we,F[1]*we),[F[0]*r+o,a-F[1]*r]}function B(F){return F=p.invert((F[0]-o)/r,(a-F[1])/r),F&&[F[0]*Ur,F[1]*Ur]}function I(F,z){return F=t(F,z),[F[0]*r+o,a-F[1]*r]}D.stream=function(F){return k&&O===F?k:k=APe(PPe(f)(g(P(S(O=F)))))},D.preclip=function(F){return arguments.length?(g=F,d=void 0,R()):g},D.postclip=function(F){return arguments.length?(S=F,_=y=x=b=null,R()):S},D.clipAngle=function(F){return arguments.length?(g=+F?_D(d=F*we):(d=null,zT),R()):d*Ur},D.clipExtent=function(F){return arguments.length?(S=F==null?(_=y=x=b=null,of):td(_=+F[0][0],y=+F[0][1],x=+F[1][0],b=+F[1][1]),R()):_==null?null:[[_,y],[x,b]]},D.scale=function(F){return arguments.length?(r=+F,L()):r},D.translate=function(F){return arguments.length?(n=+F[0],i=+F[1],L()):[n,i]},D.center=function(F){return arguments.length?(s=F[0]%360*we,l=F[1]%360*we,L()):[s*Ur,l*Ur]},D.rotate=function(F){return arguments.length?(c=F[0]%360*we,u=F[1]%360*we,h=F.length>2?F[2]%360*we:0,L()):[c*Ur,u*Ur,h*Ur]},D.precision=function(F){return arguments.length?(P=lQ(I,C=F*F),R()):Rr(C)},D.fitExtent=function(F,z){return Uy(D,F,z)},D.fitSize=function(F,z){return O2(D,F,z)},D.fitWidth=function(F,z){return z2(D,F,z)},D.fitHeight=function(F,z){return F2(D,F,z)};function L(){p=sD(f=NT(c,u,h),t);var F=t(s,l);return o=n-F[0]*r,a=i+F[1]*r,R()}function R(){return k=O=null,D}return function(){return t=e.apply(this,arguments),D.invert=t.invert&&B,L()}}var APe,Au=M(()=>{BJ();HJ();BT();gJ();MD();lr();DT();WT();kD();gLt();APe=xg({point:function(e,t){this.stream.point(e*we,t*we)}})});function B2(e){var t=0,r=rr/3,n=YT(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*we,r=o[1]*we):[t*Ur,r*Ur]},i}var RD=M(()=>{lr();Au()});function _Lt(e){var t=ae(e);function r(n,i){return[n*t,Jt(i)/t]}return r.invert=function(n,i){return[n/t,Jn(i*t)]},r}var yLt=M(()=>{lr()});function cQ(e,t){var r=Jt(e),n=(r+Jt(t))/2;if(Ye(n)<ce)return _Lt(e);var i=1+r*(2*n-r),o=Rr(i)/n;function a(s,l){var c=Rr(i-2*n*Jt(l))/n;return[c*Jt(s*=n),o-c*ae(s)]}return a.invert=function(s,l){var c=o-l;return[Sn(s,Ye(c))/n*mg(c),Jn((i-(s*s+c*c)*n*n)/(2*n))]},a}function qy(){return B2(cQ).scale(155.424).center([0,33.6442])}var ND=M(()=>{lr();RD();yLt()});function DD(){return qy().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}var uQ=M(()=>{ND()});function IPe(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function vLt(){var e,t,r=DD(),n,i=qy().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=qy().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=IPe([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+ce,g+.12*p+ce],[d-.214*p-ce,g+.234*p-ce]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+ce,g+.166*p+ce],[d-.115*p-ce,g+.234*p-ce]]).stream(c),h()},u.fitExtent=function(f,p){return Uy(u,f,p)},u.fitSize=function(f,p){return O2(u,f,p)},u.fitWidth=function(f,p){return z2(u,f,p)},u.fitHeight=function(f,p){return F2(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}var xLt=M(()=>{lr();uQ();ND();kD()});function OD(e){return function(t,r){var n=ae(t),i=ae(r),o=e(n*i);return[o*i*Jt(t),o*Jt(r)]}}function lf(e){return function(t,r){var n=Rr(t*t+r*r),i=e(n),o=Jt(i),a=ae(i);return[Sn(t*o,n*a),Jn(n&&r*o/n)]}}var H2=M(()=>{lr()});function bLt(){return eo(zD).scale(124.75).clipAngle(180-.001)}var zD,wLt=M(()=>{lr();H2();Au();zD=OD(function(e){return Rr(2/(1+e))});zD.invert=lf(function(e){return 2*Jn(e/2)})});function SLt(){return eo(FD).scale(79.4188).clipAngle(180-.001)}var FD,MLt=M(()=>{lr();H2();Au();FD=OD(function(e){return(e=KN(e))&&e/Jt(e)});FD.invert=lf(function(e){return e})});function Gy(e,t){return[e,Ny(C2((Bn+t)/2))]}function ELt(){return hQ(Gy).scale(961/Bi)}function hQ(e){var t=eo(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=rr*n(),f=t(lD(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===Gy?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}var BD=M(()=>{lr();DT();Au();Gy.invert=function(e,t){return[e,2*yc(XN(t))-Bn]}});function HD(e){return C2((Bn+e)/2)}function fQ(e,t){var r=ae(e),n=e===t?Jt(e):Ny(r/ae(t))/Ny(HD(t)/HD(e)),i=r*$N(HD(e),n)/n;if(!n)return Gy;function o(a,s){i>0?s<-Bn+ce&&(s=-Bn+ce):s>Bn-ce&&(s=Bn-ce);var l=i/$N(HD(s),n);return[l*Jt(n*a),i-l*ae(n*a)]}return o.invert=function(a,s){var l=i-s,c=mg(n)*Rr(a*a+l*l);return[Sn(a,Ye(l))/n*mg(l),2*yc($N(i/c,1/n))-Bn]},o}function TLt(){return B2(fQ).scale(109.5).parallels([30,30])}var CLt=M(()=>{lr();RD();BD()});function Wy(e,t){return[e,t]}function ALt(){return eo(Wy).scale(152.63)}var pQ=M(()=>{Au();Wy.invert=Wy});function dQ(e,t){var r=ae(e),n=e===t?Jt(e):(r-ae(t))/(t-e),i=r/n+e;if(Ye(n)<ce)return Wy;function o(a,s){var l=i-s,c=n*a;return[l*Jt(c),i-l*ae(c)]}return o.invert=function(a,s){var l=i-s;return[Sn(a,Ye(l))/n*mg(l),i-mg(n)*Rr(a*a+l*l)]},o}function PLt(){return B2(dQ).scale(131.154).center([0,13.9389])}var ILt=M(()=>{lr();RD();pQ()});function VD(e,t){var r=ae(t),n=ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function LLt(){return eo(VD).scale(144.049).clipAngle(60)}var kLt=M(()=>{lr();H2();Au();VD.invert=lf(yc)});function UD(e,t,r,n){return e===1&&t===1&&r===0&&n===0?of:xg({point:function(i,o){this.stream.point(i*e+r,o*t+n)}})}function RLt(){var e=1,t=0,r=0,n=1,i=1,o=of,a=null,s,l,c,u=of,h,f,p;function d(){return h=f=null,p}return p={stream:function(g){return h&&f===g?h:h=o(u(f=g))},postclip:function(g){return arguments.length?(u=g,a=s=l=c=null,d()):u},clipExtent:function(g){return arguments.length?(u=g==null?(a=s=l=c=null,of):td(a=+g[0][0],s=+g[0][1],l=+g[1][0],c=+g[1][1]),d()):a==null?null:[[a,s],[l,c]]},scale:function(g){return arguments.length?(o=UD((e=+g)*n,e*i,t,r),d()):e},translate:function(g){return arguments.length?(o=UD(e*n,e*i,t=+g[0],r=+g[1]),d()):[t,r]},reflectX:function(g){return arguments.length?(o=UD(e*(n=g?-1:1),e*i,t,r),d()):n<0},reflectY:function(g){return arguments.length?(o=UD(e*n,e*(i=g?-1:1),t,r),d()):i<0},fitExtent:function(g,_){return Uy(p,g,_)},fitSize:function(g,_){return O2(p,g,_)},fitWidth:function(g,_){return z2(p,g,_)},fitHeight:function(g,_){return F2(p,g,_)}}}var NLt=M(()=>{BT();MD();WT();kD()});function qD(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}function DLt(){return eo(qD).scale(175.295)}var OLt=M(()=>{Au();lr();qD.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Ye(i)>ce&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]}});function GD(e,t){return[ae(t)*Jt(e),Jt(t)]}function zLt(){return eo(GD).scale(249.5).clipAngle(90+ce)}var FLt=M(()=>{lr();H2();Au();GD.invert=lf(Jn)});function WD(e,t){var r=ae(t),n=1+ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function BLt(){return eo(WD).scale(250).clipAngle(142)}var HLt=M(()=>{lr();H2();Au();WD.invert=lf(function(e){return 2*yc(e)})});function YD(e,t){return[Ny(C2((Bn+t)/2)),-e]}function VLt(){var e=hQ(YD),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}var ULt=M(()=>{lr();BD();YD.invert=function(e,t){return[-t,2*yc(XN(e))-Bn]}});var qLt=M(()=>{uJ();ZIt();i9t();vJ();BJ();HJ();N9t();BT();U9t();WJ();Y9t();X9t();qJ();pLt();uQ();xLt();wLt();MLt();CLt();ND();ILt();pQ();kLt();NLt();Au();BD();OLt();FLt();HLt();ULt();DT();gg();WT()});function LPe(e,t){return e.parent===t.parent?1:2}function kPe(e){return e.reduce(RPe,0)/e.length}function RPe(e,t){return e+t.x}function NPe(e){return 1+e.reduce(DPe,0)}function DPe(e,t){return Math.max(e,t.y)}function OPe(e){for(var t;t=e.children;)e=t[0];return e}function zPe(e){for(var t;t=e.children;)e=t[t.length-1];return e}function GLt(){var e=LPe,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=kPe(p),f.y=NPe(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=OPe(o),c=zPe(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}var WLt=M(()=>{});function FPe(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function YLt(){return this.eachAfter(FPe)}var jLt=M(()=>{});function XLt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}var $Lt=M(()=>{});function KLt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}var ZLt=M(()=>{});function JLt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}var QLt=M(()=>{});function tkt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}var ekt=M(()=>{});function rkt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}var nkt=M(()=>{});function ikt(e){for(var t=this,r=BPe(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function BPe(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}var okt=M(()=>{});function akt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}var skt=M(()=>{});function lkt(){var e=[];return this.each(function(t){e.push(t)}),e}var ckt=M(()=>{});function ukt(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}var hkt=M(()=>{});function fkt(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}var pkt=M(()=>{});function jT(e,t){var r=new bg(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=VPe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new bg(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore(mQ)}function HPe(){return jT(this).eachBefore(UPe)}function VPe(e){return e.children}function UPe(e){e.data=e.data.data}function mQ(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function bg(e){this.data=e,this.depth=this.height=0,this.parent=null}var jD=M(()=>{jLt();$Lt();ZLt();QLt();ekt();nkt();okt();skt();ckt();hkt();pkt();bg.prototype=jT.prototype={constructor:bg,count:YLt,each:XLt,eachAfter:JLt,eachBefore:KLt,sum:tkt,sort:rkt,path:ikt,ancestors:akt,descendants:lkt,leaves:ukt,links:fkt,copy:HPe}});function mkt(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}var dkt,gkt=M(()=>{dkt=Array.prototype.slice});function $D(e){for(var t=0,r=(e=mkt(dkt.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&_kt(o,i)?++t:(o=GPe(n=qPe(n,i)),t=0);return o}function qPe(e,t){var r,n;if(gQ(t,e))return[t];for(r=0;r<e.length;++r)if(XD(t,e[r])&&gQ(XT(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(XD(XT(e[r],e[n]),t)&&XD(XT(e[r],t),e[n])&&XD(XT(e[n],t),e[r])&&gQ(ykt(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function XD(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function _kt(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function gQ(e,t){for(var r=0;r<t.length;++r)if(!_kt(e,t[r]))return!1;return!0}function GPe(e){switch(e.length){case 1:return WPe(e[0]);case 2:return XT(e[0],e[1]);case 3:return ykt(e[0],e[1],e[2])}}function WPe(e){return{x:e.x,y:e.y,r:e.r}}function XT(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function ykt(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}var _Q=M(()=>{gkt()});function vkt(e,t,r){var n=e.x,i=e.y,o=t.r+r.r,a=e.r+r.r,s=t.x-n,l=t.y-i,c=s*s+l*l;if(c){var u=.5+((a*=a)-(o*=o))/(2*c),h=Math.sqrt(Math.max(0,2*o*(a+c)-(a-=c)*a-o*o))/(2*c);r.x=n+u*s+h*l,r.y=i+u*l-h*s}else r.x=n+a,r.y=i}function xkt(e,t){var r=t.x-e.x,n=t.y-e.y,i=e.r+t.r;return i*i-1e-6>r*r+n*n}function bkt(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function KD(e){this._=e,this.next=null,this.previous=null}function yQ(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;vkt(r,t,n=e[2]),t=new KD(t),r=new KD(r),n=new KD(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){vkt(t._,r._,n=e[s]),n=new KD(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(xkt(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(xkt(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=bkt(t);(n=n.next)!==r;)(a=bkt(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=$D(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function wkt(e){return yQ(e),e}var vQ=M(()=>{_Q()});function Skt(e){return e==null?null:V2(e)}function V2(e){if(typeof e!="function")throw new Error;return e}var ZD=M(()=>{});function ed(){return 0}function wg(e){return function(){return e}}var xQ=M(()=>{});function YPe(e){return Math.sqrt(e.value)}function Tkt(){var e=null,t=1,r=1,n=ed;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(Mkt(e)).eachAfter(bQ(n,.5)).eachBefore(Ekt(1)):o.eachBefore(Mkt(YPe)).eachAfter(bQ(ed,1)).eachAfter(bQ(n,o.r/Math.min(t,r))).eachBefore(Ekt(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=Skt(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:wg(+o),i):n},i}function Mkt(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function bQ(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=yQ(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function Ekt(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}var Ckt=M(()=>{vQ();ZD();xQ()});function JD(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}var wQ=M(()=>{});function cf(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}var U2=M(()=>{});function Akt(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(JD),a}function o(a,s){return function(l){l.children&&cf(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var Pkt=M(()=>{wQ();U2()});function XPe(e){return e.id}function $Pe(e){return e.parentId}function kkt(){var e=XPe,t=$Pe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new bg(i),(h=e(i,o,n))!=null&&(h+="")&&(f=Ikt+(c.id=h),p[f]=f in p?Lkt:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[Ikt+h],!l)throw new Error("missing: "+h);if(l===Lkt)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=jPe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore(mQ),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=V2(n),r):e},r.parentId=function(n){return arguments.length?(t=V2(n),r):t},r}var Ikt,jPe,Lkt,Rkt=M(()=>{ZD();jD();Ikt="$",jPe={depth:-1},Lkt={}});function KPe(e,t){return e.parent===t.parent?1:2}function SQ(e){var t=e.children;return t?t[0]:e.t}function MQ(e){var t=e.children;return t?t[t.length-1]:e.t}function ZPe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function JPe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function QPe(e,t,r){return e.a.parent===t.parent?e.a:r}function QD(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}function t6e(e){for(var t=new QD(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new QD(o[a],a)),i.parent=r;return(t.parent=new QD(null,0)).children=[t],t}function Nkt(){var e=KPe,t=1,r=1,n=null;function i(c){var u=t6e(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){JPe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=MQ(d),f=SQ(f),d&&f;)g=SQ(g),p=MQ(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(ZPe(QPe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!MQ(p)&&(p.t=d,p.m+=x-y),f&&!SQ(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}var Dkt=M(()=>{jD();QD.prototype=Object.create(bg.prototype)});function Sg(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var $T=M(()=>{});function TQ(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?cf(l,r,n,i,g?n+=d*_/g:o):Sg(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var EQ,tO,eO=M(()=>{U2();$T();EQ=(1+Math.sqrt(5))/2;tO=function e(t){function r(n,i,o,a,s){TQ(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});function Okt(){var e=tO,t=!1,r=1,n=1,i=[0],o=ed,a=ed,s=ed,l=ed,c=ed;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(JD),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=V2(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:wg(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:wg(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:wg(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:wg(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:wg(+f),u):c},u}var zkt=M(()=>{wQ();eO();ZD();xQ()});function Fkt(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}var Bkt=M(()=>{});function Hkt(e,t,r,n,i){(e.depth&1?Sg:cf)(e,t,r,n,i)}var Vkt=M(()=>{U2();$T()});var Ukt,qkt=M(()=>{U2();$T();eO();Ukt=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?cf(c,i,o,a,o+=(s-o)*c.value/g):Sg(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=TQ(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(EQ)});var Gkt=M(()=>{WLt();jD();Ckt();vQ();_Q();Pkt();Rkt();Dkt();zkt();Bkt();U2();$T();Vkt();eO();qkt()});function rd(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Mg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var rO=M(()=>{});function ff(){}function Ykt(){return this.rgb().formatHex()}function l6e(){return Jkt(this).formatHsl()}function jkt(){return this.rgb().formatRgb()}function Tg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=e6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?Xkt(t):r===3?new ro(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=r6e.exec(e))?new ro(t[1],t[2],t[3],1):(t=n6e.exec(e))?new ro(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=i6e.exec(e))?nO(t[1],t[2],t[3],t[4]):(t=o6e.exec(e))?nO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=a6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,1):(t=s6e.exec(e))?Zkt(t[1],t[2]/100,t[3]/100,t[4]):Wkt.hasOwnProperty(e)?Xkt(Wkt[e]):e==="transparent"?new ro(NaN,NaN,NaN,0):null}function Xkt(e){return new ro(e>>16&255,e>>8&255,e&255,1)}function nO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ro(e,t,r,n)}function ZT(e){return e instanceof ff||(e=Tg(e)),e?(e=e.rgb(),new ro(e.r,e.g,e.b,e.opacity)):new ro}function G2(e,t,r,n){return arguments.length===1?ZT(e):new ro(e,t,r,n==null?1:n)}function ro(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function $kt(){return"#"+CQ(this.r)+CQ(this.g)+CQ(this.b)}function Kkt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function CQ(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function Zkt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new uf(e,t,r,n)}function Jkt(e){if(e instanceof uf)return new uf(e.h,e.s,e.l,e.opacity);if(e instanceof ff||(e=Tg(e)),!e)return new uf;if(e instanceof uf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new uf(a,s,l,e.opacity)}function JT(e,t,r,n){return arguments.length===1?Jkt(e):new uf(e,t,r,n==null?1:n)}function uf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function AQ(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Eg,Yy,q2,KT,hf,e6e,r6e,n6e,i6e,o6e,a6e,s6e,Wkt,iO=M(()=>{rO();Eg=.7,Yy=1/Eg,q2="\\s*([+-]?\\d+)\\s*",KT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",hf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",e6e=/^#([0-9a-f]{3,8})$/,r6e=new RegExp("^rgb\\("+[q2,q2,q2]+"\\)$"),n6e=new RegExp("^rgb\\("+[hf,hf,hf]+"\\)$"),i6e=new RegExp("^rgba\\("+[q2,q2,q2,KT]+"\\)$"),o6e=new RegExp("^rgba\\("+[hf,hf,hf,KT]+"\\)$"),a6e=new RegExp("^hsl\\("+[KT,hf,hf]+"\\)$"),s6e=new RegExp("^hsla\\("+[KT,hf,hf,KT]+"\\)$"),Wkt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};rd(ff,Tg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:Ykt,formatHex:Ykt,formatHsl:l6e,formatRgb:jkt,toString:jkt});rd(ro,G2,Mg(ff,{brighter:function(e){return e=e==null?Yy:Math.pow(Yy,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Eg:Math.pow(Eg,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:$kt,formatHex:$kt,formatRgb:Kkt,toString:Kkt}));rd(uf,JT,Mg(ff,{brighter:function(e){return e=e==null?Yy:Math.pow(Yy,e),new uf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Eg:Math.pow(Eg,e),new uf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ro(AQ(e>=240?e-240:e+120,i,n),AQ(e,i,n),AQ(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var oO,aO,PQ=M(()=>{oO=Math.PI/180,aO=180/Math.PI});function i8t(e){if(e instanceof pf)return new pf(e.l,e.a,e.b,e.opacity);if(e instanceof nd)return o8t(e);e instanceof ro||(e=ZT(e));var t=RQ(e.r),r=RQ(e.g),n=RQ(e.b),i=IQ((.2225045*t+.7168786*r+.0606169*n)/t8t),o,a;return t===r&&r===n?o=a=i:(o=IQ((.4360747*t+.3850649*r+.1430804*n)/Qkt),a=IQ((.0139322*t+.0971045*r+.7141733*n)/e8t)),new pf(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Y2(e,t,r,n){return arguments.length===1?i8t(e):new pf(e,t,r,n==null?1:n)}function pf(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function IQ(e){return e>c6e?Math.pow(e,1/3):e/n8t+r8t}function LQ(e){return e>W2?e*e*e:n8t*(e-r8t)}function kQ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function RQ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function u6e(e){if(e instanceof nd)return new nd(e.h,e.c,e.l,e.opacity);if(e instanceof pf||(e=i8t(e)),e.a===0&&e.b===0)return new nd(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*aO;return new nd(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function QT(e,t,r,n){return arguments.length===1?u6e(e):new nd(e,t,r,n==null?1:n)}function nd(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function o8t(e){if(isNaN(e.h))return new pf(e.l,0,0,e.opacity);var t=e.h*oO;return new pf(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}var sO,Qkt,t8t,e8t,r8t,W2,n8t,c6e,a8t=M(()=>{rO();iO();PQ();sO=18,Qkt=.96422,t8t=1,e8t=.82521,r8t=4/29,W2=6/29,n8t=3*W2*W2,c6e=W2*W2*W2;rd(pf,Y2,Mg(ff,{brighter:function(e){return new pf(this.l+sO*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new pf(this.l-sO*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=Qkt*LQ(t),e=t8t*LQ(e),r=e8t*LQ(r),new ro(kQ(3.1338561*t-1.6168667*e-.4906146*r),kQ(-.9787684*t+1.9161415*e+.033454*r),kQ(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));rd(nd,QT,Mg(ff,{brighter:function(e){return new nd(this.h,this.c,this.l+sO*(e==null?1:e),this.opacity)},darker:function(e){return new nd(this.h,this.c,this.l-sO*(e==null?1:e),this.opacity)},rgb:function(){return o8t(this).rgb()}}))});function h6e(e){if(e instanceof jy)return new jy(e.h,e.s,e.l,e.opacity);e instanceof ro||(e=ZT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(c8t*n+s8t*t-l8t*r)/(c8t+s8t-l8t),o=n-i,a=(tC*(r-i)-DQ*o)/lO,s=Math.sqrt(a*a+o*o)/(tC*i*(1-i)),l=s?Math.atan2(a,o)*aO-120:NaN;return new jy(l<0?l+360:l,s,i,e.opacity)}function j2(e,t,r,n){return arguments.length===1?h6e(e):new jy(e,t,r,n==null?1:n)}function jy(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var u8t,NQ,DQ,lO,tC,s8t,l8t,c8t,h8t=M(()=>{rO();iO();PQ();u8t=-.14861,NQ=1.78277,DQ=-.29227,lO=-.90649,tC=1.97294,s8t=tC*lO,l8t=tC*NQ,c8t=NQ*DQ-lO*u8t;rd(jy,j2,Mg(ff,{brighter:function(e){return e=e==null?Yy:Math.pow(Yy,e),new jy(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Eg:Math.pow(Eg,e),new jy(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*oO,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ro(255*(t+r*(u8t*n+NQ*i)),255*(t+r*(DQ*n+lO*i)),255*(t+r*(tC*n)),this.opacity)}}))});var Xy=M(()=>{iO();a8t();h8t()});function OQ(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function cO(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return OQ((r-n/t)*t,a,i,o,s)}}var uO=M(()=>{});function hO(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return OQ((r-n/t)*t,i,o,a,s)}}var zQ=M(()=>{uO()});function X2(e){return function(){return e}}var FQ=M(()=>{});function f8t(e,t){return function(r){return e+r*t}}function f6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function $2(e,t){var r=t-e;return r?f8t(e,r>180||r<-180?r-360*Math.round(r/360):r):X2(isNaN(e)?t:e)}function p8t(e){return(e=+e)==1?Qn:function(t,r){return r-t?f6e(t,r,e):X2(isNaN(t)?r:t)}}function Qn(e,t){var r=t-e;return r?f8t(e,r):X2(isNaN(e)?t:e)}var K2=M(()=>{FQ()});function d8t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=G2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var eC,m8t,g8t,BQ=M(()=>{Xy();uO();zQ();K2();eC=function e(t){var r=p8t(t);function n(i,o){var a=r((i=G2(i)).r,(o=G2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Qn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);m8t=d8t(cO),g8t=d8t(hO)});function fO(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=Z2(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var HQ=M(()=>{pO()});function dO(e,t){var r=new Date;return e=+e,t-=e,function(n){return r.setTime(e+t*n),r}}var VQ=M(()=>{});function Ps(e,t){return e=+e,t-=e,function(r){return e+t*r}}var rC=M(()=>{});function mO(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=Z2(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var UQ=M(()=>{pO()});function p6e(e){return function(){return e}}function d6e(e){return function(t){return e(t)+""}}function gO(e,t){var r=GQ.lastIndex=qQ.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=GQ.exec(e))&&(i=qQ.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ps(n,i)})),r=qQ.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?d6e(l[0].x):p6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var GQ,qQ,WQ=M(()=>{rC();GQ=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,qQ=new RegExp(GQ.source,"g")});function Z2(e,t){var r=typeof t,n;return t==null||r==="boolean"?X2(t):(r==="number"?Ps:r==="string"?(n=Tg(t))?(t=n,eC):gO:t instanceof Tg?eC:t instanceof Date?dO:Array.isArray(t)?fO:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?mO:Ps)(e,t)}var pO=M(()=>{Xy();BQ();HQ();VQ();rC();UQ();WQ();FQ()});function _8t(e,t){return e=+e,t-=e,function(r){return Math.round(e+t*r)}}var y8t=M(()=>{});function YQ(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*v8t,skewX:Math.atan(l)*v8t,scaleX:a,scaleY:s}}var v8t,_O,x8t=M(()=>{v8t=180/Math.PI,_O={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function w8t(e){return e==="none"?_O:(nC||(nC=document.createElement("DIV"),jQ=document.documentElement,b8t=document.defaultView),nC.style.transform=e,e=b8t.getComputedStyle(jQ.appendChild(nC),null).getPropertyValue("transform"),jQ.removeChild(nC),e=e.slice(7,-1).split(","),YQ(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function S8t(e){return e==null?_O:(yO||(yO=document.createElementNS("http://www.w3.org/2000/svg","g")),yO.setAttribute("transform",e),(e=yO.transform.baseVal.consolidate())?(e=e.matrix,YQ(e.a,e.b,e.c,e.d,e.e,e.f)):_O)}var nC,jQ,b8t,yO,M8t=M(()=>{x8t()});function E8t(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ps(c,h)},{i:g-2,x:Ps(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ps(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ps(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ps(c,h)},{i:g-2,x:Ps(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var T8t,C8t,A8t=M(()=>{rC();M8t();T8t=E8t(w8t,"px, ","px)","deg)"),C8t=E8t(S8t,", ",")",")")});function I8t(e){return((e=Math.exp(e))+1/e)/2}function g6e(e){return((e=Math.exp(e))-1/e)/2}function _6e(e){return((e=Math.exp(2*e))-1)/(e+1)}function L8t(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<m6e)f=Math.log(s/i)/iC,h=function(x){return[r+x*l,n+x*c,i*Math.exp(iC*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+P8t*u)/(2*i*XQ*p),g=(s*s-i*i-P8t*u)/(2*s*XQ*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/iC,h=function(x){var b=x*f,S=I8t(_),C=i/(XQ*p)*(S*_6e(iC*b+_)-g6e(_));return[r+C*l,n+C*c,i*S/I8t(iC*b+_)]}}return h.duration=f*1e3,h}var iC,XQ,P8t,m6e,k8t=M(()=>{iC=Math.SQRT2,XQ=2,P8t=4,m6e=1e-12});function R8t(e){return function(t,r){var n=e((t=JT(t)).h,(r=JT(r)).h),i=Qn(t.s,r.s),o=Qn(t.l,r.l),a=Qn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var N8t,D8t,O8t=M(()=>{Xy();K2();N8t=R8t($2),D8t=R8t(Qn)});function $Q(e,t){var r=Qn((e=Y2(e)).l,(t=Y2(t)).l),n=Qn(e.a,t.a),i=Qn(e.b,t.b),o=Qn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}var z8t=M(()=>{Xy();K2()});function F8t(e){return function(t,r){var n=e((t=QT(t)).h,(r=QT(r)).h),i=Qn(t.c,r.c),o=Qn(t.l,r.l),a=Qn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var B8t,H8t,V8t=M(()=>{Xy();K2();B8t=F8t($2),H8t=F8t(Qn)});function U8t(e){return function t(r){r=+r;function n(i,o){var a=e((i=j2(i)).h,(o=j2(o)).h),s=Qn(i.s,o.s),l=Qn(i.l,o.l),c=Qn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var q8t,G8t,W8t=M(()=>{Xy();K2();q8t=U8t($2),G8t=U8t(Qn)});function Y8t(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}var j8t=M(()=>{});var X8t=M(()=>{pO();HQ();uO();zQ();VQ();rC();UQ();y8t();WQ();A8t();k8t();BQ();O8t();z8t();V8t();W8t();j8t()});function JQ(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function $8t(){return new JQ}var KQ,ZQ,$y,y6e,K8t,Z8t=M(()=>{KQ=Math.PI,ZQ=2*KQ,$y=1e-6,y6e=ZQ-$y;JQ.prototype=$8t.prototype={constructor:JQ,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>$y)if(!(Math.abs(u*s-l*c)>$y)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((KQ-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>$y&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>$y||Math.abs(this._y1-c)>$y)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%ZQ+ZQ),h>y6e?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>$y&&(this._+="A"+r+","+r+",0,"+ +(h>=KQ)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};K8t=$8t});var J8t=M(()=>{Z8t()});function Q8t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}var tRt=M(()=>{});function eRt(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}var rRt=M(()=>{});function nRt(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}var iRt=M(()=>{});function v6e(e,t){return e[0]-t[0]||e[1]-t[1]}function oRt(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&nRt(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function aRt(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(v6e),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=oRt(n),a=oRt(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}var sRt=M(()=>{iRt()});function lRt(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}var cRt=M(()=>{});function uRt(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}var hRt=M(()=>{});var fRt=M(()=>{tRt();rRt();sRt();cRt();hRt()});function pRt(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return dRt(this.cover(t,r),t,r,e)}function dRt(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function mRt(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));for(u<l&&(l=this._x0,u=this._x1),h<c&&(c=this._y0,h=this._y1),this.cover(l,c).cover(u,h),r=0;r<n;++r)dRt(this,a[r],s[r],e[r]);return this}var gRt=M(()=>{});function _Rt(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else if(r>e||e>i||n>t||t>o){var a=i-r,s=this._root,l,c;switch(c=(t<(n+o)/2)<<1|e<(r+i)/2){case 0:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,o=n+a,e>i||t>o);break}case 1:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,o=n+a,r>e||t>o);break}case 2:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,n=o-a,e>i||n>t);break}case 3:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,n=o-a,r>e||n>t);break}}this._root&&this._root.length&&(this._root=s)}else return this;return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var yRt=M(()=>{});function vRt(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var xRt=M(()=>{});function bRt(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var wRt=M(()=>{});function Eo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var vO=M(()=>{});function SRt(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new Eo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new Eo(p[3],_,y,l,c),new Eo(p[2],a,y,_,c),new Eo(p[1],_,s,l,y),new Eo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var MRt=M(()=>{vO()});function ERt(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function TRt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var CRt=M(()=>{});function ARt(){return this._root}var PRt=M(()=>{});function IRt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var LRt=M(()=>{});function kRt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new Eo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new Eo(i,c,u,s,l)),(i=n[2])&&t.push(new Eo(i,o,u,c,l)),(i=n[1])&&t.push(new Eo(i,c,a,s,u)),(i=n[0])&&t.push(new Eo(i,o,a,c,u))}return this}var RRt=M(()=>{vO()});function NRt(e){var t=[],r=[],n;for(this._root&&t.push(new Eo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new Eo(o,a,s,u,h)),(o=i[1])&&t.push(new Eo(o,u,s,l,h)),(o=i[2])&&t.push(new Eo(o,a,h,u,c)),(o=i[3])&&t.push(new Eo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var DRt=M(()=>{vO()});function ORt(e){return e[0]}function zRt(e){return arguments.length?(this._x=e,this):this._x}var FRt=M(()=>{});function BRt(e){return e[1]}function HRt(e){return arguments.length?(this._y=e,this):this._y}var VRt=M(()=>{});function xO(e,t,r){var n=new QQ(t==null?ORt:t,r==null?BRt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function QQ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function URt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var $a,qRt=M(()=>{gRt();yRt();xRt();wRt();MRt();CRt();PRt();LRt();RRt();DRt();FRt();VRt();$a=xO.prototype=QQ.prototype;$a.copy=function(){var e=new QQ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=URt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=URt(n));return e};$a.add=pRt;$a.addAll=mRt;$a.cover=_Rt;$a.data=vRt;$a.extent=bRt;$a.find=SRt;$a.remove=ERt;$a.removeAll=TRt;$a.root=ARt;$a.size=IRt;$a.visit=kRt;$a.visitAfter=NRt;$a.x=zRt;$a.y=HRt});var GRt=M(()=>{qRt()});var WRt,YRt=M(()=>{WRt=[].slice});function ttt(e){this._size=e,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function jRt(e){if(!e._start)try{b6e(e)}catch(t){if(e._tasks[e._ended+e._active-1])ett(e,t);else if(!e._data)throw t}}function b6e(e){for(;e._start=e._waiting&&e._active<e._size;){var t=e._ended+e._active,r=e._tasks[t],n=r.length-1,i=r[n];r[n]=w6e(e,t),--e._waiting,++e._active,r=i.apply(null,r),e._tasks[t]&&(e._tasks[t]=r||x6e)}}function w6e(e,t){return function(r,n){!e._tasks[t]||(--e._active,++e._ended,e._tasks[t]=null,e._error==null&&(r!=null?ett(e,r):(e._data[t]=n,e._waiting?jRt(e):bO(e))))}}function ett(e,t){var r=e._tasks.length,n;for(e._error=t,e._data=void 0,e._waiting=NaN;--r>=0;)if((n=e._tasks[r])&&(e._tasks[r]=null,n.abort))try{n.abort()}catch(i){}e._active=NaN,bO(e)}function bO(e){if(!e._active&&e._call){var t=e._data;e._data=void 0,e._call(e._error,t)}}function wO(e){if(e==null)e=1/0;else if(!((e=+e)>=1))throw new Error("invalid concurrency");return new ttt(e)}var x6e,XRt=M(()=>{YRt();x6e={};ttt.prototype=wO.prototype={constructor:ttt,defer:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("defer after await");if(this._error!=null)return this;var t=WRt.call(arguments,1);return t.push(e),++this._waiting,this._tasks.push(t),jRt(this),this},abort:function(){return this._error==null&&ett(this,new Error("abort")),this},await:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=function(t,r){e.apply(null,[t].concat(r))},bO(this),this},awaitAll:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=e,bO(this),this}}});var $Rt=M(()=>{XRt()});function bc(){return Math.random()}var Ky=M(()=>{});var KRt,ZRt=M(()=>{Ky();KRt=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(bc)});var SO,rtt=M(()=>{Ky();SO=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(bc)});var JRt,QRt=M(()=>{Ky();rtt();JRt=function e(t){function r(){var n=SO.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(bc)});var MO,ntt=M(()=>{Ky();MO=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(bc)});var tNt,eNt=M(()=>{Ky();ntt();tNt=function e(t){function r(n){var i=MO.source(t)(n);return function(){return i()/n}}return r.source=e,r}(bc)});var rNt,nNt=M(()=>{Ky();rNt=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(bc)});var iNt=M(()=>{ZRt();rtt();QRt();eNt();ntt();nNt()});function J2(e,t){var r,n=xs("beforesend","progress","load","error"),i,o=Ji(),a=new XMLHttpRequest,s=null,l=null,c,u,h=0;typeof XDomainRequest!="undefined"&&!("withCredentials"in a)&&/^(http(s)?:)?\/\//.test(e)&&(a=new XDomainRequest),"onload"in a?a.onload=a.onerror=a.ontimeout=f:a.onreadystatechange=function(p){a.readyState>3&&f(p)};function f(p){var d=a.status,g;if(!d&&M6e(a)||d>=200&&d<300||d===304){if(c)try{g=c.call(r,a)}catch(_){n.call("error",r,_);return}else g=a;n.call("load",r,g)}else n.call("error",r,p)}if(a.onprogress=function(p){n.call("progress",r,p)},r={header:function(p,d){return p=(p+"").toLowerCase(),arguments.length<2?o.get(p):(d==null?o.remove(p):o.set(p,d+""),r)},mimeType:function(p){return arguments.length?(i=p==null?null:p+"",r):i},responseType:function(p){return arguments.length?(u=p,r):u},timeout:function(p){return arguments.length?(h=+p,r):h},user:function(p){return arguments.length<1?s:(s=p==null?null:p+"",r)},password:function(p){return arguments.length<1?l:(l=p==null?null:p+"",r)},response:function(p){return c=p,r},get:function(p,d){return r.send("GET",p,d)},post:function(p,d){return r.send("POST",p,d)},send:function(p,d,g){return a.open(p,e,!0,s,l),i!=null&&!o.has("accept")&&o.set("accept",i+",*/*"),a.setRequestHeader&&o.each(function(_,y){a.setRequestHeader(y,_)}),i!=null&&a.overrideMimeType&&a.overrideMimeType(i),u!=null&&(a.responseType=u),h>0&&(a.timeout=h),g==null&&typeof d=="function"&&(g=d,d=null),g!=null&&g.length===1&&(g=S6e(g)),g!=null&&r.on("error",g).on("load",function(_){g(null,_)}),n.call("beforesend",r,a),a.send(d==null?null:d),r},abort:function(){return a.abort(),r},on:function(){var p=n.on.apply(n,arguments);return p===n?r:p}},t!=null){if(typeof t!="function")throw new Error("invalid callback: "+t);return r.get(t)}return r}function S6e(e){return function(t,r){e(t==null?r:null)}}function M6e(e){var t=e.responseType;return t&&t!=="text"?e.response:e.responseText}var EO=M(()=>{Tb();Rm()});function Cg(e,t){return function(r,n){var i=J2(r).mimeType(e).response(t);if(n!=null){if(typeof n!="function")throw new Error("invalid callback: "+n);return i.get(n)}return i}}var oC=M(()=>{EO()});var oNt,aNt=M(()=>{oC();oNt=Cg("text/html",function(e){return document.createRange().createContextualFragment(e.responseText)})});var sNt,lNt=M(()=>{oC();sNt=Cg("application/json",function(e){return JSON.parse(e.responseText)})});var cNt,uNt=M(()=>{oC();cNt=Cg("text/plain",function(e){return e.responseText})});var hNt,fNt=M(()=>{oC();hNt=Cg("application/xml",function(e){var t=e.responseXML;if(!t)throw new Error("parse error");return t})});function TO(e,t){return function(r,n,i){arguments.length<3&&(i=n,n=null);var o=J2(r).mimeType(e);return o.row=function(a){return arguments.length?o.response(E6e(t,n=a)):n},o.row(n),i?o.get(i):o}}function E6e(e,t){return function(r){return e(r.responseText,t)}}var itt=M(()=>{EO()});var pNt,dNt=M(()=>{qE();itt();pNt=TO("text/csv",Cb)});var mNt,gNt=M(()=>{qE();itt();mNt=TO("text/tab-separated-values",Ab)});var _Nt=M(()=>{EO();aNt();lNt();uNt();fNt();dNt();gNt()});function df(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Zy=M(()=>{});function aC(e){return e.length===1&&(e=T6e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function T6e(e){return function(t,r){return df(e(t),r)}}var ott=M(()=>{Zy()});var yNt,vNt,C6e,mf,att=M(()=>{Zy();ott();yNt=aC(df),vNt=yNt.right,C6e=yNt.left,mf=vNt});var stt=M(()=>{});var xNt=M(()=>{stt()});var bNt=M(()=>{});function Q2(e){return e===null?NaN:+e}var tw=M(()=>{});var ltt=M(()=>{tw()});var ctt=M(()=>{ltt()});var utt=M(()=>{});var wNt,P6e,I6e,htt=M(()=>{wNt=Array.prototype,P6e=wNt.slice,I6e=wNt.map});var SNt=M(()=>{});var MNt=M(()=>{});function CO(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var ftt=M(()=>{});function sC(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=ew(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function ew(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=ptt?10:o>=dtt?5:o>=mtt?2:1)}function Jy(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=ptt?i*=10:o>=dtt?i*=5:o>=mtt&&(i*=2),t<e?-i:i}var ptt,dtt,mtt,gtt=M(()=>{ptt=Math.sqrt(50),dtt=Math.sqrt(10),mtt=Math.sqrt(2)});var _tt=M(()=>{});var ENt=M(()=>{htt();att();SNt();utt();MNt();ftt();gtt();_tt()});function lC(e,t,r){if(r==null&&(r=Q2),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var AO=M(()=>{tw()});var TNt=M(()=>{htt();Zy();tw();AO()});var CNt=M(()=>{ctt()});var ANt=M(()=>{});var PNt=M(()=>{tw()});var INt=M(()=>{Zy();tw();AO()});var LNt=M(()=>{});var ytt=M(()=>{});var kNt=M(()=>{});var RNt=M(()=>{Zy()});var NNt=M(()=>{});var DNt=M(()=>{});var vtt=M(()=>{ytt()});var ONt=M(()=>{vtt()});var gf=M(()=>{att();Zy();ott();xNt();bNt();ctt();utt();ENt();TNt();CNt();_tt();ANt();PNt();INt();LNt();ytt();stt();kNt();AO();ftt();RNt();NNt();DNt();gtt();vtt();ltt();ONt()});function PO(){}function zNt(e,t){var r=new PO;if(e instanceof PO)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var pl,Qy,IO=M(()=>{pl="$";PO.prototype=zNt.prototype={constructor:PO,has:function(e){return pl+e in this},get:function(e){return this[pl+e]},set:function(e,t){return this[pl+e]=t,this},remove:function(e){var t=pl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===pl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===pl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===pl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===pl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===pl&&++e;return e},empty:function(){for(var e in this)if(e[0]===pl)return!1;return!0},each:function(e){for(var t in this)t[0]===pl&&e(this[t],t.slice(1),this)}};Qy=zNt});var FNt=M(()=>{IO()});function LO(){}function O6e(e,t){var r=new LO;if(e instanceof LO)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var tv,BNt=M(()=>{IO();tv=Qy.prototype;LO.prototype=O6e.prototype={constructor:LO,has:tv.has,add:function(e){return e+="",this[pl+e]=e,this},remove:tv.remove,clear:tv.clear,values:tv.keys,size:tv.size,empty:tv.empty,each:tv.each}});var HNt=M(()=>{});var VNt=M(()=>{});var UNt=M(()=>{});var qNt=M(()=>{FNt();BNt();IO();HNt();VNt();UNt()});var GNt,rw,dl,Ag=M(()=>{GNt=Array.prototype,rw=GNt.map,dl=GNt.slice});function nw(e){var t=Qy(),r=[],n=kO;e=e==null?[]:dl.call(e);function i(o){var a=o+"",s=t.get(a);if(!s){if(n!==kO)return n;t.set(a,s=r.push(o))}return e[(s-1)%e.length]}return i.domain=function(o){if(!arguments.length)return r.slice();r=[],t=Qy();for(var a=-1,s=o.length,l,c;++a<s;)t.has(c=(l=o[a])+"")||t.set(c,r.push(l));return i},i.range=function(o){return arguments.length?(e=dl.call(o),i):e.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return nw().domain(r).range(e).unknown(n)},i}var kO,xtt=M(()=>{qNt();Ag();kO={name:"implicit"}});function cC(){var e=nw().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=CO(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=l=Math.max(0,Math.min(1,h)),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.max(0,Math.min(1,h)),u()):s},e.paddingOuter=function(h){return arguments.length?(l=Math.max(0,Math.min(1,h)),u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return cC().domain(t()).range(n).round(a).paddingInner(s).paddingOuter(l).align(c)},u()}function WNt(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return WNt(t())},e}function YNt(){return WNt(cC().paddingInner(1))}var jNt=M(()=>{gf();xtt()});function iw(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function uC(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var btt=M(()=>{});function rv(){}function $Nt(){return this.rgb().formatHex()}function G6e(){return eDt(this).formatHsl()}function KNt(){return this.rgb().formatRgb()}function Ig(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=z6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?ZNt(t):r===3?new fa(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?RO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?RO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=F6e.exec(e))?new fa(t[1],t[2],t[3],1):(t=B6e.exec(e))?new fa(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=H6e.exec(e))?RO(t[1],t[2],t[3],t[4]):(t=V6e.exec(e))?RO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=U6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,1):(t=q6e.exec(e))?tDt(t[1],t[2]/100,t[3]/100,t[4]):XNt.hasOwnProperty(e)?ZNt(XNt[e]):e==="transparent"?new fa(NaN,NaN,NaN,0):null}function ZNt(e){return new fa(e>>16&255,e>>8&255,e&255,1)}function RO(e,t,r,n){return n<=0&&(e=t=r=NaN),new fa(e,t,r,n)}function Mtt(e){return e instanceof rv||(e=Ig(e)),e?(e=e.rgb(),new fa(e.r,e.g,e.b,e.opacity)):new fa}function aw(e,t,r,n){return arguments.length===1?Mtt(e):new fa(e,t,r,n==null?1:n)}function fa(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function JNt(){return"#"+wtt(this.r)+wtt(this.g)+wtt(this.b)}function QNt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function wtt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function tDt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new _f(e,t,r,n)}function eDt(e){if(e instanceof _f)return new _f(e.h,e.s,e.l,e.opacity);if(e instanceof rv||(e=Ig(e)),!e)return new _f;if(e instanceof _f)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new _f(a,s,l,e.opacity)}function rDt(e,t,r,n){return arguments.length===1?eDt(e):new _f(e,t,r,n==null?1:n)}function _f(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Stt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Pg,ev,ow,hC,yf,z6e,F6e,B6e,H6e,V6e,U6e,q6e,XNt,Ett=M(()=>{btt();Pg=.7,ev=1/Pg,ow="\\s*([+-]?\\d+)\\s*",hC="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",yf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",z6e=/^#([0-9a-f]{3,8})$/,F6e=new RegExp("^rgb\\("+[ow,ow,ow]+"\\)$"),B6e=new RegExp("^rgb\\("+[yf,yf,yf]+"\\)$"),H6e=new RegExp("^rgba\\("+[ow,ow,ow,hC]+"\\)$"),V6e=new RegExp("^rgba\\("+[yf,yf,yf,hC]+"\\)$"),U6e=new RegExp("^hsl\\("+[hC,yf,yf]+"\\)$"),q6e=new RegExp("^hsla\\("+[hC,yf,yf,hC]+"\\)$"),XNt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};iw(rv,Ig,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:$Nt,formatHex:$Nt,formatHsl:G6e,formatRgb:KNt,toString:KNt});iw(fa,aw,uC(rv,{brighter:function(e){return e=e==null?ev:Math.pow(ev,e),new fa(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Pg:Math.pow(Pg,e),new fa(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:JNt,formatHex:JNt,formatRgb:QNt,toString:QNt}));iw(_f,rDt,uC(rv,{brighter:function(e){return e=e==null?ev:Math.pow(ev,e),new _f(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Pg:Math.pow(Pg,e),new _f(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new fa(Stt(e>=240?e-240:e+120,i,n),Stt(e,i,n),Stt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var nDt,iDt,oDt=M(()=>{nDt=Math.PI/180,iDt=180/Math.PI});function W6e(e){if(e instanceof nv)return new nv(e.h,e.s,e.l,e.opacity);e instanceof fa||(e=Mtt(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(lDt*n+aDt*t-sDt*r)/(lDt+aDt-sDt),o=n-i,a=(fC*(r-i)-Ctt*o)/NO,s=Math.sqrt(a*a+o*o)/(fC*i*(1-i)),l=s?Math.atan2(a,o)*iDt-120:NaN;return new nv(l<0?l+360:l,s,i,e.opacity)}function Ka(e,t,r,n){return arguments.length===1?W6e(e):new nv(e,t,r,n==null?1:n)}function nv(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var cDt,Ttt,Ctt,NO,fC,aDt,sDt,lDt,uDt=M(()=>{btt();Ett();oDt();cDt=-.14861,Ttt=1.78277,Ctt=-.29227,NO=-.90649,fC=1.97294,aDt=fC*NO,sDt=fC*Ttt,lDt=Ttt*Ctt-NO*cDt;iw(nv,Ka,uC(rv,{brighter:function(e){return e=e==null?ev:Math.pow(ev,e),new nv(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Pg:Math.pow(Pg,e),new nv(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*nDt,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new fa(255*(t+r*(cDt*n+Ttt*i)),255*(t+r*(Ctt*n+NO*i)),255*(t+r*(fC*n)),this.opacity)}}))});var sw=M(()=>{Ett();uDt()});function Att(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function hDt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Att((r-n/t)*t,a,i,o,s)}}var Ptt=M(()=>{});function fDt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Att((r-n/t)*t,i,o,a,s)}}var pDt=M(()=>{Ptt()});function lw(e){return function(){return e}}var Itt=M(()=>{});function dDt(e,t){return function(r){return e+r*t}}function Y6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function mDt(e,t){var r=t-e;return r?dDt(e,r>180||r<-180?r-360*Math.round(r/360):r):lw(isNaN(e)?t:e)}function gDt(e){return(e=+e)==1?id:function(t,r){return r-t?Y6e(t,r,e):lw(isNaN(t)?r:t)}}function id(e,t){var r=t-e;return r?dDt(e,r):lw(isNaN(e)?t:e)}var Ltt=M(()=>{Itt()});function _Dt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var ktt,_5n,y5n,yDt=M(()=>{sw();Ptt();pDt();Ltt();ktt=function e(t){var r=gDt(t);function n(i,o){var a=r((i=aw(i)).r,(o=aw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=id(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);_5n=_Dt(hDt),y5n=_Dt(fDt)});function vDt(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function xDt(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var bDt=M(()=>{});function wDt(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=iv(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var SDt=M(()=>{DO()});function MDt(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var EDt=M(()=>{});function vf(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var OO=M(()=>{});function TDt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=iv(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var CDt=M(()=>{DO()});function j6e(e){return function(){return e}}function X6e(e){return function(t){return e(t)+""}}function ADt(e,t){var r=Ntt.lastIndex=Rtt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Ntt.exec(e))&&(i=Rtt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:vf(n,i)})),r=Rtt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?X6e(l[0].x):j6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Ntt,Rtt,PDt=M(()=>{OO();Ntt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Rtt=new RegExp(Ntt.source,"g")});function iv(e,t){var r=typeof t,n;return t==null||r==="boolean"?lw(t):(r==="number"?vf:r==="string"?(n=Ig(t))?(t=n,ktt):ADt:t instanceof Ig?ktt:t instanceof Date?MDt:xDt(t)?vDt:Array.isArray(t)?wDt:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?TDt:vf)(e,t)}var DO=M(()=>{sw();yDt();SDt();EDt();OO();CDt();PDt();Itt();bDt()});function Dtt(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var IDt=M(()=>{});function LDt(e){return function t(r){r=+r;function n(i,o){var a=e((i=Ka(i)).h,(o=Ka(o)).h),s=id(i.s,o.s),l=id(i.l,o.l),c=id(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var $6e,cw,kDt=M(()=>{sw();Ltt();$6e=LDt(mDt),cw=LDt(id)});var uw=M(()=>{DO();OO();IDt();kDt()});function hw(e){return function(){return e}}var zO=M(()=>{});function FO(e){return+e}var Ott=M(()=>{});function pC(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:hw(t)}function K6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=t?0:i>=r?1:n(i)}}}function Z6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=0?t:i>=1?r:n(i)}}}function J6e(e,t,r,n){var i=e[0],o=e[1],a=t[0],s=t[1];return o<i?(i=r(o,i),a=n(s,a)):(i=r(i,o),a=n(a,s)),function(l){return a(i(l))}}function Q6e(e,t,r,n){var i=Math.min(e.length,t.length)-1,o=new Array(i),a=new Array(i),s=-1;for(e[i]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++s<i;)o[s]=r(e[s],e[s+1]),a[s]=n(t[s],t[s+1]);return function(l){var c=mf(e,l,1,i)-1;return a[c](o[c](l))}}function Lg(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp())}function od(e,t){var r=RDt,n=RDt,i=iv,o=!1,a,s,l;function c(){return a=Math.min(r.length,n.length)>2?Q6e:J6e,s=l=null,u}function u(h){return(s||(s=a(r,n,o?K6e(e):e,i)))(+h)}return u.invert=function(h){return(l||(l=a(n,r,pC,o?Z6e(t):t)))(+h)},u.domain=function(h){return arguments.length?(r=rw.call(h,FO),c()):r.slice()},u.range=function(h){return arguments.length?(n=dl.call(h),c()):n.slice()},u.rangeRound=function(h){return n=dl.call(h),i=Dtt,c()},u.clamp=function(h){return arguments.length?(o=!!h,c()):o},u.interpolate=function(h){return arguments.length?(i=h,c()):i},c()}var RDt,dC=M(()=>{gf();uw();Ag();zO();Ott();RDt=[0,1]});function NDt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function ov(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var mC=M(()=>{});function xf(e){return e=ov(Math.abs(e)),e?e[1]:NaN}var gC=M(()=>{mC()});function DDt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var ODt=M(()=>{});function zDt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var FDt=M(()=>{});function kg(e){if(!(t=tIe.exec(e)))throw new Error("invalid format: "+e);var t;return new BO({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function BO(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}var tIe,ztt=M(()=>{tIe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;kg.prototype=BO.prototype;BO.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type}});function BDt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var HDt=M(()=>{});function VDt(e,t){var r=ov(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(Ftt=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+ov(e,Math.max(0,t+o-1))[0]}var Ftt,Btt=M(()=>{mC()});function Htt(e,t){var r=ov(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var UDt=M(()=>{mC()});var Vtt,qDt=M(()=>{mC();Btt();UDt();Vtt={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:NDt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return Htt(e*100,t)},r:Htt,s:VDt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Utt(e){return e}var GDt=M(()=>{});function jDt(e){var t=e.grouping===void 0||e.thousands===void 0?Utt:DDt(WDt.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?Utt:zDt(WDt.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=kg(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):Vtt[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=Vtt[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=BDt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?YDt[8+Ftt/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=kg(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(xf(f)/3)))*3,g=Math.pow(10,-d),_=YDt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var WDt,YDt,XDt=M(()=>{gC();ODt();FDt();ztt();HDt();qDt();Btt();GDt();WDt=Array.prototype.map,YDt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function qtt(e){return HO=jDt(e),fw=HO.format,VO=HO.formatPrefix,HO}var HO,fw,VO,$Dt=M(()=>{XDt();qtt({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"})});function Gtt(e){return Math.max(0,-xf(Math.abs(e)))}var KDt=M(()=>{gC()});function Wtt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(xf(t)/3)))*3-xf(Math.abs(e)))}var ZDt=M(()=>{gC()});function Ytt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,xf(t)-xf(e))+1}var JDt=M(()=>{gC()});var jtt=M(()=>{$Dt();ztt();KDt();ZDt();JDt()});function QDt(e,t,r){var n=e[0],i=e[e.length-1],o=Jy(n,i,t==null?10:t),a;switch(r=kg(r==null?",f":r),r.type){case"s":{var s=Math.max(Math.abs(n),Math.abs(i));return r.precision==null&&!isNaN(a=Wtt(o,s))&&(r.precision=a),VO(r,s)}case"":case"e":case"g":case"p":case"r":{r.precision==null&&!isNaN(a=Ytt(o,Math.max(Math.abs(n),Math.abs(i))))&&(r.precision=a-(r.type==="e"));break}case"f":case"%":{r.precision==null&&!isNaN(a=Gtt(o))&&(r.precision=a-(r.type==="%")*2);break}}return fw(r)}var tOt=M(()=>{gf();jtt()});function ad(e){var t=e.domain;return e.ticks=function(r){var n=t();return sC(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){return QDt(t(),r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=ew(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=ew(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=ew(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function UO(){var e=od(pC,vf);return e.copy=function(){return Lg(e,UO())},ad(e)}var pw=M(()=>{gf();uw();dC();tOt()});function qO(){var e=[0,1];function t(r){return+r}return t.invert=t,t.domain=t.range=function(r){return arguments.length?(e=rw.call(r,FO),t):e.slice()},t.copy=function(){return qO().domain(e)},ad(t)}var eOt=M(()=>{Ag();pw();Ott()});function GO(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}var Xtt=M(()=>{});function eIe(e,t){return(t=Math.log(t/e))?function(r){return Math.log(r/e)/t}:hw(t)}function rIe(e,t){return e<0?function(r){return-Math.pow(-t,r)*Math.pow(-e,1-r)}:function(r){return Math.pow(t,r)*Math.pow(e,1-r)}}function nIe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function rOt(e){return e===10?nIe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function nOt(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function iOt(e){return function(t){return-e(-t)}}function WO(){var e=od(eIe,rIe).domain([1,10]),t=e.domain,r=10,n=nOt(10),i=rOt(10);function o(){return n=nOt(r),i=rOt(r),t()[0]<0&&(n=iOt(n),i=iOt(i)),e}return e.base=function(a){return arguments.length?(r=+a,o()):r},e.domain=function(a){return arguments.length?(t(a),o()):t()},e.ticks=function(a){var s=t(),l=s[0],c=s[s.length-1],u;(u=c<l)&&(h=l,l=c,c=h);var h=n(l),f=n(c),p,d,g,_=a==null?10:+a,y=[];if(!(r%1)&&f-h<_){if(h=Math.round(h)-1,f=Math.round(f)+1,l>0){for(;h<f;++h)for(d=1,p=i(h);d<r;++d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else for(;h<f;++h)for(d=r-1,p=i(h);d>=1;--d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else y=sC(h,f,Math.min(f-h,_)).map(i);return u?y.reverse():y},e.tickFormat=function(a,s){if(s==null&&(s=r===10?".0e":","),typeof s!="function"&&(s=fw(s)),a===1/0)return s;a==null&&(a=10);var l=Math.max(1,r*a/e.ticks().length);return function(c){var u=c/i(Math.round(n(c)));return u*r<r-.5&&(u*=r),u<=l?s(c):""}},e.nice=function(){return t(GO(t(),{floor:function(a){return i(Math.floor(n(a)))},ceil:function(a){return i(Math.ceil(n(a)))}}))},e.copy=function(){return Lg(e,WO().base(r))},e}var oOt=M(()=>{gf();jtt();zO();Xtt();dC()});function dw(e,t){return e<0?-Math.pow(-e,t):Math.pow(e,t)}function _C(){var e=1,t=od(n,i),r=t.domain;function n(o,a){return(a=dw(a,e)-(o=dw(o,e)))?function(s){return(dw(s,e)-o)/a}:hw(a)}function i(o,a){return a=dw(a,e)-(o=dw(o,e)),function(s){return dw(o+a*s,1/e)}}return t.exponent=function(o){return arguments.length?(e=+o,r(r())):e},t.copy=function(){return Lg(t,_C().exponent(e))},ad(t)}function aOt(){return _C().exponent(.5)}var sOt=M(()=>{zO();pw();dC()});function YO(){var e=[],t=[],r=[];function n(){var o=0,a=Math.max(1,t.length);for(r=new Array(a-1);++o<a;)r[o-1]=lC(e,o/a);return i}function i(o){if(!isNaN(o=+o))return t[mf(r,o)]}return i.invertExtent=function(o){var a=t.indexOf(o);return a<0?[NaN,NaN]:[a>0?r[a-1]:e[0],a<r.length?r[a]:e[e.length-1]]},i.domain=function(o){if(!arguments.length)return e.slice();e=[];for(var a=0,s=o.length,l;a<s;++a)l=o[a],l!=null&&!isNaN(l=+l)&&e.push(l);return e.sort(df),n()},i.range=function(o){return arguments.length?(t=dl.call(o),n()):t.slice()},i.quantiles=function(){return r.slice()},i.copy=function(){return YO().domain(e).range(t)},i}var lOt=M(()=>{gf();Ag()});function jO(){var e=0,t=1,r=1,n=[.5],i=[0,1];function o(s){if(s<=s)return i[mf(n,s,0,r)]}function a(){var s=-1;for(n=new Array(r);++s<r;)n[s]=((s+1)*t-(s-r)*e)/(r+1);return o}return o.domain=function(s){return arguments.length?(e=+s[0],t=+s[1],a()):[e,t]},o.range=function(s){return arguments.length?(r=(i=dl.call(s)).length-1,a()):i.slice()},o.invertExtent=function(s){var l=i.indexOf(s);return l<0?[NaN,NaN]:l<1?[e,n[0]]:l>=r?[n[r-1],t]:[n[l-1],n[l]]},o.copy=function(){return jO().domain([e,t]).range(i)},ad(o)}var cOt=M(()=>{gf();Ag();pw()});function XO(){var e=[.5],t=[0,1],r=1;function n(i){if(i<=i)return t[mf(e,i,0,r)]}return n.domain=function(i){return arguments.length?(e=dl.call(i),r=Math.min(e.length,t.length-1),n):e.slice()},n.range=function(i){return arguments.length?(t=dl.call(i),r=Math.min(e.length,t.length-1),n):t.slice()},n.invertExtent=function(i){var o=t.indexOf(i);return[e[o-1],e[o]]},n.copy=function(){return XO().domain(e).range(t)},n}var uOt=M(()=>{gf();Ag()});function Nr(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Nr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $tt.setTime(+o),Ktt.setTime(+a),e($tt),e(Ktt),Math.floor(r($tt,Ktt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $tt,Ktt,Za=M(()=>{$tt=new Date,Ktt=new Date});var $O,mw,hOt,fOt=M(()=>{Za();$O=Nr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});$O.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Nr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):$O};mw=$O,hOt=$O.range});var av,wc,gw,KO,ZO,bf=M(()=>{av=1e3,wc=6e4,gw=36e5,KO=864e5,ZO=6048e5});var pOt,_w,dOt,mOt=M(()=>{Za();bf();pOt=Nr(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*av)},function(e,t){return(t-e)/av},function(e){return e.getUTCSeconds()}),_w=pOt,dOt=pOt.range});var gOt,Ztt,iIe,_Ot=M(()=>{Za();bf();gOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*av)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getMinutes()}),Ztt=gOt,iIe=gOt.range});var yOt,Jtt,oIe,vOt=M(()=>{Za();bf();yOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*av-e.getMinutes()*wc)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getHours()}),Jtt=yOt,oIe=yOt.range});var xOt,yw,aIe,bOt=M(()=>{Za();bf();xOt=Nr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*wc)/KO},function(e){return e.getDate()-1}),yw=xOt,aIe=xOt.range});function sv(e){return Nr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*wc)/ZO})}var lv,vw,wOt,SOt,Rg,MOt,EOt,TOt,sIe,lIe,cIe,uIe,hIe,fIe,COt=M(()=>{Za();bf();lv=sv(0),vw=sv(1),wOt=sv(2),SOt=sv(3),Rg=sv(4),MOt=sv(5),EOt=sv(6),TOt=lv.range,sIe=vw.range,lIe=wOt.range,cIe=SOt.range,uIe=Rg.range,hIe=MOt.range,fIe=EOt.range});var AOt,Qtt,pIe,POt=M(()=>{Za();AOt=Nr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),Qtt=AOt,pIe=AOt.range});var tet,sd,dIe,IOt=M(()=>{Za();tet=Nr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});tet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};sd=tet,dIe=tet.range});var LOt,eet,mIe,kOt=M(()=>{Za();bf();LOt=Nr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getUTCMinutes()}),eet=LOt,mIe=LOt.range});var ROt,ret,gIe,NOt=M(()=>{Za();bf();ROt=Nr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getUTCHours()}),ret=ROt,gIe=ROt.range});var DOt,xw,_Ie,OOt=M(()=>{Za();bf();DOt=Nr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/KO},function(e){return e.getUTCDate()-1}),xw=DOt,_Ie=DOt.range});function cv(e){return Nr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/ZO})}var uv,bw,zOt,FOt,Ng,BOt,HOt,VOt,yIe,vIe,xIe,bIe,wIe,SIe,UOt=M(()=>{Za();bf();uv=cv(0),bw=cv(1),zOt=cv(2),FOt=cv(3),Ng=cv(4),BOt=cv(5),HOt=cv(6),VOt=uv.range,yIe=bw.range,vIe=zOt.range,xIe=FOt.range,bIe=Ng.range,wIe=BOt.range,SIe=HOt.range});var qOt,net,MIe,GOt=M(()=>{Za();qOt=Nr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),net=qOt,MIe=qOt.range});var iet,ld,EIe,WOt=M(()=>{Za();iet=Nr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});iet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};ld=iet,EIe=iet.range});var JO=M(()=>{fOt();mOt();_Ot();vOt();bOt();COt();POt();IOt();kOt();NOt();OOt();UOt();GOt();WOt()});function oet(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function aet(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function yC(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function set(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=vC(i),u=xC(i),h=vC(o),f=xC(o),p=vC(a),d=xC(a),g=vC(s),_=xC(s),y=vC(l),x=xC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:ZOt,e:ZOt,f:XIe,g:i9e,G:a9e,H:WIe,I:YIe,j:jIe,L:r7t,m:$Ie,M:KIe,p:st,q:St,Q:t7t,s:e7t,S:ZIe,u:JIe,U:QIe,V:t9e,w:e9e,W:r9e,x:null,X:null,y:n9e,Y:o9e,Z:s9e,"%":QOt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:JOt,e:JOt,f:h9e,g:b9e,G:S9e,H:l9e,I:c9e,j:u9e,L:i7t,m:f9e,M:p9e,p:_t,q:ct,Q:t7t,s:e7t,S:d9e,u:m9e,U:g9e,V:_9e,w:y9e,W:v9e,x:null,X:null,y:x9e,Y:w9e,Z:M9e,"%":QOt},C={a:B,A:I,b:L,B:R,c:F,d:$Ot,e:$Ot,f:VIe,g:XOt,G:jOt,H:KOt,I:KOt,j:zIe,L:HIe,m:OIe,M:FIe,p:D,q:DIe,Q:qIe,s:GIe,S:BIe,u:IIe,U:LIe,V:kIe,w:PIe,W:RIe,x:z,X:U,y:XOt,Y:jOt,Z:NIe,"%":UIe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=YOt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=yC(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=aet(yC(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?bw.ceil(ht):bw(ht),ht=xw.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=oet(yC(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?vw.ceil(ht):vw(ht),ht=yw.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?aet(yC(q.y,0,1)).getUTCDay():oet(yC(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,aet(q)):oet(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in YOt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}function Gr(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function AIe(e){return e.replace(CIe,"\\$&")}function vC(e){return new RegExp("^(?:"+e.map(AIe).join("|")+")","i")}function xC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function PIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function IIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function LIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function kIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function RIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function jOt(e,t,r){var n=To.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function XOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function NIe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function DIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function OIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function $Ot(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function zIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function KOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function FIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function BIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function HIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function VIe(e,t,r){var n=To.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function UIe(e,t,r){var n=TIe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function qIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function GIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function ZOt(e,t){return Gr(e.getDate(),t,2)}function WIe(e,t){return Gr(e.getHours(),t,2)}function YIe(e,t){return Gr(e.getHours()%12||12,t,2)}function jIe(e,t){return Gr(1+yw.count(sd(e),e),t,3)}function r7t(e,t){return Gr(e.getMilliseconds(),t,3)}function XIe(e,t){return r7t(e,t)+"000"}function $Ie(e,t){return Gr(e.getMonth()+1,t,2)}function KIe(e,t){return Gr(e.getMinutes(),t,2)}function ZIe(e,t){return Gr(e.getSeconds(),t,2)}function JIe(e){var t=e.getDay();return t===0?7:t}function QIe(e,t){return Gr(lv.count(sd(e)-1,e),t,2)}function n7t(e){var t=e.getDay();return t>=4||t===0?Rg(e):Rg.ceil(e)}function t9e(e,t){return e=n7t(e),Gr(Rg.count(sd(e),e)+(sd(e).getDay()===4),t,2)}function e9e(e){return e.getDay()}function r9e(e,t){return Gr(vw.count(sd(e)-1,e),t,2)}function n9e(e,t){return Gr(e.getFullYear()%100,t,2)}function i9e(e,t){return e=n7t(e),Gr(e.getFullYear()%100,t,2)}function o9e(e,t){return Gr(e.getFullYear()%1e4,t,4)}function a9e(e,t){var r=e.getDay();return e=r>=4||r===0?Rg(e):Rg.ceil(e),Gr(e.getFullYear()%1e4,t,4)}function s9e(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Gr(t/60|0,"0",2)+Gr(t%60,"0",2)}function JOt(e,t){return Gr(e.getUTCDate(),t,2)}function l9e(e,t){return Gr(e.getUTCHours(),t,2)}function c9e(e,t){return Gr(e.getUTCHours()%12||12,t,2)}function u9e(e,t){return Gr(1+xw.count(ld(e),e),t,3)}function i7t(e,t){return Gr(e.getUTCMilliseconds(),t,3)}function h9e(e,t){return i7t(e,t)+"000"}function f9e(e,t){return Gr(e.getUTCMonth()+1,t,2)}function p9e(e,t){return Gr(e.getUTCMinutes(),t,2)}function d9e(e,t){return Gr(e.getUTCSeconds(),t,2)}function m9e(e){var t=e.getUTCDay();return t===0?7:t}function g9e(e,t){return Gr(uv.count(ld(e)-1,e),t,2)}function o7t(e){var t=e.getUTCDay();return t>=4||t===0?Ng(e):Ng.ceil(e)}function _9e(e,t){return e=o7t(e),Gr(Ng.count(ld(e),e)+(ld(e).getUTCDay()===4),t,2)}function y9e(e){return e.getUTCDay()}function v9e(e,t){return Gr(bw.count(ld(e)-1,e),t,2)}function x9e(e,t){return Gr(e.getUTCFullYear()%100,t,2)}function b9e(e,t){return e=o7t(e),Gr(e.getUTCFullYear()%100,t,2)}function w9e(e,t){return Gr(e.getUTCFullYear()%1e4,t,4)}function S9e(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Ng(e):Ng.ceil(e),Gr(e.getUTCFullYear()%1e4,t,4)}function M9e(){return"+0000"}function QOt(){return"%"}function t7t(e){return+e}function e7t(e){return Math.floor(+e/1e3)}var YOt,To,TIe,CIe,a7t=M(()=>{JO();YOt={"-":"",_:" ",0:"0"},To=/^\s*\d+/,TIe=/^%/,CIe=/[\\^$*+?|[\]().{}]/g});function cet(e){return ww=set(e),QO=ww.format,s7t=ww.parse,t7=ww.utcFormat,l7t=ww.utcParse,ww}var ww,QO,s7t,t7,l7t,c7t=M(()=>{a7t();cet({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});var uet=M(()=>{c7t()});function T9e(e){return new Date(e)}function C9e(e){return e instanceof Date?+e:+new Date(+e)}function e7(e,t,r,n,i,o,a,s,l){var c=od(pC,vf),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,bC],[a,5,5*bC],[a,15,15*bC],[a,30,30*bC],[o,1,wC],[o,5,5*wC],[o,15,15*wC],[o,30,30*wC],[i,1,SC],[i,3,3*SC],[i,6,6*SC],[i,12,12*SC],[n,1,MC],[n,2,2*MC],[r,1,E9e],[t,1,u7t],[t,3,3*u7t],[e,1,het]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=aC(function(R){return R[2]}).right(S,I);L===S.length?(B=Jy(O/het,D/het,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(Jy(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(rw.call(k,C9e)):h().map(T9e)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(GO(D,k)):c},c.copy=function(){return Lg(c,e7(e,t,r,n,i,o,a,s,l))},c}function h7t(){return e7(sd,Qtt,lv,yw,Jtt,Ztt,_w,mw,QO).domain([new Date(2e3,0,1),new Date(2e3,0,2)])}var bC,wC,SC,MC,E9e,u7t,het,fet=M(()=>{gf();uw();JO();uet();Ag();dC();Xtt();bC=1e3,wC=bC*60,SC=wC*60,MC=SC*24,E9e=MC*7,u7t=MC*30,het=MC*365});function f7t(){return e7(ld,net,uv,xw,ret,eet,_w,mw,t7).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])}var p7t=M(()=>{fet();uet();JO()});function ml(e){return e.match(/.{6}/g).map(function(t){return"#"+t})}var Sw=M(()=>{});var d7t,m7t=M(()=>{Sw();d7t=ml("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf")});var g7t,_7t=M(()=>{Sw();g7t=ml("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6")});var y7t,v7t=M(()=>{Sw();y7t=ml("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9")});var x7t,b7t=M(()=>{Sw();x7t=ml("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5")});var w7t,S7t=M(()=>{sw();uw();w7t=cw(Ka(300,.5,0),Ka(-240,.5,1))});function T7t(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return r7.h=360*e-100,r7.s=1.5-1.5*t,r7.l=.8-.9*t,r7+""}var M7t,E7t,r7,C7t=M(()=>{sw();uw();M7t=cw(Ka(-100,.75,.35),Ka(80,1.5,.8)),E7t=cw(Ka(260,.75,.35),Ka(80,1.5,.8)),r7=Ka()});function n7(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var A7t,P7t,I7t,L7t,k7t=M(()=>{Sw();A7t=n7(ml("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),P7t=n7(ml("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),I7t=n7(ml("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),L7t=n7(ml("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"))});function i7(e){var t=0,r=1,n=!1;function i(o){var a=(o-t)/(r-t);return e(n?Math.max(0,Math.min(1,a)):a)}return i.domain=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.clamp=function(o){return arguments.length?(n=!!o,i):n},i.interpolator=function(o){return arguments.length?(e=o,i):e},i.copy=function(){return i7(e).domain([t,r]).clamp(n)},ad(i)}var R7t=M(()=>{pw()});var N7t=M(()=>{jNt();eOt();pw();oOt();xtt();sOt();lOt();cOt();uOt();fet();p7t();m7t();_7t();v7t();b7t();S7t();C7t();k7t();R7t()});var o7,EC,a7=M(()=>{o7="http://www.w3.org/1999/xhtml",EC={svg:"http://www.w3.org/2000/svg",xhtml:o7,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Mw(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),EC.hasOwnProperty(t)?{space:EC[t],local:e}:e}var s7=M(()=>{a7()});function A9e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===o7&&t.documentElement.namespaceURI===o7?t.createElement(e):t.createElementNS(r,e)}}function P9e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Dg(e){var t=Mw(e);return(t.local?P9e:A9e)(t)}var TC=M(()=>{s7();a7()});function I9e(){}function Ew(e){return e==null?I9e:function(){return this.querySelector(e)}}var l7=M(()=>{});function D7t(e){typeof e!="function"&&(e=Ew(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Hn(n,this._parents)}var O7t=M(()=>{Sc();l7()});function L9e(){return[]}function c7(e){return e==null?L9e:function(){return this.querySelectorAll(e)}}var pet=M(()=>{});function z7t(e){typeof e!="function"&&(e=c7(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Hn(n,i)}var F7t=M(()=>{Sc();pet()});var H7t,Tw,B7t,u7,det=M(()=>{H7t=function(e){return function(){return this.matches(e)}};typeof document!="undefined"&&(Tw=document.documentElement,Tw.matches||(B7t=Tw.webkitMatchesSelector||Tw.msMatchesSelector||Tw.mozMatchesSelector||Tw.oMatchesSelector,H7t=function(e){return function(){return B7t.call(this,e)}}));u7=H7t});function V7t(e){typeof e!="function"&&(e=u7(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Hn(n,this._parents)}var U7t=M(()=>{Sc();det()});function h7(e){return new Array(e.length)}var met=M(()=>{});function q7t(){return new Hn(this._enter||this._groups.map(h7),this._parents)}function CC(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var get=M(()=>{met();Sc();CC.prototype={constructor:CC,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function G7t(e){return function(){return e}}var W7t=M(()=>{});function k9e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new CC(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function R9e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=Y7t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=Y7t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new CC(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function j7t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?R9e:k9e,n=this._parents,i=this._groups;typeof e!="function"&&(e=G7t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Hn(a,n),a._enter=s,a._exit=l,a}var Y7t,X7t=M(()=>{Sc();get();W7t();Y7t="$"});function $7t(){return new Hn(this._exit||this._groups.map(h7),this._parents)}var K7t=M(()=>{met();Sc()});function Z7t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Hn(a,this._parents)}var J7t=M(()=>{Sc()});function Q7t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&o!==a.nextSibling&&o.parentNode.insertBefore(a,o),o=a);return this}var tzt=M(()=>{});function ezt(e){e||(e=N9e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Hn(i,this._parents).order()}function N9e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var rzt=M(()=>{Sc()});function nzt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var izt=M(()=>{});function ozt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var azt=M(()=>{});function szt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var lzt=M(()=>{});function czt(){var e=0;return this.each(function(){++e}),e}var uzt=M(()=>{});function hzt(){return!this.node()}var fzt=M(()=>{});function pzt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var dzt=M(()=>{});function D9e(e){return function(){this.removeAttribute(e)}}function O9e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function z9e(e,t){return function(){this.setAttribute(e,t)}}function F9e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function B9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function H9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function mzt(e,t){var r=Mw(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?O9e:D9e:typeof t=="function"?r.local?H9e:B9e:r.local?F9e:z9e)(r,t))}var gzt=M(()=>{s7()});function Cw(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var f7=M(()=>{});function V9e(e){return function(){this.style.removeProperty(e)}}function U9e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function q9e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function _zt(e,t,r){return arguments.length>1?this.each((t==null?V9e:typeof t=="function"?q9e:U9e)(e,t,r==null?"":r)):_et(this.node(),e)}function _et(e,t){return e.style.getPropertyValue(t)||Cw(e).getComputedStyle(e,null).getPropertyValue(t)}var yet=M(()=>{f7()});function G9e(e){return function(){delete this[e]}}function W9e(e,t){return function(){this[e]=t}}function Y9e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function yzt(e,t){return arguments.length>1?this.each((t==null?G9e:typeof t=="function"?Y9e:W9e)(e,t)):this.node()[e]}var vzt=M(()=>{});function xzt(e){return e.trim().split(/^|\s+/)}function vet(e){return e.classList||new bzt(e)}function bzt(e){this._node=e,this._names=xzt(e.getAttribute("class")||"")}function wzt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function Szt(e,t){for(var r=vet(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function j9e(e){return function(){wzt(this,e)}}function X9e(e){return function(){Szt(this,e)}}function $9e(e,t){return function(){(t.apply(this,arguments)?wzt:Szt)(this,e)}}function Mzt(e,t){var r=xzt(e+"");if(arguments.length<2){for(var n=vet(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?$9e:t?j9e:X9e)(r,t))}var Ezt=M(()=>{bzt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function K9e(){this.textContent=""}function Z9e(e){return function(){this.textContent=e}}function J9e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function Tzt(e){return arguments.length?this.each(e==null?K9e:(typeof e=="function"?J9e:Z9e)(e)):this.node().textContent}var Czt=M(()=>{});function Q9e(){this.innerHTML=""}function tLe(e){return function(){this.innerHTML=e}}function eLe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Azt(e){return arguments.length?this.each(e==null?Q9e:(typeof e=="function"?eLe:tLe)(e)):this.node().innerHTML}var Pzt=M(()=>{});function rLe(){this.nextSibling&&this.parentNode.appendChild(this)}function Izt(){return this.each(rLe)}var Lzt=M(()=>{});function nLe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function kzt(){return this.each(nLe)}var Rzt=M(()=>{});function Nzt(e){var t=typeof e=="function"?e:Dg(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var Dzt=M(()=>{TC()});function iLe(){return null}function Ozt(e,t){var r=typeof e=="function"?e:Dg(e),n=t==null?iLe:typeof t=="function"?t:Ew(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var zzt=M(()=>{TC();l7()});function oLe(){var e=this.parentNode;e&&e.removeChild(this)}function Fzt(){return this.each(oLe)}var Bzt=M(()=>{});function aLe(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function sLe(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}function Hzt(e){return this.select(e?sLe:aLe)}var Vzt=M(()=>{});function Uzt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var qzt=M(()=>{});function lLe(e,t,r){return e=Yzt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function Yzt(e,t,r){return function(n){var i=Pu;Pu=n;try{e.call(this,this.__data__,t,r)}finally{Pu=i}}}function cLe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function uLe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function hLe(e,t,r){var n=Wzt.hasOwnProperty(e.type)?lLe:Yzt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function jzt(e,t,r){var n=cLe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?hLe:uLe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Xzt(e,t,r,n){var i=Pu;e.sourceEvent=Pu,Pu=e;try{return t.apply(r,n)}finally{Pu=i}}var Wzt,Pu,Gzt,p7=M(()=>{Wzt={},Pu=null;typeof document!="undefined"&&(Gzt=document.documentElement,"onmouseenter"in Gzt||(Wzt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function $zt(e,t,r){var n=Cw(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function fLe(e,t){return function(){return $zt(this,e,t)}}function pLe(e,t){return function(){return $zt(this,e,t.apply(this,arguments))}}function Kzt(e,t){return this.each((typeof t=="function"?pLe:fLe)(e,t))}var Zzt=M(()=>{f7()});function Hn(e,t){this._groups=e,this._parents=t}function Jzt(){return new Hn([[document.documentElement]],AC)}var AC,Qzt,Sc=M(()=>{O7t();F7t();U7t();X7t();get();K7t();J7t();tzt();rzt();izt();azt();lzt();uzt();fzt();dzt();gzt();yet();vzt();Ezt();Czt();Pzt();Lzt();Rzt();Dzt();zzt();Bzt();Vzt();qzt();p7();Zzt();AC=[null];Hn.prototype=Jzt.prototype={constructor:Hn,select:D7t,selectAll:z7t,filter:V7t,data:j7t,enter:q7t,exit:$7t,merge:Z7t,order:Q7t,sort:ezt,call:nzt,nodes:ozt,node:szt,size:czt,empty:hzt,each:pzt,attr:mzt,style:_zt,property:yzt,classed:Mzt,text:Tzt,html:Azt,raise:Izt,lower:kzt,append:Nzt,insert:Ozt,remove:Fzt,clone:Hzt,datum:Uzt,on:jzt,dispatch:Kzt};Qzt=Jzt});function d7(e){return typeof e=="string"?new Hn([[document.querySelector(e)]],[document.documentElement]):new Hn([[e]],AC)}var xet=M(()=>{Sc()});function tFt(e){return d7(Dg(e).call(document.documentElement))}var eFt=M(()=>{TC();xet()});function m7(){return new bet}function bet(){this._="@"+(++dLe).toString(36)}var dLe,rFt=M(()=>{dLe=0;bet.prototype=m7.prototype={constructor:bet,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}}});function Aw(){for(var e=Pu,t;t=e.sourceEvent;)e=t;return e}var g7=M(()=>{p7()});function Og(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var PC=M(()=>{});function nFt(e){var t=Aw();return t.changedTouches&&(t=t.changedTouches[0]),Og(e,t)}var iFt=M(()=>{g7();PC()});function oFt(e){return typeof e=="string"?new Hn([document.querySelectorAll(e)],[document.documentElement]):new Hn([e==null?[]:e],AC)}var aFt=M(()=>{Sc()});function sFt(e,t,r){arguments.length<3&&(r=t,t=Aw().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Og(e,o);return null}var lFt=M(()=>{g7();PC()});function cFt(e,t){t==null&&(t=Aw().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Og(e,t[r]);return i}var uFt=M(()=>{g7();PC()});var hFt=M(()=>{eFt();TC();rFt();det();iFt();s7();a7();PC();xet();aFt();Sc();l7();pet();yet();lFt();uFt();f7();p7()});function Eet(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function fFt(){return new Eet}var wet,Met,hv,mLe,Iu,pFt=M(()=>{wet=Math.PI,Met=2*wet,hv=1e-6,mLe=Met-hv;Eet.prototype=fFt.prototype={constructor:Eet,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>hv)if(!(Math.abs(u*s-l*c)>hv)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((wet-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>hv&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>hv||Math.abs(this._y1-c)>hv)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%Met+Met),h>mLe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>hv&&(this._+="A"+r+","+r+",0,"+ +(h>=wet)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};Iu=fFt});var Pw=M(()=>{pFt()});function Ge(e){return function(){return e}}var zg=M(()=>{});function mFt(e){return e>1?0:e<-1?ku:Math.acos(e)}function Cet(e){return e>=1?IC:e<=-1?-IC:Math.asin(e)}var Tet,Ho,Fg,dFt,_7,Lu,fv,Co,ku,IC,Mc,Iw=M(()=>{Tet=Math.abs,Ho=Math.atan2,Fg=Math.cos,dFt=Math.max,_7=Math.min,Lu=Math.sin,fv=Math.sqrt,Co=1e-12,ku=Math.PI,IC=ku/2,Mc=2*ku});function gLe(e){return e.innerRadius}function _Le(e){return e.outerRadius}function yLe(e){return e.startAngle}function vLe(e){return e.endAngle}function xLe(e){return e&&e.padAngle}function bLe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=(u*(t-o)-h*(e-i))/(h*l-u*c);return[e+f*l,t+f*c]}function y7(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/fv(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*fv(dFt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function gFt(){var e=gLe,t=_Le,r=Ge(0),n=null,i=yLe,o=vLe,a=xLe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-IC,d=o.apply(this,arguments)-IC,g=Tet(d-p),_=d>p;if(s||(s=c=Iu()),f<h&&(u=f,f=h,h=u),!(f>Co))s.moveTo(0,0);else if(g>Mc-Co)s.moveTo(f*Fg(p),f*Lu(p)),s.arc(0,0,f,p,d,!_),h>Co&&(s.moveTo(h*Fg(d),h*Lu(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>Co&&(n?+n.apply(this,arguments):fv(h*h+f*f)),D=_7(Tet(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>Co){var F=Cet(O/h*Lu(k)),z=Cet(O/f*Lu(k));(C-=F*2)>Co?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>Co?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*Fg(y),W=f*Lu(y),Z=h*Fg(S),rt=h*Lu(S);if(D>Co){var ot=f*Fg(x),st=f*Lu(x),St=h*Fg(b),bt=h*Lu(b);if(g<ku){var Mt=C>Co?bLe(U,W,St,bt,ot,st,Z,rt):[Z,rt],lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/Lu(mFt((lt*_t+Kt*ct)/(fv(lt*lt+Kt*Kt)*fv(_t*_t+ct*ct)))/2),et=fv(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=_7(D,(h-et)/(X-1)),I=_7(D,(f-et)/(X+1))}}P>Co?I>Co?(L=y7(St,bt,U,W,f,I,_),R=y7(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,f,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>Co)||!(C>Co)?s.lineTo(Z,rt):B>Co?(L=y7(Z,rt,ot,st,h,-B,_),R=y7(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,h,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-ku/2;return[Fg(u)*c,Lu(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:Ge(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:Ge(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:Ge(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:Ge(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:Ge(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:Ge(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:Ge(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}var _Ft=M(()=>{Pw();zg();Iw()});function yFt(e){this._context=e}function Bg(e){return new yFt(e)}var LC=M(()=>{yFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}}});function Lw(e){return e[0]}function kw(e){return e[1]}var v7=M(()=>{});function Rw(){var e=Lw,t=kw,r=Ge(!0),n=null,i=Bg,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=Iu())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:Ge(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:Ge(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}var x7=M(()=>{Pw();zg();LC();v7()});function b7(){var e=Lw,t=null,r=Ge(0),n=kw,i=Ge(!0),o=null,a=Bg,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=Iu())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return Rw().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:Ge(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:Ge(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:Ge(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}var Aet=M(()=>{Pw();zg();LC();x7();v7()});function vFt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var xFt=M(()=>{});function bFt(e){return e}var wFt=M(()=>{});function SFt(){var e=bFt,t=vFt,r=null,n=Ge(0),i=Ge(Mc),o=Ge(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(Mc,Math.max(-Mc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:Ge(+s),a):o},a}var MFt=M(()=>{zg();xFt();wFt();Iw()});function EFt(e){this._curve=e}function Nw(e){function t(r){return new EFt(e(r))}return t._curve=e,t}var w7,Pet=M(()=>{LC();w7=Nw(Bg);EFt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}}});function Dw(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Nw(r)):t()._curve},e}function Iet(){return Dw(Rw().curve(w7))}var Let=M(()=>{Pet();x7()});function ket(){var e=b7().curve(w7),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Dw(r())},delete e.lineX0,e.lineEndAngle=function(){return Dw(n())},delete e.lineX1,e.lineInnerRadius=function(){return Dw(i())},delete e.lineY0,e.lineOuterRadius=function(){return Dw(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Nw(a)):t()._curve},e}var TFt=M(()=>{Pet();Aet();Let()});function pv(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var Ret=M(()=>{});var kC,Net=M(()=>{kC=Array.prototype.slice});function wLe(e){return e.source}function SLe(e){return e.target}function Det(e){var t=wLe,r=SLe,n=Lw,i=kw,o=null;function a(){var s,l=kC.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=Iu()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function MLe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function ELe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function TLe(e,t,r,n,i){var o=pv(t,r),a=pv(t,r=(r+i)/2),s=pv(n,r),l=pv(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function CFt(){return Det(MLe)}function AFt(){return Det(ELe)}function PFt(){var e=Det(TLe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var IFt=M(()=>{Pw();Net();zg();v7();Ret()});var RC,Oet=M(()=>{Iw();RC={draw:function(e,t){var r=Math.sqrt(t/ku);e.moveTo(r,0),e.arc(0,0,r,0,Mc)}}});var S7,zet=M(()=>{S7={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}}});var LFt,CLe,M7,Fet=M(()=>{LFt=Math.sqrt(.3333333333333333),CLe=LFt*2,M7={draw:function(e,t){var r=Math.sqrt(t/CLe),n=r*LFt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}}});var ALe,kFt,PLe,ILe,E7,Bet=M(()=>{Iw();ALe=.8908130915292852,kFt=Math.sin(ku/10)/Math.sin(7*ku/10),PLe=Math.sin(Mc/10)*kFt,ILe=-Math.cos(Mc/10)*kFt,E7={draw:function(e,t){var r=Math.sqrt(t*ALe),n=PLe*r,i=ILe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=Mc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}}});var T7,Het=M(()=>{T7={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}}});var Vet,C7,Uet=M(()=>{Vet=Math.sqrt(3),C7={draw:function(e,t){var r=-Math.sqrt(t/(Vet*3));e.moveTo(0,r*2),e.lineTo(-Vet*r,-r),e.lineTo(Vet*r,-r),e.closePath()}}});var Ec,Tc,qet,LLe,A7,Get=M(()=>{Ec=-.5,Tc=Math.sqrt(3)/2,qet=1/Math.sqrt(12),LLe=(qet/2+1)*3,A7={draw:function(e,t){var r=Math.sqrt(t/LLe),n=r/2,i=r*qet,o=n,a=r*qet+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(Ec*n-Tc*i,Tc*n+Ec*i),e.lineTo(Ec*o-Tc*a,Tc*o+Ec*a),e.lineTo(Ec*s-Tc*l,Tc*s+Ec*l),e.lineTo(Ec*n+Tc*i,Ec*i-Tc*n),e.lineTo(Ec*o+Tc*a,Ec*a-Tc*o),e.lineTo(Ec*s+Tc*l,Ec*l-Tc*s),e.closePath()}}});function NFt(){var e=Ge(RC),t=Ge(64),r=null;function n(){var i;if(r||(r=i=Iu()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:Ge(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:Ge(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}var RFt,DFt=M(()=>{Pw();Oet();zet();Fet();Bet();Het();Uet();Get();zg();RFt=[RC,S7,M7,T7,E7,C7,A7]});function Cc(){}var NC=M(()=>{});function Ow(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function DC(e){this._context=e}function OFt(e){return new DC(e)}var OC=M(()=>{DC.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ow(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function zFt(e){this._context=e}function FFt(e){return new zFt(e)}var BFt=M(()=>{NC();OC();zFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function HFt(e){this._context=e}function VFt(e){return new HFt(e)}var UFt=M(()=>{OC();HFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function qFt(e,t){this._basis=new DC(e),this._beta=t}var GFt,WFt=M(()=>{OC();qFt.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};GFt=function e(t){function r(n){return t===1?new DC(n):new qFt(n,t)}return r.beta=function(n){return e(+n)},r}(.85)});function zw(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function P7(e,t){this._context=e,this._k=(1-t)/6}var YFt,zC=M(()=>{P7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:zw(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};YFt=function e(t){function r(n){return new P7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function I7(e,t){this._context=e,this._k=(1-t)/6}var jFt,Wet=M(()=>{NC();zC();I7.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};jFt=function e(t){function r(n){return new I7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function L7(e,t){this._context=e,this._k=(1-t)/6}var XFt,Yet=M(()=>{zC();L7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};XFt=function e(t){function r(n){return new L7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function FC(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>Co){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>Co){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function $Ft(e,t){this._context=e,this._alpha=t}var KFt,k7=M(()=>{Iw();zC();$Ft.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};KFt=function e(t){function r(n){return t?new $Ft(n,t):new P7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function ZFt(e,t){this._context=e,this._alpha=t}var JFt,QFt=M(()=>{Wet();NC();k7();ZFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};JFt=function e(t){function r(n){return t?new ZFt(n,t):new I7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function tBt(e,t){this._context=e,this._alpha=t}var eBt,rBt=M(()=>{Yet();k7();tBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:FC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};eBt=function e(t){function r(n){return t?new tBt(n,t):new L7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function nBt(e){this._context=e}function iBt(e){return new nBt(e)}var oBt=M(()=>{NC();nBt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}}});function aBt(e){return e<0?-1:1}function sBt(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(aBt(o)+aBt(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function lBt(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function jet(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function R7(e){this._context=e}function cBt(e){this._context=new uBt(e)}function uBt(e){this._context=e}function hBt(e){return new R7(e)}function fBt(e){return new cBt(e)}var pBt=M(()=>{R7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:jet(this,this._t0,lBt(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,jet(this,lBt(this,r=sBt(this,e,t)),r);break;default:jet(this,this._t0,r=sBt(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};(cBt.prototype=Object.create(R7.prototype)).point=function(e,t){R7.prototype.point.call(this,t,e)};uBt.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}}});function mBt(e){this._context=e}function dBt(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function gBt(e){return new mBt(e)}var _Bt=M(()=>{mBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=dBt(e),i=dBt(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}}});function N7(e,t){this._context=e,this._t=t}function yBt(e){return new N7(e,.5)}function vBt(e){return new N7(e,0)}function xBt(e){return new N7(e,1)}var bBt=M(()=>{N7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}}});function Ru(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}var Fw=M(()=>{});function Nu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}var Bw=M(()=>{});function kLe(e,t){return e[t]}function wBt(){var e=Ge([]),t=Nu,r=Ru,n=kLe;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:Ge(kC.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:Ge(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?Nu:typeof o=="function"?o:Ge(kC.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?Ru:o,i):r},i}var SBt=M(()=>{Net();zg();Fw();Bw()});function MBt(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}Ru(e,t)}}var EBt=M(()=>{Fw()});function TBt(e,t){if((l=e.length)>1)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>=0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):i[0]=a}var CBt=M(()=>{});function ABt(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}Ru(e,t)}}var PBt=M(()=>{Fw()});function IBt(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,Ru(e,t)}}var LBt=M(()=>{Fw()});function D7(e){var t=e.map(Xet);return Nu(e).sort(function(r,n){return t[r]-t[n]})}function Xet(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}var O7=M(()=>{Bw()});function kBt(e){return D7(e).reverse()}var RBt=M(()=>{O7()});function NBt(e){var t=e.length,r,n,i=e.map(Xet),o=Nu(e).sort(function(u,h){return i[h]-i[u]}),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}var DBt=M(()=>{Bw();O7()});function OBt(e){return Nu(e).reverse()}var zBt=M(()=>{Bw()});var FBt=M(()=>{_Ft();Aet();x7();MFt();TFt();Let();Ret();IFt();DFt();Oet();zet();Fet();Het();Bet();Uet();Get();BFt();UFt();OC();WFt();Wet();Yet();zC();QFt();rBt();k7();oBt();LC();pBt();_Bt();bBt();SBt();EBt();CBt();Fw();PBt();LBt();O7();RBt();DBt();Bw();zBt()});function Sr(e,t,r,n){function i(o){return e(o=new Date(+o)),o}return i.floor=i,i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Sr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return $et.setTime(+o),Ket.setTime(+a),e($et),e(Ket),Math.floor(r($et,Ket))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var $et,Ket,pa=M(()=>{$et=new Date,Ket=new Date});var z7,Zet,Jet,BBt=M(()=>{pa();z7=Sr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});z7.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Sr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):z7};Zet=z7,Jet=z7.range});var BC,Is,wf,F7,B7,Sf=M(()=>{BC=1e3,Is=6e4,wf=36e5,F7=864e5,B7=6048e5});var HBt,Qet,trt,VBt=M(()=>{pa();Sf();HBt=Sr(function(e){e.setTime(Math.floor(e/BC)*BC)},function(e,t){e.setTime(+e+t*BC)},function(e,t){return(t-e)/BC},function(e){return e.getUTCSeconds()}),Qet=HBt,trt=HBt.range});var UBt,qBt,GBt,WBt=M(()=>{pa();Sf();UBt=Sr(function(e){e.setTime(Math.floor(e/Is)*Is)},function(e,t){e.setTime(+e+t*Is)},function(e,t){return(t-e)/Is},function(e){return e.getMinutes()}),qBt=UBt,GBt=UBt.range});var YBt,jBt,XBt,$Bt=M(()=>{pa();Sf();YBt=Sr(function(e){var t=e.getTimezoneOffset()*Is%wf;t<0&&(t+=wf),e.setTime(Math.floor((+e-t)/wf)*wf+t)},function(e,t){e.setTime(+e+t*wf)},function(e,t){return(t-e)/wf},function(e){return e.getHours()}),jBt=YBt,XBt=YBt.range});var KBt,ZBt,JBt,QBt=M(()=>{pa();Sf();KBt=Sr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*Is)/F7},function(e){return e.getDate()-1}),ZBt=KBt,JBt=KBt.range});function dv(e){return Sr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*Is)/B7})}var H7,ert,rrt,nrt,irt,ort,art,srt,tHt,eHt,rHt,nHt,iHt,oHt,aHt=M(()=>{pa();Sf();H7=dv(0),ert=dv(1),rrt=dv(2),nrt=dv(3),irt=dv(4),ort=dv(5),art=dv(6),srt=H7.range,tHt=ert.range,eHt=rrt.range,rHt=nrt.range,nHt=irt.range,iHt=ort.range,oHt=art.range});var sHt,lHt,cHt,uHt=M(()=>{pa();sHt=Sr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),lHt=sHt,cHt=sHt.range});var lrt,hHt,fHt,pHt=M(()=>{pa();lrt=Sr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});lrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};hHt=lrt,fHt=lrt.range});var dHt,mHt,gHt,_Ht=M(()=>{pa();Sf();dHt=Sr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*Is)},function(e,t){return(t-e)/Is},function(e){return e.getUTCMinutes()}),mHt=dHt,gHt=dHt.range});var yHt,vHt,xHt,bHt=M(()=>{pa();Sf();yHt=Sr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*wf)},function(e,t){return(t-e)/wf},function(e){return e.getUTCHours()}),vHt=yHt,xHt=yHt.range});var wHt,SHt,MHt,EHt=M(()=>{pa();Sf();wHt=Sr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/F7},function(e){return e.getUTCDate()-1}),SHt=wHt,MHt=wHt.range});function mv(e){return Sr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/B7})}var V7,crt,urt,hrt,frt,prt,drt,mrt,THt,CHt,AHt,PHt,IHt,LHt,kHt=M(()=>{pa();Sf();V7=mv(0),crt=mv(1),urt=mv(2),hrt=mv(3),frt=mv(4),prt=mv(5),drt=mv(6),mrt=V7.range,THt=crt.range,CHt=urt.range,AHt=hrt.range,PHt=frt.range,IHt=prt.range,LHt=drt.range});var RHt,NHt,DHt,OHt=M(()=>{pa();RHt=Sr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),NHt=RHt,DHt=RHt.range});var grt,zHt,FHt,BHt=M(()=>{pa();grt=Sr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});grt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};zHt=grt,FHt=grt.range});var HHt=M(()=>{pa();BBt();VBt();WBt();$Bt();QBt();aHt();uHt();pHt();_Ht();bHt();EHt();kHt();OHt();BHt()});function da(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return da(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return _rt.setTime(+o),yrt.setTime(+a),e(_rt),e(yrt),Math.floor(r(_rt,yrt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var _rt,yrt,gv=M(()=>{_rt=new Date,yrt=new Date});var U7,q7,G7,HC=M(()=>{U7=6e4,q7=864e5,G7=6048e5});var VHt,W7,RLe,UHt=M(()=>{gv();HC();VHt=da(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*U7)/q7},function(e){return e.getDate()-1}),W7=VHt,RLe=VHt.range});function _v(e){return da(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*U7)/G7})}var VC,Hw,qHt,GHt,Vw,WHt,YHt,jHt,NLe,DLe,OLe,zLe,FLe,BLe,XHt=M(()=>{gv();HC();VC=_v(0),Hw=_v(1),qHt=_v(2),GHt=_v(3),Vw=_v(4),WHt=_v(5),YHt=_v(6),jHt=VC.range,NLe=Hw.range,DLe=qHt.range,OLe=GHt.range,zLe=Vw.range,FLe=WHt.range,BLe=YHt.range});var vrt,yv,HLe,$Ht=M(()=>{gv();vrt=da(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});vrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:da(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};yv=vrt,HLe=vrt.range});var KHt,Y7,VLe,ZHt=M(()=>{gv();HC();KHt=da(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/q7},function(e){return e.getUTCDate()-1}),Y7=KHt,VLe=KHt.range});function vv(e){return da(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/G7})}var UC,Uw,JHt,QHt,qw,tVt,eVt,rVt,ULe,qLe,GLe,WLe,YLe,jLe,nVt=M(()=>{gv();HC();UC=vv(0),Uw=vv(1),JHt=vv(2),QHt=vv(3),qw=vv(4),tVt=vv(5),eVt=vv(6),rVt=UC.range,ULe=Uw.range,qLe=JHt.range,GLe=QHt.range,WLe=qw.range,YLe=tVt.range,jLe=eVt.range});var xrt,xv,XLe,iVt=M(()=>{gv();xrt=da(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});xrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:da(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};xv=xrt,XLe=xrt.range});var oVt=M(()=>{UHt();XHt();$Ht();ZHt();nVt();iVt()});function $Le(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function j7(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function qC(e){return{y:e,m:0,d:1,H:0,M:0,S:0,L:0}}function YC(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=GC(i),u=WC(i),h=GC(o),f=WC(o),p=GC(a),d=WC(a),g=GC(s),_=WC(s),y=GC(l),x=WC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:cVt,e:cVt,f:vke,H:gke,I:_ke,j:yke,L:dVt,m:xke,M:bke,p:st,Q:fVt,s:pVt,S:wke,u:Ske,U:Mke,V:Eke,w:Tke,W:Cke,x:null,X:null,y:Ake,Y:Pke,Z:Ike,"%":hVt},S={a:St,A:bt,b:Mt,B:lt,c:null,d:uVt,e:uVt,f:Nke,H:Lke,I:kke,j:Rke,L:mVt,m:Dke,M:Oke,p:Kt,Q:fVt,s:pVt,S:zke,u:Fke,U:Bke,V:Hke,w:Vke,W:Uke,x:null,X:null,y:qke,Y:Gke,Z:Wke,"%":hVt},C={a:B,A:I,b:L,B:R,c:F,d:sVt,e:sVt,f:fke,H:lVt,I:lVt,j:lke,L:hke,m:ske,M:cke,p:D,Q:dke,s:mke,S:uke,u:tke,U:eke,V:rke,w:QLe,W:nke,x:z,X:U,y:oke,Y:ike,Z:ake,"%":pke};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(_t,ct){return function(X){var et=[],dt=-1,q=0,pt=_t.length,ht,wt,kt;for(X instanceof Date||(X=new Date(+X));++dt<pt;)_t.charCodeAt(dt)===37&&(et.push(_t.slice(q,dt)),(wt=aVt[ht=_t.charAt(++dt)])!=null?ht=_t.charAt(++dt):wt=ht==="e"?" ":"0",(kt=ct[ht])&&(ht=kt(X,wt)),et.push(ht),q=dt+1);return et.push(_t.slice(q,dt)),et.join("")}}function k(_t,ct){return function(X){var et=qC(1900),dt=O(et,_t,X+="",0),q,pt;if(dt!=X.length)return null;if("Q"in et)return new Date(et.Q);if("p"in et&&(et.H=et.H%12+et.p*12),"V"in et){if(et.V<1||et.V>53)return null;"w"in et||(et.w=1),"Z"in et?(q=j7(qC(et.y)),pt=q.getUTCDay(),q=pt>4||pt===0?Uw.ceil(q):Uw(q),q=Y7.offset(q,(et.V-1)*7),et.y=q.getUTCFullYear(),et.m=q.getUTCMonth(),et.d=q.getUTCDate()+(et.w+6)%7):(q=ct(qC(et.y)),pt=q.getDay(),q=pt>4||pt===0?Hw.ceil(q):Hw(q),q=W7.offset(q,(et.V-1)*7),et.y=q.getFullYear(),et.m=q.getMonth(),et.d=q.getDate()+(et.w+6)%7)}else("W"in et||"U"in et)&&("w"in et||(et.w="u"in et?et.u%7:"W"in et?1:0),pt="Z"in et?j7(qC(et.y)).getUTCDay():ct(qC(et.y)).getDay(),et.m=0,et.d="W"in et?(et.w+6)%7+et.W*7-(pt+5)%7:et.w+et.U*7-(pt+6)%7);return"Z"in et?(et.H+=et.Z/100|0,et.M+=et.Z%100,j7(et)):ct(et)}}function O(_t,ct,X,et){for(var dt=0,q=ct.length,pt=X.length,ht,wt;dt<q;){if(et>=pt)return-1;if(ht=ct.charCodeAt(dt++),ht===37){if(ht=ct.charAt(dt++),wt=C[ht in aVt?ct.charAt(dt++):ht],!wt||(et=wt(_t,X,et))<0)return-1}else if(ht!=X.charCodeAt(et++))return-1}return et}function D(_t,ct,X){var et=c.exec(ct.slice(X));return et?(_t.p=u[et[0].toLowerCase()],X+et[0].length):-1}function B(_t,ct,X){var et=p.exec(ct.slice(X));return et?(_t.w=d[et[0].toLowerCase()],X+et[0].length):-1}function I(_t,ct,X){var et=h.exec(ct.slice(X));return et?(_t.w=f[et[0].toLowerCase()],X+et[0].length):-1}function L(_t,ct,X){var et=y.exec(ct.slice(X));return et?(_t.m=x[et[0].toLowerCase()],X+et[0].length):-1}function R(_t,ct,X){var et=g.exec(ct.slice(X));return et?(_t.m=_[et[0].toLowerCase()],X+et[0].length):-1}function F(_t,ct,X){return O(_t,t,ct,X)}function z(_t,ct,X){return O(_t,r,ct,X)}function U(_t,ct,X){return O(_t,n,ct,X)}function W(_t){return a[_t.getDay()]}function Z(_t){return o[_t.getDay()]}function rt(_t){return l[_t.getMonth()]}function ot(_t){return s[_t.getMonth()]}function st(_t){return i[+(_t.getHours()>=12)]}function St(_t){return a[_t.getUTCDay()]}function bt(_t){return o[_t.getUTCDay()]}function Mt(_t){return l[_t.getUTCMonth()]}function lt(_t){return s[_t.getUTCMonth()]}function Kt(_t){return i[+(_t.getUTCHours()>=12)]}return{format:function(_t){var ct=P(_t+="",b);return ct.toString=function(){return _t},ct},parse:function(_t){var ct=k(_t+="",$Le);return ct.toString=function(){return _t},ct},utcFormat:function(_t){var ct=P(_t+="",S);return ct.toString=function(){return _t},ct},utcParse:function(_t){var ct=k(_t,j7);return ct.toString=function(){return _t},ct}}}function gn(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function JLe(e){return e.replace(ZLe,"\\$&")}function GC(e){return new RegExp("^(?:"+e.map(JLe).join("|")+")","i")}function WC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function QLe(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function tke(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function eke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function rke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function nke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function ike(e,t,r){var n=Vo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function oke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function ake(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function ske(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function sVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function lke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function lVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function cke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function uke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function hke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function fke(e,t,r){var n=Vo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function pke(e,t,r){var n=KLe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function dke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function mke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0]*1e3,r+n[0].length):-1}function cVt(e,t){return gn(e.getDate(),t,2)}function gke(e,t){return gn(e.getHours(),t,2)}function _ke(e,t){return gn(e.getHours()%12||12,t,2)}function yke(e,t){return gn(1+W7.count(yv(e),e),t,3)}function dVt(e,t){return gn(e.getMilliseconds(),t,3)}function vke(e,t){return dVt(e,t)+"000"}function xke(e,t){return gn(e.getMonth()+1,t,2)}function bke(e,t){return gn(e.getMinutes(),t,2)}function wke(e,t){return gn(e.getSeconds(),t,2)}function Ske(e){var t=e.getDay();return t===0?7:t}function Mke(e,t){return gn(VC.count(yv(e),e),t,2)}function Eke(e,t){var r=e.getDay();return e=r>=4||r===0?Vw(e):Vw.ceil(e),gn(Vw.count(yv(e),e)+(yv(e).getDay()===4),t,2)}function Tke(e){return e.getDay()}function Cke(e,t){return gn(Hw.count(yv(e),e),t,2)}function Ake(e,t){return gn(e.getFullYear()%100,t,2)}function Pke(e,t){return gn(e.getFullYear()%1e4,t,4)}function Ike(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+gn(t/60|0,"0",2)+gn(t%60,"0",2)}function uVt(e,t){return gn(e.getUTCDate(),t,2)}function Lke(e,t){return gn(e.getUTCHours(),t,2)}function kke(e,t){return gn(e.getUTCHours()%12||12,t,2)}function Rke(e,t){return gn(1+Y7.count(xv(e),e),t,3)}function mVt(e,t){return gn(e.getUTCMilliseconds(),t,3)}function Nke(e,t){return mVt(e,t)+"000"}function Dke(e,t){return gn(e.getUTCMonth()+1,t,2)}function Oke(e,t){return gn(e.getUTCMinutes(),t,2)}function zke(e,t){return gn(e.getUTCSeconds(),t,2)}function Fke(e){var t=e.getUTCDay();return t===0?7:t}function Bke(e,t){return gn(UC.count(xv(e),e),t,2)}function Hke(e,t){var r=e.getUTCDay();return e=r>=4||r===0?qw(e):qw.ceil(e),gn(qw.count(xv(e),e)+(xv(e).getUTCDay()===4),t,2)}function Vke(e){return e.getUTCDay()}function Uke(e,t){return gn(Uw.count(xv(e),e),t,2)}function qke(e,t){return gn(e.getUTCFullYear()%100,t,2)}function Gke(e,t){return gn(e.getUTCFullYear()%1e4,t,4)}function Wke(){return"+0000"}function hVt(){return"%"}function fVt(e){return+e}function pVt(e){return Math.floor(+e/1e3)}var aVt,Vo,KLe,ZLe,brt=M(()=>{oVt();aVt={"-":"",_:" ",0:"0"},Vo=/^\s*\d+/,KLe=/^%/,ZLe=/[\\^$*+?|[\]().{}]/g});function X7(e){return Gw=YC(e),wrt=Gw.format,Srt=Gw.parse,jC=Gw.utcFormat,XC=Gw.utcParse,Gw}var Gw,wrt,Srt,jC,XC,$7=M(()=>{brt();X7({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});function Yke(e){return e.toISOString()}var Mrt,jke,gVt,Ert=M(()=>{$7();Mrt="%Y-%m-%dT%H:%M:%S.%LZ";jke=Date.prototype.toISOString?Yke:jC(Mrt),gVt=jke});function Xke(e){var t=new Date(e);return isNaN(t)?null:t}var $ke,_Vt,yVt=M(()=>{Ert();$7();$ke=+new Date("2000-01-01T00:00:00.000Z")?Xke:XC(Mrt),_Vt=$ke});var vVt=M(()=>{$7();brt();Ert();yVt()});function Yw(){return bv||(wVt(Kke),bv=JC.now()+J7)}function Kke(){bv=0}function wv(){this._call=this._time=this._next=null}function Crt(e,t,r){var n=new wv;return n.restart(e,t,r),n}function Art(){Yw(),++Ww;for(var e=K7,t;e;)(t=bv-e._time)>=0&&e._call.call(null,t),e=e._next;--Ww}function xVt(){bv=(Z7=JC.now())+J7,Ww=KC=0;try{Art()}finally{Ww=0,Jke(),bv=0}}function Zke(){var e=JC.now(),t=e-Z7;t>bVt&&(J7-=t,Z7=e)}function Jke(){for(var e,t=K7,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:K7=r);ZC=e,Trt(n)}function Trt(e){if(!Ww){KC&&(KC=clearTimeout(KC));var t=e-bv;t>24?(e<1/0&&(KC=setTimeout(xVt,e-JC.now()-J7)),$C&&($C=clearInterval($C))):($C||(Z7=JC.now(),$C=setInterval(Zke,bVt)),Ww=1,wVt(xVt))}}var Ww,KC,$C,bVt,K7,ZC,Z7,bv,J7,JC,wVt,Q7=M(()=>{Ww=0,KC=0,$C=0,bVt=1e3,Z7=0,bv=0,J7=0,JC=typeof performance=="object"&&performance.now?performance:Date,wVt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};wv.prototype=Crt.prototype={constructor:wv,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Yw():+r)+(t==null?0:+t),!this._next&&ZC!==this&&(ZC?ZC._next=this:K7=this,ZC=this),this._call=e,this._time=r,Trt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Trt())}}});function SVt(e,t,r){var n=new wv;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var MVt=M(()=>{Q7()});function EVt(e,t,r){var n=new wv,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Yw():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var TVt=M(()=>{Q7()});var CVt=M(()=>{Q7();MVt();TVt()});var tz,Prt,Irt=M(()=>{tz="http://www.w3.org/1999/xhtml",Prt={svg:"http://www.w3.org/2000/svg",xhtml:tz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function cd(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),Prt.hasOwnProperty(t)?{space:Prt[t],local:e}:e}var ez=M(()=>{Irt()});function Qke(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===tz&&t.documentElement.namespaceURI===tz?t.createElement(e):t.createElementNS(r,e)}}function t8e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function rz(e){var t=cd(e);return(t.local?t8e:Qke)(t)}var Lrt=M(()=>{ez();Irt()});function e8e(){}function Sv(e){return e==null?e8e:function(){return this.querySelector(e)}}var nz=M(()=>{});function AVt(e){typeof e!="function"&&(e=Sv(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new no(n,this._parents)}var PVt=M(()=>{Mf();nz()});function r8e(){return[]}function QC(e){return e==null?r8e:function(){return this.querySelectorAll(e)}}var krt=M(()=>{});function IVt(e){typeof e!="function"&&(e=QC(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new no(n,i)}var LVt=M(()=>{Mf();krt()});function tA(e){return function(){return this.matches(e)}}var Rrt=M(()=>{});function kVt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new no(n,this._parents)}var RVt=M(()=>{Mf();Rrt()});function iz(e){return new Array(e.length)}var Nrt=M(()=>{});function NVt(){return new no(this._enter||this._groups.map(iz),this._parents)}function eA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Drt=M(()=>{Nrt();Mf();eA.prototype={constructor:eA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function DVt(e){return function(){return e}}var OVt=M(()=>{});function n8e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new eA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function i8e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=zVt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=zVt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new eA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function FVt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?i8e:n8e,n=this._parents,i=this._groups;typeof e!="function"&&(e=DVt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new no(a,n),a._enter=s,a._exit=l,a}var zVt,BVt=M(()=>{Mf();Drt();OVt();zVt="$"});function HVt(){return new no(this._exit||this._groups.map(iz),this._parents)}var VVt=M(()=>{Nrt();Mf()});function UVt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var qVt=M(()=>{});function GVt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new no(a,this._parents)}var WVt=M(()=>{Mf()});function YVt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var jVt=M(()=>{});function XVt(e){e||(e=o8e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new no(i,this._parents).order()}function o8e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var $Vt=M(()=>{Mf()});function KVt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var ZVt=M(()=>{});function JVt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var QVt=M(()=>{});function tUt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var eUt=M(()=>{});function rUt(){var e=0;return this.each(function(){++e}),e}var nUt=M(()=>{});function iUt(){return!this.node()}var oUt=M(()=>{});function aUt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var sUt=M(()=>{});function a8e(e){return function(){this.removeAttribute(e)}}function s8e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function l8e(e,t){return function(){this.setAttribute(e,t)}}function c8e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function u8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function h8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function lUt(e,t){var r=cd(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?s8e:a8e:typeof t=="function"?r.local?h8e:u8e:r.local?c8e:l8e)(r,t))}var cUt=M(()=>{ez()});function oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Ort=M(()=>{});function f8e(e){return function(){this.style.removeProperty(e)}}function p8e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function d8e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function uUt(e,t,r){return arguments.length>1?this.each((t==null?f8e:typeof t=="function"?d8e:p8e)(e,t,r==null?"":r)):Hg(this.node(),e)}function Hg(e,t){return e.style.getPropertyValue(t)||oz(e).getComputedStyle(e,null).getPropertyValue(t)}var zrt=M(()=>{Ort()});function m8e(e){return function(){delete this[e]}}function g8e(e,t){return function(){this[e]=t}}function _8e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function hUt(e,t){return arguments.length>1?this.each((t==null?m8e:typeof t=="function"?_8e:g8e)(e,t)):this.node()[e]}var fUt=M(()=>{});function pUt(e){return e.trim().split(/^|\s+/)}function Frt(e){return e.classList||new dUt(e)}function dUt(e){this._node=e,this._names=pUt(e.getAttribute("class")||"")}function mUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function gUt(e,t){for(var r=Frt(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function y8e(e){return function(){mUt(this,e)}}function v8e(e){return function(){gUt(this,e)}}function x8e(e,t){return function(){(t.apply(this,arguments)?mUt:gUt)(this,e)}}function _Ut(e,t){var r=pUt(e+"");if(arguments.length<2){for(var n=Frt(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?x8e:t?y8e:v8e)(r,t))}var yUt=M(()=>{dUt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function b8e(){this.textContent=""}function w8e(e){return function(){this.textContent=e}}function S8e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function vUt(e){return arguments.length?this.each(e==null?b8e:(typeof e=="function"?S8e:w8e)(e)):this.node().textContent}var xUt=M(()=>{});function M8e(){this.innerHTML=""}function E8e(e){return function(){this.innerHTML=e}}function T8e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function bUt(e){return arguments.length?this.each(e==null?M8e:(typeof e=="function"?T8e:E8e)(e)):this.node().innerHTML}var wUt=M(()=>{});function C8e(){this.nextSibling&&this.parentNode.appendChild(this)}function SUt(){return this.each(C8e)}var MUt=M(()=>{});function A8e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function EUt(){return this.each(A8e)}var TUt=M(()=>{});function CUt(e){var t=typeof e=="function"?e:rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var AUt=M(()=>{Lrt()});function P8e(){return null}function PUt(e,t){var r=typeof e=="function"?e:rz(e),n=t==null?P8e:typeof t=="function"?t:Sv(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var IUt=M(()=>{Lrt();nz()});function I8e(){var e=this.parentNode;e&&e.removeChild(this)}function LUt(){return this.each(I8e)}var kUt=M(()=>{});function L8e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function k8e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function RUt(e){return this.select(e?k8e:L8e)}var NUt=M(()=>{});function DUt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var OUt=M(()=>{});function R8e(e,t,r){return e=BUt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function BUt(e,t,r){return function(n){var i=Brt;Brt=n;try{e.call(this,this.__data__,t,r)}finally{Brt=i}}}function N8e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function D8e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function O8e(e,t,r){var n=FUt.hasOwnProperty(e.type)?R8e:BUt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function HUt(e,t,r){var n=N8e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?O8e:D8e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}var FUt,Brt,zUt,VUt=M(()=>{FUt={},Brt=null;typeof document!="undefined"&&(zUt=document.documentElement,"onmouseenter"in zUt||(FUt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function UUt(e,t,r){var n=oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function z8e(e,t){return function(){return UUt(this,e,t)}}function F8e(e,t){return function(){return UUt(this,e,t.apply(this,arguments))}}function qUt(e,t){return this.each((typeof t=="function"?F8e:z8e)(e,t))}var GUt=M(()=>{Ort()});function no(e,t){this._groups=e,this._parents=t}function WUt(){return new no([[document.documentElement]],B8e)}var B8e,ud,Mf=M(()=>{PVt();LVt();RVt();BVt();Drt();VVt();qVt();WVt();jVt();$Vt();ZVt();QVt();eUt();nUt();oUt();sUt();cUt();zrt();fUt();yUt();xUt();wUt();MUt();TUt();AUt();IUt();kUt();NUt();OUt();VUt();GUt();B8e=[null];no.prototype=WUt.prototype={constructor:no,select:AVt,selectAll:IVt,filter:kVt,data:FVt,enter:NVt,exit:HVt,join:UVt,merge:GVt,order:YVt,sort:XVt,call:KVt,nodes:JVt,node:tUt,size:rUt,empty:iUt,each:aUt,attr:lUt,style:uUt,property:hUt,classed:_Ut,text:vUt,html:bUt,raise:SUt,lower:EUt,append:CUt,insert:PUt,remove:LUt,clone:RUt,datum:DUt,on:HUt,dispatch:qUt};ud=WUt});var Ef=M(()=>{Rrt();ez();Mf();nz();krt();zrt()});function jUt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new az(r)}function az(e){this._=e}function V8e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function U8e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function YUt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=H8e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var H8e,Hrt,XUt=M(()=>{H8e={value:function(){}};az.prototype=jUt.prototype={constructor:az,on:function(e,t){var r=this._,n=V8e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=U8e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=YUt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=YUt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new az(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};Hrt=jUt});var $Ut=M(()=>{XUt()});function Xw(){return Mv||(JUt(q8e),Mv=oA.now()+cz)}function q8e(){Mv=0}function aA(){this._call=this._time=this._next=null}function uz(e,t,r){var n=new aA;return n.restart(e,t,r),n}function QUt(){Xw(),++jw;for(var e=sz,t;e;)(t=Mv-e._time)>=0&&e._call.call(null,t),e=e._next;--jw}function KUt(){Mv=(lz=oA.now())+cz,jw=nA=0;try{QUt()}finally{jw=0,W8e(),Mv=0}}function G8e(){var e=oA.now(),t=e-lz;t>ZUt&&(cz-=t,lz=e)}function W8e(){for(var e,t=sz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:sz=r);iA=e,Vrt(n)}function Vrt(e){if(!jw){nA&&(nA=clearTimeout(nA));var t=e-Mv;t>24?(e<1/0&&(nA=setTimeout(KUt,e-oA.now()-cz)),rA&&(rA=clearInterval(rA))):(rA||(lz=oA.now(),rA=setInterval(G8e,ZUt)),jw=1,JUt(KUt))}}var jw,nA,rA,ZUt,sz,iA,lz,Mv,cz,oA,JUt,Urt=M(()=>{jw=0,nA=0,rA=0,ZUt=1e3,lz=0,Mv=0,cz=0,oA=typeof performance=="object"&&performance.now?performance:Date,JUt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};aA.prototype=uz.prototype={constructor:aA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Xw():+r)+(t==null?0:+t),!this._next&&iA!==this&&(iA?iA._next=this:sz=this,iA=this),this._call=e,this._time=r,Vrt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Vrt())}}});function hz(e,t,r){var n=new aA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var tqt=M(()=>{Urt()});var qrt=M(()=>{Urt();tqt()});function Vg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;X8e(e,r,{name:t,index:n,group:i,on:Y8e,tween:j8e,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:rqt})}function cA(e,t){var r=io(e,t);if(r.state>rqt)throw new Error("too late; already scheduled");return r}function Du(e,t){var r=io(e,t);if(r.state>lA)throw new Error("too late; already started");return r}function io(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function X8e(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=uz(o,0,r.time);function o(c){r.state=fz,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==fz)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===Grt)return hz(a);p.state===eqt?(p.state=sA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=sA,p.timer.stop(),delete n[u])}if(hz(function(){r.state===Grt&&(r.state=eqt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=lA,r.on.call("start",e,e.__data__,r.index,r.group),r.state===lA){for(r.state=Grt,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=pz,1),h=-1,f=i.length;++h<f;)i[h].call(null,u);r.state===pz&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=sA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var Y8e,j8e,rqt,fz,lA,Grt,eqt,pz,sA,Ac=M(()=>{$Ut();qrt();Y8e=Hrt("start","end","interrupt"),j8e=[],rqt=0,fz=1,lA=2,Grt=3,eqt=4,pz=5,sA=6});function dz(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>lA&&n.state<pz,n.state=sA,n.timer.stop(),i&&n.on.call("interrupt",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Wrt=M(()=>{Ac()});function nqt(e){return this.each(function(){dz(this,e)})}var iqt=M(()=>{Wrt()});function mz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Yrt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var oqt=M(()=>{});function fA(){}function sqt(){return this.rgb().formatHex()}function rRe(){return pqt(this).formatHsl()}function lqt(){return this.rgb().formatRgb()}function Ug(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=$8e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?cqt(t):r===3?new gl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?gz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?gz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=K8e.exec(e))?new gl(t[1],t[2],t[3],1):(t=Z8e.exec(e))?new gl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=J8e.exec(e))?gz(t[1],t[2],t[3],t[4]):(t=Q8e.exec(e))?gz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=tRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,1):(t=eRe.exec(e))?fqt(t[1],t[2]/100,t[3]/100,t[4]):aqt.hasOwnProperty(e)?cqt(aqt[e]):e==="transparent"?new gl(NaN,NaN,NaN,0):null}function cqt(e){return new gl(e>>16&255,e>>8&255,e&255,1)}function gz(e,t,r,n){return n<=0&&(e=t=r=NaN),new gl(e,t,r,n)}function nRe(e){return e instanceof fA||(e=Ug(e)),e?(e=e.rgb(),new gl(e.r,e.g,e.b,e.opacity)):new gl}function Kw(e,t,r,n){return arguments.length===1?nRe(e):new gl(e,t,r,n==null?1:n)}function gl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function uqt(){return"#"+jrt(this.r)+jrt(this.g)+jrt(this.b)}function hqt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function jrt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function fqt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Tf(e,t,r,n)}function pqt(e){if(e instanceof Tf)return new Tf(e.h,e.s,e.l,e.opacity);if(e instanceof fA||(e=Ug(e)),!e)return new Tf;if(e instanceof Tf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Tf(a,s,l,e.opacity)}function dqt(e,t,r,n){return arguments.length===1?pqt(e):new Tf(e,t,r,n==null?1:n)}function Tf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Xrt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var uA,_z,$w,hA,Cf,$8e,K8e,Z8e,J8e,Q8e,tRe,eRe,aqt,mqt=M(()=>{oqt();uA=.7,_z=1/uA,$w="\\s*([+-]?\\d+)\\s*",hA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Cf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",$8e=/^#([0-9a-f]{3,8})$/,K8e=new RegExp("^rgb\\("+[$w,$w,$w]+"\\)$"),Z8e=new RegExp("^rgb\\("+[Cf,Cf,Cf]+"\\)$"),J8e=new RegExp("^rgba\\("+[$w,$w,$w,hA]+"\\)$"),Q8e=new RegExp("^rgba\\("+[Cf,Cf,Cf,hA]+"\\)$"),tRe=new RegExp("^hsl\\("+[hA,Cf,Cf]+"\\)$"),eRe=new RegExp("^hsla\\("+[hA,Cf,Cf,hA]+"\\)$"),aqt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};mz(fA,Ug,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:sqt,formatHex:sqt,formatHsl:rRe,formatRgb:lqt,toString:lqt});mz(gl,Kw,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:uqt,formatHex:uqt,formatRgb:hqt,toString:hqt}));mz(Tf,dqt,Yrt(fA,{brighter:function(e){return e=e==null?_z:Math.pow(_z,e),new Tf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?uA:Math.pow(uA,e),new Tf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new gl(Xrt(e>=240?e-240:e+120,i,n),Xrt(e,i,n),Xrt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var $rt=M(()=>{mqt()});function Krt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function gqt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Krt((r-n/t)*t,a,i,o,s)}}var Zrt=M(()=>{});function _qt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Krt((r-n/t)*t,i,o,a,s)}}var yqt=M(()=>{Zrt()});function Jrt(e){return function(){return e}}var vqt=M(()=>{});function iRe(e,t){return function(r){return e+r*t}}function oRe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function xqt(e){return(e=+e)==1?yz:function(t,r){return r-t?oRe(t,r,e):Jrt(isNaN(t)?r:t)}}function yz(e,t){var r=t-e;return r?iRe(e,r):Jrt(isNaN(e)?t:e)}var bqt=M(()=>{vqt()});function wqt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=Kw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var vz,aRe,sRe,Sqt=M(()=>{$rt();Zrt();yqt();bqt();vz=function e(t){var r=xqt(t);function n(i,o){var a=r((i=Kw(i)).r,(o=Kw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=yz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);aRe=wqt(gqt),sRe=wqt(_qt)});function Pc(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var xz=M(()=>{});function lRe(e){return function(){return e}}function cRe(e){return function(t){return e(t)+""}}function ent(e,t){var r=tnt.lastIndex=Qrt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=tnt.exec(e))&&(i=Qrt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Pc(n,i)})),r=Qrt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?cRe(l[0].x):lRe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var tnt,Qrt,Mqt=M(()=>{xz();tnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Qrt=new RegExp(tnt.source,"g")});function rnt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Eqt,skewX:Math.atan(l)*Eqt,scaleX:a,scaleY:s}}var Eqt,bz,Tqt=M(()=>{Eqt=180/Math.PI,bz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function Aqt(e){return e==="none"?bz:(pA||(pA=document.createElement("DIV"),nnt=document.documentElement,Cqt=document.defaultView),pA.style.transform=e,e=Cqt.getComputedStyle(nnt.appendChild(pA),null).getPropertyValue("transform"),nnt.removeChild(pA),e=e.slice(7,-1).split(","),rnt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Pqt(e){return e==null?bz:(wz||(wz=document.createElementNS("http://www.w3.org/2000/svg","g")),wz.setAttribute("transform",e),(e=wz.transform.baseVal.consolidate())?(e=e.matrix,rnt(e.a,e.b,e.c,e.d,e.e,e.f)):bz)}var pA,nnt,Cqt,wz,Iqt=M(()=>{Tqt()});function Lqt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Pc(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Pc(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var int,ont,kqt=M(()=>{xz();Iqt();int=Lqt(Aqt,"px, ","px)","deg)"),ont=Lqt(Pqt,", ",")",")")});var Sz=M(()=>{xz();Mqt();kqt();Sqt()});function uRe(e,t){var r,n;return function(){var i=Du(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function hRe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Du(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function Rqt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=io(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?uRe:hRe)(r,e,t))}function Zw(e,t,r){var n=e._id;return e.each(function(){var i=Du(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return io(i,n).value[t]}}var dA=M(()=>{Ac()});function Mz(e,t){var r;return(typeof t=="number"?Pc:t instanceof Ug?vz:(r=Ug(t))?(t=r,vz):ent)(e,t)}var ant=M(()=>{$rt();Sz()});function fRe(e){return function(){this.removeAttribute(e)}}function pRe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function dRe(e,t,r){var n,i;return function(){var o=this.getAttribute(e);return o===r?null:o===n?i:i=t(n=o,r)}}function mRe(e,t,r){var n,i;return function(){var o=this.getAttributeNS(e.space,e.local);return o===r?null:o===n?i:i=t(n=o,r)}}function gRe(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function _Re(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function Nqt(e,t){var r=cd(e),n=r==="transform"?ont:Mz;return this.attrTween(e,typeof t=="function"?(r.local?_Re:gRe)(r,n,Zw(this,"attr."+e,t)):t==null?(r.local?pRe:fRe)(r):(r.local?mRe:dRe)(r,n,t+""))}var Dqt=M(()=>{Sz();Ef();dA();ant()});function yRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttributeNS(e.space,e.local,i(o))}}return r._value=t,r}function vRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttribute(e,i(o))}}return r._value=t,r}function Oqt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=cd(e);return this.tween(r,(n.local?yRe:vRe)(n,t))}var zqt=M(()=>{Ef()});function xRe(e,t){return function(){cA(this,e).delay=+t.apply(this,arguments)}}function bRe(e,t){return t=+t,function(){cA(this,e).delay=t}}function Fqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?xRe:bRe)(t,e)):io(this.node(),t).delay}var Bqt=M(()=>{Ac()});function wRe(e,t){return function(){Du(this,e).duration=+t.apply(this,arguments)}}function SRe(e,t){return t=+t,function(){Du(this,e).duration=t}}function Hqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?wRe:SRe)(t,e)):io(this.node(),t).duration}var Vqt=M(()=>{Ac()});function MRe(e,t){if(typeof t!="function")throw new Error;return function(){Du(this,e).ease=t}}function Uqt(e){var t=this._id;return arguments.length?this.each(MRe(t,e)):io(this.node(),t).ease}var qqt=M(()=>{Ac()});function Gqt(e){typeof e!="function"&&(e=tA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Uo(n,this._parents,this._name,this._id)}var Wqt=M(()=>{Ef();hd()});function Yqt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Uo(a,this._parents,this._name,this._id)}var jqt=M(()=>{hd()});function ERe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function TRe(e,t,r){var n,i,o=ERe(t)?cA:Du;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function Xqt(e,t){var r=this._id;return arguments.length<2?io(this.node(),r).on.on(e):this.each(TRe(r,e,t))}var $qt=M(()=>{Ac()});function CRe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function Kqt(){return this.on("end.remove",CRe(this._id))}var Zqt=M(()=>{});function Jqt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Sv(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Vg(c[f],t,r,f,c,io(u,r)));return new Uo(o,this._parents,t,r)}var Qqt=M(()=>{Ef();hd();Ac()});function tGt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=QC(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=io(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Vg(p,t,r,g,f,d);o.push(f),a.push(u)}return new Uo(o,a,t,r)}var eGt=M(()=>{Ef();hd();Ac()});function rGt(){return new ARe(this._groups,this._parents)}var ARe,nGt=M(()=>{Ef();ARe=ud.prototype.constructor});function PRe(e,t){var r,n,i;return function(){var o=Hg(this,e),a=(this.style.removeProperty(e),Hg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function IRe(e){return function(){this.style.removeProperty(e)}}function LRe(e,t,r){var n,i;return function(){var o=Hg(this,e);return o===r?null:o===n?i:i=t(n=o,r)}}function kRe(e,t,r){var n,i,o;return function(){var a=Hg(this,e),s=r(this);return s==null&&(s=(this.style.removeProperty(e),Hg(this,e))),a===s?null:a===n&&s===i?o:o=t(n=a,i=s)}}function iGt(e,t,r){var n=(e+="")=="transform"?int:Mz;return t==null?this.styleTween(e,PRe(e,n)).on("end.style."+e,IRe(e)):this.styleTween(e,typeof t=="function"?kRe(e,n,Zw(this,"style."+e,t)):LRe(e,n,t+""),r)}var oGt=M(()=>{Sz();Ef();dA();ant()});function RRe(e,t,r){function n(){var i=this,o=t.apply(i,arguments);return o&&function(a){i.style.setProperty(e,o(a),r)}}return n._value=t,n}function aGt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RRe(e,t,r==null?"":r))}var sGt=M(()=>{});function NRe(e){return function(){this.textContent=e}}function DRe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function lGt(e){return this.tween("text",typeof e=="function"?DRe(Zw(this,"text",e)):NRe(e==null?"":e+""))}var cGt=M(()=>{dA()});function uGt(){for(var e=this._name,t=this._id,r=Ez(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=io(l,t);Vg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Uo(n,this._parents,e,r)}var hGt=M(()=>{hd();Ac()});function Uo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function Tz(e){return ud().transition(e)}function Ez(){return++ORe}var ORe,Jw,hd=M(()=>{Ef();Dqt();zqt();Bqt();Vqt();qqt();Wqt();jqt();$qt();Zqt();Qqt();eGt();nGt();oGt();sGt();cGt();hGt();dA();ORe=0;Jw=ud.prototype;Uo.prototype=Tz.prototype={constructor:Uo,select:Jqt,selectAll:tGt,filter:Gqt,merge:Yqt,selection:rGt,transition:uGt,call:Jw.call,nodes:Jw.nodes,node:Jw.node,size:Jw.size,empty:Jw.empty,each:Jw.each,on:Xqt,attr:Nqt,attrTween:Oqt,style:iGt,styleTween:aGt,text:lGt,remove:Kqt,tween:Rqt,delay:Fqt,duration:Hqt,ease:Uqt}});function zRe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return snt.time=Xw(),snt;return r}function fGt(e){var t,r;e instanceof Uo?(t=e._id,e=e._name):(t=Ez(),(r=snt).time=Xw(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Vg(l,e,t,c,a,r||zRe(l,t));return new Uo(n,this._parents,e,t)}var snt,pGt=M(()=>{hd();Ac();L_();qrt();snt={time:null,delay:0,duration:250,ease:bs}});var dGt=M(()=>{Ef();iqt();pGt();ud.prototype.interrupt=nqt;ud.prototype.transition=fGt});function mGt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>fz&&n.name===t)return new Uo([[e]],FRe,t,+i)}return null}var FRe,gGt=M(()=>{hd();Ac();FRe=[null]});var _Gt=M(()=>{dGt();hd();gGt();Wrt()});function lnt(e){return function(){return e}}var yGt=M(()=>{});function vGt(e){return e[0]}function xGt(e){return e[1]}var bGt=M(()=>{});function cnt(){this._=null}function Qw(e){e.U=e.C=e.L=e.R=e.P=e.N=null}function mA(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function gA(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function wGt(e){for(;e.L;)e=e.L;return e}var unt,Cz=M(()=>{cnt.prototype={constructor:cnt,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=wGt(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(mA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,gA(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(gA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,mA(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=wGt(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,mA(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,gA(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,mA(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,gA(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,mA(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,gA(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};unt=cnt});function tS(e,t,r,n){var i=[null,null],o=Ao.push(i)-1;return i.left=e,i.right=t,r&&_A(i,e,t,r),n&&_A(i,t,e,n),Ja[e.index].halfedges.push(o),Ja[t.index].halfedges.push(o),i}function eS(e,t,r){var n=[t,r];return n.left=e,n}function _A(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function BRe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function HRe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function SGt(e,t,r,n){for(var i=Ao.length,o;i--;)(!HRe(o=Ao[i],e,t,r,n)||!BRe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Wr||Math.abs(o[0][1]-o[1][1])>Wr))&&delete Ao[i]}var Az=M(()=>{rS()});function MGt(e){return Ja[e.index]={site:e,halfedges:[]}}function VRe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function hnt(e,t){return t[+(t.left!==e.site)]}function URe(e,t){return t[+(t.left===e.site)]}function EGt(){for(var e=0,t=Ja.length,r,n,i,o;e<t;++e)if((r=Ja[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=VRe(r,Ao[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function TGt(e,t,r,n){var i=Ja.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Ja[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)Ao[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=URe(a,Ao[c[l]]),g=d[0],_=d[1],h=hnt(a,Ao[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Wr||Math.abs(_-p)>Wr)&&(c.splice(l,0,Ao.push(eS(s,d,Math.abs(g-e)<Wr&&n-_>Wr?[e,Math.abs(f-e)<Wr?p:n]:Math.abs(_-n)<Wr&&r-g>Wr?[Math.abs(p-n)<Wr?f:r,n]:Math.abs(g-r)<Wr&&_-t>Wr?[r,Math.abs(f-r)<Wr?p:t]:Math.abs(_-t)<Wr&&g-e>Wr?[Math.abs(p-t)<Wr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Ja[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(Ao.push(eS(s=y.site,P,k))-1,Ao.push(eS(s,k,O))-1,Ao.push(eS(s,O,D))-1,Ao.push(eS(s,D,P))-1)}}for(o=0;o<i;++o)(a=Ja[o])&&(a.halfedges.length||delete Ja[o])}var fnt=M(()=>{Az();rS()});function qRe(){Qw(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ev(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-AGt)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=CGt.pop()||new qRe;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=nS._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}nS.insert(x,y),x||(Pz=y)}}}}function Tv(e){var t=e.circle;t&&(t.P||(Pz=t.N),nS.remove(t),CGt.push(t),Qw(t),e.circle=null)}var CGt,Pz,pnt=M(()=>{Cz();rS();CGt=[]});function GRe(){Qw(this),this.edge=this.site=this.circle=null}function PGt(e){var t=IGt.pop()||new GRe;return t.site=e,t}function dnt(e){Tv(e),Cv.remove(e),IGt.push(e),Qw(e)}function LGt(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];dnt(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Wr&&Math.abs(n-l.circle.cy)<Wr;)o=l.P,s.unshift(l),dnt(l),l=o;s.unshift(l),Tv(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Wr&&Math.abs(n-c.circle.cy)<Wr;)a=c.N,s.push(c),dnt(c),c=a;s.push(c),Tv(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],_A(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=tS(l.site,c.site,null,i),Ev(l),Ev(c)}function kGt(e){for(var t=e[0],r=e[1],n,i,o,a,s=Cv._;s;)if(o=RGt(s,r)-t,o>Wr)s=s.L;else if(a=t-WRe(s,r),a>Wr){if(!s.R){n=s;break}s=s.R}else{o>-Wr?(n=s.P,i=s):a>-Wr?(n=s,i=s.N):n=i=s;break}MGt(e);var l=PGt(e);if(Cv.insert(n,l),!(!n&&!i)){if(n===i){Tv(n),i=PGt(n.site),Cv.insert(l,i),l.edge=i.edge=tS(n.site,l.site),Ev(n),Ev(i);return}if(!i){l.edge=tS(n.site,l.site);return}Tv(n),Tv(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];_A(i.edge,c,d,S),l.edge=tS(c,e,null,S),i.edge=tS(e,d,null,S),Ev(n),Ev(i)}}function RGt(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function WRe(e,t){var r=e.N;if(r)return RGt(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var IGt,NGt=M(()=>{Cz();fnt();pnt();Az();rS();IGt=[]});function YRe(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function jRe(e,t){return t[1]-e[1]||t[0]-e[0]}function yA(e,t){var r=e.sort(jRe).pop(),n,i,o;for(Ao=[],Ja=new Array(e.length),Cv=new unt,nS=new unt;;)if(o=Pz,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(kGt(r),n=r[0],i=r[1]),r=e.pop();else if(o)LGt(o.arc);else break;if(EGt(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];SGt(a,s,l,c),TGt(a,s,l,c)}this.edges=Ao,this.cells=Ja,Cv=nS=Ao=Ja=null}var Wr,AGt,Cv,Ja,nS,Ao,rS=M(()=>{NGt();fnt();pnt();Az();Cz();Wr=1e-6,AGt=1e-12;yA.prototype={constructor:yA,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return hnt(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&YRe(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}}});function DGt(){var e=vGt,t=xGt,r=null;function n(i){return new yA(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Wr)*Wr,Math.round(t(o,a,i)/Wr)*Wr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:lnt(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:lnt(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}var OGt=M(()=>{yGt();bGt();rS()});var zGt=M(()=>{OGt()});function BGt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new Iz(r)}function Iz(e){this._=e}function $Re(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function KRe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function FGt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=XRe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var XRe,vA,HGt=M(()=>{XRe={value:function(){}};Iz.prototype=BGt.prototype={constructor:Iz,on:function(e,t){var r=this._,n=$Re(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=KRe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=FGt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=FGt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new Iz(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vA=BGt});var mnt=M(()=>{HGt()});var Lz,gnt,_nt=M(()=>{Lz="http://www.w3.org/1999/xhtml",gnt={svg:"http://www.w3.org/2000/svg",xhtml:Lz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function fd(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),gnt.hasOwnProperty(t)?{space:gnt[t],local:e}:e}var kz=M(()=>{_nt()});function ZRe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Lz&&t.documentElement.namespaceURI===Lz?t.createElement(e):t.createElementNS(r,e)}}function JRe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rz(e){var t=fd(e);return(t.local?JRe:ZRe)(t)}var ynt=M(()=>{kz();_nt()});function QRe(){}function Av(e){return e==null?QRe:function(){return this.querySelector(e)}}var Nz=M(()=>{});function VGt(e){typeof e!="function"&&(e=Av(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new mi(n,this._parents)}var UGt=M(()=>{Ou();Nz()});function tNe(){return[]}function xA(e){return e==null?tNe:function(){return this.querySelectorAll(e)}}var vnt=M(()=>{});function qGt(e){typeof e!="function"&&(e=xA(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new mi(n,i)}var GGt=M(()=>{Ou();vnt()});function bA(e){return function(){return this.matches(e)}}var xnt=M(()=>{});function WGt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new mi(n,this._parents)}var YGt=M(()=>{Ou();xnt()});function Dz(e){return new Array(e.length)}var bnt=M(()=>{});function jGt(){return new mi(this._enter||this._groups.map(Dz),this._parents)}function wA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var wnt=M(()=>{bnt();Ou();wA.prototype={constructor:wA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function XGt(e){return function(){return e}}var $Gt=M(()=>{});function eNe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new wA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function rNe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=KGt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=KGt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new wA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function ZGt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?rNe:eNe,n=this._parents,i=this._groups;typeof e!="function"&&(e=XGt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new mi(a,n),a._enter=s,a._exit=l,a}var KGt,JGt=M(()=>{Ou();wnt();$Gt();KGt="$"});function QGt(){return new mi(this._exit||this._groups.map(Dz),this._parents)}var tWt=M(()=>{bnt();Ou()});function eWt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var rWt=M(()=>{});function nWt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new mi(a,this._parents)}var iWt=M(()=>{Ou()});function oWt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var aWt=M(()=>{});function sWt(e){e||(e=nNe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new mi(i,this._parents).order()}function nNe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var lWt=M(()=>{Ou()});function cWt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var uWt=M(()=>{});function hWt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var fWt=M(()=>{});function pWt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var dWt=M(()=>{});function mWt(){var e=0;return this.each(function(){++e}),e}var gWt=M(()=>{});function _Wt(){return!this.node()}var yWt=M(()=>{});function vWt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var xWt=M(()=>{});function iNe(e){return function(){this.removeAttribute(e)}}function oNe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function aNe(e,t){return function(){this.setAttribute(e,t)}}function sNe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function lNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function cNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function bWt(e,t){var r=fd(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?oNe:iNe:typeof t=="function"?r.local?cNe:lNe:r.local?sNe:aNe)(r,t))}var wWt=M(()=>{kz()});function Oz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Snt=M(()=>{});function uNe(e){return function(){this.style.removeProperty(e)}}function hNe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function fNe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function SWt(e,t,r){return arguments.length>1?this.each((t==null?uNe:typeof t=="function"?fNe:hNe)(e,t,r==null?"":r)):qg(this.node(),e)}function qg(e,t){return e.style.getPropertyValue(t)||Oz(e).getComputedStyle(e,null).getPropertyValue(t)}var Mnt=M(()=>{Snt()});function pNe(e){return function(){delete this[e]}}function dNe(e,t){return function(){this[e]=t}}function mNe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function MWt(e,t){return arguments.length>1?this.each((t==null?pNe:typeof t=="function"?mNe:dNe)(e,t)):this.node()[e]}var EWt=M(()=>{});function TWt(e){return e.trim().split(/^|\s+/)}function Ent(e){return e.classList||new CWt(e)}function CWt(e){this._node=e,this._names=TWt(e.getAttribute("class")||"")}function AWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function PWt(e,t){for(var r=Ent(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function gNe(e){return function(){AWt(this,e)}}function _Ne(e){return function(){PWt(this,e)}}function yNe(e,t){return function(){(t.apply(this,arguments)?AWt:PWt)(this,e)}}function IWt(e,t){var r=TWt(e+"");if(arguments.length<2){for(var n=Ent(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?yNe:t?gNe:_Ne)(r,t))}var LWt=M(()=>{CWt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function vNe(){this.textContent=""}function xNe(e){return function(){this.textContent=e}}function bNe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function kWt(e){return arguments.length?this.each(e==null?vNe:(typeof e=="function"?bNe:xNe)(e)):this.node().textContent}var RWt=M(()=>{});function wNe(){this.innerHTML=""}function SNe(e){return function(){this.innerHTML=e}}function MNe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function NWt(e){return arguments.length?this.each(e==null?wNe:(typeof e=="function"?MNe:SNe)(e)):this.node().innerHTML}var DWt=M(()=>{});function ENe(){this.nextSibling&&this.parentNode.appendChild(this)}function OWt(){return this.each(ENe)}var zWt=M(()=>{});function TNe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function FWt(){return this.each(TNe)}var BWt=M(()=>{});function HWt(e){var t=typeof e=="function"?e:Rz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var VWt=M(()=>{ynt()});function CNe(){return null}function UWt(e,t){var r=typeof e=="function"?e:Rz(e),n=t==null?CNe:typeof t=="function"?t:Av(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var qWt=M(()=>{ynt();Nz()});function ANe(){var e=this.parentNode;e&&e.removeChild(this)}function GWt(){return this.each(ANe)}var WWt=M(()=>{});function PNe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function INe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function YWt(e){return this.select(e?INe:PNe)}var jWt=M(()=>{});function XWt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var $Wt=M(()=>{});function LNe(e,t,r){return e=JWt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function JWt(e,t,r){return function(n){var i=Yr;Yr=n;try{e.call(this,this.__data__,t,r)}finally{Yr=i}}}function kNe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function RNe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function NNe(e,t,r){var n=ZWt.hasOwnProperty(e.type)?LNe:JWt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function QWt(e,t,r){var n=kNe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?NNe:RNe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Tnt(e,t,r,n){var i=Yr;e.sourceEvent=Yr,Yr=e;try{return t.apply(r,n)}finally{Yr=i}}var ZWt,Yr,KWt,zz=M(()=>{ZWt={},Yr=null;typeof document!="undefined"&&(KWt=document.documentElement,"onmouseenter"in KWt||(ZWt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function tYt(e,t,r){var n=Oz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function DNe(e,t){return function(){return tYt(this,e,t)}}function ONe(e,t){return function(){return tYt(this,e,t.apply(this,arguments))}}function eYt(e,t){return this.each((typeof t=="function"?ONe:DNe)(e,t))}var rYt=M(()=>{Snt()});function mi(e,t){this._groups=e,this._parents=t}function nYt(){return new mi([[document.documentElement]],Cnt)}var Cnt,pd,Ou=M(()=>{UGt();GGt();YGt();JGt();wnt();tWt();rWt();iWt();aWt();lWt();uWt();fWt();dWt();gWt();yWt();xWt();wWt();Mnt();EWt();LWt();RWt();DWt();zWt();BWt();VWt();qWt();WWt();jWt();$Wt();zz();rYt();Cnt=[null];mi.prototype=nYt.prototype={constructor:mi,select:VGt,selectAll:qGt,filter:WGt,data:ZGt,enter:jGt,exit:QGt,join:eWt,merge:nWt,order:oWt,sort:sWt,call:cWt,nodes:hWt,node:pWt,size:mWt,empty:_Wt,each:vWt,attr:bWt,style:SWt,property:MWt,classed:IWt,text:kWt,html:NWt,raise:OWt,lower:FWt,append:HWt,insert:UWt,remove:GWt,clone:YWt,datum:XWt,on:QWt,dispatch:eYt};pd=nYt});function dd(e){return typeof e=="string"?new mi([[document.querySelector(e)]],[document.documentElement]):new mi([[e]],Cnt)}var iYt=M(()=>{Ou()});function Fz(){for(var e=Yr,t;t=e.sourceEvent;)e=t;return e}var Ant=M(()=>{zz()});function Bz(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var Pnt=M(()=>{});function iS(e){var t=Fz();return t.changedTouches&&(t=t.changedTouches[0]),Bz(e,t)}var oYt=M(()=>{Ant();Pnt()});function Hz(e,t,r){arguments.length<3&&(r=t,t=Fz().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Bz(e,o);return null}var aYt=M(()=>{Ant();Pnt()});var Ls=M(()=>{xnt();oYt();kz();iYt();Ou();Nz();vnt();Mnt();aYt();zz()});function Vz(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var sYt=M(()=>{Ls()});function Int(e){var t=e.document.documentElement,r=dd(e).on("dragstart.drag",Vz,!0);"onselectstart"in t?r.on("selectstart.drag",Vz,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Lnt(e,t){var r=e.document.documentElement,n=dd(e).on("dragstart.drag",null);t&&(n.on("click.drag",Vz,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var lYt=M(()=>{Ls();sYt()});var cYt=M(()=>{lYt()});function Uz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function knt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var uYt=M(()=>{});function EA(){}function fYt(){return this.rgb().formatHex()}function GNe(){return yYt(this).formatHsl()}function pYt(){return this.rgb().formatRgb()}function Gg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=zNe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?dYt(t):r===3?new _l(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?qz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?qz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=FNe.exec(e))?new _l(t[1],t[2],t[3],1):(t=BNe.exec(e))?new _l(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=HNe.exec(e))?qz(t[1],t[2],t[3],t[4]):(t=VNe.exec(e))?qz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=UNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,1):(t=qNe.exec(e))?_Yt(t[1],t[2]/100,t[3]/100,t[4]):hYt.hasOwnProperty(e)?dYt(hYt[e]):e==="transparent"?new _l(NaN,NaN,NaN,0):null}function dYt(e){return new _l(e>>16&255,e>>8&255,e&255,1)}function qz(e,t,r,n){return n<=0&&(e=t=r=NaN),new _l(e,t,r,n)}function WNe(e){return e instanceof EA||(e=Gg(e)),e?(e=e.rgb(),new _l(e.r,e.g,e.b,e.opacity)):new _l}function aS(e,t,r,n){return arguments.length===1?WNe(e):new _l(e,t,r,n==null?1:n)}function _l(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function mYt(){return"#"+Rnt(this.r)+Rnt(this.g)+Rnt(this.b)}function gYt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Rnt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function _Yt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Af(e,t,r,n)}function yYt(e){if(e instanceof Af)return new Af(e.h,e.s,e.l,e.opacity);if(e instanceof EA||(e=Gg(e)),!e)return new Af;if(e instanceof Af)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Af(a,s,l,e.opacity)}function vYt(e,t,r,n){return arguments.length===1?yYt(e):new Af(e,t,r,n==null?1:n)}function Af(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Nnt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var SA,Gz,oS,MA,Pf,zNe,FNe,BNe,HNe,VNe,UNe,qNe,hYt,xYt=M(()=>{uYt();SA=.7,Gz=1/SA,oS="\\s*([+-]?\\d+)\\s*",MA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Pf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",zNe=/^#([0-9a-f]{3,8})$/,FNe=new RegExp("^rgb\\("+[oS,oS,oS]+"\\)$"),BNe=new RegExp("^rgb\\("+[Pf,Pf,Pf]+"\\)$"),HNe=new RegExp("^rgba\\("+[oS,oS,oS,MA]+"\\)$"),VNe=new RegExp("^rgba\\("+[Pf,Pf,Pf,MA]+"\\)$"),UNe=new RegExp("^hsl\\("+[MA,Pf,Pf]+"\\)$"),qNe=new RegExp("^hsla\\("+[MA,Pf,Pf,MA]+"\\)$"),hYt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Uz(EA,Gg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:fYt,formatHex:fYt,formatHsl:GNe,formatRgb:pYt,toString:pYt});Uz(_l,aS,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new _l(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new _l(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:mYt,formatHex:mYt,formatRgb:gYt,toString:gYt}));Uz(Af,vYt,knt(EA,{brighter:function(e){return e=e==null?Gz:Math.pow(Gz,e),new Af(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?SA:Math.pow(SA,e),new Af(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new _l(Nnt(e>=240?e-240:e+120,i,n),Nnt(e,i,n),Nnt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var Dnt=M(()=>{xYt()});function Ont(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function bYt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Ont((r-n/t)*t,a,i,o,s)}}var znt=M(()=>{});function wYt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Ont((r-n/t)*t,i,o,a,s)}}var SYt=M(()=>{znt()});function Fnt(e){return function(){return e}}var MYt=M(()=>{});function YNe(e,t){return function(r){return e+r*t}}function jNe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function EYt(e){return(e=+e)==1?Wz:function(t,r){return r-t?jNe(t,r,e):Fnt(isNaN(t)?r:t)}}function Wz(e,t){var r=t-e;return r?YNe(e,r):Fnt(isNaN(e)?t:e)}var TYt=M(()=>{MYt()});function CYt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aS(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var Yz,XNe,$Ne,AYt=M(()=>{Dnt();znt();SYt();TYt();Yz=function e(t){var r=EYt(t);function n(i,o){var a=r((i=aS(i)).r,(o=aS(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Wz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);XNe=CYt(bYt),$Ne=CYt(wYt)});function Ic(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var jz=M(()=>{});function KNe(e){return function(){return e}}function ZNe(e){return function(t){return e(t)+""}}function Vnt(e,t){var r=Hnt.lastIndex=Bnt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Hnt.exec(e))&&(i=Bnt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ic(n,i)})),r=Bnt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?ZNe(l[0].x):KNe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Hnt,Bnt,PYt=M(()=>{jz();Hnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Bnt=new RegExp(Hnt.source,"g")});function Unt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*IYt,skewX:Math.atan(l)*IYt,scaleX:a,scaleY:s}}var IYt,Xz,LYt=M(()=>{IYt=180/Math.PI,Xz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function RYt(e){return e==="none"?Xz:(TA||(TA=document.createElement("DIV"),qnt=document.documentElement,kYt=document.defaultView),TA.style.transform=e,e=kYt.getComputedStyle(qnt.appendChild(TA),null).getPropertyValue("transform"),qnt.removeChild(TA),e=e.slice(7,-1).split(","),Unt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function NYt(e){return e==null?Xz:($z||($z=document.createElementNS("http://www.w3.org/2000/svg","g")),$z.setAttribute("transform",e),(e=$z.transform.baseVal.consolidate())?(e=e.matrix,Unt(e.a,e.b,e.c,e.d,e.e,e.f)):Xz)}var TA,qnt,kYt,$z,DYt=M(()=>{LYt()});function OYt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ic(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ic(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var Gnt,Wnt,zYt=M(()=>{jz();DYt();Gnt=OYt(RYt,"px, ","px)","deg)"),Wnt=OYt(NYt,", ",")",")")});function BYt(e){return((e=Math.exp(e))+1/e)/2}function QNe(e){return((e=Math.exp(e))-1/e)/2}function tDe(e){return((e=Math.exp(2*e))-1)/(e+1)}function jnt(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<JNe)f=Math.log(s/i)/CA,h=function(x){return[r+x*l,n+x*c,i*Math.exp(CA*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+FYt*u)/(2*i*Ynt*p),g=(s*s-i*i-FYt*u)/(2*s*Ynt*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/CA,h=function(x){var b=x*f,S=BYt(_),C=i/(Ynt*p)*(S*tDe(CA*b+_)-QNe(_));return[r+C*l,n+C*c,i*S/BYt(CA*b+_)]}}return h.duration=f*1e3,h}var CA,Ynt,FYt,JNe,HYt=M(()=>{CA=Math.SQRT2,Ynt=2,FYt=4,JNe=1e-12});var AA=M(()=>{jz();PYt();zYt();HYt();AYt()});function lS(){return Pv||(qYt(eDe),Pv=kA.now()+Jz)}function eDe(){Pv=0}function RA(){this._call=this._time=this._next=null}function Qz(e,t,r){var n=new RA;return n.restart(e,t,r),n}function GYt(){lS(),++sS;for(var e=Kz,t;e;)(t=Pv-e._time)>=0&&e._call.call(null,t),e=e._next;--sS}function VYt(){Pv=(Zz=kA.now())+Jz,sS=IA=0;try{GYt()}finally{sS=0,nDe(),Pv=0}}function rDe(){var e=kA.now(),t=e-Zz;t>UYt&&(Jz-=t,Zz=e)}function nDe(){for(var e,t=Kz,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:Kz=r);LA=e,Xnt(n)}function Xnt(e){if(!sS){IA&&(IA=clearTimeout(IA));var t=e-Pv;t>24?(e<1/0&&(IA=setTimeout(VYt,e-kA.now()-Jz)),PA&&(PA=clearInterval(PA))):(PA||(Zz=kA.now(),PA=setInterval(rDe,UYt)),sS=1,qYt(VYt))}}var sS,IA,PA,UYt,Kz,LA,Zz,Pv,Jz,kA,qYt,$nt=M(()=>{sS=0,IA=0,PA=0,UYt=1e3,Zz=0,Pv=0,Jz=0,kA=typeof performance=="object"&&performance.now?performance:Date,qYt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};RA.prototype=Qz.prototype={constructor:RA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?lS():+r)+(t==null?0:+t),!this._next&&LA!==this&&(LA?LA._next=this:Kz=this,LA=this),this._call=e,this._time=r,Xnt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Xnt())}}});function tF(e,t,r){var n=new RA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var WYt=M(()=>{$nt()});var Knt=M(()=>{$nt();WYt()});function Wg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;aDe(e,r,{name:t,index:n,group:i,on:iDe,tween:oDe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:jYt})}function DA(e,t){var r=oo(e,t);if(r.state>jYt)throw new Error("too late; already scheduled");return r}function Qa(e,t){var r=oo(e,t);if(r.state>eF)throw new Error("too late; already running");return r}function oo(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function aDe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=Qz(o,0,r.time);function o(c){r.state=Znt,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==Znt)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===eF)return tF(a);p.state===YYt?(p.state=NA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=NA,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(tF(function(){r.state===eF&&(r.state=YYt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=rF,r.on.call("start",e,e.__data__,r.index,r.group),r.state===rF){for(r.state=eF,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=nF,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===nF&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=NA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var iDe,oDe,jYt,Znt,rF,eF,YYt,nF,NA,ks=M(()=>{mnt();Knt();iDe=vA("start","end","cancel","interrupt"),oDe=[],jYt=0,Znt=1,rF=2,eF=3,YYt=4,nF=5,NA=6});function Iv(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>rF&&n.state<nF,n.state=NA,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Jnt=M(()=>{ks()});function XYt(e){return this.each(function(){Iv(this,e)})}var $Yt=M(()=>{Jnt()});function sDe(e,t){var r,n;return function(){var i=Qa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function lDe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Qa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function KYt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=oo(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?sDe:lDe)(r,e,t))}function cS(e,t,r){var n=e._id;return e.each(function(){var i=Qa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return oo(i,n).value[t]}}var OA=M(()=>{ks()});function iF(e,t){var r;return(typeof t=="number"?Ic:t instanceof Gg?Yz:(r=Gg(t))?(t=r,Yz):Vnt)(e,t)}var Qnt=M(()=>{Dnt();AA()});function cDe(e){return function(){this.removeAttribute(e)}}function uDe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function hDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function fDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function pDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function dDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function ZYt(e,t){var r=fd(e),n=r==="transform"?Wnt:iF;return this.attrTween(e,typeof t=="function"?(r.local?dDe:pDe)(r,n,cS(this,"attr."+e,t)):t==null?(r.local?uDe:cDe)(r):(r.local?fDe:hDe)(r,n,t))}var JYt=M(()=>{AA();Ls();OA();Qnt()});function mDe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function gDe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function _De(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&gDe(e,o)),r}return i._value=t,i}function yDe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&mDe(e,o)),r}return i._value=t,i}function QYt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=fd(e);return this.tween(r,(n.local?_De:yDe)(n,t))}var tjt=M(()=>{Ls()});function vDe(e,t){return function(){DA(this,e).delay=+t.apply(this,arguments)}}function xDe(e,t){return t=+t,function(){DA(this,e).delay=t}}function ejt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?vDe:xDe)(t,e)):oo(this.node(),t).delay}var rjt=M(()=>{ks()});function bDe(e,t){return function(){Qa(this,e).duration=+t.apply(this,arguments)}}function wDe(e,t){return t=+t,function(){Qa(this,e).duration=t}}function njt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?bDe:wDe)(t,e)):oo(this.node(),t).duration}var ijt=M(()=>{ks()});function SDe(e,t){if(typeof t!="function")throw new Error;return function(){Qa(this,e).ease=t}}function ojt(e){var t=this._id;return arguments.length?this.each(SDe(t,e)):oo(this.node(),t).ease}var ajt=M(()=>{ks()});function sjt(e){typeof e!="function"&&(e=bA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new ma(n,this._parents,this._name,this._id)}var ljt=M(()=>{Ls();md()});function cjt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new ma(a,this._parents,this._name,this._id)}var ujt=M(()=>{md()});function MDe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function EDe(e,t,r){var n,i,o=MDe(t)?DA:Qa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function hjt(e,t){var r=this._id;return arguments.length<2?oo(this.node(),r).on.on(e):this.each(EDe(r,e,t))}var fjt=M(()=>{ks()});function TDe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function pjt(){return this.on("end.remove",TDe(this._id))}var djt=M(()=>{});function mjt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Av(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Wg(c[f],t,r,f,c,oo(u,r)));return new ma(o,this._parents,t,r)}var gjt=M(()=>{Ls();md();ks()});function _jt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=xA(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=oo(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Wg(p,t,r,g,f,d);o.push(f),a.push(u)}return new ma(o,a,t,r)}var yjt=M(()=>{Ls();md();ks()});function vjt(){return new CDe(this._groups,this._parents)}var CDe,xjt=M(()=>{Ls();CDe=pd.prototype.constructor});function ADe(e,t){var r,n,i;return function(){var o=qg(this,e),a=(this.style.removeProperty(e),qg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function bjt(e){return function(){this.style.removeProperty(e)}}function PDe(e,t,r){var n,i=r+"",o;return function(){var a=qg(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function IDe(e,t,r){var n,i,o;return function(){var a=qg(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),qg(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function LDe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Qa(this,e),c=l.on,u=l.value[o]==null?s||(s=bjt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function wjt(e,t,r){var n=(e+="")=="transform"?Gnt:iF;return t==null?this.styleTween(e,ADe(e,n)).on("end.style."+e,bjt(e)):typeof t=="function"?this.styleTween(e,IDe(e,n,cS(this,"style."+e,t))).each(LDe(this._id,e)):this.styleTween(e,PDe(e,n,t),r).on("end.style."+e,null)}var Sjt=M(()=>{AA();Ls();ks();OA();Qnt()});function kDe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function RDe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&kDe(e,a,r)),n}return o._value=t,o}function Mjt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,RDe(e,t,r==null?"":r))}var Ejt=M(()=>{});function NDe(e){return function(){this.textContent=e}}function DDe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Tjt(e){return this.tween("text",typeof e=="function"?DDe(cS(this,"text",e)):NDe(e==null?"":e+""))}var Cjt=M(()=>{OA()});function ODe(e){return function(t){this.textContent=e.call(this,t)}}function zDe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&ODe(i)),t}return n._value=e,n}function Ajt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,zDe(e))}var Pjt=M(()=>{});function Ijt(){for(var e=this._name,t=this._id,r=oF(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=oo(l,t);Wg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new ma(n,this._parents,e,r)}var Ljt=M(()=>{md();ks()});function kjt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Qa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var Rjt=M(()=>{ks()});function ma(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function tit(e){return pd().transition(e)}function oF(){return++FDe}var FDe,uS,md=M(()=>{Ls();JYt();tjt();rjt();ijt();ajt();ljt();ujt();fjt();djt();gjt();yjt();xjt();Sjt();Ejt();Cjt();Pjt();Ljt();OA();Rjt();FDe=0;uS=pd.prototype;ma.prototype=tit.prototype={constructor:ma,select:mjt,selectAll:_jt,filter:sjt,merge:cjt,selection:vjt,transition:Ijt,call:uS.call,nodes:uS.nodes,node:uS.node,size:uS.size,empty:uS.empty,each:uS.each,on:hjt,attr:ZYt,attrTween:QYt,style:wjt,styleTween:Mjt,text:Tjt,textTween:Ajt,remove:pjt,tween:KYt,delay:ejt,duration:njt,ease:ojt,end:kjt}});function BDe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return eit.time=lS(),eit;return r}function Njt(e){var t,r;e instanceof ma?(t=e._id,e=e._name):(t=oF(),(r=eit).time=lS(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Wg(l,e,t,c,a,r||BDe(l,t));return new ma(n,this._parents,e,t)}var eit,Djt=M(()=>{md();ks();L_();Knt();eit={time:null,delay:0,duration:250,ease:bs}});var Ojt=M(()=>{Ls();$Yt();Djt();pd.prototype.interrupt=XYt;pd.prototype.transition=Njt});var zjt=M(()=>{md();ks()});var Fjt=M(()=>{Ojt();md();zjt();Jnt()});function zA(e){return function(){return e}}var Bjt=M(()=>{});function rit(e,t,r){this.target=e,this.type=t,this.transform=r}var Hjt=M(()=>{});function If(e,t,r){this.k=e,this.x=t,this.y=r}function aF(e){return e.__zoom||hS}var hS,nit=M(()=>{If.prototype={constructor:If,scale:function(e){return e===1?this:new If(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new If(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};hS=new If(1,0,0);aF.prototype=If.prototype});function sF(){Yr.stopImmediatePropagation()}function fS(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var Vjt=M(()=>{Ls()});function HDe(){return!Yr.button}function VDe(){var e=this,t,r;return e instanceof SVGElement?(e=e.ownerSVGElement||e,t=e.width.baseVal.value,r=e.height.baseVal.value):(t=e.clientWidth,r=e.clientHeight),[[0,0],[t,r]]}function Ujt(){return this.__zoom||hS}function UDe(){return-Yr.deltaY*(Yr.deltaMode?120:1)/500}function qDe(){return"ontouchstart"in this}function GDe(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function qjt(){var e=HDe,t=VDe,r=GDe,n=UDe,i=qDe,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=jnt,c=[],u=vA("start","zoom","end"),h,f,p=500,d=150,g=0;function _(R){R.property("__zoom",Ujt).on("wheel.zoom",k).on("mousedown.zoom",O).on("dblclick.zoom",D).filter(i).on("touchstart.zoom",B).on("touchmove.zoom",I).on("touchend.zoom touchcancel.zoom",L).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}_.transform=function(R,F){var z=R.selection?R.selection():R;z.property("__zoom",Ujt),R!==z?S(R,F):z.interrupt().each(function(){C(this,arguments).start().zoom(null,typeof F=="function"?F.apply(this,arguments):F).end()})},_.scaleBy=function(R,F){_.scaleTo(R,function(){var z=this.__zoom.k,U=typeof F=="function"?F.apply(this,arguments):F;return z*U})},_.scaleTo=function(R,F){_.transform(R,function(){var z=t.apply(this,arguments),U=this.__zoom,W=b(z),Z=U.invert(W),rt=typeof F=="function"?F.apply(this,arguments):F;return r(x(y(U,rt),W,Z),z,a)})},_.translateBy=function(R,F,z){_.transform(R,function(){return r(this.__zoom.translate(typeof F=="function"?F.apply(this,arguments):F,typeof z=="function"?z.apply(this,arguments):z),t.apply(this,arguments),a)})},_.translateTo=function(R,F,z){_.transform(R,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=b(U);return r(hS.translate(Z[0],Z[1]).scale(W.k).translate(typeof F=="function"?-F.apply(this,arguments):-F,typeof z=="function"?-z.apply(this,arguments):-z),U,a)})};function y(R,F){return F=Math.max(o[0],Math.min(o[1],F)),F===R.k?R:new If(F,R.x,R.y)}function x(R,F,z){var U=F[0]-z[0]*R.k,W=F[1]-z[1]*R.k;return U===R.x&&W===R.y?R:new If(R.k,U,W)}function b(R){return[(+R[0][0]+ +R[1][0])/2,(+R[0][1]+ +R[1][1])/2]}function S(R,F,z){R.on("start.zoom",function(){C(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){C(this,arguments).end()}).tween("zoom",function(){var U=this,W=arguments,Z=C(U,W),rt=t.apply(U,W),ot=z||b(rt),st=Math.max(rt[1][0]-rt[0][0],rt[1][1]-rt[0][1]),St=U.__zoom,bt=typeof F=="function"?F.apply(U,W):F,Mt=l(St.invert(ot).concat(st/St.k),bt.invert(ot).concat(st/bt.k));return function(lt){if(lt===1)lt=bt;else{var Kt=Mt(lt),_t=st/Kt[2];lt=new If(_t,ot[0]-Kt[0]*_t,ot[1]-Kt[1]*_t)}Z.zoom(null,lt)}})}function C(R,F){for(var z=0,U=c.length,W;z<U;++z)if((W=c[z]).that===R)return W;return new P(R,F)}function P(R,F){this.that=R,this.args=F,this.index=-1,this.active=0,this.extent=t.apply(R,F)}P.prototype={start:function(){return++this.active===1&&(this.index=c.push(this)-1,this.emit("start")),this},zoom:function(R,F){return this.mouse&&R!=="mouse"&&(this.mouse[1]=F.invert(this.mouse[0])),this.touch0&&R!=="touch"&&(this.touch0[1]=F.invert(this.touch0[0])),this.touch1&&R!=="touch"&&(this.touch1[1]=F.invert(this.touch1[0])),this.that.__zoom=F,this.emit("zoom"),this},end:function(){return--this.active===0&&(c.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(R){Tnt(new rit(_,R,this.that.__zoom),u.apply,u,[R,this.that,this.args])}};function k(){if(!e.apply(this,arguments))return;var R=C(this,arguments),F=this.__zoom,z=Math.max(o[0],Math.min(o[1],F.k*Math.pow(2,n.apply(this,arguments)))),U=iS(this);if(R.wheel)(R.mouse[0][0]!==U[0]||R.mouse[0][1]!==U[1])&&(R.mouse[1]=F.invert(R.mouse[0]=U)),clearTimeout(R.wheel);else{if(F.k===z)return;R.mouse=[U,F.invert(U)],Iv(this),R.start()}fS(),R.wheel=setTimeout(W,d),R.zoom("mouse",r(x(y(F,z),R.mouse[0],R.mouse[1]),R.extent,a));function W(){R.wheel=null,R.end()}}function O(){if(f||!e.apply(this,arguments))return;var R=C(this,arguments),F=dd(Yr.view).on("mousemove.zoom",Z,!0).on("mouseup.zoom",rt,!0),z=iS(this),U=Yr.clientX,W=Yr.clientY;Int(Yr.view),sF(),R.mouse=[z,this.__zoom.invert(z)],Iv(this),R.start();function Z(){if(fS(),!R.moved){var ot=Yr.clientX-U,st=Yr.clientY-W;R.moved=ot*ot+st*st>g}R.zoom("mouse",r(x(R.that.__zoom,R.mouse[0]=iS(R.that),R.mouse[1]),R.extent,a))}function rt(){F.on("mousemove.zoom mouseup.zoom",null),Lnt(Yr.view,R.moved),fS(),R.end()}}function D(){if(!!e.apply(this,arguments)){var R=this.__zoom,F=iS(this),z=R.invert(F),U=R.k*(Yr.shiftKey?.5:2),W=r(x(y(R,U),F,z),t.apply(this,arguments),a);fS(),s>0?dd(this).transition().duration(s).call(S,W,F):dd(this).call(_.transform,W)}}function B(){if(!!e.apply(this,arguments)){var R=C(this,arguments),F=Yr.changedTouches,z,U=F.length,W,Z,rt;for(sF(),W=0;W<U;++W)Z=F[W],rt=Hz(this,F,Z.identifier),rt=[rt,this.__zoom.invert(rt),Z.identifier],R.touch0?R.touch1||(R.touch1=rt):(R.touch0=rt,z=!0);if(h&&(h=clearTimeout(h),!R.touch1)){R.end(),rt=dd(this).on("dblclick.zoom"),rt&&rt.apply(this,arguments);return}z&&(h=setTimeout(function(){h=null},p),Iv(this),R.start())}}function I(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W,Z,rt;for(fS(),h&&(h=clearTimeout(h)),U=0;U<z;++U)W=F[U],Z=Hz(this,F,W.identifier),R.touch0&&R.touch0[2]===W.identifier?R.touch0[0]=Z:R.touch1&&R.touch1[2]===W.identifier&&(R.touch1[0]=Z);if(W=R.that.__zoom,R.touch1){var ot=R.touch0[0],st=R.touch0[1],St=R.touch1[0],bt=R.touch1[1],Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt,lt=(lt=bt[0]-st[0])*lt+(lt=bt[1]-st[1])*lt;W=y(W,Math.sqrt(Mt/lt)),Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2],rt=[(st[0]+bt[0])/2,(st[1]+bt[1])/2]}else if(R.touch0)Z=R.touch0[0],rt=R.touch0[1];else return;R.zoom("touch",r(x(W,Z,rt),R.extent,a))}function L(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W;for(sF(),f&&clearTimeout(f),f=setTimeout(function(){f=null},p),U=0;U<z;++U)W=F[U],R.touch0&&R.touch0[2]===W.identifier?delete R.touch0:R.touch1&&R.touch1[2]===W.identifier&&delete R.touch1;R.touch1&&!R.touch0&&(R.touch0=R.touch1,delete R.touch1),R.touch0?R.touch0[1]=this.__zoom.invert(R.touch0[0]):R.end()}return _.wheelDelta=function(R){return arguments.length?(n=typeof R=="function"?R:zA(+R),_):n},_.filter=function(R){return arguments.length?(e=typeof R=="function"?R:zA(!!R),_):e},_.touchable=function(R){return arguments.length?(i=typeof R=="function"?R:zA(!!R),_):i},_.extent=function(R){return arguments.length?(t=typeof R=="function"?R:zA([[+R[0][0],+R[0][1]],[+R[1][0],+R[1][1]]]),_):t},_.scaleExtent=function(R){return arguments.length?(o[0]=+R[0],o[1]=+R[1],_):[o[0],o[1]]},_.translateExtent=function(R){return arguments.length?(a[0][0]=+R[0][0],a[1][0]=+R[1][0],a[0][1]=+R[0][1],a[1][1]=+R[1][1],_):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},_.constrain=function(R){return arguments.length?(r=R,_):r},_.duration=function(R){return arguments.length?(s=+R,_):s},_.interpolate=function(R){return arguments.length?(l=R,_):l},_.on=function(){var R=u.on.apply(u,arguments);return R===u?_:R},_.clickDistance=function(R){return arguments.length?(g=(R=+R)*R,_):Math.sqrt(g)},_}var Gjt=M(()=>{mnt();cYt();AA();Ls();Fjt();Bjt();Hjt();nit();Vjt()});var Wjt=M(()=>{Gjt();nit()});var Mr={};Zs(Mr,{active:()=>mGt,arc:()=>gFt,area:()=>b7,areaRadial:()=>ket,ascending:()=>_c,axisBottom:()=>ZMt,axisLeft:()=>JMt,axisRight:()=>KMt,axisTop:()=>$Mt,bisect:()=>sR,bisectLeft:()=>sMt,bisectRight:()=>x$,bisector:()=>aR,brush:()=>yCt,brushSelection:()=>mCt,brushX:()=>gCt,brushY:()=>_Ct,chord:()=>UCt,clientPoint:()=>Og,cluster:()=>GLt,color:()=>x2,create:()=>tFt,creator:()=>Dg,cross:()=>cMt,csv:()=>pNt,csvFormat:()=>yPt,csvFormatRows:()=>vPt,csvParse:()=>gPt,csvParseRows:()=>_Pt,cubehelix:()=>uN,curveBasis:()=>OFt,curveBasisClosed:()=>FFt,curveBasisOpen:()=>VFt,curveBundle:()=>GFt,curveCardinal:()=>YFt,curveCardinalClosed:()=>jFt,curveCardinalOpen:()=>XFt,curveCatmullRom:()=>KFt,curveCatmullRomClosed:()=>JFt,curveCatmullRomOpen:()=>eBt,curveLinear:()=>Bg,curveLinearClosed:()=>iBt,curveMonotoneX:()=>hBt,curveMonotoneY:()=>fBt,curveNatural:()=>gBt,curveStep:()=>yBt,curveStepAfter:()=>xBt,curveStepBefore:()=>vBt,customEvent:()=>Xzt,descending:()=>hMt,deviation:()=>cR,dispatch:()=>kAt,drag:()=>hPt,dragDisable:()=>EN,dragEnable:()=>TN,dsvFormat:()=>w2,easeBack:()=>OZ,easeBackIn:()=>JPt,easeBackInOut:()=>OZ,easeBackOut:()=>QPt,easeBounce:()=>S2,easeBounceIn:()=>$Pt,easeBounceInOut:()=>KPt,easeBounceOut:()=>S2,easeCircle:()=>RZ,easeCircleIn:()=>YPt,easeCircleInOut:()=>RZ,easeCircleOut:()=>jPt,easeCubic:()=>AZ,easeCubicIn:()=>kPt,easeCubicInOut:()=>AZ,easeCubicOut:()=>RPt,easeElastic:()=>BZ,easeElasticIn:()=>e6t,easeElasticInOut:()=>r6t,easeElasticOut:()=>BZ,easeExp:()=>kZ,easeExpIn:()=>qPt,easeExpInOut:()=>kZ,easeExpOut:()=>GPt,easeLinear:()=>CPt,easePoly:()=>IZ,easePolyIn:()=>DPt,easePolyInOut:()=>IZ,easePolyOut:()=>OPt,easeQuad:()=>CZ,easeQuadIn:()=>PPt,easeQuadInOut:()=>CZ,easeQuadOut:()=>IPt,easeSin:()=>LZ,easeSinIn:()=>HPt,easeSinInOut:()=>LZ,easeSinOut:()=>VPt,entries:()=>hAt,event:()=>Pu,extent:()=>uR,forceCenter:()=>o6t,forceCollide:()=>F6t,forceLink:()=>j6t,forceManyBody:()=>lIt,forceRadial:()=>uIt,forceSimulation:()=>sIt,forceX:()=>fIt,forceY:()=>dIt,format:()=>rJ,formatDefaultLocale:()=>WN,formatLocale:()=>qN,formatPrefix:()=>nJ,formatSpecifier:()=>ky,geoAlbers:()=>DD,geoAlbersUsa:()=>vLt,geoArea:()=>UIt,geoAzimuthalEqualArea:()=>bLt,geoAzimuthalEqualAreaRaw:()=>zD,geoAzimuthalEquidistant:()=>SLt,geoAzimuthalEquidistantRaw:()=>FD,geoBounds:()=>KIt,geoCentroid:()=>n9t,geoCircle:()=>u9t,geoClipAntimeridian:()=>zT,geoClipCircle:()=>_D,geoClipExtent:()=>R9t,geoClipRectangle:()=>td,geoConicConformal:()=>TLt,geoConicConformalRaw:()=>fQ,geoConicEqualArea:()=>qy,geoConicEqualAreaRaw:()=>cQ,geoConicEquidistant:()=>PLt,geoConicEquidistantRaw:()=>dQ,geoContains:()=>V9t,geoDistance:()=>Hy,geoEquirectangular:()=>ALt,geoEquirectangularRaw:()=>Wy,geoGnomonic:()=>LLt,geoGnomonicRaw:()=>VD,geoGraticule:()=>SD,geoGraticule10:()=>W9t,geoIdentity:()=>RLt,geoInterpolate:()=>j9t,geoLength:()=>bD,geoMercator:()=>ELt,geoMercatorRaw:()=>Gy,geoNaturalEarth1:()=>DLt,geoNaturalEarth1Raw:()=>qD,geoOrthographic:()=>zLt,geoOrthographicRaw:()=>GD,geoPath:()=>fLt,geoProjection:()=>eo,geoProjectionMutator:()=>YT,geoRotation:()=>lD,geoStereographic:()=>BLt,geoStereographicRaw:()=>WD,geoStream:()=>Mo,geoTransform:()=>dLt,geoTransverseMercator:()=>VLt,geoTransverseMercatorRaw:()=>YD,hcl:()=>iZ,hierarchy:()=>jT,histogram:()=>xMt,hsl:()=>ZK,html:()=>oNt,interpolate:()=>Z2,interpolateArray:()=>fO,interpolateBasis:()=>cO,interpolateBasisClosed:()=>hO,interpolateCool:()=>E7t,interpolateCubehelix:()=>q8t,interpolateCubehelixDefault:()=>w7t,interpolateCubehelixLong:()=>G8t,interpolateDate:()=>dO,interpolateHcl:()=>B8t,interpolateHclLong:()=>H8t,interpolateHsl:()=>N8t,interpolateHslLong:()=>D8t,interpolateInferno:()=>I7t,interpolateLab:()=>$Q,interpolateMagma:()=>P7t,interpolateNumber:()=>Ps,interpolateObject:()=>mO,interpolatePlasma:()=>L7t,interpolateRainbow:()=>T7t,interpolateRgb:()=>eC,interpolateRgbBasis:()=>m8t,interpolateRgbBasisClosed:()=>g8t,interpolateRound:()=>_8t,interpolateString:()=>gO,interpolateTransformCss:()=>T8t,interpolateTransformSvg:()=>C8t,interpolateViridis:()=>A7t,interpolateWarm:()=>M7t,interpolateZoom:()=>L8t,interrupt:()=>dz,interval:()=>EVt,isoFormat:()=>gVt,isoParse:()=>_Vt,json:()=>sNt,keys:()=>sAt,lab:()=>lN,line:()=>Rw,lineRadial:()=>Iet,linkHorizontal:()=>CFt,linkRadial:()=>PFt,linkVertical:()=>AFt,local:()=>m7,map:()=>wy,matcher:()=>u7,max:()=>TMt,mean:()=>AMt,median:()=>IMt,merge:()=>kMt,min:()=>mR,mouse:()=>nFt,namespace:()=>Mw,namespaces:()=>EC,nest:()=>rAt,now:()=>Yw,pack:()=>Tkt,packEnclose:()=>$D,packSiblings:()=>wkt,pairs:()=>lMt,partition:()=>Akt,path:()=>K8t,permute:()=>NMt,pie:()=>SFt,pointRadial:()=>pv,polygonArea:()=>Q8t,polygonCentroid:()=>eRt,polygonContains:()=>lRt,polygonHull:()=>aRt,polygonLength:()=>uRt,precisionFixed:()=>AIt,precisionPrefix:()=>IIt,precisionRound:()=>kIt,quadtree:()=>xO,quantile:()=>my,quantize:()=>Y8t,queue:()=>wO,radialArea:()=>ket,radialLine:()=>Iet,randomBates:()=>tNt,randomExponential:()=>rNt,randomIrwinHall:()=>MO,randomLogNormal:()=>JRt,randomNormal:()=>SO,randomUniform:()=>KRt,range:()=>hR,request:()=>J2,rgb:()=>KK,ribbon:()=>KCt,scaleBand:()=>cC,scaleIdentity:()=>qO,scaleImplicit:()=>kO,scaleLinear:()=>UO,scaleLog:()=>WO,scaleOrdinal:()=>nw,scalePoint:()=>YNt,scalePow:()=>_C,scaleQuantile:()=>YO,scaleQuantize:()=>jO,scaleSequential:()=>i7,scaleSqrt:()=>aOt,scaleThreshold:()=>XO,scaleTime:()=>h7t,scaleUtc:()=>f7t,scan:()=>OMt,schemeCategory10:()=>d7t,schemeCategory20:()=>x7t,schemeCategory20b:()=>g7t,schemeCategory20c:()=>y7t,select:()=>d7,selectAll:()=>oFt,selection:()=>Qzt,selector:()=>Ew,selectorAll:()=>c7,set:()=>oAt,shuffle:()=>FMt,stack:()=>wBt,stackOffsetDiverging:()=>TBt,stackOffsetExpand:()=>MBt,stackOffsetNone:()=>Ru,stackOffsetSilhouette:()=>ABt,stackOffsetWiggle:()=>IBt,stackOrderAscending:()=>D7,stackOrderDescending:()=>kBt,stackOrderInsideOut:()=>NBt,stackOrderNone:()=>Nu,stackOrderReverse:()=>OBt,stratify:()=>kkt,style:()=>_et,sum:()=>HMt,symbol:()=>NFt,symbolCircle:()=>RC,symbolCross:()=>S7,symbolDiamond:()=>M7,symbolSquare:()=>T7,symbolStar:()=>E7,symbolTriangle:()=>C7,symbolWye:()=>A7,symbols:()=>RFt,text:()=>cNt,thresholdFreedmanDiaconis:()=>wMt,thresholdScott:()=>MMt,thresholdSturges:()=>pR,tickIncrement:()=>k$,tickStep:()=>fR,ticks:()=>vMt,timeDay:()=>ZBt,timeDays:()=>JBt,timeFormat:()=>wrt,timeFormatDefaultLocale:()=>X7,timeFormatLocale:()=>YC,timeFriday:()=>ort,timeFridays:()=>iHt,timeHour:()=>jBt,timeHours:()=>XBt,timeInterval:()=>Sr,timeMillisecond:()=>Zet,timeMilliseconds:()=>Jet,timeMinute:()=>qBt,timeMinutes:()=>GBt,timeMonday:()=>ert,timeMondays:()=>tHt,timeMonth:()=>lHt,timeMonths:()=>cHt,timeParse:()=>Srt,timeSaturday:()=>art,timeSaturdays:()=>oHt,timeSecond:()=>Qet,timeSeconds:()=>trt,timeSunday:()=>H7,timeSundays:()=>srt,timeThursday:()=>irt,timeThursdays:()=>nHt,timeTuesday:()=>rrt,timeTuesdays:()=>eHt,timeWednesday:()=>nrt,timeWednesdays:()=>rHt,timeWeek:()=>H7,timeWeeks:()=>srt,timeYear:()=>hHt,timeYears:()=>fHt,timeout:()=>SVt,timer:()=>Crt,timerFlush:()=>Art,touch:()=>sFt,touches:()=>cFt,transition:()=>Tz,transpose:()=>gR,tree:()=>Nkt,treemap:()=>Okt,treemapBinary:()=>Fkt,treemapDice:()=>cf,treemapResquarify:()=>Ukt,treemapSlice:()=>Sg,treemapSliceDice:()=>Hkt,treemapSquarify:()=>tO,tsv:()=>mNt,tsvFormat:()=>SPt,tsvFormatRows:()=>MPt,tsvParse:()=>bPt,tsvParseRows:()=>wPt,utcDay:()=>SHt,utcDays:()=>MHt,utcFormat:()=>jC,utcFriday:()=>prt,utcFridays:()=>IHt,utcHour:()=>vHt,utcHours:()=>xHt,utcMillisecond:()=>Zet,utcMilliseconds:()=>Jet,utcMinute:()=>mHt,utcMinutes:()=>gHt,utcMonday:()=>crt,utcMondays:()=>THt,utcMonth:()=>NHt,utcMonths:()=>DHt,utcParse:()=>XC,utcSaturday:()=>drt,utcSaturdays:()=>LHt,utcSecond:()=>Qet,utcSeconds:()=>trt,utcSunday:()=>V7,utcSundays:()=>mrt,utcThursday:()=>frt,utcThursdays:()=>PHt,utcTuesday:()=>urt,utcTuesdays:()=>CHt,utcWednesday:()=>hrt,utcWednesdays:()=>AHt,utcWeek:()=>V7,utcWeeks:()=>mrt,utcYear:()=>zHt,utcYears:()=>FHt,values:()=>cAt,variance:()=>lR,version:()=>iMt,voronoi:()=>DGt,window:()=>Cw,xml:()=>hNt,zip:()=>UMt,zoom:()=>qjt,zoomIdentity:()=>hS,zoomTransform:()=>aF});var Er=M(()=>{oMt();GMt();tEt();xCt();JCt();pAt();PAt();NAt();pPt();TPt();i6t();gIt();NIt();qLt();Gkt();X8t();J8t();fRt();GRt();$Rt();iNt();_Nt();N7t();hFt();FBt();HHt();vVt();CVt();_Gt();zGt();Wjt()});var $jt=H(Xjt=>{"use strict";Object.defineProperty(Xjt,"__esModule",{value:!0});var Yjt=(Er(),Ut(Mr)),Yg=Yjt,jjt=Yjt;function WDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Yg.select(this);for(var i in r)n.attr(i,r[i])})}function YDe(e,t){for(var r in t)e.attr(r,t[r]);return e}function jDe(e){return(typeof e=="function"?WDe:YDe)(this,e)}function XDe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Yg.select(this);for(var o in n)i.style(o,n[o],r)})}function $De(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function KDe(e,t){return(typeof e=="function"?XDe:$De)(this,e,t==null?"":t)}function ZDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Yg.select(this);for(var i in r)n.property(i,r[i])})}function JDe(e,t){for(var r in t)e.property(r,t[r]);return e}function QDe(e){return(typeof e=="function"?ZDe:JDe)(this,e)}function tOe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Yg.select(this).transition(e);for(var i in r)n.attr(i,r[i])})}function eOe(e,t){for(var r in t)e.attr(r,t[r]);return e}function rOe(e){return(typeof e=="function"?tOe:eOe)(this,e)}function nOe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Yg.select(this).transition(e);for(var o in n)i.style(o,n[o],r)})}function iOe(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function oOe(e,t){return(typeof e=="function"?nOe:iOe)(this,e,t==null?"":t)}Yg.selection.prototype.attrs=jDe;Yg.selection.prototype.styles=KDe;Yg.selection.prototype.properties=QDe;jjt.transition.prototype.attrs=rOe;jjt.transition.prototype.styles=oOe});var jg=H(iit=>{"use strict";Object.defineProperty(iit,"__esModule",{value:!0});var Kjt=(Er(),Ut(Mr));function aOe(e){if(e.attrs==null)if(e.nodes==null){var t=[];return e.each(function(){t.push(this)}),Kjt.selectAll(t)}else return Kjt.selectAll(e.nodes());else return e}iit.coerceExternalD3=aOe});var Lf=H(oit=>{"use strict";Object.defineProperty(oit,"__esModule",{value:!0});function sOe(e){return e.reduce(function(t,r){return t[r]=r,t},{})}oit.makeEnum=sOe});var Jjt=H(lF=>{"use strict";Object.defineProperty(lF,"__esModule",{value:!0});var dr=(L_(),Ut(Bvt)),lOe=jg(),cOe=Lf(),Zjt={linear:dr.easeLinear,quad:dr.easeQuad,quadIn:dr.easeQuadIn,quadOut:dr.easeQuadOut,quadInOut:dr.easeQuadInOut,cubic:dr.easeCubic,cubicIn:dr.easeCubicIn,cubicOut:dr.easeCubicOut,cubicInOut:dr.easeCubicInOut,poly:dr.easePoly,polyIn:dr.easePolyIn,polyOut:dr.easePolyOut,polyInOut:dr.easePolyInOut,sin:dr.easeSin,sinIn:dr.easeSinIn,sinOut:dr.easeSinOut,sinInOut:dr.easeSinInOut,exp:dr.easeExp,expIn:dr.easeExpIn,expOut:dr.easeExpOut,expInOut:dr.easeExpInOut,circle:dr.easeCircle,circleIn:dr.easeCircleIn,circleOut:dr.easeCircleOut,circleInOut:dr.easeCircleInOut,bounce:dr.easeBounce,bounceIn:dr.easeBounceIn,bounceOut:dr.easeBounceOut,bounceInOut:dr.easeBounceInOut,back:dr.easeBack,backIn:dr.easeBackIn,backOut:dr.easeBackOut,backInOut:dr.easeBackInOut,elastic:dr.easeElastic,elasticIn:dr.easeElasticIn,elasticOut:dr.easeElasticOut,elasticInOut:dr.easeElasticInOut};lF.EaseName=cOe.makeEnum(["linear","quad","quadIn","quadOut","quadInOut","cubic","cubicIn","cubicOut","cubicInOut","poly","polyIn","polyOut","polyInOut","sin","sinIn","sinOut","sinInOut","exp","expIn","expOut","expInOut","circle","circleIn","circleOut","circleInOut","bounce","bounceIn","bounceOut","bounceInOut","back","backIn","backOut","backInOut","elastic","elasticIn","elasticOut","elasticInOut"]);var uOe=function(){function e(){this._startDelay=e._DEFAULT_START_DELAY_MILLISECONDS,this._stepDuration=e._DEFAULT_STEP_DURATION_MILLISECONDS,this._stepDelay=e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS,this._maxTotalDuration=e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS,this._easingMode=e._DEFAULT_EASING_MODE}return e.prototype.totalTime=function(t){var r=this._getAdjustedIterativeDelay(t);return this.startDelay()+r*Math.max(t-1,0)+this.stepDuration()},e.prototype.animate=function(t,r){var n=this;t=lOe.coerceExternalD3(t);var i=t.size(),o=this._getAdjustedIterativeDelay(i);return t.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(a,s){return n.startDelay()+o*s}).attrs(r)},e.prototype.startDelay=function(t){return t==null?this._startDelay:(this._startDelay=t,this)},e.prototype.stepDuration=function(t){return t==null?Math.min(this._stepDuration,this._maxTotalDuration):(this._stepDuration=t,this)},e.prototype.stepDelay=function(t){return t==null?this._stepDelay:(this._stepDelay=t,this)},e.prototype.maxTotalDuration=function(t){return t==null?this._maxTotalDuration:(this._maxTotalDuration=t,this)},e.prototype.easingMode=function(t){return t==null?this._easingMode:(this._easingMode=t,this)},e.prototype._getEaseFactory=function(){var t=this.easingMode();if(typeof t=="string"){var r=Zjt[t];return r==null?Zjt.linear:r}else return t},e.prototype._getAdjustedIterativeDelay=function(t){var r=this.maxTotalDuration()-this.stepDuration();r=Math.max(r,0);var n=r/Math.max(t-1,1);return Math.min(this.stepDelay(),n)},e._DEFAULT_START_DELAY_MILLISECONDS=0,e._DEFAULT_STEP_DURATION_MILLISECONDS=300,e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15,e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=1/0,e._DEFAULT_EASING_MODE="expOut",e}();lF.Easing=uOe});var Qjt=H(ait=>{"use strict";Object.defineProperty(ait,"__esModule",{value:!0});var hOe=jg(),fOe=function(){function e(){}return e.prototype.totalTime=function(t){return 0},e.prototype.animate=function(t,r){return t=hOe.coerceExternalD3(t),t.attrs(r)},e}();ait.Null=fOe});var kf=H(cF=>{"use strict";Object.defineProperty(cF,"__esModule",{value:!0});var tXt=(de(),Ut(pe));tXt.__exportStar(Jjt(),cF);tXt.__exportStar(Qjt(),cF)});var eXt=H(sit=>{"use strict";Object.defineProperty(sit,"__esModule",{value:!0});var pOe=function(){function e(t){this.cache={},this.compute=t}return e.prototype.get=function(t){return this.cache.hasOwnProperty(t)||(this.cache[t]=this.compute(t)),this.cache[t]},e.prototype.clear=function(){return this.cache={},this},e}();sit.Cache=pOe});var rXt=H(lit=>{"use strict";Object.defineProperty(lit,"__esModule",{value:!0});var dOe=function(){function e(){}return e.arrayEq=function(t,r){if(t==null||r==null)return t===r;if(t.length!==r.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!==r[n])return!1;return!0},e.objEq=function(t,r){if(t==null||r==null)return t===r;var n=Object.keys(t).sort(),i=Object.keys(r).sort(),o=n.map(function(s){return t[s]}),a=i.map(function(s){return r[s]});return e.arrayEq(n,i)&&e.arrayEq(o,a)},e.strictEq=function(t,r){return t===r},e.defaults=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];if(t==null)throw new TypeError("Cannot convert undefined or null to object");var i=Object(t);return r.forEach(function(o){if(o!=null)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(i[a]=o[a])}),i},e}();lit.Methods=dOe});var nXt=H(cit=>{"use strict";Object.defineProperty(cit,"__esModule",{value:!0});var mOe=function(){function e(){}return e.combineWhitespace=function(t){return t.replace(/[ \t]+/g," ")},e.isNotEmptyString=function(t){return t&&t.trim()!==""},e.trimStart=function(t,r){if(!t)return t;var n=t.split(""),i=r?function(o){return o.split(r).some(e.isNotEmptyString)}:e.isNotEmptyString;return n.reduce(function(o,a){return i(o+a)?o+a:o},"")},e.trimEnd=function(t,r){if(!t)return t;var n=t.split("");return n.reverse(),n=e.trimStart(n.join(""),r).split(""),n.reverse(),n.join("")},e}();cit.StringMethods=mOe});var iXt=H(uit=>{"use strict";Object.defineProperty(uit,"__esModule",{value:!0});var gOe=function(){function e(){this.WordDividerRegExp=new RegExp("\\W"),this.WhitespaceRegExp=new RegExp("\\s")}return e.prototype.tokenize=function(t){var r=this;return t.split("").reduce(function(n,i){return n.slice(0,-1).concat(r.shouldCreateNewToken(n[n.length-1],i))},[""])},e.prototype.shouldCreateNewToken=function(t,r){if(!t)return[r];var n=t[t.length-1];return this.WhitespaceRegExp.test(n)&&this.WhitespaceRegExp.test(r)?[t+r]:this.WhitespaceRegExp.test(n)||this.WhitespaceRegExp.test(r)?[t,r]:this.WordDividerRegExp.test(n)?n===r?[t+r]:[t,r]:[t+r]},e}();uit.Tokenizer=gOe});var pS=H(uF=>{"use strict";function hF(e){for(var t in e)uF.hasOwnProperty(t)||(uF[t]=e[t])}Object.defineProperty(uF,"__esModule",{value:!0});hF(eXt());hF(rXt());hF(nXt());hF(iXt())});var aXt=H(hit=>{"use strict";Object.defineProperty(hit,"__esModule",{value:!0});var oXt=pS(),_Oe={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"},fF=function(){function e(t,r,n){this._measurer=t,this._penFactory=r,this._wrapper=n}return e.prototype.measurer=function(t){return this._measurer=t,this},e.prototype.wrapper=function(t){return this._wrapper=t,this},e.prototype.penFactory=function(t){return this._penFactory=t,this},e.prototype.write=function(t,r,n,i,o){if(i===void 0&&(i={}),i=oXt.Methods.defaults({},_Oe,i),e.SupportedRotation.indexOf(i.textRotation)===-1)throw new Error("unsupported rotation - "+i.textRotation+". Supported rotations are "+e.SupportedRotation.join(", "));if(i.textShear!=null&&i.textShear<-80||i.textShear>80)throw new Error("unsupported shear angle - "+i.textShear+". Must be between -80 and 80");var a=Math.abs(Math.abs(i.textRotation)-90)>45,s=a?r:n,l=a?n:r,c=i.textShear,u=c*Math.PI/180,h=this._measurer.measure().height,f=h*Math.tan(u),p=s/Math.cos(u)-Math.abs(f),d=l*Math.cos(u),g=oXt.StringMethods.combineWhitespace(t),_=this._wrapper?this._wrapper.wrap(g,this._measurer,p,d).wrappedText:g,y=_.split(`
`),x=e.XOffsetFactor[i.xAlign]*p*Math.sin(u),b=e.YOffsetFactor[i.yAlign]*(d-y.length*h),S=x-b,C=[0,0],P=i.textRotation+c;switch(i.textRotation){case 90:C=[r+S,0];break;case-90:C=[-S,n];break;case 180:C=[r,n+S];break;default:C=[0,-S];break}var k=this._penFactory.createPen(t,{translate:C,rotate:P},o);this.writeLines(y,k,p,h,f,i.xAlign),k.destroy!=null&&k.destroy()},e.prototype.writeLines=function(t,r,n,i,o,a){t.forEach(function(s,l){var c=o>0?(l+1)*o:l*o;r.write(s,n,a,c,(l+1)*i)})},e}();fF.XOffsetFactor={center:.5,left:0,right:1};fF.YOffsetFactor={bottom:1,center:.5,top:0};fF.SupportedRotation=[-90,0,180,90];hit.Writer=fF});var FA=H(pF=>{"use strict";function yOe(e){for(var t in e)pF.hasOwnProperty(t)||(pF[t]=e[t])}Object.defineProperty(pF,"__esModule",{value:!0});yOe(aXt())});var fit=H(dF=>{"use strict";Object.defineProperty(dF,"__esModule",{value:!0});var BA=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElement(t);return e.addClasses.apply(e,[i].concat(r)),i},e.addClasses=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];r=r.filter(function(i){return i!=null}),t.classList!=null?r.forEach(function(i){t.classList.add(i)}):t.setAttribute("class",r.join(" "))},e.getDimensions=function(t){if(t.getBoundingClientRect)try{var r=t.getBoundingClientRect(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();dF.HtmlUtils=BA;var vOe=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitle=n,this.createRuler=function(){return function(o){var a=BA.append(i.element,"span","text-tmp",i.className);a.textContent=o;var s=BA.getDimensions(a);return i.element.removeChild(a),s}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=BA.append(s,"div","text-block",i.className);return l.style.position="relative",l.style.transform="translate(0, -1em) "+("translate("+a.translate[0]+"px, "+a.translate[1]+"px) ")+("rotate("+a.rotate+"deg)"),l.style.transformOrigin="0 1.2em",i.addTitle&&l.setAttribute("title",o),i.createHtmlLinePen(l)}}return e.prototype.setAddTitle=function(t){this.addTitle=t},e.prototype.createHtmlLinePen=function(t){return{write:function(r,n,i,o,a){var s=BA.append(t,"div","text-line");s.textContent=r,s.style.width=n+"px",s.style.textAlign=i,s.style.position="absolute",s.style.whiteSpace="nowrap",s.style.top=a+"px",s.style.left=o+"px"}}},e}();dF.HtmlContext=vOe});var cXt=H(mF=>{"use strict";Object.defineProperty(mF,"__esModule",{value:!0});var xOe=FA(),sXt=fit(),Xg=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElementNS(e.SVG_NS,t);return sXt.HtmlUtils.addClasses.apply(sXt.HtmlUtils,[i].concat(r)),i},e.getDimensions=function(t){if(t.getBBox)try{var r=t.getBBox(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();Xg.SVG_NS="http://www.w3.org/2000/svg";mF.SvgUtils=Xg;var lXt=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitleElement=n,this.createRuler=function(){var o=i.getTextElements(i.element),a=o.parentElement,s=o.containerElement,l=o.textElement;return function(c){a.appendChild(s),l.textContent=c;var u=Xg.getDimensions(l);return a.removeChild(s),u}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=Xg.append(s,"g","text-container",i.className);i.addTitleElement&&(Xg.append(l,"title").textContent=o,l.setAttribute("title",o));var c=Xg.append(l,"g","text-area");return c.setAttribute("transform","translate("+a.translate[0]+","+a.translate[1]+")"+("rotate("+a.rotate+")")),i.createSvgLinePen(c)}}return e.prototype.setAddTitleElement=function(t){this.addTitleElement=t},e.prototype.createSvgLinePen=function(t){return{write:function(r,n,i,o,a){o+=n*xOe.Writer.XOffsetFactor[i];var s=Xg.append(t,"text","text-line");s.textContent=r,s.setAttribute("text-anchor",e.AnchorMap[i]),s.setAttribute("transform","translate("+o+","+a+")"),s.setAttribute("y","-0.25em")}}},e.prototype.getTextElements=function(t){if(t.tagName==="text"){var r=t.parentElement;return r==null&&(r=t.parentNode),r.removeChild(t),{containerElement:t,parentElement:r,textElement:t}}var n=t.querySelector("text");if(n!=null){var r=n.parentElement;return r==null&&(r=n.parentNode),r.removeChild(n),{containerElement:n,parentElement:r,textElement:n}}var i=Xg.create("text",this.className);return{containerElement:i,parentElement:t,textElement:i}},e}();lXt.AnchorMap={center:"middle",left:"start",right:"end"};mF.SvgContext=lXt});var uXt=H(pit=>{"use strict";Object.defineProperty(pit,"__esModule",{value:!0});var bOe=FA(),wOe="#444",SOe=function(){function e(t,r,n){r===void 0&&(r=10),n===void 0&&(n={});var i=this;this.ctx=t,this.lineHeight=r,this.style=n,this.createRuler=function(){return function(o){i.ctx.font=i.style.font;var a=i.ctx.measureText(o).width;return{width:a,height:i.lineHeight}}},this.createPen=function(o,a,s){return s==null&&(s=i.ctx),s.save(),s.translate(a.translate[0],a.translate[1]),s.rotate(a.rotate*Math.PI/180),i.createCanvasPen(s)},this.style.fill===void 0&&(this.style.fill=wOe)}return e.prototype.createCanvasPen=function(t){var r=this;return{destroy:function(){t.restore()},write:function(n,i,o,a,s){a+=i*bOe.Writer.XOffsetFactor[o],t.textAlign=o,r.style.font!=null&&(t.font=r.style.font),r.style.fill!=null&&(t.fillStyle=r.style.fill,t.fillText(n,a,s)),r.style.stroke!=null&&(t.strokeStyle=r.style.fill,t.strokeText(n,a,s))}}},e}();pit.CanvasContext=SOe});var mit=H(gF=>{"use strict";function dit(e){for(var t in e)gF.hasOwnProperty(t)||(gF[t]=e[t])}Object.defineProperty(gF,"__esModule",{value:!0});dit(cXt());dit(uXt());dit(fit())});var _F=H(git=>{"use strict";Object.defineProperty(git,"__esModule",{value:!0});var hXt=function(){function e(t){t.createRuler!=null?this.ruler=t.createRuler():this.ruler=t}return e.prototype.measure=function(t){return t===void 0&&(t=e.HEIGHT_TEXT),this.ruler(t)},e}();hXt.HEIGHT_TEXT="bdpql";git.AbstractMeasurer=hXt});var _it=H(HA=>{"use strict";var MOe=HA&&HA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(HA,"__esModule",{value:!0});var yF=_F(),EOe=function(e){MOe(t,e);function t(r,n){n===void 0&&(n=!1);var i=e.call(this,r)||this;return i.useGuards=n,i}return t.prototype._addGuards=function(r){return yF.AbstractMeasurer.HEIGHT_TEXT+r+yF.AbstractMeasurer.HEIGHT_TEXT},t.prototype._measureLine=function(r,n){n===void 0&&(n=!1);var i=this.useGuards||n||/^[\t ]$/.test(r),o=i?this._addGuards(r):r,a=e.prototype.measure.call(this,o);return a.width-=i?2*this.getGuardWidth():0,a},t.prototype.measure=function(r){var n=this;if(r===void 0&&(r=yF.AbstractMeasurer.HEIGHT_TEXT),r.trim()==="")return{width:0,height:0};var i=r.trim().split(`
`).map(function(o){return n._measureLine(o)});return{height:i.reduce(function(o,a){return o+a.height},0),width:i.reduce(function(o,a){return Math.max(o,a.width)},0)}},t.prototype.getGuardWidth=function(){return this.guardWidth==null&&(this.guardWidth=e.prototype.measure.call(this).width),this.guardWidth},t}(yF.AbstractMeasurer);HA.Measurer=EOe});var yit=H(VA=>{"use strict";var TOe=VA&&VA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(VA,"__esModule",{value:!0});var COe=_it(),AOe=function(e){TOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype._measureCharacter=function(r){return e.prototype._measureLine.call(this,r)},t.prototype._measureLine=function(r){var n=this,i=r.split("").map(function(o){return n._measureCharacter(o)});return{height:i.reduce(function(o,a){return Math.max(o,a.height)},0),width:i.reduce(function(o,a){return o+a.width},0)}},t}(COe.Measurer);VA.CharacterMeasurer=AOe});var vit=H(UA=>{"use strict";var POe=UA&&UA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(UA,"__esModule",{value:!0});var IOe=pS(),LOe=yit(),kOe=function(e){POe(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.cache=new IOe.Cache(function(o){return i._measureCharacterNotFromCache(o)}),i}return t.prototype._measureCharacterNotFromCache=function(r){return e.prototype._measureCharacter.call(this,r)},t.prototype._measureCharacter=function(r){return this.cache.get(r)},t.prototype.reset=function(){this.cache.clear()},t}(LOe.CharacterMeasurer);UA.CacheCharacterMeasurer=kOe});var fXt=H(qA=>{"use strict";var ROe=qA&&qA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(qA,"__esModule",{value:!0});var NOe=pS(),DOe=_F(),OOe=vit(),zOe=function(e){ROe(t,e);function t(r){var n=e.call(this,r)||this;return n.dimCache=new NOe.Cache(function(i){return n._measureNotFromCache(i)}),n}return t.prototype._measureNotFromCache=function(r){return e.prototype.measure.call(this,r)},t.prototype.measure=function(r){return r===void 0&&(r=DOe.AbstractMeasurer.HEIGHT_TEXT),this.dimCache.get(r)},t.prototype.reset=function(){this.dimCache.clear(),e.prototype.reset.call(this)},t}(OOe.CacheCharacterMeasurer);qA.CacheMeasurer=zOe});var xit=H(vF=>{"use strict";function GA(e){for(var t in e)vF.hasOwnProperty(t)||(vF[t]=e[t])}Object.defineProperty(vF,"__esModule",{value:!0});GA(_F());GA(vit());GA(fXt());GA(yit());GA(_it())});var wit=H(bit=>{"use strict";Object.defineProperty(bit,"__esModule",{value:!0});var WA=pS(),FOe=function(){function e(){this.maxLines(1/0),this.textTrimming("ellipsis"),this.allowBreakingWords(!1),this._tokenizer=new WA.Tokenizer,this._breakingCharacter="-"}return e.prototype.maxLines=function(t){return t==null?this._maxLines:(this._maxLines=t,this)},e.prototype.textTrimming=function(t){if(t==null)return this._textTrimming;if(t!=="ellipsis"&&t!=="none")throw new Error(t+" - unsupported text trimming option.");return this._textTrimming=t,this},e.prototype.allowBreakingWords=function(t){return t==null?this._allowBreakingWords:(this._allowBreakingWords=t,this)},e.prototype.wrap=function(t,r,n,i){var o=this;i===void 0&&(i=1/0);var a={noBrokeWords:0,noLines:0,originalText:t,truncatedText:"",wrappedText:""},s={availableLines:Math.min(Math.floor(i/r.measure().height),this._maxLines),availableWidth:n,canFitText:!0,currentLine:"",wrapping:a},l=t.split(`
`);return l.reduce(function(c,u,h){return o.breakLineToFitWidth(c,u,h!==l.length-1,r)},s).wrapping},e.prototype.breakLineToFitWidth=function(t,r,n,i){var o=this;!t.canFitText&&t.wrapping.truncatedText!==""&&(t.wrapping.truncatedText+=`
`);var a=this._tokenizer.tokenize(r);t=a.reduce(function(l,c){return o.wrapNextToken(c,l,i)},t);var s=WA.StringMethods.trimEnd(t.currentLine);return t.wrapping.noLines+=+(s!==""),t.wrapping.noLines===t.availableLines&&this._textTrimming!=="none"&&n?t.canFitText=!1:t.wrapping.wrappedText+=s,t.currentLine=`
`,t},e.prototype.canFitToken=function(t,r,n){var i=this,o=t.split("").map(function(a,s){return s!==t.length-1?a+i._breakingCharacter:a});return n.measure(t).width<=r||o.every(function(a){return n.measure(a).width<=r})},e.prototype.addEllipsis=function(t,r,n){if(this._textTrimming==="none")return{remainingToken:"",wrappedToken:t};var i=t.substring(0).trim(),o=n.measure(i).width,a=n.measure("...").width,s=t.length>0&&t[0]===`
`?`
`:"";if(r<=a){var l=a/3,c=Math.floor(r/l);return{remainingToken:t,wrappedToken:s+"...".substr(0,c)}}for(;o+a>r;)i=WA.StringMethods.trimEnd(i.substr(0,i.length-1)),o=n.measure(i).width;return{remainingToken:WA.StringMethods.trimEnd(t.substring(i.length),"-").trim(),wrappedToken:s+i+"..."}},e.prototype.wrapNextToken=function(t,r,n){if(!r.canFitText||r.availableLines===r.wrapping.noLines||!this.canFitToken(t,r.availableWidth,n))return this.finishWrapping(t,r,n);for(var i=t;i;){var o=this.breakTokenToFitInWidth(i,r.currentLine,r.availableWidth,n);if(r.currentLine=o.line,i=o.remainingToken,i!=null)if(r.wrapping.noBrokeWords+=+o.breakWord,++r.wrapping.noLines,r.availableLines===r.wrapping.noLines){var a=this.addEllipsis(r.currentLine,r.availableWidth,n);return r.wrapping.wrappedText+=a.wrappedToken,r.wrapping.truncatedText+=a.remainingToken+i,r.currentLine=`
`,r}else r.wrapping.wrappedText+=WA.StringMethods.trimEnd(r.currentLine),r.currentLine=`
`}return r},e.prototype.finishWrapping=function(t,r,n){if(r.canFitText&&r.availableLines!==r.wrapping.noLines&&this._textTrimming!=="none"){var i=this.addEllipsis(r.currentLine+t,r.availableWidth,n);r.wrapping.wrappedText+=i.wrappedToken,r.wrapping.truncatedText+=i.remainingToken,r.wrapping.noBrokeWords+=+(i.remainingToken.length<t.length),r.wrapping.noLines+=+(i.wrappedToken.length>0),r.currentLine=""}else r.wrapping.truncatedText+=t;return r.canFitText=!1,r},e.prototype.breakTokenToFitInWidth=function(t,r,n,i,o){if(o===void 0&&(o=this._breakingCharacter),i.measure(r+t).width<=n)return{breakWord:!1,line:r+t,remainingToken:null};if(t.trim()==="")return{breakWord:!1,line:r,remainingToken:""};if(!this._allowBreakingWords&&r.trim()!=="")return{breakWord:!1,line:r,remainingToken:t};for(var a=0;a<t.length&&i.measure(r+t.substring(0,a+1)+o).width<=n;)++a;var s="";return a>0&&(s=o),{breakWord:a>0,line:r+t.substring(0,a)+s,remainingToken:t.substring(a)}},e}();bit.Wrapper=FOe});var dXt=H(YA=>{"use strict";var BOe=YA&&YA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(YA,"__esModule",{value:!0});var HOe=wit(),pXt=function(e){BOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.wrap=function(r,n,i,o){var a=this;o===void 0&&(o=1/0);var s=r.split(`
`);if(s.length>1)throw new Error("SingleLineWrapper is designed to work only on single line");var l=function(g){return e.prototype.wrap.call(a,r,n,g,o)},c=l(i);if(c.noLines<2)return c;for(var u=0,h=i,f=0;f<t.NO_WRAP_ITERATIONS&&h>u;++f){var p=(h+u)/2,d=l(p);this.areSameResults(c,d)?(h=p,c=d):u=p}return c},t.prototype.areSameResults=function(r,n){return r.noLines===n.noLines&&r.truncatedText===n.truncatedText},t}(HOe.Wrapper);pXt.NO_WRAP_ITERATIONS=5;YA.SingleLineWrapper=pXt});var Sit=H(xF=>{"use strict";function mXt(e){for(var t in e)xF.hasOwnProperty(t)||(xF[t]=e[t])}Object.defineProperty(xF,"__esModule",{value:!0});mXt(dXt());mXt(wit())});var gXt=H(Eit=>{"use strict";Object.defineProperty(Eit,"__esModule",{value:!0});var Mit=mit(),VOe=xit(),UOe=Sit(),qOe=FA(),GOe=function(){function e(t){this.context=t,this.measurer=new VOe.CacheMeasurer(this.context),this.wrapper=new UOe.Wrapper,this.writer=new qOe.Writer(this.measurer,this.context,this.wrapper)}return e.svg=function(t,r,n){return new e(new Mit.SvgContext(t,r,n))},e.canvas=function(t,r,n){return new e(new Mit.CanvasContext(t,r,n))},e.html=function(t,r,n){return new e(new Mit.HtmlContext(t,r,n))},e.prototype.write=function(t,r,n,i,o){this.writer.write(t,r,n,i,o)},e.prototype.clearMeasurerCache=function(){this.measurer.reset()},e}();Eit.Typesetter=GOe});var yl=H(bF=>{"use strict";function dS(e){for(var t in e)bF.hasOwnProperty(t)||(bF[t]=e[t])}Object.defineProperty(bF,"__esModule",{value:!0});dS(mit());dS(xit());dS(gXt());dS(pS());dS(Sit());dS(FA())});var _Xt=H(mS=>{"use strict";Object.defineProperty(mS,"__esModule",{value:!0});var WOe=(Er(),Ut(Mr)),YOe=window.Array;function jOe(e,t){if(e.length!==t.length)throw new Error("attempted to add arrays of unequal length");return e.map(function(r,n){return e[n]+t[n]})}mS.add=jOe;function XOe(e){var t=WOe.set(),r=[];return e.forEach(function(n){t.has(String(n))||(t.add(String(n)),r.push(n))}),r}mS.uniq=XOe;function $Oe(e){return YOe.prototype.concat.apply([],e)}mS.flatten=$Oe;function KOe(e,t){for(var r=[],n=0;n<t;n++)r[n]=typeof e=="function"?e(n):e;return r}mS.createFilledArray=KOe});var xXt=H(jA=>{"use strict";Object.defineProperty(jA,"__esModule",{value:!0});var vXt=(Er(),Ut(Mr)),ZOe=window.Math;function JOe(e,t){var r=yXt(e)+.05,n=yXt(t)+.05;return r>n?r/n:n/r}jA.contrast=JOe;function QOe(e,t){var r=vXt.color(e).brighter(t);return r.rgb().toString()}jA.lightenColor=QOe;function t7e(e,t){e.classed(t,!0);var r=e.style("background-color");if(r==="transparent")return null;var n=/\((.+)\)/.exec(r);if(!n)return null;var i=n[1].split(",").map(function(a){var s=+a,l=s.toString(16);return s<16?"0"+l:l});if(i.length===4&&i[3]==="00")return null;var o="#"+i.join("");return e.classed(t,!1),o}jA.colorTest=t7e;function yXt(e){var t=vXt.rgb(e),r=function(a){return a=a/255,a<=.03928?a/12.92:ZOe.pow((a+.055)/1.055,2.4)},n=r(t.r),i=r(t.g),o=r(t.b);return .2126*n+.7152*i+.0722*o}});var Cit=H(ao=>{"use strict";Object.defineProperty(ao,"__esModule",{value:!0});var Tit=(Er(),Ut(Mr)),ga=window.Math;function e7e(e,t){for(var r=t;r!=null&&r!==e;)r=r.parentNode;return r===e}ao.contains=e7e;function wXt(e){var t;try{t=e.node().getBBox()}catch(r){t={x:0,y:0,width:0,height:0}}return t}ao.elementBBox=wXt;function r7e(e){if(e instanceof SVGElement)return wXt(Tit.select(e));if(e instanceof HTMLElement){var t=e.getBoundingClientRect();return{x:t.left,y:t.top,width:t.width,height:t.height}}else return{x:0,y:0,width:0,height:0}}ao.entityBounds=r7e;ao.SCREEN_REFRESH_RATE_MILLISECONDS=1e3/60;function n7e(e){window.requestAnimationFrame!=null?window.requestAnimationFrame(e):setTimeout(e,ao.SCREEN_REFRESH_RATE_MILLISECONDS)}ao.requestAnimationFramePolyfill=n7e;function i7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return Rf(r,"width")+Rf(r,"padding-left")+Rf(r,"padding-right")+Rf(r,"border-left-width")+Rf(r,"border-right-width")}ao.elementWidth=i7e;function o7e(e){var t=e instanceof Tit.selection?e.node():e,r=window.getComputedStyle(t);return Rf(r,"height")+Rf(r,"padding-top")+Rf(r,"padding-bottom")+Rf(r,"border-top-width")+Rf(r,"border-bottom-width")}ao.elementHeight=o7e;var Lc="\\s",XA="(?:[-+]?[0-9]*\\.?[0-9]+)",SXt="(?:(?:"+Lc+"+,?"+Lc+"*)|(?:,"+Lc+"*))",a7e=new RegExp("translate"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)"),s7e=new RegExp("rotate"+Lc+"*\\("+Lc+"*("+XA+")"+Lc+"*\\)"),l7e=new RegExp("scale"+Lc+"*\\("+Lc+"*("+XA+")(?:"+SXt+"("+XA+"))?"+Lc+"*\\)");function c7e(e){var t=a7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2],i=n===void 0?0:n;return[+r,+i]}else return[0,0]}ao.getTranslateValues=c7e;function u7e(e){var t=s7e.exec(e.attr("transform"));if(t!=null){var r=t[1];return+r}else return 0}ao.getRotate=u7e;function h7e(e){var t=l7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2];return[+r,n==null?+r:+n]}else return[0,0]}ao.getScaleValues=h7e;function f7e(e,t){return!(ga.floor(e.right)<=ga.ceil(t.left)||ga.ceil(e.left)>=ga.floor(t.right)||ga.floor(e.bottom)<=ga.ceil(t.top)||ga.ceil(e.top)>=ga.floor(t.bottom))}ao.clientRectsOverlap=f7e;function p7e(e,t){return{left:e.left-t,top:e.top-t,right:e.right+t,bottom:e.bottom+t,width:e.width+t*2,height:e.height+t*2}}ao.expandRect=p7e;function d7e(e,t){return ga.floor(t.left)<=ga.ceil(e.left)&&ga.floor(t.top)<=ga.ceil(e.top)&&ga.floor(e.right)<=ga.ceil(t.right)&&ga.floor(e.bottom)<=ga.ceil(t.bottom)}ao.clientRectInside=d7e;function m7e(e,t,r,n){n===void 0&&(n=.5);var i=bXt(e),o=bXt(t);return r.x+r.width>=i.min-n&&r.x<=i.max+n&&r.y+r.height>=o.min-n&&r.y<=o.max+n}ao.intersectsBBox=m7e;function bXt(e){if(typeof e=="number"){var t=e;return{min:t,max:t}}var r=e;if(r instanceof Object&&"min"in r&&"max"in r)return r;throw new Error("input '"+e+"' can't be parsed as an Range")}function Rf(e,t){var r=e.getPropertyValue(t),n=parseFloat(r);return n||0}function g7e(e){for(var t=[];e&&e instanceof HTMLElement;)t.push(e),e=e.parentElement;return t}ao.getHtmlElementAncestors=g7e;function _7e(e){var t=window.getComputedStyle(e,null),r=t.getPropertyValue("-webkit-transform")||t.getPropertyValue("-moz-transform")||t.getPropertyValue("-ms-transform")||t.getPropertyValue("-o-transform")||t.getPropertyValue("transform");return x7e(r)}ao.getElementTransform=_7e;var y7e=/^matrix\(([^)]+)\)$/,v7e=/[, ]+/;function x7e(e){if(e==null||e==="none")return null;var t=e.match(y7e);if(t==null||t.length<2)return null;var r=t[1].split(v7e).map(function(n){return parseFloat(n)});return r.length!=6?null:r}});var Ait=H(so=>{"use strict";Object.defineProperty(so,"__esModule",{value:!0});var SF=(Er(),Ut(Mr)),MXt=Cit(),gd=window.Math,b7e=[1,0,0,1,0,0];function w7e(e,t,r){return gd.min(t,r)<=e&&e<=gd.max(t,r)}so.inRange=w7e;function S7e(e,t,r){return gd.min(gd.max(t,e),r)}so.clamp=S7e;function M7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.max(e):SF.max(e,n);return o!==void 0?o:i}so.max=M7e;function E7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?SF.min(e):SF.min(e,n);return o!==void 0?o:i}so.min=E7e;function T7e(e){return e!==e}so.isNaN=T7e;function C7e(e){return typeof e=="number"&&e-e<1}so.isValidNumber=C7e;function A7e(e,t,r){if(r===void 0&&(r=1),r===0)throw new Error("step cannot be 0");for(var n=gd.max(gd.ceil((t-e)/r),0),i=[],o=0;o<n;++o)i[o]=e+r*o;return i}so.range=A7e;function P7e(e,t){return gd.pow(t.y-e.y,2)+gd.pow(t.x-e.x,2)}so.distanceSquared=P7e;function I7e(e){return e/360*gd.PI*2}so.degreesToRadians=I7e;function L7e(e,t){return t.topLeft.x<=e.x&&t.bottomRight.x>=e.x&&t.topLeft.y<=e.y&&t.bottomRight.y>=e.y}so.within=L7e;function k7e(e,t,r,n,i,o,a,s){return e<=i+a&&i<=e+r&&t<=o+s&&o<=t+n}so.boundsIntersects=k7e;function R7e(e){for(var t=MXt.getHtmlElementAncestors(e),r=b7e,n=null,i=0,o=t;i<o.length;i++){var a=o[i],s=MXt.getElementTransform(a);if(s!=null){var l=a.clientWidth/2,c=a.clientHeight/2;r=wF(r,[l,c]),r=EXt(r,TXt(s)),r=wF(r,[-l,-c])}var u=a.scrollLeft,h=a.scrollTop;(n===null||a===n)&&(u-=a.offsetLeft+a.clientLeft,h-=a.offsetTop+a.clientTop,n=a.offsetParent),r=wF(r,[u,h])}return r}so.getCumulativeTransform=R7e;function EXt(e,t){return[e[0]*t[0]+e[2]*t[1],e[1]*t[0]+e[3]*t[1],e[0]*t[2]+e[2]*t[3],e[1]*t[2]+e[3]*t[3],e[0]*t[4]+e[2]*t[5]+e[4],e[1]*t[4]+e[3]*t[5]+e[5]]}so.multiplyMatrix=EXt;function N7e(e,t){return[t[0],t[1],t[2],t[3],t[4]+e[0],t[5]+e[1]]}so.premultiplyTranslate=N7e;function wF(e,t){return[e[0],e[1],e[2],e[3],e[0]*t[0]+e[2]*t[1]+e[4],e[1]*t[0]+e[3]*t[1]+e[5]]}so.multiplyTranslate=wF;function TXt(e){var t=e[0]*e[3]-e[1]*e[2];if(t===0)throw new Error("singular matrix");var r=1/t;return[r*e[3],r*-e[1],r*-e[2],r*e[0],r*(-e[3]*e[4]+e[2]*e[5]),r*(e[1]*e[4]+-e[0]*e[5])]}so.invertMatrix=TXt;function D7e(e,t){return{x:e[0]*t.x+e[2]*t.y+e[4],y:e[1]*t.x+e[3]*t.y+e[5]}}so.applyTransform=D7e});var CXt=H(MF=>{"use strict";Object.defineProperty(MF,"__esModule",{value:!0});var O7e=function(){function e(){}return e.prototype.split=function(t,r){for(var n=Math.ceil(t.length/2),i=0;i<n;i++)r[0].insert(t[i]);for(var i=n;i<t.length;i++)r[1].insert(t[i])},e}();MF.SplitStrategyTrivial=O7e;var z7e=function(){function e(){}return e.prototype.split=function(t,r){for(t=t.slice(),this.chooseFirstSplit(t,r);t.length>0;)this.addNext(t,r)},e.prototype.chooseFirstSplit=function(t,r){for(var n=0,i=0,o=t.length-1,a=t.length-1,s=1;s<t.length-1;s++){var l=t[s];l.bounds.xl>t[o].bounds.xl?o=s:l.bounds.xh<t[n].bounds.xh&&(n=s),l.bounds.yl>t[a].bounds.yl?a=s:l.bounds.yh<t[i].bounds.yh&&(i=s)}var c=Math.abs(t[n].bounds.xh-t[o].bounds.xl),u=Math.abs(t[i].bounds.yh-t[a].bounds.yl),h=c>u?[n,o]:[i,a],f=h[0],p=h[1];f===p&&(f=0,p=t.length-1),r[0].insert(t.splice(Math.max(f,p),1)[0]),r[1].insert(t.splice(Math.min(f,p),1)[0])},e.prototype.addNext=function(t,r){for(var n=null,i=null,o=null,a=0;a<t.length;a++){var s=t[a],l=r[0].unionAreaDifference(s.bounds),c=r[1].unionAreaDifference(s.bounds);(l<i||n==null)&&(n=a,i=l,o=r[0]),c<i&&(n=a,i=c,o=r[1])}o.insert(t.splice(n,1)[0])},e}();MF.SplitStrategyLinear=z7e});var Iit=H(_d=>{"use strict";Object.defineProperty(_d,"__esModule",{value:!0});var F7e=CXt(),B7e=5,H7e=new F7e.SplitStrategyLinear,Nf;(function(e){e[e.PASS=0]="PASS",e[e.FAIL=1]="FAIL",e[e.PASS_AND_OVERWRITE=2]="PASS_AND_OVERWRITE"})(Nf=_d.QueryPredicateResult||(_d.QueryPredicateResult={}));function EF(e,t,r){var n=1/0,i=1/0,o=1/0;return function(a){var s=t(a.bounds,e),l=r(a.bounds,e);return a.value!=null?s<n?(n=s,i=s,o=l,Nf.PASS_AND_OVERWRITE):s===n?Nf.PASS:Nf.FAIL:s>o?Nf.FAIL:(i=Math.min(s,i),o=Math.max(l,o),Nf.PASS)}}_d.createMinimizingNodePredicate=EF;function Pit(e,t){return function(r,n){return t(n.bounds,e)-t(r.bounds,e)}}_d.createNodeSort=Pit;var V7e=function(){function e(t,r){t===void 0&&(t=B7e),r===void 0&&(r=H7e),this.maxNodeChildren=t,this.splitStrategy=r,this.root=new TF(!0),this.size=0}return e.prototype.getRoot=function(){return this.root},e.prototype.clear=function(){this.root=new TF(!0),this.size=0},e.prototype.insert=function(t,r){for(var n=this.root;!n.leaf;)n=n.subtree(t);var i=TF.valueNode(t,r);for(n.insert(i),this.size+=1;n.overflow(this.maxNodeChildren);)n=n.split(this.splitStrategy),n.parent==null&&(this.root=n);return i},e.prototype.locate=function(t){return this.query(function(r){return r.contains(t)})},e.prototype.locateNearest=function(t){var r=EF(t,ts.distanceSquaredToNearEdge,ts.distanceSquaredToFarEdge),n=this.queryNodes(r);return n.map(function(i){return i.value})},e.prototype.locateNearestX=function(t){var r=EF(t,ts.absoluteDistanceToNearEdgeX,ts.absoluteDistanceToFarEdgeX),n=this.queryNodes(r);return n.sort(Pit(t,ts.absoluteDistanceToNearEdgeY)),n.map(function(i){return i.value})},e.prototype.locateNearestY=function(t){var r=EF(t,ts.absoluteDistanceToNearEdgeY,ts.absoluteDistanceToFarEdgeY),n=this.queryNodes(r);return n.sort(Pit(t,ts.absoluteDistanceToNearEdgeX)),n.map(function(i){return i.value})},e.prototype.intersect=function(t){return this.query(function(r){return ts.isBoundsOverlapBounds(r,t)})},e.prototype.intersectX=function(t){return this.query(function(r){return ts.isBoundsOverlapX(r,t)})},e.prototype.intersectY=function(t){return this.query(function(r){return ts.isBoundsOverlapY(r,t)})},e.prototype.query=function(t){var r=[];if(this.root.bounds!=null&&!t(this.root.bounds))return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o];t(a.bounds)&&(i.leaf?r.push(a.value):n.push(a))}return r},e.prototype.queryNodes=function(t){var r=[];if(this.root.bounds!=null&&t(this.root)===Nf.FAIL)return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o],s=t(a);s===Nf.PASS_AND_OVERWRITE&&(r=[]),(s===Nf.PASS||s===Nf.PASS_AND_OVERWRITE)&&(i.leaf?r.push(a):n.push(a))}return r},e}();_d.RTree=V7e;var TF=function(){function e(t){this.leaf=t,this.bounds=null,this.entries=[],this.parent=null,this.value=null}return e.valueNode=function(t,r){var n=new e(!0);return n.bounds=t,n.value=r,n},e.prototype.overflow=function(t){return this.entries.length>t},e.prototype.insert=function(t){this.entries.push(t),t.parent=this;for(var r=this;r!=null;)r.bounds=ts.unionAll([r.bounds,t.bounds]),r=r.parent;return this},e.prototype.remove=function(t){var r=this.entries.indexOf(t);if(r>=0){this.entries.splice(r,1);for(var n=this;n!=null;)n.bounds=ts.unionAll(n.entries.map(function(i){return i.bounds})),n=n.parent}return this},e.prototype.subtree=function(t){for(var r=1/0,n=null,i=0;i<this.entries.length;i++){var o=this.entries[i],a=o.unionAreaDifference(t);(a<r||a===r&&n!=null&&o.entries.length<n.entries.length)&&(n=o)}return n},e.prototype.split=function(t){this.parent!=null&&this.parent.remove(this);var r=[new e(this.leaf),new e(this.leaf)];t.split(this.entries,r);var n=this.parent!=null?this.parent:new e(!1);return n.insert(r[0]),n.insert(r[1]),n.leaf=!1,n},e.prototype.unionAreaDifference=function(t){return Math.abs(ts.union(this.bounds,t).area()-this.bounds.area())},e.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(t){return t.maxDepth()}).reduce(function(t,r){return Math.max(t,r)})},e}();_d.RTreeNode=TF;var ts=function(){function e(t,r,n,i){this.xl=t,this.yl=r,this.xh=n,this.yh=i,this.width=this.xh-this.xl,this.height=this.yh-this.yl}return e.xywh=function(t,r,n,i){return new e(t,r,t+n,r+i)},e.entityBounds=function(t){return new e(t.x,t.y,t.x+t.width,t.y+t.height)},e.bounds=function(t){return e.pointPair(t.topLeft,t.bottomRight)},e.pointPair=function(t,r){return new e(Math.min(t.x,r.x),Math.min(t.y,r.y),Math.max(t.x,r.x),Math.max(t.y,r.y))},e.points=function(t){if(t.length<2)throw new Error("need at least 2 points to create bounds");var r=t.map(function(i){return i.x}),n=t.map(function(i){return i.y});return new e(r.reduce(function(i,o){return Math.min(i,o)}),n.reduce(function(i,o){return Math.min(i,o)}),r.reduce(function(i,o){return Math.max(i,o)}),n.reduce(function(i,o){return Math.max(i,o)}))},e.union=function(t,r){return new e(Math.min(t.xl,r.xl),Math.min(t.yl,r.yl),Math.max(t.xh,r.xh),Math.max(t.yh,r.yh))},e.unionAll=function(t){return t=t.filter(function(r){return r!=null}),t.length===0?null:t.reduce(function(r,n){return e.union(r,n)})},e.isBoundsOverlapBounds=function(t,r){return e.isBoundsOverlapX(t,r)&&e.isBoundsOverlapY(t,r)},e.isBoundsOverlapX=function(t,r){return!(t.xh<r.xl)&&!(t.xl>r.xh)},e.isBoundsOverlapY=function(t,r){return!(t.yh<r.yl)&&!(t.yl>r.yh)},e.absoluteDistanceToNearEdgeX=function(t,r){var n=t.width/2,i=t.xl+n;return Math.max(Math.abs(r.x-i)-n,0)},e.absoluteDistanceToNearEdgeY=function(t,r){var n=t.height/2,i=t.yl+n;return Math.max(Math.abs(r.y-i)-n,0)},e.absoluteDistanceToFarEdgeX=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r);return n===0?0:n+t.width},e.absoluteDistanceToFarEdgeY=function(t,r){var n=e.absoluteDistanceToNearEdgeY(t,r);return n===0?0:n+t.height},e.distanceSquaredToNearEdge=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r),i=e.absoluteDistanceToNearEdgeY(t,r);return n*n+i*i},e.distanceSquaredToFarEdge=function(t,r){var n=e.absoluteDistanceToFarEdgeX(t,r),i=e.absoluteDistanceToFarEdgeY(t,r);return n*n+i*i},e.prototype.area=function(){return this.areaCached==null&&(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl)),this.areaCached},e.prototype.contains=function(t){return this.xl<=t.x&&this.xh>=t.x&&this.yl<=t.y&&this.yh>=t.y},e}();_d.RTreeBounds=ts});var IXt=H(yd=>{"use strict";Object.defineProperty(yd,"__esModule",{value:!0});var AXt=(Er(),Ut(Mr)),U7e=Oe(),$g=Fe(),q7e=Lf();yd.IStackingOrder=q7e.makeEnum(["topdown","bottomup"]);var PXt=window.Math;function G7e(e,t,r,n){n===void 0&&(n="bottomup");var i=AXt.map(),o=AXt.map(),a=new $g.Map;n==="topdown"&&(e=e.slice(),e.reverse());for(var s=0,l=e;s<l.length;s++){for(var c=l[s],u=new $g.Map,h=c.data(),f=h.length,p=0;p<f;p++){var d=h[p],g=t(d,p,c),_=yd.normalizeKey(g),y=+r(d,p,c),x=void 0,b=y>=0?i:o;b.has(_)?(x=b.get(_),b.set(_,x+y)):(x=0,b.set(_,y)),u.set(_,{offset:x,value:y,axisValue:g,originalDatum:d,originalDataset:c,originalIndex:p})}a.set(c,u)}return a}yd.stack=G7e;function W7e(e){var t=new $g.Map,r=new $g.Map;return e.forEach(function(n){n.forEach(function(i,o){var a=i.offset+i.value,s=$g.Math.max([a,i.offset],i.offset),l=$g.Math.min([a,i.offset],i.offset),c=i.axisValue;t.has(o)?t.get(o).extent<s&&t.set(o,{extent:s,axisValue:c,stackedDatum:i}):t.set(o,{extent:s,axisValue:c,stackedDatum:i}),r.has(o)?r.get(o).extent>l&&r.set(o,{extent:l,axisValue:c,stackedDatum:i}):r.set(o,{extent:l,axisValue:c,stackedDatum:i})})}),{maximumExtents:t,minimumExtents:r}}yd.stackedExtents=W7e;function Y7e(e,t,r){var n=[];e.forEach(function(a,s){for(var l=s.data(),c=l.length,u=0;u<c;u++){var h=l[u];if(!(r!=null&&!r(h,u,s))){var f=a.get(yd.normalizeKey(t(h,u,s)));n.push(f.value+f.offset)}}});var i=$g.Math.max(n,0),o=$g.Math.min(n,0);return[PXt.min(o,0),PXt.max(0,i)]}yd.stackedExtent=Y7e;yd.normalizeKey=U7e.memoize(function(e){return String(e)})});var $A=H(CF=>{"use strict";Object.defineProperty(CF,"__esModule",{value:!0});CF.SHOW_WARNINGS=!0;CF.ADD_TITLE_ELEMENTS=!0});var AF=H(gS=>{"use strict";Object.defineProperty(gS,"__esModule",{value:!0});var j7e=$A();function LXt(e){!j7e.SHOW_WARNINGS||console.warn(e)}gS.warn=LXt;function kXt(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];return t===0?(e(r),-1):window.setTimeout(e,t,r)}gS.setTimeout=kXt;function X7e(e,t,r){var n=null,i=[],o=function(){t.apply(r,i)};return function(){i=Array.prototype.slice.call(arguments),clearTimeout(n),n=kXt(o,e)}}gS.debounce=X7e;function $7e(e,t,r){r===void 0&&(r=""),LXt("Method "+e+" has been deprecated in version "+t+". Please refer to the release notes. "+r)}gS.deprecated=$7e});var RXt=H(Lit=>{"use strict";Object.defineProperty(Lit,"__esModule",{value:!0});var K7e=function(){function e(t,r,n){this.entryIndex=t,this.exitIndex=t,this.minIndex=t,this.maxIndex=t,this.bucketValue=r,this.minValue=n,this.maxValue=n}return e.prototype.isInBucket=function(t){return t==this.bucketValue},e.prototype.addToBucket=function(t,r){t<this.minValue&&(this.minValue=t,this.minIndex=r),t>this.maxValue&&(this.maxValue=t,this.maxIndex=r),this.exitIndex=r},e.prototype.getUniqueIndices=function(){var t=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return t.filter(function(r,n){return n==0||r!=t[n-1]})},e}();Lit.Bucket=K7e});var Rit=H(kit=>{"use strict";Object.defineProperty(kit,"__esModule",{value:!0});var Z7e=function(){function e(){typeof window.Set=="function"?this._es6Set=new window.Set:this._values=[],this.size=0}return e.prototype.add=function(t){return this._es6Set!=null?(this._es6Set.add(t),this.size=this._es6Set.size,this):(this.has(t)||(this._values.push(t),this.size=this._values.length),this)},e.prototype.delete=function(t){if(this._es6Set!=null){var r=this._es6Set.delete(t);return this.size=this._es6Set.size,r}var n=this._values.indexOf(t);return n!==-1?(this._values.splice(n,1),this.size=this._values.length,!0):!1},e.prototype.has=function(t){return this._es6Set!=null?this._es6Set.has(t):this._values.indexOf(t)!==-1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Set!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Set.forEach(i,r);return}this._values.forEach(function(o){t.call(r,o,o,n)})},e}();kit.Set=Z7e});var NXt=H(Nit=>{"use strict";Object.defineProperty(Nit,"__esModule",{value:!0});var J7e=(de(),Ut(pe)),Q7e=Rit(),tze=function(e){J7e.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.callCallbacks=function(){for(var r=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return this.forEach(function(o){o.apply(r,n)}),this},t}(Q7e.Set);Nit.CallbackSet=tze});var DXt=H(Dit=>{"use strict";Object.defineProperty(Dit,"__esModule",{value:!0});var Kg=Iit(),eze=function(){function e(){this._entities=[],this._rtree=new Kg.RTree}return e.prototype.addAll=function(t,r,n){if(this._entities=this._entities.concat(t),n!==void 0)for(var i=Kg.RTreeBounds.bounds(n),o=0;o<t.length;o++){var a=t[o],s=Kg.RTreeBounds.entityBounds(r(a));Kg.RTreeBounds.isBoundsOverlapBounds(i,s)&&this._rtree.insert(s,a)}else for(var o=0;o<t.length;o++){var a=t[o],s=Kg.RTreeBounds.entityBounds(r(a));this._rtree.insert(s,a)}},e.prototype.entityNearest=function(t){return this._rtree.locateNearest(t).pop()},e.prototype.entityNearestX=function(t){return this._rtree.locateNearestX(t).pop()},e.prototype.entityNearestY=function(t){return this._rtree.locateNearestY(t).pop()},e.prototype.entitiesInBounds=function(t){return this._rtree.intersect(Kg.RTreeBounds.entityBounds(t))},e.prototype.entitiesInXBounds=function(t){return this._rtree.intersectX(Kg.RTreeBounds.entityBounds(t))},e.prototype.entitiesInYBounds=function(t){return this._rtree.intersectY(Kg.RTreeBounds.entityBounds(t))},e.prototype.entities=function(){return this._entities},e}();Dit.EntityStore=eze});var OXt=H(Oit=>{"use strict";Object.defineProperty(Oit,"__esModule",{value:!0});var rze=Ait(),nze=function(){function e(){typeof window.Map=="function"?this._es6Map=new window.Map:this._keyValuePairs=[]}return e.prototype.set=function(t,r){if(rze.isNaN(t))throw new Error("NaN may not be used as a key to the Map");if(this._es6Map!=null)return this._es6Map.set(t,r),this;for(var n=0;n<this._keyValuePairs.length;n++)if(this._keyValuePairs[n].key===t)return this._keyValuePairs[n].value=r,this;return this._keyValuePairs.push({key:t,value:r}),this},e.prototype.get=function(t){if(this._es6Map!=null)return this._es6Map.get(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs[r].value},e.prototype.has=function(t){if(this._es6Map!=null)return this._es6Map.has(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return!0;return!1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Map!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Map.forEach(i,r);return}this._keyValuePairs.forEach(function(o){t.call(r,o.value,o.key,n)})},e.prototype.delete=function(t){if(this._es6Map!=null)return this._es6Map.delete(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs.splice(r,1),!0;return!1},e}();Oit.Map=nze});var zXt=H(zit=>{"use strict";Object.defineProperty(zit,"__esModule",{value:!0});function ize(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var r={},n=0,i=e;n<i.length;n++)for(var o=i[n],a=Object.keys(o),s=0,l=a;s<l.length;s++){var c=l[s];r[c]=o[c]}return r}zit.assign=ize});var HXt=H(PF=>{"use strict";Object.defineProperty(PF,"__esModule",{value:!0});var Fit=Fe(),FXt="__Plottable_ClientTranslator";function oze(e){var t=e.root().rootElement().node(),r=t[FXt];return r==null&&(r=new BXt(t),t[FXt]=r),r}PF.getTranslator=oze;var BXt=function(){function e(t){this._rootElement=t}return e.prototype.computePosition=function(t,r){var n={x:t,y:r},i=Fit.Math.getCumulativeTransform(this._rootElement);if(i==null)return n;var o=Fit.Math.applyTransform(i,n);return o},e.isEventInside=function(t,r){return Fit.DOM.contains(t.root().rootElement().node(),r.target)},e}();PF.Translator=BXt});var Fe=H(qo=>{"use strict";Object.defineProperty(qo,"__esModule",{value:!0});var Zg=(de(),Ut(pe)),aze=_Xt();qo.Array=aze;var sze=xXt();qo.Color=sze;var lze=Cit();qo.DOM=lze;var cze=Ait();qo.Math=cze;var uze=Iit();qo.RTree=uze;var hze=IXt();qo.Stacking=hze;var fze=AF();qo.Window=fze;Zg.__exportStar(RXt(),qo);Zg.__exportStar(NXt(),qo);Zg.__exportStar(jg(),qo);Zg.__exportStar(DXt(),qo);Zg.__exportStar(OXt(),qo);Zg.__exportStar(zXt(),qo);Zg.__exportStar(Rit(),qo);Zg.__exportStar(HXt(),qo)});var Hit=H(KA=>{"use strict";Object.defineProperty(KA,"__esModule",{value:!0});var VXt=Fe(),Bit=IF(),pze=function(){function e(){}return e.prototype.render=function(){Bit.flush()},e}();KA.Immediate=pze;var dze=function(){function e(){}return e.prototype.render=function(){VXt.DOM.requestAnimationFramePolyfill(Bit.flush)},e}();KA.AnimationFrame=dze;var mze=function(){function e(){this._timeoutMsec=VXt.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}return e.prototype.render=function(){setTimeout(Bit.flush,this._timeoutMsec)},e}();KA.Timeout=mze});var IF=H(zu=>{"use strict";Object.defineProperty(zu,"__esModule",{value:!0});var _S=Fe(),gze=Lf(),LF=Hit(),JA=new _S.Set,Vit=new _S.Set,kF=!1,Uit=!1;zu.Policy=gze.makeEnum(["immediate","animationFrame","timeout"]);var ZA=new LF.AnimationFrame;function _ze(e){if(e==null)return ZA;switch(e){case zu.Policy.immediate:ZA=new LF.Immediate;break;case zu.Policy.animationFrame:ZA=new LF.AnimationFrame;break;case zu.Policy.timeout:ZA=new LF.Timeout;break;default:_S.Window.warn("Unrecognized renderPolicy: "+e)}}zu.renderPolicy=_ze;function yze(e){Uit&&_S.Window.warn("Registered to render while other components are flushing: request may be ignored"),JA.add(e),qXt()}zu.registerToRender=yze;function UXt(e){Vit.add(e),JA.add(e),qXt()}zu.registerToComputeLayoutAndRender=UXt;function vze(e){UXt(e)}zu.registerToComputeLayout=vze;function qXt(){kF||(kF=!0,ZA.render())}function xze(){if(kF){Vit.forEach(function(t){return t.computeLayout()}),JA.forEach(function(t){return t.render()}),Uit=!0;var e=new _S.Set;JA.forEach(function(t){try{t.renderImmediately()}catch(r){window.setTimeout(function(){throw r},0),e.add(t)}}),Vit=new _S.Set,JA=e,kF=!1,Uit=!1}}zu.flush=xze});var kc=H(QA=>{"use strict";Object.defineProperty(QA,"__esModule",{value:!0});var GXt=(Er(),Ut(Mr)),RF=IF(),yS=Fe(),bze=Oe(),WXt=jg(),YXt=Lf();QA.XAlignment=YXt.makeEnum(["left","center","right"]);QA.YAlignment=YXt.makeEnum(["top","center","bottom"]);var wze=function(){function e(){this._overflowHidden=!1,this._origin={x:0,y:0},this._xAlignment="left",this._yAlignment="top",this._isSetup=!1,this._isAnchored=!1,this._cssClasses=new yS.Set,this._destroyed=!1,this._onAnchorCallbacks=new yS.CallbackSet,this._onDetachCallbacks=new yS.CallbackSet,this._cssClasses.add("component")}return e.prototype.anchor=function(t){if(t=WXt.coerceExternalD3(t),this._destroyed)throw new Error("Can't reuse destroy()-ed Components!");return this.isRoot()&&(this._rootElement=t,this._rootElement.classed("plottable",!0)),this._element!=null?t.node().appendChild(this._element.node()):(this._element=t.append("div"),this._setup()),this._isAnchored=!0,this._onAnchorCallbacks.callCallbacks(this),this},e.prototype.onAnchor=function(t){return this._isAnchored&&t(this),this._onAnchorCallbacks.add(t),this},e.prototype.offAnchor=function(t){return this._onAnchorCallbacks.delete(t),this},e.prototype._setup=function(){var t=this;this._isSetup||(this._cssClasses.forEach(function(r){t._element.classed(r,!0)}),this._cssClasses=new yS.Set,this._backgroundContainer=this._element.append("svg").classed("background-container",!0),this._content=this._element.append("svg").classed("content",!0),this._foregroundContainer=this._element.append("svg").classed("foreground-container",!0),this._overflowHidden?this._content.classed("component-overflow-hidden",!0):this._content.classed("component-overflow-visible",!0),this._isSetup=!0)},e.prototype.requestedSpace=function(t,r){return{minWidth:0,minHeight:0}},e.prototype.computeLayout=function(t,r,n){if(t==null||r==null||n==null){if(this._element==null)throw new Error("anchor() must be called before computeLayout()");if(this._rootElement!=null){t={x:0,y:0};var i=this._rootElement.node();r=yS.DOM.elementWidth(i),n=yS.DOM.elementHeight(i)}else throw new Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node")}var o=this._sizeFromOffer(r,n),a=o.height,s=o.width,l=e._xAlignToProportion[this._xAlignment],c=e._yAlignToProportion[this._yAlignment],u=t.x+(r-s)*l,h=t.y+(n-a)*c;return this.setBounds(s,a,u,h),this},e.prototype.setBounds=function(t,r,n,i){return n===void 0&&(n=0),i===void 0&&(i=0),this._width=t,this._height=r,this._origin={x:n,y:i},this._element!=null&&this._element.styles({left:n+"px",height:r+"px",top:i+"px",width:t+"px"}),this._resizeHandler!=null&&this._resizeHandler({width:t,height:r}),this},e.prototype._sizeFromOffer=function(t,r){var n=this.requestedSpace(t,r);return{width:this.fixedWidth()?Math.min(t,n.minWidth):t,height:this.fixedHeight()?Math.min(r,n.minHeight):r}},e.prototype.render=function(){return this._isAnchored&&this._isSetup&&this.width()>=0&&this.height()>=0&&RF.registerToRender(this),this},e.prototype.renderLowPriority=function(){return this.render()},e.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&RF.registerToComputeLayoutAndRender(this)},e.prototype.onResize=function(t){return this._resizeHandler=t,this},e.prototype.renderImmediately=function(){return this},e.prototype.redraw=function(){return this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():this.parent().redraw()),this},e.prototype.invalidateCache=function(){},e.prototype.renderTo=function(t){if(this.detach(),t!=null){var r=void 0;if(typeof t=="string"||bze.isElement(t)?r=GXt.select(t):r=WXt.coerceExternalD3(t),!r.node()||r.node().nodeName==null)throw new Error("Plottable requires a valid Element to renderTo");if(r.node().nodeName==="svg")throw new Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(r)}if(this._element==null)throw new Error("If a Component has never been rendered before, then renderTo must be given a node to render to, or a d3.Selection, or a selector string");return RF.registerToComputeLayoutAndRender(this),RF.flush(),this},e.prototype.xAlignment=function(t){if(t==null)return this._xAlignment;if(t=t.toLowerCase(),e._xAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._xAlignment=t,this.redraw(),this},e.prototype.yAlignment=function(t){if(t==null)return this._yAlignment;if(t=t.toLowerCase(),e._yAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._yAlignment=t,this.redraw(),this},e.prototype.hasClass=function(t){return t==null?!1:this._element==null?this._cssClasses.has(t):this._element.classed(t)},e.prototype.addClass=function(t){return t==null?this:(this._element==null?this._cssClasses.add(t):this._element.classed(t,!0),this)},e.prototype.removeClass=function(t){return t==null?this:(this._element==null?this._cssClasses.delete(t):this._element.classed(t,!1),this)},e.prototype.fixedWidth=function(){return!1},e.prototype.fixedHeight=function(){return!1},e.prototype.detach=function(){return this.parent(null),this._isAnchored&&this._element.remove(),this._isAnchored=!1,this._onDetachCallbacks.callCallbacks(this),this},e.prototype.onDetach=function(t){return this._onDetachCallbacks.add(t),this},e.prototype.offDetach=function(t){return this._onDetachCallbacks.delete(t),this},e.prototype.parent=function(t){if(t===void 0)return this._parent;if(t!==null&&!t.has(this))throw new Error("Passed invalid parent");return this._parent=t,this},e.prototype.bounds=function(){var t=this.origin();return{topLeft:t,bottomRight:{x:t.x+this.width(),y:t.y+this.height()}}},e.prototype.destroy=function(){this._destroyed=!0,this.detach()},e.prototype.width=function(){return this._width},e.prototype.height=function(){return this._height},e.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}},e.prototype.originToRoot=function(){for(var t=this.origin(),r=this.parent();r!=null;){var n=r.origin();t.x+=n.x,t.y+=n.y,r=r.parent()}return t},e.prototype.root=function(){for(var t=this;!t.isRoot();)t=t.parent();return t},e.prototype.isRoot=function(){return this.parent()==null},e.prototype.foreground=function(){return this._foregroundContainer},e.prototype.content=function(){return this._content},e.prototype.element=function(){return this._element},e.prototype.rootElement=function(){return this.root()._rootElement},e.prototype.background=function(){return this._backgroundContainer},e._xAlignToProportion={left:0,center:.5,right:1},e._yAlignToProportion={top:0,center:.5,bottom:1},e}();QA.Component=wze});var Bu=H(Fu=>{"use strict";Object.defineProperty(Fu,"__esModule",{value:!0});var vS=(Er(),Ut(Mr)),Sze=!1;function Mze(e,t,r){e===void 0&&(e=2),t===void 0&&(t="$"),r===void 0&&(r=!0);var n=qit(e);return function(i){var o=n(Math.abs(i));return o!==""&&(r?o=t+o:o+=t,i<0&&(o="-"+o)),o}}Fu.currency=Mze;function qit(e){return e===void 0&&(e=3),NF(e),function(t){return t.toFixed(e)}}Fu.fixed=qit;function Eze(e){return e===void 0&&(e=3),NF(e),function(t){if(typeof t=="number"){var r=Math.pow(10,e);return String(Math.round(t*r)/r)}else return String(t)}}Fu.general=Eze;function Tze(){return function(e){return String(e)}}Fu.identity=Tze;function Cze(e){e===void 0&&(e=0);var t=qit(e);return function(r){var n=r*100,i=r.toString(),o=Math.pow(10,i.length-(i.indexOf(".")+1));return n=parseInt((n*o).toString(),10)/o,t(n)+"%"}}Fu.percentage=Cze;function Aze(e){return e===void 0&&(e=3),NF(e),function(t){return vS.format("."+e+"s")(t)}}Fu.siSuffix=Aze;function Pze(e){e===void 0&&(e=3),NF(e);var t="KMBTQ",r=vS.format("."+e+"e"),n=vS.format("."+e+"f"),i=Math.pow(10,3*(t.length+1)),o=Math.pow(10,-e);return function(a){var s=Math.abs(a);if((s<o||s>=i)&&s!==0)return r(a);for(var l=-1;s>=Math.pow(1e3,l+2)&&l<t.length-1;)l++;var c="";return l===-1?c=n(a):c=n(a/Math.pow(1e3,l+1))+t[l],(a>0&&c.substr(0,4)==="1000"||a<0&&c.substr(0,5)==="-1000")&&(l<t.length-1?(l++,c=n(a/Math.pow(1e3,l+1))+t[l]):c=r(a)),c}}Fu.shortScale=Pze;function Ize(){var e=[{specifier:".%L",predicate:function(t){return t.getMilliseconds()!==0}},{specifier:":%S",predicate:function(t){return t.getSeconds()!==0}},{specifier:"%I:%M",predicate:function(t){return t.getMinutes()!==0}},{specifier:"%I %p",predicate:function(t){return t.getHours()!==0}},{specifier:"%a %d",predicate:function(t){return t.getDay()!==0&&t.getDate()!==1}},{specifier:"%b %d",predicate:function(t){return t.getDate()!==1}},{specifier:"%b",predicate:function(t){return t.getMonth()!==0}}];return function(t){var r=e.filter(function(i){return i.predicate(t)}),n=r.length>0?r[0].specifier:"%Y";return vS.timeFormat(n)(t)}}Fu.multiTime=Ize;function Lze(e,t){return t===void 0&&(t=Sze),t?vS.utcFormat(e):vS.timeFormat(e)}Fu.time=Lze;function NF(e){if(e<0||e>20)throw new RangeError("Formatter precision must be between 0 and 20");if(e!==Math.floor(e))throw new RangeError("Formatter precision must be an integer")}});var t4=H(DF=>{"use strict";Object.defineProperty(DF,"__esModule",{value:!0});var kze=(de(),Ut(pe)),vd=(Er(),Ut(Mr)),Git=yl(),Rze=kc(),jXt=Bu(),xS=Fe(),Nze=Lf();DF.AxisOrientation=Nze.makeEnum(["bottom","left","right","top"]);var Dze=function(e){kze.__extends(t,e);function t(r,n){var i=e.call(this)||this;if(i._endTickLength=5,i._innerTickLength=5,i._tickLabelPadding=10,i._margin=15,i._showEndTickLabels=!1,i._annotationsEnabled=!1,i._annotationTierCount=1,r==null||n==null)throw new Error("Axis requires a scale and orientation");return i._scale=r,i.orientation(n),i._setDefaultAlignment(),i.addClass("axis"),i.isHorizontal()?i.addClass("x-axis"):i.addClass("y-axis"),i.formatter(jXt.identity()),i._rescaleCallback=function(o){return i._rescale()},i._scale.onUpdate(i._rescaleCallback),i._annotatedTicks=[],i._annotationFormatter=jXt.identity(),i}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._rescaleCallback)},t.prototype.tickLabelDataOnElement=function(r){if(r!=null){for(var n;r!=null&&r.classList&&n===void 0;)r.classList.contains(t.TICK_LABEL_CLASS)?n=r:r=r.parentNode;return r===void 0?void 0:vd.select(r).datum()}},t.prototype._computeWidth=function(){return this._maxLabelTickLength()},t.prototype._computeHeight=function(){return this._maxLabelTickLength()},t.prototype.requestedSpace=function(r,n){var i=0,o=0;if(this.isHorizontal()){if(o=this._computeHeight()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;o+=a*this.annotationTierCount()}}else if(i=this._computeWidth()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;i+=a*this.annotationTierCount()}return{minWidth:i,minHeight:o}},t.prototype.fixedHeight=function(){return this.isHorizontal()},t.prototype.fixedWidth=function(){return!this.isHorizontal()},t.prototype._rescale=function(){this.render()},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]),this},t.prototype._sizeFromOffer=function(r,n){var i=this.requestedSpace(r,n);return this.isHorizontal()?{width:r,height:i.minHeight}:{height:n,width:i.minWidth}},t.prototype._setup=function(){e.prototype._setup.call(this),this._tickMarkContainer=this.content().append("g").classed(t.TICK_MARK_CLASS+"-container",!0),this._tickLabelContainer=this.content().append("g").classed(t.TICK_LABEL_CLASS+"-container",!0),this._baseline=this.content().append("line").classed("baseline",!0),this._annotationContainer=this.content().append("g").classed("annotation-container",!0),this._annotationContainer.append("g").classed("annotation-line-container",!0),this._annotationContainer.append("g").classed("annotation-circle-container",!0),this._annotationContainer.append("g").classed("annotation-rect-container",!0);var r=this._annotationContainer.append("g").classed("annotation-label-container",!0),n=new Git.SvgContext(r.node());this._annotationMeasurer=new Git.CacheMeasurer(n),this._annotationWriter=new Git.Writer(this._annotationMeasurer,n)},t.prototype._getTickValues=function(){return[]},t.prototype.renderImmediately=function(){var r=this._getTickValues(),n=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(t.TICK_MARK_CLASS,!0).merge(n);return i.attrs(this._generateTickMarkAttrHash()),vd.select(i.nodes()[0]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),vd.select(i.nodes()[r.length-1]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),n.exit().remove(),this._baseline.attrs(this._generateBaselineAttrHash()),this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype.annotatedTicks=function(r){return r==null?this._annotatedTicks:(this._annotatedTicks=r,this.render(),this)},t.prototype.annotationFormatter=function(r){return r==null?this._annotationFormatter:(this._annotationFormatter=r,this.render(),this)},t.prototype.annotationsEnabled=function(r){return r==null?this._annotationsEnabled:(this._annotationsEnabled=r,this.redraw(),this)},t.prototype.annotationTierCount=function(r){if(r==null)return this._annotationTierCount;if(r<0)throw new Error("annotationTierCount cannot be negative");return this._annotationTierCount=r,this.redraw(),this},t.prototype._drawAnnotations=function(){var r=this,n=t._ANNOTATION_LABEL_PADDING,i=new xS.Map,o=this._annotatedTicksToRender();o.forEach(function(P){var k=r._annotationMeasurer.measure(r.annotationFormatter()(P)),O={width:k.width+2*n,height:k.height+2*n};i.set(P,O)});var a=this._annotationMeasurer.measure().height+2*n,s=this._annotationToTier(i),l=new xS.Set,c=this.isHorizontal()?this.height():this.width(),u=this._coreSize(),h=Math.min(this.annotationTierCount(),Math.floor((c-u)/a));s.forEach(function(P,k){(P===-1||P>=h)&&l.add(k)});var f=function(P,k,O){var D=P.selectAll("."+O).data(o),B=D.enter().append(k).classed(O,!0).merge(D);return D.exit().remove(),B},p=function(P){switch(r.orientation()){case"bottom":case"right":return s.get(P)*a+u;case"top":case"left":return c-u-s.get(P)*a}},d=function(P){return r._scale.scale(P)},g=function(P){return l.has(P)?"hidden":"visible"},_;switch(this.orientation()){case"bottom":case"right":_=0;break;case"top":_=this.height();break;case"left":_=this.width();break}var y=this.isHorizontal();f(this._annotationContainer.select(".annotation-line-container"),"line",t.ANNOTATION_LINE_CLASS).attrs({x1:y?d:_,x2:y?d:p,y1:y?_:d,y2:y?p:d,visibility:g}),f(this._annotationContainer.select(".annotation-circle-container"),"circle",t.ANNOTATION_CIRCLE_CLASS).attrs({cx:y?d:_,cy:y?_:d,r:3});var x=function(P){switch(r.orientation()){case"bottom":case"right":return p(P);case"top":case"left":return p(P)-i.get(P).height}};f(this._annotationContainer.select(".annotation-rect-container"),"rect",t.ANNOTATION_RECT_CLASS).attrs({x:y?d:x,y:y?x:d,width:y?function(P){return i.get(P).width}:function(P){return i.get(P).height},height:y?function(P){return i.get(P).height}:function(P){return i.get(P).width},visibility:g});var b=this._annotationWriter,S=this.annotationFormatter(),C=f(this._annotationContainer.select(".annotation-label-container"),"g",t.ANNOTATION_LABEL_CLASS);C.selectAll(".text-container").remove(),C.attrs({transform:function(P){var k=y?d(P):x(P),O=y?x(P):d(P);return"translate("+k+","+O+")"},visibility:g}).each(function(P){b.write(S(P),y?i.get(P).width:i.get(P).height,y?i.get(P).height:i.get(P).width,{xAlign:"center",yAlign:"center",textRotation:y?0:90},vd.select(this).node())})},t.prototype._annotatedTicksToRender=function(){var r=this,n=this._scale.range();return xS.Array.uniq(this.annotatedTicks().filter(function(i){return i==null?!1:xS.Math.inRange(r._scale.scale(i),n[0],n[1])}))},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(n,r)},t.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING},t.prototype._annotationToTier=function(r){var n=this,i=[[]],o=new xS.Map,a=this.isHorizontal()?this.width():this.height();return this._annotatedTicksToRender().forEach(function(s){var l=n._scale.scale(s),c=r.get(s).width;if(l<0||l+c>a){o.set(s,-1);return}for(var u=function(f){return i[f].some(function(p){var d=n._scale.scale(p),g=r.get(p).width;return l+c>=d&&l<=d+g})},h=0;u(h);)h++,i.length===h&&i.push([]);i[h].push(s),o.set(s,h)}),o},t.prototype._removeAnnotations=function(){this._annotationContainer.selectAll(".annotation-line").remove(),this._annotationContainer.selectAll(".annotation-circle").remove(),this._annotationContainer.selectAll(".annotation-rect").remove(),this._annotationContainer.selectAll(".annotation-label").remove()},t.prototype._generateBaselineAttrHash=function(){var r={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case"bottom":r.x2=this.width();break;case"top":r.x2=this.width(),r.y1=this.height(),r.y2=this.height();break;case"left":r.x1=this.width(),r.x2=this.width(),r.y2=this.height();break;case"right":r.y2=this.height();break}return r},t.prototype._generateTickMarkAttrHash=function(r){var n=this;r===void 0&&(r=!1);var i={x1:0,y1:0,x2:0,y2:0},o=function(s){return n._scale.scale(s)};this.isHorizontal()?(i.x1=o,i.x2=o):(i.y1=o,i.y2=o);var a=r?this._endTickLength:this._innerTickLength;switch(this._orientation){case"bottom":i.y2=a;break;case"top":i.y1=this.height(),i.y2=this.height()-a;break;case"left":i.x1=this.width(),i.x2=this.width()-a;break;case"right":i.x2=a;break}return i},t.prototype._setDefaultAlignment=function(){switch(this._orientation){case"bottom":this.yAlignment("top");break;case"top":this.yAlignment("bottom");break;case"left":this.xAlignment("right");break;case"right":this.xAlignment("left");break}},t.prototype.isHorizontal=function(){return this._orientation==="top"||this._orientation==="bottom"},t.prototype.getScale=function(){return this._scale},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.innerTickLength=function(r){if(r==null)return this._innerTickLength;if(r<0)throw new Error("inner tick length must be positive");return this._innerTickLength=r,this.redraw(),this},t.prototype.endTickLength=function(r){if(r==null)return this._endTickLength;if(r<0)throw new Error("end tick length must be positive");return this._endTickLength=r,this.redraw(),this},t.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),this.endTickLength()):this.innerTickLength()},t.prototype.tickLabelPadding=function(r){if(r==null)return this._tickLabelPadding;if(r<0)throw new Error("tick label padding must be positive");return this._tickLabelPadding=r,this.redraw(),this},t.prototype.margin=function(r){if(r==null)return this._margin;if(r<0)throw new Error("margin size must be positive");return this._margin=r,this.redraw(),this},t.prototype.orientation=function(r){if(r==null)return this._orientation;var n=r.toLowerCase();if(n!=="top"&&n!=="bottom"&&n!=="left"&&n!=="right")throw new Error("unsupported orientation");return this._orientation=n,this.redraw(),this},t.prototype.showEndTickLabels=function(r){return r==null?this._showEndTickLabels:(this._showEndTickLabels=r,this.render(),this)},t.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).each(function(){vd.select(this).style("visibility","inherit")})},t.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).each(function(){vd.select(this).style("visibility","inherit")})},t.prototype._hideOverflowingTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS);n.empty()||n.each(function(i,o){xS.DOM.clientRectInside(this.getBoundingClientRect(),r)||vd.select(this).style("visibility","hidden")})},t.prototype._hideTickMarksWithoutLabel=function(){var r=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).filter(function(o,a){var s=vd.select(this).style("visibility");return s==="inherit"||s==="visible"}),i=n.data();r.each(function(o,a){i.indexOf(o)===-1&&vd.select(this).style("visibility","hidden")})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._annotationMeasurer.reset()},t.END_TICK_MARK_CLASS="end-tick-mark",t.TICK_MARK_CLASS="tick-mark",t.TICK_LABEL_CLASS="tick-label",t.ANNOTATION_LINE_CLASS="annotation-line",t.ANNOTATION_RECT_CLASS="annotation-rect",t.ANNOTATION_CIRCLE_CLASS="annotation-circle",t.ANNOTATION_LABEL_CLASS="annotation-label",t._ANNOTATION_LABEL_PADDING=4,t}(Rze.Component);DF.Axis=Dze});var $Xt=H(jit=>{"use strict";Object.defineProperty(jit,"__esModule",{value:!0});var Oze=(de(),Ut(pe)),Wit=(Er(),Ut(Mr)),OF=yl(),zze=kc(),XXt=Fe(),Yit=t4(),Fze=function(e){Oze.__extends(t,e);function t(r,n){n===void 0&&(n="bottom");var i=e.call(this,r,n)||this;return i._tickLabelAngle=0,i._tickLabelShearAngle=0,i.addClass("category-axis"),i}return Object.defineProperty(t.prototype,"_wrapper",{get:function(){var r=new OF.Wrapper;return this._tickLabelMaxLines!=null&&r.maxLines(this._tickLabelMaxLines),r},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"_writer",{get:function(){return new OF.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0}),t.prototype._setup=function(){e.prototype._setup.call(this),this._typesetterContext=new OF.SvgContext(this._tickLabelContainer.node()),this._measurer=new OF.CacheMeasurer(this._typesetterContext)},t.prototype._rescale=function(){return this.redraw()},t.prototype.requestedSpace=function(r,n){var i=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),o=this.isHorizontal()?this._tickSpaceRequired()+this.margin():0;if(this._scale.domain().length===0)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var a=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?o+=a:i+=a}var s=this._measureTickLabels(r,n);return{minWidth:s.usedWidth+i,minHeight:s.usedHeight+o}},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),this.height()).minWidth,i=this.margin()+this._annotationTierHeight(),o=n-i;return Math.min(o,r)},t.prototype._getTickValues=function(){return this.getDownsampleInfo().domain},t.prototype._sizeFromOffer=function(r,n){return zze.Component.prototype._sizeFromOffer.call(this,r,n)},t.prototype.getDownsampleInfo=function(r,n){r===void 0&&(r=this._scale),n===void 0&&(n=r.invertRange());var i=this._tickLabelAngle===0?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI),o=t._MINIMUM_WIDTH_PER_LABEL_PX*i,a=Math.ceil(o/r.stepWidth());return{domain:n.filter(function(s,l){return l%a===0}),stepWidth:a*r.stepWidth()}},t.prototype.tickLabelAngle=function(r){if(r==null)return this._tickLabelAngle;if(r!==0&&r!==90&&r!==-90)throw new Error("Angle "+r+" not supported; only 0, 90, and -90 are valid values");return this._tickLabelAngle=r,this.redraw(),this},t.prototype.tickLabelShearAngle=function(r){if(r==null)return this._tickLabelShearAngle;if(r<-80||r>80)throw new Error("Angle "+r+" not supported; Must be between [-80, 80]");return this._tickLabelShearAngle=r,this.redraw(),this},t.prototype.tickLabelMaxWidth=function(r){return arguments.length===0?this._tickLabelMaxWidth:(this._tickLabelMaxWidth=r,this.redraw(),this)},t.prototype.tickLabelMaxLines=function(r){return arguments.length===0?this._tickLabelMaxLines:(this._tickLabelMaxLines=r,this.redraw(),this)},t.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()},t.prototype._drawTicks=function(r,n){var i=this,o,a;switch(this.tickLabelAngle()){case 0:o={left:"right",right:"left",top:"center",bottom:"center"},a={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:o={left:"center",right:"center",top:"right",bottom:"left"},a={left:"top",right:"bottom",top:"center",bottom:"center"};break;case-90:o={left:"center",right:"center",top:"left",bottom:"right"},a={left:"bottom",right:"top",top:"center",bottom:"center"};break}n.each(function(s){var l=Wit.select(this),c=i.isHorizontal()?r:i.width()-i._tickSpaceRequired(),u=i.isHorizontal()?i.height()-i._tickSpaceRequired():r,h={xAlign:o[i.orientation()],yAlign:a[i.orientation()],textRotation:i.tickLabelAngle(),textShear:i.tickLabelShearAngle()};if(i._tickLabelMaxWidth!=null){if(i.orientation()==="left"&&c>i._tickLabelMaxWidth){var f=c-i._tickLabelMaxWidth,p=l.attr("transform")+" translate("+f+", 0)";l.attr("transform",p)}c=Math.min(c,i._tickLabelMaxWidth)}i._writer.write(i.formatter()(s),c,u,h,l.node())})},t.prototype._measureTickLabels=function(r,n){var i=this,o=this._scale,a=o.cloneWithoutProviders().range([0,this.isHorizontal()?r:n]),s=this.getDownsampleInfo(a),l=s.domain,c=s.stepWidth,u=r-this._tickSpaceRequired();this.isHorizontal()&&(u=c,this._tickLabelAngle!==0&&(u=n-this._tickSpaceRequired()),u=Math.max(u,0));var h=c;this.isHorizontal()&&(h=n-this._tickSpaceRequired(),this._tickLabelAngle!==0&&(h=r-this._tickSpaceRequired()),h=Math.max(h,0)),this._tickLabelMaxWidth!=null&&(u=Math.min(u,this._tickLabelMaxWidth));var f=l.map(function(x){return i._wrapper.wrap(i.formatter()(x),i._measurer,u,h)}),p=this.isHorizontal()&&this._tickLabelAngle===0?Wit.sum:XXt.Math.max,d=this.isHorizontal()&&this._tickLabelAngle===0?XXt.Math.max:Wit.sum,g=p(f,function(x){return i._measurer.measure(x.wrappedText).width},0),_=d(f,function(x){return i._measurer.measure(x.wrappedText).height},0);return this._tickLabelAngle!==0&&(y=[_,g],g=y[0],_=y[1]),{usedWidth:g,usedHeight:_};var y},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale,i=this.getDownsampleInfo(n),o=i.domain,a=i.stepWidth,s=a;this.isHorizontal()&&this._tickLabelMaxWidth!=null&&(s=Math.min(s,this._tickLabelMaxWidth));var l=function(p,d){var g=n.scale(p)-s/2,_=r.isHorizontal()?g:0,y=r.isHorizontal()?0:g;return"translate("+_+","+y+")"},c=this._tickLabelContainer.selectAll("."+Yit.Axis.TICK_LABEL_CLASS).data(o),u=c.enter().append("g").classed(Yit.Axis.TICK_LABEL_CLASS,!0).merge(c);c.exit().remove(),u.attr("transform",l),u.text(""),this._drawTicks(a,u);var h=this.orientation()==="right"?this._tickSpaceRequired():0,f=this.orientation()==="bottom"?this._tickSpaceRequired():0;return this._tickLabelContainer.attr("transform","translate("+h+","+f+")"),this._showAllTickMarks(),this._showAllTickLabels(),this._hideTickMarksWithoutLabel(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()||this._scale.range([0,this.height()]),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._MINIMUM_WIDTH_PER_LABEL_PX=15,t}(Yit.Axis);jit.Category=Fze});var KXt=H($it=>{"use strict";Object.defineProperty($it,"__esModule",{value:!0});var Bze=(de(),Ut(pe)),zF=(Er(),Ut(Mr)),Xit=yl(),Hze=Bu(),bS=Fe(),wS=t4(),Vze=function(e){Bze.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i._tickLabelPositioning="center",i._usesTextWidthApproximation=!1,i.formatter(Hze.general()),i}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=new Xit.SvgContext(this._tickLabelContainer.node(),wS.Axis.TICK_LABEL_CLASS);this._measurer=new Xit.CacheMeasurer(r),this._wrapper=new Xit.Wrapper().maxLines(1)},t.prototype._computeWidth=function(){var r=this._usesTextWidthApproximation?this._computeApproximateTextWidth():this._computeExactTextWidth();return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._computeExactTextWidth=function(){var r=this,n=this._getTickValues(),i=n.map(function(o){var a=r.formatter()(o);return r._measurer.measure(a).width});return bS.Math.max(i,0)},t.prototype._computeApproximateTextWidth=function(){var r=this,n=this._getTickValues(),i=this._measurer.measure("M").width,o=n.map(function(a){var s=r.formatter()(a);return s.length*i});return bS.Math.max(o,0)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._getTickValues=function(){var r=this._scale,n=r.domain(),i=n[0]<=n[1]?n[0]:n[1],o=n[0]>=n[1]?n[0]:n[1];return r.ticks().filter(function(a){return a>=i&&a<=o})},t.prototype._rescale=function(){if(!!this._isSetup){if(!this.isHorizontal()){var r=this._computeWidth();if(r>this.width()||r<this.width()-this.margin()){this.redraw();return}}this.render()}},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n={x:0,y:0,dx:"0em",dy:"0.3em"},i=this._maxLabelTickLength(),o=this.tickLabelPadding(),a="middle",s=0,l=0,c=0,u=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case"left":a="end",s=-o,u=o;break;case"center":u=i+o;break;case"right":a="start",s=o,u=o;break}else switch(this._tickLabelPositioning){case"top":n.dy="-0.3em",c=o,l=-o;break;case"center":c=i+o;break;case"bottom":n.dy="1em",c=o,l=o;break}var h=this._generateTickMarkAttrHash();switch(this.orientation()){case"bottom":n.x=h.x1,n.dy="0.95em",l=h.y1+u;break;case"top":n.x=h.x1,n.dy="-.25em",l=h.y1-u;break;case"left":a="end",s=h.x1-c,n.y=h.y1;break;case"right":a="start",s=h.x1+c,n.y=h.y1;break}var f=this._getTickValues(),p=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).data(f);p.exit().remove();var d=p.enter().append("text").classed(wS.Axis.TICK_LABEL_CLASS,!0).merge(p);d.style("text-anchor",a).style("visibility","inherit").attrs(n).text(function(_){return r.formatter()(_)});var g="translate("+s+", "+l+")";return this._tickLabelContainer.attr("transform",g),this._showAllTickMarks(),this.showEndTickLabels()||this._hideEndTickLabels(),this._hideOverflowingTickLabels(),this._hideOverlappingTickLabels(),this._tickLabelPositioning!=="center"&&this._hideTickMarksWithoutLabel(),this},t.prototype.tickLabelPosition=function(r){if(r==null)return this._tickLabelPositioning;var n=r.toLowerCase();if(this.isHorizontal()){if(!(n==="left"||n==="center"||n==="right"))throw new Error(n+" is not a valid tick label position for a horizontal NumericAxis")}else if(!(n==="top"||n==="center"||n==="bottom"))throw new Error(n+" is not a valid tick label position for a vertical NumericAxis");return this._tickLabelPositioning=n,this.redraw(),this},t.prototype.usesTextWidthApproximation=function(r){return r==null?this._usesTextWidthApproximation:(this._usesTextWidthApproximation=r,this)},t.prototype._hideEndTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS);if(n.size()!==0){var i=n.nodes()[0];bS.DOM.clientRectInside(i.getBoundingClientRect(),r)||zF.select(i).style("visibility","hidden");var o=n.nodes()[n.size()-1];bS.DOM.clientRectInside(o.getBoundingClientRect(),r)||zF.select(o).style("visibility","hidden")}},t.prototype._hideOverlappingTickLabels=function(){for(var r=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).filter(function(o,a){var s=zF.select(this).style("visibility");return s==="inherit"||s==="visible"}),n=r.nodes().map(function(o){return o.getBoundingClientRect()}),i=1;!this._hasOverlapWithInterval(i,n)&&i<n.length;)i+=1;r.each(function(o,a){var s=zF.select(this);a%i!==0&&s.style("visibility","hidden")})},t.prototype._hasOverlapWithInterval=function(r,n){for(var i=this._tickLabelPositioning==="center"?this.tickLabelPadding():this.tickLabelPadding()*3,o=n.map(function(c){return bS.DOM.expandRect(c,i)}),a=0;a<o.length-r;a+=r){var s=o[a],l=o[a+r];if(bS.DOM.clientRectsOverlap(s,l))return!1}return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(wS.Axis);$it.Numeric=Vze});var ZXt=H(FF=>{"use strict";Object.defineProperty(FF,"__esModule",{value:!0});var Uze=Fe();function qze(e){if(e<=0)throw new Error("interval must be positive number");return function(t){var r=t.domain(),n=Math.min(r[0],r[1]),i=Math.max(r[0],r[1]),o=Math.ceil(n/e)*e,a=Math.floor((i-o)/e)+1,s=n%e===0?[]:[n],l=Uze.Math.range(0,a).map(function(u){return o+u*e}),c=i%e===0?[]:[i];return s.concat(l).concat(c)}}FF.intervalTickGenerator=qze;function Gze(){return function(e){var t=e.defaultTicks();return t.filter(function(r,n){return r%1===0||n===0||n===t.length-1})}}FF.integerTickGenerator=Gze});var e4=H(Lv=>{"use strict";Object.defineProperty(Lv,"__esModule",{value:!0});function Zit(e,t,r){return r-(r-e)*t}Lv.zoomOut=Zit;function Kit(e,t,r){return(e*t-r)/(t-1)}function Wze(e,t,r,n,i,o,a){return t=JXt(e,t,n,i),QXt(e,t,r,o,a)}Lv.constrainedZoom=Wze;function JXt(e,t,r,n){var i=t>1,o=i?n:r;if(o==null)return t;var a=e.getTransformationDomain(),s=a[0],l=a[1],c=Math.abs(l-s),u=i?Math.min:Math.max;return u(t,o/c)}Lv.constrainZoomExtents=JXt;function QXt(e,t,r,n,i){if(t<=1)return{centerPoint:r,zoomAmount:t};if(n==null&&i==null)return{centerPoint:r,zoomAmount:t};var o=t$t(e),a=jze(e),s=a?1/0:-1/0,l=a?-1/0:1/0;n=n==null?s:n,i=i==null?l:i;var c=e.getTransformationDomain(),u=c[0],h=c[1],f=e.scaleTransformation(i),p=e.scaleTransformation(h),d=Zit(p,t,r),g=e.scaleTransformation(n),_=e.scaleTransformation(u),y=Zit(_,t,r),x=Math.abs(f-g),b=Math.abs(d-y);if(b>x){var S=(f-g)/(p-_);if(S!==1){var C=Kit(p,S,f);return{centerPoint:C,zoomAmount:S}}else return{centerPoint:r,zoomAmount:S}}else return d>f!=o?{centerPoint:Kit(p,t,f),zoomAmount:t}:y<g!=o?{centerPoint:Kit(_,t,g),zoomAmount:t}:{centerPoint:r,zoomAmount:t}}Lv.constrainZoomValues=QXt;function Yze(e,t,r,n){var i=e.getTransformationDomain(),o=i[0],a=i[1],s=t$t(e);if(t>0!==s){var l=n;if(l!=null){var c=e.scaleTransformation(a),u=e.scaleTransformation(l);t=(s?Math.max:Math.min)(c+t,u)-c}}else{var l=r;if(l!=null){var h=e.scaleTransformation(o),f=e.scaleTransformation(l);t=(s?Math.min:Math.max)(h+t,f)-h}}return t}Lv.constrainedTranslation=Yze;function t$t(e){var t=e.range();return t[1]<t[0]}function jze(e){var t=e.getTransformationDomain();return t[1]<t[0]}});var kv=H(Jit=>{"use strict";Object.defineProperty(Jit,"__esModule",{value:!0});var e$t=Fe(),Xze=function(){function e(){this._autoDomainAutomatically=!0,this._domainModificationInProgress=!1,this._updateId=0,this._callbacks=new e$t.CallbackSet,this._includedValuesProviders=new e$t.Set}return e.prototype.extentOfValues=function(t){return[]},e.prototype._getAllIncludedValues=function(t){var r=this;t===void 0&&(t=!1);var n=[];return this._includedValuesProviders.forEach(function(i){var o=i(r,t);n=n.concat(o)}),n},e.prototype._getExtent=function(){return[]},e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype._dispatchUpdate=function(){this._updateId++,this._callbacks.callCallbacks(this)},e.prototype.autoDomain=function(){return this._autoDomainAutomatically=!0,this._setDomain(this._getExtent()),this},e.prototype.autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()},e.prototype.scale=function(t){throw new Error("Subclasses should override scale")},e.prototype.ticks=function(){return this.domain()},e.prototype.domain=function(t){return t==null?this._getDomain():(this._autoDomainAutomatically=!1,this._setDomain(t),this)},e.prototype._getDomain=function(){throw new Error("Subclasses should override _getDomain")},e.prototype._setDomain=function(t){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(t),this._dispatchUpdate(),this._domainModificationInProgress=!1)},e.prototype._backingScaleDomain=function(t){throw new Error("Subclasses should override _backingDomain")},e.prototype.range=function(t){return t==null?this._getRange():(this._setRange(t),this)},e.prototype._getRange=function(){throw new Error("Subclasses should override _getRange")},e.prototype._setRange=function(t){throw new Error("Subclasses should override _setRange")},e.prototype.addIncludedValuesProvider=function(t){return this._includedValuesProviders.add(t),this.autoDomainIfAutomaticMode(),this},e.prototype.removeIncludedValuesProvider=function(t){return this._includedValuesProviders.delete(t),this.autoDomainIfAutomaticMode(),this},e.prototype.updateId=function(){return this._updateId},e}();Jit.Scale=Xze});var eot=H(tot=>{"use strict";Object.defineProperty(tot,"__esModule",{value:!0});var $ze=(de(),Ut(pe)),BF=(Er(),Ut(Mr)),Kze=e4(),r$t=Fe(),Zze=kv(),Qit=[0,1],Jze=function(e){$ze.__extends(t,e);function t(){var r=e.call(this)||this;r._range=[0,1],r._d3Scale=BF.scaleBand(),r._d3Scale.range(Qit),r._d3TransformationScale=BF.scaleLinear(),r._d3TransformationScale.domain(Qit);var n=.3;return r._innerPadding=t._convertToPlottableInnerPadding(n),r._outerPadding=t._convertToPlottableOuterPadding(.5,n),r}return t.prototype.cloneWithoutProviders=function(){var r=new t().domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());return r._d3TransformationScale.domain(this._d3TransformationScale.domain()),r},t.prototype.extentOfValues=function(r){return r$t.Array.uniq(r)},t.prototype._getExtent=function(){return r$t.Array.uniq(this._getAllIncludedValues())},t.prototype.domain=function(r){return e.prototype.domain.call(this,r)},t.prototype.invertRange=function(r){var n=this;r===void 0&&(r=this.range());var i=this._d3Scale.bandwidth(),o=this.invertedTransformation(r[0]),a=this.invertedTransformation(r[1]),s=this._d3Scale.domain(),l=s.map(function(h){return n._d3Scale(h)+i/2}),c=BF.bisect(l,o),u=BF.bisect(l,a);return s.slice(c,u)},t.prototype.range=function(r){return e.prototype.range.call(this,r)},t._convertToPlottableInnerPadding=function(r){return 1/(1-r)-1},t._convertToPlottableOuterPadding=function(r,n){return r/(1-n)},t.prototype._setBands=function(){var r=1-1/(1+this.innerPadding()),n=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(r),this._d3Scale.paddingOuter(n)},t.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())},t.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))},t.prototype.ticks=function(){return this.domain()},t.prototype.innerPadding=function(r){return r==null?this._innerPadding:(this._innerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.outerPadding=function(r){return r==null?this._outerPadding:(this._outerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.scale=function(r){var n=this._d3Scale(r)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(n)},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i._d3TransformationScale.invert(Kze.zoomOut(a,r,n))};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(o)),this._dispatchUpdate()},t.prototype.pan=function(r){var n=this,i=function(o){return n._d3TransformationScale.invert(o+r)};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(i)),this._dispatchUpdate()},t.prototype.scaleTransformation=function(r){return this._d3TransformationScale(r)},t.prototype.invertedTransformation=function(r){return this._d3TransformationScale.invert(r)},t.prototype.getTransformationExtent=function(){return Qit},t.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()},t.prototype.setTransformationDomain=function(r){this._d3TransformationScale.domain(r),this._dispatchUpdate()},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._setBands(),this)},t.prototype._getRange=function(){return this._range},t.prototype._setRange=function(r){this._range=r,this._d3TransformationScale.range(r),this._setBands()},t.prototype._rescaleBand=function(r){return Math.abs(this._d3TransformationScale(r)-this._d3TransformationScale(0))},t}(Zze.Scale);tot.Category=Jze});var n$t=H(rot=>{"use strict";Object.defineProperty(rot,"__esModule",{value:!0});var Qze=(de(),Ut(pe)),Df=(Er(),Ut(Mr)),SS=Fe(),tFe=kv(),eFe=function(){function e(){this.count=0,this.tracker={}}return e.prototype.getIndex=function(t){if(this.tracker[t]!=null)return this.tracker[t];var r=this.count;return this.tracker[t]=r,this.count+=1,r},e.prototype.clear=function(){this.count=0,this.tracker={}},e}(),rFe=function(e){Qze.__extends(t,e);function t(r){var n=e.call(this)||this;n._rangeLength=1,n._tracker=new eFe;var i;switch(r){case null:case void 0:t._plottableColorCache==null&&(t._plottableColorCache=t._getPlottableColors()),i=Df.scaleOrdinal().range(t._plottableColorCache);break;case"Category10":case"category10":case"10":i=Df.scaleOrdinal(Df.schemeCategory10);break;case"Category20":case"category20":case"20":i=Df.scaleOrdinal(Df.schemeCategory20);break;case"Category20b":case"category20b":case"20b":i=Df.scaleOrdinal(Df.schemeCategory20b);break;case"Category20c":case"category20c":case"20c":i=Df.scaleOrdinal(Df.schemeCategory20c);break;default:throw new Error("Unsupported ColorScale type")}return n._d3Scale=i,n._rangeLength=n._d3Scale.range().length,n}return t.prototype.extentOfValues=function(r){return SS.Array.uniq(r)},t.prototype._getExtent=function(){return SS.Array.uniq(this._getAllIncludedValues())},t.invalidateColorCache=function(){t._plottableColorCache=null},t._getPlottableColors=function(){for(var r=[],n=Df.select("body").append("plottable-color-tester"),i=SS.Color.colorTest(n,""),o=0,a=SS.Color.colorTest(n,"plottable-colors-0");a!=null&&o<this._MAXIMUM_COLORS_FROM_CSS&&!(a===i&&a===r[r.length-1]);)r.push(a),o++,a=SS.Color.colorTest(n,"plottable-colors-"+o);return n.remove(),r},t.prototype.scale=function(r){var n=this._d3Scale(r),i=this._tracker.getIndex(r),o=Math.floor(i/this._rangeLength);if(o===0)return n;var a=Math.log(o*t._LOOP_LIGHTEN_FACTOR+1);return SS.Color.lightenColor(n,a)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._tracker.clear(),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r),this._rangeLength=r.length},t._LOOP_LIGHTEN_FACTOR=1.6,t._MAXIMUM_COLORS_FROM_CSS=256,t}(tFe.Scale);rot.Color=rFe});var o$t=H(not=>{"use strict";Object.defineProperty(not,"__esModule",{value:!0});var nFe=(de(),Ut(pe)),MS=(Er(),Ut(Mr)),i$t=Fe(),iFe=kv(),oFe=function(e){nFe.__extends(t,e);function t(r){r===void 0&&(r="linear");var n=e.call(this)||this;switch(r){case"linear":n._colorScale=MS.scaleLinear();break;case"log":n._colorScale=MS.scaleLog();break;case"sqrt":n._colorScale=MS.scaleSqrt();break;case"pow":n._colorScale=MS.scalePow();break}if(n._colorScale==null)throw new Error("unknown QuantitativeScale scale type "+r);return n.range(t.REDS),n}return t.prototype.extentOfValues=function(r){var n=MS.extent(r);return n[0]==null||n[1]==null?[]:n},t.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())},t.prototype._interpolateColors=function(){var r=this._colorRange;if(r.length<2)throw new Error("Color scale arrays must have at least two elements.");return function(n,i){return function(o){o=Math.max(0,Math.min(1,o));var a=o*(r.length-1),s=Math.floor(a),l=Math.ceil(a),c=a-s;return MS.interpolateLab(r[s],r[l])(c)}}},t.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale(),this.autoDomainIfAutomaticMode(),this._dispatchUpdate()},t.prototype.autoDomain=function(){var r=this._getAllIncludedValues();return r.length>0&&this._setDomain([i$t.Math.min(r,0),i$t.Math.max(r,0)]),this},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._colorRange},t.prototype._setRange=function(r){this._colorRange=r,this._resetScale()},t.REDS=["#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t.BLUES=["#FFFFFF","#CCFFFF","#A5FFFD","#85F7FB","#6ED3EF","#55A7E0","#417FD0","#2545D3","#0B02E1"],t.POSNEG=["#0B02E1","#2545D3","#417FD0","#55A7E0","#6ED3EF","#85F7FB","#A5FFFD","#CCFFFF","#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t}(iFe.Scale);not.InterpolatedColor=oFe});var xd=H(iot=>{"use strict";Object.defineProperty(iot,"__esModule",{value:!0});var aFe=(de(),Ut(pe)),sFe=(Er(),Ut(Mr)),lFe=e4(),ES=Fe(),cFe=kv(),uFe=function(e){aFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._tickGenerator=function(n){return n.defaultTicks()},r._padProportion=.05,r._snappingDomainEnabled=!0,r._paddingExceptionsProviders=new ES.Set,r}return t.prototype.autoDomain=function(){return this._domainMin=null,this._domainMax=null,e.prototype.autoDomain.call(this),this},t.prototype.autoDomainIfAutomaticMode=function(){if(this._domainMin!=null&&this._domainMax!=null){this._setDomain([this._domainMin,this._domainMax]);return}var r=this._getExtent();if(this._domainMin!=null){var n=r[1];this._domainMin>=n&&(n=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,n]);return}if(this._domainMax!=null){var i=r[0];this._domainMax<=i&&(i=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([i,this._domainMax]);return}e.prototype.autoDomainIfAutomaticMode.call(this)},t.prototype._getUnboundedExtent=function(r){r===void 0&&(r=!1);var n=this._getAllIncludedValues(r),i=this._defaultExtent();if(n.length!==0){var o=[ES.Math.min(n,i[0]),ES.Math.max(n,i[1])];i=this._padDomain(o)}return i},t.prototype._getExtent=function(){var r=this._getUnboundedExtent();return this._domainMin!=null&&(r[0]=this._domainMin),this._domainMax!=null&&(r[1]=this._domainMax),r},t.prototype.addPaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.add(r),this.autoDomainIfAutomaticMode(),this},t.prototype.removePaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.delete(r),this.autoDomainIfAutomaticMode(),this},t.prototype.padProportion=function(r){if(r==null)return this._padProportion;if(r<0)throw new Error("padProportion must be non-negative");return this._padProportion=r,this.autoDomainIfAutomaticMode(),this},t.prototype._padDomain=function(r){var n=this;if(r[0].valueOf()===r[1].valueOf())return this._expandSingleValueDomain(r);if(this._padProportion===0)return r;var i=this._padProportion/2,o=r[0],a=r[1],s=!1,l=!1;this._paddingExceptionsProviders.forEach(function(f){var p=f(n);p.forEach(function(d){d.valueOf()===o.valueOf()&&(s=!0),d.valueOf()===a.valueOf()&&(l=!0)})});var c=this._backingScaleDomain();this._backingScaleDomain(r);var u=s?o:this.invert(this.scale(o)-(this.scale(a)-this.scale(o))*i),h=l?a:this.invert(this.scale(a)+(this.scale(a)-this.scale(o))*i);return this._backingScaleDomain(c),this._snappingDomainEnabled?this._niceDomain([u,h]):[u,h]},t.prototype.snappingDomainEnabled=function(r){return r==null?this._snappingDomainEnabled:(this._snappingDomainEnabled=r,this.autoDomainIfAutomaticMode(),this)},t.prototype._expandSingleValueDomain=function(r){return r},t.prototype.invert=function(r){throw new Error("Subclasses should override invert")},t.prototype.domain=function(r){return r!=null&&(this._domainMin=r[0],this._domainMax=r[1]),e.prototype.domain.call(this,r)},t.prototype.domainMin=function(r){return r==null?this.domain()[0]:(this._domainMin=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.domainMax=function(r){return r==null?this.domain()[1]:(this._domainMax=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.extentOfValues=function(r){var n=sFe.extent(r.filter(function(i){return ES.Math.isValidNumber(+i)}));return n[0]==null||n[1]==null?[]:n},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i.invert(lFe.zoomOut(a,r,n))};this.domain(this.range().map(o))},t.prototype.pan=function(r){var n=this,i=function(o){return n.invert(o+r)};this.domain(this.range().map(i))},t.prototype.scaleTransformation=function(r){throw new Error("Subclasses should override scaleTransformation")},t.prototype.invertedTransformation=function(r){throw new Error("Subclasses should override invertedTransformation")},t.prototype.getTransformationExtent=function(){throw new Error("Subclasses should override getTransformationExtent")},t.prototype.getTransformationDomain=function(){throw new Error("Subclasses should override getTransformationDomain")},t.prototype.setTransformationDomain=function(r){throw new Error("Subclasses should override setTransformationDomain")},t.prototype._setDomain=function(r){var n=function(i){return ES.Math.isNaN(i)||i===1/0||i===-1/0};if(n(r[0])||n(r[1])){ES.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring.");return}e.prototype._setDomain.call(this,r)},t.prototype.defaultTicks=function(){throw new Error("Subclasses should override _getDefaultTicks")},t.prototype.ticks=function(){return this._tickGenerator(this)},t.prototype._niceDomain=function(r,n){throw new Error("Subclasses should override _niceDomain")},t.prototype._defaultExtent=function(){throw new Error("Subclasses should override _defaultExtent")},t.prototype.tickGenerator=function(r){return r==null?this._tickGenerator:(this._tickGenerator=r,this)},t._DEFAULT_NUM_TICKS=10,t}(cFe.Scale);iot.QuantitativeScale=uFe});var a$t=H(oot=>{"use strict";Object.defineProperty(oot,"__esModule",{value:!0});var hFe=(de(),Ut(pe)),fFe=(Er(),Ut(Mr)),pFe=xd(),dFe=function(e){hFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=fFe.scaleLinear(),r}return t.prototype._defaultExtent=function(){return[0,1]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]-1,r[1]+1]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice(n).domain()},t}(pFe.QuantitativeScale);oot.Linear=dFe});var s$t=H(aot=>{"use strict";Object.defineProperty(aot,"__esModule",{value:!0});var mFe=(de(),Ut(pe)),gFe=(Er(),Ut(Mr)),_Fe=xd(),yFe=function(e){mFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;return n._d3Scale=gFe.scaleLog().base(r),n._setDomain(n._defaultExtent()),n}return t.prototype._defaultExtent=function(){return[1,this._d3Scale.base()]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]/this._d3Scale.base(),r[1]*this._d3Scale.base()]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice().domain()},t}(_Fe.QuantitativeScale);aot.Log=yFe});var l$t=H(lot=>{"use strict";Object.defineProperty(lot,"__esModule",{value:!0});var vFe=(de(),Ut(pe)),r4=(Er(),Ut(Mr)),TS=Fe(),sot=Rs(),xFe=xd(),bFe=function(e){vFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;if(n._logTickGenerator=function(i){var o=function(x,b,S){return[x,b,S].sort(function(C,P){return C-P})[1]},a=TS.Math.min(n._untransformedDomain,0),s=TS.Math.max(n._untransformedDomain,0),l=a,c=o(a,s,-n._pivot),u=o(a,s,n._pivot),h=s,f=n._logTicks(-c,-l).map(function(x){return-x}).reverse(),p=n._logTicks(u,h),d=Math.max(a,-n._pivot),g=Math.min(s,n._pivot),_=r4.scaleLinear().domain([d,g]).ticks(n._howManyTicks(d,g)),y=f.concat(_).concat(p);return y.length<=1&&(y=r4.scaleLinear().domain([a,s]).ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)),y},n._d3Scale=r4.scaleLinear(),n._base=r,n._pivot=n._base,n._setDomain(n._defaultExtent()),n.tickGenerator(n._logTickGenerator),r<=1)throw new Error("ModifiedLogScale: The base must be > 1");return n}return t.prototype._adjustedLog=function(r){var n=r<0?-1:1;return r*=n,r<this._pivot&&(r+=(this._pivot-r)/this._pivot),r=Math.log(r)/Math.log(this._base),r*=n,r},t.prototype._invertedAdjustedLog=function(r){var n=r<0?-1:1;return r*=n,r=Math.pow(this._base,r),r<this._pivot&&(r=this._pivot*(r-1)/(this._pivot-1)),r*=n,r},t.prototype.scale=function(r){return this._d3Scale(this._adjustedLog(r))},t.prototype.invert=function(r){return this._invertedAdjustedLog(this._d3Scale.invert(r))},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._untransformedDomain},t.prototype._setDomain=function(r){this._untransformedDomain=r;var n=[this._adjustedLog(r[0]),this._adjustedLog(r[1])];e.prototype._setDomain.call(this,n)},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._logTicks=function(r,n){var i=this,o=this._howManyTicks(r,n);if(o===0)return[];var a=Math.floor(Math.log(r)/Math.log(this._base)),s=Math.ceil(Math.log(n)/Math.log(this._base)),l=r4.range(s,a,-Math.ceil((s-a)/o)),c=r4.range(this._base,1,-(this._base-1)).map(Math.floor),u=TS.Array.uniq(c),h=l.map(function(g){return u.map(function(_){return Math.pow(i._base,g-1)*_})}),f=TS.Array.flatten(h),p=f.filter(function(g){return r<=g&&g<=n}),d=p.sort(function(g,_){return g-_});return d},t.prototype._howManyTicks=function(r,n){var i=this._adjustedLog(TS.Math.min(this._untransformedDomain,0)),o=this._adjustedLog(TS.Math.max(this._untransformedDomain,0)),a=this._adjustedLog(r),s=this._adjustedLog(n),l=(s-a)/(o-i),c=Math.ceil(l*sot.ModifiedLog._DEFAULT_NUM_TICKS);return c},t.prototype._niceDomain=function(r,n){return r},t.prototype._defaultExtent=function(){return[0,this._base]},t.prototype._expandSingleValueDomain=function(r){if(r[0]===r[1]){var n=r[0];return n>0?[n/this._base,n*this._base]:n===0?[-this._base,this._base]:[n*this._base,n/this._base]}return r},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(sot.ModifiedLog._DEFAULT_NUM_TICKS)},t}(xFe.QuantitativeScale);lot.ModifiedLog=bFe});var c$t=H(cot=>{"use strict";Object.defineProperty(cot,"__esModule",{value:!0});var wFe=(de(),Ut(pe)),_a=(Er(),Ut(Mr)),Rv=HF(),SFe=xd(),MFe=function(e){wFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=_a.scaleTime(),r.autoDomain(),r}return t.prototype.tickInterval=function(r,n,i){n===void 0&&(n=1),i===void 0&&(i=!1);var o=_a.scaleTime(),a=t.timeIntervalToD3Time(r,i).every(n);return o.domain(this.domain()),o.range(this.range()),o.ticks(a)},t.prototype._setDomain=function(r){if(r[1]<r[0])throw new Error("Scale.Time domain values must be in chronological order");return e.prototype._setDomain.call(this,r)},t.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]},t.prototype._expandSingleValueDomain=function(r){var n=r[0].getTime(),i=r[1].getTime();if(n===i){var o=new Date(n);o.setDate(o.getDate()-1);var a=new Date(i);return a.setDate(a.getDate()+1),[o,a]}return r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(new Date(r))},t.prototype.invertedTransformation=function(r){return this.invert(r).getTime()},t.prototype.getTransformationExtent=function(){var r=this._getUnboundedExtent(!0);return[r[0].valueOf(),r[1].valueOf()]},t.prototype.getTransformationDomain=function(){var r=this.domain();return[r[0].valueOf(),r[1].valueOf()]},t.prototype.setTransformationDomain=function(r){var n=r[0],i=r[1];this.domain([new Date(n),new Date(i)])},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r){return this._d3Scale.copy().domain(r).nice().domain()},t.timeIntervalToD3Time=function(r,n){switch(r){case Rv.TimeInterval.second:return n?_a.utcSecond:_a.timeSecond;case Rv.TimeInterval.minute:return n?_a.utcMinute:_a.timeMinute;case Rv.TimeInterval.hour:return n?_a.utcHour:_a.timeHour;case Rv.TimeInterval.day:return n?_a.utcDay:_a.timeDay;case Rv.TimeInterval.week:return n?_a.utcWeek:_a.timeWeek;case Rv.TimeInterval.month:return n?_a.utcMonth:_a.timeMonth;case Rv.TimeInterval.year:return n?_a.utcYear:_a.timeYear;default:throw Error("TimeInterval specified does not exist: "+r)}},t}(SFe.QuantitativeScale);cot.Time=MFe});var Rs=H(Hu=>{"use strict";Object.defineProperty(Hu,"__esModule",{value:!0});var Nv=(de(),Ut(pe)),EFe=ZXt();Hu.TickGenerators=EFe;Nv.__exportStar(eot(),Hu);Nv.__exportStar(n$t(),Hu);Nv.__exportStar(o$t(),Hu);Nv.__exportStar(a$t(),Hu);Nv.__exportStar(s$t(),Hu);Nv.__exportStar(l$t(),Hu);Nv.__exportStar(c$t(),Hu);var TFe=eot(),CFe=xd();function AFe(e){return e instanceof CFe.QuantitativeScale||e instanceof TFe.Category}Hu.isTransformable=AFe});var HF=H(Se=>{"use strict";Object.defineProperty(Se,"__esModule",{value:!0});var PFe=(de(),Ut(pe)),Vu=(Er(),Ut(Mr)),u$t=yl(),h$t=Bu(),IFe=Rs(),n4=Fe(),uot=Lf(),es=t4();Se.TimeInterval=uot.makeEnum(["second","minute","hour","day","week","month","year"]);Se.TimeAxisOrientation=uot.makeEnum(["top","bottom"]);Se.TierLabelPosition=uot.makeEnum(["between","center"]);var LFe=function(e){PFe.__extends(t,e);function t(r,n,i){var o=e.call(this,r,n)||this;return o._maxTimeIntervalPrecision=null,o._tierLabelPositions=[],o._useUTC=i,o.addClass("time-axis"),o.tickLabelPadding(5),o.axisConfigurations(t._DEFAULT_TIME_AXIS_CONFIGURATIONS(o._useUTC)),o.annotationFormatter(h$t.time("%a %b %d, %Y",o._useUTC)),o}return t.prototype.tierLabelPositions=function(r){if(r==null)return this._tierLabelPositions;if(!r.every(function(n){return n.toLowerCase()==="between"||n.toLowerCase()==="center"}))throw new Error("Unsupported position for tier labels");return this._tierLabelPositions=r,this.redraw(),this},t.prototype.maxTimeIntervalPrecision=function(r){return r==null?this._maxTimeIntervalPrecision:(this._maxTimeIntervalPrecision=r,this.redraw(),this)},t.prototype.currentAxisConfiguration=function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]},t.prototype.axisConfigurations=function(r){if(r==null)return this._possibleTimeAxisConfigurations;this._possibleTimeAxisConfigurations=r,this._numTiers=n4.Math.max(this._possibleTimeAxisConfigurations.map(function(a){return a.length}),0),this._isAnchored&&this._setupDomElements();for(var n=this.tierLabelPositions(),i=[],o=0;o<this._numTiers;o++)i.push(n[o]||"between");return this.tierLabelPositions(i),this.redraw(),this},t.prototype._getMostPreciseConfigurationIndex=function(){var r=this,n=this._possibleTimeAxisConfigurations.length;return this._possibleTimeAxisConfigurations.forEach(function(i,o){o<n&&i.every(function(a){return r._checkTimeAxisTierConfiguration(a)})&&(n=o)}),n===this._possibleTimeAxisConfigurations.length&&(n4.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--n),n},t.prototype.orientation=function(r){if(r&&(r.toLowerCase()==="right"||r.toLowerCase()==="left"))throw new Error(r+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");return e.prototype.orientation.call(this,r)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;this._tierHeights=[];for(var n=0;n<this._numTiers;n++)this._tierHeights.push(r+this.tickLabelPadding()+(this._tierLabelPositions[n]==="between"?0:this._maxLabelTickLength()));return Vu.sum(this._tierHeights)},t.prototype._getIntervalLength=function(r){var n=this._scale.domain()[0],i=IFe.Time.timeIntervalToD3Time(r.interval,this._useUTC),o=i.offset(n,r.step);if(o>this._scale.domain()[1])return this.width();var a=Math.abs(this._scale.scale(o)-this._scale.scale(n));return a},t.prototype._maxWidthForInterval=function(r){return this._measurer.measure(r.formatter(t._LONG_DATE)).width},t.prototype._checkTimeAxisTierConfiguration=function(r){if(this._maxTimeIntervalPrecision!=null){var n=t._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],i=t._SORTED_TIME_INTERVAL_INDEX[r.interval];if(n!=null&&i!=null&&i<n)return!1}var o=this._maxWidthForInterval(r)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(r),this.width())>=o},t.prototype._sizeFromOffer=function(r,n){var i=e.prototype._sizeFromOffer.call(this,r,n),o=this._tierHeights.reduce(function(s,l,c,u){return s+l>i.height?s:s+l}),a=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);return i.height=Math.min(i.height,o+a),i},t.prototype._setup=function(){e.prototype._setup.call(this),this._setupDomElements()},t.prototype._setupDomElements=function(){this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).remove(),this._tierLabelContainers=[],this._tierMarkContainers=[],this._tierBaselines=[],this._tickLabelContainer.remove(),this._baseline.remove();for(var r=0;r<this._numTiers;++r){var n=this.content().append("g").classed(t.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(n.append("g").classed(es.Axis.TICK_LABEL_CLASS+"-container",!0)),this._tierMarkContainers.push(n.append("g").classed(es.Axis.TICK_MARK_CLASS+"-container",!0)),this._tierBaselines.push(n.append("line").classed("baseline",!0))}var i=new u$t.SvgContext(this._tierLabelContainers[0].node());this._measurer=new u$t.CacheMeasurer(i)},t.prototype._getTickIntervalValues=function(r){return this._scale.tickInterval(r.interval,r.step,this._useUTC)},t.prototype._getTickValues=function(){var r=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(n,i){return n.concat(r._getTickIntervalValues(i))},[])},t.prototype._cleanTiers=function(){for(var r=0;r<this._tierLabelContainers.length;r++)this._tierLabelContainers[r].selectAll("."+es.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[r].selectAll("."+es.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[r].style("visibility","hidden")},t.prototype._getTickValuesForConfiguration=function(r){var n=this._scale.tickInterval(r.interval,r.step,this._useUTC),i=this._scale.domain(),o=n.map(function(a){return a.valueOf()});return o.indexOf(i[0].valueOf())===-1&&n.unshift(i[0]),o.indexOf(i[1].valueOf())===-1&&n.push(i[1]),n},t.prototype._renderTierLabels=function(r,n,i){var o=this,a=this._getTickValuesForConfiguration(n),s=[];this._tierLabelPositions[i]==="between"&&n.step===1?a.map(function(g,_){_+1>=a.length||s.push(new Date((a[_+1].valueOf()-a[_].valueOf())/2+a[_].valueOf()))}):s=a;var l=r.selectAll("."+es.Axis.TICK_LABEL_CLASS).data(s,function(g){return String(g.valueOf())}),c=l.enter().append("g").classed(es.Axis.TICK_LABEL_CLASS,!0);c.append("text");var u=this._tierLabelPositions[i]==="center"||n.step===1?0:this.tickLabelPadding(),h;this.orientation()==="bottom"?h=Vu.sum(this._tierHeights.slice(0,i+1))-this.tickLabelPadding():this._tierLabelPositions[i]==="center"?h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding()-this._maxLabelTickLength():h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding();var f=l.merge(c),p=f.selectAll("text");p.size()>0&&p.attr("transform","translate("+u+","+h+")"),l.exit().remove(),f.attr("transform",function(g){return"translate("+o._scale.scale(g)+",0)"});var d=this._tierLabelPositions[i]==="center"||n.step===1?"middle":"start";f.selectAll("text").text(n.formatter).style("text-anchor",d)},t.prototype._renderTickMarks=function(r,n){var i=this._tierMarkContainers[n].selectAll("."+es.Axis.TICK_MARK_CLASS).data(r),o=i.enter().append("line").classed(es.Axis.TICK_MARK_CLASS,!0).merge(i),a=this._generateTickMarkAttrHash(),s=this._tierHeights.slice(0,n).reduce(function(l,c){return l+c},0);this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n]))),o.attrs(a),this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n]))),Vu.select(o.nodes()[0]).attrs(a),Vu.select(o.nodes()[o.size()-1]).attrs(a),Vu.select(o.nodes()[0]).classed(es.Axis.END_TICK_MARK_CLASS,!0),Vu.select(o.nodes()[o.size()-1]).classed(es.Axis.END_TICK_MARK_CLASS,!0),i.exit().remove()},t.prototype._renderLabellessTickMarks=function(r){var n=this._tickMarkContainer.selectAll("."+es.Axis.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(es.Axis.TICK_MARK_CLASS,!0).merge(n),o=this._generateTickMarkAttrHash();o.y2=this.orientation()==="bottom"?this.tickLabelPadding():this.height()-this.tickLabelPadding(),i.attrs(o),n.exit().remove()},t.prototype._generateLabellessTicks=function(){return this._mostPreciseConfigIndex<1?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-1][0])},t.prototype.renderImmediately=function(){var r=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var n=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers(),n.forEach(function(h,f){return r._renderTierLabels(r._tierLabelContainers[f],h,f)});for(var i=n.map(function(h,f){return r._getTickValuesForConfiguration(h)}),o=0,a=0;a<Math.max(n.length,1);++a){var s=this._generateBaselineAttrHash();s.y1+=this.orientation()==="bottom"?o:-o,s.y2=s.y1,this._tierBaselines[a].attrs(s).style("visibility","inherit"),o+=this._tierHeights[a]}var l=[],c=this._scale.domain(),u=this._scale.scale(c[1])-this._scale.scale(c[0]);this._getIntervalLength(n[0])*1.5>=u&&(l=this._generateLabellessTicks()),this._renderLabellessTickMarks(l),this._hideOverflowingTiers();for(var a=0;a<n.length;++a)this._renderTickMarks(i[a],a),this._hideOverlappingAndCutOffLabels(a);return this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype._hideOverflowingTiers=function(){var r=this,n=this.height(),i=0;this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).attr("visibility",function(o,a){return i+=r._tierHeights[a],i<=n?"inherit":"hidden"})},t.prototype._hideOverlappingAndCutOffLabels=function(r){var n=this,i=this.element().node().getBoundingClientRect(),o=function(u){return Math.floor(i.left)<=Math.ceil(u.left)&&Math.floor(i.top)<=Math.ceil(u.top)&&Math.floor(u.right)<=Math.ceil(i.left+n.width())&&Math.floor(u.bottom)<=Math.ceil(i.top+n.height())},a=this._tierMarkContainers[r].selectAll("."+es.Axis.TICK_MARK_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),s=a.nodes().map(function(u){return u.getBoundingClientRect()}),l=this._tierLabelContainers[r].selectAll("."+es.Axis.TICK_LABEL_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),c;l.each(function(u,h){var f=this.getBoundingClientRect(),p=Vu.select(this),d=s[h],g=s[h+1],_=c!=null&&n4.DOM.clientRectsOverlap(f,c),y=d!=null&&n4.DOM.clientRectsOverlap(f,d),x=g!=null&&n4.DOM.clientRectsOverlap(f,g);!o(f)||_||y||x?p.style("visibility","hidden"):(c=f,p.style("visibility","inherit"))})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.TIME_AXIS_TIER_CLASS="time-axis-tier",t._SORTED_TIME_INTERVAL_INDEX=(bd={},bd[Se.TimeInterval.second]=0,bd[Se.TimeInterval.minute]=1,bd[Se.TimeInterval.hour]=2,bd[Se.TimeInterval.day]=3,bd[Se.TimeInterval.week]=4,bd[Se.TimeInterval.month]=5,bd[Se.TimeInterval.year]=6,bd),t._DEFAULT_TIME_AXIS_CONFIGURATIONS=function(r){var n=function(i){return h$t.time(i,r)};return[[{interval:Se.TimeInterval.second,step:1,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:5,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:10,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:15,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:30,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:1,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:5,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:10,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:15,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:30,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:1,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:3,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:6,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:12,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%a %e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%B")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:3,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:6,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%y")}],[{interval:Se.TimeInterval.year,step:5,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:25,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:50,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:100,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:200,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:500,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1e3,formatter:n("%Y")}]]},t._LONG_DATE=new Date(9999,8,29,12,59,9999),t}(es.Axis);Se.Time=LFe;var bd});var f$t=H(i4=>{"use strict";Object.defineProperty(i4,"__esModule",{value:!0});var hot=(de(),Ut(pe));hot.__exportStar($Xt(),i4);hot.__exportStar(KXt(),i4);hot.__exportStar(HF(),i4)});var o4=H(fot=>{"use strict";Object.defineProperty(fot,"__esModule",{value:!0});var kFe=Fe(),RFe=function(){function e(){this._eventToProcessingFunction={},this._eventTarget=document,this._eventNameToCallbackSet={},this._connected=!1}return e.prototype._hasNoCallbacks=function(){for(var t=Object.keys(this._eventNameToCallbackSet),r=0;r<t.length;r++)if(this._eventNameToCallbackSet[t[r]].size!==0)return!1;return!0},e.prototype._connect=function(){var t=this;this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r],i=r==="wheel"?{passive:!1}:void 0;t._eventTarget.addEventListener(r,n,i)}),this._connected=!0)},e.prototype._disconnect=function(){var t=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r];t._eventTarget.removeEventListener(r,n)}),this._connected=!1)},e.prototype._addCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]==null&&(this._eventNameToCallbackSet[t]=new kFe.CallbackSet),this._eventNameToCallbackSet[t].add(r),this._connect()},e.prototype._removeCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]!=null&&this._eventNameToCallbackSet[t].delete(r),this._disconnect()},e.prototype._callCallbacksForEvent=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=this._eventNameToCallbackSet[t];i!=null&&i.callCallbacks.apply(i,r)},e}();fot.Dispatcher=RFe});var p$t=H(pot=>{"use strict";Object.defineProperty(pot,"__esModule",{value:!0});var NFe=(de(),Ut(pe)),DFe=o4(),OFe=function(e){NFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._eventToProcessingFunction[t._KEYDOWN_EVENT_NAME]=function(n){return r._processKeydown(n)},r._eventToProcessingFunction[t._KEYUP_EVENT_NAME]=function(n){return r._processKeyup(n)},r}return t.getDispatcher=function(){var r=document[t._DISPATCHER_KEY];return r==null&&(r=new t,document[t._DISPATCHER_KEY]=r),r},t.prototype._processKeydown=function(r){this._callCallbacksForEvent(t._KEYDOWN_EVENT_NAME,r.keyCode,r)},t.prototype._processKeyup=function(r){this._callCallbacksForEvent(t._KEYUP_EVENT_NAME,r.keyCode,r)},t.prototype.onKeyDown=function(r){return this._addCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.offKeyDown=function(r){return this._removeCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.onKeyUp=function(r){return this._addCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t.prototype.offKeyUp=function(r){return this._removeCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t._DISPATCHER_KEY="__Plottable_Dispatcher_Key",t._KEYDOWN_EVENT_NAME="keydown",t._KEYUP_EVENT_NAME="keyup",t}(DFe.Dispatcher);pot.Key=OFe});var m$t=H(dot=>{"use strict";Object.defineProperty(dot,"__esModule",{value:!0});var zFe=(de(),Ut(pe)),d$t=Fe(),FFe=o4(),BFe=function(e){zFe.__extends(t,e);function t(r){var n=e.call(this)||this;n._lastMousePosition={x:-1,y:-1},n._translator=d$t.getTranslator(r);var i=function(o){return n._measureAndDispatch(r,o,t._MOUSEMOVE_EVENT_NAME,"page")};return n._eventToProcessingFunction[t._MOUSEOVER_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEMOVE_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEOUT_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEDOWN_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEDOWN_EVENT_NAME)},n._eventToProcessingFunction[t._MOUSEUP_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEUP_EVENT_NAME,"page")},n._eventToProcessingFunction[t._WHEEL_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._WHEEL_EVENT_NAME)},n._eventToProcessingFunction[t._DBLCLICK_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._DBLCLICK_EVENT_NAME)},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onMouseMove=function(r){return this._addCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.offMouseMove=function(r){return this._removeCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.onMouseDown=function(r){return this._addCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.offMouseDown=function(r){return this._removeCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.onMouseUp=function(r){return this._addCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.offMouseUp=function(r){return this._removeCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.onWheel=function(r){return this._addCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.offWheel=function(r){return this._removeCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.onDblClick=function(r){return this._addCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype.offDblClick=function(r){return this._removeCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(o==="page"||this.eventInside(r,n)){var a=this._translator.computePosition(n.clientX,n.clientY);this._lastMousePosition=a,this._callCallbacksForEvent(i,this.lastMousePosition(),n)}},t.prototype.eventInside=function(r,n){return d$t.Translator.isEventInside(r,n)},t.prototype.lastMousePosition=function(){return this._lastMousePosition},t._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse",t._MOUSEOVER_EVENT_NAME="mouseover",t._MOUSEMOVE_EVENT_NAME="mousemove",t._MOUSEOUT_EVENT_NAME="mouseout",t._MOUSEDOWN_EVENT_NAME="mousedown",t._MOUSEUP_EVENT_NAME="mouseup",t._WHEEL_EVENT_NAME="wheel",t._DBLCLICK_EVENT_NAME="dblclick",t}(FFe.Dispatcher);dot.Mouse=BFe});var _$t=H(mot=>{"use strict";Object.defineProperty(mot,"__esModule",{value:!0});var HFe=(de(),Ut(pe)),g$t=Fe(),VFe=o4(),UFe=function(e){HFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._translator=g$t.getTranslator(r),n._eventToProcessingFunction[t._TOUCHSTART_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHSTART_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHMOVE_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHMOVE_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHEND_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHEND_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHCANCEL_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHCANCEL_EVENT_NAME,"page")},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onTouchStart=function(r){return this._addCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.offTouchStart=function(r){return this._removeCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.onTouchMove=function(r){return this._addCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.offTouchMove=function(r){return this._removeCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.onTouchEnd=function(r){return this._addCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.offTouchEnd=function(r){return this._removeCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.onTouchCancel=function(r){return this._addCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype.offTouchCancel=function(r){return this._removeCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(!(o==="element"&&!this.eventInside(r,n))){for(var a=n.changedTouches,s={},l=[],c=0;c<a.length;c++){var u=a[c],h=u.identifier,f=this._translator.computePosition(u.clientX,u.clientY);f!=null&&(s[h]=f,l.push(h))}l.length>0&&this._callCallbacksForEvent(i,l,s,n)}},t.prototype.eventInside=function(r,n){return g$t.Translator.isEventInside(r,n)},t._DISPATCHER_KEY="__Plottable_Dispatcher_Touch",t._TOUCHSTART_EVENT_NAME="touchstart",t._TOUCHMOVE_EVENT_NAME="touchmove",t._TOUCHEND_EVENT_NAME="touchend",t._TOUCHCANCEL_EVENT_NAME="touchcancel",t}(VFe.Dispatcher);mot.Touch=UFe});var Dv=H(a4=>{"use strict";Object.defineProperty(a4,"__esModule",{value:!0});var got=(de(),Ut(pe));got.__exportStar(p$t(),a4);got.__exportStar(m$t(),a4);got.__exportStar(_$t(),a4)});var Ov=H(_ot=>{"use strict";Object.defineProperty(_ot,"__esModule",{value:!0});var qFe=function(){function e(){var t=this;this._anchorCallback=function(r){return t._anchor(r)},this._enabled=!0}return e.prototype.attachTo=function(t){return this._disconnect(),this._componentAttachedTo=t,this._connect(),this},e.prototype.detachFrom=function(t){return this.detach()},e.prototype.detach=function(){return this._disconnect(),this._componentAttachedTo=null,this},e.prototype.enabled=function(t){return t==null?this._enabled:(this._enabled=t,this._enabled?this._connect():this._disconnect(),this)},e.prototype._anchor=function(t){this._isAnchored=!0},e.prototype._unanchor=function(){this._isAnchored=!1},e.prototype._translateToComponentSpace=function(t){var r=this._componentAttachedTo.originToRoot();return{x:t.x-r.x,y:t.y-r.y}},e.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<=this._componentAttachedTo.width()&&t.y<=this._componentAttachedTo.height()},e.prototype._connect=function(){this.enabled()&&this._componentAttachedTo!=null&&!this._isAnchored&&this._componentAttachedTo.onAnchor(this._anchorCallback)},e.prototype._disconnect=function(){this._isAnchored&&this._unanchor(),this._componentAttachedTo!=null&&this._componentAttachedTo.offAnchor(this._anchorCallback)},e}();_ot.Interaction=qFe});var x$t=H(yot=>{"use strict";Object.defineProperty(yot,"__esModule",{value:!0});var GFe=(de(),Ut(pe)),y$t=Dv(),v$t=Fe(),WFe=Ov(),YFe=function(e){GFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._clickedDown=!1,r._doubleClicking=!1,r._onClickCallbacks=new v$t.CallbackSet,r._onDoubleClickCallbacks=new v$t.CallbackSet,r._mouseDownCallback=function(n,i){return r._handleClickDown(n,i)},r._mouseUpCallback=function(n,i){return r._handleClickUp(n,i)},r._dblClickCallback=function(n,i){return r._handleDblClick(n,i)},r._touchStartCallback=function(n,i,o){return r._handleClickDown(i[n[0]],o)},r._touchEndCallback=function(n,i,o){return r._handleClickUp(i[n[0]],o)},r._touchCancelCallback=function(n,i){return r._clickedDown=!1},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=y$t.Mouse.getDispatcher(r),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._mouseDispatcher.onDblClick(this._dblClickCallback),this._touchDispatcher=y$t.Touch.getDispatcher(r),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher.offDblClick(this._dblClickCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null},t.prototype._handleClickDown=function(r,n){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(this._clickedDown=!0,this._clickedPoint=i)},t.prototype._handleClickUp=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._clickedDown&&t._pointsEqual(o,this._clickedPoint)&&setTimeout(function(){i._doubleClicking||i._onClickCallbacks.callCallbacks(o,n)},0),this._clickedDown=!1},t.prototype._handleDblClick=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._doubleClicking=!0,this._onDoubleClickCallbacks.callCallbacks(o,n),setTimeout(function(){return i._doubleClicking=!1},0)},t._pointsEqual=function(r,n){return r.x===n.x&&r.y===n.y},t.prototype.onClick=function(r){return this._onClickCallbacks.add(r),this},t.prototype.offClick=function(r){return this._onClickCallbacks.delete(r),this},t.prototype.onDoubleClick=function(r){return this._onDoubleClickCallbacks.add(r),this},t.prototype.offDoubleClick=function(r){return this._onDoubleClickCallbacks.delete(r),this},t}(WFe.Interaction);yot.Click=YFe});var w$t=H(vot=>{"use strict";Object.defineProperty(vot,"__esModule",{value:!0});var jFe=(de(),Ut(pe)),b$t=Dv(),s4=Fe(),XFe=Ov(),$Fe=function(e){jFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._dragging=!1,n._constrainedToComponent=!0,n._mouseFilter=t._DEFAULT_MOUSE_FILTER,n._dragStartCallbacks=new s4.CallbackSet,n._dragCallbacks=new s4.CallbackSet,n._dragEndCallbacks=new s4.CallbackSet,n._mouseDownCallback=function(i,o){return n._startDrag(i,o)},n._mouseMoveCallback=function(i,o){return n._doDrag(i,o)},n._mouseUpCallback=function(i,o){return n._endDrag(i,o)},n._touchStartCallback=function(i,o,a){return n._startDrag(o[i[0]],a)},n._touchMoveCallback=function(i,o,a){return n._doDrag(o[i[0]],a)},n._touchEndCallback=function(i,o,a){return n._endDrag(o[i[0]],a)},n._mouseButton=r!==void 0?r:0,n}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=b$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._touchDispatcher=b$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher=null},t.prototype._translateAndConstrain=function(r){var n=this._translateToComponentSpace(r);return this._constrainedToComponent?{x:s4.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:s4.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n},t.prototype._startDrag=function(r,n){if(!(n instanceof MouseEvent&&!this._mouseFilter(n))){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(n.preventDefault(),this._dragging=!0,this._dragOrigin=i,this._dragStartCallbacks.callCallbacks(this._dragOrigin))}},t.prototype._doDrag=function(r,n){this._dragging&&this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r))},t.prototype._endDrag=function(r,n){n instanceof MouseEvent&&n.button!==this._mouseButton||this._dragging&&(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r)))},t.prototype.constrainedToComponent=function(r){return r==null?this._constrainedToComponent:(this._constrainedToComponent=r,this)},t.prototype.mouseFilter=function(r){return arguments.length===0?this._mouseFilter:(this._mouseFilter=r,this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t._DEFAULT_MOUSE_FILTER=function(r){return r.button===0},t}(XFe.Interaction);vot.Drag=$Fe});var wot=H(bot=>{"use strict";Object.defineProperty(bot,"__esModule",{value:!0});var KFe=(de(),Ut(pe)),S$t=Dv(),xot=Fe(),ZFe=Ov(),JFe=function(e){KFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._keyPressCallbacks={},r._keyReleaseCallbacks={},r._mouseMoveCallback=function(n){return!1},r._downedKeys=new xot.Set,r._keyDownCallback=function(n,i){return r._handleKeyDownEvent(n,i)},r._keyUpCallback=function(n){return r._handleKeyUpEvent(n)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._positionDispatcher=S$t.Mouse.getDispatcher(this._componentAttachedTo),this._positionDispatcher.onMouseMove(this._mouseMoveCallback),this._keyDispatcher=S$t.Key.getDispatcher(),this._keyDispatcher.onKeyDown(this._keyDownCallback),this._keyDispatcher.onKeyUp(this._keyUpCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._positionDispatcher.offMouseMove(this._mouseMoveCallback),this._positionDispatcher=null,this._keyDispatcher.offKeyDown(this._keyDownCallback),this._keyDispatcher.offKeyUp(this._keyUpCallback),this._keyDispatcher=null},t.prototype._handleKeyDownEvent=function(r,n){var i=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(i)&&!n.repeat&&(this._keyPressCallbacks[r]&&this._keyPressCallbacks[r].callCallbacks(r),this._downedKeys.add(r))},t.prototype._handleKeyUpEvent=function(r){this._downedKeys.has(r)&&this._keyReleaseCallbacks[r]&&this._keyReleaseCallbacks[r].callCallbacks(r),this._downedKeys.delete(r)},t.prototype.onKeyPress=function(r,n){return this._keyPressCallbacks[r]||(this._keyPressCallbacks[r]=new xot.CallbackSet),this._keyPressCallbacks[r].add(n),this},t.prototype.offKeyPress=function(r,n){return this._keyPressCallbacks[r].delete(n),this._keyPressCallbacks[r].size===0&&delete this._keyPressCallbacks[r],this},t.prototype.onKeyRelease=function(r,n){return this._keyReleaseCallbacks[r]||(this._keyReleaseCallbacks[r]=new xot.CallbackSet),this._keyReleaseCallbacks[r].add(n),this},t.prototype.offKeyRelease=function(r,n){return this._keyReleaseCallbacks[r].delete(n),this._keyReleaseCallbacks[r].size===0&&delete this._keyReleaseCallbacks[r],this},t}(ZFe.Interaction);bot.Key=JFe});var C$t=H(Sot=>{"use strict";Object.defineProperty(Sot,"__esModule",{value:!0});var QFe=(de(),Ut(pe)),tBe=(Er(),Ut(Mr)),M$t=Dv(),E$t=Rs(),vl=Fe(),eBe=l4(),rBe=Ov(),T$t=e4(),nBe=function(e){QFe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i._wheelFilter=function(o){return!0},i._wheelCallback=function(o,a){return i._handleWheelEvent(o,a)},i._touchStartCallback=function(o,a,s){return i._handleTouchStart(o,a,s)},i._touchMoveCallback=function(o,a,s){return i._handlePinch(o,a,s)},i._touchEndCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._touchCancelCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._panEndCallbacks=new vl.CallbackSet,i._zoomEndCallbacks=new vl.CallbackSet,i._panZoomUpdateCallbacks=new vl.CallbackSet,i._xScales=new vl.Set,i._yScales=new vl.Set,i._dragInteraction=new eBe.Drag,i._setupDragInteraction(),i._touchIds=tBe.map(),i._minDomainExtents=new vl.Map,i._maxDomainExtents=new vl.Map,i._minDomainValues=new vl.Map,i._maxDomainValues=new vl.Map,r!=null&&i.addXScale(r),n!=null&&i.addYScale(n),i}return t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.wheelFilter=function(r){return arguments.length===0?this._wheelFilter:(this._wheelFilter=r,this)},t.prototype.pan=function(r){var n=this;this.xScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.x))}),this.yScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.y))}),this._panZoomUpdateCallbacks.callCallbacks()},t.prototype.zoom=function(r,n,i){var o=this;i===void 0&&(i=!0);var a,s;return n!=null&&(a=n.x,s=n.y,i&&(this.xScales().forEach(function(l){var c=o._constrainedZoom(l,r,a);a=c.centerPoint,r=c.zoomAmount}),this.yScales().forEach(function(l){var c=o._constrainedZoom(l,r,s);s=c.centerPoint,r=c.zoomAmount}))),this.xScales().forEach(function(l){var c=l.range(),u=a==null?(c[1]+c[0])/2:a;l.zoom(r,u)}),this.yScales().forEach(function(l){var c=l.range(),u=s==null?(c[1]+c[0])/2:s;l.zoom(r,u)}),this._panZoomUpdateCallbacks.callCallbacks(),{zoomAmount:r,centerValue:{centerX:a,centerY:s}}},t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._dragInteraction.attachTo(r),this._mouseDispatcher=M$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onWheel(this._wheelCallback),this._touchDispatcher=M$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offWheel(this._wheelCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null,this._dragInteraction.detach()},t.prototype._handleTouchStart=function(r,n,i){for(var o=0;o<r.length&&this._touchIds.size()<2;o++){var a=r[o];this._touchIds.set(a.toString(),this._translateToComponentSpace(n[a]))}},t.prototype._handlePinch=function(r,n,i){var o=this;if(!(this._touchIds.size()<2)){var a=this._touchIds.values();if(!(!this._isInsideComponent(this._translateToComponentSpace(a[0]))||!this._isInsideComponent(this._translateToComponentSpace(a[1])))){var s=t._pointDistance(a[0],a[1]);if(s!==0){r.forEach(function(S){o._touchIds.has(S.toString())&&o._touchIds.set(S.toString(),o._translateToComponentSpace(n[S]))});var l=this._touchIds.values(),c=t._pointDistance(l[0],l[1]);if(c!==0){var u=s/c,h=l.map(function(S,C){return{x:(S.x-a[C].x)/u,y:(S.y-a[C].y)/u}}),f=t.centerPoint(a[0],a[1]),p=this.zoom(u,f),d=p.centerValue,g=p.zoomAmount,_=d.centerX,y=d.centerY,x=a.map(function(S,C){return{x:h[C].x*g+S.x,y:h[C].y*g+S.y}}),b={x:_-(x[0].x+x[1].x)/2,y:y-(x[0].y+x[1].y)/2};this.pan(b)}}}}},t.centerPoint=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return{x:(i+o)/2,y:(s+a)/2}},t._pointDistance=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return Math.sqrt(Math.pow(o-i,2)+Math.pow(s-a,2))},t.prototype._handleTouchEnd=function(r,n,i){var o=this;r.forEach(function(a){o._touchIds.remove(a.toString())}),this._touchIds.size()>0&&this._zoomEndCallbacks.callCallbacks()},t.prototype._handleWheelEvent=function(r,n){if(!!this._wheelFilter(n)){var i=this._translateToComponentSpace(r);if(this._isInsideComponent(i)){n.preventDefault();var o=n.deltaY!==0?n.deltaY:n.deltaX,a=o*(n.deltaMode?t._PIXELS_PER_LINE:1),s=Math.pow(2,a*.002);this.zoom(s,i),this._zoomEndCallbacks.callCallbacks()}}},t.prototype._constrainedZoom=function(r,n,i){return T$t.constrainedZoom(r,n,i,this.minDomainExtent(r),this.maxDomainExtent(r),this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._constrainedTranslation=function(r,n){return T$t.constrainedTranslation(r,n,this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._setupDragInteraction=function(){var r=this;this._dragInteraction.constrainedToComponent(!1);var n;this._dragInteraction.onDragStart(function(){return n=null}),this._dragInteraction.onDrag(function(i,o){if(!(r._touchIds.size()>=2)){var a={x:(n==null?i.x:n.x)-o.x,y:(n==null?i.y:n.y)-o.y};r.pan(a),n=o}}),this._dragInteraction.onDragEnd(function(){return r._panEndCallbacks.callCallbacks()})},t.prototype._nonLinearScaleWithExtents=function(r){return this.minDomainExtent(r)!=null&&this.maxDomainExtent(r)!=null&&!(r instanceof E$t.Linear)&&!(r instanceof E$t.Time)},t.prototype.xScales=function(r){var n=this;if(r==null){var i=[];return this._xScales.forEach(function(o){i.push(o)}),i}return this._xScales=new vl.Set,r.forEach(function(o){n.addXScale(o)}),this},t.prototype.yScales=function(r){var n=this;if(r==null){var i=[];return this._yScales.forEach(function(o){i.push(o)}),i}return this._yScales=new vl.Set,r.forEach(function(o){n.addYScale(o)}),this},t.prototype.addXScale=function(r){return this._xScales.add(r),this},t.prototype.removeXScale=function(r){return this._xScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.addYScale=function(r){return this._yScales.add(r),this},t.prototype.removeYScale=function(r){return this._yScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.minDomainExtent=function(r,n){if(n==null)return this._minDomainExtents.get(r);if(n.valueOf()<0)throw new Error("extent must be non-negative");var i=this.maxDomainExtent(r);if(i!=null&&i.valueOf()<n.valueOf())throw new Error("minDomainExtent must be smaller than maxDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&vl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._minDomainExtents.set(r,n),this},t.prototype.maxDomainExtent=function(r,n){if(n==null)return this._maxDomainExtents.get(r);if(n.valueOf()<=0)throw new Error("extent must be positive");var i=this.minDomainExtent(r);if(i!=null&&n.valueOf()<i.valueOf())throw new Error("maxDomainExtent must be larger than minDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&vl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._maxDomainExtents.set(r,n),this},t.prototype.minDomainValue=function(r,n){return n==null?this._minDomainValues.get(r):(this._minDomainValues.set(r,n),this)},t.prototype.maxDomainValue=function(r,n){return n==null?this._maxDomainValues.get(r):(this._maxDomainValues.set(r,n),this)},t.prototype.setMinMaxDomainValuesTo=function(r){this._minDomainValues.delete(r),this._maxDomainValues.delete(r);var n=r.getTransformationDomain(),i=n[0],o=n[1];return this.minDomainValue(r,i),this.maxDomainValue(r,o),this},t.prototype.onPanEnd=function(r){return this._panEndCallbacks.add(r),this},t.prototype.offPanEnd=function(r){return this._panEndCallbacks.delete(r),this},t.prototype.onZoomEnd=function(r){return this._zoomEndCallbacks.add(r),this},t.prototype.offZoomEnd=function(r){return this._zoomEndCallbacks.delete(r),this},t.prototype.onPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.add(r),this},t.prototype.offPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.delete(r),this},t._PIXELS_PER_LINE=120,t}(rBe.Interaction);Sot.PanZoom=nBe});var P$t=H(Eot=>{"use strict";Object.defineProperty(Eot,"__esModule",{value:!0});var iBe=(de(),Ut(pe)),A$t=Dv(),Mot=Fe(),oBe=Ov(),aBe=function(e){iBe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._overComponent=!1,r._pointerEnterCallbacks=new Mot.CallbackSet,r._pointerMoveCallbacks=new Mot.CallbackSet,r._pointerExitCallbacks=new Mot.CallbackSet,r._mouseMoveCallback=function(n,i){return r._handleMouseEvent(n,i)},r._touchStartCallback=function(n,i,o){return r._handleTouchEvent(i[n[0]],o)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=A$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._touchDispatcher=A$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher=null},t.prototype._handleMouseEvent=function(r,n){var i=this._mouseDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handleTouchEvent=function(r,n){var i=this._touchDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handlePointerEvent=function(r,n){var i=this._translateToComponentSpace(r),o=this._isInsideComponent(i);o&&n?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(i),this._pointerMoveCallbacks.callCallbacks(i)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(i),this._overComponent=o&&n},t.prototype.onPointerEnter=function(r){return this._pointerEnterCallbacks.add(r),this},t.prototype.offPointerEnter=function(r){return this._pointerEnterCallbacks.delete(r),this},t.prototype.onPointerMove=function(r){return this._pointerMoveCallbacks.add(r),this},t.prototype.offPointerMove=function(r){return this._pointerMoveCallbacks.delete(r),this},t.prototype.onPointerExit=function(r){return this._pointerExitCallbacks.add(r),this},t.prototype.offPointerExit=function(r){return this._pointerExitCallbacks.delete(r),this},t}(oBe.Interaction);Eot.Pointer=aBe});var l4=H(Jg=>{"use strict";Object.defineProperty(Jg,"__esModule",{value:!0});var c4=(de(),Ut(pe));c4.__exportStar(x$t(),Jg);c4.__exportStar(w$t(),Jg);c4.__exportStar(wot(),Jg);c4.__exportStar(C$t(),Jg);c4.__exportStar(P$t(),Jg);var sBe=e4();Jg.zoomOut=sBe.zoomOut});var Tot=H(u4=>{"use strict";Object.defineProperty(u4,"__esModule",{value:!0});var lBe=(de(),Ut(pe)),VF=Fe(),cBe=kc(),rs;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(rs=u4.PropertyMode||(u4.PropertyMode={}));var uBe=function(e){lBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._boxVisible=!1,r._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}},r._xBoundsMode=rs.PIXEL,r._yBoundsMode=rs.PIXEL,r.addClass("selection-box-layer"),r._adjustBoundsCallback=function(){r.render()},r._overflowHidden=!0,r._xExtent=[void 0,void 0],r._yExtent=[void 0,void 0],r}return t.prototype._setup=function(){e.prototype._setup.call(this),this._box=this.content().append("g").classed("selection-box",!0).remove(),this._boxArea=this._box.append("rect").classed("selection-area",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.bounds=function(r){return r==null?this._getBounds():(this._setBounds(r),this._xBoundsMode=rs.PIXEL,this._yBoundsMode=rs.PIXEL,this.render(),this)},t.prototype._setBounds=function(r){var n={x:Math.min(r.topLeft.x,r.bottomRight.x),y:Math.min(r.topLeft.y,r.bottomRight.y)},i={x:Math.max(r.topLeft.x,r.bottomRight.x),y:Math.max(r.topLeft.y,r.bottomRight.y)};this._boxBounds={topLeft:n,bottomRight:i}},t.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===rs.PIXEL?this._boxBounds.topLeft.x:this._xScale==null?0:Math.min(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===rs.PIXEL?this._boxBounds.topLeft.y:this._yScale==null?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===rs.PIXEL?this._boxBounds.bottomRight.x:this._xScale==null?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===rs.PIXEL?this._boxBounds.bottomRight.y:this._yScale==null?0:Math.max(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))}}},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this._boxVisible){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;if(!(VF.Math.isValidNumber(n)&&VF.Math.isValidNumber(i)&&VF.Math.isValidNumber(o)&&VF.Math.isValidNumber(a)))throw new Error("bounds have not been properly set");this._boxArea.attrs({x:o,y:n,width:a-o,height:i-n}),this.content().node().appendChild(this._box.node())}else this._box.remove();return this},t.prototype.boxVisible=function(r){return r==null?this._boxVisible:(this._boxVisible=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.xScale=function(r){return r==null?this._xScale:(this._xScale!=null&&this._xScale.offUpdate(this._adjustBoundsCallback),this._xScale=r,this._xBoundsMode=rs.VALUE,this._xScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.yScale=function(r){return r==null?this._yScale:(this._yScale!=null&&this._yScale.offUpdate(this._adjustBoundsCallback),this._yScale=r,this._yBoundsMode=rs.VALUE,this._yScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.xExtent=function(r){return r==null?this._getXExtent():(this._setXExtent(r),this._xBoundsMode=rs.VALUE,this.render(),this)},t.prototype._getXExtent=function(){return this._xBoundsMode===rs.VALUE?this._xExtent:this._xScale==null?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]},t.prototype._setXExtent=function(r){this._xExtent=r},t.prototype.yExtent=function(r){return r==null?this._getYExtent():(this._setYExtent(r),this._yBoundsMode=rs.VALUE,this.render(),this)},t.prototype._getYExtent=function(){return this._yBoundsMode===rs.VALUE?this._yExtent:this._yScale==null?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]},t.prototype._setYExtent=function(r){this._yExtent=r},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._xScale!=null&&this.xScale().offUpdate(this._adjustBoundsCallback),this._yScale!=null&&this.yScale().offUpdate(this._adjustBoundsCallback)},t}(cBe.Component);u4.SelectionBoxLayer=uBe});var qF=H(Aot=>{"use strict";Object.defineProperty(Aot,"__esModule",{value:!0});var hBe=(de(),Ut(pe)),fBe=l4(),Cot=Fe(),pBe=jg(),UF=Pot(),dBe=Tot(),mBe=function(e){hBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detectionRadius=3,r._resizable=!1,r._movable=!1,r._hasCorners=!0,r.addClass("drag-box-layer"),r._dragInteraction=new fBe.Drag,r._setUpCallbacks(),r._dragInteraction.attachTo(r),r._dragStartCallbacks=new Cot.CallbackSet,r._dragCallbacks=new Cot.CallbackSet,r._dragEndCallbacks=new Cot.CallbackSet,r}return t.prototype._setUpCallbacks=function(){var r=this,n,i,o,a,s={newBox:0,resize:1,move:2},l=s.newBox,c=function(f){n=r._getResizingEdges(f);var p=r.bounds(),d=p.topLeft.x<=f.x&&f.x<=p.bottomRight.x&&p.topLeft.y<=f.y&&f.y<=p.bottomRight.y;r.boxVisible()&&(n.top||n.bottom||n.left||n.right)?l=s.resize:r.boxVisible()&&r.movable()&&d?l=s.move:(l=s.newBox,r._setBounds({topLeft:f,bottomRight:f}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(f.x),r.xScale().invert(f.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(f.y),r.yScale().invert(f.y)]),r.render()),r.boxVisible(!0),p=r.bounds(),i={x:p.topLeft.x,y:p.topLeft.y},o={x:p.bottomRight.x,y:p.bottomRight.y},a=f,r._dragStartCallbacks.callCallbacks(p)},u=function(f,p){switch(l){case s.newBox:o.x=p.x,o.y=p.y;break;case s.resize:n.bottom?o.y=p.y:n.top&&(i.y=p.y),n.right?o.x=p.x:n.left&&(i.x=p.x);break;case s.move:var d=p.x-a.x,g=p.y-a.y;i.x+=d,i.y+=g,o.x+=d,o.y+=g,a=p;break}r._setBounds({topLeft:i,bottomRight:o}),r._xBoundsMode===UF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(i.x),r.xScale().invert(o.x)]),r._yBoundsMode===UF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(i.y),r.yScale().invert(o.y)]),r.render(),r._dragCallbacks.callCallbacks(r.bounds())},h=function(f,p){l===s.newBox&&f.x===p.x&&f.y===p.y&&r.boxVisible(!1),r._dragEndCallbacks.callCallbacks(r.bounds())};this._dragInteraction.onDragStart(c),this._dragInteraction.onDrag(u),this._dragInteraction.onDragEnd(h),this._disconnectInteraction=function(){r._dragInteraction.offDragStart(c),r._dragInteraction.offDrag(u),r._dragInteraction.offDragEnd(h),r._dragInteraction.detach()}},t.prototype._setup=function(){var r=this;e.prototype._setup.call(this);var n=function(){return r._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})};if(this._detectionEdgeT=n().classed("drag-edge-tb",!0),this._detectionEdgeB=n().classed("drag-edge-tb",!0),this._detectionEdgeL=n().classed("drag-edge-lr",!0),this._detectionEdgeR=n().classed("drag-edge-lr",!0),this._hasCorners){var i=function(){return r._box.append("circle").styles({opacity:0,fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=i().classed("drag-corner-tl",!0),this._detectionCornerTR=i().classed("drag-corner-tr",!0),this._detectionCornerBL=i().classed("drag-corner-bl",!0),this._detectionCornerBR=i().classed("drag-corner-br",!0)}},t.prototype._getResizingEdges=function(r){var n={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return n;var i=this.bounds(),o=i.topLeft.y,a=i.bottomRight.y,s=i.topLeft.x,l=i.bottomRight.x,c=this._detectionRadius;return s-c<=r.x&&r.x<=l+c&&(n.top=o-c<=r.y&&r.y<=o+c,n.bottom=a-c<=r.y&&r.y<=a+c),o-c<=r.y&&r.y<=a+c&&(n.left=s-c<=r.x&&r.x<=s+c,n.right=l-c<=r.x&&r.x<=l+c),n},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this.boxVisible()){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;this._detectionEdgeT.attrs({x1:o,y1:n,x2:a,y2:n,"stroke-width":this._detectionRadius*2}),this._detectionEdgeB.attrs({x1:o,y1:i,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeL.attrs({x1:o,y1:n,x2:o,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeR.attrs({x1:a,y1:n,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._hasCorners&&(this._detectionCornerTL.attrs({cx:o,cy:n,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:a,cy:n,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:o,cy:i,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:a,cy:i,r:this._detectionRadius}))}return this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.resizable=function(r){return r==null?this._resizable:(this._resizable=r,this._setResizableClasses(r),this)},t.prototype._setResizableClasses=function(r){r&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))},t.prototype.movable=function(r){return r==null?this._movable:(this._movable=r,this._setMovableClass(),this)},t.prototype._setMovableClass=function(){this.movable()&&this.enabled()?this.addClass("movable"):this.removeClass("movable")},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.enabled=function(r){return r==null?this._dragInteraction.enabled():(this._dragInteraction.enabled(r),this._setResizableClasses(this.resizable()),this._setMovableClass(),this)},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t.prototype.detach=function(){return this._resetState(),this._dragInteraction.detach(),e.prototype.detach.call(this),this},t.prototype.anchor=function(r){return r=pBe.coerceExternalD3(r),this._dragInteraction.attachTo(this),e.prototype.anchor.call(this,r),this},t.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})},t}(dBe.SelectionBoxLayer);Aot.DragBoxLayer=mBe});var Lot=H(Iot=>{"use strict";Object.defineProperty(Iot,"__esModule",{value:!0});var gBe=(de(),Ut(pe)),_Be=Fe(),yBe=kc(),zv;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(zv||(zv={}));var vBe=function(e){gBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._mode=zv.VALUE,r!==t.ORIENTATION_VERTICAL&&r!==t.ORIENTATION_HORIZONTAL)throw new Error(r+" is not a valid orientation for GuideLineLayer");return n._orientation=r,n._overflowHidden=!0,n.addClass("guide-line-layer"),n._isVertical()?n.addClass("vertical"):n.addClass("horizontal"),n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue(),n.render()},n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._guideLine=this.content().append("line").classed("guide-line",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype._isVertical=function(){return this._orientation===t.ORIENTATION_VERTICAL},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.scale()!=null&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),0])),this},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._syncPixelPositionAndValue(),this._guideLine.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition()}),this},t.prototype._syncPixelPositionAndValue=function(){this.scale()!=null&&(this._mode===zv.VALUE&&this.value()!=null?this._pixelPosition=this.scale().scale(this.value()):this._mode===zv.PIXEL&&this.pixelPosition()!=null&&(this._value=this.scale().invert(this.pixelPosition())))},t.prototype._setPixelPositionWithoutChangingMode=function(r){this._pixelPosition=r,this.scale()!=null&&(this._value=this.scale().invert(this.pixelPosition())),this.render()},t.prototype.scale=function(r){if(r==null)return this._scale;var n=this._scale;return n!=null&&n.offUpdate(this._scaleUpdateCallback),this._scale=r,this._scale.onUpdate(this._scaleUpdateCallback),this._syncPixelPositionAndValue(),this.redraw(),this},t.prototype.value=function(r){return r==null?this._value:(this._value=r,this._mode=zv.VALUE,this._syncPixelPositionAndValue(),this.render(),this)},t.prototype.pixelPosition=function(r){if(r==null)return this._pixelPosition;if(!_Be.Math.isValidNumber(r))throw new Error("pixelPosition must be a finite number");return this._pixelPosition=r,this._mode=zv.PIXEL,this._syncPixelPositionAndValue(),this.render(),this},t.prototype.destroy=function(){e.prototype.destroy.call(this),this.scale()!=null&&this.scale().offUpdate(this._scaleUpdateCallback)},t.ORIENTATION_VERTICAL="vertical",t.ORIENTATION_HORIZONTAL="horizontal",t}(yBe.Component);Iot.GuideLineLayer=vBe});var I$t=H(Rot=>{"use strict";Object.defineProperty(Rot,"__esModule",{value:!0});var xBe=(de(),Ut(pe)),bBe=Lot(),wBe=l4(),kot=Fe(),SBe=function(e){xBe.__extends(t,e);function t(r){var n=e.call(this,r)||this;n._detectionRadius=3,n._enabled=!0,n.addClass("drag-line-layer"),n.addClass("enabled"),n._dragInteraction=new wBe.Drag,n._dragInteraction.attachTo(n);var i=function(c){return n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.x&&c.x<=n.pixelPosition()+n.detectionRadius()||!n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.y&&c.y<=n.pixelPosition()+n.detectionRadius()},o=!1,a=function(c){i(c)&&(o=!0,n._dragStartCallbacks.callCallbacks(n))};n._dragInteraction.onDragStart(a);var s=function(c,u){o&&(n._setPixelPositionWithoutChangingMode(n._isVertical()?u.x:u.y),n._dragCallbacks.callCallbacks(n))};n._dragInteraction.onDrag(s);var l=function(c,u){o&&(o=!1,n._dragEndCallbacks.callCallbacks(n))};return n._dragInteraction.onDragEnd(l),n._disconnectInteraction=function(){n._dragInteraction.offDragStart(a),n._dragInteraction.offDrag(s),n._dragInteraction.offDragEnd(l),n._dragInteraction.detach()},n._dragStartCallbacks=new kot.CallbackSet,n._dragCallbacks=new kot.CallbackSet,n._dragEndCallbacks=new kot.CallbackSet,n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._detectionEdge=this.content().append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._detectionEdge.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition(),"stroke-width":this._detectionRadius*2}),this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.enabled=function(r){return r==null?this._enabled:(this._enabled=r,r?this.addClass("enabled"):this.removeClass("enabled"),this._dragInteraction.enabled(r),this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragStartCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t}(bBe.GuideLineLayer);Rot.DragLineLayer=SBe});var L$t=H(Not=>{"use strict";Object.defineProperty(Not,"__esModule",{value:!0});var MBe=(de(),Ut(pe)),EBe=kc();function GF(e,t,r){var n={};if(r!==void 0)for(var i=0;i<r.length;i++){var o=r[i-1],a=r[i];n[a]=o}return function(s){var l=e.scale(s);if(!t)return l;var c,u=n[s]===void 0?void 0:e.scale(n[s]);return u!==void 0&&(c=u+(l-u)/2),c}}var TBe=function(e){MBe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i.addClass("gridlines"),i._xScale=r,i._yScale=n,i._renderCallback=function(o){return i.render()},i._xScale&&i._xScale.onUpdate(i._renderCallback),i._yScale&&i._yScale.onUpdate(i._renderCallback),i}return t.prototype.betweenX=function(r){return r===void 0?this._betweenX:(r!==this._betweenX&&(this._betweenX=r,this.render()),this)},t.prototype.betweenY=function(r){return r===void 0?this._betweenY:(r!==this._betweenY&&(this._betweenY=r,this.render()),this)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this._xScale&&this._xScale.offUpdate(this._renderCallback),this._yScale&&this._yScale.offUpdate(this._renderCallback),this},t.prototype._setup=function(){e.prototype._setup.call(this),this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0),this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._redrawXLines(),this._redrawYLines(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._xScale!=null&&this._xScale.range([0,this.width()]),this._yScale!=null&&this._yScale.range([this.height(),0]),this},t.prototype._redrawXLines=function(){if(this._xScale){var r=this.betweenX(),n=this._xScale.ticks().slice(r?1:0),i=this._xLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",GF(this._xScale,r,this._xScale.ticks())).attr("y1",0).attr("x2",GF(this._xScale,r,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t.prototype._redrawYLines=function(){if(this._yScale){var r=this.betweenY(),n=this._yScale.ticks().slice(r?1:0),i=this._yLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",0).attr("y1",GF(this._yScale,r,this._yScale.ticks())).attr("x2",this.width()).attr("y2",GF(this._yScale,r,this._yScale.ticks())).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t}(EBe.Component);Not.Gridlines=TBe});var WF=H(Dot=>{"use strict";Object.defineProperty(Dot,"__esModule",{value:!0});var CBe=(de(),Ut(pe)),ABe=jg(),PBe=kc(),IBe=function(e){CBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detachCallback=function(n){return r.remove(n)},r}return t.prototype.anchor=function(r){var n=this;return r=ABe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._forEach(function(i){return i.anchor(n.element())}),this},t.prototype.render=function(){return this._forEach(function(r){return r.render()}),this},t.prototype.has=function(r){throw new Error("has() is not implemented on ComponentContainer")},t.prototype._adoptAndAnchor=function(r){r.parent(this),r.onDetach(this._detachCallback),this._isAnchored&&r.anchor(this.element())},t.prototype.remove=function(r){return this.has(r)&&(r.offDetach(this._detachCallback),this._remove(r),r.detach(),this.redraw()),this},t.prototype._remove=function(r){return!1},t.prototype._forEach=function(r){throw new Error("_forEach() is not implemented on ComponentContainer")},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._forEach(function(r){return r.destroy()})},t.prototype.invalidateCache=function(){this._forEach(function(r){return r.invalidateCache()})},t}(PBe.Component);Dot.ComponentContainer=IBe});var zot=H(Oot=>{"use strict";Object.defineProperty(Oot,"__esModule",{value:!0});var LBe=(de(),Ut(pe)),k$t=Fe(),kBe=WF(),RBe=function(e){LBe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._components=[],n.addClass("component-group"),r.forEach(function(i){return n.append(i)}),n}return t.prototype._forEach=function(r){this.components().forEach(r)},t.prototype.has=function(r){return this._components.indexOf(r)>=0},t.prototype.requestedSpace=function(r,n){var i=this._components.map(function(o){return o.requestedSpace(r,n)});return{minWidth:k$t.Math.max(i,function(o){return o.minWidth},0),minHeight:k$t.Math.max(i,function(o){return o.minHeight},0)}},t.prototype.computeLayout=function(r,n,i){var o=this;return e.prototype.computeLayout.call(this,r,n,i),this._forEach(function(a){a.computeLayout({x:0,y:0},o.width(),o.height())}),this},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.fixedWidth=function(){return this._components.every(function(r){return r.fixedWidth()})},t.prototype.fixedHeight=function(){return this._components.every(function(r){return r.fixedHeight()})},t.prototype.components=function(){return this._components.slice()},t.prototype.append=function(r){return r!=null&&!this.has(r)&&(r.detach(),this._components.push(r),this._adoptAndAnchor(r),this.redraw()),this},t.prototype._remove=function(r){var n=this._components.indexOf(r);return n>=0?(this._components.splice(n,1),!0):!1},t}(kBe.ComponentContainer);Oot.Group=RBe});var R$t=H(Fot=>{"use strict";Object.defineProperty(Fot,"__esModule",{value:!0});var NBe=(de(),Ut(pe)),YF=yl(),DBe=$A(),OBe=Bu(),zBe=Fe(),FBe=kc(),BBe=function(e){NBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._textPadding=5,r==null)throw new Error("InterpolatedColorLegend requires a interpolatedColorScale");return n._scale=r,n._redrawCallback=function(i){return n.redraw()},n._scale.onUpdate(n._redrawCallback),n._formatter=OBe.general(),n._orientation="horizontal",n._expands=!1,n.addClass("legend"),n.addClass("interpolated-color-legend"),n}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._redrawCallback)},t.prototype.formatter=function(r){return r===void 0?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.expands=function(r){return r==null?this._expands:(this._expands=r,this.redraw(),this)},t._ensureOrientation=function(r){if(r=r.toLowerCase(),r==="horizontal"||r==="left"||r==="right")return r;throw new Error('"'+r+'" is not a valid orientation for InterpolatedColorLegend')},t.prototype.orientation=function(r){return r==null?this._orientation:(this._orientation=t._ensureOrientation(r),this.redraw(),this)},t.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()},t.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()},t.prototype._generateTicks=function(r){r===void 0&&(r=t._DEFAULT_NUM_SWATCHES);var n=this._scale.domain();if(r===1)return[n[0]];for(var i=(n[1]-n[0])/(r-1),o=[],a=0;a<r;a++)o.push(n[0]+i*a);return o},t.prototype._setup=function(){e.prototype._setup.call(this),this._swatchContainer=this.content().append("g").classed("swatch-container",!0),this._swatchBoundingBox=this.content().append("rect").classed("swatch-bounding-box",!0),this._lowerLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0),this._upperLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0);var r=new YF.SvgContext(this.content().node());this._measurer=new YF.Measurer(r),this._wrapper=new YF.Wrapper,this._writer=new YF.Writer(this._measurer,r,this._wrapper)},t.prototype.requestedSpace=function(r,n){var i=this,o=this._measurer.measure().height,a=o,s=this._scale.domain(),l=s.map(function(p){return i._measurer.measure(i._formatter(p)).width}),c,u,h=t._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var f=zBe.Math.max(l,0);u=a+o+this._textPadding+f+this._textPadding,c=h*o}else c=a+o+a,u=this._textPadding+l[0]+h*o+l[1]+this._textPadding;return{minWidth:u,minHeight:c}},t.prototype._isVertical=function(){return this._orientation!=="horizontal"},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale.domain(),i=this._formatter(n[0]),o=this._measurer.measure(i).width,a=this._formatter(n[1]),s=this._measurer.measure(a).width,l=this._measurer.measure().height,c=this._textPadding,u={x:0,y:0},h={x:0,y:0},f={xAlign:"center",yAlign:"center",textRotation:0},p={xAlign:"center",yAlign:"center",textRotation:0},d,g,_,y,x={x:0,y:0,width:0,height:0},b,S;if(this._isVertical()){S=Math.floor(this.height());var C=Math.max(o,s);b=(this.width()-C-2*this._textPadding)/2,d=Math.max(this.width()-b-2*c-C,0),g=1,y=function(L,R){return r.height()-(R+1)},p.yAlign="top",u.y=0,f.yAlign="bottom",h.y=0,this._orientation==="left"?(_=function(L,R){return c+C+c},p.xAlign="right",u.x=-(b+d+c),f.xAlign="right",h.x=-(b+d+c)):(_=function(L,R){return b},p.xAlign="left",u.x=b+d+c,f.xAlign="left",h.x=b+d+c),x.width=d,x.height=S*g}else b=Math.max(c,(this.height()-l)/2),S=Math.max(Math.floor(this.width()-c*4-o-s),0),d=1,g=Math.max(this.height()-2*b,0),_=function(L,R){return Math.floor(o+2*c)+R},y=function(L,R){return b},p.xAlign="right",u.x=-c,f.xAlign="left",h.x=c,x.y=b,x.width=S*d,x.height=g;x.x=_(null,0),this._upperLabel.text(""),this._writer.write(a,this.width(),this.height(),p,this._upperLabel.node());var P="translate("+u.x+", "+u.y+")";this._upperLabel.attr("transform",P),this._lowerLabel.text(""),this._writer.write(i,this.width(),this.height(),f,this._lowerLabel.node());var k="translate("+h.x+", "+h.y+")";this._lowerLabel.attr("transform",k),this._swatchBoundingBox.attrs(x);var O=this._generateTicks(S),D=this._swatchContainer.selectAll("rect.swatch").data(O),B=D.enter().append("rect").classed("swatch",!0),I=D.merge(B);return D.exit().remove(),I.attrs({fill:function(L,R){return r._scale.scale(L)},width:d,height:g,x:_,y,"shape-rendering":"crispEdges"}),DBe.ADD_TITLE_ELEMENTS&&B.append("title").text(function(L){return r._formatter(L)}),this},t._DEFAULT_NUM_SWATCHES=11,t.LEGEND_LABEL_CLASS="legend-label",t}(FBe.Component);Fot.InterpolatedColorLegend=BBe});var Vot=H(h4=>{"use strict";Object.defineProperty(h4,"__esModule",{value:!0});var Bot=(de(),Ut(pe)),jF=yl(),HBe=kc(),Hot=function(e){Bot.__extends(t,e);function t(r,n){r===void 0&&(r=""),n===void 0&&(n=0);var i=e.call(this)||this;return i.addClass("label"),i.text(r),i.angle(n),i.xAlignment("center").yAlignment("center"),i._padding=0,i}return t.prototype.requestedSpace=function(r,n){var i=this._measurer.measure(this._text),o=(this.angle()===0?i.width:i.height)+2*this.padding(),a=(this.angle()===0?i.height:i.width)+2*this.padding();return{minWidth:o,minHeight:a}},t.prototype._setup=function(){e.prototype._setup.call(this),this._textContainer=this.content().append("g");var r=new jF.SvgContext(this._textContainer.node());this._measurer=new jF.CacheMeasurer(r),this._wrapper=new jF.Wrapper,this._writer=new jF.Writer(this._measurer,r,this._wrapper),this.text(this._text)},t.prototype.text=function(r){if(r==null)return this._text;if(typeof r!="string")throw new Error("Label.text() only takes strings as input");return this._text=r,this.redraw(),this},t.prototype.angle=function(r){if(r==null)return this._angle;if(r%=360,r>180?r-=360:r<-180&&(r+=360),r===-90||r===0||r===90)this._angle=r;else throw new Error(r+" is not a valid angle for Label");return this.redraw(),this},t.prototype.padding=function(r){if(r==null)return this._padding;if(r=+r,r<0)throw new Error(r+" is not a valid padding value. Cannot be less than 0.");return this._padding=r,this.redraw(),this},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this),this._textContainer.selectAll("g").remove();var r=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-r.height)/2,this.padding()),0),i=Math.max(Math.min((this.width()-r.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+i+","+n+")");var o=this.width()-2*i,a=this.height()-2*n,s={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};return this._writer.write(this._text,o,a,s),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(HBe.Component);h4.Label=Hot;var VBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.TITLE_LABEL_CLASS),i}return t.TITLE_LABEL_CLASS="title-label",t}(Hot);h4.TitleLabel=VBe;var UBe=function(e){Bot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.AXIS_LABEL_CLASS),i}return t.AXIS_LABEL_CLASS="axis-label",t}(Hot);h4.AxisLabel=UBe});var XF=H(wd=>{"use strict";Object.defineProperty(wd,"__esModule",{value:!0});var Ns=(Er(),Ut(Mr));function qBe(){return function(e){return Ns.symbol().type(Ns.symbolCircle).size(Math.PI*Math.pow(e/2,2))}}wd.circle=qBe;function GBe(){return function(e){return Ns.symbol().type(Ns.symbolSquare).size(Math.pow(e,2))}}wd.square=GBe;function WBe(){return function(e){return Ns.symbol().type(Ns.symbolCross).size(5/9*Math.pow(e,2))}}wd.cross=WBe;function YBe(){return function(e){return Ns.symbol().type(Ns.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(e,2)/2)}}wd.diamond=YBe;function jBe(){return function(e){return Ns.symbol().type(Ns.symbolTriangle).size(Math.sqrt(3)*Math.pow(e/2,2))}}wd.triangle=jBe;var XBe=.8908130915292852;function $Be(){return function(e){return Ns.symbol().type(Ns.symbolStar).size(XBe*Math.pow(e/2,2))}}wd.star=$Be;var KBe=(1/Math.sqrt(12)/2+1)*3;function ZBe(){return function(e){return Ns.symbol().type(Ns.symbolWye).size(KBe*Math.pow(e/2.4,2))}}wd.wye=ZBe});var N$t=H(qot=>{"use strict";Object.defineProperty(qot,"__esModule",{value:!0});var JBe=(de(),Ut(pe)),Fv=(Er(),Ut(Mr)),$F=yl(),QBe=$A(),tHe=Bu(),eHe=XF(),Qg=Fe(),rHe=kc(),Uot=function(){function e(t,r,n){t===void 0&&(t=[]),r===void 0&&(r=0),n===void 0&&(n=1/0),this.columns=t,this.bottomPadding=r,this.maxWidth=n}return e.prototype.addColumn=function(t){var r=t.width,n=this.getWidthAvailable();t.width=Math.min(n,r),this.columns.push(t)},e.prototype.getBounds=function(t){for(var r=this.columns[t],n=0,i=0;i<t;i++)n+=this.columns[i].width;return{topLeft:{x:n,y:0},bottomRight:{x:n+r.width,y:r.height}}},e.prototype.getHeight=function(){return Qg.Math.max(this.columns.map(function(t){var r=t.height;return r}),0)+this.bottomPadding},e.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(t,r){var n=r.width;return t+n},0),this.maxWidth)},e.prototype.getWidthAvailable=function(){var t=this.getWidth();return Math.max(this.maxWidth-t,0)},e}(),nHe=function(){function e(t,r,n,i){t===void 0&&(t=1/0),r===void 0&&(r=1/0),n===void 0&&(n=0),i===void 0&&(i=[]),this.maxWidth=t,this.maxHeight=r,this.padding=n,this.rows=i}return e.prototype.addRow=function(t){t.maxWidth=this.maxWidth-this.padding*2,this.rows.push(t)},e.prototype.getColumnBounds=function(t,r){var n=this.getRowBounds(t),i=this.rows[t].getBounds(r);return i.topLeft.x+=n.topLeft.x,i.bottomRight.x+=n.topLeft.x,i.topLeft.y+=n.topLeft.y,i.bottomRight.y+=n.topLeft.y,i},e.prototype.getRowBounds=function(t){for(var r=this.padding,n=this.padding,i=0;i<t;i++)n+=this.rows[i].getHeight();var o={topLeft:{x:r,y:n},bottomRight:{x:r+this.rows[t].getWidth(),y:n+this.rows[t].getHeight()}};return o},e.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(t,r){return t+r.getHeight()},0)+this.padding*2,this.maxHeight)},e.prototype.getWidth=function(){return Math.min(Qg.Math.max(this.rows.map(function(t){return t.getWidth()}),0)+this.padding*2,this.maxWidth)},e}(),iHe=function(e){JBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._padding=5,n._rowBottomPadding=3,n.addClass("legend"),n.maxEntriesPerRow(1),r==null)throw new Error("Legend requires a colorScale");return n._colorScale=r,n._redrawCallback=function(i){return n.redraw()},n._colorScale.onUpdate(n._redrawCallback),n._formatter=tHe.identity(),n.maxLinesPerEntry(1),n.xAlignment("right").yAlignment("top"),n.comparator(function(i,o){var a=n._colorScale.domain().slice().map(function(s){return n._formatter(s)});return a.indexOf(i)-a.indexOf(o)}),n._symbolFactoryAccessor=function(){return eHe.circle()},n._symbolOpacityAccessor=function(){return 1},n}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=this.content().append("g").classed(t.LEGEND_ROW_CLASS,!0),n=r.append("g").classed(t.LEGEND_ENTRY_CLASS,!0);n.append("text");var i=new $F.SvgContext(r.node(),null,QBe.ADD_TITLE_ELEMENTS);this._measurer=new $F.CacheMeasurer(i),this._wrapper=new $F.Wrapper().maxLines(this.maxLinesPerEntry()),this._writer=new $F.Writer(this._measurer,i,this._wrapper)},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.maxEntriesPerRow=function(r){return r==null?this._maxEntriesPerRow:(this._maxEntriesPerRow=r,this.redraw(),this)},t.prototype.maxLinesPerEntry=function(r){return r==null?this._maxLinesPerEntry:(this._maxLinesPerEntry=r,this.redraw(),this)},t.prototype.maxWidth=function(r){return r==null?this._maxWidth:(this._maxWidth=r,this.redraw(),this)},t.prototype.comparator=function(r){return r==null?this._comparator:(this._comparator=r,this.redraw(),this)},t.prototype.colorScale=function(r){return r!=null?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=r,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._colorScale.offUpdate(this._redrawCallback)},t.prototype._buildLegendTable=function(r,n){var i=this,o=this._measurer.measure().height,a=new nHe(r,n,this._padding),s=this._colorScale.domain().slice().sort(function(c,u){return i._comparator(i._formatter(c),i._formatter(u))}),l=new Uot;return a.addRow(l),l.bottomPadding=this._rowBottomPadding,s.forEach(function(c,u){l.columns.length/2===i.maxEntriesPerRow()&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var h=l.getWidthAvailable(),f=i._formatter(c),p=i._measurer.measure(f).width,d=h-o-p<0;d&&l.columns.length>1&&(l=new Uot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var g={width:o,height:o,data:{name:c,type:"symbol"}};l.addColumn(g),h=l.getWidthAvailable();var _=Math.min(h,p);i._wrapper.maxLines(i.maxLinesPerEntry());var y=i._wrapper.wrap(f,i._measurer,_).noLines,x=y*o,b={width:_,height:x,data:{name:c,type:"text"}};l.addColumn(b)}),a},t.prototype.requestedSpace=function(r,n){var i=this._buildLegendTable(Qg.Math.min([this.maxWidth(),r],r),n);return{minHeight:i.getHeight(),minWidth:i.getWidth()}},t.prototype.entitiesAt=function(r){var n=this;if(!this._isSetup)return[];var i=this._buildLegendTable(this.width(),this.height());return i.rows.reduce(function(o,a,s){if(o.length!==0)return o;var l=i.getRowBounds(s),c=Qg.Math.within(r,l);return c?a.columns.reduce(function(u,h,f){var p=i.getColumnBounds(s,f),d=Qg.Math.within(r,p);if(d){var g=n.content().selectAll("."+t.LEGEND_ROW_CLASS).nodes()[s],_=Fv.select(g).selectAll("."+t.LEGEND_ENTRY_CLASS).nodes()[Math.floor(f/2)],y=Fv.select(_).select("."+t.LEGEND_SYMBOL_CLASS),x=Qg.DOM.getTranslateValues(Fv.select(g)),b=Qg.DOM.getTranslateValues(y);return[{bounds:Qg.DOM.elementBBox(Fv.select(g)),datum:h.data.name,position:{x:x[0]+b[0],y:x[1]+b[1]},selection:Fv.select(_),component:n}]}return u},o):o},[])},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this);var r=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var n=this.content().selectAll("g."+t.LEGEND_ROW_CLASS).data(r.rows),i=n.enter().append("g").classed(t.LEGEND_ROW_CLASS,!0).merge(n);n.exit().remove(),i.attr("transform",function(a,s){var l=r.getRowBounds(s);return"translate("+l.topLeft.x+", "+l.topLeft.y+")"});var o=this;return i.each(function(a,s){for(var l=[],c=0;c<a.columns.length;c+=2)l.push([a.columns[c],a.columns[c+1]]);var u=Fv.select(this).selectAll("g."+t.LEGEND_ENTRY_CLASS).data(l),h=u.enter().append("g").classed(t.LEGEND_ENTRY_CLASS,!0).merge(u);h.append("path").attr("d",function(f,p){var d=f[0];return o.symbol()(d.data.name,s)(d.height*.6)(null)}).attr("transform",function(f,p){var d=f[0],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+(_.topLeft.x+d.width/2)+", "+d.height/2+")"}).attr("fill",function(f){return o._colorScale.scale(f[0].data.name)}).attr("opacity",function(f,p){return o.symbolOpacity()(f[0].data.name,s)}).classed(t.LEGEND_SYMBOL_CLASS,!0),h.append("g").classed("text-container",!0).attr("transform",function(f,p){var d=f[1],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+_.topLeft.x+", 0)"}).each(function(f,p,d){var g=Fv.select(this),_=f[1],y={xAlign:"left",yAlign:"top",textRotation:0};o._writer.write(o._formatter(_.data.name),_.width,o.height(),y,g.node())}),u.exit().remove()}),this},t.prototype.symbol=function(r){return r==null?this._symbolFactoryAccessor:(this._symbolFactoryAccessor=r,this.render(),this)},t.prototype.symbolOpacity=function(r){return r==null?this._symbolOpacityAccessor:(typeof r=="number"?this._symbolOpacityAccessor=function(){return r}:this._symbolOpacityAccessor=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.LEGEND_ROW_CLASS="legend-row",t.LEGEND_ENTRY_CLASS="legend-entry",t.LEGEND_SYMBOL_CLASS="legend-symbol",t}(rHe.Component);qot.Legend=iHe});var Got=H(KF=>{"use strict";Object.defineProperty(KF,"__esModule",{value:!0});var oHe;(function(e){e.MAIN="main",e.RESET="reset"})(oHe=KF.Animator||(KF.Animator={}))});var O$t=H((eGn,D$t)=>{"use strict";D$t.exports=function(t){return t!=null&&typeof t=="object"&&Array.isArray(t)===!1}});var B$t=H((rGn,F$t)=>{"use strict";var aHe=O$t();function z$t(e){return aHe(e)===!0&&Object.prototype.toString.call(e)==="[object Object]"}F$t.exports=function(t){var r,n;return!(z$t(t)===!1||(r=t.constructor,typeof r!="function")||(n=r.prototype,z$t(n)===!1)||n.hasOwnProperty("isPrototypeOf")===!1)}});var Yot=H(Wot=>{"use strict";Object.defineProperty(Wot,"__esModule",{value:!0});var sHe=Fe(),H$t=0,lHe=function(){function e(t,r){t===void 0&&(t=[]),r===void 0&&(r={}),this._updateId=H$t++,this._data=t,this._metadata=r,this._callbacks=new sHe.CallbackSet}return e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype.data=function(t){return t==null?this._data:(this._data=t,this._dispatchUpdate(),this)},e.prototype.metadata=function(t){return t==null?this._metadata:(this._metadata=t,this._dispatchUpdate(),this)},e.prototype.updateId=function(){return this._updateId},e.prototype._dispatchUpdate=function(){this._updateId=H$t++,this._callbacks.callCallbacks(this)},e}();Wot.Dataset=lHe});var $ot=H(Rc=>{"use strict";Object.defineProperty(Rc,"__esModule",{value:!0});var jot=(de(),Ut(pe)),cHe=B$t(),uHe=Yot(),hHe=kv();function Xot(e){return e instanceof p4?e:e instanceof Date?f4(e.valueOf()):e instanceof hHe.Scale?V$t(e):e instanceof uHe.Dataset?U$t(e):cHe(e)?ZF(e):Array.isArray(e)?q$t(e):f4(e)}Rc.sign=Xot;function V$t(e){var t={domain:e.domain(),range:e.range(),updateId:e.updateId(),ref:f4(e)};return ZF(t)}Rc.signScale=V$t;function U$t(e){var t={ref:f4(e),updateId:e.updateId()};return ZF(t)}Rc.signDataset=U$t;function f4(e){return new W$t(e)}Rc.signRef=f4;function q$t(e){return new G$t(e.map(function(t){return Xot(t)}))}Rc.signArray=q$t;function ZF(e){var t={};for(var r in e)e.hasOwnProperty(r)&&(t[r]=Xot(e[r]));return new Y$t(t)}Rc.signObj=ZF;var p4=function(){function e(){}return e.prototype.isDifferent=function(t){return t instanceof this.constructor?this.isSignatureDifferent(t):!0},e}();Rc.Signature=p4;var G$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.array=r,n}return t.prototype.isSignatureDifferent=function(r){if(r.array.length!==this.array.length)return!0;for(var n=0;n<this.array.length;n++)if(this.array[n].isDifferent(r.array[n]))return!0;return!1},t}(p4);Rc.ArraySignature=G$t;var W$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.ref=r,n}return t.prototype.isSignatureDifferent=function(r){return this.ref!==r.ref},t}(p4);Rc.ReferenceSignature=W$t;var Y$t=function(e){jot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.obj=r,n}return t.prototype.isSignatureDifferent=function(r){var n=Object.keys(this.obj),i=Object.keys(r.obj);if(n.length!==i.length)return!0;for(var o=0,a=n;o<a.length;o++){var s=a[o];if(!r.obj.hasOwnProperty(s)||this.obj[s].isDifferent(r.obj[s]))return!0}return!1},t}(p4);Rc.ObjectSignature=Y$t});var j$t=H(Kot=>{"use strict";Object.defineProperty(Kot,"__esModule",{value:!0});var fHe=$ot();function pHe(e){var t=void 0,r,n=!1,i=!1,o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];if(n)return r;var l=fHe.signArray(a);return t===void 0||t.isDifferent(l)?(i&&console.warn("cache miss! computing"),t=l,r=e.apply(this,a)):i&&console.warn("cache hit!"),r};return o.doLocked=function(a){if(n)throw new Error("Locking an already locked memoize function!");n=!0;var s=a.apply(this);return n=!1,s},o.logPerformance=function(a){return a===void 0&&(a=!0),i=a,this},o}Kot.memoize=pHe});var K$t=H(JF=>{"use strict";Object.defineProperty(JF,"__esModule",{value:!0});var dHe=Oe(),Zot=function(){function e(){this.map=Object.create(null),this.exists=Object.create(null)}return e.prototype.delete=function(t){return delete this.map[t],delete this.exists[t],!0},e.prototype.get=function(t){return this.map[t]},e.prototype.has=function(t){return!!this.exists[t]},e.prototype.set=function(t,r){return this.map[t]=r,this.exists[t]=!0,this},e}(),X$t=function(){function e(){this.map=new Zot}return e.prototype.get=function(t){return this.map.get(t[0]).get(t[1])},e.prototype.has=function(t){return this.map.has(t[0])&&this.map.get(t[0]).has(t[1])},e.prototype.set=function(t,r){return this.map.has(t[0])||this.map.set(t[0],new Zot),this.map.get(t[0]).set(t[1],r),this},e.prototype.delete=function(t){return this.map.has(t[0])&&this.map.get(t[0]).delete(t[1]),!0},e.prototype.clear=function(){this.map=new Zot},e.resolver=function(t,r,n){return[n.updateId(),r]},e}();function $$t(e){var t=dHe.memoize(e,X$t.resolver);return t.cache=new X$t,t}JF.memoizeProjector=$$t;function mHe(e){return Object.keys(e).forEach(function(t){e[t]=$$t(e[t])}),e}JF.memoizeProjectors=mHe});var Z$t=H(Jot=>{"use strict";Object.defineProperty(Jot,"__esModule",{value:!0});var gHe=CS();function _He(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=e.slice(0,-1),n=e[e.length-1],i=gHe.memoize(n),o=function(){var a=this,s=r.map(function(l){return l.apply(a)});return i.apply(void 0,s)};return o}Jot.memThunk=_He});var CS=H(AS=>{"use strict";Object.defineProperty(AS,"__esModule",{value:!0});var Qot=(de(),Ut(pe));Qot.__exportStar(j$t(),AS);Qot.__exportStar(K$t(),AS);Qot.__exportStar(Z$t(),AS);var yHe=$ot();AS.sign=yHe.sign});var Bv=H(Nc=>{"use strict";Object.defineProperty(Nc,"__esModule",{value:!0});var J$t=(Er(),Ut(Mr)),vHe=function(){function e(t,r){this._context=t,this._drawStep=r}return e.prototype.getDrawStep=function(){return this._drawStep},e.prototype.draw=function(t,r){var n=r[r.length-1].attrToAppliedProjector;this._context.save(),this._drawStep(this._context,t,n),this._context.restore()},e.prototype.getVisualPrimitives=function(){return[]},e.prototype.getVisualPrimitiveAtIndex=function(t){return null},e.prototype.remove=function(){},e}();Nc.CanvasDrawer=vHe;Nc.ContextStyleAttrs=["fill-opacity","fill","opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function xHe(e,t,r,n){var i=Nc.ContextStyleAttrs.concat(t);return Q$t(e,i,r,n)}Nc.resolveAttributesSubsetWithStyles=xHe;function Q$t(e,t,r,n){for(var i={},o=0,a=t;o<a.length;o++){var s=a[o];e.hasOwnProperty(s)&&(i[s]=e[s](r,n))}return i}Nc.resolveAttributes=Q$t;function bHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["stroke-opacity"]!=null?parseFloat(e["stroke-opacity"]):1;return r*t}function wHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["fill-opacity"]!=null?parseFloat(e["fill-opacity"]):1;return r*t}function tKt(e){return e["stroke-width"]!=null?parseFloat(e["stroke-width"]):1}Nc.getStrokeWidth=tKt;function eKt(e){var t=e["stroke-dasharray"];if(t!=null)try{return t.split(/[ ,]+/).map(function(r){return parseInt(r,10)})}catch(r){return console.error("getStrokeDashArray failed with: "+r),[]}return[]}Nc.getStrokeDashArray=eKt;function SHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderArea=SHe;function MHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",tat(e,n),e.restore()}Nc.renderLine=MHe;function tat(e,t){if(t.stroke){e.lineWidth=tKt(t);var r=J$t.color(t.stroke),n=eKt(t);e.setLineDash(n),r.opacity*=bHe(t),e.strokeStyle=r.toString(),e.stroke()}if(t.fill){var i=J$t.color(t.fill);i.opacity*=wHe(t),e.fillStyle=i.toString(),e.fill()}}Nc.renderPathWithStyle=tat});var Uu=H(eat=>{"use strict";Object.defineProperty(eat,"__esModule",{value:!0});var EHe=function(){function e(t,r){this._svgDrawerFactory=t,this._canvasDrawerFactory=r}return e.prototype.useSVG=function(t){this._currentDrawer!=null&&this._currentDrawer.remove();var r=this._svgDrawerFactory();r.attachTo(t),this._currentDrawer=r},e.prototype.useCanvas=function(t){this._currentDrawer!=null&&this._currentDrawer.remove(),this._currentDrawer=this._canvasDrawerFactory(t.node().getContext("2d"))},e.prototype.getDrawer=function(){return this._currentDrawer},e.prototype.remove=function(){this._currentDrawer!=null&&this._currentDrawer.remove()},e.prototype.draw=function(t,r){this._currentDrawer.draw(t,r)},e.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._currentDrawer.getVisualPrimitiveAtIndex(t)},e}();eat.ProxyDrawer=EHe});var Of=H(rat=>{"use strict";Object.defineProperty(rat,"__esModule",{value:!0});var THe=(Er(),Ut(Mr)),rKt=Fe(),CHe=function(){function e(t,r){this._root=THe.select(document.createElementNS("http://www.w3.org/2000/svg","g")),this._className=r,this._svgElementName=t}return e.prototype.draw=function(t,r){var n=this;this._createAndDestroyDOMElements(t);for(var i=0,o=r.length,a=function(l){var c=r[l];rKt.Window.setTimeout(function(){return n._drawStep(c)},i),i+=c.animator.totalTime(t.length)},s=0;s<o;s++)a(s)},e.prototype.getVisualPrimitives=function(){return this._cachedVisualPrimitivesNodes==null&&(this._cachedVisualPrimitivesNodes=this._selection.nodes()),this._cachedVisualPrimitivesNodes},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._cachedVisualPrimitivesNodeMap==null?null:this._cachedVisualPrimitivesNodeMap.get(t)},e.prototype.remove=function(){this._root.remove()},e.prototype.attachTo=function(t){t.node().appendChild(this._root.node())},e.prototype.getRoot=function(){return this._root},e.prototype.selector=function(){return this._svgElementName},e.prototype._applyDefaultAttributes=function(t){},e.prototype._createAndDestroyDOMElements=function(t){var r=t.map(function(a,s){return a!=null?{d:a,i:s}:null}),n=r.filter(function(a){return a!=null}),i=this._root.selectAll(this.selector()).data(n);this._selection=i.enter().append(this._svgElementName).merge(i),i.exit().remove();var o=new rKt.Map;this._selection.each(function(a){o.set(a.i,this)}),this._cachedVisualPrimitivesNodeMap=o,this._cachedVisualPrimitivesNodes=null,this._selection.data(this._selection.data().map(function(a){var s=a.d;return s})),this._className!=null&&this._selection.classed(this._className,!0),this._applyDefaultAttributes(this._selection)},e.prototype._drawStep=function(t){var r=this,n=["fill","stroke"];n.forEach(function(i){t.attrToAppliedProjector[i]!=null&&r._selection.attr(i,t.attrToAppliedProjector[i])}),t.animator.animate(this._selection,t.attrToAppliedProjector),this._className!=null&&this._selection.classed(this._className,!0)},e}();rat.SVGDrawer=CHe});var iat=H(nat=>{"use strict";Object.defineProperty(nat,"__esModule",{value:!0});var nKt=function(){function e(){var t=this;this.scale=0,this.translate=0,this.cachedDomain=[null,null],this.lastSeenDomain=[null,null],this.updateDomain=function(r){t.lastSeenDomain=r.getTransformationDomain();var n=r.scaleTransformation(t.cachedDomain[1])-r.scaleTransformation(t.cachedDomain[0]),i=r.scaleTransformation(t.lastSeenDomain[1])-r.scaleTransformation(t.lastSeenDomain[0]);t.scale=n/i||1,t.translate=r.scaleTransformation(t.cachedDomain[0])-r.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}return e.prototype.reset=function(){this.scale=1,this.translate=0,this.cachedDomain=this.lastSeenDomain},e.prototype.setDomain=function(t){this.cachedDomain=t.getTransformationDomain()},e}(),AHe=function(){function e(t,r){var n=this;this.renderCallback=t,this.applyTransformCallback=r,this.domainTransformX=new nKt,this.domainTransformY=new nKt,this.renderDeferred=function(){n.applyTransform(),clearTimeout(n.timeoutToken),n.timeoutToken=setTimeout(function(){n.renderCallback()},e.DEFERRED_RENDERING_DELAY)}}return e.prototype.setDomains=function(t,r){t&&this.domainTransformX.setDomain(t),r&&this.domainTransformY.setDomain(r),this.renderDeferred()},e.prototype.updateDomains=function(t,r){t&&this.domainTransformX.updateDomain(t),r&&this.domainTransformY.updateDomain(r),this.renderDeferred()},e.prototype.resetTransforms=function(){this.domainTransformX.reset(),this.domainTransformY.reset(),this.applyTransform()},e.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)},e.DEFERRED_RENDERING_DELAY=200,e}();nat.DeferredRenderer=AHe});var ns=H(QF=>{"use strict";Object.defineProperty(QF,"__esModule",{value:!0});var PHe=(de(),Ut(pe)),Sd=(Er(),Ut(Mr)),d4=kf(),Md=Fe(),iKt=Got(),oat=CS(),IHe=kc(),LHe=Bv(),kHe=Uu(),RHe=Of(),NHe=jg(),DHe=Lf(),OHe=iat();QF.Renderer=DHe.makeEnum(["svg","canvas"]);var zHe=function(e){PHe.__extends(t,e);function t(){var r=e.call(this)||this;r._dataChanged=!1,r._attrExtents={},r._animate=!1,r._animators={},r._propertyExtents={},r._resetEntityStore=function(){r._cachedEntityStore=void 0},r._overflowHidden=!0,r.addClass("plot"),r._datasetToDrawer=new Md.Map,r._attrBindings=Sd.map(),r._includedValuesProvider=function(i,o){return r._includedValuesForScale(i,o)},r._renderCallback=function(){return r.render()},r._onDatasetUpdateCallback=function(){return r._onDatasetUpdate()},r._propertyBindings=Sd.map();var n=new d4.Easing().maxTotalDuration(t._ANIMATION_MAX_DURATION);return r.animator(iKt.Animator.MAIN,n),r.animator(iKt.Animator.RESET,new d4.Null),r._deferredResetEntityStore=Md.Window.debounce(OHe.DeferredRenderer.DEFERRED_RENDERING_DELAY,r._resetEntityStore),r}return t.getTotalDrawTime=function(r,n){return n.reduce(function(i,o){return i+o.animator.totalTime(r.length)},0)},t.applyDrawSteps=function(r,n){var i=r.map(function(o){var a=o.attrToProjector,s={};return Object.keys(a).forEach(function(l){s[l]=function(c,u){return a[l](c,u,n)}}),{attrToAppliedProjector:s,animator:o.animator}});return i},t.prototype.anchor=function(r){return r=NHe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._dataChanged=!0,this._resetEntityStore(),this._updateExtents(),this},t.prototype._setup=function(){var r=this;this._isSetup||(e.prototype._setup.call(this),this._canvas!=null&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",!0),this.datasets().forEach(function(n){return r._createNodesForDataset(n)}))},t.prototype._appendCanvasNode=function(){var r=this.element().select(".plot-canvas-container");r.empty()&&(r=this.element().append("div").classed("plot-canvas-container",!0),r.node().appendChild(this._canvas.node()))},t.prototype.setBounds=function(r,n,i,o){if(e.prototype.setBounds.call(this,r,n,i,o),this._updateExtents(),this._canvas!=null){if(this._bufferCanvas&&!this._bufferCanvasValid){this._bufferCanvas.attr("width",this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height"));var a=this._bufferCanvas.node().getContext("2d");if(a){var s=this._canvas.node();s.width>0&&s.height>0?a.canvas.width>0&&a.canvas.height>0&&a.drawImage(s,0,0):console.warn("Failed to fill buffer canvas with with 0x0 canvas")}this._bufferCanvasValid=!0}var l=window.devicePixelRatio!=null?window.devicePixelRatio:1;this._canvas.attr("width",r*l),this._canvas.attr("height",n*l);var c=this._canvas.node().getContext("2d");if(c&&(c.setTransform(l,0,0,l,0,0),this._bufferCanvas)){var u=this._bufferCanvas.node();u.width>0&&u.height>0?c.canvas.width>0&&c.canvas.height>0&&c.drawImage(u,0,0,r,n):console.warn("Failed to fill canvas with 0x0 buffer canvas")}}return this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._scales().forEach(function(n){return n.offUpdate(r._renderCallback)}),this.datasets([])},t.prototype._createNodesForDataset=function(r){var n=this._datasetToDrawer.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._createDrawer=function(r){return new kHe.ProxyDrawer(function(){return new RHe.SVGDrawer("path","")},function(n){return new LHe.CanvasDrawer(n,function(){})})},t.prototype._getAnimator=function(r){return this._animateOnNextRender()?this._animators[r]||new d4.Null:new d4.Null},t.prototype._onDatasetUpdate=function(){this._updateExtents(),this._dataChanged=!0,this._resetEntityStore(),this.renderLowPriority()},t.prototype.attr=function(r,n,i){return n==null?this._attrBindings.get(r):(this._bindAttr(r,n,i),this.render(),this)},t.prototype._bindProperty=function(r,n,i,o){var a=this._propertyBindings.get(r),s=a!=null?a.scale:null,l=typeof n=="function"?n:function(){return n};this._propertyBindings.set(r,{accessor:l,scale:i,postScale:o}),s!=null&&this._uninstallScaleForKey(s,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._bindAttr=function(r,n,i){var o=this._attrBindings.get(r),a=o!=null?o.scale:null,s=typeof n=="function"?n:function(){return n};this._attrBindings.set(r,{accessor:s,scale:i}),a!=null&&this._uninstallScaleForKey(a,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector},t.prototype._getAttrToProjector=function(){if(this._cachedAttrToProjector==null){var r=this._generateAttrToProjector();t.OPTIMIZE_MEMOIZE_PROJECTORS&&(r=oat.memoizeProjectors(r)),this._cachedAttrToProjector=r}return Md.assign({},this._cachedAttrToProjector)},t.prototype._generateAttrToProjector=function(){var r={};this._attrBindings.each(function(i,o){r[o]=t._scaledAccessor(i)});var n=this._propertyProjectors();return Object.keys(n).forEach(function(i){r[i]==null&&(r[i]=n[i])}),r},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._isAnchored&&(this._paint(),this._dataChanged=!1),this},t.prototype.renderLowPriority=function(){return this._renderCallback(),this},t.prototype.animated=function(r){return r==null?this._animate:(this._animate=r,this)},t.prototype.detach=function(){return e.prototype.detach.call(this),this._updateExtents(),this},t.prototype._scales=function(){var r=[];return this._attrBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),this._propertyBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),r},t.prototype._updateExtents=function(){var r=this;this._resetEntityStore(),this._scales().forEach(function(n){return n.addIncludedValuesProvider(r._includedValuesProvider)})},t.prototype._filterForProperty=function(r){return null},t.prototype.getExtentsForAttr=function(r){var n=this;if(this._attrExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._attrBindings.get(r)},function(o,a){return a==null||a.accessor==null?null:o.map(function(s){return oKt(s,a,null)})});this._attrExtents[r]=i}return this._attrExtents[r]()},t.prototype.getExtentsForProperty=function(r){var n=this;if(this._propertyExtents[r]==null){var i=oat.memThunk(function(){return n.datasets()},function(){return n._propertyBindings.get(r)},function(){return n._filterForProperty(r)},function(o,a,s){return a==null||a.accessor==null?null:o.map(function(l){return oKt(l,a,s)})});this._propertyExtents[r]=i}return this._propertyExtents[r]()},t.prototype._includedValuesForScale=function(r,n){var i=this;if(!this._isAnchored&&!n)return[];var o=[];return this._attrBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForAttr(s);l!=null&&(o=o.concat(Sd.merge(l)))}}),this._propertyBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForProperty(s);l!=null&&(o=o.concat(Sd.merge(l)))}}),o},t.prototype.animator=function(r,n){return n===void 0?this._animators[r]:(this._animators[r]=n,this)},t.prototype.renderer=function(r){var n=this;return r===void 0?this._canvas==null?"svg":"canvas":(this._canvas==null&&r==="canvas"?(this._canvas=Sd.select(document.createElement("canvas")).classed("plot-canvas",!0),this._bufferCanvas=Sd.select(document.createElement("canvas")),this.element()!=null&&this._appendCanvasNode(),this._datasetToDrawer.forEach(function(i){i.useCanvas(n._canvas)}),this.render()):this._canvas!=null&&r=="svg"&&(this._canvas.remove(),this._canvas=null,this._bufferCanvas=null,this._datasetToDrawer.forEach(function(i){i.useSVG(n._renderArea)}),this.render()),this)},t.prototype.addDataset=function(r){return this._addDataset(r),this._onDatasetUpdate(),this},t.prototype._addDataset=function(r){this._removeDataset(r);var n=this._createDrawer(r);return this._datasetToDrawer.set(r,n),this._isSetup&&this._createNodesForDataset(r),r.onUpdate(this._onDatasetUpdateCallback),this},t.prototype.removeDataset=function(r){return this._removeDataset(r),this._onDatasetUpdate(),this},t.prototype._removeDataset=function(r){return this.datasets().indexOf(r)===-1?this:(this._removeDatasetNodes(r),r.offUpdate(this._onDatasetUpdateCallback),this._datasetToDrawer.delete(r),this)},t.prototype._removeDatasetNodes=function(r){var n=this._datasetToDrawer.get(r);n.remove()},t.prototype.datasets=function(r){var n=this,i=[];return this._datasetToDrawer.forEach(function(o,a){return i.push(a)}),r==null?i:(i.forEach(function(o){return n._removeDataset(o)}),r.forEach(function(o){return n._addDataset(o)}),this._onDatasetUpdate(),this)},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new d4.Null}]},t.prototype._additionalPaint=function(r){},t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=[];return r.forEach(function(o,a){for(var s=n._datasetToDrawer.get(o),l=0,c=o.data(),u=c.length,h=function(p){var d=c[p],g=n._pixelPoint(d,p,o);if(Md.Math.isNaN(g.x)||Md.Math.isNaN(g.y))return"continue";var _=n;i.push({datum:d,get position(){return _._pixelPoint.call(_,d,p,o)},index:p,dataset:o,datasetIndex:a,component:n,drawer:s,validDatumIndex:l}),l++},f=0;f<u;f++)h(f)}),i},t.prototype._getDataToDraw=function(){var r=new Md.Map;return this.datasets().forEach(function(n){return r.set(n,n.data())}),r},t.prototype._paint=function(){var r=this;delete this._cachedAttrToProjector;var n=this._generateDrawSteps(),i=this._getDataToDraw(),o=this.datasets().map(function(u){return r._datasetToDrawer.get(u)});if(this.renderer()==="canvas"){var a=this._canvas.node(),s=a.getContext("2d");s.clearRect(0,0,a.clientWidth,a.clientHeight),this._bufferCanvasValid=!1}this.datasets().forEach(function(u,h){var f=t.applyDrawSteps(n,u);o[h].draw(i.get(u),f)});var l=this.datasets().map(function(u,h){return t.getTotalDrawTime(i.get(u),n)}),c=Md.Math.max(l,0);this._additionalPaint(c)},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return Sd.selectAll();var i=[];return r.forEach(function(o){var a=n._datasetToDrawer.get(o);if(a!=null){var s=a.getVisualPrimitives();i.push.apply(i,s)}}),Sd.selectAll(i)},t.prototype.entities=function(r){var n=this;return this._getEntityStore(r).entities().map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype.filterEntities=function(r){var n=this;return this._getEntityStore().entities().filter(r).map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype._getEntityStore=function(r){var n=this,i=function(a){return n._entityBounds(a)};if(r!==void 0){var o=new Md.EntityStore;return o.addAll(this._buildLightweightPlotEntities(r),i,this._localOriginBounds()),o}else if(this._cachedEntityStore===void 0){var o=new Md.EntityStore;o.addAll(this._buildLightweightPlotEntities(this.datasets()),i,this._localOriginBounds()),this._cachedEntityStore=o}return this._cachedEntityStore},t.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset,a=this._pixelPoint(n,i,o),s=a.x,l=a.y;return{x:s,y:l,width:0,height:0}},t.prototype._lightweightPlotEntityToPlotEntity=function(r){var n={bounds:this._entityBounds(r),component:r.component,dataset:r.dataset,datasetIndex:r.datasetIndex,datum:r.datum,index:r.index,position:r.position,selection:Sd.select(r.drawer.getVisualPrimitiveAtIndex(r.validDatumIndex))};return n},t.prototype.entitiesAt=function(r){throw new Error("plots must implement entitiesAt")},t.prototype.entityNearest=function(r){var n=this._getEntityStore().entityNearest(r);return n===void 0?void 0:this._lightweightPlotEntityToPlotEntity(n)},t.prototype.entitiesIn=function(r,n){var i;if(n==null){var o=r;i={x:o.topLeft.x,y:o.topLeft.y,width:o.bottomRight.x-o.topLeft.x,height:o.bottomRight.y-o.topLeft.y}}else{var a=r;i={x:a.min,y:n.min,width:a.max-a.min,height:n.max-n.min}}return this.entitiesInBounds(i)},t.prototype.entitiesInBounds=function(r){var n=this,i=this._getEntityStore().entitiesInBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInXBounds=function(r){var n=this,i=this._getEntityStore().entitiesInXBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInYBounds=function(r){var n=this,i=this._getEntityStore().entitiesInYBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype._uninstallScaleForKey=function(r,n){r.offUpdate(this._renderCallback),r.offUpdate(this._deferredResetEntityStore),r.removeIncludedValuesProvider(this._includedValuesProvider)},t.prototype._installScaleForKey=function(r,n){r.onUpdate(this._renderCallback),r.onUpdate(this._deferredResetEntityStore),r.addIncludedValuesProvider(this._includedValuesProvider)},t.prototype._propertyProjectors=function(){return{}},t._scaledAccessor=function(r){var n=r.scale,i=r.accessor,o=r.postScale,a=n==null?i:function(l,c,u){return n.scale(i(l,c,u))},s=o==null?a:function(l,c,u){return o(a(l,c,u),l,c,u)};return s},t.prototype._pixelPoint=function(r,n,i){return{x:0,y:0}},t.prototype._animateOnNextRender=function(){return this._animate&&this._dataChanged},t.OPTIMIZE_MEMOIZE_PROJECTORS=!1,t._ANIMATION_MAX_DURATION=600,t}(IHe.Component);QF.Plot=zHe;function oKt(e,t,r){var n=t.accessor,i=t.scale;if(i==null)return[];var o=e.data();r!=null&&(o=o.filter(function(l,c){return r(l,c,e)}));var a=function(l,c){return n(l,c,e)},s=o.map(a);return i.extentOfValues(s)}});var aKt=H(aat=>{"use strict";Object.defineProperty(aat,"__esModule",{value:!0});var FHe=(de(),Ut(pe)),BHe=ns(),HHe=Fe(),VHe=zot(),UHe=function(e){FHe.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.entityNearest=function(r){var n,i=1/0;return this.components().forEach(function(o){var a=o,s=a.entityNearest(r);if(s!=null){var l=HHe.Math.distanceSquared(s.position,r);l<=i&&(i=l,n=s)}}),n},t.prototype.append=function(r){if(r!=null&&!(r instanceof BHe.Plot))throw new Error("Plot Group only accepts plots");return e.prototype.append.call(this,r),this},t}(VHe.Group);aat.PlotGroup=UHe});var sKt=H(sat=>{"use strict";Object.defineProperty(sat,"__esModule",{value:!0});var qHe=(de(),Ut(pe)),qu=(Er(),Ut(Mr)),Go=Fe(),GHe=WF(),WHe=function(e){qHe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._rowPadding=0,n._columnPadding=0,n._rows=[],n._rowWeights=[],n._columnWeights=[],n._nRows=0,n._nCols=0,n._calculatedLayout=null,n.addClass("table"),r.forEach(function(i,o){i.forEach(function(a,s){a!=null&&n.add(a,o,s)})}),n}return t.prototype._forEach=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)this._rows[n][i]!=null&&r(this._rows[n][i])},t.prototype.has=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return!0;return!1},t.prototype.componentAt=function(r,n){return r<0||r>=this._nRows||n<0||n>=this._nCols?null:this._rows[r][n]},t.prototype.add=function(r,n,i){if(r==null)throw Error("Cannot add null to a table cell");if(!this.has(r)){var o=this._rows[n]&&this._rows[n][i];if(o!=null)throw new Error("cell is occupied");r.detach(),this._nRows=Math.max(n+1,this._nRows),this._nCols=Math.max(i+1,this._nCols),this._padTableToSize(this._nRows,this._nCols),this._rows[n][i]=r,this._adoptAndAnchor(r),this.redraw()}return this},t.prototype._remove=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return this._rows[n][i]=null,!0;return!1},t.prototype._iterateLayout=function(r,n,i){i===void 0&&(i=!1);for(var o=this._rows,a=qu.transpose(this._rows),s=r-this._columnPadding*(this._nCols-1),l=n-this._rowPadding*(this._nRows-1),c=t._calcComponentWeights(this._rowWeights,o,function(z){return z==null||z.fixedHeight()}),u=t._calcComponentWeights(this._columnWeights,a,function(z){return z==null||z.fixedWidth()}),h=u.map(function(z){return z===0?.5:z}),f=c.map(function(z){return z===0?.5:z}),p=t._calcProportionalSpace(h,s),d=t._calcProportionalSpace(f,l),g=Go.Array.createFilledArray(0,this._nCols),_=Go.Array.createFilledArray(0,this._nRows),y,x,b=0,S,C,P;;){var k=Go.Array.add(_,d),O=Go.Array.add(g,p);S=this._determineGuarantees(O,k,i),g=S.guaranteedWidths,_=S.guaranteedHeights,C=S.wantsWidthArr.some(function(z){return z}),P=S.wantsHeightArr.some(function(z){return z});var D=y,B=x;y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights);var I=void 0;C?(I=S.wantsWidthArr.map(function(z){return z?.1:0}),I=Go.Array.add(I,u)):I=u;var L=void 0;P?(L=S.wantsHeightArr.map(function(z){return z?.1:0}),L=Go.Array.add(L,c)):L=c,p=t._calcProportionalSpace(I,y),d=t._calcProportionalSpace(L,x),b++;var R=y>0&&y!==D,F=x>0&&x!==B;if(!(R||F)||b>5)break}return y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights),p=t._calcProportionalSpace(u,y),d=t._calcProportionalSpace(c,x),{colProportionalSpace:p,rowProportionalSpace:d,guaranteedWidths:S.guaranteedWidths,guaranteedHeights:S.guaranteedHeights,wantsWidth:C,wantsHeight:P}},t.prototype._determineGuarantees=function(r,n,i){i===void 0&&(i=!1);var o=Go.Array.createFilledArray(0,this._nCols),a=Go.Array.createFilledArray(0,this._nRows),s=Go.Array.createFilledArray(!1,this._nCols),l=Go.Array.createFilledArray(!1,this._nRows);return this._rows.forEach(function(c,u){c.forEach(function(h,f){var p;h!=null?p=h.requestedSpace(r[f],n[u]):p={minWidth:0,minHeight:0};var d=i?Math.min(p.minWidth,r[f]):p.minWidth;o[f]=Math.max(o[f],d);var g=i?Math.min(p.minHeight,n[u]):p.minHeight;a[u]=Math.max(a[u],g);var _=p.minWidth>r[f];s[f]=s[f]||_;var y=p.minHeight>n[u];l[u]=l[u]||y})}),{guaranteedWidths:o,guaranteedHeights:a,wantsWidthArr:s,wantsHeightArr:l}},t.prototype.requestedSpace=function(r,n){return this._calculatedLayout=this._iterateLayout(r,n),{minWidth:qu.sum(this._calculatedLayout.guaranteedWidths),minHeight:qu.sum(this._calculatedLayout.guaranteedHeights)}},t.prototype.computeLayout=function(r,n,i){var o=this;e.prototype.computeLayout.call(this,r,n,i);var a=qu.sum(this._calculatedLayout.guaranteedWidths),s=qu.sum(this._calculatedLayout.guaranteedHeights),l=this._calculatedLayout;(a>this.width()||s>this.height())&&(l=this._iterateLayout(this.width(),this.height(),!0));var c=0,u=Go.Array.add(l.rowProportionalSpace,l.guaranteedHeights),h=Go.Array.add(l.colProportionalSpace,l.guaranteedWidths);return this._rows.forEach(function(f,p){var d=0;f.forEach(function(g,_){g!=null&&g.computeLayout({x:d,y:c},h[_],u[p]),d+=h[_]+o._columnPadding}),c+=u[p]+o._rowPadding}),this},t.prototype.rowPadding=function(r){if(r==null)return this._rowPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("rowPadding must be a non-negative finite value");return this._rowPadding=r,this.redraw(),this},t.prototype.columnPadding=function(r){if(r==null)return this._columnPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("columnPadding must be a non-negative finite value");return this._columnPadding=r,this.redraw(),this},t.prototype.rowWeight=function(r,n){if(n==null)return this._rowWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("rowWeight must be a non-negative finite value");return this._rowWeights[r]=n,this.redraw(),this},t.prototype.columnWeight=function(r,n){if(n==null)return this._columnWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("columnWeight must be a non-negative finite value");return this._columnWeights[r]=n,this.redraw(),this},t.prototype.fixedWidth=function(){var r=qu.transpose(this._rows);return t._fixedSpace(r,function(n){return n==null||n.fixedWidth()})},t.prototype.fixedHeight=function(){return t._fixedSpace(this._rows,function(r){return r==null||r.fixedHeight()})},t.prototype._padTableToSize=function(r,n){for(var i=0;i<r;i++){this._rows[i]===void 0&&(this._rows[i]=[],this._rowWeights[i]=null);for(var o=0;o<n;o++)this._rows[i][o]===void 0&&(this._rows[i][o]=null)}for(var o=0;o<n;o++)this._columnWeights[o]===void 0&&(this._columnWeights[o]=null)},t._calcComponentWeights=function(r,n,i){return r.map(function(o,a){if(o!=null)return o;var s=n[a].map(i),l=s.reduce(function(c,u){return c&&u},!0);return l?0:1})},t._calcProportionalSpace=function(r,n){var i=qu.sum(r);return i===0?Go.Array.createFilledArray(0,r.length):r.map(function(o){return n*o/i})},t._fixedSpace=function(r,n){var i=function(a){return a.reduce(function(s,l){return s&&l},!0)},o=function(a){return i(a.map(n))};return i(r.map(o))},t}(GHe.ComponentContainer);sat.Table=WHe});var lKt=H(lat=>{"use strict";Object.defineProperty(lat,"__esModule",{value:!0});var YHe=(de(),Ut(pe)),jHe=Vot(),XHe=2,$He=function(e){YHe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._maxLines=XHe,r}return t.prototype.requestedSpace=function(r,n){this._wrapper.maxLines(this._maxLines);var i=this.angle()===0?r:n;i===0&&(i=1/0);var o=this._wrapper.wrap(this._text,this._measurer,i),a=this._measurer.measure(o.wrappedText),s=(this.angle()===0?a.width:a.height)+2*this.padding(),l=(this.angle()===0?a.height:a.width)+2*this.padding();return{minWidth:s,minHeight:l}},t.prototype.maxLines=function(r){return arguments.length===0?this._maxLines:(this._maxLines=r,this.redraw(),this)},t}(jHe.Label);lat.WrappedLabel=$He});var cKt=H(cat=>{"use strict";Object.defineProperty(cat,"__esModule",{value:!0});var KHe=(de(),Ut(pe)),ZHe=qF(),JHe=function(e){KHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("x-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:r.topLeft.x,y:0},bottomRight:{x:r.bottomRight.x,y:this.height()}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")},t.prototype.yScale=function(r){if(r==null)return e.prototype.yScale.call(this);throw new Error("yScales cannot be set on an XDragBoxLayer")},t.prototype.yExtent=function(r){if(r==null)return e.prototype.yExtent.call(this);throw new Error("XDragBoxLayer has no yExtent")},t}(ZHe.DragBoxLayer);cat.XDragBoxLayer=JHe});var uKt=H(uat=>{"use strict";Object.defineProperty(uat,"__esModule",{value:!0});var QHe=(de(),Ut(pe)),tVe=qF(),eVe=function(e){QHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("y-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:0,y:r.topLeft.y},bottomRight:{x:this.width(),y:r.bottomRight.y}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")},t.prototype.xScale=function(r){if(r==null)return e.prototype.xScale.call(this);throw new Error("xScales cannot be set on an YDragBoxLayer")},t.prototype.xExtent=function(r){if(r==null)return e.prototype.xExtent.call(this);throw new Error("YDragBoxLayer has no xExtent")},t}(tVe.DragBoxLayer);uat.YDragBoxLayer=eVe});var Pot=H(ya=>{"use strict";Object.defineProperty(ya,"__esModule",{value:!0});var Ds=(de(),Ut(pe));Ds.__exportStar(qF(),ya);Ds.__exportStar(I$t(),ya);Ds.__exportStar(L$t(),ya);Ds.__exportStar(zot(),ya);Ds.__exportStar(Lot(),ya);Ds.__exportStar(R$t(),ya);Ds.__exportStar(Vot(),ya);Ds.__exportStar(N$t(),ya);Ds.__exportStar(aKt(),ya);Ds.__exportStar(Tot(),ya);Ds.__exportStar(sKt(),ya);Ds.__exportStar(lKt(),ya);Ds.__exportStar(cKt(),ya);Ds.__exportStar(uKt(),ya)});var fat=H(hat=>{"use strict";Object.defineProperty(hat,"__esModule",{value:!0});var rVe=(de(),Ut(pe)),nVe=Of(),iVe=function(e){rVe.__extends(t,e);function t(){return e.call(this,"path","arc fill")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t}(nVe.SVGDrawer);hat.ArcSVGDrawer=iVe});var dat=H(pat=>{"use strict";Object.defineProperty(pat,"__esModule",{value:!0});var oVe=(de(),Ut(pe)),aVe=Of(),sVe=function(e){oVe.__extends(t,e);function t(){return e.call(this,"path","arc outline")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t}(aVe.SVGDrawer);pat.ArcOutlineSVGDrawer=sVe});var mat=H(eB=>{"use strict";Object.defineProperty(eB,"__esModule",{value:!0});var lVe=(de(),Ut(pe)),tB=Bv(),cVe=Of(),uVe=function(e){lVe.__extends(t,e);function t(){return e.call(this,"path","area")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(cVe.SVGDrawer);eB.AreaSVGDrawer=uVe;var hVe=["opacity","fill","fill-opacity"],fVe=["opacity","stroke","stroke-width"];function pVe(e,t){return function(r,n,i){var o=tB.resolveAttributes(i,hVe,n[0],0);tB.renderArea(r,e(),n[0],o);var a=tB.resolveAttributes(i,fVe,n[0],0);tB.renderLine(r,t(),n[0],a)}}eB.makeAreaCanvasDrawStep=pVe});var nB=H(rB=>{"use strict";Object.defineProperty(rB,"__esModule",{value:!0});var dVe=(de(),Ut(pe)),hKt=Bv(),mVe=Of(),gVe=function(e){dVe.__extends(t,e);function t(){return e.call(this,"path","line")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(mVe.SVGDrawer);rB.LineSVGDrawer=gVe;var _Ve=["opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function yVe(e){return function(t,r,n){var i=hKt.resolveAttributes(n,_Ve,r[0],0);hKt.renderLine(t,e(),r[0],i)}}rB.makeLineCanvasDrawStep=yVe});var oB=H(PS=>{"use strict";Object.defineProperty(PS,"__esModule",{value:!0});var fKt=(de(),Ut(pe)),iB=Bv(),vVe=Of(),xVe=function(e){fKt.__extends(t,e);function t(r){r===void 0&&(r="");var n=e.call(this,"rect","")||this;return n._rootClassName=r,n._root.classed(n._rootClassName,!0),n}return t}(vVe.SVGDrawer);PS.RectangleSVGDrawer=xVe;var bVe=iB.ContextStyleAttrs.concat(["x","y","width","height"]);PS.RectangleCanvasDrawStep=function(e,t,r){e.save();for(var n=t.length,i=0;i<n;i++){var o=t[i];if(o!=null){var a=iB.resolveAttributes(r,bVe,o,i);e.beginPath(),e.rect(a.x,a.y,a.width,a.height),iB.renderPathWithStyle(e,a)}}e.restore()};var wVe=function(e){fKt.__extends(t,e);function t(r){return e.call(this,r,PS.RectangleCanvasDrawStep)||this}return t}(iB.CanvasDrawer);PS.RectangleCanvasDrawer=wVe});var _at=H(gat=>{"use strict";Object.defineProperty(gat,"__esModule",{value:!0});var SVe=(de(),Ut(pe)),MVe=Of(),EVe=function(e){SVe.__extends(t,e);function t(){return e.call(this,"line","")||this}return t}(MVe.SVGDrawer);gat.SegmentSVGDrawer=EVe});var pKt=H(yat=>{"use strict";Object.defineProperty(yat,"__esModule",{value:!0});var TVe=function(){function e(t,r,n){n===void 0&&(n=window.devicePixelRatio),this.screenWidth=t,this.screenHeight=r,this.devicePixelRatio=n,this.pixelWidth=t*n,this.pixelHeight=r*n,this.canvas=document.createElement("canvas"),this.ctx=this.canvas.getContext("2d"),e.sizePixels(this.ctx,t,r,n)}return e.sizePixels=function(t,r,n,i){var o=t.canvas;o.width=r*i,o.height=n*i,o.style.width=r+"px",o.style.height=n+"px",t.setTransform(1,0,0,1,0,0),t.scale(i,i)},e.prototype.blit=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),t.drawImage(this.canvas,r,n,this.screenWidth,this.screenHeight)},e.prototype.blitCenter=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),this.blit(t,Math.floor(r-this.screenWidth/2),Math.floor(n-this.screenHeight/2))},e.prototype.resize=function(t,r,n){n===void 0&&(n=!1);var i=this.devicePixelRatio;return this.screenWidth=t,this.screenHeight=r,this.pixelWidth=t*i,this.pixelHeight=r*i,e.sizePixels(this.ctx,t,r,i),n&&this.ctx.translate(t/2,t/2),this},e.prototype.clear=function(t){var r=this,n=r.pixelWidth,i=r.pixelHeight,o=r.ctx;return o.save(),o.setTransform(1,0,0,1,0,0),t==null?o.clearRect(0,0,n,i):(o.fillStyle=t,o.fillRect(0,0,n,i)),o.restore(),this},e.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)},e}();yat.CanvasBuffer=TVe});var vat=H(aB=>{"use strict";Object.defineProperty(aB,"__esModule",{value:!0});var CVe=(de(),Ut(pe)),m4=Bv(),AVe=pKt(),PVe=Of(),IVe=function(e){CVe.__extends(t,e);function t(){return e.call(this,"path","symbol")||this}return t}(PVe.SVGDrawer);aB.SymbolSVGDrawer=IVe;var LVe=m4.ContextStyleAttrs.concat(["x","y"]);function kVe(e,t,r,n){var i=this;return function(o,a,s){for(var l=o.canvas,c=l.clientWidth,u=l.clientHeight,h=n===void 0?new AVe.CanvasBuffer(0,0):n,f=t(),p=r(),d=null,g=null,_=null,y=0;y<a.length;y++){var x=a[y];if(x!=null){var b=m4.resolveAttributes(s,LVe,x,y),S=p(x,y,e);if(!!RVe(c,u,b.x,b.y,S)){var C=NVe(d,b,m4.ContextStyleAttrs),P=f(x,y,i._dataset);if(!(C&&_==S&&g==P)){var k=m4.getStrokeWidth(b),O=S+k+1;(O>h.screenWidth||O>h.screenHeight)&&h.resize(O,O,!0),h.clear();var D=h.ctx;D.beginPath(),P(S).context(D)(null),D.closePath(),m4.renderPathWithStyle(D,b),g=P,_=S,d=b}h.blitCenter(o,b.x,b.y)}}}}}aB.makeSymbolCanvasDrawStep=kVe;function RVe(e,t,r,n,i){return r+i>=0&&r-i<=e&&n+i>=0&&n-i<=t}function NVe(e,t,r){if(e==null)return!1;for(var n=0;n<r.length;n++){var i=r[n];if(e[i]!=t[i])return!1}return!0}});var Hv=H(Dc=>{"use strict";Object.defineProperty(Dc,"__esModule",{value:!0});var zf=(de(),Ut(pe));zf.__exportStar(fat(),Dc);zf.__exportStar(dat(),Dc);zf.__exportStar(mat(),Dc);zf.__exportStar(Bv(),Dc);zf.__exportStar(Uu(),Dc);zf.__exportStar(nB(),Dc);zf.__exportStar(oB(),Dc);zf.__exportStar(_at(),Dc);zf.__exportStar(Of(),Dc);zf.__exportStar(vat(),Dc)});var Vv=H(bat=>{"use strict";Object.defineProperty(bat,"__esModule",{value:!0});var DVe=(de(),Ut(pe)),dKt=Rs(),xat=Fe(),OVe=iat(),g4=ns(),zVe=function(e){DVe.__extends(t,e);function t(){var r=e.call(this)||this;return r._autoAdjustXScaleDomain=!1,r._autoAdjustYScaleDomain=!1,r._deferredRendering=!1,r._applyDeferredRenderingTransform=function(n,i,o,a){!r._isAnchored||(r._renderArea!=null&&r._renderArea.attr("transform","translate("+n+", "+i+") scale("+o+", "+a+")"),r._canvas!=null&&r._canvas.style("transform","translate("+n+"px, "+i+"px) scale("+o+", "+a+")"))},r.addClass("xy-plot"),r._adjustYDomainOnChangeFromXCallback=function(n){return r._adjustYDomainOnChangeFromX()},r._adjustXDomainOnChangeFromYCallback=function(n){return r._adjustXDomainOnChangeFromY()},r._renderCallback=function(){if(r.deferredRendering()){var n=r.x()&&r.x().scale,i=r.y()&&r.y().scale;r._deferredRenderer.updateDomains(n,i)}else r.render()},r._deferredRenderer=new OVe.DeferredRenderer(function(){return r.render()},r._applyDeferredRenderingTransform),r}return t.prototype.render=function(){return this.deferredRendering()&&this._deferredRenderer.resetTransforms(),e.prototype.render.call(this)},t.prototype.deferredRendering=function(r){if(r==null)return this._deferredRendering;if(r){var n=this.x()&&this.x().scale,i=this.y()&&this.y().scale;this._deferredRenderer.setDomains(n,i)}return this._deferredRendering=r,this},t.prototype.x=function(r,n,i){if(r==null)return this._propertyBindings.get(t._X_KEY);this._bindProperty(t._X_KEY,r,n,i);var o=this.width();return n!=null&&o!=null&&n.range([0,o]),this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain(),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return this._propertyBindings.get(t._Y_KEY);this._bindProperty(t._Y_KEY,r,n,i);var o=this.height();return n!=null&&o!=null&&(n instanceof dKt.Category?n.range([0,o]):n.range([o,0])),this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain(),this.render(),this},t.prototype._filterForProperty=function(r){return r==="x"&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):(r==="y"||r==="y0")&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null},t.prototype._makeFilterByProperty=function(r){var n=this._propertyBindings.get(r);if(n!=null){var i=n.accessor,o=n.scale;if(o!=null)return function(a,s,l){var c=o.range();return xat.Math.inRange(o.scale(i(a,s,l)),c[0],c[1])}}return null},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.offUpdate(i)},t.prototype._installScaleForKey=function(r,n){e.prototype._installScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.onUpdate(i)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback),this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback),this},t.prototype.autorangeMode=function(r){if(r==null)return this._autoAdjustXScaleDomain?"x":this._autoAdjustYScaleDomain?"y":"none";switch(r){case"x":this._autoAdjustXScaleDomain=!0,this._autoAdjustYScaleDomain=!1,this._adjustXDomainOnChangeFromY();break;case"y":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!0,this._adjustYDomainOnChangeFromX();break;case"none":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!1;break;default:throw new Error("Invalid scale name '"+r+"', must be 'x', 'y' or 'none'")}return this},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this.x(),a=o&&o.scale;a!=null&&a.range([0,this.width()]);var s=this.y(),l=s&&s.scale;return l!=null&&(l instanceof dKt.Category?l.range([0,this.height()]):l.range([this.height(),0])),this},t.prototype._updateXExtentsAndAutodomain=function(){var r=this.x().scale;r!=null&&r.autoDomain()},t.prototype._updateYExtentsAndAutodomain=function(){var r=this.y().scale;r!=null&&r.autoDomain()},t.prototype.showAllData=function(){return this._updateXExtentsAndAutodomain(),this._updateYExtentsAndAutodomain(),this},t.prototype._adjustYDomainOnChangeFromX=function(){!this._projectorsReady()||this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()},t.prototype._adjustXDomainOnChangeFromY=function(){!this._projectorsReady()||this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()},t.prototype._projectorsReady=function(){var r=this.x(),n=this.y();return r!=null&&r.accessor!=null&&n!=null&&n.accessor!=null},t.prototype._pixelPoint=function(r,n,i){var o=g4.Plot._scaledAccessor(this.x()),a=g4.Plot._scaledAccessor(this.y());return{x:o(r,n,i),y:a(r,n,i)}},t.prototype._getDataToDraw=function(){var r=this,n=e.prototype._getDataToDraw.call(this),i=this.attr("defined"),o=function(a,s,l){var c=g4.Plot._scaledAccessor(r.x())(a,s,l),u=g4.Plot._scaledAccessor(r.y())(a,s,l);return i&&i.accessor(a,s,l)===!1?!1:xat.Math.isValidNumber(c)&&xat.Math.isValidNumber(u)};return this.datasets().forEach(function(a){n.set(a,n.get(a).filter(function(s,l){return o(s,l,a)}))}),n},t._X_KEY="x",t._Y_KEY="y",t}(g4.Plot);bat.XYPlot=zVe});var Sat=H(lB=>{"use strict";Object.defineProperty(lB,"__esModule",{value:!0});var FVe=(de(),Ut(pe)),va=(Er(),Ut(Mr)),BVe=kf(),HVe=Hv(),VVe=Uu(),mKt=nB(),UVe=Rs(),sB=xd(),t0=Fe(),qVe=Lf(),wat=IS(),xl=ns(),GVe=Vv(),gKt={linear:va.curveLinear,linearClosed:va.curveLinearClosed,step:va.curveStep,stepBefore:va.curveStepBefore,stepAfter:va.curveStepAfter,basis:va.curveBasis,basisOpen:va.curveBasisOpen,basisClosed:va.curveBasisClosed,bundle:va.curveBundle,cardinal:va.curveCardinal,cardinalOpen:va.curveCardinalOpen,cardinalClosed:va.curveCardinalClosed,monotone:va.curveMonotoneX};lB.CurveName=qVe.makeEnum(["linear","linearClosed","step","stepBefore","stepAfter","basis","basisOpen","basisClosed","bundle","cardinal","cardinalOpen","cardinalClosed","monotone"]);var WVe=function(e){FVe.__extends(t,e);function t(){var r=e.call(this)||this;r._curve="linear",r._autorangeSmooth=!1,r._croppedRenderingEnabled=!0,r._collapseDenseVerticalLinesEnabled=!1,r._downsamplingEnabled=!1,r.addClass("line-plot");var n=new BVe.Easing;return n.stepDuration(xl.Plot._ANIMATION_MAX_DURATION),n.easingMode("expInOut"),n.maxTotalDuration(xl.Plot._ANIMATION_MAX_DURATION),r.animator(wat.Animator.MAIN,n),r.attr("stroke",new UVe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype.x=function(r,n,i){return r==null?e.prototype.x.call(this):(e.prototype.x.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.y=function(r,n,i){return r==null?e.prototype.y.call(this):(e.prototype.y.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.autorangeMode=function(r){return r==null?e.prototype.autorangeMode.call(this):(e.prototype.autorangeMode.call(this,r),this._setScaleSnapping(),this)},t.prototype.autorangeSmooth=function(r){return r==null?this._autorangeSmooth:(this._autorangeSmooth=r,this._setScaleSnapping(),this)},t.prototype._setScaleSnapping=function(){this.autorangeMode()==="x"&&this.x()&&this.x().scale&&this.x().scale instanceof sB.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth()),this.autorangeMode()==="y"&&this.y()&&this.y().scale&&this.y().scale instanceof sB.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())},t.prototype.curve=function(r){return r==null?this._curve:(this._curve=r,this.render(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?this._downsamplingEnabled:(this._downsamplingEnabled=r,this)},t.prototype.croppedRenderingEnabled=function(r){return r==null?this._croppedRenderingEnabled:(this._croppedRenderingEnabled=r,this.render(),this)},t.prototype.collapseDenseLinesEnabled=function(r){return r==null?this._collapseDenseVerticalLinesEnabled:(this._collapseDenseVerticalLinesEnabled=r,this.render(),this)},t.prototype._createDrawer=function(r){var n=this;return new VVe.ProxyDrawer(function(){return new mKt.LineSVGDrawer},function(i){return new HVe.CanvasDrawer(i,mKt.makeLineCanvasDrawStep(function(){return n._d3LineFactory(r)}))})},t.prototype.getExtentsForProperty=function(r){var n=e.prototype.getExtentsForProperty.call(this,r);if(!this._autorangeSmooth||this.autorangeMode()!==r||this.autorangeMode()!=="x"&&this.autorangeMode()!=="y")return n;var i=this._getEdgeIntersectionPoints(),o;return this.autorangeMode()==="y"?o=i.left.concat(i.right).map(function(a){return a.y}):o=i.top.concat(i.bottom).map(function(a){return a.x}),n.map(function(a){return va.extent(va.merge([a,o]))})},t.prototype._getEdgeIntersectionPoints=function(){var r=this;if(!(this.y().scale instanceof sB.QuantitativeScale&&this.x().scale instanceof sB.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};var n=this.y().scale,i=this.x().scale,o={left:[],right:[],top:[],bottom:[]},a=i.scale(i.domain()[0]),s=i.scale(i.domain()[1]),l=n.scale(n.domain()[0]),c=n.scale(n.domain()[1]);return this.datasets().forEach(function(u){for(var h=u.data(),f,p,d,g,_,y,x,b,S=1;S<h.length;S++)_=x||i.scale(r.x().accessor(h[S-1],S-1,u)),y=b||n.scale(r.y().accessor(h[S-1],S-1,u)),x=i.scale(r.x().accessor(h[S],S,u)),b=n.scale(r.y().accessor(h[S],S,u)),_<a==a<=x&&(f=a-_,p=x-_,g=b-y,d=f*g/p,o.left.push({x:a,y:n.invert(y+d)})),_<s==s<=x&&(f=s-_,p=x-_,g=b-y,d=f*g/p,o.right.push({x:s,y:n.invert(y+d)})),y<c==c<=b&&(p=x-_,d=c-y,g=b-y,f=d*p/g,o.top.push({x:i.invert(_+f),y:c})),y<l==l<=b&&(p=x-_,d=l-y,g=b-y,f=d*p/g,o.bottom.push({x:i.invert(_+f),y:l}))}),o},t.prototype._getResetYFunction=function(){var r=this.y().scale.domain(),n=Math.max(r[0],r[1]),i=Math.min(r[0],r[1]),o=n<0&&n||i>0&&i||0,a=this.y().scale.scale(o);return function(s,l,c){return a}},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructLineProjector(xl.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(wat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(wat.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=e.prototype._generateAttrToProjector.call(this);return Object.keys(r).forEach(function(n){if(n!=="d"){var i=r[n];r[n]=function(o,a,s){return o.length>0?i(o[0],a,s):null}}}),r},t.prototype.entitiesAt=function(r){var n=this.entityNearestByXThenY(r);return n!=null?[n]:[]},t.prototype.entityNearestByXThenY=function(r){for(var n=1/0,i=1/0,o,a=this.bounds(),s=this.entities(),l=s.length,c=0;c<l;c++){var u=s[c];if(!!t0.Math.within(u.position,a)){var h=Math.abs(r.x-u.position.x),f=Math.abs(r.y-u.position.y);(h<n||h===n&&f<i)&&(o=u,n=h,i=f)}}return o},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.d=this._constructLineProjector(xl.Plot._scaledAccessor(this.x()),xl.Plot._scaledAccessor(this.y())),r},t.prototype._constructLineProjector=function(r,n){var i=this;return function(o,a,s){return i._d3LineFactory(s,r,n)(o)}},t.prototype._d3LineFactory=function(r,n,i){n===void 0&&(n=xl.Plot._scaledAccessor(this.x())),i===void 0&&(i=xl.Plot._scaledAccessor(this.y()));var o=function(a,s,l){var c=n(a,s,l),u=i(a,s,l);return t0.Math.isValidNumber(c)&&t0.Math.isValidNumber(u)};return va.line().x(function(a,s){return n(a,s,r)}).y(function(a,s){return i(a,s,r)}).curve(this._getCurveFactory()).defined(function(a,s){return o(a,s,r)})},t.prototype._getCurveFactory=function(){var r=this.curve();if(typeof r=="string"){var n=gKt[r];return n==null?gKt.linear:n}else return r},t.prototype._getDataToDraw=function(){var r=this,n=new t0.Map;return this.datasets().forEach(function(i){var o=i.data();if(!r._croppedRenderingEnabled&&!r._downsamplingEnabled){n.set(i,[o]);return}for(var a=[],s=o.length,l=0;l<s;l++)a[l]=l;r._croppedRenderingEnabled&&(a=r._filterCroppedRendering(i,a)),r._downsamplingEnabled&&(a=r._filterDownsampling(i,a)),r._collapseDenseVerticalLinesEnabled&&(a=r._filterDenseLines(i,a));for(var c=[],u=a.length,l=0;l<u;l++){var h=a[l];c[l]=o[h]}n.set(i,[c])}),n},t.prototype._filterCroppedRendering=function(r,n){for(var i=this,o=xl.Plot._scaledAccessor(this.x()),a=xl.Plot._scaledAccessor(this.y()),s=r.data(),l=[],c=function(x,b){return t0.Math.inRange(x,0,i.width())&&t0.Math.inRange(b,0,i.height())},u=0;u<n.length;u++){var h=o(s[n[u]],n[u],r),f=a(s[n[u]],n[u],r),p=c(h,f);if(!p&&n[u-1]!=null&&s[n[u-1]]!=null){var d=o(s[n[u-1]],n[u-1],r),g=a(s[n[u-1]],n[u-1],r);p=p||c(d,g)}if(!p&&n[u+1]!=null&&s[n[u+1]]!=null){var _=o(s[n[u+1]],n[u+1],r),y=a(s[n[u+1]],n[u+1],r);p=p||c(_,y)}p&&l.push(n[u])}return l},t.prototype._filterDownsampling=function(r,n){if(n.length===0)return[];for(var i=r.data(),o=xl.Plot._scaledAccessor(this.x()),a=xl.Plot._scaledAccessor(this.y()),s=[n[0]],l=function(k,O){var D=o(i[n[k]],n[k],r),B=a(i[n[k]],n[k],r),I=o(i[n[k+1]],n[k+1],r),L=a(i[n[k+1]],n[k+1],r);if(O===1/0)return Math.floor(D)===Math.floor(I);var R=B+(I-D)*O;return Math.floor(L)===Math.floor(R)},c=0;c<n.length-1;){for(var u=n[c],h=o(i[n[c]],n[c],r),f=a(i[n[c]],n[c],r),p=o(i[n[c+1]],n[c+1],r),d=a(i[n[c+1]],n[c+1],r),g=Math.floor(h)===Math.floor(p)?1/0:(d-f)/(p-h),_=n[c],y=g===1/0?f:h,x=_,b=y,S=!0;c<n.length-1&&(S||l(c,g));){c++,S=!1;var C=g===1/0?a(i[n[c]],n[c],r):o(i[n[c]],n[c],r);C>b&&(b=C,x=n[c]),C<y&&(y=C,_=n[c])}var P=n[c];_!==u&&s.push(_),x!==_&&x!==u&&s.push(x),P!==u&&P!==_&&P!==x&&s.push(P)}return s},t.prototype._filterDenseLines=function(r,n){if(n.length===0)return[];var i=r.data(),o=xl.Plot._scaledAccessor(this.x()),a=xl.Plot._scaledAccessor(this.y()),s=function(c){return o(i[c],c,r)},l=function(c){return a(i[c],c,r)};return this._bucketByX(r,n,s,l)},t.prototype._bucketByX=function(r,n,i,o){for(var a=[],s=r.data(),l=null,c=n.length,u=0;u<=c;++u){var h=n[u];if(s[h]!=null){var f=Math.floor(i(h)),p=o(h);l==null?l=new t0.Bucket(h,f,p):l.isInBucket(f)?l.addToBucket(p,h):(a.push.apply(a,l.getUniqueIndices()),l=new t0.Bucket(h,f,p))}}return l!=null&&a.push.apply(a,l.getUniqueIndices()),a},t}(GVe.XYPlot);lB.Line=WVe});var Tat=H(Eat=>{"use strict";Object.defineProperty(Eat,"__esModule",{value:!0});var YVe=(de(),Ut(pe)),cB=(Er(),Ut(Mr)),jVe=Rs(),_4=Fe(),Mat=Hv(),_Kt=mat(),XVe=Uu(),yKt=nB(),uB=IS(),$Ve=Sat(),Os=ns(),KVe=function(e){YVe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("area-plot"),r.y0(0),r.attr("fill-opacity",.25),r.attr("fill",new jVe.Color().range()[0]),r._lineDrawers=new _4.Map,r}return t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),n!=null){var i=this.y0().accessor;i!=null&&this._bindProperty(t._Y0_KEY,i,n),this._updateYScale()}return this},t.prototype.y0=function(r){if(r==null)return this._propertyBindings.get(t._Y0_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y0_KEY,r,i),this._updateYScale(),this.render(),this},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updateYScale()},t.prototype._addDataset=function(r){var n=this;return this._lineDrawers.set(r,new Mat.ProxyDrawer(function(){return new yKt.LineSVGDrawer},function(i){return new Mat.CanvasDrawer(i,yKt.makeLineCanvasDrawStep(function(){var o=Os.Plot._scaledAccessor(n.x()),a=Os.Plot._scaledAccessor(n.y());return n._d3LineFactory(r,o,a)}))})),e.prototype._addDataset.call(this,r),this},t.prototype._createNodesForDataset=function(r){e.prototype._createNodesForDataset.call(this,r);var n=this._lineDrawers.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._lineDrawers.get(r).remove()},t.prototype._additionalPaint=function(){var r=this,n=this._generateLineDrawSteps(),i=this._getDataToDraw();this.datasets().forEach(function(o){var a=Os.Plot.applyDrawSteps(n,o);r._lineDrawers.get(o).draw(i.get(o),a)})},t.prototype._generateLineDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._generateLineAttrToProjector();n.d=this._constructLineProjector(Os.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._generateLineAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._generateLineAttrToProjector=function(){var r=this._getAttrToProjector();return r.d=this._constructLineProjector(Os.Plot._scaledAccessor(this.x()),Os.Plot._scaledAccessor(this.y())),r},t.prototype._createDrawer=function(r){var n=this;return new XVe.ProxyDrawer(function(){return new _Kt.AreaSVGDrawer},function(i){return new Mat.CanvasDrawer(i,_Kt.makeAreaCanvasDrawStep(function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=o[2],c=n._createDefinedProjector(a,s);return n._createAreaGenerator(a,s,l,c,r)},function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=n._createDefinedProjector(a,s);return n._createTopLineGenerator(a,s,l,r)}))})},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructAreaProjector(Os.Plot._scaledAccessor(this.x()),this._getResetYFunction(),Os.Plot._scaledAccessor(this.y0())),r.push({attrToProjector:n,animator:this._getAnimator(uB.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(uB.Animator.MAIN)}),r},t.prototype._updateYScale=function(){var r=this.getExtentsForProperty("y0"),n=_4.Array.flatten(r),i=_4.Array.uniq(n),o=i.length===1?i[0]:null,a=this.y(),s=a&&a.scale;s!=null&&(this._constantBaselineValueProvider!=null&&(s.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),o!=null&&(this._constantBaselineValueProvider=function(){return[o]},s.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))},t.prototype._getResetYFunction=function(){return Os.Plot._scaledAccessor(this.y0())},t.prototype._coordinateProjectors=function(){return[Os.Plot._scaledAccessor(this.x()),Os.Plot._scaledAccessor(this.y()),Os.Plot._scaledAccessor(this.y0())]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return cB.selectAll();var i=e.prototype.selections.call(this,r).nodes(),o=r.map(function(a){return n._lineDrawers.get(a)}).filter(function(a){return a!=null});return o.forEach(function(a){return i.push.apply(i,a.getVisualPrimitives())}),cB.selectAll(i)},t.prototype._constructAreaProjector=function(r,n,i){var o=this,a=this._createDefinedProjector(Os.Plot._scaledAccessor(this.x()),Os.Plot._scaledAccessor(this.y()));return function(s,l,c){var u=o._createAreaGenerator(r,n,i,a,c);return u(s)}},t.prototype._createDefinedProjector=function(r,n){return function(i,o,a){var s=r(i,o,a),l=n(i,o,a);return _4.Math.isValidNumber(s)&&_4.Math.isValidNumber(l)}},t.prototype._createAreaGenerator=function(r,n,i,o,a){var s=this._getCurveFactory(),l=cB.area().x(function(c,u){return r(c,u,a)}).y1(function(c,u){return n(c,u,a)}).y0(function(c,u){return i(c,u,a)}).curve(s).defined(function(c,u){return o(c,u,a)});return l},t.prototype._createTopLineGenerator=function(r,n,i,o){var a=this._getCurveFactory(),s=cB.line().x(function(l,c){return r(l,c,o)}).y(function(l,c){return n(l,c,o)}).curve(a).defined(function(l,c){return i(l,c,o)});return s},t._Y0_KEY="y0",t}($Ve.Line);Eat.Area=KVe});var y4=H(Gu=>{"use strict";Object.defineProperty(Gu,"__esModule",{value:!0});var ZVe=(de(),Ut(pe)),Aat=(Er(),Ut(Mr)),Cat=yl(),JVe=kf(),QVe=Bu(),tUe=Hv(),eUe=Uu(),rUe=oB(),nUe=CS(),Pat=Rs(),vKt=xd(),bl=Fe(),Lat=Lf(),xKt=IS(),hB=ns(),iUe=Vv();Gu.BarOrientation=Lat.makeEnum(["vertical","horizontal"]);Gu.LabelsPosition=Lat.makeEnum(["start","middle","end","outside"]);Gu.BarAlignment=Lat.makeEnum(["start","middle","end"]);var Iat=function(e){ZVe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this)||this;if(n._labelFormatter=QVe.identity(),n._labelsEnabled=!1,n._labelsPosition=Gu.LabelsPosition.end,n._hideBarsIfAnyAreTooWide=!0,n._barAlignment="middle",n._computeBarPixelThickness=nUe.memoize(oUe),n._fixedBarPixelThickness=!0,n.addClass("bar-plot"),r!=="vertical"&&r!=="horizontal")throw new Error(r+" is not a valid orientation for Plots.Bar");return n._isVertical=r==="vertical",n.animator("baseline",new JVe.Null),n.attr("fill",new Pat.Color().range()[0]),n.attr(t._BAR_THICKNESS_KEY,function(){return n._barPixelThickness()}),n._labelConfig=new bl.Map,n._baselineValueProvider=function(){return[n.baselineValue()]},n}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._updateExtents(),this},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._updateThicknessAttr(),this._updateLengthScale(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._updateLengthScale(),this)},t.prototype.length=function(){return this._isVertical?this.y():this.x()},t.prototype.position=function(){return this._isVertical?this.x():this.y()},t.prototype.barEnd=function(r){if(r==null)return this._propertyBindings.get(t._BAR_END_KEY);var n=this.position(),i=n&&n.scale;return this._bindProperty(t._BAR_END_KEY,r,i),this._updateThicknessAttr(),this._updateLengthScale(),this.render(),this},t.prototype.barAlignment=function(r){return r==null?this._barAlignment:(this._barAlignment=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"},t.prototype._createDrawer=function(){return new eUe.ProxyDrawer(function(){return new rUe.RectangleSVGDrawer(t._BAR_AREA_CLASS)},function(r){return new tUe.RectangleCanvasDrawer(r)})},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.baselineValue=function(r){if(r==null){if(this._baselineValue!=null)return this._baselineValue;if(!this._projectorsReady())return 0;var n=this.length().scale;return n&&n instanceof Pat.Time?new Date(0):0}return this._baselineValue=r,this._updateLengthScale(),this._clearAttrToProjectorCache(),this.render(),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){return e.prototype._addDataset.call(this,r),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this},t.prototype.datasets=function(r){return r==null?e.prototype.datasets.call(this):(e.prototype.datasets.call(this,r),this)},t.prototype.labelsEnabled=function(r,n){return r==null?this._labelsEnabled:(this._labelsEnabled=r,n!=null&&(this._labelsPosition=n),this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new Cat.SvgContext(i.node()),a=new Cat.CacheMeasurer(o),s=new Cat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype.entityNearest=function(r){var n=this,i=function(){var o=n._isVertical?n._getEntityStore().entityNearestX(r):n._getEntityStore().entityNearestY(r);return o===void 0?void 0:n._lightweightPlotEntityToPlotEntity(o)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesAt=function(r){var n=this,i=function(){return n._entitiesIntersecting(r.x,r.y)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInXBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInXBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInYBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInYBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getEntityStore().entities(),a=o.length,s=0;s<a;s++){var l=o[s];bl.DOM.intersectsBBox(r,n,this._entityBounds(l))&&i.push(this._lightweightPlotEntityToPlotEntity(l))}return i},t.prototype._updateLengthScale=function(){if(!!this._projectorsReady()){var r=this.length().scale;r instanceof vKt.QuantitativeScale&&(r.addPaddingExceptionsProvider(this._baselineValueProvider),r.addIncludedValuesProvider(this._baselineValueProvider))}},t.prototype.renderImmediately=function(){var r=this;return this._barPixelThickness(),this._computeBarPixelThickness.doLocked(function(){return e.prototype.renderImmediately.call(r)})},t.prototype._additionalPaint=function(r){var n=this,i=this.length().scale,o=i.scale(this.baselineValue()),a={x1:this._isVertical?0:o,y1:this._isVertical?o:0,x2:this._isVertical?this.width():o,y2:this._isVertical?o:this.height()};this._getAnimator("baseline").animate(this._baseline,a),this.datasets().forEach(function(s){return n._labelConfig.get(s).labelArea.selectAll("g").remove()}),this._labelsEnabled&&bl.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype.getExtentsForProperty=function(r){var n=this,i=e.prototype.getExtentsForProperty.call(this,r),o;if(r==="x"&&this._isVertical)o=this.x();else if(r==="y"&&!this._isVertical)o=this.y();else return i;if(!(o&&o.scale&&o.scale instanceof vKt.QuantitativeScale))return i;var a=o.scale,s=this._barPixelThickness();return i=i.map(function(l){return Aat.extent([a.invert(n._getPositionAttr(a.scale(l[0]),s)),a.invert(n._getPositionAttr(a.scale(l[0]),s)+s),a.invert(n._getPositionAttr(a.scale(l[1]),s)),a.invert(n._getPositionAttr(a.scale(l[1]),s)+s)])}),i},t.prototype._getPositionAttr=function(r,n){switch(this._isVertical||(r-=n,n*=-1),this._barAlignment){case"start":return r;case"end":return r-n;case"middle":default:return r-n/2}},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector(),o=this.datasets().some(function(a){return n.get(a).some(function(s,l){return s==null?!1:r._drawLabel(s,l,a,i)})});this._hideBarsIfAnyAreTooWide&&o&&this.datasets().forEach(function(a){return r._labelConfig.get(a).labelArea.selectAll("g").remove()})},t.prototype._drawLabel=function(r,n,i,o){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u=this.length().accessor,h=u(r,n,i),f=this.length().scale,p=f!=null?f.scale(h):h,d=f!=null?f.scale(this.baselineValue()):this.baselineValue(),g={x:o.x(r,n,i),y:o.y(r,n,i)},_={width:o.width(r,n,i),height:o.height(r,n,i)},y=this._labelFormatter(h,r,n,i),x=l.measure(y),b=this._shouldShowLabelOnBar(g,_,x),S=this._isVertical?p<=d:p<d,C=this._calculateLabelProperties(g,_,x,b,S),P=C.containerDimensions,k=C.labelContainerOrigin,O=C.labelOrigin,D=C.alignment,B=o.fill(r,n,i),I=this._createLabelContainer(s,k,O,x,b,B),L={xAlign:D.x,yAlign:D.y};c.write(y,P.width,P.height,L,I.node());var R=this._isVertical?_.width<x.width:_.height<x.height;return R},t.prototype._shouldShowLabelOnBar=function(r,n,i){if(this._labelsPosition===Gu.LabelsPosition.outside)return!1;var o=this._isVertical?r.y:r.x,a=this._isVertical?n.height:n.width,s=this._isVertical?this.height():this.width(),l=this._isVertical?i.height:i.width,c=o+a,u=a;return c>s?u=s-o:o<0&&(u=c),l+t._LABEL_MARGIN_INSIDE_BAR<=u},t.prototype._calculateLabelProperties=function(r,n,i,o,a){var s=this,l=this._isVertical?r.y:r.x,c=this._isVertical?n.height:n.width,u=this._isVertical?i.height:i.width,h="center",f=c,p=l,d=l,g=function(_){switch(_){case"topLeft":h=s._isVertical?"top":"left",p+=t._LABEL_MARGIN_INSIDE_BAR,d+=t._LABEL_MARGIN_INSIDE_BAR;return;case"center":d+=(c+u)/2;return;case"bottomRight":h=s._isVertical?"bottom":"right",p-=t._LABEL_MARGIN_INSIDE_BAR,d+=f-t._LABEL_MARGIN_INSIDE_BAR-u;return}};if(o)switch(this._labelsPosition){case Gu.LabelsPosition.start:g(a?"bottomRight":"topLeft");break;case Gu.LabelsPosition.middle:g("center");break;case Gu.LabelsPosition.end:g(a?"topLeft":"bottomRight");break}else a?(h=this._isVertical?"top":"left",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,p-=t._LABEL_MARGIN_INSIDE_BAR+u,d-=t._LABEL_MARGIN_INSIDE_BAR+u):(h=this._isVertical?"bottom":"right",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,d+=c+t._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?n.width:f,height:this._isVertical?f:n.height},labelContainerOrigin:{x:this._isVertical?r.x:p,y:this._isVertical?p:r.y},labelOrigin:{x:this._isVertical?r.x+n.width/2-i.width/2:d,y:this._isVertical?d:r.y+n.height/2-i.height/2},alignment:{x:this._isVertical?"center":h,y:this._isVertical?h:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o,a,s){var l=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");if(a){l.classed("on-bar-label",!0);var c=bl.Color.contrast("white",s)*1.6<bl.Color.contrast("black",s);l.classed(c?"dark-label":"light-label",!0)}else l.classed("off-bar-label",!0);return l},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"height":"width";n[a]=function(){return o},n[s]=function(){return 0},r.push({attrToProjector:n,animator:this._getAnimator(xKt.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(xKt.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"x":"y",l=hB.Plot._scaledAccessor(this.position()),c=hB.Plot._scaledAccessor(this.length()),u=function(d,g,_){return Math.abs(o-c(d,g,_))},h=n[t._BAR_THICKNESS_KEY],f=n.gap,p=f==null?h:function(d,g,_){var y=h(d,g,_);return y<t._BAR_GAPLESS_THRESHOLD_PX?y:y-f(d,g,_)};return n.width=this._isVertical?p:u,n.height=this._isVertical?u:p,n[a]=function(d,g,_){var y=c(d,g,_);return y>o?o:y},n[s]=function(d,g,_){return r._getPositionAttr(l(d,g,_),h(d,g,_))},n},t.prototype._updateThicknessAttr=function(){var r=this,n=this.position(),i=this.barEnd();n!=null&&i!=null?(this._fixedBarPixelThickness=!1,this.attr(t._BAR_THICKNESS_KEY,function(o,a,s){var l=n.accessor(o,a,s),c=i.accessor(o,a,s);return l=n.scale?n.scale.scale(l):l,c=i.scale?i.scale.scale(c):c,Math.abs(c-l)})):(this._fixedBarPixelThickness=!0,this.attr(t._BAR_THICKNESS_KEY,function(){return r._barPixelThickness()}))},t.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness&&this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0},t.prototype.entities=function(r){if(r===void 0&&(r=this.datasets()),!this._projectorsReady())return[];var n=e.prototype.entities.call(this,r);return n},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._pixelBounds(n,i,o)},t.prototype._pixelBounds=function(r,n,i){var o=this._getAttrToProjector();return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype._pixelPoint=function(r,n,i){var o=this._pixelBounds(r,n,i),a=(this._isVertical?hB.Plot._scaledAccessor(this.y()):hB.Plot._scaledAccessor(this.x()))(r,n,i),s=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(a,s,o)},t.prototype._pixelPointBar=function(r,n,i){var o,a;return this._isVertical?(o=i.x+i.width/2,a=r<=n?i.y:i.y+i.height):(o=r>=n?i.x+i.width:i.x,a=i.y+i.height/2),{x:o,y:a}},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n)},t.prototype._getDataToDraw=function(){var r=this,n=new bl.Map,i=this._getAttrToProjector(),o=this.width(),a=this.height();return this.datasets().forEach(function(s){var l=s.data().map(function(c,u){var h=r._isDatumOnScreen(i,o,a,c,u,s);return h?c:null});n.set(s,l)}),n},t.prototype._isDatumOnScreen=function(r,n,i,o,a,s){var l=r.x(o,a,s),c=r.y(o,a,s),u=r.width(o,a,s),h=r.height(o,a,s),f=bl.Math.isValidNumber(l)&&bl.Math.isValidNumber(c)&&bl.Math.isValidNumber(u)&&bl.Math.isValidNumber(h);return f?bl.Math.boundsIntersects(l,c,u,h,0,0,n,i):!1},t.prototype.invalidateCache=function(){var r=this;e.prototype.invalidateCache.call(this),this.datasets().forEach(function(n){return r._labelConfig.get(n).measurer.reset()})},t._BAR_THICKNESS_RATIO=.95,t._BAR_GAPLESS_THRESHOLD_PX=3,t._SINGLE_BAR_DIMENSION_RATIO=.4,t._BAR_AREA_CLASS="bar-area",t._BAR_END_KEY="barEnd",t._BAR_THICKNESS_KEY="width",t._LABEL_AREA_CLASS="bar-label-text-area",t._LABEL_MARGIN_INSIDE_BAR=10,t}(iUe.XYPlot);Gu.Bar=Iat;function oUe(e,t,r){var n,i=e.scale;if(i instanceof Pat.Category)n=i.rangeBand();else{var o=e.accessor,a=Aat.set(bl.Array.flatten(t.map(function(c){return c.data().map(function(u,h){return o(u,h,c)}).filter(function(u){return u!=null}).map(function(u){return u.valueOf()})}))).values().map(function(c){return+c});a.sort(function(c,u){return c-u});var s=a.map(function(c){return i.scale(c)}),l=Aat.pairs(s);n=bl.Math.min(l,function(c,u){return Math.abs(c[1]-c[0])},r*Iat._SINGLE_BAR_DIMENSION_RATIO),n*=Iat._BAR_THICKNESS_RATIO}return n}});var wKt=H(kat=>{"use strict";Object.defineProperty(kat,"__esModule",{value:!0});var aUe=(de(),Ut(pe)),sUe=Rs(),lUe=Fe(),bKt=y4(),cUe=ns(),uUe=function(e){aUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._clusterOffsets=new lUe.Map,n}return t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._makeInnerScale(),o=function(l,c){return i.rangeBand()};n.width=this._isVertical?o:n.width,n.height=this._isVertical?n.height:o;var a=n.x,s=n.y;return n.x=this._isVertical?function(l,c,u){return a(l,c,u)+r._clusterOffsets.get(u)}:function(l,c,u){return a(l,c,u)},n.y=this._isVertical?function(l,c,u){return s(l,c,u)}:function(l,c,u){return s(l,c,u)+r._clusterOffsets.get(u)},n},t.prototype._updateClusterPosition=function(){var r=this,n=this._makeInnerScale();this.datasets().forEach(function(i,o){return r._clusterOffsets.set(i,n.scale(String(o))-n.rangeBand()/2)})},t.prototype._makeInnerScale=function(){var r=new sUe.Category;r.domain(this.datasets().map(function(i,o){return String(o)}));var n=cUe.Plot._scaledAccessor(this.attr(bKt.Bar._BAR_THICKNESS_KEY));return r.range([0,n(null,0,null)]),r},t.prototype._getDataToDraw=function(){return this._updateClusterPosition(),e.prototype._getDataToDraw.call(this)},t}(bKt.Bar);kat.ClusteredBar=uUe});var SKt=H(Nat=>{"use strict";Object.defineProperty(Nat,"__esModule",{value:!0});var hUe=(de(),Ut(pe)),v4=(Er(),Ut(Mr)),Rat=yl(),fUe=kf(),pUe=Bu(),dUe=Rs(),Uv=Fe(),mUe=fat(),gUe=dat(),_Ue=Uu(),yUe=AF(),Ed=ns(),vUe=function(e){hUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._startAngle=0,r._endAngle=2*Math.PI,r._labelFormatter=pUe.identity(),r._labelsEnabled=!1,r.innerRadius(0),r.outerRadius(function(){var n=r._pieCenter();return Math.min(Math.max(r.width()-n.x,n.x),Math.max(r.height()-n.y,n.y))}),r.addClass("pie-plot"),r.attr("fill",function(n,i){return String(i)},new dUe.Color),r._strokeDrawers=new Uv.Map,r}return t.prototype._setup=function(){var r=this;e.prototype._setup.call(this),this._strokeDrawers.forEach(function(n){return n.attachTo(r._renderArea)})},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this._pieCenter();this._renderArea.attr("transform","translate("+o.x+","+o.y+")");var a=Math.min(Math.max(this.width()-o.x,o.x),Math.max(this.height()-o.y,o.y));return this.innerRadius().scale!=null&&this.innerRadius().scale.range([0,a]),this.outerRadius().scale!=null&&this.outerRadius().scale.range([0,a]),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){if(this.datasets().length===1)return Uv.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles(),e.prototype._addDataset.call(this,r);var n=new gUe.ArcOutlineSVGDrawer;return this._isSetup&&n.attachTo(this._renderArea),this._strokeDrawers.set(r,n),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._strokeDrawers.get(r).remove()},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this._strokeDrawers.delete(r),this._startAngles=[],this._endAngles=[],this},t.prototype.selections=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.selections.call(this,r).nodes();return r.forEach(function(o){var a=n._strokeDrawers.get(o);a!=null&&i.push.apply(i,a.getVisualPrimitives())}),v4.selectAll(i)},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updatePieAngles(),this.render()},t.prototype._createDrawer=function(){return new _Ue.ProxyDrawer(function(){return new mUe.ArcSVGDrawer},function(){return yUe.warn("canvas renderer is not supported on Pie Plot!"),null})},t.prototype.entities=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.entities.call(this,r);return i.map(function(o){o.position.x+=n.width()/2,o.position.y+=n.height()/2;var a=v4.select(n._strokeDrawers.get(o.dataset).getVisualPrimitiveAtIndex(o.index)),s=o;return s.strokeSelection=a,s})},t.prototype.sectorValue=function(r,n){return r==null?this._propertyBindings.get(t._SECTOR_VALUE_KEY):(this._bindProperty(t._SECTOR_VALUE_KEY,r,n),this._updatePieAngles(),this.render(),this)},t.prototype.innerRadius=function(r,n){return r==null?this._propertyBindings.get(t._INNER_RADIUS_KEY):(this._bindProperty(t._INNER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.outerRadius=function(r,n){return r==null?this._propertyBindings.get(t._OUTER_RADIUS_KEY):(this._bindProperty(t._OUTER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.startAngle=function(r){return r==null?this._startAngle:(this._startAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.endAngle=function(r){return r==null?this._endAngle:(this._endAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this.render(),this)},t.prototype.entitiesAt=function(r){var n={x:this.width()/2,y:this.height()/2},i={x:r.x-n.x,y:r.y-n.y},o=this._sliceIndexForPoint(i);return o==null?[]:[this.entities()[o]]},t.prototype._propertyProjectors=function(){var r=this,n=e.prototype._propertyProjectors.call(this),i=Ed.Plot._scaledAccessor(this.innerRadius()),o=Ed.Plot._scaledAccessor(this.outerRadius());return n.d=function(a,s,l){return v4.arc().innerRadius(i(a,s,l)).outerRadius(o(a,s,l)).startAngle(r._startAngles[s]).endAngle(r._endAngles[s])(a,s)},n},t.prototype._updatePieAngles=function(){if(this.sectorValue()!=null&&this.datasets().length!==0){var r=Ed.Plot._scaledAccessor(this.sectorValue()),n=this.datasets()[0],i=this._getDataToDraw().get(n),o=v4.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(a,s){return r(a,s,n)})(i);this._startAngles=o.map(function(a){return a.startAngle}),this._endAngles=o.map(function(a){return a.endAngle})}},t.prototype._pieCenter=function(){var r=this._startAngle<this._endAngle?this._startAngle:this._endAngle,n=this._startAngle<this._endAngle?this._endAngle:this._startAngle,i=Math.sin(r),o=Math.cos(r),a=Math.sin(n),s=Math.cos(n),l,c,u,h;return i>=0&&a>=0?o>=0&&s>=0?(l=o,c=0,h=0,u=a):o<0&&s<0?(l=0,c=-s,h=0,u=i):o>=0&&s<0?(l=o,c=-s,h=0,u=i):o<0&&s>=0&&(l=1,c=1,h=1,u=Math.max(i,a)):i>=0&&a<0?o>=0&&s>=0?(l=Math.max(o,s),c=1,h=1,u=1):o<0&&s<0?(l=0,c=1,h=-a,u=i):o>=0&&s<0?(l=o,c=1,h=-a,u=1):o<0&&s>=0&&(l=s,c=1,h=1,u=i):i<0&&a>=0?o>=0&&s>=0?(l=1,c=0,h=-i,u=a):o<0&&s<0?(l=1,c=Math.max(-o,-s),h=1,u=1):o>=0&&s<0?(l=1,c=-s,h=-i,u=1):o<0&&s>=0&&(l=1,c=-o,h=1,u=a):i<0&&a<0&&(o>=0&&s>=0?(l=s,c=0,h=-i,u=0):o<0&&s<0?(l=0,c=-o,h=-a,u=0):o>=0&&s<0?(l=1,c=1,h=Math.max(o,-s),u=1):o<0&&s>=0&&(l=s,c=-o,h=1,u=0)),{x:h+u==0?0:h/(h+u)*this.width(),y:l+c==0?0:l/(l+c)*this.height()}},t.prototype._getDataToDraw=function(){var r=e.prototype._getDataToDraw.call(this);if(this.datasets().length===0)return r;var n=Ed.Plot._scaledAccessor(this.sectorValue()),i=this.datasets()[0],o=r.get(i),a=o.filter(function(s,l){return t._isValidData(n(s,l,i))});return r.set(i,a),r},t._isValidData=function(r){return Uv.Math.isValidNumber(r)&&r>=0},t.prototype._pixelPoint=function(r,n,i){var o=Ed.Plot._scaledAccessor(this.sectorValue());if(!t._isValidData(o(r,n,i)))return{x:NaN,y:NaN};var a=Ed.Plot._scaledAccessor(this.innerRadius())(r,n,i),s=Ed.Plot._scaledAccessor(this.outerRadius())(r,n,i),l=(a+s)/2,c=v4.pie().sort(null).value(function(p,d){var g=o(p,d,i);return t._isValidData(g)?g:0}).startAngle(this._startAngle).endAngle(this._endAngle)(i.data()),u=c[n].startAngle,h=c[n].endAngle,f=(u+h)/2;return{x:l*Math.sin(f),y:-l*Math.cos(f)}},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.select(".label-area").remove(),this._labelsEnabled&&Uv.Window.setTimeout(function(){return n._drawLabels()},r);var i=this._generateStrokeDrawSteps(),o=this._getDataToDraw();this.datasets().forEach(function(a){var s=Ed.Plot.applyDrawSteps(i,a);n._strokeDrawers.get(a).draw(o.get(a),s)})},t.prototype._generateStrokeDrawSteps=function(){var r=this._getAttrToProjector();return[{attrToProjector:r,animator:new fUe.Null}]},t.prototype._sliceIndexForPoint=function(r){var n=Math.sqrt(Math.pow(r.x,2)+Math.pow(r.y,2)),i=Math.acos(-r.y/n);r.x<0&&(i=Math.PI*2-i);for(var o,a=0;a<this._startAngles.length;a++)if(this._startAngles[a]<i&&this._endAngles[a]>i){o=a;break}if(o!==void 0){var s=this.datasets()[0],l=s.data()[o],c=this.innerRadius().accessor(l,o,s),u=this.outerRadius().accessor(l,o,s);if(n>c&&n<u)return o}return null},t.prototype._drawLabels=function(){for(var r=this,n=this._getAttrToProjector(),i=this._renderArea.append("g").classed("label-area",!0),o=new Rat.SvgContext(i.node()),a=new Rat.CacheMeasurer(o),s=new Rat.Writer(a,o),l=this.datasets()[0],c=this._getDataToDraw().get(l),u=c.length,h=function(d){var g=c[d],_=f.sectorValue().accessor(g,d,l);if(!Uv.Math.isValidNumber(_))return"continue";_=f._labelFormatter(_,g,d,l);var y=a.measure(_),x=(f._endAngles[d]+f._startAngles[d])/2,b=f.outerRadius().accessor(g,d,l);f.outerRadius().scale&&(b=f.outerRadius().scale.scale(b));var S=f.innerRadius().accessor(g,d,l);f.innerRadius().scale&&(S=f.innerRadius().scale.scale(S));var C=(b+S)/2,P=Math.sin(x)*C-y.width/2,k=-Math.cos(x)*C-y.height/2,O=[{x:P,y:k},{x:P,y:k+y.height},{x:P+y.width,y:k},{x:P+y.width,y:k+y.height}],D=O.every(function(z){return Math.abs(z.x)<=r.width()/2&&Math.abs(z.y)<=r.height()/2});if(D){var B=O.map(function(z){return r._sliceIndexForPoint(z)});D=B.every(function(z){return z===d})}var I=n.fill(g,d,l),L=Uv.Color.contrast("white",I)*1.6<Uv.Color.contrast("black",I),R=i.append("g").attr("transform","translate("+P+","+k+")"),F=L?"dark-label":"light-label";R.classed(F,!0),R.style("visibility",D?"inherit":"hidden"),s.write(_,y.width,y.height,{xAlign:"center",yAlign:"center"},R.node())},f=this,p=0;p<u;p++)h(p)},t._INNER_RADIUS_KEY="inner-radius",t._OUTER_RADIUS_KEY="outer-radius",t._SECTOR_VALUE_KEY="sector-value",t}(Ed.Plot);Nat.Pie=vUe});var MKt=H(Oat=>{"use strict";Object.defineProperty(Oat,"__esModule",{value:!0});var xUe=(de(),Ut(pe)),bUe=(Er(),Ut(Mr)),Dat=yl(),wUe=kf(),SUe=Hv(),MUe=Uu(),EUe=oB(),fB=Rs(),Oc=Fe(),pB=ns(),TUe=Vv(),CUe=function(e){xUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._labelsEnabled=!1,r._label=null,r.animator("rectangles",new wUe.Null),r.addClass("rectangle-plot"),r.attr("fill",new fB.Color().range()[0]),r}return t.prototype._createDrawer=function(){return new MUe.ProxyDrawer(function(){return new EUe.RectangleSVGDrawer},function(r){return new SUe.RectangleCanvasDrawer(r)})},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=pB.Plot._scaledAccessor(this.x()),o=n[t._X2_KEY],a=pB.Plot._scaledAccessor(this.y()),s=n[t._Y2_KEY],l=this.x().scale,c=this.y().scale;return o!=null?(n.width=function(u,h,f){return Math.abs(o(u,h,f)-i(u,h,f))},n.x=function(u,h,f){return Math.min(o(u,h,f),i(u,h,f))}):(n.width=function(u,h,f){return r._rectangleWidth(l)},n.x=function(u,h,f){return i(u,h,f)-.5*n.width(u,h,f)}),s!=null?(n.height=function(u,h,f){return Math.abs(s(u,h,f)-a(u,h,f))},n.y=function(u,h,f){return Math.max(s(u,h,f),a(u,h,f))-n.height(u,h,f)}):(n.height=function(u,h,f){return r._rectangleWidth(c)},n.y=function(u,h,f){return a(u,h,f)-.5*n.height(u,h,f)}),delete n[t._X2_KEY],delete n[t._Y2_KEY],n},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n,i){if(r==null)return e.prototype.x.call(this);if(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n,i),n!=null){var o=this.x2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._X2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.x2=function(r,n){if(r==null)return this._propertyBindings.get(t._X2_KEY);var i=this.x(),o=i&&i.scale;return this._bindProperty(t._X2_KEY,r,o,n),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n,i),n!=null){var o=this.y2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._Y2_KEY,a,n,o.postScale)}return n instanceof fB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.y2=function(r,n){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var i=this.y(),o=i&&i.scale;return this._bindProperty(t._Y2_KEY,r,o,n),this.render(),this},t.prototype.entitiesAt=function(r){var n=this._getAttrToProjector();return this.entities().filter(function(i){var o=i.datum,a=i.index,s=i.dataset,l=n.x(o,a,s),c=n.y(o,a,s),u=n.width(o,a,s),h=n.height(o,a,s);return l<=r.x&&r.x<=l+u&&c<=r.y&&r.y<=c+h})},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._entityBBox(n,i,o,this._getAttrToProjector())},t.prototype._entityBBox=function(r,n,i,o){return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype.label=function(r){return r==null?this._label:(this._label=r,this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return this.x2()!=null&&(r.x2=pB.Plot._scaledAccessor(this.x2())),this.y2()!=null&&(r.y2=pB.Plot._scaledAccessor(this.y2())),r},t.prototype._pixelPoint=function(r,n,i){var o=this._getAttrToProjector(),a=o.x(r,n,i),s=o.y(r,n,i),l=o.width(r,n,i),c=o.height(r,n,i),u=a+l/2,h=s+c/2;return{x:u,y:h}},t.prototype._rectangleWidth=function(r){if(r instanceof fB.Category)return r.rangeBand();var n=r===this.x().scale?this.x().accessor:this.y().accessor,i=bUe.set(Oc.Array.flatten(this.datasets().map(function(c){return c.data().map(function(u,h){return n(u,h,c).valueOf()})}))).values().map(function(c){return+c}),o=Oc.Math.min(i,0),a=Oc.Math.max(i,0),s=r.scale(o),l=r.scale(a);return(l-s)/Math.abs(a-o)},t.prototype._getDataToDraw=function(){var r=new Oc.Map,n=this._getAttrToProjector();return this.datasets().forEach(function(i){var o=i.data().map(function(a,s){var l=Oc.Math.isValidNumber(n.x(a,s,i))&&Oc.Math.isValidNumber(n.y(a,s,i))&&Oc.Math.isValidNumber(n.width(a,s,i))&&Oc.Math.isValidNumber(n.height(a,s,i));return l?a:null});r.set(i,o)}),r},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.selectAll(".label-area").remove(),this._labelsEnabled&&this.label()!=null&&Oc.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw();this.datasets().forEach(function(i,o){return r._drawLabel(n,i,o)})},t.prototype._drawLabel=function(r,n,i){for(var o=this._getAttrToProjector(),a=this._renderArea.append("g").classed("label-area",!0),s=new Dat.SvgContext(a.node()),l=new Dat.CacheMeasurer(s),c=new Dat.Writer(l,s),u=this.x().scale.range(),h=this.y().scale.range(),f=Math.min.apply(null,u),p=Math.max.apply(null,u),d=Math.min.apply(null,h),g=Math.max.apply(null,h),_=r.get(n),y=_.length,x=0;x<y;x++){var b=_[x];if(b!=null){var S=""+this.label()(b,x,n),C=l.measure(S),P=o.x(b,x,n),k=o.y(b,x,n),O=o.width(b,x,n),D=o.height(b,x,n);if(C.height<=D&&C.width<=O){var B=(O-C.width)/2,I=(D-C.height)/2;P+=B,k+=I;var L={min:P,max:P+C.width},R={min:k,max:k+C.height};if(L.min<f||L.max>p||R.min<d||R.max>g||this._overlayLabel(L,R,x,i,r))continue;var F=o.fill(b,x,n),z=Oc.Color.contrast("white",F)*1.6<Oc.Color.contrast("black",F),U=a.append("g").attr("transform","translate("+P+","+k+")"),W=z?"dark-label":"light-label";U.classed(W,!0),c.write(S,C.width,C.height,{xAlign:"center",yAlign:"center"},U.node())}}}},t.prototype._overlayLabel=function(r,n,i,o,a){for(var s=this._getAttrToProjector(),l=this.datasets(),c=o;c<l.length;c++)for(var u=l[c],h=a.get(u),f=h.length,p=c===o?i+1:0;p<f;p++)if(Oc.DOM.intersectsBBox(r,n,this._entityBBox(h[p],p,u,s)))return!0;return!1},t._X2_KEY="x2",t._Y2_KEY="y2",t}(TUe.XYPlot);Oat.Rectangle=CUe});var TKt=H(Hat=>{"use strict";Object.defineProperty(Hat,"__esModule",{value:!0});var AUe=(de(),Ut(pe)),zat=yl(),PUe=Bu(),IUe=XF(),LUe=Uu(),EKt=vat(),kUe=kf(),RUe=Hv(),NUe=Rs(),Fat=Fe(),Bat=IS(),wl=ns(),DUe=Vv(),OUe=function(e){AUe.__extends(t,e);function t(){var r=e.call(this)||this;r._labelFormatter=PUe.identity(),r._labelsEnabled=!1,r.addClass("scatter-plot");var n=new kUe.Easing;n.startDelay(5),n.stepDuration(250),n.maxTotalDuration(wl.Plot._ANIMATION_MAX_DURATION),r.animator(Bat.Animator.MAIN,n),r.attr("opacity",.6),r.attr("fill",new NUe.Color().range()[0]),r.size(6);var i=IUe.circle();return r.symbol(function(){return i}),r._labelConfig=new Fat.Map,r}return t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=e.prototype._buildLightweightPlotEntities.call(this,r);return i.map(function(o){var a=wl.Plot._scaledAccessor(n.size())(o.datum,o.index,o.dataset);return o.diameter=a,o})},t.prototype._createDrawer=function(r){var n=this;return new LUe.ProxyDrawer(function(){return new EKt.SymbolSVGDrawer},function(i){return new RUe.CanvasDrawer(i,EKt.makeSymbolCanvasDrawStep(r,function(){return wl.Plot._scaledAccessor(n.symbol())},function(){return wl.Plot._scaledAccessor(n.size())}))})},t.prototype.size=function(r,n){return r==null?this._propertyBindings.get(t._SIZE_KEY):(this._bindProperty(t._SIZE_KEY,r,n),this.render(),this)},t.prototype.symbol=function(r){return r==null?this._propertyBindings.get(t._SYMBOL_KEY):(this._propertyBindings.set(t._SYMBOL_KEY,{accessor:r}),this.render(),this)},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=wl.Plot._scaledAccessor(this.symbol());n.d=function(o,a,s){return i(o,a,s)(0)(null)},r.push({attrToProjector:n,animator:this._getAnimator(Bat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Bat.Animator.MAIN)}),r},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=wl.Plot._scaledAccessor(this.x()),i=wl.Plot._scaledAccessor(this.y());return r.x=n,r.y=i,r.transform=function(o,a,s){return"translate("+n(o,a,s)+","+i(o,a,s)+")"},r.d=this._constructSymbolGenerator(),r},t.prototype._constructSymbolGenerator=function(){var r=wl.Plot._scaledAccessor(this.symbol()),n=wl.Plot._scaledAccessor(this.size());return function(i,o,a){return r(i,o,a)(n(i,o,a))(null)}},t.prototype._entityBounds=function(r){return{x:r.position.x-r.diameter/2,y:r.position.y-r.diameter/2,width:r.diameter,height:r.diameter}},t.prototype._entityVisibleOnPlot=function(r,n){var i={min:n.topLeft.x,max:n.bottomRight.x},o={min:n.topLeft.y,max:n.bottomRight.y},a=this._entityBounds(r);return Fat.DOM.intersectsBBox(i,o,a)},t.prototype.entitiesAt=function(r){var n=wl.Plot._scaledAccessor(this.x()),i=wl.Plot._scaledAccessor(this.y()),o=wl.Plot._scaledAccessor(this.size());return this.entities().filter(function(a){var s=a.datum,l=a.index,c=a.dataset,u=n(s,l,c),h=i(s,l,c),f=o(s,l,c);return u-f/2<=r.x&&r.x<=u+f/2&&h-f/2<=r.y&&r.y<=h+f/2})},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new zat.SvgContext(i.node()),a=new zat.CacheMeasurer(o),s=new zat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype._additionalPaint=function(r){var n=this;this.datasets().forEach(function(i){return n._labelConfig.get(i).labelArea.selectAll("g").remove()}),this._labelsEnabled&&Fat.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector();this.datasets().forEach(function(o){for(var a=n.get(o),s=a.length,l=0;l<s;l++){var c=a[l];c!=null&&r._drawLabel(c,l,o,i)}})},t.prototype._drawLabel=function(r,n,i,o){if(r.label!=null){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u={x:o.x(r,n,i),y:o.y(r,n,i)},h=wl.Plot._scaledAccessor(this.size()),f=h(r,n,i),p=this._labelFormatter(r.label,r,n,i),d=l.measure(p),g=this._calculateLabelProperties(u,f,d),_=g.containerDimensions,y=g.labelContainerOrigin,x=g.labelOrigin,b=g.alignment,S=this._createLabelContainer(s,y,x,d),C={xAlign:b.x,yAlign:b.y};c.write(p,_.width,_.height,C,S.node())}},t.prototype._calculateLabelProperties=function(r,n,i){var o=n<i.height?n/2+t._LABEL_MARGIN_FROM_BUBBLE:0;return{containerDimensions:{width:i.width,height:i.height},labelContainerOrigin:{x:r.x-i.width/2,y:r.y-i.height/2+o},labelOrigin:{x:r.x,y:r.y},alignment:{x:"center",y:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o){var a=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");return a.classed("on-bar-label",!0),a},t._SIZE_KEY="size",t._SYMBOL_KEY="symbol",t._LABEL_AREA_CLASS="scatter-label-text-area",t._LABEL_MARGIN_FROM_BUBBLE=15,t}(DUe.XYPlot);Hat.Scatter=OUe});var CKt=H(Vat=>{"use strict";Object.defineProperty(Vat,"__esModule",{value:!0});var zUe=(de(),Ut(pe)),FUe=kf(),BUe=Uu(),HUe=_at(),VUe=Rs(),UUe=AF(),LS=ns(),qUe=Vv(),GUe=function(e){zUe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("segment-plot"),r.attr("stroke",new VUe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype._createDrawer=function(){return new BUe.ProxyDrawer(function(){return new HUe.SegmentSVGDrawer},function(){return UUe.warn("canvas renderer is not supported on Segment Plot!"),null})},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new FUe.Null}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n){if(r==null)return e.prototype.x.call(this);if(n==null)e.prototype.x.call(this,r);else{e.prototype.x.call(this,r,n);var i=this.x2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._X2_KEY,o,n)}return this},t.prototype.x2=function(r){if(r==null)return this._propertyBindings.get(t._X2_KEY);var n=this.x(),i=n&&n.scale;return this._bindProperty(t._X2_KEY,r,i),this.render(),this},t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null)e.prototype.y.call(this,r);else{e.prototype.y.call(this,r,n);var i=this.y2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._Y2_KEY,o,n)}return this},t.prototype.y2=function(r){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y2_KEY,r,i),this.render(),this},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.x1=LS.Plot._scaledAccessor(this.x()),r.x2=this.x2()==null?LS.Plot._scaledAccessor(this.x()):LS.Plot._scaledAccessor(this.x2()),r.y1=LS.Plot._scaledAccessor(this.y()),r.y2=this.y2()==null?LS.Plot._scaledAccessor(this.y()):LS.Plot._scaledAccessor(this.y2()),r},t.prototype.entitiesAt=function(r){var n=this.entityNearest(r);return n!=null?[n]:[]},t.prototype.entitiesIn=function(r,n){var i,o;if(n==null){var a=r;i={min:a.topLeft.x,max:a.bottomRight.x},o={min:a.topLeft.y,max:a.bottomRight.y}}else i=r,o=n;return this._entitiesIntersecting(i,o)},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getAttrToProjector(),a=this.entities(),s=a.length,l=0;l<s;l++){var c=a[l];this._lineIntersectsBox(c,r,n,o)&&i.push(c)}return i},t.prototype._lineIntersectsBox=function(r,n,i,o){var a=this,s=o.x1(r.datum,r.index,r.dataset),l=o.x2(r.datum,r.index,r.dataset),c=o.y1(r.datum,r.index,r.dataset),u=o.y2(r.datum,r.index,r.dataset);if(n.min<=s&&s<=n.max&&i.min<=c&&c<=i.max||n.min<=l&&l<=n.max&&i.min<=u&&u<=i.max)return!0;var h={x:s,y:c},f={x:l,y:u},p=[{x:n.min,y:i.min},{x:n.min,y:i.max},{x:n.max,y:i.max},{x:n.max,y:i.min}],d=p.filter(function(g,_){return _!==0?a._lineIntersectsSegment(h,f,g,p[_-1])&&a._lineIntersectsSegment(g,p[_-1],h,f):!1});return d.length>0},t.prototype._lineIntersectsSegment=function(r,n,i,o){var a=function(s,l,c){return(l.x-s.x)*(c.y-l.y)-(l.y-s.y)*(c.x-l.x)};return a(r,n,i)*a(r,n,o)<0},t._X2_KEY="x2",t._Y2_KEY="y2",t}(qUe.XYPlot);Vat.Segment=GUe});var IKt=H(Uat=>{"use strict";Object.defineProperty(Uat,"__esModule",{value:!0});var WUe=(de(),Ut(pe)),AKt=(Er(),Ut(Mr)),YUe=kf(),PKt=CS(),e0=Fe(),jUe=Tat(),XUe=ns(),$Ue=function(e){WUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._stackingResult=PKt.memThunk(function(){return r.datasets()},function(){return r.x().accessor},function(){return r.y().accessor},function(){return r._stackingOrder},function(n,i,o,a){return e0.Stacking.stack(n,i,o,a)}),r._stackedExtent=PKt.memThunk(r._stackingResult,function(){return r.x().accessor},function(){return r._filterForProperty("y")},function(n,i,o){return e0.Stacking.stackedExtent(n,i,o)}),r._baselineValue=0,r._stackingOrder="bottomup",r.addClass("stacked-area-plot"),r._baselineValueProvider=function(){return[r._baselineValue]},r.croppedRenderingEnabled(!1),r}return t.prototype.croppedRenderingEnabled=function(r){return r==null?e.prototype.croppedRenderingEnabled.call(this):r?(e0.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):e.prototype.croppedRenderingEnabled.call(this,r)},t.prototype._getAnimator=function(r){return new YUe.Null},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._checkSameDomain(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._checkSameDomain(),this)},t.prototype.yOffset=function(r,n){var i=this._stackingResult();if(i!=null){var o=i.get(r);if(o!=null){var a=o.get(String(n));if(a!=null)return a.offset}}},t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?e.prototype.downsamplingEnabled.call(this):(e0.Window.warn("Warning: Stacked Area Plot does not support downsampling"),this)},t.prototype._additionalPaint=function(){var r=this.y().scale.scale(this._baselineValue),n={x1:0,y1:r,x2:this.width(),y2:r};this._getAnimator("baseline").animate(this._baseline,n)},t.prototype._updateYScale=function(){var r=this.y(),n=r&&r.scale;n!=null&&(n.addPaddingExceptionsProvider(this._baselineValueProvider),n.addIncludedValuesProvider(this._baselineValueProvider))},t.prototype._onDatasetUpdate=function(){return this._checkSameDomain(),e.prototype._onDatasetUpdate.call(this),this},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._checkSameDomain=function(){if(!!this._projectorsReady()){var r=this.datasets(),n=this.x().accessor,i=r.map(function(a){return AKt.set(a.data().map(function(s,l){return e0.Stacking.normalizeKey(n(s,l,a))})).values()}),o=t._domainKeys(r,n);i.some(function(a){return a.length!==o.length})&&e0.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}},t._domainKeys=function(r,n){var i=AKt.set();return r.forEach(function(o){for(var a=o.data(),s=a.length,l=0;l<s;l++){var c=a[l];i.add(n(c,l,o))}}),i.values()},t.prototype._coordinateProjectors=function(){var r=this,n=XUe.Plot._scaledAccessor(this.x()),i=this.y().accessor,o=this.x().accessor,a=function(u,h,f){return e0.Stacking.normalizeKey(o(u,h,f))},s=this._stackingResult(),l=function(u,h,f){var p=+i(u,h,f),d=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p+d)},c=function(u,h,f){var p=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p)};return[n,l,c]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype._pixelPoint=function(r,n,i){var o=e.prototype._pixelPoint.call(this,r,n,i),a=this.x().accessor(r,n,i),s=this.y().accessor(r,n,i),l=this.y().scale.scale(+s+this._stackingResult().get(i).get(e0.Stacking.normalizeKey(a)).offset);return{x:o.x,y:l}},t}(jUe.Area);Uat.StackedArea=$Ue});var kKt=H(Wat=>{"use strict";Object.defineProperty(Wat,"__esModule",{value:!0});var KUe=(de(),Ut(pe)),qat=yl(),ZUe=Bu(),LKt=CS(),dB=Fe(),Gat=y4(),JUe=ns(),QUe=function(e){KUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._extremaFormatter=ZUe.identity(),n._stackingResult=LKt.memThunk(function(){return n.datasets()},function(){return n.position().accessor},function(){return n.length().accessor},function(){return n._stackingOrder},function(i,o,a,s){return dB.Stacking.stack(i,o,a,s)}),n._stackedExtent=LKt.memThunk(n._stackingResult,function(){return n.position().accessor},function(){return n._filterForProperty(n._isVertical?"y":"x")},function(i,o,a){return dB.Stacking.stackedExtent(i,o,a)}),n.addClass("stacked-bar-plot"),n._stackingOrder="bottomup",n}return t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.extremaFormatter=function(r){return arguments.length===0?this._extremaFormatter:(this._extremaFormatter=r,this.render(),this)},t.prototype._setup=function(){e.prototype._setup.call(this),this._labelArea=this._renderArea.append("g").classed(Gat.Bar._LABEL_AREA_CLASS,!0);var r=new qat.SvgContext(this._labelArea.node());this._measurer=new qat.CacheMeasurer(r),this._writer=new qat.Writer(this._measurer,r)},t.prototype._drawLabels=function(){var r=this;e.prototype._drawLabels.call(this),this._labelArea.selectAll("g").remove();var n=+this.baselineValue(),i=this.position().scale,o=this.length().scale,a=dB.Stacking.stackedExtents(this._stackingResult()),s=a.maximumExtents,l=a.minimumExtents,c=[],u=function(f,p,d){var g=p.topLeft,_=g.x,y=g.y,x=p.bottomRight.x-p.topLeft.x,b=p.bottomRight.y-p.topLeft.y,S=r._isVertical?x>d:b>d;if(!S){var C=r._labelArea.append("g").attr("transform","translate("+_+", "+y+")");C.classed("stacked-bar-label",!0);var P={xAlign:"center",yAlign:"center"};r._writer.write(f,x,b,P,C.node())}return S},h=function(f,p){var d=r._generateAttrToProjector(),g=r.width(),_=r.height();f.forEach(function(y){if(y.extent!==n){var x=r.extremaFormatter()(y.extent),b=r._measurer.measure(x),S=y.stackedDatum,C=S.originalDatum,P=S.originalIndex,k=S.originalDataset;if(!r._isDatumOnScreen(d,g,_,C,P,k))return;var O=JUe.Plot._scaledAccessor(r.attr(Gat.Bar._BAR_THICKNESS_KEY))(C,P,k),D=o.scale(y.extent),B=r._getPositionAttr(i.scale(y.axisValue),O)+O/2,I=r._isVertical?{x:B,y:D}:{x:D,y:B},L=p(I,b,O),R=u(x,{topLeft:L,bottomRight:{x:L.x+b.width,y:L.y+b.height}},O);c.push(R)}})};h(s,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x+t._EXTREMA_LABEL_MARGIN_FROM_BAR,y:r._isVertical?f.y-_:f.y-g/2}}),h(l,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x-_,y:r._isVertical?f.y+t._EXTREMA_LABEL_MARGIN_FROM_BAR:f.y-g/2}}),c.some(function(f){return f})&&this._labelArea.selectAll("g").remove()},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._isVertical?"y":"x",o=this.length().scale,a=this.length().accessor,s=this.position().accessor,l=function(d,g,_){return dB.Stacking.normalizeKey(s(d,g,_))},c=this._stackingResult(),u=function(d,g,_){return o.scale(c.get(_).get(l(d,g,_)).offset)},h=function(d,g,_){return o.scale(+a(d,g,_)+c.get(_).get(l(d,g,_)).offset)},f=function(d,g,_){return Math.abs(h(d,g,_)-u(d,g,_))};n[this._isVertical?"height":"width"]=f;var p=function(d,g,_){return+a(d,g,_)<0?u(d,g,_):h(d,g,_)};return n[i]=function(d,g,_){return r._isVertical?p(d,g,_):p(d,g,_)-f(d,g,_)},n},t.prototype.getExtentsForProperty=function(r){var n=this._isVertical?"y":"x";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._EXTREMA_LABEL_MARGIN_FROM_BAR=5,t}(Gat.Bar);Wat.StackedBar=QUe});var RKt=H(Yat=>{"use strict";Object.defineProperty(Yat,"__esModule",{value:!0});var tqe=(de(),Ut(pe)),eqe=Fe(),rqe=y4(),nqe=ns(),iqe=function(e){tqe.__extends(t,e);function t(){var r=e.call(this)||this;return r._connectorsEnabled=!1,r.addClass("waterfall-plot"),r}return t.prototype.connectorsEnabled=function(r){return r==null?this._connectorsEnabled:(this._connectorsEnabled=r,this)},t.prototype.total=function(r){return r==null?this._propertyBindings.get(t._TOTAL_KEY):(this._bindProperty(t._TOTAL_KEY,r,null),this)},t.prototype._additionalPaint=function(r){var n=this;this._connectorArea.selectAll("line").remove(),this._connectorsEnabled&&eqe.Window.setTimeout(function(){return n._drawConnectors()},r)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r);return this._connectorArea=this._renderArea.append("g").classed(t._CONNECTOR_AREA_CLASS,!0),n},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._extent]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.y().scale,o=nqe.Plot._scaledAccessor(this.total()),a=this.attr("y");a==null&&(n.y=function(l,c,u){var h=r.y().accessor(l,c,u),f=o(l,c,u);if(f)return Math.min(i.scale(h),i.scale(0));var p=r._subtotals[c];if(c===0)return h<0?i.scale(p-h):i.scale(p);var d=r._subtotals[c-1];return p>d?i.scale(p):i.scale(d)});var s=this.attr("height");return s==null&&(n.height=function(l,c,u){var h=o(l,c,u),f=r.y().accessor(l,c,u);if(h)return Math.abs(i.scale(f)-i.scale(0));var p=r._subtotals[c];if(c===0)return Math.abs(i.scale(p)-i.scale(p-f));var d=r._subtotals[c-1];return Math.abs(i.scale(p)-i.scale(d))}),n.class=function(l,c,u){var h="";r.attr("class")!=null&&(h=r.attr("class").accessor(l,c,u)+" ");var f=o(l,c,u);if(f)return h+t._BAR_TOTAL_CLASS;var p=r.y().accessor(l,c,u);return h+(p>0?t._BAR_GROWTH_CLASS:t._BAR_DECLINE_CLASS)},n},t.prototype._onDatasetUpdate=function(){return this._updateSubtotals(),e.prototype._onDatasetUpdate.call(this),this},t.prototype._calculateSubtotalsAndExtent=function(r){for(var n=Number.MAX_VALUE,i=Number.MIN_VALUE,o=0,a=!1,s=r.data(),l=s.length,c=0;c<l;c++){var u=s[c],h=this.y().accessor(u,c,r),f=this.total().accessor(u,c,r);if((!f||c===0)&&(o+=h),this._subtotals.push(o),o<n&&(n=o),o>i&&(i=o),f&&(h<n&&(n=h),h>i&&(i=h)),!a&&f){for(var p=h-o,d=0;d<this._subtotals.length;d++)this._subtotals[d]+=p;a=!0,o+=p,n+=p,i+=p}}this._extent=[n,i]},t.prototype._drawConnectors=function(){for(var r=this._getAttrToProjector(),n=this.datasets()[0],i=1;i<n.data().length;i++){var o=i-1,a=n.data()[i],s=n.data()[o],l=r.x(s,o,n),c=r.x(a,i,n)+r.width(a,i,n),u=r.y(a,i,n);(this._subtotals[i]>0&&this._subtotals[i]>this._subtotals[o]||this._subtotals[i]<0&&this._subtotals[i]>=this._subtotals[o])&&(u=r.y(a,i,n)+r.height(a,i,n)),this._connectorArea.append("line").classed(t._CONNECTOR_CLASS,!0).attr("x1",l).attr("x2",c).attr("y1",u).attr("y2",u)}},t.prototype._updateSubtotals=function(){var r=this.datasets();if(r.length>0){var n=r[r.length-1];this._subtotals=new Array,this._calculateSubtotalsAndExtent(n)}},t._BAR_DECLINE_CLASS="waterfall-decline",t._BAR_GROWTH_CLASS="waterfall-growth",t._BAR_TOTAL_CLASS="waterfall-total",t._CONNECTOR_CLASS="connector",t._CONNECTOR_AREA_CLASS="connector-area",t._TOTAL_KEY="total",t}(rqe.Bar);Yat.Waterfall=iqe});var IS=H(zs=>{"use strict";Object.defineProperty(zs,"__esModule",{value:!0});var zc=(de(),Ut(pe));zc.__exportStar(Tat(),zs);zc.__exportStar(y4(),zs);zc.__exportStar(Got(),zs);zc.__exportStar(wKt(),zs);zc.__exportStar(Sat(),zs);zc.__exportStar(SKt(),zs);zc.__exportStar(MKt(),zs);zc.__exportStar(TKt(),zs);zc.__exportStar(CKt(),zs);zc.__exportStar(IKt(),zs);zc.__exportStar(kKt(),zs);zc.__exportStar(RKt(),zs)});var NKt=H(jat=>{"use strict";Object.defineProperty(jat,"__esModule",{value:!0});jat.version="3.9.0"});var Sl=H(ln=>{"use strict";Object.defineProperty(ln,"__esModule",{value:!0});var Fc=(de(),Ut(pe));$jt();var oqe=kf();ln.Animators=oqe;var aqe=f$t();ln.Axes=aqe;var sqe=Pot();ln.Components=sqe;var lqe=$A();ln.Configs=lqe;var cqe=Bu();ln.Formatters=cqe;var uqe=IF();ln.RenderController=uqe;var hqe=Hit();ln.RenderPolicies=hqe;var fqe=XF();ln.SymbolFactories=fqe;var pqe=Dv();ln.Dispatchers=pqe;var dqe=Hv();ln.Drawers=dqe;var mqe=l4();ln.Interactions=mqe;var gqe=IS();ln.Plots=gqe;var _qe=Rs();ln.Scales=_qe;var yqe=Fe();ln.Utils=yqe;Fc.__exportStar(t4(),ln);var vqe=HF();ln.TimeInterval=vqe.TimeInterval;Fc.__exportStar(kc(),ln);Fc.__exportStar(WF(),ln);Fc.__exportStar(Yot(),ln);var xqe=NKt();ln.version=xqe.version;Fc.__exportStar(o4(),ln);Fc.__exportStar(Uu(),ln);Fc.__exportStar(Ov(),ln);Fc.__exportStar(wot(),ln);Fc.__exportStar(Vv(),ln);Fc.__exportStar(ns(),ln);Fc.__exportStar(xd(),ln);Fc.__exportStar(kv(),ln)});var QKt=H((sXn,JKt)=>{function Bqe(){this.__data__=[],this.size=0}JKt.exports=Bqe});var jv=H((lXn,tZt)=>{function Hqe(e,t){return e===t||e!==e&&t!==t}tZt.exports=Hqe});var M4=H((cXn,eZt)=>{var Vqe=jv();function Uqe(e,t){for(var r=e.length;r--;)if(Vqe(e[r][0],t))return r;return-1}eZt.exports=Uqe});var nZt=H((uXn,rZt)=>{var qqe=M4(),Gqe=Array.prototype,Wqe=Gqe.splice;function Yqe(e){var t=this.__data__,r=qqe(t,e);if(r<0)return!1;var n=t.length-1;return r==n?t.pop():Wqe.call(t,r,1),--this.size,!0}rZt.exports=Yqe});var oZt=H((hXn,iZt)=>{var jqe=M4();function Xqe(e){var t=this.__data__,r=jqe(t,e);return r<0?void 0:t[r][1]}iZt.exports=Xqe});var sZt=H((fXn,aZt)=>{var $qe=M4();function Kqe(e){return $qe(this.__data__,e)>-1}aZt.exports=Kqe});var cZt=H((pXn,lZt)=>{var Zqe=M4();function Jqe(e,t){var r=this.__data__,n=Zqe(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}lZt.exports=Jqe});var E4=H((dXn,uZt)=>{var Qqe=QKt(),tGe=nZt(),eGe=oZt(),rGe=sZt(),nGe=cZt();function zS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}zS.prototype.clear=Qqe;zS.prototype.delete=tGe;zS.prototype.get=eGe;zS.prototype.has=rGe;zS.prototype.set=nGe;uZt.exports=zS});var fZt=H((mXn,hZt)=>{var iGe=E4();function oGe(){this.__data__=new iGe,this.size=0}hZt.exports=oGe});var dZt=H((gXn,pZt)=>{function aGe(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}pZt.exports=aGe});var gZt=H((_Xn,mZt)=>{function sGe(e){return this.__data__.get(e)}mZt.exports=sGe});var yZt=H((yXn,_Zt)=>{function lGe(e){return this.__data__.has(e)}_Zt.exports=lGe});var cst=H((vXn,vZt)=>{var cGe=typeof global=="object"&&global&&global.Object===Object&&global;vZt.exports=cGe});var Hc=H((xXn,xZt)=>{var uGe=cst(),hGe=typeof self=="object"&&self&&self.Object===Object&&self,fGe=uGe||hGe||Function("return this")();xZt.exports=fGe});var Xv=H((bXn,bZt)=>{var pGe=Hc(),dGe=pGe.Symbol;bZt.exports=dGe});var EZt=H((wXn,MZt)=>{var wZt=Xv(),SZt=Object.prototype,mGe=SZt.hasOwnProperty,gGe=SZt.toString,T4=wZt?wZt.toStringTag:void 0;function _Ge(e){var t=mGe.call(e,T4),r=e[T4];try{e[T4]=void 0;var n=!0}catch(o){}var i=gGe.call(e);return n&&(t?e[T4]=r:delete e[T4]),i}MZt.exports=_Ge});var CZt=H((SXn,TZt)=>{var yGe=Object.prototype,vGe=yGe.toString;function xGe(e){return vGe.call(e)}TZt.exports=xGe});var l0=H((MXn,IZt)=>{var AZt=Xv(),bGe=EZt(),wGe=CZt(),SGe="[object Null]",MGe="[object Undefined]",PZt=AZt?AZt.toStringTag:void 0;function EGe(e){return e==null?e===void 0?MGe:SGe:PZt&&PZt in Object(e)?bGe(e):wGe(e)}IZt.exports=EGe});var El=H((EXn,LZt)=>{function TGe(e){var t=typeof e;return e!=null&&(t=="object"||t=="function")}LZt.exports=TGe});var FS=H((TXn,kZt)=>{var CGe=l0(),AGe=El(),PGe="[object AsyncFunction]",IGe="[object Function]",LGe="[object GeneratorFunction]",kGe="[object Proxy]";function RGe(e){if(!AGe(e))return!1;var t=CGe(e);return t==IGe||t==LGe||t==PGe||t==kGe}kZt.exports=RGe});var NZt=H((CXn,RZt)=>{var NGe=Hc(),DGe=NGe["__core-js_shared__"];RZt.exports=DGe});var zZt=H((AXn,OZt)=>{var ust=NZt(),DZt=function(){var e=/[^.]+$/.exec(ust&&ust.keys&&ust.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();function OGe(e){return!!DZt&&DZt in e}OZt.exports=OGe});var hst=H((PXn,FZt)=>{var zGe=Function.prototype,FGe=zGe.toString;function BGe(e){if(e!=null){try{return FGe.call(e)}catch(t){}try{return e+""}catch(t){}}return""}FZt.exports=BGe});var HZt=H((IXn,BZt)=>{var HGe=FS(),VGe=zZt(),UGe=El(),qGe=hst(),GGe=/[\\^$.*+?()[\]{}|]/g,WGe=/^\[object .+?Constructor\]$/,YGe=Function.prototype,jGe=Object.prototype,XGe=YGe.toString,$Ge=jGe.hasOwnProperty,KGe=RegExp("^"+XGe.call($Ge).replace(GGe,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function ZGe(e){if(!UGe(e)||VGe(e))return!1;var t=HGe(e)?KGe:WGe;return t.test(qGe(e))}BZt.exports=ZGe});var UZt=H((LXn,VZt)=>{function JGe(e,t){return e==null?void 0:e[t]}VZt.exports=JGe});var c0=H((kXn,qZt)=>{var QGe=HZt(),tWe=UZt();function eWe(e,t){var r=tWe(e,t);return QGe(r)?r:void 0}qZt.exports=eWe});var zB=H((RXn,GZt)=>{var rWe=c0(),nWe=Hc(),iWe=rWe(nWe,"Map");GZt.exports=iWe});var C4=H((NXn,WZt)=>{var oWe=c0(),aWe=oWe(Object,"create");WZt.exports=aWe});var XZt=H((DXn,jZt)=>{var YZt=C4();function sWe(){this.__data__=YZt?YZt(null):{},this.size=0}jZt.exports=sWe});var KZt=H((OXn,$Zt)=>{function lWe(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}$Zt.exports=lWe});var JZt=H((zXn,ZZt)=>{var cWe=C4(),uWe="__lodash_hash_undefined__",hWe=Object.prototype,fWe=hWe.hasOwnProperty;function pWe(e){var t=this.__data__;if(cWe){var r=t[e];return r===uWe?void 0:r}return fWe.call(t,e)?t[e]:void 0}ZZt.exports=pWe});var tJt=H((FXn,QZt)=>{var dWe=C4(),mWe=Object.prototype,gWe=mWe.hasOwnProperty;function _We(e){var t=this.__data__;return dWe?t[e]!==void 0:gWe.call(t,e)}QZt.exports=_We});var rJt=H((BXn,eJt)=>{var yWe=C4(),vWe="__lodash_hash_undefined__";function xWe(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=yWe&&t===void 0?vWe:t,this}eJt.exports=xWe});var iJt=H((HXn,nJt)=>{var bWe=XZt(),wWe=KZt(),SWe=JZt(),MWe=tJt(),EWe=rJt();function BS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}BS.prototype.clear=bWe;BS.prototype.delete=wWe;BS.prototype.get=SWe;BS.prototype.has=MWe;BS.prototype.set=EWe;nJt.exports=BS});var sJt=H((VXn,aJt)=>{var oJt=iJt(),TWe=E4(),CWe=zB();function AWe(){this.size=0,this.__data__={hash:new oJt,map:new(CWe||TWe),string:new oJt}}aJt.exports=AWe});var cJt=H((UXn,lJt)=>{function PWe(e){var t=typeof e;return t=="string"||t=="number"||t=="symbol"||t=="boolean"?e!=="__proto__":e===null}lJt.exports=PWe});var A4=H((qXn,uJt)=>{var IWe=cJt();function LWe(e,t){var r=e.__data__;return IWe(t)?r[typeof t=="string"?"string":"hash"]:r.map}uJt.exports=LWe});var fJt=H((GXn,hJt)=>{var kWe=A4();function RWe(e){var t=kWe(this,e).delete(e);return this.size-=t?1:0,t}hJt.exports=RWe});var dJt=H((WXn,pJt)=>{var NWe=A4();function DWe(e){return NWe(this,e).get(e)}pJt.exports=DWe});var gJt=H((YXn,mJt)=>{var OWe=A4();function zWe(e){return OWe(this,e).has(e)}mJt.exports=zWe});var yJt=H((jXn,_Jt)=>{var FWe=A4();function BWe(e,t){var r=FWe(this,e),n=r.size;return r.set(e,t),this.size+=r.size==n?0:1,this}_Jt.exports=BWe});var FB=H((XXn,vJt)=>{var HWe=sJt(),VWe=fJt(),UWe=dJt(),qWe=gJt(),GWe=yJt();function HS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}HS.prototype.clear=HWe;HS.prototype.delete=VWe;HS.prototype.get=UWe;HS.prototype.has=qWe;HS.prototype.set=GWe;vJt.exports=HS});var bJt=H(($Xn,xJt)=>{var WWe=E4(),YWe=zB(),jWe=FB(),XWe=200;function $We(e,t){var r=this.__data__;if(r instanceof WWe){var n=r.__data__;if(!YWe||n.length<XWe-1)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new jWe(n)}return r.set(e,t),this.size=r.size,this}xJt.exports=$We});var P4=H((KXn,wJt)=>{var KWe=E4(),ZWe=fZt(),JWe=dZt(),QWe=gZt(),tYe=yZt(),eYe=bJt();function VS(e){var t=this.__data__=new KWe(e);this.size=t.size}VS.prototype.clear=ZWe;VS.prototype.delete=JWe;VS.prototype.get=QWe;VS.prototype.has=tYe;VS.prototype.set=eYe;wJt.exports=VS});var BB=H((ZXn,SJt)=>{function rYe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n&&t(e[r],r,e)!==!1;);return e}SJt.exports=rYe});var fst=H((JXn,MJt)=>{var nYe=c0(),iYe=function(){try{var e=nYe(Object,"defineProperty");return e({},"",{}),e}catch(t){}}();MJt.exports=iYe});var I4=H((QXn,TJt)=>{var EJt=fst();function oYe(e,t,r){t=="__proto__"&&EJt?EJt(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}TJt.exports=oYe});var L4=H((t$n,CJt)=>{var aYe=I4(),sYe=jv(),lYe=Object.prototype,cYe=lYe.hasOwnProperty;function uYe(e,t,r){var n=e[t];(!(cYe.call(e,t)&&sYe(n,r))||r===void 0&&!(t in e))&&aYe(e,t,r)}CJt.exports=uYe});var US=H((e$n,AJt)=>{var hYe=L4(),fYe=I4();function pYe(e,t,r,n){var i=!r;r||(r={});for(var o=-1,a=t.length;++o<a;){var s=t[o],l=n?n(r[s],e[s],s,r,e):void 0;l===void 0&&(l=e[s]),i?fYe(r,s,l):hYe(r,s,l)}return r}AJt.exports=pYe});var IJt=H((r$n,PJt)=>{function dYe(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}PJt.exports=dYe});var Yu=H((n$n,LJt)=>{function mYe(e){return e!=null&&typeof e=="object"}LJt.exports=mYe});var RJt=H((i$n,kJt)=>{var gYe=l0(),_Ye=Yu(),yYe="[object Arguments]";function vYe(e){return _Ye(e)&&gYe(e)==yYe}kJt.exports=vYe});var qS=H((o$n,OJt)=>{var NJt=RJt(),xYe=Yu(),DJt=Object.prototype,bYe=DJt.hasOwnProperty,wYe=DJt.propertyIsEnumerable,SYe=NJt(function(){return arguments}())?NJt:function(e){return xYe(e)&&bYe.call(e,"callee")&&!wYe.call(e,"callee")};OJt.exports=SYe});var Ti=H((a$n,zJt)=>{var MYe=Array.isArray;zJt.exports=MYe});var BJt=H((s$n,FJt)=>{function EYe(){return!1}FJt.exports=EYe});var $v=H((k4,GS)=>{var TYe=Hc(),CYe=BJt(),UJt=typeof k4=="object"&&k4&&!k4.nodeType&&k4,HJt=UJt&&typeof GS=="object"&&GS&&!GS.nodeType&&GS,AYe=HJt&&HJt.exports===UJt,VJt=AYe?TYe.Buffer:void 0,PYe=VJt?VJt.isBuffer:void 0,IYe=PYe||CYe;GS.exports=IYe});var R4=H((l$n,qJt)=>{var LYe=9007199254740991,kYe=/^(?:0|[1-9]\d*)$/;function RYe(e,t){var r=typeof e;return t=t==null?LYe:t,!!t&&(r=="number"||r!="symbol"&&kYe.test(e))&&e>-1&&e%1==0&&e<t}qJt.exports=RYe});var HB=H((c$n,GJt)=>{var NYe=9007199254740991;function DYe(e){return typeof e=="number"&&e>-1&&e%1==0&&e<=NYe}GJt.exports=DYe});var YJt=H((u$n,WJt)=>{var OYe=l0(),zYe=HB(),FYe=Yu(),BYe="[object Arguments]",HYe="[object Array]",VYe="[object Boolean]",UYe="[object Date]",qYe="[object Error]",GYe="[object Function]",WYe="[object Map]",YYe="[object Number]",jYe="[object Object]",XYe="[object RegExp]",$Ye="[object Set]",KYe="[object String]",ZYe="[object WeakMap]",JYe="[object ArrayBuffer]",QYe="[object DataView]",tje="[object Float32Array]",eje="[object Float64Array]",rje="[object Int8Array]",nje="[object Int16Array]",ije="[object Int32Array]",oje="[object Uint8Array]",aje="[object Uint8ClampedArray]",sje="[object Uint16Array]",lje="[object Uint32Array]",Un={};Un[tje]=Un[eje]=Un[rje]=Un[nje]=Un[ije]=Un[oje]=Un[aje]=Un[sje]=Un[lje]=!0;Un[BYe]=Un[HYe]=Un[JYe]=Un[VYe]=Un[QYe]=Un[UYe]=Un[qYe]=Un[GYe]=Un[WYe]=Un[YYe]=Un[jYe]=Un[XYe]=Un[$Ye]=Un[KYe]=Un[ZYe]=!1;function cje(e){return FYe(e)&&zYe(e.length)&&!!Un[OYe(e)]}WJt.exports=cje});var N4=H((h$n,jJt)=>{function uje(e){return function(t){return e(t)}}jJt.exports=uje});var VB=H((D4,WS)=>{var hje=cst(),XJt=typeof D4=="object"&&D4&&!D4.nodeType&&D4,O4=XJt&&typeof WS=="object"&&WS&&!WS.nodeType&&WS,fje=O4&&O4.exports===XJt,pst=fje&&hje.process,pje=function(){try{var e=O4&&O4.require&&O4.require("util").types;return e||pst&&pst.binding&&pst.binding("util")}catch(t){}}();WS.exports=pje});var YS=H((f$n,ZJt)=>{var dje=YJt(),mje=N4(),$Jt=VB(),KJt=$Jt&&$Jt.isTypedArray,gje=KJt?mje(KJt):dje;ZJt.exports=gje});var dst=H((p$n,JJt)=>{var _je=IJt(),yje=qS(),vje=Ti(),xje=$v(),bje=R4(),wje=YS(),Sje=Object.prototype,Mje=Sje.hasOwnProperty;function Eje(e,t){var r=vje(e),n=!r&&yje(e),i=!r&&!n&&xje(e),o=!r&&!n&&!i&&wje(e),a=r||n||i||o,s=a?_je(e.length,String):[],l=s.length;for(var c in e)(t||Mje.call(e,c))&&!(a&&(c=="length"||i&&(c=="offset"||c=="parent")||o&&(c=="buffer"||c=="byteLength"||c=="byteOffset")||bje(c,l)))&&s.push(c);return s}JJt.exports=Eje});var z4=H((d$n,QJt)=>{var Tje=Object.prototype;function Cje(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||Tje;return e===r}QJt.exports=Cje});var mst=H((m$n,tQt)=>{function Aje(e,t){return function(r){return e(t(r))}}tQt.exports=Aje});var rQt=H((g$n,eQt)=>{var Pje=mst(),Ije=Pje(Object.keys,Object);eQt.exports=Ije});var UB=H((_$n,nQt)=>{var Lje=z4(),kje=rQt(),Rje=Object.prototype,Nje=Rje.hasOwnProperty;function Dje(e){if(!Lje(e))return kje(e);var t=[];for(var r in Object(e))Nje.call(e,r)&&r!="constructor"&&t.push(r);return t}nQt.exports=Dje});var Hf=H((y$n,iQt)=>{var Oje=FS(),zje=HB();function Fje(e){return e!=null&&zje(e.length)&&!Oje(e)}iQt.exports=Fje});var Pd=H((v$n,oQt)=>{var Bje=dst(),Hje=UB(),Vje=Hf();function Uje(e){return Vje(e)?Bje(e):Hje(e)}oQt.exports=Uje});var sQt=H((x$n,aQt)=>{var qje=US(),Gje=Pd();function Wje(e,t){return e&&qje(t,Gje(t),e)}aQt.exports=Wje});var cQt=H((b$n,lQt)=>{function Yje(e){var t=[];if(e!=null)for(var r in Object(e))t.push(r);return t}lQt.exports=Yje});var hQt=H((w$n,uQt)=>{var jje=El(),Xje=z4(),$je=cQt(),Kje=Object.prototype,Zje=Kje.hasOwnProperty;function Jje(e){if(!jje(e))return $je(e);var t=Xje(e),r=[];for(var n in e)n=="constructor"&&(t||!Zje.call(e,n))||r.push(n);return r}uQt.exports=Jje});var u0=H((S$n,fQt)=>{var Qje=dst(),tXe=hQt(),eXe=Hf();function rXe(e){return eXe(e)?Qje(e,!0):tXe(e)}fQt.exports=rXe});var dQt=H((M$n,pQt)=>{var nXe=US(),iXe=u0();function oXe(e,t){return e&&nXe(t,iXe(t),e)}pQt.exports=oXe});var gst=H((F4,jS)=>{var aXe=Hc(),yQt=typeof F4=="object"&&F4&&!F4.nodeType&&F4,mQt=yQt&&typeof jS=="object"&&jS&&!jS.nodeType&&jS,sXe=mQt&&mQt.exports===yQt,gQt=sXe?aXe.Buffer:void 0,_Qt=gQt?gQt.allocUnsafe:void 0;function lXe(e,t){if(t)return e.slice();var r=e.length,n=_Qt?_Qt(r):new e.constructor(r);return e.copy(n),n}jS.exports=lXe});var _st=H((E$n,vQt)=>{function cXe(e,t){var r=-1,n=e.length;for(t||(t=Array(n));++r<n;)t[r]=e[r];return t}vQt.exports=cXe});var yst=H((T$n,xQt)=>{function uXe(e,t){for(var r=-1,n=e==null?0:e.length,i=0,o=[];++r<n;){var a=e[r];t(a,r,e)&&(o[i++]=a)}return o}xQt.exports=uXe});var vst=H((C$n,bQt)=>{function hXe(){return[]}bQt.exports=hXe});var qB=H((A$n,SQt)=>{var fXe=yst(),pXe=vst(),dXe=Object.prototype,mXe=dXe.propertyIsEnumerable,wQt=Object.getOwnPropertySymbols,gXe=wQt?function(e){return e==null?[]:(e=Object(e),fXe(wQt(e),function(t){return mXe.call(e,t)}))}:pXe;SQt.exports=gXe});var EQt=H((P$n,MQt)=>{var _Xe=US(),yXe=qB();function vXe(e,t){return _Xe(e,yXe(e),t)}MQt.exports=vXe});var GB=H((I$n,TQt)=>{function xXe(e,t){for(var r=-1,n=t.length,i=e.length;++r<n;)e[i+r]=t[r];return e}TQt.exports=xXe});var B4=H((L$n,CQt)=>{var bXe=mst(),wXe=bXe(Object.getPrototypeOf,Object);CQt.exports=wXe});var xst=H((k$n,AQt)=>{var SXe=GB(),MXe=B4(),EXe=qB(),TXe=vst(),CXe=Object.getOwnPropertySymbols,AXe=CXe?function(e){for(var t=[];e;)SXe(t,EXe(e)),e=MXe(e);return t}:TXe;AQt.exports=AXe});var IQt=H((R$n,PQt)=>{var PXe=US(),IXe=xst();function LXe(e,t){return PXe(e,IXe(e),t)}PQt.exports=LXe});var bst=H((N$n,LQt)=>{var kXe=GB(),RXe=Ti();function NXe(e,t,r){var n=t(e);return RXe(e)?n:kXe(n,r(e))}LQt.exports=NXe});var wst=H((D$n,kQt)=>{var DXe=bst(),OXe=qB(),zXe=Pd();function FXe(e){return DXe(e,zXe,OXe)}kQt.exports=FXe});var NQt=H((O$n,RQt)=>{var BXe=bst(),HXe=xst(),VXe=u0();function UXe(e){return BXe(e,VXe,HXe)}RQt.exports=UXe});var OQt=H((z$n,DQt)=>{var qXe=c0(),GXe=Hc(),WXe=qXe(GXe,"DataView");DQt.exports=WXe});var FQt=H((F$n,zQt)=>{var YXe=c0(),jXe=Hc(),XXe=YXe(jXe,"Promise");zQt.exports=XXe});var Sst=H((B$n,BQt)=>{var $Xe=c0(),KXe=Hc(),ZXe=$Xe(KXe,"Set");BQt.exports=ZXe});var VQt=H((H$n,HQt)=>{var JXe=c0(),QXe=Hc(),t$e=JXe(QXe,"WeakMap");HQt.exports=t$e});var Zv=H((V$n,XQt)=>{var Mst=OQt(),Est=zB(),Tst=FQt(),Cst=Sst(),Ast=VQt(),jQt=l0(),XS=hst(),UQt="[object Map]",e$e="[object Object]",qQt="[object Promise]",GQt="[object Set]",WQt="[object WeakMap]",YQt="[object DataView]",r$e=XS(Mst),n$e=XS(Est),i$e=XS(Tst),o$e=XS(Cst),a$e=XS(Ast),Kv=jQt;(Mst&&Kv(new Mst(new ArrayBuffer(1)))!=YQt||Est&&Kv(new Est)!=UQt||Tst&&Kv(Tst.resolve())!=qQt||Cst&&Kv(new Cst)!=GQt||Ast&&Kv(new Ast)!=WQt)&&(Kv=function(e){var t=jQt(e),r=t==e$e?e.constructor:void 0,n=r?XS(r):"";if(n)switch(n){case r$e:return YQt;case n$e:return UQt;case i$e:return qQt;case o$e:return GQt;case a$e:return WQt}return t});XQt.exports=Kv});var KQt=H((U$n,$Qt)=>{var s$e=Object.prototype,l$e=s$e.hasOwnProperty;function c$e(e){var t=e.length,r=new e.constructor(t);return t&&typeof e[0]=="string"&&l$e.call(e,"index")&&(r.index=e.index,r.input=e.input),r}$Qt.exports=c$e});var Pst=H((q$n,ZQt)=>{var u$e=Hc(),h$e=u$e.Uint8Array;ZQt.exports=h$e});var WB=H((G$n,QQt)=>{var JQt=Pst();function f$e(e){var t=new e.constructor(e.byteLength);return new JQt(t).set(new JQt(e)),t}QQt.exports=f$e});var ete=H((W$n,tte)=>{var p$e=WB();function d$e(e,t){var r=t?p$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.byteLength)}tte.exports=d$e});var nte=H((Y$n,rte)=>{var m$e=/\w*$/;function g$e(e){var t=new e.constructor(e.source,m$e.exec(e));return t.lastIndex=e.lastIndex,t}rte.exports=g$e});var lte=H((j$n,ste)=>{var ite=Xv(),ote=ite?ite.prototype:void 0,ate=ote?ote.valueOf:void 0;function _$e(e){return ate?Object(ate.call(e)):{}}ste.exports=_$e});var Ist=H((X$n,cte)=>{var y$e=WB();function v$e(e,t){var r=t?y$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.length)}cte.exports=v$e});var hte=H(($$n,ute)=>{var x$e=WB(),b$e=ete(),w$e=nte(),S$e=lte(),M$e=Ist(),E$e="[object Boolean]",T$e="[object Date]",C$e="[object Map]",A$e="[object Number]",P$e="[object RegExp]",I$e="[object Set]",L$e="[object String]",k$e="[object Symbol]",R$e="[object ArrayBuffer]",N$e="[object DataView]",D$e="[object Float32Array]",O$e="[object Float64Array]",z$e="[object Int8Array]",F$e="[object Int16Array]",B$e="[object Int32Array]",H$e="[object Uint8Array]",V$e="[object Uint8ClampedArray]",U$e="[object Uint16Array]",q$e="[object Uint32Array]";function G$e(e,t,r){var n=e.constructor;switch(t){case R$e:return x$e(e);case E$e:case T$e:return new n(+e);case N$e:return b$e(e,r);case D$e:case O$e:case z$e:case F$e:case B$e:case H$e:case V$e:case U$e:case q$e:return M$e(e,r);case C$e:return new n;case A$e:case L$e:return new n(e);case P$e:return w$e(e);case I$e:return new n;case k$e:return S$e(e)}}ute.exports=G$e});var Lst=H((K$n,pte)=>{var W$e=El(),fte=Object.create,Y$e=function(){function e(){}return function(t){if(!W$e(t))return{};if(fte)return fte(t);e.prototype=t;var r=new e;return e.prototype=void 0,r}}();pte.exports=Y$e});var kst=H((Z$n,dte)=>{var j$e=Lst(),X$e=B4(),$$e=z4();function K$e(e){return typeof e.constructor=="function"&&!$$e(e)?j$e(X$e(e)):{}}dte.exports=K$e});var gte=H((J$n,mte)=>{var Z$e=Zv(),J$e=Yu(),Q$e="[object Map]";function tKe(e){return J$e(e)&&Z$e(e)==Q$e}mte.exports=tKe});var xte=H((Q$n,vte)=>{var eKe=gte(),rKe=N4(),_te=VB(),yte=_te&&_te.isMap,nKe=yte?rKe(yte):eKe;vte.exports=nKe});var wte=H((tKn,bte)=>{var iKe=Zv(),oKe=Yu(),aKe="[object Set]";function sKe(e){return oKe(e)&&iKe(e)==aKe}bte.exports=sKe});var Tte=H((eKn,Ete)=>{var lKe=wte(),cKe=N4(),Ste=VB(),Mte=Ste&&Ste.isSet,uKe=Mte?cKe(Mte):lKe;Ete.exports=uKe});var Rst=H((rKn,Ite)=>{var hKe=P4(),fKe=BB(),pKe=L4(),dKe=sQt(),mKe=dQt(),gKe=gst(),_Ke=_st(),yKe=EQt(),vKe=IQt(),xKe=wst(),bKe=NQt(),wKe=Zv(),SKe=KQt(),MKe=hte(),EKe=kst(),TKe=Ti(),CKe=$v(),AKe=xte(),PKe=El(),IKe=Tte(),LKe=Pd(),kKe=u0(),RKe=1,NKe=2,DKe=4,Cte="[object Arguments]",OKe="[object Array]",zKe="[object Boolean]",FKe="[object Date]",BKe="[object Error]",Ate="[object Function]",HKe="[object GeneratorFunction]",VKe="[object Map]",UKe="[object Number]",Pte="[object Object]",qKe="[object RegExp]",GKe="[object Set]",WKe="[object String]",YKe="[object Symbol]",jKe="[object WeakMap]",XKe="[object ArrayBuffer]",$Ke="[object DataView]",KKe="[object Float32Array]",ZKe="[object Float64Array]",JKe="[object Int8Array]",QKe="[object Int16Array]",tZe="[object Int32Array]",eZe="[object Uint8Array]",rZe="[object Uint8ClampedArray]",nZe="[object Uint16Array]",iZe="[object Uint32Array]",Cn={};Cn[Cte]=Cn[OKe]=Cn[XKe]=Cn[$Ke]=Cn[zKe]=Cn[FKe]=Cn[KKe]=Cn[ZKe]=Cn[JKe]=Cn[QKe]=Cn[tZe]=Cn[VKe]=Cn[UKe]=Cn[Pte]=Cn[qKe]=Cn[GKe]=Cn[WKe]=Cn[YKe]=Cn[eZe]=Cn[rZe]=Cn[nZe]=Cn[iZe]=!0;Cn[BKe]=Cn[Ate]=Cn[jKe]=!1;function YB(e,t,r,n,i,o){var a,s=t&RKe,l=t&NKe,c=t&DKe;if(r&&(a=i?r(e,n,i,o):r(e)),a!==void 0)return a;if(!PKe(e))return e;var u=TKe(e);if(u){if(a=SKe(e),!s)return _Ke(e,a)}else{var h=wKe(e),f=h==Ate||h==HKe;if(CKe(e))return gKe(e,s);if(h==Pte||h==Cte||f&&!i){if(a=l||f?{}:EKe(e),!s)return l?vKe(e,mKe(a,e)):yKe(e,dKe(a,e))}else{if(!Cn[h])return i?e:{};a=MKe(e,h,s)}}o||(o=new hKe);var p=o.get(e);if(p)return p;o.set(e,a),IKe(e)?e.forEach(function(_){a.add(YB(_,t,r,_,e,o))}):AKe(e)&&e.forEach(function(_,y){a.set(y,YB(_,t,r,y,e,o))});var d=c?l?bKe:xKe:l?kKe:LKe,g=u?void 0:d(e);return fKe(g||e,function(_,y){g&&(y=_,_=e[y]),pKe(a,y,YB(_,t,r,y,e,o))}),a}Ite.exports=YB});var kte=H((nKn,Lte)=>{var oZe=Rst(),aZe=4;function sZe(e){return oZe(e,aZe)}Lte.exports=sZe});var jB=H((iKn,Rte)=>{function lZe(e){return function(){return e}}Rte.exports=lZe});var Dte=H((oKn,Nte)=>{function cZe(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var l=a[e?s:++i];if(r(o[l],l,o)===!1)break}return t}}Nte.exports=cZe});var XB=H((aKn,Ote)=>{var uZe=Dte(),hZe=uZe();Ote.exports=hZe});var $B=H((sKn,zte)=>{var fZe=XB(),pZe=Pd();function dZe(e,t){return e&&fZe(e,t,pZe)}zte.exports=dZe});var Bte=H((lKn,Fte)=>{var mZe=Hf();function gZe(e,t){return function(r,n){if(r==null)return r;if(!mZe(r))return e(r,n);for(var i=r.length,o=t?i:-1,a=Object(r);(t?o--:++o<i)&&n(a[o],o,a)!==!1;);return r}}Fte.exports=gZe});var H4=H((cKn,Hte)=>{var _Ze=$B(),yZe=Bte(),vZe=yZe(_Ze);Hte.exports=vZe});var h0=H((uKn,Vte)=>{function xZe(e){return e}Vte.exports=xZe});var Nst=H((hKn,Ute)=>{var bZe=h0();function wZe(e){return typeof e=="function"?e:bZe}Ute.exports=wZe});var Dst=H((fKn,qte)=>{var SZe=BB(),MZe=H4(),EZe=Nst(),TZe=Ti();function CZe(e,t){var r=TZe(e)?SZe:MZe;return r(e,EZe(t))}qte.exports=CZe});var Ost=H((pKn,Gte)=>{Gte.exports=Dst()});var Yte=H((dKn,Wte)=>{var AZe=H4();function PZe(e,t){var r=[];return AZe(e,function(n,i,o){t(n,i,o)&&r.push(n)}),r}Wte.exports=PZe});var Xte=H((mKn,jte)=>{var IZe="__lodash_hash_undefined__";function LZe(e){return this.__data__.set(e,IZe),this}jte.exports=LZe});var Kte=H((gKn,$te)=>{function kZe(e){return this.__data__.has(e)}$te.exports=kZe});var zst=H((_Kn,Zte)=>{var RZe=FB(),NZe=Xte(),DZe=Kte();function KB(e){var t=-1,r=e==null?0:e.length;for(this.__data__=new RZe;++t<r;)this.add(e[t])}KB.prototype.add=KB.prototype.push=NZe;KB.prototype.has=DZe;Zte.exports=KB});var Qte=H((yKn,Jte)=>{function OZe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n;)if(t(e[r],r,e))return!0;return!1}Jte.exports=OZe});var Fst=H((vKn,tee)=>{function zZe(e,t){return e.has(t)}tee.exports=zZe});var Bst=H((xKn,eee)=>{var FZe=zst(),BZe=Qte(),HZe=Fst(),VZe=1,UZe=2;function qZe(e,t,r,n,i,o){var a=r&VZe,s=e.length,l=t.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(e),u=o.get(t);if(c&&u)return c==t&&u==e;var h=-1,f=!0,p=r&UZe?new FZe:void 0;for(o.set(e,t),o.set(t,e);++h<s;){var d=e[h],g=t[h];if(n)var _=a?n(g,d,h,t,e,o):n(d,g,h,e,t,o);if(_!==void 0){if(_)continue;f=!1;break}if(p){if(!BZe(t,function(y,x){if(!HZe(p,x)&&(d===y||i(d,y,r,n,o)))return p.push(x)})){f=!1;break}}else if(!(d===g||i(d,g,r,n,o))){f=!1;break}}return o.delete(e),o.delete(t),f}eee.exports=qZe});var nee=H((bKn,ree)=>{function GZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n,i){r[++t]=[i,n]}),r}ree.exports=GZe});var ZB=H((wKn,iee)=>{function WZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n){r[++t]=n}),r}iee.exports=WZe});var cee=H((SKn,lee)=>{var oee=Xv(),aee=Pst(),YZe=jv(),jZe=Bst(),XZe=nee(),$Ze=ZB(),KZe=1,ZZe=2,JZe="[object Boolean]",QZe="[object Date]",tJe="[object Error]",eJe="[object Map]",rJe="[object Number]",nJe="[object RegExp]",iJe="[object Set]",oJe="[object String]",aJe="[object Symbol]",sJe="[object ArrayBuffer]",lJe="[object DataView]",see=oee?oee.prototype:void 0,Hst=see?see.valueOf:void 0;function cJe(e,t,r,n,i,o,a){switch(r){case lJe:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case sJe:return!(e.byteLength!=t.byteLength||!o(new aee(e),new aee(t)));case JZe:case QZe:case rJe:return YZe(+e,+t);case tJe:return e.name==t.name&&e.message==t.message;case nJe:case oJe:return e==t+"";case eJe:var s=XZe;case iJe:var l=n&KZe;if(s||(s=$Ze),e.size!=t.size&&!l)return!1;var c=a.get(e);if(c)return c==t;n|=ZZe,a.set(e,t);var u=jZe(s(e),s(t),n,i,o,a);return a.delete(e),u;case aJe:if(Hst)return Hst.call(e)==Hst.call(t)}return!1}lee.exports=cJe});var fee=H((MKn,hee)=>{var uee=wst(),uJe=1,hJe=Object.prototype,fJe=hJe.hasOwnProperty;function pJe(e,t,r,n,i,o){var a=r&uJe,s=uee(e),l=s.length,c=uee(t),u=c.length;if(l!=u&&!a)return!1;for(var h=l;h--;){var f=s[h];if(!(a?f in t:fJe.call(t,f)))return!1}var p=o.get(e),d=o.get(t);if(p&&d)return p==t&&d==e;var g=!0;o.set(e,t),o.set(t,e);for(var _=a;++h<l;){f=s[h];var y=e[f],x=t[f];if(n)var b=a?n(x,y,f,t,e,o):n(y,x,f,e,t,o);if(!(b===void 0?y===x||i(y,x,r,n,o):b)){g=!1;break}_||(_=f=="constructor")}if(g&&!_){var S=e.constructor,C=t.constructor;S!=C&&"constructor"in e&&"constructor"in t&&!(typeof S=="function"&&S instanceof S&&typeof C=="function"&&C instanceof C)&&(g=!1)}return o.delete(e),o.delete(t),g}hee.exports=pJe});var xee=H((EKn,vee)=>{var Vst=P4(),dJe=Bst(),mJe=cee(),gJe=fee(),pee=Zv(),dee=Ti(),mee=$v(),_Je=YS(),yJe=1,gee="[object Arguments]",_ee="[object Array]",JB="[object Object]",vJe=Object.prototype,yee=vJe.hasOwnProperty;function xJe(e,t,r,n,i,o){var a=dee(e),s=dee(t),l=a?_ee:pee(e),c=s?_ee:pee(t);l=l==gee?JB:l,c=c==gee?JB:c;var u=l==JB,h=c==JB,f=l==c;if(f&&mee(e)){if(!mee(t))return!1;a=!0,u=!1}if(f&&!u)return o||(o=new Vst),a||_Je(e)?dJe(e,t,r,n,i,o):mJe(e,t,l,r,n,i,o);if(!(r&yJe)){var p=u&&yee.call(e,"__wrapped__"),d=h&&yee.call(t,"__wrapped__");if(p||d){var g=p?e.value():e,_=d?t.value():t;return o||(o=new Vst),i(g,_,r,n,o)}}return f?(o||(o=new Vst),gJe(e,t,r,n,i,o)):!1}vee.exports=xJe});var Ust=H((TKn,See)=>{var bJe=xee(),bee=Yu();function wee(e,t,r,n,i){return e===t?!0:e==null||t==null||!bee(e)&&!bee(t)?e!==e&&t!==t:bJe(e,t,r,n,wee,i)}See.exports=wee});var Eee=H((CKn,Mee)=>{var wJe=P4(),SJe=Ust(),MJe=1,EJe=2;function TJe(e,t,r,n){var i=r.length,o=i,a=!n;if(e==null)return!o;for(e=Object(e);i--;){var s=r[i];if(a&&s[2]?s[1]!==e[s[0]]:!(s[0]in e))return!1}for(;++i<o;){s=r[i];var l=s[0],c=e[l],u=s[1];if(a&&s[2]){if(c===void 0&&!(l in e))return!1}else{var h=new wJe;if(n)var f=n(c,u,l,e,t,h);if(!(f===void 0?SJe(u,c,MJe|EJe,n,h):f))return!1}}return!0}Mee.exports=TJe});var qst=H((AKn,Tee)=>{var CJe=El();function AJe(e){return e===e&&!CJe(e)}Tee.exports=AJe});var Aee=H((PKn,Cee)=>{var PJe=qst(),IJe=Pd();function LJe(e){for(var t=IJe(e),r=t.length;r--;){var n=t[r],i=e[n];t[r]=[n,i,PJe(i)]}return t}Cee.exports=LJe});var Gst=H((IKn,Pee)=>{function kJe(e,t){return function(r){return r==null?!1:r[e]===t&&(t!==void 0||e in Object(r))}}Pee.exports=kJe});var Lee=H((LKn,Iee)=>{var RJe=Eee(),NJe=Aee(),DJe=Gst();function OJe(e){var t=NJe(e);return t.length==1&&t[0][2]?DJe(t[0][0],t[0][1]):function(r){return r===e||RJe(r,e,t)}}Iee.exports=OJe});var Jv=H((kKn,kee)=>{var zJe=l0(),FJe=Yu(),BJe="[object Symbol]";function HJe(e){return typeof e=="symbol"||FJe(e)&&zJe(e)==BJe}kee.exports=HJe});var QB=H((RKn,Ree)=>{var VJe=Ti(),UJe=Jv(),qJe=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,GJe=/^\w*$/;function WJe(e,t){if(VJe(e))return!1;var r=typeof e;return r=="number"||r=="symbol"||r=="boolean"||e==null||UJe(e)?!0:GJe.test(e)||!qJe.test(e)||t!=null&&e in Object(t)}Ree.exports=WJe});var Oee=H((NKn,Dee)=>{var Nee=FB(),YJe="Expected a function";function Wst(e,t){if(typeof e!="function"||t!=null&&typeof t!="function")throw new TypeError(YJe);var r=function(){var n=arguments,i=t?t.apply(this,n):n[0],o=r.cache;if(o.has(i))return o.get(i);var a=e.apply(this,n);return r.cache=o.set(i,a)||o,a};return r.cache=new(Wst.Cache||Nee),r}Wst.Cache=Nee;Dee.exports=Wst});var Fee=H((DKn,zee)=>{var jJe=Oee(),XJe=500;function $Je(e){var t=jJe(e,function(n){return r.size===XJe&&r.clear(),n}),r=t.cache;return t}zee.exports=$Je});var Hee=H((OKn,Bee)=>{var KJe=Fee(),ZJe=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,JJe=/\\(\\)?/g,QJe=KJe(function(e){var t=[];return e.charCodeAt(0)===46&&t.push(""),e.replace(ZJe,function(r,n,i,o){t.push(i?o.replace(JJe,"$1"):n||r)}),t});Bee.exports=QJe});var V4=H((zKn,Vee)=>{function tQe(e,t){for(var r=-1,n=e==null?0:e.length,i=Array(n);++r<n;)i[r]=t(e[r],r,e);return i}Vee.exports=tQe});var jee=H((FKn,Yee)=>{var Uee=Xv(),eQe=V4(),rQe=Ti(),nQe=Jv(),iQe=1/0,qee=Uee?Uee.prototype:void 0,Gee=qee?qee.toString:void 0;function Wee(e){if(typeof e=="string")return e;if(rQe(e))return eQe(e,Wee)+"";if(nQe(e))return Gee?Gee.call(e):"";var t=e+"";return t=="0"&&1/e==-iQe?"-0":t}Yee.exports=Wee});var Yst=H((BKn,Xee)=>{var oQe=jee();function aQe(e){return e==null?"":oQe(e)}Xee.exports=aQe});var U4=H((HKn,$ee)=>{var sQe=Ti(),lQe=QB(),cQe=Hee(),uQe=Yst();function hQe(e,t){return sQe(e)?e:lQe(e,t)?[e]:cQe(uQe(e))}$ee.exports=hQe});var $S=H((VKn,Kee)=>{var fQe=Jv(),pQe=1/0;function dQe(e){if(typeof e=="string"||fQe(e))return e;var t=e+"";return t=="0"&&1/e==-pQe?"-0":t}Kee.exports=dQe});var q4=H((UKn,Zee)=>{var mQe=U4(),gQe=$S();function _Qe(e,t){t=mQe(t,e);for(var r=0,n=t.length;e!=null&&r<n;)e=e[gQe(t[r++])];return r&&r==n?e:void 0}Zee.exports=_Qe});var Qee=H((qKn,Jee)=>{var yQe=q4();function vQe(e,t,r){var n=e==null?void 0:yQe(e,t);return n===void 0?r:n}Jee.exports=vQe});var ere=H((GKn,tre)=>{function xQe(e,t){return e!=null&&t in Object(e)}tre.exports=xQe});var jst=H((WKn,rre)=>{var bQe=U4(),wQe=qS(),SQe=Ti(),MQe=R4(),EQe=HB(),TQe=$S();function CQe(e,t,r){t=bQe(t,e);for(var n=-1,i=t.length,o=!1;++n<i;){var a=TQe(t[n]);if(!(o=e!=null&&r(e,a)))break;e=e[a]}return o||++n!=i?o:(i=e==null?0:e.length,!!i&&EQe(i)&&MQe(a,i)&&(SQe(e)||wQe(e)))}rre.exports=CQe});var Xst=H((YKn,nre)=>{var AQe=ere(),PQe=jst();function IQe(e,t){return e!=null&&PQe(e,t,AQe)}nre.exports=IQe});var ore=H((jKn,ire)=>{var LQe=Ust(),kQe=Qee(),RQe=Xst(),NQe=QB(),DQe=qst(),OQe=Gst(),zQe=$S(),FQe=1,BQe=2;function HQe(e,t){return NQe(e)&&DQe(t)?OQe(zQe(e),t):function(r){var n=kQe(r,e);return n===void 0&&n===t?RQe(r,e):LQe(t,n,FQe|BQe)}}ire.exports=HQe});var $st=H((XKn,are)=>{function VQe(e){return function(t){return t==null?void 0:t[e]}}are.exports=VQe});var lre=H(($Kn,sre)=>{var UQe=q4();function qQe(e){return function(t){return UQe(t,e)}}sre.exports=qQe});var ure=H((KKn,cre)=>{var GQe=$st(),WQe=lre(),YQe=QB(),jQe=$S();function XQe(e){return YQe(e)?GQe(jQe(e)):WQe(e)}cre.exports=XQe});var Vf=H((ZKn,hre)=>{var $Qe=Lee(),KQe=ore(),ZQe=h0(),JQe=Ti(),QQe=ure();function ttr(e){return typeof e=="function"?e:e==null?ZQe:typeof e=="object"?JQe(e)?KQe(e[0],e[1]):$Qe(e):QQe(e)}hre.exports=ttr});var Kst=H((JKn,fre)=>{var etr=yst(),rtr=Yte(),ntr=Vf(),itr=Ti();function otr(e,t){var r=itr(e)?etr:rtr;return r(e,ntr(t,3))}fre.exports=otr});var dre=H((QKn,pre)=>{var atr=Object.prototype,str=atr.hasOwnProperty;function ltr(e,t){return e!=null&&str.call(e,t)}pre.exports=ltr});var Zst=H((tZn,mre)=>{var ctr=dre(),utr=jst();function htr(e,t){return e!=null&&utr(e,t,ctr)}mre.exports=htr});var _re=H((eZn,gre)=>{var ftr=UB(),ptr=Zv(),dtr=qS(),mtr=Ti(),gtr=Hf(),_tr=$v(),ytr=z4(),vtr=YS(),xtr="[object Map]",btr="[object Set]",wtr=Object.prototype,Str=wtr.hasOwnProperty;function Mtr(e){if(e==null)return!0;if(gtr(e)&&(mtr(e)||typeof e=="string"||typeof e.splice=="function"||_tr(e)||vtr(e)||dtr(e)))return!e.length;var t=ptr(e);if(t==xtr||t==btr)return!e.size;if(ytr(e))return!ftr(e).length;for(var r in e)if(Str.call(e,r))return!1;return!0}gre.exports=Mtr});var Jst=H((rZn,yre)=>{function Etr(e){return e===void 0}yre.exports=Etr});var Qst=H((nZn,vre)=>{var Ttr=H4(),Ctr=Hf();function Atr(e,t){var r=-1,n=Ctr(e)?Array(e.length):[];return Ttr(e,function(i,o,a){n[++r]=t(i,o,a)}),n}vre.exports=Atr});var tlt=H((iZn,xre)=>{var Ptr=V4(),Itr=Vf(),Ltr=Qst(),ktr=Ti();function Rtr(e,t){var r=ktr(e)?Ptr:Ltr;return r(e,Itr(t,3))}xre.exports=Rtr});var wre=H((oZn,bre)=>{function Ntr(e,t,r,n){var i=-1,o=e==null?0:e.length;for(n&&o&&(r=e[++i]);++i<o;)r=t(r,e[i],i,e);return r}bre.exports=Ntr});var Mre=H((aZn,Sre)=>{function Dtr(e,t,r,n,i){return i(e,function(o,a,s){r=n?(n=!1,o):t(r,o,a,s)}),r}Sre.exports=Dtr});var elt=H((sZn,Ere)=>{var Otr=wre(),ztr=H4(),Ftr=Vf(),Btr=Mre(),Htr=Ti();function Vtr(e,t,r){var n=Htr(e)?Otr:Btr,i=arguments.length<3;return n(e,Ftr(t,4),r,i,ztr)}Ere.exports=Vtr});var Cre=H((lZn,Tre)=>{var Utr=l0(),qtr=Ti(),Gtr=Yu(),Wtr="[object String]";function Ytr(e){return typeof e=="string"||!qtr(e)&&Gtr(e)&&Utr(e)==Wtr}Tre.exports=Ytr});var Pre=H((cZn,Are)=>{var jtr=$st(),Xtr=jtr("length");Are.exports=Xtr});var Lre=H((uZn,Ire)=>{var $tr="\\ud800-\\udfff",Ktr="\\u0300-\\u036f",Ztr="\\ufe20-\\ufe2f",Jtr="\\u20d0-\\u20ff",Qtr=Ktr+Ztr+Jtr,ter="\\ufe0e\\ufe0f",eer="\\u200d",rer=RegExp("["+eer+$tr+Qtr+ter+"]");function ner(e){return rer.test(e)}Ire.exports=ner});var Hre=H((hZn,Bre)=>{var Rre="\\ud800-\\udfff",ier="\\u0300-\\u036f",oer="\\ufe20-\\ufe2f",aer="\\u20d0-\\u20ff",ser=ier+oer+aer,ler="\\ufe0e\\ufe0f",cer="["+Rre+"]",rlt="["+ser+"]",nlt="\\ud83c[\\udffb-\\udfff]",uer="(?:"+rlt+"|"+nlt+")",Nre="[^"+Rre+"]",Dre="(?:\\ud83c[\\udde6-\\uddff]){2}",Ore="[\\ud800-\\udbff][\\udc00-\\udfff]",her="\\u200d",zre=uer+"?",Fre="["+ler+"]?",fer="(?:"+her+"(?:"+[Nre,Dre,Ore].join("|")+")"+Fre+zre+")*",per=Fre+zre+fer,der="(?:"+[Nre+rlt+"?",rlt,Dre,Ore,cer].join("|")+")",kre=RegExp(nlt+"(?="+nlt+")|"+der+per,"g");function mer(e){for(var t=kre.lastIndex=0;kre.test(e);)++t;return t}Bre.exports=mer});var Ure=H((fZn,Vre)=>{var ger=Pre(),_er=Lre(),yer=Hre();function ver(e){return _er(e)?yer(e):ger(e)}Vre.exports=ver});var Gre=H((pZn,qre)=>{var xer=UB(),ber=Zv(),wer=Hf(),Ser=Cre(),Mer=Ure(),Eer="[object Map]",Ter="[object Set]";function Cer(e){if(e==null)return 0;if(wer(e))return Ser(e)?Mer(e):e.length;var t=ber(e);return t==Eer||t==Ter?e.size:xer(e).length}qre.exports=Cer});var Yre=H((dZn,Wre)=>{var Aer=BB(),Per=Lst(),Ier=$B(),Ler=Vf(),ker=B4(),Rer=Ti(),Ner=$v(),Der=FS(),Oer=El(),zer=YS();function Fer(e,t,r){var n=Rer(e),i=n||Ner(e)||zer(e);if(t=Ler(t,4),r==null){var o=e&&e.constructor;i?r=n?new o:[]:Oer(e)?r=Der(o)?Per(ker(e)):{}:r={}}return(i?Aer:Ier)(e,function(a,s,l){return t(r,a,s,l)}),r}Wre.exports=Fer});var Kre=H((mZn,$re)=>{var jre=Xv(),Ber=qS(),Her=Ti(),Xre=jre?jre.isConcatSpreadable:void 0;function Ver(e){return Her(e)||Ber(e)||!!(Xre&&e&&e[Xre])}$re.exports=Ver});var tH=H((gZn,Jre)=>{var Uer=GB(),qer=Kre();function Zre(e,t,r,n,i){var o=-1,a=e.length;for(r||(r=qer),i||(i=[]);++o<a;){var s=e[o];t>0&&r(s)?t>1?Zre(s,t-1,r,n,i):Uer(i,s):n||(i[i.length]=s)}return i}Jre.exports=Zre});var tne=H((_Zn,Qre)=>{function Ger(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}Qre.exports=Ger});var ilt=H((yZn,rne)=>{var Wer=tne(),ene=Math.max;function Yer(e,t,r){return t=ene(t===void 0?e.length-1:t,0),function(){for(var n=arguments,i=-1,o=ene(n.length-t,0),a=Array(o);++i<o;)a[i]=n[t+i];i=-1;for(var s=Array(t+1);++i<t;)s[i]=n[i];return s[t]=r(a),Wer(e,this,s)}}rne.exports=Yer});var one=H((vZn,ine)=>{var jer=jB(),nne=fst(),Xer=h0(),$er=nne?function(e,t){return nne(e,"toString",{configurable:!0,enumerable:!1,value:jer(t),writable:!0})}:Xer;ine.exports=$er});var sne=H((xZn,ane)=>{var Ker=800,Zer=16,Jer=Date.now;function Qer(e){var t=0,r=0;return function(){var n=Jer(),i=Zer-(n-r);if(r=n,i>0){if(++t>=Ker)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}ane.exports=Qer});var olt=H((bZn,lne)=>{var trr=one(),err=sne(),rrr=err(trr);lne.exports=rrr});var G4=H((wZn,cne)=>{var nrr=h0(),irr=ilt(),orr=olt();function arr(e,t){return orr(irr(e,t,nrr),e+"")}cne.exports=arr});var alt=H((SZn,une)=>{function srr(e,t,r,n){for(var i=e.length,o=r+(n?1:-1);n?o--:++o<i;)if(t(e[o],o,e))return o;return-1}une.exports=srr});var fne=H((MZn,hne)=>{function lrr(e){return e!==e}hne.exports=lrr});var dne=H((EZn,pne)=>{function crr(e,t,r){for(var n=r-1,i=e.length;++n<i;)if(e[n]===t)return n;return-1}pne.exports=crr});var gne=H((TZn,mne)=>{var urr=alt(),hrr=fne(),frr=dne();function prr(e,t,r){return t===t?frr(e,t,r):urr(e,hrr,r)}mne.exports=prr});var yne=H((CZn,_ne)=>{var drr=gne();function mrr(e,t){var r=e==null?0:e.length;return!!r&&drr(e,t,0)>-1}_ne.exports=mrr});var xne=H((AZn,vne)=>{function grr(e,t,r){for(var n=-1,i=e==null?0:e.length;++n<i;)if(r(t,e[n]))return!0;return!1}vne.exports=grr});var wne=H((PZn,bne)=>{function _rr(){}bne.exports=_rr});var Mne=H((IZn,Sne)=>{var slt=Sst(),yrr=wne(),vrr=ZB(),xrr=1/0,brr=slt&&1/vrr(new slt([,-0]))[1]==xrr?function(e){return new slt(e)}:yrr;Sne.exports=brr});var Tne=H((LZn,Ene)=>{var wrr=zst(),Srr=yne(),Mrr=xne(),Err=Fst(),Trr=Mne(),Crr=ZB(),Arr=200;function Prr(e,t,r){var n=-1,i=Srr,o=e.length,a=!0,s=[],l=s;if(r)a=!1,i=Mrr;else if(o>=Arr){var c=t?null:Trr(e);if(c)return Crr(c);a=!1,i=Err,l=new wrr}else l=t?[]:s;t:for(;++n<o;){var u=e[n],h=t?t(u):u;if(u=r||u!==0?u:0,a&&h===h){for(var f=l.length;f--;)if(l[f]===h)continue t;t&&l.push(h),s.push(u)}else i(l,h,r)||(l!==s&&l.push(h),s.push(u))}return s}Ene.exports=Prr});var llt=H((kZn,Cne)=>{var Irr=Hf(),Lrr=Yu();function krr(e){return Lrr(e)&&Irr(e)}Cne.exports=krr});var Pne=H((RZn,Ane)=>{var Rrr=tH(),Nrr=G4(),Drr=Tne(),Orr=llt(),zrr=Nrr(function(e){return Drr(Rrr(e,1,Orr,!0))});Ane.exports=zrr});var Lne=H((NZn,Ine)=>{var Frr=V4();function Brr(e,t){return Frr(t,function(r){return e[r]})}Ine.exports=Brr});var clt=H((DZn,kne)=>{var Hrr=Lne(),Vrr=Pd();function Urr(e){return e==null?[]:Hrr(e,Vrr(e))}kne.exports=Urr});var Tl=H((OZn,Rne)=>{var eH;if(typeof Ex=="function")try{eH={clone:kte(),constant:jB(),each:Ost(),filter:Kst(),has:Zst(),isArray:Ti(),isEmpty:_re(),isFunction:FS(),isUndefined:Jst(),keys:Pd(),map:tlt(),reduce:elt(),size:Gre(),transform:Yre(),union:Pne(),values:clt()}}catch(e){}eH||(eH=window._);Rne.exports=eH});var rH=H((FZn,zne)=>{"use strict";var je=Tl();zne.exports=cr;var qrr="\0",Qv="\0",Nne="";function cr(e){this._isDirected=je.has(e,"directed")?e.directed:!0,this._isMultigraph=je.has(e,"multigraph")?e.multigraph:!1,this._isCompound=je.has(e,"compound")?e.compound:!1,this._label=void 0,this._defaultNodeLabelFn=je.constant(void 0),this._defaultEdgeLabelFn=je.constant(void 0),this._nodes={},this._isCompound&&(this._parent={},this._children={},this._children[Qv]={}),this._in={},this._preds={},this._out={},this._sucs={},this._edgeObjs={},this._edgeLabels={}}cr.prototype._nodeCount=0;cr.prototype._edgeCount=0;cr.prototype.isDirected=function(){return this._isDirected};cr.prototype.isMultigraph=function(){return this._isMultigraph};cr.prototype.isCompound=function(){return this._isCompound};cr.prototype.setGraph=function(e){return this._label=e,this};cr.prototype.graph=function(){return this._label};cr.prototype.setDefaultNodeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultNodeLabelFn=e,this};cr.prototype.nodeCount=function(){return this._nodeCount};cr.prototype.nodes=function(){return je.keys(this._nodes)};cr.prototype.sources=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._in[t])})};cr.prototype.sinks=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._out[t])})};cr.prototype.setNodes=function(e,t){var r=arguments,n=this;return je.each(e,function(i){r.length>1?n.setNode(i,t):n.setNode(i)}),this};cr.prototype.setNode=function(e,t){return je.has(this._nodes,e)?(arguments.length>1&&(this._nodes[e]=t),this):(this._nodes[e]=arguments.length>1?t:this._defaultNodeLabelFn(e),this._isCompound&&(this._parent[e]=Qv,this._children[e]={},this._children[Qv][e]=!0),this._in[e]={},this._preds[e]={},this._out[e]={},this._sucs[e]={},++this._nodeCount,this)};cr.prototype.node=function(e){return this._nodes[e]};cr.prototype.hasNode=function(e){return je.has(this._nodes,e)};cr.prototype.removeNode=function(e){var t=this;if(je.has(this._nodes,e)){var r=function(n){t.removeEdge(t._edgeObjs[n])};delete this._nodes[e],this._isCompound&&(this._removeFromParentsChildList(e),delete this._parent[e],je.each(this.children(e),function(n){t.setParent(n)}),delete this._children[e]),je.each(je.keys(this._in[e]),r),delete this._in[e],delete this._preds[e],je.each(je.keys(this._out[e]),r),delete this._out[e],delete this._sucs[e],--this._nodeCount}return this};cr.prototype.setParent=function(e,t){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(je.isUndefined(t))t=Qv;else{t+="";for(var r=t;!je.isUndefined(r);r=this.parent(r))if(r===e)throw new Error("Setting "+t+" as parent of "+e+" would create a cycle");this.setNode(t)}return this.setNode(e),this._removeFromParentsChildList(e),this._parent[e]=t,this._children[t][e]=!0,this};cr.prototype._removeFromParentsChildList=function(e){delete this._children[this._parent[e]][e]};cr.prototype.parent=function(e){if(this._isCompound){var t=this._parent[e];if(t!==Qv)return t}};cr.prototype.children=function(e){if(je.isUndefined(e)&&(e=Qv),this._isCompound){var t=this._children[e];if(t)return je.keys(t)}else{if(e===Qv)return this.nodes();if(this.hasNode(e))return[]}};cr.prototype.predecessors=function(e){var t=this._preds[e];if(t)return je.keys(t)};cr.prototype.successors=function(e){var t=this._sucs[e];if(t)return je.keys(t)};cr.prototype.neighbors=function(e){var t=this.predecessors(e);if(t)return je.union(t,this.successors(e))};cr.prototype.isLeaf=function(e){var t;return this.isDirected()?t=this.successors(e):t=this.neighbors(e),t.length===0};cr.prototype.filterNodes=function(e){var t=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});t.setGraph(this.graph());var r=this;je.each(this._nodes,function(o,a){e(a)&&t.setNode(a,o)}),je.each(this._edgeObjs,function(o){t.hasNode(o.v)&&t.hasNode(o.w)&&t.setEdge(o,r.edge(o))});var n={};function i(o){var a=r.parent(o);return a===void 0||t.hasNode(a)?(n[o]=a,a):a in n?n[a]:i(a)}return this._isCompound&&je.each(t.nodes(),function(o){t.setParent(o,i(o))}),t};cr.prototype.setDefaultEdgeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultEdgeLabelFn=e,this};cr.prototype.edgeCount=function(){return this._edgeCount};cr.prototype.edges=function(){return je.values(this._edgeObjs)};cr.prototype.setPath=function(e,t){var r=this,n=arguments;return je.reduce(e,function(i,o){return n.length>1?r.setEdge(i,o,t):r.setEdge(i,o),o}),this};cr.prototype.setEdge=function(){var e,t,r,n,i=!1,o=arguments[0];typeof o=="object"&&o!==null&&"v"in o?(e=o.v,t=o.w,r=o.name,arguments.length===2&&(n=arguments[1],i=!0)):(e=o,t=arguments[1],r=arguments[3],arguments.length>2&&(n=arguments[2],i=!0)),e=""+e,t=""+t,je.isUndefined(r)||(r=""+r);var a=W4(this._isDirected,e,t,r);if(je.has(this._edgeLabels,a))return i&&(this._edgeLabels[a]=n),this;if(!je.isUndefined(r)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(e),this.setNode(t),this._edgeLabels[a]=i?n:this._defaultEdgeLabelFn(e,t,r);var s=Grr(this._isDirected,e,t,r);return e=s.v,t=s.w,Object.freeze(s),this._edgeObjs[a]=s,Dne(this._preds[t],e),Dne(this._sucs[e],t),this._in[t][a]=s,this._out[e][a]=s,this._edgeCount++,this};cr.prototype.edge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return this._edgeLabels[n]};cr.prototype.hasEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r);return je.has(this._edgeLabels,n)};cr.prototype.removeEdge=function(e,t,r){var n=arguments.length===1?ult(this._isDirected,arguments[0]):W4(this._isDirected,e,t,r),i=this._edgeObjs[n];return i&&(e=i.v,t=i.w,delete this._edgeLabels[n],delete this._edgeObjs[n],One(this._preds[t],e),One(this._sucs[e],t),delete this._in[t][n],delete this._out[e][n],this._edgeCount--),this};cr.prototype.inEdges=function(e,t){var r=this._in[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.v===t}):n}};cr.prototype.outEdges=function(e,t){var r=this._out[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.w===t}):n}};cr.prototype.nodeEdges=function(e,t){var r=this.inEdges(e,t);if(r)return r.concat(this.outEdges(e,t))};function Dne(e,t){e[t]?e[t]++:e[t]=1}function One(e,t){--e[t]||delete e[t]}function W4(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}return i+Nne+o+Nne+(je.isUndefined(n)?qrr:n)}function Grr(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}var s={v:i,w:o};return n&&(s.name=n),s}function ult(e,t){return W4(e,t.v,t.w,t.name)}});var Bne=H((BZn,Fne)=>{Fne.exports="2.1.8"});var Vne=H((HZn,Hne)=>{Hne.exports={Graph:rH(),version:Bne()}});var qne=H((VZn,Une)=>{var Uf=Tl(),Wrr=rH();Une.exports={write:Yrr,read:$rr};function Yrr(e){var t={options:{directed:e.isDirected(),multigraph:e.isMultigraph(),compound:e.isCompound()},nodes:jrr(e),edges:Xrr(e)};return Uf.isUndefined(e.graph())||(t.value=Uf.clone(e.graph())),t}function jrr(e){return Uf.map(e.nodes(),function(t){var r=e.node(t),n=e.parent(t),i={v:t};return Uf.isUndefined(r)||(i.value=r),Uf.isUndefined(n)||(i.parent=n),i})}function Xrr(e){return Uf.map(e.edges(),function(t){var r=e.edge(t),n={v:t.v,w:t.w};return Uf.isUndefined(t.name)||(n.name=t.name),Uf.isUndefined(r)||(n.value=r),n})}function $rr(e){var t=new Wrr(e.options).setGraph(e.value);return Uf.each(e.nodes,function(r){t.setNode(r.v,r.value),r.parent&&t.setParent(r.v,r.parent)}),Uf.each(e.edges,function(r){t.setEdge({v:r.v,w:r.w,name:r.name},r.value)}),t}});var Wne=H((UZn,Gne)=>{var nH=Tl();Gne.exports=Krr;function Krr(e){var t={},r=[],n;function i(o){nH.has(t,o)||(t[o]=!0,n.push(o),nH.each(e.successors(o),i),nH.each(e.predecessors(o),i))}return nH.each(e.nodes(),function(o){n=[],i(o),n.length&&r.push(n)}),r}});var hlt=H((qZn,jne)=>{var Yne=Tl();jne.exports=Vc;function Vc(){this._arr=[],this._keyIndices={}}Vc.prototype.size=function(){return this._arr.length};Vc.prototype.keys=function(){return this._arr.map(function(e){return e.key})};Vc.prototype.has=function(e){return Yne.has(this._keyIndices,e)};Vc.prototype.priority=function(e){var t=this._keyIndices[e];if(t!==void 0)return this._arr[t].priority};Vc.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};Vc.prototype.add=function(e,t){var r=this._keyIndices;if(e=String(e),!Yne.has(r,e)){var n=this._arr,i=n.length;return r[e]=i,n.push({key:e,priority:t}),this._decrease(i),!0}return!1};Vc.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var e=this._arr.pop();return delete this._keyIndices[e.key],this._heapify(0),e.key};Vc.prototype.decrease=function(e,t){var r=this._keyIndices[e];if(t>this._arr[r].priority)throw new Error("New priority is greater than current priority. Key: "+e+" Old: "+this._arr[r].priority+" New: "+t);this._arr[r].priority=t,this._decrease(r)};Vc.prototype._heapify=function(e){var t=this._arr,r=2*e,n=r+1,i=e;r<t.length&&(i=t[r].priority<t[i].priority?r:i,n<t.length&&(i=t[n].priority<t[i].priority?n:i),i!==e&&(this._swap(e,i),this._heapify(i)))};Vc.prototype._decrease=function(e){for(var t=this._arr,r=t[e].priority,n;e!==0&&(n=e>>1,!(t[n].priority<r));)this._swap(e,n),e=n};Vc.prototype._swap=function(e,t){var r=this._arr,n=this._keyIndices,i=r[e],o=r[t];r[e]=o,r[t]=i,n[o.key]=e,n[i.key]=t}});var flt=H((GZn,Xne)=>{var Zrr=Tl(),Jrr=hlt();Xne.exports=tnr;var Qrr=Zrr.constant(1);function tnr(e,t,r,n){return enr(e,String(t),r||Qrr,n||function(i){return e.outEdges(i)})}function enr(e,t,r,n){var i={},o=new Jrr,a,s,l=function(c){var u=c.v!==a?c.v:c.w,h=i[u],f=r(c),p=s.distance+f;if(f<0)throw new Error("dijkstra does not allow negative edge weights. Bad edge: "+c+" Weight: "+f);p<h.distance&&(h.distance=p,h.predecessor=a,o.decrease(u,p))};for(e.nodes().forEach(function(c){var u=c===t?0:Number.POSITIVE_INFINITY;i[c]={distance:u},o.add(c,u)});o.size()>0&&(a=o.removeMin(),s=i[a],s.distance!==Number.POSITIVE_INFINITY);)n(a).forEach(l);return i}});var Kne=H((WZn,$ne)=>{var rnr=flt(),nnr=Tl();$ne.exports=inr;function inr(e,t,r){return nnr.transform(e.nodes(),function(n,i){n[i]=rnr(e,i,t,r)},{})}});var plt=H((YZn,Jne)=>{var Zne=Tl();Jne.exports=onr;function onr(e){var t=0,r=[],n={},i=[];function o(a){var s=n[a]={onStack:!0,lowlink:t,index:t++};if(r.push(a),e.successors(a).forEach(function(u){Zne.has(n,u)?n[u].onStack&&(s.lowlink=Math.min(s.lowlink,n[u].index)):(o(u),s.lowlink=Math.min(s.lowlink,n[u].lowlink))}),s.lowlink===s.index){var l=[],c;do c=r.pop(),n[c].onStack=!1,l.push(c);while(a!==c);i.push(l)}}return e.nodes().forEach(function(a){Zne.has(n,a)||o(a)}),i}});var tie=H((jZn,Qne)=>{var anr=Tl(),snr=plt();Qne.exports=lnr;function lnr(e){return anr.filter(snr(e),function(t){return t.length>1||t.length===1&&e.hasEdge(t[0],t[0])})}});var rie=H((XZn,eie)=>{var cnr=Tl();eie.exports=hnr;var unr=cnr.constant(1);function hnr(e,t,r){return fnr(e,t||unr,r||function(n){return e.outEdges(n)})}function fnr(e,t,r){var n={},i=e.nodes();return i.forEach(function(o){n[o]={},n[o][o]={distance:0},i.forEach(function(a){o!==a&&(n[o][a]={distance:Number.POSITIVE_INFINITY})}),r(o).forEach(function(a){var s=a.v===o?a.w:a.v,l=t(a);n[o][s]={distance:l,predecessor:o}})}),i.forEach(function(o){var a=n[o];i.forEach(function(s){var l=n[s];i.forEach(function(c){var u=l[o],h=a[c],f=l[c],p=u.distance+h.distance;p<f.distance&&(f.distance=p,f.predecessor=h.predecessor)})})}),n}});var dlt=H(($Zn,iie)=>{var Y4=Tl();iie.exports=nie;nie.CycleException=iH;function nie(e){var t={},r={},n=[];function i(o){if(Y4.has(r,o))throw new iH;Y4.has(t,o)||(r[o]=!0,t[o]=!0,Y4.each(e.predecessors(o),i),delete r[o],n.push(o))}if(Y4.each(e.sinks(),i),Y4.size(t)!==e.nodeCount())throw new iH;return n}function iH(){}iH.prototype=new Error});var sie=H((KZn,aie)=>{var oie=dlt();aie.exports=pnr;function pnr(e){try{oie(e)}catch(t){if(t instanceof oie.CycleException)return!1;throw t}return!0}});var mlt=H((ZZn,cie)=>{var oH=Tl();cie.exports=dnr;function dnr(e,t,r){oH.isArray(t)||(t=[t]);var n=(e.isDirected()?e.successors:e.neighbors).bind(e),i=[],o={};return oH.each(t,function(a){if(!e.hasNode(a))throw new Error("Graph does not have node: "+a);lie(e,a,r==="post",o,n,i)}),i}function lie(e,t,r,n,i,o){oH.has(n,t)||(n[t]=!0,r||o.push(t),oH.each(i(t),function(a){lie(e,a,r,n,i,o)}),r&&o.push(t))}});var hie=H((JZn,uie)=>{var mnr=mlt();uie.exports=gnr;function gnr(e,t){return mnr(e,t,"post")}});var pie=H((QZn,fie)=>{var _nr=mlt();fie.exports=ynr;function ynr(e,t){return _nr(e,t,"pre")}});var gie=H((tJn,mie)=>{var die=Tl(),vnr=rH(),xnr=hlt();mie.exports=bnr;function bnr(e,t){var r=new vnr,n={},i=new xnr,o;function a(l){var c=l.v===o?l.w:l.v,u=i.priority(c);if(u!==void 0){var h=t(l);h<u&&(n[c]=o,i.decrease(c,h))}}if(e.nodeCount()===0)return r;die.each(e.nodes(),function(l){i.add(l,Number.POSITIVE_INFINITY),r.setNode(l)}),i.decrease(e.nodes()[0],0);for(var s=!1;i.size()>0;){if(o=i.removeMin(),die.has(n,o))r.setEdge(o,n[o]);else{if(s)throw new Error("Input graph is not connected: "+e);s=!0}e.nodeEdges(o).forEach(a)}return r}});var yie=H((eJn,_ie)=>{_ie.exports={components:Wne(),dijkstra:flt(),dijkstraAll:Kne(),findCycles:tie(),floydWarshall:rie(),isAcyclic:sie(),postorder:hie(),preorder:pie(),prim:gie(),tarjan:plt(),topsort:dlt()}});var bie=H((rJn,xie)=>{var vie=Vne();xie.exports={Graph:vie.Graph,json:qne(),alg:yie(),version:vie.version}});var Uc=H((nJn,wie)=>{var aH;if(typeof Ex=="function")try{aH=bie()}catch(e){}aH||(aH=window.graphlib);wie.exports=aH});var Mie=H((oJn,Sie)=>{var wnr=Rst(),Snr=1,Mnr=4;function Enr(e){return wnr(e,Snr|Mnr)}Sie.exports=Enr});var j4=H((aJn,Eie)=>{var Tnr=jv(),Cnr=Hf(),Anr=R4(),Pnr=El();function Inr(e,t,r){if(!Pnr(r))return!1;var n=typeof t;return(n=="number"?Cnr(r)&&Anr(t,r.length):n=="string"&&t in r)?Tnr(r[t],e):!1}Eie.exports=Inr});var Aie=H((sJn,Cie)=>{var Lnr=G4(),knr=jv(),Rnr=j4(),Nnr=u0(),Tie=Object.prototype,Dnr=Tie.hasOwnProperty,Onr=Lnr(function(e,t){e=Object(e);var r=-1,n=t.length,i=n>2?t[2]:void 0;for(i&&Rnr(t[0],t[1],i)&&(n=1);++r<n;)for(var o=t[r],a=Nnr(o),s=-1,l=a.length;++s<l;){var c=a[s],u=e[c];(u===void 0||knr(u,Tie[c])&&!Dnr.call(e,c))&&(e[c]=o[c])}return e});Cie.exports=Onr});var Iie=H((lJn,Pie)=>{var znr=Vf(),Fnr=Hf(),Bnr=Pd();function Hnr(e){return function(t,r,n){var i=Object(t);if(!Fnr(t)){var o=znr(r,3);t=Bnr(t),r=function(s){return o(i[s],s,i)}}var a=e(t,r,n);return a>-1?i[o?t[a]:a]:void 0}}Pie.exports=Hnr});var kie=H((cJn,Lie)=>{var Vnr=/\s/;function Unr(e){for(var t=e.length;t--&&Vnr.test(e.charAt(t)););return t}Lie.exports=Unr});var Nie=H((uJn,Rie)=>{var qnr=kie(),Gnr=/^\s+/;function Wnr(e){return e&&e.slice(0,qnr(e)+1).replace(Gnr,"")}Rie.exports=Wnr});var Fie=H((hJn,zie)=>{var Ynr=Nie(),Die=El(),jnr=Jv(),Oie=0/0,Xnr=/^[-+]0x[0-9a-f]+$/i,$nr=/^0b[01]+$/i,Knr=/^0o[0-7]+$/i,Znr=parseInt;function Jnr(e){if(typeof e=="number")return e;if(jnr(e))return Oie;if(Die(e)){var t=typeof e.valueOf=="function"?e.valueOf():e;e=Die(t)?t+"":t}if(typeof e!="string")return e===0?e:+e;e=Ynr(e);var r=$nr.test(e);return r||Knr.test(e)?Znr(e.slice(2),r?2:8):Xnr.test(e)?Oie:+e}zie.exports=Jnr});var glt=H((fJn,Hie)=>{var Qnr=Fie(),Bie=1/0,tir=17976931348623157e292;function eir(e){if(!e)return e===0?e:0;if(e=Qnr(e),e===Bie||e===-Bie){var t=e<0?-1:1;return t*tir}return e===e?e:0}Hie.exports=eir});var Uie=H((pJn,Vie)=>{var rir=glt();function nir(e){var t=rir(e),r=t%1;return t===t?r?t-r:t:0}Vie.exports=nir});var Gie=H((dJn,qie)=>{var iir=alt(),oir=Vf(),air=Uie(),sir=Math.max;function lir(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var i=r==null?0:air(r);return i<0&&(i=sir(n+i,0)),iir(e,oir(t,3),i)}qie.exports=lir});var Yie=H((mJn,Wie)=>{var cir=Iie(),uir=Gie(),hir=cir(uir);Wie.exports=hir});var _lt=H((gJn,jie)=>{var fir=tH();function pir(e){var t=e==null?0:e.length;return t?fir(e,1):[]}jie.exports=pir});var $ie=H((_Jn,Xie)=>{var dir=XB(),mir=Nst(),gir=u0();function _ir(e,t){return e==null?e:dir(e,mir(t),gir)}Xie.exports=_ir});var Zie=H((yJn,Kie)=>{function yir(e){var t=e==null?0:e.length;return t?e[t-1]:void 0}Kie.exports=yir});var Qie=H((vJn,Jie)=>{var vir=I4(),xir=$B(),bir=Vf();function wir(e,t){var r={};return t=bir(t,3),xir(e,function(n,i,o){vir(r,i,t(n,i,o))}),r}Jie.exports=wir});var sH=H((xJn,toe)=>{var Sir=Jv();function Mir(e,t,r){for(var n=-1,i=e.length;++n<i;){var o=e[n],a=t(o);if(a!=null&&(s===void 0?a===a&&!Sir(a):r(a,s)))var s=a,l=o}return l}toe.exports=Mir});var roe=H((bJn,eoe)=>{function Eir(e,t){return e>t}eoe.exports=Eir});var ioe=H((wJn,noe)=>{var Tir=sH(),Cir=roe(),Air=h0();function Pir(e){return e&&e.length?Tir(e,Air,Cir):void 0}noe.exports=Pir});var ylt=H((SJn,ooe)=>{var Iir=I4(),Lir=jv();function kir(e,t,r){(r!==void 0&&!Lir(e[t],r)||r===void 0&&!(t in e))&&Iir(e,t,r)}ooe.exports=kir});var loe=H((MJn,soe)=>{var Rir=l0(),Nir=B4(),Dir=Yu(),Oir="[object Object]",zir=Function.prototype,Fir=Object.prototype,aoe=zir.toString,Bir=Fir.hasOwnProperty,Hir=aoe.call(Object);function Vir(e){if(!Dir(e)||Rir(e)!=Oir)return!1;var t=Nir(e);if(t===null)return!0;var r=Bir.call(t,"constructor")&&t.constructor;return typeof r=="function"&&r instanceof r&&aoe.call(r)==Hir}soe.exports=Vir});var vlt=H((EJn,coe)=>{function Uir(e,t){if(!(t==="constructor"&&typeof e[t]=="function")&&t!="__proto__")return e[t]}coe.exports=Uir});var hoe=H((TJn,uoe)=>{var qir=US(),Gir=u0();function Wir(e){return qir(e,Gir(e))}uoe.exports=Wir});var _oe=H((CJn,goe)=>{var foe=ylt(),Yir=gst(),jir=Ist(),Xir=_st(),$ir=kst(),poe=qS(),doe=Ti(),Kir=llt(),Zir=$v(),Jir=FS(),Qir=El(),tor=loe(),eor=YS(),moe=vlt(),ror=hoe();function nor(e,t,r,n,i,o,a){var s=moe(e,r),l=moe(t,r),c=a.get(l);if(c){foe(e,r,c);return}var u=o?o(s,l,r+"",e,t,a):void 0,h=u===void 0;if(h){var f=doe(l),p=!f&&Zir(l),d=!f&&!p&&eor(l);u=l,f||p||d?doe(s)?u=s:Kir(s)?u=Xir(s):p?(h=!1,u=Yir(l,!0)):d?(h=!1,u=jir(l,!0)):u=[]:tor(l)||poe(l)?(u=s,poe(s)?u=ror(s):(!Qir(s)||Jir(s))&&(u=$ir(l))):h=!1}h&&(a.set(l,u),i(u,l,n,o,a),a.delete(l)),foe(e,r,u)}goe.exports=nor});var xoe=H((AJn,voe)=>{var ior=P4(),oor=ylt(),aor=XB(),sor=_oe(),lor=El(),cor=u0(),uor=vlt();function yoe(e,t,r,n,i){e!==t&&aor(t,function(o,a){if(i||(i=new ior),lor(o))sor(e,t,a,r,yoe,n,i);else{var s=n?n(uor(e,a),o,a+"",e,t,i):void 0;s===void 0&&(s=o),oor(e,a,s)}},cor)}voe.exports=yoe});var woe=H((PJn,boe)=>{var hor=G4(),por=j4();function dor(e){return hor(function(t,r){var n=-1,i=r.length,o=i>1?r[i-1]:void 0,a=i>2?r[2]:void 0;for(o=e.length>3&&typeof o=="function"?(i--,o):void 0,a&&por(r[0],r[1],a)&&(o=i<3?void 0:o,i=1),t=Object(t);++n<i;){var s=r[n];s&&e(t,s,n,o)}return t})}boe.exports=dor});var Moe=H((IJn,Soe)=>{var mor=xoe(),gor=woe(),_or=gor(function(e,t,r){mor(e,t,r)});Soe.exports=_or});var xlt=H((LJn,Eoe)=>{function yor(e,t){return e<t}Eoe.exports=yor});var Coe=H((kJn,Toe)=>{var vor=sH(),xor=xlt(),bor=h0();function wor(e){return e&&e.length?vor(e,bor,xor):void 0}Toe.exports=wor});var Poe=H((RJn,Aoe)=>{var Sor=sH(),Mor=Vf(),Eor=xlt();function Tor(e,t){return e&&e.length?Sor(e,Mor(t,2),Eor):void 0}Aoe.exports=Tor});var Loe=H((NJn,Ioe)=>{var Cor=Hc(),Aor=function(){return Cor.Date.now()};Ioe.exports=Aor});var Noe=H((DJn,Roe)=>{var Por=L4(),Ior=U4(),Lor=R4(),koe=El(),kor=$S();function Ror(e,t,r,n){if(!koe(e))return e;t=Ior(t,e);for(var i=-1,o=t.length,a=o-1,s=e;s!=null&&++i<o;){var l=kor(t[i]),c=r;if(l==="__proto__"||l==="constructor"||l==="prototype")return e;if(i!=a){var u=s[l];c=n?n(u,l,s):void 0,c===void 0&&(c=koe(u)?u:Lor(t[i+1])?[]:{})}Por(s,l,c),s=s[l]}return e}Roe.exports=Ror});var Ooe=H((OJn,Doe)=>{var Nor=q4(),Dor=Noe(),Oor=U4();function zor(e,t,r){for(var n=-1,i=t.length,o={};++n<i;){var a=t[n],s=Nor(e,a);r(s,a)&&Dor(o,Oor(a,e),s)}return o}Doe.exports=zor});var Foe=H((zJn,zoe)=>{var For=Ooe(),Bor=Xst();function Hor(e,t){return For(e,t,function(r,n){return Bor(e,n)})}zoe.exports=Hor});var Hoe=H((FJn,Boe)=>{var Vor=_lt(),Uor=ilt(),qor=olt();function Gor(e){return qor(Uor(e,void 0,Vor),e+"")}Boe.exports=Gor});var Uoe=H((BJn,Voe)=>{var Wor=Foe(),Yor=Hoe(),jor=Yor(function(e,t){return e==null?{}:Wor(e,t)});Voe.exports=jor});var Goe=H((HJn,qoe)=>{var Xor=Math.ceil,$or=Math.max;function Kor(e,t,r,n){for(var i=-1,o=$or(Xor((t-e)/(r||1)),0),a=Array(o);o--;)a[n?o:++i]=e,e+=r;return a}qoe.exports=Kor});var Yoe=H((VJn,Woe)=>{var Zor=Goe(),Jor=j4(),blt=glt();function Qor(e){return function(t,r,n){return n&&typeof n!="number"&&Jor(t,r,n)&&(r=n=void 0),t=blt(t),r===void 0?(r=t,t=0):r=blt(r),n=n===void 0?t<r?1:-1:blt(n),Zor(t,r,n,e)}}Woe.exports=Qor});var Xoe=H((UJn,joe)=>{var tar=Yoe(),ear=tar();joe.exports=ear});var Koe=H((qJn,$oe)=>{function rar(e,t){var r=e.length;for(e.sort(t);r--;)e[r]=e[r].value;return e}$oe.exports=rar});var Qoe=H((GJn,Joe)=>{var Zoe=Jv();function nar(e,t){if(e!==t){var r=e!==void 0,n=e===null,i=e===e,o=Zoe(e),a=t!==void 0,s=t===null,l=t===t,c=Zoe(t);if(!s&&!c&&!o&&e>t||o&&a&&l&&!s&&!c||n&&a&&l||!r&&l||!i)return 1;if(!n&&!o&&!c&&e<t||c&&r&&i&&!n&&!o||s&&r&&i||!a&&i||!l)return-1}return 0}Joe.exports=nar});var eae=H((WJn,tae)=>{var iar=Qoe();function oar(e,t,r){for(var n=-1,i=e.criteria,o=t.criteria,a=i.length,s=r.length;++n<a;){var l=iar(i[n],o[n]);if(l){if(n>=s)return l;var c=r[n];return l*(c=="desc"?-1:1)}}return e.index-t.index}tae.exports=oar});var nae=H((YJn,rae)=>{var wlt=V4(),aar=q4(),sar=Vf(),lar=Qst(),car=Koe(),uar=N4(),har=eae(),far=h0(),par=Ti();function dar(e,t,r){t.length?t=wlt(t,function(o){return par(o)?function(a){return aar(a,o.length===1?o[0]:o)}:o}):t=[far];var n=-1;t=wlt(t,uar(sar));var i=lar(e,function(o,a,s){var l=wlt(t,function(c){return c(o)});return{criteria:l,index:++n,value:o}});return car(i,function(o,a){return har(o,a,r)})}rae.exports=dar});var aae=H((jJn,oae)=>{var mar=tH(),gar=nae(),_ar=G4(),iae=j4(),yar=_ar(function(e,t){if(e==null)return[];var r=t.length;return r>1&&iae(e,t[0],t[1])?t=[]:r>2&&iae(t[0],t[1],t[2])&&(t=[t[0]]),gar(e,mar(t,1),[])});oae.exports=yar});var lae=H((XJn,sae)=>{var xar=Yst(),bar=0;function war(e){var t=++bar;return xar(e)+t}sae.exports=war});var uae=H(($Jn,cae)=>{function Sar(e,t,r){for(var n=-1,i=e.length,o=t.length,a={};++n<i;){var s=n<o?t[n]:void 0;r(a,e[n],s)}return a}cae.exports=Sar});var fae=H((KJn,hae)=>{var Mar=L4(),Ear=uae();function Tar(e,t){return Ear(e||[],t||[],Mar)}hae.exports=Tar});var qn=H((ZJn,pae)=>{var lH;if(typeof Ex=="function")try{lH={cloneDeep:Mie(),constant:jB(),defaults:Aie(),each:Ost(),filter:Kst(),find:Yie(),flatten:_lt(),forEach:Dst(),forIn:$ie(),has:Zst(),isUndefined:Jst(),last:Zie(),map:tlt(),mapValues:Qie(),max:ioe(),merge:Moe(),min:Coe(),minBy:Poe(),now:Loe(),pick:Uoe(),range:Xoe(),reduce:elt(),sortBy:aae(),uniqueId:lae(),values:clt(),zipObject:fae()}}catch(e){}lH||(lH=window._);pae.exports=lH});var gae=H((QJn,mae)=>{mae.exports=cH;function cH(){var e={};e._next=e._prev=e,this._sentinel=e}cH.prototype.dequeue=function(){var e=this._sentinel,t=e._prev;if(t!==e)return dae(t),t};cH.prototype.enqueue=function(e){var t=this._sentinel;e._prev&&e._next&&dae(e),e._next=t._next,t._next._prev=e,t._next=e,e._prev=t};cH.prototype.toString=function(){for(var e=[],t=this._sentinel,r=t._prev;r!==t;)e.push(JSON.stringify(r,Car)),r=r._prev;return"["+e.join(", ")+"]"};function dae(e){e._prev._next=e._next,e._next._prev=e._prev,delete e._next,delete e._prev}function Car(e,t){if(e!=="_next"&&e!=="_prev")return t}});var yae=H((tQn,_ae)=>{var Id=qn(),Aar=Uc().Graph,Par=gae();_ae.exports=Lar;var Iar=Id.constant(1);function Lar(e,t){if(e.nodeCount()<=1)return[];var r=Rar(e,t||Iar),n=kar(r.graph,r.buckets,r.zeroIdx);return Id.flatten(Id.map(n,function(i){return e.outEdges(i.v,i.w)}),!0)}function kar(e,t,r){for(var n=[],i=t[t.length-1],o=t[0],a;e.nodeCount();){for(;a=o.dequeue();)Slt(e,t,r,a);for(;a=i.dequeue();)Slt(e,t,r,a);if(e.nodeCount()){for(var s=t.length-2;s>0;--s)if(a=t[s].dequeue(),a){n=n.concat(Slt(e,t,r,a,!0));break}}}return n}function Slt(e,t,r,n,i){var o=i?[]:void 0;return Id.forEach(e.inEdges(n.v),function(a){var s=e.edge(a),l=e.node(a.v);i&&o.push({v:a.v,w:a.w}),l.out-=s,Mlt(t,r,l)}),Id.forEach(e.outEdges(n.v),function(a){var s=e.edge(a),l=a.w,c=e.node(l);c.in-=s,Mlt(t,r,c)}),e.removeNode(n.v),o}function Rar(e,t){var r=new Aar,n=0,i=0;Id.forEach(e.nodes(),function(s){r.setNode(s,{v:s,in:0,out:0})}),Id.forEach(e.edges(),function(s){var l=r.edge(s.v,s.w)||0,c=t(s),u=l+c;r.setEdge(s.v,s.w,u),i=Math.max(i,r.node(s.v).out+=c),n=Math.max(n,r.node(s.w).in+=c)});var o=Id.range(i+n+3).map(function(){return new Par}),a=n+1;return Id.forEach(r.nodes(),function(s){Mlt(o,a,r.node(s))}),{graph:r,buckets:o,zeroIdx:a}}function Mlt(e,t,r){r.out?r.in?e[r.out-r.in+t].enqueue(r):e[e.length-1].enqueue(r):e[0].enqueue(r)}});var xae=H((eQn,vae)=>{"use strict";var t1=qn(),Nar=yae();vae.exports={run:Dar,undo:zar};function Dar(e){var t=e.graph().acyclicer==="greedy"?Nar(e,r(e)):Oar(e);t1.forEach(t,function(n){var i=e.edge(n);e.removeEdge(n),i.forwardName=n.name,i.reversed=!0,e.setEdge(n.w,n.v,i,t1.uniqueId("rev"))});function r(n){return function(i){return n.edge(i).weight}}}function Oar(e){var t=[],r={},n={};function i(o){t1.has(n,o)||(n[o]=!0,r[o]=!0,t1.forEach(e.outEdges(o),function(a){t1.has(r,a.w)?t.push(a):i(a.w)}),delete r[o])}return t1.forEach(e.nodes(),i),t}function zar(e){t1.forEach(e.edges(),function(t){var r=e.edge(t);if(r.reversed){e.removeEdge(t);var n=r.forwardName;delete r.reversed,delete r.forwardName,e.setEdge(t.w,t.v,r,n)}})}});var is=H((rQn,Mae)=>{"use strict";var Qr=qn(),bae=Uc().Graph;Mae.exports={addDummyNode:wae,simplify:Far,asNonCompoundGraph:Bar,successorWeights:Har,predecessorWeights:Var,intersectRect:Uar,buildLayerMatrix:qar,normalizeRanks:Gar,removeEmptyRanks:War,addBorderNode:Yar,maxRank:Sae,partition:jar,time:Xar,notime:$ar};function wae(e,t,r,n){var i;do i=Qr.uniqueId(n);while(e.hasNode(i));return r.dummy=t,e.setNode(i,r),i}function Far(e){var t=new bae().setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){var n=t.edge(r.v,r.w)||{weight:0,minlen:1},i=e.edge(r);t.setEdge(r.v,r.w,{weight:n.weight+i.weight,minlen:Math.max(n.minlen,i.minlen)})}),t}function Bar(e){var t=new bae({multigraph:e.isMultigraph()}).setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){e.children(r).length||t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){t.setEdge(r,e.edge(r))}),t}function Har(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.outEdges(r),function(i){n[i.w]=(n[i.w]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Var(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.inEdges(r),function(i){n[i.v]=(n[i.v]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Uar(e,t){var r=e.x,n=e.y,i=t.x-r,o=t.y-n,a=e.width/2,s=e.height/2;if(!i&&!o)throw new Error("Not possible to find intersection inside of the rectangle");var l,c;return Math.abs(o)*a>Math.abs(i)*s?(o<0&&(s=-s),l=s*i/o,c=s):(i<0&&(a=-a),l=a,c=a*o/i),{x:r+l,y:n+c}}function qar(e){var t=Qr.map(Qr.range(Sae(e)+1),function(){return[]});return Qr.forEach(e.nodes(),function(r){var n=e.node(r),i=n.rank;Qr.isUndefined(i)||(t[i][n.order]=r)}),t}function Gar(e){var t=Qr.min(Qr.map(e.nodes(),function(r){return e.node(r).rank}));Qr.forEach(e.nodes(),function(r){var n=e.node(r);Qr.has(n,"rank")&&(n.rank-=t)})}function War(e){var t=Qr.min(Qr.map(e.nodes(),function(o){return e.node(o).rank})),r=[];Qr.forEach(e.nodes(),function(o){var a=e.node(o).rank-t;r[a]||(r[a]=[]),r[a].push(o)});var n=0,i=e.graph().nodeRankFactor;Qr.forEach(r,function(o,a){Qr.isUndefined(o)&&a%i!==0?--n:n&&Qr.forEach(o,function(s){e.node(s).rank+=n})})}function Yar(e,t,r,n){var i={width:0,height:0};return arguments.length>=4&&(i.rank=r,i.order=n),wae(e,"border",i,t)}function Sae(e){return Qr.max(Qr.map(e.nodes(),function(t){var r=e.node(t).rank;if(!Qr.isUndefined(r))return r}))}function jar(e,t){var r={lhs:[],rhs:[]};return Qr.forEach(e,function(n){t(n)?r.lhs.push(n):r.rhs.push(n)}),r}function Xar(e,t){var r=Qr.now();try{return t()}finally{console.log(e+" time: "+(Qr.now()-r)+"ms")}}function $ar(e,t){return t()}});var Cae=H((nQn,Tae)=>{"use strict";var Eae=qn(),Kar=is();Tae.exports={run:Zar,undo:Qar};function Zar(e){e.graph().dummyChains=[],Eae.forEach(e.edges(),function(t){Jar(e,t)})}function Jar(e,t){var r=t.v,n=e.node(r).rank,i=t.w,o=e.node(i).rank,a=t.name,s=e.edge(t),l=s.labelRank;if(o!==n+1){e.removeEdge(t);var c,u,h;for(h=0,++n;n<o;++h,++n)s.points=[],u={width:0,height:0,edgeLabel:s,edgeObj:t,rank:n},c=Kar.addDummyNode(e,"edge",u,"_d"),n===l&&(u.width=s.width,u.height=s.height,u.dummy="edge-label",u.labelpos=s.labelpos),e.setEdge(r,c,{weight:s.weight},a),h===0&&e.graph().dummyChains.push(c),r=c;e.setEdge(r,i,{weight:s.weight},a)}}function Qar(e){Eae.forEach(e.graph().dummyChains,function(t){var r=e.node(t),n=r.edgeLabel,i;for(e.setEdge(r.edgeObj,n);r.dummy;)i=e.successors(t)[0],e.removeNode(t),n.points.push({x:r.x,y:r.y}),r.dummy==="edge-label"&&(n.x=r.x,n.y=r.y,n.width=r.width,n.height=r.height),t=i,r=e.node(t)})}});var X4=H((iQn,Aae)=>{"use strict";var uH=qn();Aae.exports={longestPath:tsr,slack:esr};function tsr(e){var t={};function r(n){var i=e.node(n);if(uH.has(t,n))return i.rank;t[n]=!0;var o=uH.min(uH.map(e.outEdges(n),function(a){return r(a.w)-e.edge(a).minlen}));return(o===Number.POSITIVE_INFINITY||o===void 0||o===null)&&(o=0),i.rank=o}uH.forEach(e.sources(),r)}function esr(e,t){return e.node(t.w).rank-e.node(t.v).rank-e.edge(t).minlen}});var Elt=H((oQn,Pae)=>{"use strict";var hH=qn(),rsr=Uc().Graph,fH=X4().slack;Pae.exports=nsr;function nsr(e){var t=new rsr({directed:!1}),r=e.nodes()[0],n=e.nodeCount();t.setNode(r,{});for(var i,o;isr(t,e)<n;)i=osr(t,e),o=t.hasNode(i.v)?fH(e,i):-fH(e,i),asr(t,e,o);return t}function isr(e,t){function r(n){hH.forEach(t.nodeEdges(n),function(i){var o=i.v,a=n===o?i.w:o;!e.hasNode(a)&&!fH(t,i)&&(e.setNode(a,{}),e.setEdge(n,a,{}),r(a))})}return hH.forEach(e.nodes(),r),e.nodeCount()}function osr(e,t){return hH.minBy(t.edges(),function(r){if(e.hasNode(r.v)!==e.hasNode(r.w))return fH(t,r)})}function asr(e,t,r){hH.forEach(e.nodes(),function(n){t.node(n).rank+=r})}});var zae=H((aQn,Oae)=>{"use strict";var Ld=qn(),ssr=Elt(),lsr=X4().slack,csr=X4().longestPath,usr=Uc().alg.preorder,hsr=Uc().alg.postorder,fsr=is().simplify;Oae.exports=e1;e1.initLowLimValues=Clt;e1.initCutValues=Tlt;e1.calcCutValue=Lae;e1.leaveEdge=Rae;e1.enterEdge=Nae;e1.exchangeEdges=Dae;function e1(e){e=fsr(e),csr(e);var t=ssr(e);Clt(t),Tlt(t,e);for(var r,n;r=Rae(t);)n=Nae(t,e,r),Dae(t,e,r,n)}function Tlt(e,t){var r=hsr(e,e.nodes());r=r.slice(0,r.length-1),Ld.forEach(r,function(n){psr(e,t,n)})}function psr(e,t,r){var n=e.node(r),i=n.parent;e.edge(r,i).cutvalue=Lae(e,t,r)}function Lae(e,t,r){var n=e.node(r),i=n.parent,o=!0,a=t.edge(r,i),s=0;return a||(o=!1,a=t.edge(i,r)),s=a.weight,Ld.forEach(t.nodeEdges(r),function(l){var c=l.v===r,u=c?l.w:l.v;if(u!==i){var h=c===o,f=t.edge(l).weight;if(s+=h?f:-f,msr(e,r,u)){var p=e.edge(r,u).cutvalue;s+=h?-p:p}}}),s}function Clt(e,t){arguments.length<2&&(t=e.nodes()[0]),kae(e,{},1,t)}function kae(e,t,r,n,i){var o=r,a=e.node(n);return t[n]=!0,Ld.forEach(e.neighbors(n),function(s){Ld.has(t,s)||(r=kae(e,t,r,s,n))}),a.low=o,a.lim=r++,i?a.parent=i:delete a.parent,r}function Rae(e){return Ld.find(e.edges(),function(t){return e.edge(t).cutvalue<0})}function Nae(e,t,r){var n=r.v,i=r.w;t.hasEdge(n,i)||(n=r.w,i=r.v);var o=e.node(n),a=e.node(i),s=o,l=!1;o.lim>a.lim&&(s=a,l=!0);var c=Ld.filter(t.edges(),function(u){return l===Iae(e,e.node(u.v),s)&&l!==Iae(e,e.node(u.w),s)});return Ld.minBy(c,function(u){return lsr(t,u)})}function Dae(e,t,r,n){var i=r.v,o=r.w;e.removeEdge(i,o),e.setEdge(n.v,n.w,{}),Clt(e),Tlt(e,t),dsr(e,t)}function dsr(e,t){var r=Ld.find(e.nodes(),function(i){return!t.node(i).parent}),n=usr(e,r);n=n.slice(1),Ld.forEach(n,function(i){var o=e.node(i).parent,a=t.edge(i,o),s=!1;a||(a=t.edge(o,i),s=!0),t.node(i).rank=t.node(o).rank+(s?a.minlen:-a.minlen)})}function msr(e,t,r){return e.hasEdge(t,r)}function Iae(e,t,r){return r.low<=t.lim&&t.lim<=r.lim}});var Vae=H((sQn,Hae)=>{"use strict";var gsr=X4(),Bae=gsr.longestPath,_sr=Elt(),ysr=zae();Hae.exports=vsr;function vsr(e){switch(e.graph().ranker){case"network-simplex":Fae(e);break;case"tight-tree":bsr(e);break;case"longest-path":xsr(e);break;default:Fae(e)}}var xsr=Bae;function bsr(e){Bae(e),_sr(e)}function Fae(e){ysr(e)}});var qae=H((lQn,Uae)=>{var Alt=qn();Uae.exports=wsr;function wsr(e){var t=Msr(e);Alt.forEach(e.graph().dummyChains,function(r){for(var n=e.node(r),i=n.edgeObj,o=Ssr(e,t,i.v,i.w),a=o.path,s=o.lca,l=0,c=a[l],u=!0;r!==i.w;){if(n=e.node(r),u){for(;(c=a[l])!==s&&e.node(c).maxRank<n.rank;)l++;c===s&&(u=!1)}if(!u){for(;l<a.length-1&&e.node(c=a[l+1]).minRank<=n.rank;)l++;c=a[l]}e.setParent(r,c),r=e.successors(r)[0]}})}function Ssr(e,t,r,n){var i=[],o=[],a=Math.min(t[r].low,t[n].low),s=Math.max(t[r].lim,t[n].lim),l,c;l=r;do l=e.parent(l),i.push(l);while(l&&(t[l].low>a||s>t[l].lim));for(c=l,l=n;(l=e.parent(l))!==c;)o.push(l);return{path:i.concat(o.reverse()),lca:c}}function Msr(e){var t={},r=0;function n(i){var o=r;Alt.forEach(e.children(i),n),t[i]={low:o,lim:r++}}return Alt.forEach(e.children(),n),t}});var Yae=H((cQn,Wae)=>{var kd=qn(),Plt=is();Wae.exports={run:Esr,cleanup:Asr};function Esr(e){var t=Plt.addDummyNode(e,"root",{},"_root"),r=Tsr(e),n=kd.max(kd.values(r))-1,i=2*n+1;e.graph().nestingRoot=t,kd.forEach(e.edges(),function(a){e.edge(a).minlen*=i});var o=Csr(e)+1;kd.forEach(e.children(),function(a){Gae(e,t,i,o,n,r,a)}),e.graph().nodeRankFactor=i}function Gae(e,t,r,n,i,o,a){var s=e.children(a);if(!s.length){a!==t&&e.setEdge(t,a,{weight:0,minlen:r});return}var l=Plt.addBorderNode(e,"_bt"),c=Plt.addBorderNode(e,"_bb"),u=e.node(a);e.setParent(l,a),u.borderTop=l,e.setParent(c,a),u.borderBottom=c,kd.forEach(s,function(h){Gae(e,t,r,n,i,o,h);var f=e.node(h),p=f.borderTop?f.borderTop:h,d=f.borderBottom?f.borderBottom:h,g=f.borderTop?n:2*n,_=p!==d?1:i-o[a]+1;e.setEdge(l,p,{weight:g,minlen:_,nestingEdge:!0}),e.setEdge(d,c,{weight:g,minlen:_,nestingEdge:!0})}),e.parent(a)||e.setEdge(t,l,{weight:0,minlen:i+o[a]})}function Tsr(e){var t={};function r(n,i){var o=e.children(n);o&&o.length&&kd.forEach(o,function(a){r(a,i+1)}),t[n]=i}return kd.forEach(e.children(),function(n){r(n,1)}),t}function Csr(e){return kd.reduce(e.edges(),function(t,r){return t+e.edge(r).weight},0)}function Asr(e){var t=e.graph();e.removeNode(t.nestingRoot),delete t.nestingRoot,kd.forEach(e.edges(),function(r){var n=e.edge(r);n.nestingEdge&&e.removeEdge(r)})}});var $ae=H((uQn,Xae)=>{var Ilt=qn(),Psr=is();Xae.exports=Isr;function Isr(e){function t(r){var n=e.children(r),i=e.node(r);if(n.length&&Ilt.forEach(n,t),Ilt.has(i,"minRank")){i.borderLeft=[],i.borderRight=[];for(var o=i.minRank,a=i.maxRank+1;o<a;++o)jae(e,"borderLeft","_bl",r,i,o),jae(e,"borderRight","_br",r,i,o)}}Ilt.forEach(e.children(),t)}function jae(e,t,r,n,i,o){var a={width:0,height:0,rank:o,borderType:t},s=i[t][o-1],l=Psr.addDummyNode(e,"border",a,r);i[t][o]=l,e.setParent(l,n),s&&e.setEdge(s,l,{weight:1})}});var Qae=H((hQn,Jae)=>{"use strict";var qf=qn();Jae.exports={adjust:Lsr,undo:ksr};function Lsr(e){var t=e.graph().rankdir.toLowerCase();(t==="lr"||t==="rl")&&Zae(e)}function ksr(e){var t=e.graph().rankdir.toLowerCase();(t==="bt"||t==="rl")&&Rsr(e),(t==="lr"||t==="rl")&&(Nsr(e),Zae(e))}function Zae(e){qf.forEach(e.nodes(),function(t){Kae(e.node(t))}),qf.forEach(e.edges(),function(t){Kae(e.edge(t))})}function Kae(e){var t=e.width;e.width=e.height,e.height=t}function Rsr(e){qf.forEach(e.nodes(),function(t){Llt(e.node(t))}),qf.forEach(e.edges(),function(t){var r=e.edge(t);qf.forEach(r.points,Llt),qf.has(r,"y")&&Llt(r)})}function Llt(e){e.y=-e.y}function Nsr(e){qf.forEach(e.nodes(),function(t){klt(e.node(t))}),qf.forEach(e.edges(),function(t){var r=e.edge(t);qf.forEach(r.points,klt),qf.has(r,"x")&&klt(r)})}function klt(e){var t=e.x;e.x=e.y,e.y=t}});var ese=H((fQn,tse)=>{"use strict";var Rd=qn();tse.exports=Dsr;function Dsr(e){var t={},r=Rd.filter(e.nodes(),function(s){return!e.children(s).length}),n=Rd.max(Rd.map(r,function(s){return e.node(s).rank})),i=Rd.map(Rd.range(n+1),function(){return[]});function o(s){if(!Rd.has(t,s)){t[s]=!0;var l=e.node(s);i[l.rank].push(s),Rd.forEach(e.successors(s),o)}}var a=Rd.sortBy(r,function(s){return e.node(s).rank});return Rd.forEach(a,o),i}});var nse=H((pQn,rse)=>{"use strict";var f0=qn();rse.exports=Osr;function Osr(e,t){for(var r=0,n=1;n<t.length;++n)r+=zsr(e,t[n-1],t[n]);return r}function zsr(e,t,r){for(var n=f0.zipObject(r,f0.map(r,function(c,u){return u})),i=f0.flatten(f0.map(t,function(c){return f0.sortBy(f0.map(e.outEdges(c),function(u){return{pos:n[u.w],weight:e.edge(u).weight}}),"pos")}),!0),o=1;o<r.length;)o<<=1;var a=2*o-1;o-=1;var s=f0.map(new Array(a),function(){return 0}),l=0;return f0.forEach(i.forEach(function(c){var u=c.pos+o;s[u]+=c.weight;for(var h=0;u>0;)u%2&&(h+=s[u+1]),u=u-1>>1,s[u]+=c.weight;l+=c.weight*h})),l}});var ase=H((dQn,ose)=>{var ise=qn();ose.exports=Fsr;function Fsr(e,t){return ise.map(t,function(r){var n=e.inEdges(r);if(n.length){var i=ise.reduce(n,function(o,a){var s=e.edge(a),l=e.node(a.v);return{sum:o.sum+s.weight*l.order,weight:o.weight+s.weight}},{sum:0,weight:0});return{v:r,barycenter:i.sum/i.weight,weight:i.weight}}else return{v:r}})}});var lse=H((mQn,sse)=>{"use strict";var Cl=qn();sse.exports=Bsr;function Bsr(e,t){var r={};Cl.forEach(e,function(i,o){var a=r[i.v]={indegree:0,in:[],out:[],vs:[i.v],i:o};Cl.isUndefined(i.barycenter)||(a.barycenter=i.barycenter,a.weight=i.weight)}),Cl.forEach(t.edges(),function(i){var o=r[i.v],a=r[i.w];!Cl.isUndefined(o)&&!Cl.isUndefined(a)&&(a.indegree++,o.out.push(r[i.w]))});var n=Cl.filter(r,function(i){return!i.indegree});return Hsr(n)}function Hsr(e){var t=[];function r(o){return function(a){a.merged||(Cl.isUndefined(a.barycenter)||Cl.isUndefined(o.barycenter)||a.barycenter>=o.barycenter)&&Vsr(o,a)}}function n(o){return function(a){a.in.push(o),--a.indegree===0&&e.push(a)}}for(;e.length;){var i=e.pop();t.push(i),Cl.forEach(i.in.reverse(),r(i)),Cl.forEach(i.out,n(i))}return Cl.map(Cl.filter(t,function(o){return!o.merged}),function(o){return Cl.pick(o,["vs","i","barycenter","weight"])})}function Vsr(e,t){var r=0,n=0;e.weight&&(r+=e.barycenter*e.weight,n+=e.weight),t.weight&&(r+=t.barycenter*t.weight,n+=t.weight),e.vs=t.vs.concat(e.vs),e.barycenter=r/n,e.weight=n,e.i=Math.min(t.i,e.i),t.merged=!0}});var hse=H((gQn,use)=>{var $4=qn(),Usr=is();use.exports=qsr;function qsr(e,t){var r=Usr.partition(e,function(u){return $4.has(u,"barycenter")}),n=r.lhs,i=$4.sortBy(r.rhs,function(u){return-u.i}),o=[],a=0,s=0,l=0;n.sort(Gsr(!!t)),l=cse(o,i,l),$4.forEach(n,function(u){l+=u.vs.length,o.push(u.vs),a+=u.barycenter*u.weight,s+=u.weight,l=cse(o,i,l)});var c={vs:$4.flatten(o,!0)};return s&&(c.barycenter=a/s,c.weight=s),c}function cse(e,t,r){for(var n;t.length&&(n=$4.last(t)).i<=r;)t.pop(),e.push(n.vs),r++;return r}function Gsr(e){return function(t,r){return t.barycenter<r.barycenter?-1:t.barycenter>r.barycenter?1:e?r.i-t.i:t.i-r.i}}});var dse=H((_Qn,pse)=>{var p0=qn(),Wsr=ase(),Ysr=lse(),jsr=hse();pse.exports=fse;function fse(e,t,r,n){var i=e.children(t),o=e.node(t),a=o?o.borderLeft:void 0,s=o?o.borderRight:void 0,l={};a&&(i=p0.filter(i,function(d){return d!==a&&d!==s}));var c=Wsr(e,i);p0.forEach(c,function(d){if(e.children(d.v).length){var g=fse(e,d.v,r,n);l[d.v]=g,p0.has(g,"barycenter")&&$sr(d,g)}});var u=Ysr(c,r);Xsr(u,l);var h=jsr(u,n);if(a&&(h.vs=p0.flatten([a,h.vs,s],!0),e.predecessors(a).length)){var f=e.node(e.predecessors(a)[0]),p=e.node(e.predecessors(s)[0]);p0.has(h,"barycenter")||(h.barycenter=0,h.weight=0),h.barycenter=(h.barycenter*h.weight+f.order+p.order)/(h.weight+2),h.weight+=2}return h}function Xsr(e,t){p0.forEach(e,function(r){r.vs=p0.flatten(r.vs.map(function(n){return t[n]?t[n].vs:n}),!0)})}function $sr(e,t){p0.isUndefined(e.barycenter)?(e.barycenter=t.barycenter,e.weight=t.weight):(e.barycenter=(e.barycenter*e.weight+t.barycenter*t.weight)/(e.weight+t.weight),e.weight+=t.weight)}});var gse=H((yQn,mse)=>{var K4=qn(),Ksr=Uc().Graph;mse.exports=Zsr;function Zsr(e,t,r){var n=Jsr(e),i=new Ksr({compound:!0}).setGraph({root:n}).setDefaultNodeLabel(function(o){return e.node(o)});return K4.forEach(e.nodes(),function(o){var a=e.node(o),s=e.parent(o);(a.rank===t||a.minRank<=t&&t<=a.maxRank)&&(i.setNode(o),i.setParent(o,s||n),K4.forEach(e[r](o),function(l){var c=l.v===o?l.w:l.v,u=i.edge(c,o),h=K4.isUndefined(u)?0:u.weight;i.setEdge(c,o,{weight:e.edge(l).weight+h})}),K4.has(a,"minRank")&&i.setNode(o,{borderLeft:a.borderLeft[t],borderRight:a.borderRight[t]}))}),i}function Jsr(e){for(var t;e.hasNode(t=K4.uniqueId("_root")););return t}});var yse=H((vQn,_se)=>{var Qsr=qn();_se.exports=tlr;function tlr(e,t,r){var n={},i;Qsr.forEach(r,function(o){for(var a=e.parent(o),s,l;a;){if(s=e.parent(a),s?(l=n[s],n[s]=a):(l=i,i=a),l&&l!==a){t.setEdge(l,a);return}a=s}})}});var Sse=H((xQn,wse)=>{"use strict";var d0=qn(),elr=ese(),rlr=nse(),nlr=dse(),ilr=gse(),olr=yse(),alr=Uc().Graph,vse=is();wse.exports=slr;function slr(e){var t=vse.maxRank(e),r=xse(e,d0.range(1,t+1),"inEdges"),n=xse(e,d0.range(t-1,-1,-1),"outEdges"),i=elr(e);bse(e,i);for(var o=Number.POSITIVE_INFINITY,a,s=0,l=0;l<4;++s,++l){llr(s%2?r:n,s%4>=2),i=vse.buildLayerMatrix(e);var c=rlr(e,i);c<o&&(l=0,a=d0.cloneDeep(i),o=c)}bse(e,a)}function xse(e,t,r){return d0.map(t,function(n){return ilr(e,n,r)})}function llr(e,t){var r=new alr;d0.forEach(e,function(n){var i=n.graph().root,o=nlr(n,i,r,t);d0.forEach(o.vs,function(a,s){n.node(a).order=s}),olr(n,r,o.vs)})}function bse(e,t){d0.forEach(t,function(r){d0.forEach(r,function(n,i){e.node(n).order=i})})}});var Rse=H((bQn,kse)=>{"use strict";var Xe=qn(),clr=Uc().Graph,ulr=is();kse.exports={positionX:plr,findType1Conflicts:Mse,findType2Conflicts:Ese,addConflict:Rlt,hasConflict:Tse,verticalAlignment:Cse,horizontalCompaction:Ase,alignCoordinates:Ise,findSmallestWidthAlignment:Pse,balance:Lse};function Mse(e,t){var r={};function n(i,o){var a=0,s=0,l=i.length,c=Xe.last(o);return Xe.forEach(o,function(u,h){var f=hlr(e,u),p=f?e.node(f).order:l;(f||u===c)&&(Xe.forEach(o.slice(s,h+1),function(d){Xe.forEach(e.predecessors(d),function(g){var _=e.node(g),y=_.order;(y<a||p<y)&&!(_.dummy&&e.node(d).dummy)&&Rlt(r,g,d)})}),s=h+1,a=p)}),o}return Xe.reduce(t,n),r}function Ese(e,t){var r={};function n(o,a,s,l,c){var u;Xe.forEach(Xe.range(a,s),function(h){u=o[h],e.node(u).dummy&&Xe.forEach(e.predecessors(u),function(f){var p=e.node(f);p.dummy&&(p.order<l||p.order>c)&&Rlt(r,f,u)})})}function i(o,a){var s=-1,l,c=0;return Xe.forEach(a,function(u,h){if(e.node(u).dummy==="border"){var f=e.predecessors(u);f.length&&(l=e.node(f[0]).order,n(a,c,h,s,l),c=h,s=l)}n(a,c,a.length,l,o.length)}),a}return Xe.reduce(t,i),r}function hlr(e,t){if(e.node(t).dummy)return Xe.find(e.predecessors(t),function(r){return e.node(r).dummy})}function Rlt(e,t,r){if(t>r){var n=t;t=r,r=n}var i=e[t];i||(e[t]=i={}),i[r]=!0}function Tse(e,t,r){if(t>r){var n=t;t=r,r=n}return Xe.has(e[t],r)}function Cse(e,t,r,n){var i={},o={},a={};return Xe.forEach(t,function(s){Xe.forEach(s,function(l,c){i[l]=l,o[l]=l,a[l]=c})}),Xe.forEach(t,function(s){var l=-1;Xe.forEach(s,function(c){var u=n(c);if(u.length){u=Xe.sortBy(u,function(g){return a[g]});for(var h=(u.length-1)/2,f=Math.floor(h),p=Math.ceil(h);f<=p;++f){var d=u[f];o[c]===c&&l<a[d]&&!Tse(r,c,d)&&(o[d]=c,o[c]=i[c]=i[d],l=a[d])}}})}),{root:i,align:o}}function Ase(e,t,r,n,i){var o={},a=flr(e,t,r,i),s=i?"borderLeft":"borderRight";function l(h,f){for(var p=a.nodes(),d=p.pop(),g={};d;)g[d]?h(d):(g[d]=!0,p.push(d),p=p.concat(f(d))),d=p.pop()}function c(h){o[h]=a.inEdges(h).reduce(function(f,p){return Math.max(f,o[p.v]+a.edge(p))},0)}function u(h){var f=a.outEdges(h).reduce(function(d,g){return Math.min(d,o[g.w]-a.edge(g))},Number.POSITIVE_INFINITY),p=e.node(h);f!==Number.POSITIVE_INFINITY&&p.borderType!==s&&(o[h]=Math.max(o[h],f))}return l(c,a.predecessors.bind(a)),l(u,a.successors.bind(a)),Xe.forEach(n,function(h){o[h]=o[r[h]]}),o}function flr(e,t,r,n){var i=new clr,o=e.graph(),a=dlr(o.nodesep,o.edgesep,n);return Xe.forEach(t,function(s){var l;Xe.forEach(s,function(c){var u=r[c];if(i.setNode(u),l){var h=r[l],f=i.edge(h,u);i.setEdge(h,u,Math.max(a(e,c,l),f||0))}l=c})}),i}function Pse(e,t){return Xe.minBy(Xe.values(t),function(r){var n=Number.NEGATIVE_INFINITY,i=Number.POSITIVE_INFINITY;return Xe.forIn(r,function(o,a){var s=mlr(e,a)/2;n=Math.max(o+s,n),i=Math.min(o-s,i)}),n-i})}function Ise(e,t){var r=Xe.values(t),n=Xe.min(r),i=Xe.max(r);Xe.forEach(["u","d"],function(o){Xe.forEach(["l","r"],function(a){var s=o+a,l=e[s],c;if(l!==t){var u=Xe.values(l);c=a==="l"?n-Xe.min(u):i-Xe.max(u),c&&(e[s]=Xe.mapValues(l,function(h){return h+c}))}})})}function Lse(e,t){return Xe.mapValues(e.ul,function(r,n){if(t)return e[t.toLowerCase()][n];var i=Xe.sortBy(Xe.map(e,n));return(i[1]+i[2])/2})}function plr(e){var t=ulr.buildLayerMatrix(e),r=Xe.merge(Mse(e,t),Ese(e,t)),n={},i;Xe.forEach(["u","d"],function(a){i=a==="u"?t:Xe.values(t).reverse(),Xe.forEach(["l","r"],function(s){s==="r"&&(i=Xe.map(i,function(h){return Xe.values(h).reverse()}));var l=(a==="u"?e.predecessors:e.successors).bind(e),c=Cse(e,i,r,l),u=Ase(e,i,c.root,c.align,s==="r");s==="r"&&(u=Xe.mapValues(u,function(h){return-h})),n[a+s]=u})});var o=Pse(e,n);return Ise(n,o),Lse(n,e.graph().align)}function dlr(e,t,r){return function(n,i,o){var a=n.node(i),s=n.node(o),l=0,c;if(l+=a.width/2,Xe.has(a,"labelpos"))switch(a.labelpos.toLowerCase()){case"l":c=-a.width/2;break;case"r":c=a.width/2;break}if(c&&(l+=r?c:-c),c=0,l+=(a.dummy?t:e)/2,l+=(s.dummy?t:e)/2,l+=s.width/2,Xe.has(s,"labelpos"))switch(s.labelpos.toLowerCase()){case"l":c=s.width/2;break;case"r":c=-s.width/2;break}return c&&(l+=r?c:-c),c=0,l}}function mlr(e,t){return e.node(t).width}});var Ose=H((wQn,Dse)=>{"use strict";var Z4=qn(),Nse=is(),glr=Rse().positionX;Dse.exports=_lr;function _lr(e){e=Nse.asNonCompoundGraph(e),ylr(e),Z4.forEach(glr(e),function(t,r){e.node(r).x=t})}function ylr(e){var t=Nse.buildLayerMatrix(e),r=e.graph().ranksep,n=0;Z4.forEach(t,function(i){var o=Z4.max(Z4.map(i,function(a){return e.node(a).height}));Z4.forEach(i,function(a){e.node(a).y=n+o/2}),n+=o+r})}});var Use=H((SQn,Vse)=>{"use strict";var ir=qn(),zse=xae(),Fse=Cae(),vlr=Vae(),xlr=is().normalizeRanks,blr=qae(),wlr=is().removeEmptyRanks,Bse=Yae(),Slr=$ae(),Hse=Qae(),Mlr=Sse(),Elr=Ose(),m0=is(),Tlr=Uc().Graph;Vse.exports=Clr;function Clr(e,t){var r=t&&t.debugTiming?m0.time:m0.notime;r("layout",function(){var n=r("  buildLayoutGraph",function(){return Flr(e)});r("  runLayout",function(){Alr(n,r)}),r("  updateInputGraph",function(){Plr(e,n)})})}function Alr(e,t){t("    makeSpaceForEdgeLabels",function(){Blr(e)}),t("    removeSelfEdges",function(){Xlr(e)}),t("    acyclic",function(){zse.run(e)}),t("    nestingGraph.run",function(){Bse.run(e)}),t("    rank",function(){vlr(m0.asNonCompoundGraph(e))}),t("    injectEdgeLabelProxies",function(){Hlr(e)}),t("    removeEmptyRanks",function(){wlr(e)}),t("    nestingGraph.cleanup",function(){Bse.cleanup(e)}),t("    normalizeRanks",function(){xlr(e)}),t("    assignRankMinMax",function(){Vlr(e)}),t("    removeEdgeLabelProxies",function(){Ulr(e)}),t("    normalize.run",function(){Fse.run(e)}),t("    parentDummyChains",function(){blr(e)}),t("    addBorderSegments",function(){Slr(e)}),t("    order",function(){Mlr(e)}),t("    insertSelfEdges",function(){$lr(e)}),t("    adjustCoordinateSystem",function(){Hse.adjust(e)}),t("    position",function(){Elr(e)}),t("    positionSelfEdges",function(){Klr(e)}),t("    removeBorderNodes",function(){jlr(e)}),t("    normalize.undo",function(){Fse.undo(e)}),t("    fixupEdgeLabelCoords",function(){Wlr(e)}),t("    undoCoordinateSystem",function(){Hse.undo(e)}),t("    translateGraph",function(){qlr(e)}),t("    assignNodeIntersects",function(){Glr(e)}),t("    reversePoints",function(){Ylr(e)}),t("    acyclic.undo",function(){zse.undo(e)})}function Plr(e,t){ir.forEach(e.nodes(),function(r){var n=e.node(r),i=t.node(r);n&&(n.x=i.x,n.y=i.y,t.children(r).length&&(n.width=i.width,n.height=i.height))}),ir.forEach(e.edges(),function(r){var n=e.edge(r),i=t.edge(r);n.points=i.points,ir.has(i,"x")&&(n.x=i.x,n.y=i.y)}),e.graph().width=t.graph().width,e.graph().height=t.graph().height}var Ilr=["nodesep","edgesep","ranksep","marginx","marginy"],Llr={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},klr=["acyclicer","ranker","rankdir","align"],Rlr=["width","height"],Nlr={width:0,height:0},Dlr=["minlen","weight","width","height","labeloffset"],Olr={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},zlr=["labelpos"];function Flr(e){var t=new Tlr({multigraph:!0,compound:!0}),r=Dlt(e.graph());return t.setGraph(ir.merge({},Llr,Nlt(r,Ilr),ir.pick(r,klr))),ir.forEach(e.nodes(),function(n){var i=Dlt(e.node(n));t.setNode(n,ir.defaults(Nlt(i,Rlr),Nlr)),t.setParent(n,e.parent(n))}),ir.forEach(e.edges(),function(n){var i=Dlt(e.edge(n));t.setEdge(n,ir.merge({},Olr,Nlt(i,Dlr),ir.pick(i,zlr)))}),t}function Blr(e){var t=e.graph();t.ranksep/=2,ir.forEach(e.edges(),function(r){var n=e.edge(r);n.minlen*=2,n.labelpos.toLowerCase()!=="c"&&(t.rankdir==="TB"||t.rankdir==="BT"?n.width+=n.labeloffset:n.height+=n.labeloffset)})}function Hlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(r.width&&r.height){var n=e.node(t.v),i=e.node(t.w),o={rank:(i.rank-n.rank)/2+n.rank,e:t};m0.addDummyNode(e,"edge-proxy",o,"_ep")}})}function Vlr(e){var t=0;ir.forEach(e.nodes(),function(r){var n=e.node(r);n.borderTop&&(n.minRank=e.node(n.borderTop).rank,n.maxRank=e.node(n.borderBottom).rank,t=ir.max(t,n.maxRank))}),e.graph().maxRank=t}function Ulr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);r.dummy==="edge-proxy"&&(e.edge(r.e).labelRank=r.rank,e.removeNode(t))})}function qlr(e){var t=Number.POSITIVE_INFINITY,r=0,n=Number.POSITIVE_INFINITY,i=0,o=e.graph(),a=o.marginx||0,s=o.marginy||0;function l(c){var u=c.x,h=c.y,f=c.width,p=c.height;t=Math.min(t,u-f/2),r=Math.max(r,u+f/2),n=Math.min(n,h-p/2),i=Math.max(i,h+p/2)}ir.forEach(e.nodes(),function(c){l(e.node(c))}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.has(u,"x")&&l(u)}),t-=a,n-=s,ir.forEach(e.nodes(),function(c){var u=e.node(c);u.x-=t,u.y-=n}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.forEach(u.points,function(h){h.x-=t,h.y-=n}),ir.has(u,"x")&&(u.x-=t),ir.has(u,"y")&&(u.y-=n)}),o.width=r-t+a,o.height=i-n+s}function Glr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t),n=e.node(t.v),i=e.node(t.w),o,a;r.points?(o=r.points[0],a=r.points[r.points.length-1]):(r.points=[],o=i,a=n),r.points.unshift(m0.intersectRect(n,o)),r.points.push(m0.intersectRect(i,a))})}function Wlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(ir.has(r,"x"))switch((r.labelpos==="l"||r.labelpos==="r")&&(r.width-=r.labeloffset),r.labelpos){case"l":r.x-=r.width/2+r.labeloffset;break;case"r":r.x+=r.width/2+r.labeloffset;break}})}function Ylr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);r.reversed&&r.points.reverse()})}function jlr(e){ir.forEach(e.nodes(),function(t){if(e.children(t).length){var r=e.node(t),n=e.node(r.borderTop),i=e.node(r.borderBottom),o=e.node(ir.last(r.borderLeft)),a=e.node(ir.last(r.borderRight));r.width=Math.abs(a.x-o.x),r.height=Math.abs(i.y-n.y),r.x=o.x+r.width/2,r.y=n.y+r.height/2}}),ir.forEach(e.nodes(),function(t){e.node(t).dummy==="border"&&e.removeNode(t)})}function Xlr(e){ir.forEach(e.edges(),function(t){if(t.v===t.w){var r=e.node(t.v);r.selfEdges||(r.selfEdges=[]),r.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}})}function $lr(e){var t=m0.buildLayerMatrix(e);ir.forEach(t,function(r){var n=0;ir.forEach(r,function(i,o){var a=e.node(i);a.order=o+n,ir.forEach(a.selfEdges,function(s){m0.addDummyNode(e,"selfedge",{width:s.label.width,height:s.label.height,rank:a.rank,order:o+ ++n,e:s.e,label:s.label},"_se")}),delete a.selfEdges})})}function Klr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);if(r.dummy==="selfedge"){var n=e.node(r.e.v),i=n.x+n.width/2,o=n.y,a=r.x-i,s=n.height/2;e.setEdge(r.e,r.label),e.removeNode(t),r.label.points=[{x:i+2*a/3,y:o-s},{x:i+5*a/6,y:o-s},{x:i+a,y:o},{x:i+5*a/6,y:o+s},{x:i+2*a/3,y:o+s}],r.label.x=r.x,r.label.y=r.y}})}function Nlt(e,t){return ir.mapValues(ir.pick(e,t),Number)}function Dlt(e){var t={};return ir.forEach(e,function(r,n){t[n.toLowerCase()]=r}),t}});var Gse=H((MQn,qse)=>{var pH=qn(),Zlr=is(),Jlr=Uc().Graph;qse.exports={debugOrdering:Qlr};function Qlr(e){var t=Zlr.buildLayerMatrix(e),r=new Jlr({compound:!0,multigraph:!0}).setGraph({});return pH.forEach(e.nodes(),function(n){r.setNode(n,{label:n}),r.setParent(n,"layer"+e.node(n).rank)}),pH.forEach(e.edges(),function(n){r.setEdge(n.v,n.w,{},n.name)}),pH.forEach(t,function(n,i){var o="layer"+i;r.setNode(o,{rank:"same"}),pH.reduce(n,function(a,s){return r.setEdge(a,s,{style:"invis"}),s})}),r}});var Yse=H((EQn,Wse)=>{Wse.exports="0.8.5"});var Olt=H((TQn,jse)=>{jse.exports={graphlib:Uc(),layout:Use(),debug:Gse(),util:{time:is().time,notime:is().notime},version:Yse()}});var Vdt=Ee(Hdt(),1),{__extends:d_r,__assign:m_r,__rest:g_r,__decorate:E,__param:__r,__esDecorate:y_r,__runInitializers:v_r,__propKey:x_r,__setFunctionName:b_r,__metadata:w,__awaiter:w_r,__generator:S_r,__exportStar:M_r,__createBinding:E_r,__values:T_r,__read:C_r,__spread:A_r,__spreadArrays:P_r,__spreadArray:I_r,__await:L_r,__asyncGenerator:k_r,__asyncDelegator:R_r,__asyncValues:N_r,__makeTemplateObject:D_r,__importStar:O_r,__importDefault:z_r,__classPrivateFieldGet:F_r,__classPrivateFieldSet:B_r,__classPrivateFieldIn:H_r}=Vdt.default;function yt(e){return t=>{if(e)if(t.hasOwnProperty("is")){if(e!==t.is)throw new Error(`custom element tag names do not match: (${e} !== ${t.is})`)}else Object.defineProperty(t,"is",{value:e});window.customElements.define(t.is,t)}}function Udt(e,t,r){e.constructor.hasOwnProperty("properties")||Object.defineProperty(e.constructor,"properties",{value:{}}),e.constructor.properties[t]=Object.assign({},e.constructor.properties[t],r)}function A(e){return(t,r)=>{Udt(t,r,e)}}function Bt(...e){return(t,r)=>{t.constructor.hasOwnProperty("observers")||Object.defineProperty(t.constructor,"observers",{value:[]}),t.constructor.observers.push(`${r}(${e.join(",")})`)}}function Rt(e,...t){return(r,n,i)=>{let o=`__compute${n}`;Object.defineProperty(r,o,{value:i.get}),i.get=void 0;let a=[e,...t].join(",");Udt(r,n,{computed:`${o}(${a})`})}}var U_r=qdt((e,t)=>e.querySelector(t)),q_r=qdt((e,t)=>e.querySelectorAll(t));function qdt(e){return t=>(r,n)=>{Object.defineProperty(r,n,{get(){return e(this.shadowRoot,t)},enumerable:!0,configurable:!0})}}window.JSCompiler_renameProperty=function(e,t){return e};var Tve=/(url\()([^)]*)(\))/g,Cve=/(^\/[^\/])|(^#)|(^[\w-\d]*:)/,II,Js;function c_(e,t){if(e&&Cve.test(e)||e==="//")return e;if(II===void 0){II=!1;try{let r=new URL("b","http://a");r.pathname="c%20d",II=r.href==="http://a/c%20d"}catch(r){}}if(t||(t=document.baseURI||window.location.href),II)try{return new URL(e,t).href}catch(r){return e}return Js||(Js=document.implementation.createHTMLDocument("temp"),Js.base=Js.createElement("base"),Js.head.appendChild(Js.base),Js.anchor=Js.createElement("a"),Js.body.appendChild(Js.anchor)),Js.base.href=t,Js.anchor.href=e,Js.anchor.href||e}function HM(e,t){return e.replace(Tve,function(r,n,i,o){return n+"'"+c_(i.replace(/["']/g,""),t)+"'"+o})}function Cx(e){return e.substring(0,e.lastIndexOf("/")+1)}var u_=!window.ShadyDOM||!window.ShadyDOM.inUse,$_r=Boolean(!window.ShadyCSS||window.ShadyCSS.nativeCss),K_r=!window.customElements.polyfillWrapFlushCallback,Gdt=u_&&"adoptedStyleSheets"in Document.prototype&&"replaceSync"in CSSStyleSheet.prototype&&(()=>{try{let e=new CSSStyleSheet;e.replaceSync("");let t=document.createElement("div");return t.attachShadow({mode:"open"}),t.shadowRoot.adoptedStyleSheets=[e],t.shadowRoot.adoptedStyleSheets[0]===e}catch(e){return!1}})(),Wdt=window.Polymer&&window.Polymer.rootPath||Cx(document.baseURI||window.location.href);var VM=window.Polymer&&window.Polymer.sanitizeDOMValue||void 0;var Ydt=window.Polymer&&window.Polymer.setPassiveTouchGestures||!1;var iu=window.Polymer&&window.Polymer.strictTemplatePolicy||!1;var jdt=window.Polymer&&window.Polymer.allowTemplateFromDomModule||!1;var dp=window.Polymer&&window.Polymer.legacyOptimizations||!1;var LI=window.Polymer&&window.Polymer.legacyWarnings||!1;var Xdt=window.Polymer&&window.Polymer.syncInitialRender||!1;var kI=window.Polymer&&window.Polymer.legacyUndefined||!1;var $dt=window.Polymer&&window.Polymer.orderedComputed||!1;var fG=!0;var pG=window.Polymer&&window.Polymer.removeNestedTemplates||!1;var RI=window.Polymer&&window.Polymer.fastDomIf||!1;var UM=window.Polymer&&window.Polymer.suppressTemplateNotifications||!1;var qM=window.Polymer&&window.Polymer.legacyNoObservedAttributes||!1;var Kdt=window.Polymer&&window.Polymer.useAdoptedStyleSheetsWithBuiltCSS||!1;var Ave=0;function Zdt(){}Zdt.prototype.__mixinApplications;Zdt.prototype.__mixinSet;var Nn=function(e){let t=e.__mixinApplications;t||(t=new WeakMap,e.__mixinApplications=t);let r=Ave++;function n(i){let o=i.__mixinSet;if(o&&o[r])return i;let a=t,s=a.get(i);if(!s){s=e(i),a.set(i,s);let l=Object.create(s.__mixinSet||o||null);l[r]=!0,s.__mixinSet=l}return s}return n};var dG={},tmt={};function Jdt(e,t){dG[e]=tmt[e.toLowerCase()]=t}function Qdt(e){return dG[e]||tmt[e.toLowerCase()]}function Pve(e){e.querySelector("style")&&console.warn("dom-module %s has style outside template",e.id)}var ou=class extends HTMLElement{static get observedAttributes(){return["id"]}static import(t,r){if(t){let n=Qdt(t);return n&&r?n.querySelector(r):n}return null}attributeChangedCallback(t,r,n,i){r!==n&&this.register()}get assetpath(){if(!this.__assetpath){let t=window.HTMLImports&&HTMLImports.importForElement?HTMLImports.importForElement(this)||document:this.ownerDocument,r=c_(this.getAttribute("assetpath")||"",t.baseURI);this.__assetpath=Cx(r)}return this.__assetpath}register(t){if(t=t||this.id,t){if(iu&&Qdt(t)!==void 0)throw Jdt(t,null),new Error(`strictTemplatePolicy: dom-module ${t} re-registered`);this.id=t,Jdt(t,this),Pve(this)}}};ou.prototype.modules=dG;customElements.define("dom-module",ou);var Ive="link[rel=import][type~=css]",Lve="include",emt="shady-unscoped";function mG(e){return ou.import(e)}function rmt(e){let t=e.body?e.body:e,r=HM(t.textContent,e.baseURI),n=document.createElement("style");return n.textContent=r,n}function kve(e){let t=e.trim().split(/\s+/),r=[];for(let n=0;n<t.length;n++)r.push(...Rve(t[n]));return r}function Rve(e){let t=mG(e);if(!t)return console.warn("Could not find style data in module named",e),[];if(t._styles===void 0){let r=[];r.push(...gG(t));let n=t.querySelector("template");n&&r.push(...NI(n,t.assetpath)),t._styles=r}return t._styles}function NI(e,t){if(!e._styles){let r=[],n=e.content.querySelectorAll("style");for(let i=0;i<n.length;i++){let o=n[i],a=o.getAttribute(Lve);a&&r.push(...kve(a).filter(function(s,l,c){return c.indexOf(s)===l})),t&&(o.textContent=HM(o.textContent,t)),r.push(o)}e._styles=r}return e._styles}function nmt(e){let t=mG(e);return t?gG(t):[]}function gG(e){let t=[],r=e.querySelectorAll(Ive);for(let n=0;n<r.length;n++){let i=r[n];if(i.import){let o=i.import,a=i.hasAttribute(emt);if(a&&!o._unscopedStyle){let s=rmt(o);s.setAttribute(emt,""),o._unscopedStyle=s}else o._style||(o._style=rmt(o));t.push(a?o._unscopedStyle:o._style)}}return t}function imt(e){let t=e.trim().split(/\s+/),r="";for(let n=0;n<t.length;n++)r+=Nve(t[n]);return r}function Nve(e){let t=mG(e);if(t&&t._cssText===void 0){let r=Ove(t),n=t.querySelector("template");n&&(r+=Dve(n,t.assetpath)),t._cssText=r||null}return t||console.warn("Could not find style data in module named",e),t&&t._cssText||""}function Dve(e,t){let r="",n=NI(e,t);for(let i=0;i<n.length;i++){let o=n[i];o.parentNode&&o.parentNode.removeChild(o),r+=o.textContent}return r}function Ove(e){let t="",r=gG(e);for(let n=0;n<r.length;n++)t+=r[n].textContent;return t}var ue=window.ShadyDOM&&window.ShadyDOM.noPatch&&window.ShadyDOM.wrap?window.ShadyDOM.wrap:window.ShadyDOM?e=>ShadyDOM.patch(e):e=>e;function DI(e){return e.indexOf(".")>=0}function au(e){let t=e.indexOf(".");return t===-1?e:e.slice(0,t)}function _G(e,t){return e.indexOf(t+".")===0}function Ax(e,t){return t.indexOf(e+".")===0}function mp(e,t,r){return t+r.slice(e.length)}function OI(e,t){return e===t||_G(e,t)||Ax(e,t)}function Px(e){if(Array.isArray(e)){let t=[];for(let r=0;r<e.length;r++){let n=e[r].toString().split(".");for(let i=0;i<n.length;i++)t.push(n[i])}return t.join(".")}else return e}function omt(e){return Array.isArray(e)?Px(e).split("."):e.toString().split(".")}function No(e,t,r){let n=e,i=omt(t);for(let o=0;o<i.length;o++){if(!n)return;let a=i[o];n=n[a]}return r&&(r.path=i.join(".")),n}function yG(e,t,r){let n=e,i=omt(t),o=i[i.length-1];if(i.length>1){for(let a=0;a<i.length-1;a++){let s=i[a];if(n=n[s],!n)return}n[o]=r}else n[t]=r;return i.join(".")}var zI={},zve=/-[a-z]/g,Fve=/([A-Z])/g;function Sm(e){return zI[e]||(zI[e]=e.indexOf("-")<0?e:e.replace(zve,t=>t[1].toUpperCase()))}function Ix(e){return zI[e]||(zI[e]=e.replace(Fve,"-$1").toLowerCase())}var Bve=0,amt=0,Lx=[],Hve=0,vG=!1,smt=document.createTextNode("");new window.MutationObserver(Vve).observe(smt,{characterData:!0});function Vve(){vG=!1;let e=Lx.length;for(let t=0;t<e;t++){let r=Lx[t];if(r)try{r()}catch(n){setTimeout(()=>{throw n})}}Lx.splice(0,e),amt+=e}var mo={after(e){return{run(t){return window.setTimeout(t,e)},cancel(t){window.clearTimeout(t)}}},run(e,t){return window.setTimeout(e,t)},cancel(e){window.clearTimeout(e)}};var Ni={run(e){return window.requestAnimationFrame(e)},cancel(e){window.cancelAnimationFrame(e)}};var kx={run(e){return window.requestIdleCallback?window.requestIdleCallback(e):window.setTimeout(e,16)},cancel(e){window.cancelIdleCallback?window.cancelIdleCallback(e):window.clearTimeout(e)}};var li={run(e){return vG||(vG=!0,smt.textContent=Hve++),Lx.push(e),Bve++},cancel(e){let t=e-amt;if(t>=0){if(!Lx[t])throw new Error("invalid async handle: "+e);Lx[t]=null}}};var Uve=li,FI=Nn(e=>{class t extends e{static createProperties(n){let i=this.prototype;for(let o in n)o in i||i._createPropertyAccessor(o)}static attributeNameForProperty(n){return n.toLowerCase()}static typeForProperty(n){}_createPropertyAccessor(n,i){this._addPropertyToAttributeMap(n),this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor",this))||(this.__dataHasAccessor=Object.assign({},this.__dataHasAccessor)),this.__dataHasAccessor[n]||(this.__dataHasAccessor[n]=!0,this._definePropertyAccessor(n,i))}_addPropertyToAttributeMap(n){this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes",this))||(this.__dataAttributes=Object.assign({},this.__dataAttributes));let i=this.__dataAttributes[n];return i||(i=this.constructor.attributeNameForProperty(n),this.__dataAttributes[i]=n),i}_definePropertyAccessor(n,i){Object.defineProperty(this,n,{get(){return this.__data[n]},set:i?function(){}:function(o){this._setPendingProperty(n,o,!0)&&this._invalidateProperties()}})}constructor(){super(),this.__dataEnabled=!1,this.__dataReady=!1,this.__dataInvalid=!1,this.__data={},this.__dataPending=null,this.__dataOld=null,this.__dataInstanceProps=null,this.__dataCounter=0,this.__serializing=!1,this._initializeProperties()}ready(){this.__dataReady=!0,this._flushProperties()}_initializeProperties(){for(let n in this.__dataHasAccessor)this.hasOwnProperty(n)&&(this.__dataInstanceProps=this.__dataInstanceProps||{},this.__dataInstanceProps[n]=this[n],delete this[n])}_initializeInstanceProperties(n){Object.assign(this,n)}_setProperty(n,i){this._setPendingProperty(n,i)&&this._invalidateProperties()}_getProperty(n){return this.__data[n]}_setPendingProperty(n,i,o){let a=this.__data[n],s=this._shouldPropertyChange(n,i,a);return s&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),this.__dataOld&&!(n in this.__dataOld)&&(this.__dataOld[n]=a),this.__data[n]=i,this.__dataPending[n]=i),s}_isPropertyPending(n){return!!(this.__dataPending&&this.__dataPending.hasOwnProperty(n))}_invalidateProperties(){!this.__dataInvalid&&this.__dataReady&&(this.__dataInvalid=!0,Uve.run(()=>{this.__dataInvalid&&(this.__dataInvalid=!1,this._flushProperties())}))}_enableProperties(){this.__dataEnabled||(this.__dataEnabled=!0,this.__dataInstanceProps&&(this._initializeInstanceProperties(this.__dataInstanceProps),this.__dataInstanceProps=null),this.ready())}_flushProperties(){this.__dataCounter++;let n=this.__data,i=this.__dataPending,o=this.__dataOld;this._shouldPropertiesChange(n,i,o)&&(this.__dataPending=null,this.__dataOld=null,this._propertiesChanged(n,i,o)),this.__dataCounter--}_shouldPropertiesChange(n,i,o){return Boolean(i)}_propertiesChanged(n,i,o){}_shouldPropertyChange(n,i,o){return o!==i&&(o===o||i===i)}attributeChangedCallback(n,i,o,a){i!==o&&this._attributeToProperty(n,o),super.attributeChangedCallback&&super.attributeChangedCallback(n,i,o,a)}_attributeToProperty(n,i,o){if(!this.__serializing){let a=this.__dataAttributes,s=a&&a[n]||n;this[s]=this._deserializeValue(i,o||this.constructor.typeForProperty(s))}}_propertyToAttribute(n,i,o){this.__serializing=!0,o=arguments.length<3?this[n]:o,this._valueToNodeAttribute(this,o,i||this.constructor.attributeNameForProperty(n)),this.__serializing=!1}_valueToNodeAttribute(n,i,o){let a=this._serializeValue(i);(o==="class"||o==="name"||o==="slot")&&(n=ue(n)),a===void 0?n.removeAttribute(o):n.setAttribute(o,a)}_serializeValue(n){switch(typeof n){case"boolean":return n?"":void 0;default:return n!=null?n.toString():void 0}}_deserializeValue(n,i){switch(i){case Boolean:return n!==null;case Number:return Number(n);default:return n}}}return t});var lmt={},BI=HTMLElement.prototype;for(;BI;){let e=Object.getOwnPropertyNames(BI);for(let t=0;t<e.length;t++)lmt[e[t]]=!0;BI=Object.getPrototypeOf(BI)}function qve(e,t){if(!lmt[t]){let r=e[t];r!==void 0&&(e.__data?e._setPendingProperty(t,r):(e.__dataProto?e.hasOwnProperty(JSCompiler_renameProperty("__dataProto",e))||(e.__dataProto=Object.create(e.__dataProto)):e.__dataProto={},e.__dataProto[t]=r))}}var HI=Nn(e=>{let t=FI(e);class r extends t{static createPropertiesForAttributes(){let i=this.observedAttributes;for(let o=0;o<i.length;o++)this.prototype._createPropertyAccessor(Sm(i[o]))}static attributeNameForProperty(i){return Ix(i)}_initializeProperties(){this.__dataProto&&(this._initializeProtoProperties(this.__dataProto),this.__dataProto=null),super._initializeProperties()}_initializeProtoProperties(i){for(let o in i)this._setProperty(o,i[o])}_ensureAttribute(i,o){let a=this;a.hasAttribute(i)||this._valueToNodeAttribute(a,o,i)}_serializeValue(i){switch(typeof i){case"object":if(i instanceof Date)return i.toString();if(i)try{return JSON.stringify(i)}catch(o){return""}default:return super._serializeValue(i)}}_deserializeValue(i,o){let a;switch(o){case Object:try{a=JSON.parse(i)}catch(s){a=i}break;case Array:try{a=JSON.parse(i)}catch(s){a=null,console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${i}`)}break;case Date:a=isNaN(i)?String(i):Number(i),a=new Date(a);break;default:a=super._deserializeValue(i,o);break}return a}_definePropertyAccessor(i,o){qve(this,i),super._definePropertyAccessor(i,o)}_hasAccessor(i){return this.__dataHasAccessor&&this.__dataHasAccessor[i]}_isPropertyPending(i){return Boolean(this.__dataPending&&i in this.__dataPending)}}return r});var Gve={"dom-if":!0,"dom-repeat":!0},cmt=!1,umt=!1;function Wve(){if(!cmt){cmt=!0;let e=document.createElement("textarea");e.placeholder="a",umt=e.placeholder===e.textContent}return umt}function Yve(e){Wve()&&e.localName==="textarea"&&e.placeholder&&e.placeholder===e.textContent&&(e.textContent=null)}function jve(e){let t=e.getAttribute("is");if(t&&Gve[t]){let r=e;for(r.removeAttribute("is"),e=r.ownerDocument.createElement(t),r.parentNode.replaceChild(e,r),e.appendChild(r);r.attributes.length;)e.setAttribute(r.attributes[0].name,r.attributes[0].value),r.removeAttribute(r.attributes[0].name)}return e}function hmt(e,t){let r=t.parentInfo&&hmt(e,t.parentInfo);if(r){for(let n=r.firstChild,i=0;n;n=n.nextSibling)if(t.parentIndex===i++)return n}else return e}function Xve(e,t,r,n){n.id&&(t[n.id]=r)}function $ve(e,t,r){if(r.events&&r.events.length)for(let n=0,i=r.events,o;n<i.length&&(o=i[n]);n++)e._addMethodEventListenerToNode(t,o.name,o.value,e)}function Kve(e,t,r,n){r.templateInfo&&(t._templateInfo=r.templateInfo,t._parentTemplateInfo=n)}function Zve(e,t,r){return e=e._methodHost||e,function(i){e[r]?e[r](i,i.detail):console.warn("listener method `"+r+"` not defined")}}var fmt=Nn(e=>{class t extends e{static _parseTemplate(n,i){if(!n._templateInfo){let o=n._templateInfo={};o.nodeInfoList=[],o.nestedTemplate=Boolean(i),o.stripWhiteSpace=i&&i.stripWhiteSpace||n.hasAttribute("strip-whitespace"),this._parseTemplateContent(n,o,{parent:null})}return n._templateInfo}static _parseTemplateContent(n,i,o){return this._parseTemplateNode(n.content,i,o)}static _parseTemplateNode(n,i,o){let a=!1,s=n;return s.localName=="template"&&!s.hasAttribute("preserve-content")?a=this._parseTemplateNestedTemplate(s,i,o)||a:s.localName==="slot"&&(i.hasInsertionPoint=!0),Yve(s),s.firstChild&&this._parseTemplateChildNodes(s,i,o),s.hasAttributes&&s.hasAttributes()&&(a=this._parseTemplateNodeAttributes(s,i,o)||a),a||o.noted}static _parseTemplateChildNodes(n,i,o){if(!(n.localName==="script"||n.localName==="style"))for(let a=n.firstChild,s=0,l;a;a=l){if(a.localName=="template"&&(a=jve(a)),l=a.nextSibling,a.nodeType===Node.TEXT_NODE){let u=l;for(;u&&u.nodeType===Node.TEXT_NODE;)a.textContent+=u.textContent,l=u.nextSibling,n.removeChild(u),u=l;if(i.stripWhiteSpace&&!a.textContent.trim()){n.removeChild(a);continue}}let c={parentIndex:s,parentInfo:o};this._parseTemplateNode(a,i,c)&&(c.infoIndex=i.nodeInfoList.push(c)-1),a.parentNode&&s++}}static _parseTemplateNestedTemplate(n,i,o){let a=n,s=this._parseTemplate(a,i);return(s.content=a.content.ownerDocument.createDocumentFragment()).appendChild(a.content),o.templateInfo=s,!0}static _parseTemplateNodeAttributes(n,i,o){let a=!1,s=Array.from(n.attributes);for(let l=s.length-1,c;c=s[l];l--)a=this._parseTemplateNodeAttribute(n,i,o,c.name,c.value)||a;return a}static _parseTemplateNodeAttribute(n,i,o,a,s){return a.slice(0,3)==="on-"?(n.removeAttribute(a),o.events=o.events||[],o.events.push({name:a.slice(3),value:s}),!0):a==="id"?(o.id=s,!0):!1}static _contentForTemplate(n){let i=n._templateInfo;return i&&i.content||n.content}_stampTemplate(n,i){n&&!n.content&&window.HTMLTemplateElement&&HTMLTemplateElement.decorate&&HTMLTemplateElement.decorate(n),i=i||this.constructor._parseTemplate(n);let o=i.nodeInfoList,a=i.content||n.content,s=document.importNode(a,!0);s.__noInsertionPoint=!i.hasInsertionPoint;let l=s.nodeList=new Array(o.length);s.$={};for(let c=0,u=o.length,h;c<u&&(h=o[c]);c++){let f=l[c]=hmt(s,h);Xve(this,s.$,f,h),Kve(this,f,h,i),$ve(this,f,h)}return s=s,s}_addMethodEventListenerToNode(n,i,o,a){a=a||n;let s=Zve(a,i,o);return this._addEventListenerToNode(n,i,s),s}_addEventListenerToNode(n,i,o){n.addEventListener(i,o)}_removeEventListenerFromNode(n,i,o){n.removeEventListener(i,o)}}return t});var jM=0,XM=[],zr={COMPUTE:"__computeEffects",REFLECT:"__reflectEffects",NOTIFY:"__notifyEffects",PROPAGATE:"__propagateEffects",OBSERVE:"__observeEffects",READ_ONLY:"__readOnly"},xmt="__computeInfo",Jve=/[A-Z]/;function xG(e,t,r){let n=e[t];if(!n)n=e[t]={};else if(!e.hasOwnProperty(t)&&(n=e[t]=Object.create(e[t]),r))for(let i in n){let o=n[i],a=n[i]=Array(o.length);for(let s=0;s<o.length;s++)a[s]=o[s]}return n}function YM(e,t,r,n,i,o){if(t){let a=!1,s=jM++;for(let l in r){let c=i?au(l):l,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==s)&&(!i||MG(l,p.trigger))&&(p.info&&(p.info.lastRun=s),p.fn(e,l,r,n,p.info,i,o),a=!0)}return a}return!1}function Qve(e,t,r,n,i,o,a,s){let l=!1,c=a?au(n):n,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==r)&&(!a||MG(n,p.trigger))&&(p.info&&(p.info.lastRun=r),p.fn(e,n,i,o,p.info,a,s),l=!0);return l}function MG(e,t){if(t){let r=t.name;return r==e||!!(t.structured&&_G(r,e))||!!(t.wildcard&&Ax(r,e))}else return!0}function pmt(e,t,r,n,i){let o=typeof i.method=="string"?e[i.method]:i.method,a=i.property;o?o.call(e,e.__data[a],n[a]):i.dynamicFn||console.warn("observer method `"+i.method+"` not defined")}function t1e(e,t,r,n,i){let o=e[zr.NOTIFY],a,s=jM++;for(let c in t)t[c]&&(o&&Qve(e,o,s,c,r,n,i)||i&&e1e(e,c,r))&&(a=!0);let l;a&&(l=e.__dataHost)&&l._invalidateProperties&&l._invalidateProperties()}function e1e(e,t,r){let n=au(t);if(n!==t){let i=Ix(n)+"-changed";return bmt(e,i,r[t],t),!0}return!1}function bmt(e,t,r,n){let i={value:r,queueProperty:!0};n&&(i.path=n),ue(e).dispatchEvent(new CustomEvent(t,{detail:i}))}function r1e(e,t,r,n,i,o){let s=(o?au(t):t)!=t?t:null,l=s?No(e,s):e.__data[t];s&&l===void 0&&(l=r[t]),bmt(e,i.eventName,l,s)}function n1e(e,t,r,n,i){let o,a=e.detail,s=a&&a.path;s?(n=mp(r,n,s),o=a&&a.value):o=e.currentTarget[r],o=i?!o:o,(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][n])&&t._setPendingPropertyOrPath(n,o,!0,Boolean(s))&&(!a||!a.queueProperty)&&t._invalidateProperties()}function i1e(e,t,r,n,i){let o=e.__data[t];VM&&(o=VM(o,i.attrName,"attribute",e)),e._propertyToAttribute(t,i.attrName,o)}function o1e(e,t,r,n){let i=e[zr.COMPUTE];if(i)if($dt){jM++;let o=s1e(e),a=[];for(let l in t)dmt(l,i,a,o,n);let s;for(;s=a.shift();)wmt(e,"",t,r,s)&&dmt(s.methodInfo,i,a,o,n);Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),e.__dataPending=null}else{let o=t;for(;YM(e,i,o,r,n);)Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),o=e.__dataPending,e.__dataPending=null}}var a1e=(e,t,r)=>{let n=0,i=t.length-1,o=-1;for(;n<=i;){let a=n+i>>1,s=r.get(t[a].methodInfo)-r.get(e.methodInfo);if(s<0)n=a+1;else if(s>0)i=a-1;else{o=a;break}}o<0&&(o=i+1),t.splice(o,0,e)},dmt=(e,t,r,n,i)=>{let o=i?au(e):e,a=t[o];if(a)for(let s=0;s<a.length;s++){let l=a[s];l.info.lastRun!==jM&&(!i||MG(e,l.trigger))&&(l.info.lastRun=jM,a1e(l.info,r,n))}};function s1e(e){let t=e.constructor.__orderedComputedDeps;if(!t){t=new Map;let r=e[zr.COMPUTE],{counts:n,ready:i,total:o}=l1e(e),a;for(;a=i.shift();){t.set(a,t.size);let s=r[a];s&&s.forEach(l=>{let c=l.info.methodInfo;--o,--n[c]===0&&i.push(c)})}o!==0&&console.warn(`Computed graph for ${e.localName} incomplete; circular?`),e.constructor.__orderedComputedDeps=t}return t}function l1e(e){let t=e[xmt],r={},n=e[zr.COMPUTE],i=[],o=0;for(let a in t){let s=t[a];o+=r[a]=s.args.filter(l=>!l.literal).length+(s.dynamicFn?1:0)}for(let a in n)t[a]||i.push(a);return{counts:r,ready:i,total:o}}function wmt(e,t,r,n,i){let o=SG(e,t,r,n,i);if(o===XM)return!1;let a=i.methodInfo;return e.__dataHasAccessor&&e.__dataHasAccessor[a]?e._setPendingProperty(a,o,!0):(e[a]=o,!1)}function c1e(e,t,r){let n=e.__dataLinkedPaths;if(n){let i;for(let o in n){let a=n[o];Ax(o,t)?(i=mp(o,a,t),e._setPendingPropertyOrPath(i,r,!0,!0)):Ax(a,t)&&(i=mp(a,o,t),e._setPendingPropertyOrPath(i,r,!0,!0))}}}function bG(e,t,r,n,i,o,a){r.bindings=r.bindings||[];let s={kind:n,target:i,parts:o,literal:a,isCompound:o.length!==1};if(r.bindings.push(s),d1e(s)){let{event:c,negate:u}=s.parts[0];s.listenerEvent=c||Ix(i)+"-changed",s.listenerNegate=u}let l=t.nodeInfoList.length;for(let c=0;c<s.parts.length;c++){let u=s.parts[c];u.compoundIndex=c,u1e(e,t,s,u,l)}}function u1e(e,t,r,n,i){if(!n.literal)if(r.kind==="attribute"&&r.target[0]==="-")console.warn("Cannot set attribute "+r.target+' because "-" is not a valid attribute starting character');else{let o=n.dependencies,a={index:i,binding:r,part:n,evaluator:e};for(let s=0;s<o.length;s++){let l=o[s];typeof l=="string"&&(l=Mmt(l),l.wildcard=!0),e._addTemplatePropertyEffect(t,l.rootProperty,{fn:h1e,info:a,trigger:l})}}}function h1e(e,t,r,n,i,o,a){let s=a[i.index],l=i.binding,c=i.part;if(o&&c.source&&t.length>c.source.length&&l.kind=="property"&&!l.isCompound&&s.__isPropertyEffectsClient&&s.__dataHasAccessor&&s.__dataHasAccessor[l.target]){let u=r[t];t=mp(c.source,l.target,t),s._setPendingPropertyOrPath(t,u,!1,!0)&&e._enqueueClient(s)}else{let u=i.evaluator._evaluateBinding(e,c,t,r,n,o);u!==XM&&f1e(e,s,l,c,u)}}function f1e(e,t,r,n,i){if(i=p1e(t,i,r,n),VM&&(i=VM(i,r.target,r.kind,t)),r.kind=="attribute")e._valueToNodeAttribute(t,i,r.target);else{let o=r.target;t.__isPropertyEffectsClient&&t.__dataHasAccessor&&t.__dataHasAccessor[o]?(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][o])&&t._setPendingProperty(o,i)&&e._enqueueClient(t):e._setUnmanagedPropertyToNode(t,o,i)}}function p1e(e,t,r,n){if(r.isCompound){let i=e.__dataCompoundStorage[r.target];i[n.compoundIndex]=t,t=i.join("")}return r.kind!=="attribute"&&(r.target==="textContent"||r.target==="value"&&(e.localName==="input"||e.localName==="textarea"))&&(t=t==null?"":t),t}function d1e(e){return Boolean(e.target)&&e.kind!="attribute"&&e.kind!="text"&&!e.isCompound&&e.parts[0].mode==="{"}function m1e(e,t){let{nodeList:r,nodeInfoList:n}=t;if(n.length)for(let i=0;i<n.length;i++){let o=n[i],a=r[i],s=o.bindings;if(s)for(let l=0;l<s.length;l++){let c=s[l];g1e(a,c),_1e(a,e,c)}a.__dataHost=e}}function g1e(e,t){if(t.isCompound){let r=e.__dataCompoundStorage||(e.__dataCompoundStorage={}),n=t.parts,i=new Array(n.length);for(let a=0;a<n.length;a++)i[a]=n[a].literal;let o=t.target;r[o]=i,t.literal&&t.kind=="property"&&(o==="className"&&(e=ue(e)),e[o]=t.literal)}}function _1e(e,t,r){if(r.listenerEvent){let n=r.parts[0];e.addEventListener(r.listenerEvent,function(i){n1e(i,t,r.target,n.source,n.negate)})}}function mmt(e,t,r,n,i,o){o=t.static||o&&(typeof o!="object"||o[t.methodName]);let a={methodName:t.methodName,args:t.args,methodInfo:i,dynamicFn:o};for(let s=0,l;s<t.args.length&&(l=t.args[s]);s++)l.literal||e._addPropertyEffect(l.rootProperty,r,{fn:n,info:a,trigger:l});return o&&e._addPropertyEffect(t.methodName,r,{fn:n,info:a}),a}function SG(e,t,r,n,i){let o=e._methodHost||e,a=o[i.methodName];if(a){let s=e._marshalArgs(i.args,t,r);return s===XM?XM:a.apply(o,s)}else i.dynamicFn||console.warn("method `"+i.methodName+"` not defined")}var y1e=[],Smt="(?:[a-zA-Z_$][\\w.:$\\-*]*)",v1e="(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)",x1e="(?:'(?:[^'\\\\]|\\\\.)*')",b1e='(?:"(?:[^"\\\\]|\\\\.)*")',w1e="(?:"+x1e+"|"+b1e+")",gmt="(?:("+Smt+"|"+v1e+"|"+w1e+")\\s*)",S1e="(?:"+gmt+"(?:,\\s*"+gmt+")*)",M1e="(?:\\(\\s*(?:"+S1e+"?)\\)\\s*)",E1e="("+Smt+"\\s*"+M1e+"?)",T1e="(\\[\\[|{{)\\s*",C1e="(?:]]|}})",A1e="(?:(!)\\s*)?",P1e=T1e+A1e+E1e+C1e,_mt=new RegExp(P1e,"g");function ymt(e){let t="";for(let r=0;r<e.length;r++)t+=e[r].literal||"";return t}function wG(e){let t=e.match(/([^\s]+?)\(([\s\S]*)\)/);if(t){let n={methodName:t[1],static:!0,args:y1e};if(t[2].trim()){let i=t[2].replace(/\\,/g,"&comma;").split(",");return I1e(i,n)}else return n}return null}function I1e(e,t){return t.args=e.map(function(r){let n=Mmt(r);return n.literal||(t.static=!1),n},this),t}function Mmt(e){let t=e.trim().replace(/&comma;/g,",").replace(/\\(.)/g,"$1"),r={name:t,value:"",literal:!1},n=t[0];switch(n==="-"&&(n=t[1]),n>="0"&&n<="9"&&(n="#"),n){case"'":case'"':r.value=t.slice(1,-1),r.literal=!0;break;case"#":r.value=Number(t),r.literal=!0;break}return r.literal||(r.rootProperty=au(t),r.structured=DI(t),r.structured&&(r.wildcard=t.slice(-2)==".*",r.wildcard&&(r.name=t.slice(0,-2)))),r}function vmt(e,t,r){let n=No(e,r);return n===void 0&&(n=t[r]),n}function Emt(e,t,r,n){let i={indexSplices:n};kI&&!e._overrideLegacyUndefined&&(t.splices=i),e.notifyPath(r+".splices",i),e.notifyPath(r+".length",t.length),kI&&!e._overrideLegacyUndefined&&(i.indexSplices=[])}function GM(e,t,r,n,i,o){Emt(e,t,r,[{index:n,addedCount:i,removed:o,object:t,type:"splice"}])}function L1e(e){return e[0].toUpperCase()+e.substring(1)}var h_=Nn(e=>{let t=fmt(HI(e));class r extends t{constructor(){super(),this.__isPropertyEffectsClient=!0,this.__dataClientsReady,this.__dataPendingClients,this.__dataToNotify,this.__dataLinkedPaths,this.__dataHasPaths,this.__dataCompoundStorage,this.__dataHost,this.__dataTemp,this.__dataClientsInitialized,this.__data,this.__dataPending,this.__dataOld,this.__computeEffects,this.__computeInfo,this.__reflectEffects,this.__notifyEffects,this.__propagateEffects,this.__observeEffects,this.__readOnly,this.__templateInfo,this._overrideLegacyUndefined}get PROPERTY_EFFECT_TYPES(){return zr}_initializeProperties(){super._initializeProperties(),this._registerHost(),this.__dataClientsReady=!1,this.__dataPendingClients=null,this.__dataToNotify=null,this.__dataLinkedPaths=null,this.__dataHasPaths=!1,this.__dataCompoundStorage=this.__dataCompoundStorage||null,this.__dataHost=this.__dataHost||null,this.__dataTemp={},this.__dataClientsInitialized=!1}_registerHost(){if(WM.length){let i=WM[WM.length-1];i._enqueueClient(this),this.__dataHost=i}}_initializeProtoProperties(i){this.__data=Object.create(i),this.__dataPending=Object.create(i),this.__dataOld={}}_initializeInstanceProperties(i){let o=this[zr.READ_ONLY];for(let a in i)(!o||!o[a])&&(this.__dataPending=this.__dataPending||{},this.__dataOld=this.__dataOld||{},this.__data[a]=this.__dataPending[a]=i[a])}_addPropertyEffect(i,o,a){this._createPropertyAccessor(i,o==zr.READ_ONLY);let s=xG(this,o,!0)[i];s||(s=this[o][i]=[]),s.push(a)}_removePropertyEffect(i,o,a){let s=xG(this,o,!0)[i],l=s.indexOf(a);l>=0&&s.splice(l,1)}_hasPropertyEffect(i,o){let a=this[o];return Boolean(a&&a[i])}_hasReadOnlyEffect(i){return this._hasPropertyEffect(i,zr.READ_ONLY)}_hasNotifyEffect(i){return this._hasPropertyEffect(i,zr.NOTIFY)}_hasReflectEffect(i){return this._hasPropertyEffect(i,zr.REFLECT)}_hasComputedEffect(i){return this._hasPropertyEffect(i,zr.COMPUTE)}_setPendingPropertyOrPath(i,o,a,s){if(s||au(Array.isArray(i)?i[0]:i)!==i){if(!s){let l=No(this,i);if(i=yG(this,i,o),!i||!super._shouldPropertyChange(i,o,l))return!1}if(this.__dataHasPaths=!0,this._setPendingProperty(i,o,a))return c1e(this,i,o),!0}else{if(this.__dataHasAccessor&&this.__dataHasAccessor[i])return this._setPendingProperty(i,o,a);this[i]=o}return!1}_setUnmanagedPropertyToNode(i,o,a){(a!==i[o]||typeof a=="object")&&(o==="className"&&(i=ue(i)),i[o]=a)}_setPendingProperty(i,o,a){let s=this.__dataHasPaths&&DI(i),l=s?this.__dataTemp:this.__data;return this._shouldPropertyChange(i,o,l[i])?(this.__dataPending||(this.__dataPending={},this.__dataOld={}),i in this.__dataOld||(this.__dataOld[i]=this.__data[i]),s?this.__dataTemp[i]=o:this.__data[i]=o,this.__dataPending[i]=o,(s||this[zr.NOTIFY]&&this[zr.NOTIFY][i])&&(this.__dataToNotify=this.__dataToNotify||{},this.__dataToNotify[i]=a),!0):!1}_setProperty(i,o){this._setPendingProperty(i,o,!0)&&this._invalidateProperties()}_invalidateProperties(){this.__dataReady&&this._flushProperties()}_enqueueClient(i){this.__dataPendingClients=this.__dataPendingClients||[],i!==this&&this.__dataPendingClients.push(i)}_flushClients(){this.__dataClientsReady?this.__enableOrFlushClients():(this.__dataClientsReady=!0,this._readyClients(),this.__dataReady=!0)}__enableOrFlushClients(){let i=this.__dataPendingClients;if(i){this.__dataPendingClients=null;for(let o=0;o<i.length;o++){let a=i[o];a.__dataEnabled?a.__dataPending&&a._flushProperties():a._enableProperties()}}}_readyClients(){this.__enableOrFlushClients()}setProperties(i,o){for(let a in i)(o||!this[zr.READ_ONLY]||!this[zr.READ_ONLY][a])&&this._setPendingPropertyOrPath(a,i[a],!0);this._invalidateProperties()}ready(){this._flushProperties(),this.__dataClientsReady||this._flushClients(),this.__dataPending&&this._flushProperties()}_propertiesChanged(i,o,a){let s=this.__dataHasPaths;this.__dataHasPaths=!1;let l;o1e(this,o,a,s),l=this.__dataToNotify,this.__dataToNotify=null,this._propagatePropertyChanges(o,a,s),this._flushClients(),YM(this,this[zr.REFLECT],o,a,s),YM(this,this[zr.OBSERVE],o,a,s),l&&t1e(this,l,o,a,s),this.__dataCounter==1&&(this.__dataTemp={})}_propagatePropertyChanges(i,o,a){this[zr.PROPAGATE]&&YM(this,this[zr.PROPAGATE],i,o,a),this.__templateInfo&&this._runEffectsForTemplate(this.__templateInfo,i,o,a)}_runEffectsForTemplate(i,o,a,s){let l=(c,u)=>{YM(this,i.propertyEffects,c,a,u,i.nodeList);for(let h=i.firstChild;h;h=h.nextSibling)this._runEffectsForTemplate(h,c,a,u)};i.runEffects?i.runEffects(l,o,s):l(o,s)}linkPaths(i,o){i=Px(i),o=Px(o),this.__dataLinkedPaths=this.__dataLinkedPaths||{},this.__dataLinkedPaths[i]=o}unlinkPaths(i){i=Px(i),this.__dataLinkedPaths&&delete this.__dataLinkedPaths[i]}notifySplices(i,o){let a={path:""},s=No(this,i,a);Emt(this,s,a.path,o)}get(i,o){return No(o||this,i)}set(i,o,a){a?yG(a,i,o):(!this[zr.READ_ONLY]||!this[zr.READ_ONLY][i])&&this._setPendingPropertyOrPath(i,o,!0)&&this._invalidateProperties()}push(i,...o){let a={path:""},s=No(this,i,a),l=s.length,c=s.push(...o);return o.length&&GM(this,s,a.path,l,o.length,[]),c}pop(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.pop();return s&&GM(this,a,o.path,a.length,0,[l]),l}splice(i,o,a,...s){let l={path:""},c=No(this,i,l);o<0?o=c.length-Math.floor(-o):o&&(o=Math.floor(o));let u;return arguments.length===2?u=c.splice(o):u=c.splice(o,a,...s),(s.length||u.length)&&GM(this,c,l.path,o,s.length,u),u}shift(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.shift();return s&&GM(this,a,o.path,0,0,[l]),l}unshift(i,...o){let a={path:""},s=No(this,i,a),l=s.unshift(...o);return o.length&&GM(this,s,a.path,0,o.length,[]),l}notifyPath(i,o){let a;if(arguments.length==1){let s={path:""};o=No(this,i,s),a=s.path}else Array.isArray(i)?a=Px(i):a=i;this._setPendingPropertyOrPath(a,o,!0,!0)&&this._invalidateProperties()}_createReadOnlyProperty(i,o){this._addPropertyEffect(i,zr.READ_ONLY),o&&(this["_set"+L1e(i)]=function(a){this._setProperty(i,a)})}_createPropertyObserver(i,o,a){let s={property:i,method:o,dynamicFn:Boolean(a)};this._addPropertyEffect(i,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:i}}),a&&this._addPropertyEffect(o,zr.OBSERVE,{fn:pmt,info:s,trigger:{name:o}})}_createMethodObserver(i,o){let a=wG(i);if(!a)throw new Error("Malformed observer expression '"+i+"'");mmt(this,a,zr.OBSERVE,SG,null,o)}_createNotifyingProperty(i){this._addPropertyEffect(i,zr.NOTIFY,{fn:r1e,info:{eventName:Ix(i)+"-changed",property:i}})}_createReflectedProperty(i){let o=this.constructor.attributeNameForProperty(i);o[0]==="-"?console.warn("Property "+i+" cannot be reflected to attribute "+o+' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.'):this._addPropertyEffect(i,zr.REFLECT,{fn:i1e,info:{attrName:o}})}_createComputedProperty(i,o,a){let s=wG(o);if(!s)throw new Error("Malformed computed expression '"+o+"'");let l=mmt(this,s,zr.COMPUTE,wmt,i,a);xG(this,xmt)[i]=l}_marshalArgs(i,o,a){let s=this.__data,l=[];for(let c=0,u=i.length;c<u;c++){let{name:h,structured:f,wildcard:p,value:d,literal:g}=i[c];if(!g)if(p){let _=Ax(h,o),y=vmt(s,a,_?o:h);d={path:_?o:h,value:y,base:_?No(s,h):y}}else d=f?vmt(s,a,h):s[h];if(kI&&!this._overrideLegacyUndefined&&d===void 0&&i.length>1)return XM;l[c]=d}return l}static addPropertyEffect(i,o,a){this.prototype._addPropertyEffect(i,o,a)}static createPropertyObserver(i,o,a){this.prototype._createPropertyObserver(i,o,a)}static createMethodObserver(i,o){this.prototype._createMethodObserver(i,o)}static createNotifyingProperty(i){this.prototype._createNotifyingProperty(i)}static createReadOnlyProperty(i,o){this.prototype._createReadOnlyProperty(i,o)}static createReflectedProperty(i){this.prototype._createReflectedProperty(i)}static createComputedProperty(i,o,a){this.prototype._createComputedProperty(i,o,a)}static bindTemplate(i){return this.prototype._bindTemplate(i)}_bindTemplate(i,o){let a=this.constructor._parseTemplate(i),s=this.__preBoundTemplateInfo==a;if(!s)for(let l in a.propertyEffects)this._createPropertyAccessor(l);if(o)if(a=Object.create(a),a.wasPreBound=s,!this.__templateInfo)this.__templateInfo=a;else{let l=i._parentTemplateInfo||this.__templateInfo,c=l.lastChild;a.parent=l,l.lastChild=a,a.previousSibling=c,c?c.nextSibling=a:l.firstChild=a}else this.__preBoundTemplateInfo=a;return a}static _addTemplatePropertyEffect(i,o,a){let s=i.hostProps=i.hostProps||{};s[o]=!0;let l=i.propertyEffects=i.propertyEffects||{};(l[o]=l[o]||[]).push(a)}_stampTemplate(i,o){o=o||this._bindTemplate(i,!0),WM.push(this);let a=super._stampTemplate(i,o);if(WM.pop(),o.nodeList=a.nodeList,!o.wasPreBound){let s=o.childNodes=[];for(let l=a.firstChild;l;l=l.nextSibling)s.push(l)}return a.templateInfo=o,m1e(this,o),this.__dataClientsReady&&(this._runEffectsForTemplate(o,this.__data,null,!1),this._flushClients()),a}_removeBoundDom(i){let o=i.templateInfo,{previousSibling:a,nextSibling:s,parent:l}=o;a?a.nextSibling=s:l&&(l.firstChild=s),s?s.previousSibling=a:l&&(l.lastChild=a),o.nextSibling=o.previousSibling=null;let c=o.childNodes;for(let u=0;u<c.length;u++){let h=c[u];ue(ue(h).parentNode).removeChild(h)}}static _parseTemplateNode(i,o,a){let s=t._parseTemplateNode.call(this,i,o,a);if(i.nodeType===Node.TEXT_NODE){let l=this._parseBindings(i.textContent,o);l&&(i.textContent=ymt(l)||" ",bG(this,o,a,"text","textContent",l),s=!0)}return s}static _parseTemplateNodeAttribute(i,o,a,s,l){let c=this._parseBindings(l,o);if(c){let u=s,h="property";Jve.test(s)?h="attribute":s[s.length-1]=="$"&&(s=s.slice(0,-1),h="attribute");let f=ymt(c);return f&&h=="attribute"&&(s=="class"&&i.hasAttribute("class")&&(f+=" "+i.getAttribute(s)),i.setAttribute(s,f)),h=="attribute"&&u=="disable-upgrade$"&&i.setAttribute(s,""),i.localName==="input"&&u==="value"&&i.setAttribute(u,""),i.removeAttribute(u),h==="property"&&(s=Sm(s)),bG(this,o,a,h,s,c,f),!0}else return t._parseTemplateNodeAttribute.call(this,i,o,a,s,l)}static _parseTemplateNestedTemplate(i,o,a){let s=t._parseTemplateNestedTemplate.call(this,i,o,a),l=i.parentNode,c=a.templateInfo,u=l.localName==="dom-if",h=l.localName==="dom-repeat";pG&&(u||h)&&(l.removeChild(i),a=a.parentInfo,a.templateInfo=c,a.noted=!0,s=!1);let f=c.hostProps;if(RI&&u)f&&(o.hostProps=Object.assign(o.hostProps||{},f),pG||(a.parentInfo.noted=!0));else{let p="{";for(let d in f){let g=[{mode:p,source:d,dependencies:[d],hostProp:!0}];bG(this,o,a,"property","_host_"+d,g)}}return s}static _parseBindings(i,o){let a=[],s=0,l;for(;(l=_mt.exec(i))!==null;){l.index>s&&a.push({literal:i.slice(s,l.index)});let c=l[1][0],u=Boolean(l[2]),h=l[3].trim(),f=!1,p="",d=-1;c=="{"&&(d=h.indexOf("::"))>0&&(p=h.substring(d+2),h=h.substring(0,d),f=!0);let g=wG(h),_=[];if(g){let{args:y,methodName:x}=g;for(let S=0;S<y.length;S++){let C=y[S];C.literal||_.push(C)}let b=o.dynamicFns;(b&&b[x]||g.static)&&(_.push(x),g.dynamicFn=!0)}else _.push(h);a.push({source:h,mode:c,negate:u,customEvent:f,signature:g,dependencies:_,event:p}),s=_mt.lastIndex}if(s&&s<i.length){let c=i.substring(s);c&&a.push({literal:c})}return a.length?a:null}static _evaluateBinding(i,o,a,s,l,c){let u;return o.signature?u=SG(i,a,s,l,o.signature):a!=o.source?u=No(i,o.source):c&&DI(a)?u=No(i,a):u=i.__data[a],o.negate&&(u=!u),u}}return r}),WM=[];var k1e=0;function Tmt(){k1e++}var R1e=[];function VI(e){R1e.push(e)}function N1e(e){let t={};for(let r in e){let n=e[r];t[r]=typeof n=="function"?{type:n}:n}return t}var Cmt=Nn(e=>{let t=FI(e);function r(o){let a=Object.getPrototypeOf(o);return a.prototype instanceof i?a:null}function n(o){if(!o.hasOwnProperty(JSCompiler_renameProperty("__ownProperties",o))){let a=null;if(o.hasOwnProperty(JSCompiler_renameProperty("properties",o))){let s=o.properties;s&&(a=N1e(s))}o.__ownProperties=a}return o.__ownProperties}class i extends t{static get observedAttributes(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))){VI(this.prototype);let a=this._properties;this.__observedAttributes=a?Object.keys(a).map(s=>this.prototype._addPropertyToAttributeMap(s)):[]}return this.__observedAttributes}static finalize(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__finalized",this))){let a=r(this);a&&a.finalize(),this.__finalized=!0,this._finalizeClass()}}static _finalizeClass(){let a=n(this);a&&this.createProperties(a)}static get _properties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__properties",this))){let a=r(this);this.__properties=Object.assign({},a&&a._properties,n(this))}return this.__properties}static typeForProperty(a){let s=this._properties[a];return s&&s.type}_initializeProperties(){Tmt(),this.constructor.finalize(),super._initializeProperties()}connectedCallback(){super.connectedCallback&&super.connectedCallback(),this._enableProperties()}disconnectedCallback(){super.disconnectedCallback&&super.disconnectedCallback()}}return i});var Amt="3.4.1",UI=window.ShadyCSS&&window.ShadyCSS.cssBuild,Mm=Nn(e=>{let t=Cmt(h_(e));function r(l){if(!l.hasOwnProperty(JSCompiler_renameProperty("__propertyDefaults",l))){l.__propertyDefaults=null;let c=l._properties;for(let u in c){let h=c[u];"value"in h&&(l.__propertyDefaults=l.__propertyDefaults||{},l.__propertyDefaults[u]=h)}}return l.__propertyDefaults}function n(l){return l.hasOwnProperty(JSCompiler_renameProperty("__ownObservers",l))||(l.__ownObservers=l.hasOwnProperty(JSCompiler_renameProperty("observers",l))?l.observers:null),l.__ownObservers}function i(l,c,u,h){u.computed&&(u.readOnly=!0),u.computed&&(l._hasReadOnlyEffect(c)?console.warn(`Cannot redefine computed property '${c}'.`):l._createComputedProperty(c,u.computed,h)),u.readOnly&&!l._hasReadOnlyEffect(c)?l._createReadOnlyProperty(c,!u.computed):u.readOnly===!1&&l._hasReadOnlyEffect(c)&&console.warn(`Cannot make readOnly property '${c}' non-readOnly.`),u.reflectToAttribute&&!l._hasReflectEffect(c)?l._createReflectedProperty(c):u.reflectToAttribute===!1&&l._hasReflectEffect(c)&&console.warn(`Cannot make reflected property '${c}' non-reflected.`),u.notify&&!l._hasNotifyEffect(c)?l._createNotifyingProperty(c):u.notify===!1&&l._hasNotifyEffect(c)&&console.warn(`Cannot make notify property '${c}' non-notify.`),u.observer&&l._createPropertyObserver(c,u.observer,h[u.observer]),l._addPropertyToAttributeMap(c)}function o(l,c,u,h){if(!UI){let f=c.content.querySelectorAll("style"),p=NI(c),d=nmt(u),g=c.content.firstElementChild;for(let y=0;y<d.length;y++){let x=d[y];x.textContent=l._processStyleText(x.textContent,h),c.content.insertBefore(x,g)}let _=0;for(let y=0;y<p.length;y++){let x=p[y],b=f[_];b!==x?(x=x.cloneNode(!0),b.parentNode.insertBefore(x,b)):_++,x.textContent=l._processStyleText(x.textContent,h)}}if(window.ShadyCSS&&window.ShadyCSS.prepareTemplate(c,u),Kdt&&UI&&Gdt){let f=c.content.querySelectorAll("style");if(f){let p="";Array.from(f).forEach(d=>{p+=d.textContent,d.parentNode.removeChild(d)}),l._styleSheet=new CSSStyleSheet,l._styleSheet.replaceSync(p)}}}function a(l){let c=null;if(l&&(!iu||jdt)&&(c=ou.import(l,"template"),iu&&!c))throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${l}`);return c}class s extends t{static get polymerElementVersion(){return Amt}static _finalizeClass(){t._finalizeClass.call(this);let c=n(this);c&&this.createObservers(c,this._properties),this._prepareTemplate()}static _prepareTemplate(){let c=this.template;c&&(typeof c=="string"?(console.error("template getter must return HTMLTemplateElement"),c=null):dp||(c=c.cloneNode(!0))),this.prototype._template=c}static createProperties(c){for(let u in c)i(this.prototype,u,c[u],c)}static createObservers(c,u){let h=this.prototype;for(let f=0;f<c.length;f++)h._createMethodObserver(c[f],u)}static get template(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_template",this))){let c=this.prototype.hasOwnProperty(JSCompiler_renameProperty("_template",this.prototype))?this.prototype._template:void 0;this._template=c!==void 0?c:this.hasOwnProperty(JSCompiler_renameProperty("is",this))&&a(this.is)||Object.getPrototypeOf(this.prototype).constructor.template}return this._template}static set template(c){this._template=c}static get importPath(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_importPath",this))){let c=this.importMeta;if(c)this._importPath=Cx(c.url);else{let u=ou.import(this.is);this._importPath=u&&u.assetpath||Object.getPrototypeOf(this.prototype).constructor.importPath}}return this._importPath}constructor(){super(),this._template,this._importPath,this.rootPath,this.importPath,this.root,this.$}_initializeProperties(){this.constructor.finalize(),this.constructor._finalizeTemplate(this.localName),super._initializeProperties(),this.rootPath=Wdt,this.importPath=this.constructor.importPath;let c=r(this.constructor);if(!!c)for(let u in c){let h=c[u];if(this._canApplyPropertyDefault(u)){let f=typeof h.value=="function"?h.value.call(this):h.value;this._hasAccessor(u)?this._setPendingProperty(u,f,!0):this[u]=f}}}_canApplyPropertyDefault(c){return!this.hasOwnProperty(c)}static _processStyleText(c,u){return HM(c,u)}static _finalizeTemplate(c){let u=this.prototype._template;if(u&&!u.__polymerFinalized){u.__polymerFinalized=!0;let h=this.importPath,f=h?c_(h):"";o(this,u,c,f),this.prototype._bindTemplate(u)}}connectedCallback(){window.ShadyCSS&&this._template&&window.ShadyCSS.styleElement(this),super.connectedCallback()}ready(){this._template&&(this.root=this._stampTemplate(this._template),this.$=this.root.$),super.ready()}_readyClients(){this._template&&(this.root=this._attachDom(this.root)),super._readyClients()}_attachDom(c){let u=ue(this);if(u.attachShadow)return c?(u.shadowRoot||(u.attachShadow({mode:"open",shadyUpgradeFragment:c}),u.shadowRoot.appendChild(c),this.constructor._styleSheet&&(u.shadowRoot.adoptedStyleSheets=[this.constructor._styleSheet])),Xdt&&window.ShadyDOM&&window.ShadyDOM.flushInitial(u.shadowRoot),u.shadowRoot):null;throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.")}updateStyles(c){window.ShadyCSS&&window.ShadyCSS.styleSubtree(this,c)}resolveUrl(c,u){return!u&&this.importPath&&(u=c_(this.importPath)),c_(c,u)}static _parseTemplateContent(c,u,h){return u.dynamicFns=u.dynamicFns||this._properties,t._parseTemplateContent.call(this,c,u,h)}static _addTemplatePropertyEffect(c,u,h){return LI&&!(u in this._properties)&&!(h.info.part.signature&&h.info.part.signature.static)&&!h.info.part.hostProp&&!c.nestedTemplate&&console.warn(`Property '${u}' used in template but not declared in 'properties'; attribute will not be observed.`),t._addTemplatePropertyEffect.call(this,c,u,h)}}return s});var qI=class{constructor(t){this.value=t.toString()}toString(){return this.value}};function D1e(e){if(e instanceof qI)return e.value;throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${e}`)}function O1e(e){if(e instanceof HTMLTemplateElement)return e.innerHTML;if(e instanceof qI)return D1e(e);throw new Error(`non-template value passed to Polymer's html function: ${e}`)}var Q=function(t,...r){let n=document.createElement("template");return n.innerHTML=r.reduce((i,o,a)=>i+O1e(o)+t[a+1],t[0]),n};var mt=Mm(HTMLElement);var py=Ee(Oe(),1);var f_=!(window.ShadyDOM&&window.ShadyDOM.inUse),GI;function Pmt(e){e&&e.shimcssproperties?GI=!1:GI=f_||Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)&&window.CSS&&CSS.supports&&CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Em;window.ShadyCSS&&window.ShadyCSS.cssBuild!==void 0&&(Em=window.ShadyCSS.cssBuild);var WI=Boolean(window.ShadyCSS&&window.ShadyCSS.disableRuntime);window.ShadyCSS&&window.ShadyCSS.nativeCss!==void 0?GI=window.ShadyCSS.nativeCss:window.ShadyCSS?(Pmt(window.ShadyCSS),window.ShadyCSS=void 0):Pmt(window.WebComponents&&window.WebComponents.flags);var Nx=GI;var YI=class{constructor(){this.start=0,this.end=0,this.previous=null,this.parent=null,this.rules=null,this.parsedCssText="",this.cssText="",this.atRule=!1,this.type=0,this.keyframesName="",this.selector="",this.parsedSelector=""}};function EG(e){return e=z1e(e),Imt(F1e(e),e)}function z1e(e){return e.replace(_p.comments,"").replace(_p.port,"")}function F1e(e){let t=new YI;t.start=0,t.end=e.length;let r=t;for(let n=0,i=e.length;n<i;n++)if(e[n]===Lmt){r.rules||(r.rules=[]);let o=r,a=o.rules[o.rules.length-1]||null;r=new YI,r.start=n+1,r.parent=o,r.previous=a,o.rules.push(r)}else e[n]===kmt&&(r.end=n+1,r=r.parent||t);return t}function Imt(e,t){let r=t.substring(e.start,e.end-1);if(e.parsedCssText=e.cssText=r.trim(),e.parent){let i=e.previous?e.previous.end:e.parent.start;r=t.substring(i,e.start-1),r=B1e(r),r=r.replace(_p.multipleSpaces," "),r=r.substring(r.lastIndexOf(";")+1);let o=e.parsedSelector=e.selector=r.trim();e.atRule=o.indexOf(W1e)===0,e.atRule?o.indexOf(G1e)===0?e.type=gp.MEDIA_RULE:o.match(_p.keyframesRule)&&(e.type=gp.KEYFRAMES_RULE,e.keyframesName=e.selector.split(_p.multipleSpaces).pop()):o.indexOf(Rmt)===0?e.type=gp.MIXIN_RULE:e.type=gp.STYLE_RULE}let n=e.rules;if(n)for(let i=0,o=n.length,a;i<o&&(a=n[i]);i++)Imt(a,t);return e}function B1e(e){return e.replace(/\\([0-9a-f]{1,6})\s/gi,function(){let t=arguments[1],r=6-t.length;for(;r--;)t="0"+t;return"\\"+t})}function TG(e,t,r=""){let n="";if(e.cssText||e.rules){let i=e.rules;if(i&&!H1e(i))for(let o=0,a=i.length,s;o<a&&(s=i[o]);o++)n=TG(s,t,n);else n=t?e.cssText:V1e(e.cssText),n=n.trim(),n&&(n="  "+n+`
`)}return n&&(e.selector&&(r+=e.selector+" "+Lmt+`
`),r+=n,e.selector&&(r+=kmt+`

`)),r}function H1e(e){let t=e[0];return Boolean(t)&&Boolean(t.selector)&&t.selector.indexOf(Rmt)===0}function V1e(e){return e=U1e(e),q1e(e)}function U1e(e){return e.replace(_p.customProp,"").replace(_p.mixinProp,"")}function q1e(e){return e.replace(_p.mixinApply,"").replace(_p.varApply,"")}var gp={STYLE_RULE:1,KEYFRAMES_RULE:7,MEDIA_RULE:4,MIXIN_RULE:1e3},Lmt="{",kmt="}",_p={comments:/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,port:/@import[^;]*;/gim,customProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,mixinProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,mixinApply:/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,varApply:/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,keyframesRule:/^@[^\s]*keyframes/,multipleSpaces:/\s+/g},Rmt="--",G1e="@media",W1e="@";var KM=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Dx=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi;var Nmt=/@media\s(.*)/;var Dmt=new Set,Y1e="shady-unscoped";function Omt(e){let t=e.textContent;if(!Dmt.has(t)){Dmt.add(t);let r=document.createElement("style");r.setAttribute("shady-unscoped",""),r.textContent=t,document.head.appendChild(r)}}function zmt(e){return e.hasAttribute(Y1e)}function ZM(e,t){return e?(typeof e=="string"&&(e=EG(e)),t&&Ox(e,t),TG(e,Nx)):""}function CG(e){return!e.__cssRules&&e.textContent&&(e.__cssRules=EG(e.textContent)),e.__cssRules||null}function Ox(e,t,r,n){if(!e)return;let i=!1,o=e.type;if(n&&o===gp.MEDIA_RULE){let s=e.selector.match(Nmt);s&&(window.matchMedia(s[1]).matches||(i=!0))}o===gp.STYLE_RULE?t(e):r&&o===gp.KEYFRAMES_RULE?r(e):o===gp.MIXIN_RULE&&(i=!0);let a=e.rules;if(a&&!i)for(let s=0,l=a.length,c;s<l&&(c=a[s]);s++)Ox(c,t,r,n)}function j1e(e,t){let r=0;for(let n=t,i=e.length;n<i;n++)if(e[n]==="(")r++;else if(e[n]===")"&&--r===0)return n;return-1}function AG(e,t){let r=e.indexOf("var(");if(r===-1)return t(e,"","","");let n=j1e(e,r+3),i=e.substring(r+4,n),o=e.substring(0,r),a=AG(e.substring(n+1),t),s=i.indexOf(",");if(s===-1)return t(o,i.trim(),"",a);let l=i.substring(0,s).trim(),c=i.substring(s+1).trim();return t(o,l,c,a)}var fvr=window.ShadyDOM&&window.ShadyDOM.wrap||(e=>e);function Fmt(e){let t=e.localName,r="",n="";return t?t.indexOf("-")>-1?r=t:(n=t,r=e.getAttribute&&e.getAttribute("is")||""):(r=e.is,n=e.extends),{is:r,typeExtension:n}}function Bmt(e){let t=[],r=e.querySelectorAll("style");for(let n=0;n<r.length;n++){let i=r[n];zmt(i)?f_||(Omt(i),i.parentNode.removeChild(i)):(t.push(i.textContent),i.parentNode.removeChild(i))}return t.join("").trim()}var Hmt="css-build";function X1e(e){if(Em!==void 0)return Em;if(e.__cssBuild===void 0){let t=e.getAttribute(Hmt);if(t)e.__cssBuild=t;else{let r=$1e(e);r!==""&&K1e(e),e.__cssBuild=r}}return e.__cssBuild||""}function PG(e){return X1e(e)!==""}function $1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;if(t instanceof Comment){let r=t.textContent.trim().split(":");if(r[0]===Hmt)return r[1]}return""}function K1e(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;t.parentNode.removeChild(t)}function JM(e,t){for(let r in t)r===null?e.style.removeProperty(r):e.style.setProperty(r,t[r])}function jI(e,t){let r=window.getComputedStyle(e).getPropertyValue(t);return r?r.trim():""}function Vmt(e){let t=Dx.test(e)||KM.test(e);return Dx.lastIndex=0,KM.lastIndex=0,t}var Z1e=/;\s*/m,J1e=/^\s*(initial)|(inherit)\s*$/,Umt=/\s*!important/,IG="_-_";var LG=class{constructor(){this._map={}}set(t,r){t=t.trim(),this._map[t]={properties:r,dependants:{}}}get(t){return t=t.trim(),this._map[t]||null}},XI=null,Do=class{constructor(){this._currentElement=null,this._measureElement=null,this._map=new LG}detectMixin(t){return Vmt(t)}gatherStyles(t){let r=Bmt(t.content);if(r){let n=document.createElement("style");return n.textContent=r,t.content.insertBefore(n,t.content.firstChild),n}return null}transformTemplate(t,r){t._gatheredStyle===void 0&&(t._gatheredStyle=this.gatherStyles(t));let n=t._gatheredStyle;return n?this.transformStyle(n,r):null}transformStyle(t,r=""){let n=CG(t);return this.transformRules(n,r),t.textContent=ZM(n),n}transformCustomStyle(t){let r=CG(t);return Ox(r,n=>{n.selector===":root"&&(n.selector="html"),this.transformRule(n)}),t.textContent=ZM(r),r}transformRules(t,r){this._currentElement=r,Ox(t,n=>{this.transformRule(n)}),this._currentElement=null}transformRule(t){t.cssText=this.transformCssText(t.parsedCssText,t),t.selector===":root"&&(t.selector=":host > *")}transformCssText(t,r){return t=t.replace(KM,(n,i,o,a)=>this._produceCssProperties(n,i,o,a,r)),this._consumeCssProperties(t,r)}_getInitialValueForProperty(t){return this._measureElement||(this._measureElement=document.createElement("meta"),this._measureElement.setAttribute("apply-shim-measure",""),this._measureElement.style.all="initial",document.head.appendChild(this._measureElement)),window.getComputedStyle(this._measureElement).getPropertyValue(t)}_fallbacksFromPreviousRules(t){let r=t;for(;r.parent;)r=r.parent;let n={},i=!1;return Ox(r,o=>{i=i||o===t,!i&&o.selector===t.selector&&Object.assign(n,this._cssTextToMap(o.parsedCssText))}),n}_consumeCssProperties(t,r){let n=null;for(;n=Dx.exec(t);){let i=n[0],o=n[1],a=n.index,s=a+i.indexOf("@apply"),l=a+i.length,c=t.slice(0,s),u=t.slice(l),h=r?this._fallbacksFromPreviousRules(r):{};Object.assign(h,this._cssTextToMap(c));let f=this._atApplyToCssProperties(o,h);t=`${c}${f}${u}`,Dx.lastIndex=a+f.length}return t}_atApplyToCssProperties(t,r){t=t.replace(Z1e,"");let n=[],i=this._map.get(t);if(i||(this._map.set(t,{}),i=this._map.get(t)),i){this._currentElement&&(i.dependants[this._currentElement]=!0);let o,a,s,l=i.properties;for(o in l)s=r&&r[o],a=[o,": var(",t,IG,o],s&&a.push(",",s.replace(Umt,"")),a.push(")"),Umt.test(l[o])&&a.push(" !important"),n.push(a.join(""))}return n.join("; ")}_replaceInitialOrInherit(t,r){let n=J1e.exec(r);return n&&(n[1]?r=this._getInitialValueForProperty(t):r="apply-shim-inherit"),r}_cssTextToMap(t,r=!1){let n=t.split(";"),i,o,a={};for(let s=0,l,c;s<n.length;s++)l=n[s],l&&(c=l.split(":"),c.length>1&&(i=c[0].trim(),o=c.slice(1).join(":"),r&&(o=this._replaceInitialOrInherit(i,o)),a[i]=o));return a}_invalidateMixinEntry(t){if(!!XI)for(let r in t.dependants)r!==this._currentElement&&XI(r)}_produceCssProperties(t,r,n,i,o){if(n&&AG(n,(_,y)=>{y&&this._map.get(y)&&(i=`@apply ${y};`)}),!i)return t;let a=this._consumeCssProperties(""+i,o),s=t.slice(0,t.indexOf("--")),l=this._cssTextToMap(a,!0),c=l,u=this._map.get(r),h=u&&u.properties;h?c=Object.assign(Object.create(h),l):this._map.set(r,c);let f=[],p,d,g=!1;for(p in c)d=l[p],d===void 0&&(d="initial"),h&&!(p in h)&&(g=!0),f.push(`${r}${IG}${p}: ${d}`);return g&&this._invalidateMixinEntry(u),u&&(u.properties=c),n&&(s=`${t};${s}`),`${s}${f.join("; ")};`}};Do.prototype.detectMixin=Do.prototype.detectMixin;Do.prototype.transformStyle=Do.prototype.transformStyle;Do.prototype.transformCustomStyle=Do.prototype.transformCustomStyle;Do.prototype.transformRules=Do.prototype.transformRules;Do.prototype.transformRule=Do.prototype.transformRule;Do.prototype.transformTemplate=Do.prototype.transformTemplate;Do.prototype._separator=IG;Object.defineProperty(Do.prototype,"invalidCallback",{get(){return XI},set(e){XI=e}});var qmt=Do;var Q1e={},QM=Q1e;var $I="_applyShimCurrentVersion",zx="_applyShimNextVersion",KI="_applyShimValidatingVersion",txe=Promise.resolve();function Gmt(e){let t=QM[e];t&&exe(t)}function exe(e){e[$I]=e[$I]||0,e[KI]=e[KI]||0,e[zx]=(e[zx]||0)+1}function kG(e){return e[$I]===e[zx]}function Wmt(e){return!kG(e)&&e[KI]===e[zx]}function Ymt(e){e[KI]=e[zx],e._validating||(e._validating=!0,txe.then(function(){e[$I]=e[zx],e._validating=!1}))}var RG=null,jmt=window.HTMLImports&&window.HTMLImports.whenReady||null,NG;function ZI(e){requestAnimationFrame(function(){jmt?jmt(e):(RG||(RG=new Promise(t=>{NG=t}),document.readyState==="complete"?NG():document.addEventListener("readystatechange",()=>{document.readyState==="complete"&&NG()})),RG.then(function(){e&&e()}))})}var Xmt="__seenByShadyCSS",JI="__shadyCSSCachedStyle",QI=null,tE=null,Zl=class{constructor(){this.customStyles=[],this.enqueued=!1,ZI(()=>{window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}enqueueDocumentValidation(){this.enqueued||!tE||(this.enqueued=!0,ZI(tE))}addCustomStyle(t){t[Xmt]||(t[Xmt]=!0,this.customStyles.push(t),this.enqueueDocumentValidation())}getStyleForCustomStyle(t){if(t[JI])return t[JI];let r;return t.getStyle?r=t.getStyle():r=t,r}processStyles(){let t=this.customStyles;for(let r=0;r<t.length;r++){let n=t[r];if(n[JI])continue;let i=this.getStyleForCustomStyle(n);if(i){let o=i.__appliedElement||i;QI&&QI(o),n[JI]=o}}return t}};Zl.prototype.addCustomStyle=Zl.prototype.addCustomStyle;Zl.prototype.getStyleForCustomStyle=Zl.prototype.getStyleForCustomStyle;Zl.prototype.processStyles=Zl.prototype.processStyles;Object.defineProperties(Zl.prototype,{transformCallback:{get(){return QI},set(e){QI=e}},validateCallback:{get(){return tE},set(e){let t=!1;tE||(t=!0),tE=e,t&&this.enqueueDocumentValidation()}}});var eE=new qmt,DG=class{constructor(){this.customStyleInterface=null,eE.invalidCallback=Gmt}ensure(){this.customStyleInterface||window.ShadyCSS.CustomStyleInterface&&(this.customStyleInterface=window.ShadyCSS.CustomStyleInterface,this.customStyleInterface.transformCallback=t=>{eE.transformCustomStyle(t)},this.customStyleInterface.validateCallback=()=>{requestAnimationFrame(()=>{this.customStyleInterface.enqueued&&this.flushCustomStyles()})})}prepareTemplate(t,r){if(this.ensure(),PG(t))return;QM[r]=t;let n=eE.transformTemplate(t,r);t._styleAst=n}flushCustomStyles(){if(this.ensure(),!this.customStyleInterface)return;let t=this.customStyleInterface.processStyles();if(!!this.customStyleInterface.enqueued){for(let r=0;r<t.length;r++){let n=t[r],i=this.customStyleInterface.getStyleForCustomStyle(n);i&&eE.transformCustomStyle(i)}this.customStyleInterface.enqueued=!1}}styleSubtree(t,r){if(this.ensure(),r&&JM(t,r),t.shadowRoot){this.styleElement(t);let n=t.shadowRoot.children||t.shadowRoot.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}else{let n=t.children||t.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}}styleElement(t){this.ensure();let{is:r}=Fmt(t),n=QM[r];if(!(n&&PG(n))&&n&&!kG(n)){Wmt(n)||(this.prepareTemplate(n,r),Ymt(n));let i=t.shadowRoot;if(i){let o=i.querySelector("style");o&&(o.__cssRules=n._styleAst,o.textContent=ZM(n._styleAst))}}}styleDocument(t){this.ensure(),this.styleSubtree(document.body,t)}};if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){let e=new DG,t=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate(r,n,i){e.flushCustomStyles(),e.prepareTemplate(r,n)},prepareTemplateStyles(r,n,i){window.ShadyCSS.prepareTemplate(r,n,i)},prepareTemplateDom(r,n){},styleSubtree(r,n){e.flushCustomStyles(),e.styleSubtree(r,n)},styleElement(r){e.flushCustomStyles(),e.styleElement(r)},styleDocument(r){e.flushCustomStyles(),e.styleDocument(r)},getComputedStyleValue(r,n){return jI(r,n)},flushCustomStyles(){e.flushCustomStyles()},nativeCss:Nx,nativeShadow:f_,cssBuild:Em,disableRuntime:WI},t&&(window.ShadyCSS.CustomStyleInterface=t)}window.ShadyCSS.ApplyShim=eE;var sr=class{constructor(){this._asyncModule=null,this._callback=null,this._timer=null}setConfig(t,r){this._asyncModule=t,this._callback=r,this._timer=this._asyncModule.run(()=>{this._timer=null,rE.delete(this),this._callback()})}cancel(){this.isActive()&&(this._cancelAsync(),rE.delete(this))}_cancelAsync(){this.isActive()&&(this._asyncModule.cancel(this._timer),this._timer=null)}flush(){this.isActive()&&(this.cancel(),this._callback())}isActive(){return this._timer!=null}static debounce(t,r,n){return t instanceof sr?t._cancelAsync():t=new sr,t.setConfig(r,n),t}},rE=new Set,Jl=function(e){rE.add(e)},$mt=function(){let e=Boolean(rE.size);return rE.forEach(t=>{try{t.flush()}catch(r){setTimeout(()=>{throw r})}}),e};var BG=typeof document.head.style.touchAction=="string",e9="__polymerGestures",t9="__polymerGesturesHandled",zG="__polymerGesturesTouchAction",Kmt=25,Zmt=5,nxe=2,ixe=2500,rgt=["mousedown","mousemove","mouseup","click"],oxe=[0,1,4,2],axe=function(){try{return new MouseEvent("test",{buttons:1}).buttons===1}catch(e){return!1}}();function HG(e){return rgt.indexOf(e)>-1}var VG=!1;(function(){try{let e=Object.defineProperty({},"passive",{get(){VG=!0}});window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(e){}})();function ngt(e){if(!(HG(e)||e==="touchend")&&BG&&VG&&Ydt)return{passive:!0}}var igt=navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/),FG=[],sxe={button:!0,input:!0,keygen:!0,meter:!0,output:!0,textarea:!0,progress:!0,select:!0},lxe={button:!0,command:!0,fieldset:!0,input:!0,keygen:!0,optgroup:!0,option:!0,select:!0,textarea:!0};function cxe(e){return sxe[e.localName]||!1}function uxe(e){let t=Array.prototype.slice.call(e.labels||[]);if(!t.length){t=[];let r=e.getRootNode();if(e.id){let n=r.querySelectorAll(`label[for = ${e.id}]`);for(let i=0;i<n.length;i++)t.push(n[i])}}return t}var Jmt=function(e){let t=e.sourceCapabilities;if(!(t&&!t.firesTouchEvents)&&(e[t9]={skip:!0},e.type==="click")){let r=!1,n=n9(e);for(let i=0;i<n.length;i++){if(n[i].nodeType===Node.ELEMENT_NODE){if(n[i].localName==="label")FG.push(n[i]);else if(cxe(n[i])){let o=uxe(n[i]);for(let a=0;a<o.length;a++)r=r||FG.indexOf(o[a])>-1}}if(n[i]===oa.mouse.target)return}if(r)return;e.preventDefault(),e.stopPropagation()}};function Qmt(e){let t=igt?["click"]:rgt;for(let r=0,n;r<t.length;r++)n=t[r],e?(FG.length=0,document.addEventListener(n,Jmt,!0)):document.removeEventListener(n,Jmt,!0)}function hxe(e){if(!fG)return;oa.mouse.mouseIgnoreJob||Qmt(!0);let t=function(){Qmt(),oa.mouse.target=null,oa.mouse.mouseIgnoreJob=null};oa.mouse.target=n9(e)[0],oa.mouse.mouseIgnoreJob=sr.debounce(oa.mouse.mouseIgnoreJob,mo.after(ixe),t)}function d_(e){let t=e.type;if(!HG(t))return!1;if(t==="mousemove"){let r=e.buttons===void 0?1:e.buttons;return e instanceof window.MouseEvent&&!axe&&(r=oxe[e.which]||0),Boolean(r&1)}else return(e.button===void 0?0:e.button)===0}function fxe(e){if(e.type==="click"){if(e.detail===0)return!0;let t=yp(e);if(!t.nodeType||t.nodeType!==Node.ELEMENT_NODE)return!0;let r=t.getBoundingClientRect(),n=e.pageX,i=e.pageY;return!(n>=r.left&&n<=r.right&&i>=r.top&&i<=r.bottom)}return!1}var oa={mouse:{target:null,mouseIgnoreJob:null},touch:{x:0,y:0,id:-1,scrollDecided:!1}};function pxe(e){let t="auto",r=n9(e);for(let n=0,i;n<r.length;n++)if(i=r[n],i[zG]){t=i[zG];break}return t}function ogt(e,t,r){e.movefn=t,e.upfn=r,document.addEventListener("mousemove",t),document.addEventListener("mouseup",r)}function Fx(e){document.removeEventListener("mousemove",e.movefn),document.removeEventListener("mouseup",e.upfn),e.movefn=null,e.upfn=null}fG&&document.addEventListener("touchend",hxe,VG?{passive:!0}:!1);var n9=window.ShadyDOM&&window.ShadyDOM.noPatch?window.ShadyDOM.composedPath:e=>e.composedPath&&e.composedPath()||[],iE={},p_=[];function dxe(e,t){let r=document.elementFromPoint(e,t),n=r;for(;n&&n.shadowRoot&&!window.ShadyDOM;){let i=n;if(n=n.shadowRoot.elementFromPoint(e,t),i===n)break;n&&(r=n)}return r}function yp(e){let t=n9(e);return t.length>0?t[0]:e.target}function agt(e){let t,r=e.type,i=e.currentTarget[e9];if(!i)return;let o=i[r];if(!!o){if(!e[t9]&&(e[t9]={},r.slice(0,5)==="touch")){e=e;let a=e.changedTouches[0];if(r==="touchstart"&&e.touches.length===1&&(oa.touch.id=a.identifier),oa.touch.id!==a.identifier)return;BG||(r==="touchstart"||r==="touchmove")&&mxe(e)}if(t=e[t9],!t.skip){for(let a=0,s;a<p_.length;a++)s=p_[a],o[s.name]&&!t[s.name]&&s.flow&&s.flow.start.indexOf(e.type)>-1&&s.reset&&s.reset();for(let a=0,s;a<p_.length;a++)s=p_[a],o[s.name]&&!t[s.name]&&(t[s.name]=!0,s[r](e))}}}function mxe(e){let t=e.changedTouches[0],r=e.type;if(r==="touchstart")oa.touch.x=t.clientX,oa.touch.y=t.clientY,oa.touch.scrollDecided=!1;else if(r==="touchmove"){if(oa.touch.scrollDecided)return;oa.touch.scrollDecided=!0;let n=pxe(e),i=!1,o=Math.abs(oa.touch.x-t.clientX),a=Math.abs(oa.touch.y-t.clientY);e.cancelable&&(n==="none"?i=!0:n==="pan-x"?i=a>o:n==="pan-y"&&(i=o>a)),i?e.preventDefault():r9("track")}}function Tm(e,t,r){return iE[t]?(gxe(e,t,r),!0):!1}function sgt(e,t,r){return iE[t]?(_xe(e,t,r),!0):!1}function gxe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];a||(e[e9]=a={});for(let s=0,l,c;s<i.length;s++)l=i[s],!(igt&&HG(l)&&l!=="click")&&(c=a[l],c||(a[l]=c={_count:0}),c._count===0&&e.addEventListener(l,agt,ngt(l)),c[o]=(c[o]||0)+1,c._count=(c._count||0)+1);e.addEventListener(t,r),n.touchAction&&m_(e,n.touchAction)}function _xe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[e9];if(a)for(let s=0,l,c;s<i.length;s++)l=i[s],c=a[l],c&&c[o]&&(c[o]=(c[o]||1)-1,c._count=(c._count||1)-1,c._count===0&&e.removeEventListener(l,agt,ngt(l)));e.removeEventListener(t,r)}function UG(e){p_.push(e);for(let t=0;t<e.emits.length;t++)iE[e.emits[t]]=e}function yxe(e){for(let t=0,r;t<p_.length;t++){r=p_[t];for(let n=0,i;n<r.emits.length;n++)if(i=r.emits[n],i===e)return r}return null}function m_(e,t){BG&&e instanceof HTMLElement&&li.run(()=>{e.style.touchAction=t}),e[zG]=t}function qG(e,t,r){let n=new Event(t,{bubbles:!0,cancelable:!0,composed:!0});if(n.detail=r,ue(e).dispatchEvent(n),n.defaultPrevented){let i=r.preventer||r.sourceEvent;i&&i.preventDefault&&i.preventDefault()}}function r9(e){let t=yxe(e);t.info&&(t.info.prevent=!0)}UG({name:"downup",deps:["mousedown","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["down","up"],info:{movefn:null,upfn:null},reset:function(){Fx(this.info)},mousedown:function(e){if(!d_(e))return;let t=yp(e),r=this,n=function(a){d_(a)||(nE("up",t,a),Fx(r.info))},i=function(a){d_(a)&&nE("up",t,a),Fx(r.info)};ogt(this.info,n,i),nE("down",t,e)},touchstart:function(e){nE("down",yp(e),e.changedTouches[0],e)},touchend:function(e){nE("up",yp(e),e.changedTouches[0],e)}});function nE(e,t,r,n){!t||qG(t,e,{x:r.clientX,y:r.clientY,sourceEvent:r,preventer:n,prevent:function(i){return r9(i)}})}UG({name:"track",touchAction:"none",deps:["mousedown","touchstart","touchmove","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["track"],info:{x:0,y:0,state:"start",started:!1,moves:[],addMove:function(e){this.moves.length>nxe&&this.moves.shift(),this.moves.push(e)},movefn:null,upfn:null,prevent:!1},reset:function(){this.info.state="start",this.info.started=!1,this.info.moves=[],this.info.x=0,this.info.y=0,this.info.prevent=!1,Fx(this.info)},mousedown:function(e){if(!d_(e))return;let t=yp(e),r=this,n=function(a){let s=a.clientX,l=a.clientY;tgt(r.info,s,l)&&(r.info.state=r.info.started?a.type==="mouseup"?"end":"track":"start",r.info.state==="start"&&r9("tap"),r.info.addMove({x:s,y:l}),d_(a)||(r.info.state="end",Fx(r.info)),t&&OG(r.info,t,a),r.info.started=!0)},i=function(a){r.info.started&&n(a),Fx(r.info)};ogt(this.info,n,i),this.info.x=e.clientX,this.info.y=e.clientY},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchmove:function(e){let t=yp(e),r=e.changedTouches[0],n=r.clientX,i=r.clientY;tgt(this.info,n,i)&&(this.info.state==="start"&&r9("tap"),this.info.addMove({x:n,y:i}),OG(this.info,t,r),this.info.state="track",this.info.started=!0)},touchend:function(e){let t=yp(e),r=e.changedTouches[0];this.info.started&&(this.info.state="end",this.info.addMove({x:r.clientX,y:r.clientY}),OG(this.info,t,r))}});function tgt(e,t,r){if(e.prevent)return!1;if(e.started)return!0;let n=Math.abs(e.x-t),i=Math.abs(e.y-r);return n>=Zmt||i>=Zmt}function OG(e,t,r){if(!t)return;let n=e.moves[e.moves.length-2],i=e.moves[e.moves.length-1],o=i.x-e.x,a=i.y-e.y,s,l=0;n&&(s=i.x-n.x,l=i.y-n.y),qG(t,"track",{state:e.state,x:r.clientX,y:r.clientY,dx:o,dy:a,ddx:s,ddy:l,sourceEvent:r,hover:function(){return dxe(r.clientX,r.clientY)}})}UG({name:"tap",deps:["mousedown","click","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["click","touchend"]},emits:["tap"],info:{x:NaN,y:NaN,prevent:!1},reset:function(){this.info.x=NaN,this.info.y=NaN,this.info.prevent=!1},mousedown:function(e){d_(e)&&(this.info.x=e.clientX,this.info.y=e.clientY)},click:function(e){d_(e)&&egt(this.info,e)},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchend:function(e){egt(this.info,e.changedTouches[0],e)}});function egt(e,t,r){let n=Math.abs(t.clientX-e.x),i=Math.abs(t.clientY-e.y),o=yp(r||t);!o||lxe[o.localName]&&o.hasAttribute("disabled")||(isNaN(n)||isNaN(i)||n<=Kmt&&i<=Kmt||fxe(t))&&(e.prevent||qG(o,"tap",{x:t.clientX,y:t.clientY,sourceEvent:t,preventer:r}))}var lgt=yp;var vh=Nn(e=>{class t extends e{_addEventListenerToNode(n,i,o){Tm(n,i,o)||super._addEventListenerToNode(n,i,o)}_removeEventListenerFromNode(n,i,o){sgt(n,i,o)||super._removeEventListenerFromNode(n,i,o)}}return t});var vxe=/:host\(:dir\((ltr|rtl)\)\)/g,xxe=':host([dir="$1"])',bxe=/([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g,wxe=':host([dir="$2"]) $1',Sxe=/:dir\((?:ltr|rtl)\)/,ugt=Boolean(window.ShadyDOM&&window.ShadyDOM.inUse),oE=[],aE=null,GG="";function hgt(){GG=document.documentElement.getAttribute("dir")}function fgt(e){e.__autoDirOptOut||e.setAttribute("dir",GG)}function pgt(){hgt(),GG=document.documentElement.getAttribute("dir");for(let e=0;e<oE.length;e++)fgt(oE[e])}function Mxe(){aE&&aE.takeRecords().length&&pgt()}var dgt=Nn(e=>{ugt||aE||(hgt(),aE=new MutationObserver(pgt),aE.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]}));let t=HI(e);class r extends t{static _processStyleText(i,o){return i=t._processStyleText.call(this,i,o),!ugt&&Sxe.test(i)&&(i=this._replaceDirInCssText(i),this.__activateDir=!0),i}static _replaceDirInCssText(i){let o=i;return o=o.replace(vxe,xxe),o=o.replace(bxe,wxe),o}constructor(){super(),this.__autoDirOptOut=!1}ready(){super.ready(),this.__autoDirOptOut=this.hasAttribute("dir")}connectedCallback(){t.prototype.connectedCallback&&super.connectedCallback(),this.constructor.__activateDir&&(Mxe(),oE.push(this),fgt(this))}disconnectedCallback(){if(t.prototype.disconnectedCallback&&super.disconnectedCallback(),this.constructor.__activateDir){let i=oE.indexOf(this);i>-1&&oE.splice(i,1)}}}return r.__activateDir=!1,r});var i9=!1,mgt=[],ggt=[];function _gt(){i9=!0,requestAnimationFrame(function(){i9=!1,Exe(mgt),setTimeout(function(){Txe(ggt)})})}function Exe(e){for(;e.length;)ygt(e.shift())}function Txe(e){for(let t=0,r=e.length;t<r;t++)ygt(e.shift())}function ygt(e){let t=e[0],r=e[1],n=e[2];try{r.apply(t,n)}catch(i){setTimeout(()=>{throw i})}}function vgt(e,t,r){i9||_gt(),mgt.push([e,t,r])}function Cm(e,t,r){i9||_gt(),ggt.push([e,t,r])}function xgt(){document.body.removeAttribute("unresolved")}document.readyState==="interactive"||document.readyState==="complete"?xgt():window.addEventListener("DOMContentLoaded",xgt);function sE(e,t,r){return{index:e,removed:t,addedCount:r}}var bgt=0,wgt=1,WG=2,YG=3;function Cxe(e,t,r,n,i,o){let a=o-i+1,s=r-t+1,l=new Array(a);for(let c=0;c<a;c++)l[c]=new Array(s),l[c][0]=c;for(let c=0;c<s;c++)l[0][c]=c;for(let c=1;c<a;c++)for(let u=1;u<s;u++)if(jG(e[t+u-1],n[i+c-1]))l[c][u]=l[c-1][u-1];else{let h=l[c-1][u]+1,f=l[c][u-1]+1;l[c][u]=h<f?h:f}return l}function Axe(e){let t=e.length-1,r=e[0].length-1,n=e[t][r],i=[];for(;t>0||r>0;){if(t==0){i.push(WG),r--;continue}if(r==0){i.push(YG),t--;continue}let o=e[t-1][r-1],a=e[t-1][r],s=e[t][r-1],l;a<s?l=a<o?a:o:l=s<o?s:o,l==o?(o==n?i.push(bgt):(i.push(wgt),n=o),t--,r--):l==a?(i.push(YG),t--,n=a):(i.push(WG),r--,n=s)}return i.reverse(),i}function Pxe(e,t,r,n,i,o){let a=0,s=0,l,c=Math.min(r-t,o-i);if(t==0&&i==0&&(a=Ixe(e,n,c)),r==e.length&&o==n.length&&(s=Lxe(e,n,c-a)),t+=a,i+=a,r-=s,o-=s,r-t==0&&o-i==0)return[];if(t==r){for(l=sE(t,[],0);i<o;)l.removed.push(n[i++]);return[l]}else if(i==o)return[sE(t,[],r-t)];let u=Axe(Cxe(e,t,r,n,i,o));l=void 0;let h=[],f=t,p=i;for(let d=0;d<u.length;d++)switch(u[d]){case bgt:l&&(h.push(l),l=void 0),f++,p++;break;case wgt:l||(l=sE(f,[],0)),l.addedCount++,f++,l.removed.push(n[p]),p++;break;case WG:l||(l=sE(f,[],0)),l.addedCount++,f++;break;case YG:l||(l=sE(f,[],0)),l.removed.push(n[p]),p++;break}return l&&h.push(l),h}function Ixe(e,t,r){for(let n=0;n<r;n++)if(!jG(e[n],t[n]))return n;return r}function Lxe(e,t,r){let n=e.length,i=t.length,o=0;for(;o<r&&jG(e[--n],t[--i]);)o++;return o}function o9(e,t){return Pxe(e,0,e.length,t,0,t.length)}function jG(e,t){return e===t}function Bx(e){return e.localName==="slot"}var xh=class{static getFlattenedNodes(e){let t=ue(e);return Bx(e)?(e=e,t.assignedNodes({flatten:!0})):Array.from(t.childNodes).map(r=>Bx(r)?(r=r,ue(r).assignedNodes({flatten:!0})):[r]).reduce((r,n)=>r.concat(n),[])}constructor(e,t){this._shadyChildrenObserver=null,this._nativeChildrenObserver=null,this._connected=!1,this._target=e,this.callback=t,this._effectiveNodes=[],this._observer=null,this._scheduled=!1,this._boundSchedule=()=>{this._schedule()},this.connect(),this._schedule()}connect(){Bx(this._target)?this._listenSlots([this._target]):ue(this._target).children&&(this._listenSlots(ue(this._target).children),window.ShadyDOM?this._shadyChildrenObserver=window.ShadyDOM.observeChildren(this._target,e=>{this._processMutations(e)}):(this._nativeChildrenObserver=new MutationObserver(e=>{this._processMutations(e)}),this._nativeChildrenObserver.observe(this._target,{childList:!0}))),this._connected=!0}disconnect(){Bx(this._target)?this._unlistenSlots([this._target]):ue(this._target).children&&(this._unlistenSlots(ue(this._target).children),window.ShadyDOM&&this._shadyChildrenObserver?(window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver),this._shadyChildrenObserver=null):this._nativeChildrenObserver&&(this._nativeChildrenObserver.disconnect(),this._nativeChildrenObserver=null)),this._connected=!1}_schedule(){this._scheduled||(this._scheduled=!0,li.run(()=>this.flush()))}_processMutations(e){this._processSlotMutations(e),this.flush()}_processSlotMutations(e){if(e)for(let t=0;t<e.length;t++){let r=e[t];r.addedNodes&&this._listenSlots(r.addedNodes),r.removedNodes&&this._unlistenSlots(r.removedNodes)}}flush(){if(!this._connected)return!1;window.ShadyDOM&&ShadyDOM.flush(),this._nativeChildrenObserver?this._processSlotMutations(this._nativeChildrenObserver.takeRecords()):this._shadyChildrenObserver&&this._processSlotMutations(this._shadyChildrenObserver.takeRecords()),this._scheduled=!1;let e={target:this._target,addedNodes:[],removedNodes:[]},t=this.constructor.getFlattenedNodes(this._target),r=o9(t,this._effectiveNodes);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=0,s;a<o.removed.length&&(s=o.removed[a]);a++)e.removedNodes.push(s);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=o.index;a<o.index+o.addedCount;a++)e.addedNodes.push(t[a]);this._effectiveNodes=t;let n=!1;return(e.addedNodes.length||e.removedNodes.length)&&(n=!0,this.callback.call(this._target,e)),n}_listenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.addEventListener("slotchange",this._boundSchedule)}}_unlistenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.removeEventListener("slotchange",this._boundSchedule)}}};var ci=function(){let e,t;do e=window.ShadyDOM&&ShadyDOM.flush(),window.ShadyCSS&&window.ShadyCSS.ScopingShim&&window.ShadyCSS.ScopingShim.flush(),t=$mt();while(e||t)};var Hx=Element.prototype,kxe=Hx.matches||Hx.matchesSelector||Hx.mozMatchesSelector||Hx.msMatchesSelector||Hx.oMatchesSelector||Hx.webkitMatchesSelector,$G=function(e,t){return kxe.call(e,t)},Kr=class{constructor(t){window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.patch(t),this.node=t}observeNodes(t){return new xh(this.node,t)}unobserveNodes(t){t.disconnect()}notifyObserver(){}deepContains(t){if(ue(this.node).contains(t))return!0;let r=t,n=t.ownerDocument;for(;r&&r!==n&&r!==this.node;)r=ue(r).parentNode||ue(r).host;return r===this.node}getOwnerRoot(){return ue(this.node).getRootNode()}getDistributedNodes(){return this.node.localName==="slot"?ue(this.node).assignedNodes({flatten:!0}):[]}getDestinationInsertionPoints(){let t=[],r=ue(this.node).assignedSlot;for(;r;)t.push(r),r=ue(r).assignedSlot;return t}importNode(t,r){let n=this.node instanceof Document?this.node:this.node.ownerDocument;return ue(n).importNode(t,r)}getEffectiveChildNodes(){return xh.getFlattenedNodes(this.node)}queryDistributedElements(t){let r=this.getEffectiveChildNodes(),n=[];for(let i=0,o=r.length,a;i<o&&(a=r[i]);i++)a.nodeType===Node.ELEMENT_NODE&&$G(a,t)&&n.push(a);return n}get activeElement(){let t=this.node;return t._activeElement!==void 0?t._activeElement:t.activeElement}};function Rxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];e[n]=function(){return this.node[n].apply(this.node,arguments)}}}function Sgt(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},configurable:!0})}}function Nxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},set:function(i){this.node[n]=i},configurable:!0})}}var lE=class{constructor(t){this.event=t}get rootTarget(){return this.path[0]}get localTarget(){return this.event.target}get path(){return this.event.composedPath()}};Kr.prototype.cloneNode;Kr.prototype.appendChild;Kr.prototype.insertBefore;Kr.prototype.removeChild;Kr.prototype.replaceChild;Kr.prototype.setAttribute;Kr.prototype.removeAttribute;Kr.prototype.querySelector;Kr.prototype.querySelectorAll;Kr.prototype.parentNode;Kr.prototype.firstChild;Kr.prototype.lastChild;Kr.prototype.nextSibling;Kr.prototype.previousSibling;Kr.prototype.firstElementChild;Kr.prototype.lastElementChild;Kr.prototype.nextElementSibling;Kr.prototype.previousElementSibling;Kr.prototype.childNodes;Kr.prototype.children;Kr.prototype.classList;Kr.prototype.textContent;Kr.prototype.innerHTML;var XG=Kr;if(window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.noPatch&&window.ShadyDOM.Wrapper){class e extends window.ShadyDOM.Wrapper{}Object.getOwnPropertyNames(Kr.prototype).forEach(t=>{t!="activeElement"&&(e.prototype[t]=Kr.prototype[t])}),Sgt(e.prototype,["classList"]),XG=e,Object.defineProperties(lE.prototype,{localTarget:{get(){let t=this.event.currentTarget,r=t&&zt(t).getOwnerRoot(),n=this.path;for(let i=0;i<n.length;i++){let o=n[i];if(zt(o).getOwnerRoot()===r)return o}},configurable:!0},path:{get(){return window.ShadyDOM.composedPath(this.event)},configurable:!0}})}else Rxe(Kr.prototype,["cloneNode","appendChild","insertBefore","removeChild","replaceChild","setAttribute","removeAttribute","querySelector","querySelectorAll"]),Sgt(Kr.prototype,["parentNode","firstChild","lastChild","nextSibling","previousSibling","firstElementChild","lastElementChild","nextElementSibling","previousElementSibling","childNodes","children","classList"]),Nxe(Kr.prototype,["textContent","innerHTML","className"]);var zt=function(e){if(e=e||document,e instanceof XG||e instanceof lE)return e;let t=e.__domApi;return t||(e instanceof Event?t=new lE(e):t=new XG(e),e.__domApi=t),t};var KG=window.ShadyDOM,Mgt=window.ShadyCSS;function Egt(e,t){return ue(e).getRootNode()===t}function Tgt(e,t=!1){if(!KG||!Mgt||!KG.handlesDynamicScoping)return null;let r=Mgt.ScopingShim;if(!r)return null;let n=r.scopeForNode(e),i=ue(e).getRootNode(),o=a=>{if(!Egt(a,i))return;let s=Array.from(KG.nativeMethods.querySelectorAll.call(a,"*"));s.push(a);for(let l=0;l<s.length;l++){let c=s[l];if(!Egt(c,i))continue;let u=r.currentScopeForNode(c);u!==n&&(u!==""&&r.unscopeNode(c,u),r.scopeNode(c,n))}};if(o(e),t){let a=new MutationObserver(s=>{for(let l=0;l<s.length;l++){let c=s[l];for(let u=0;u<c.addedNodes.length;u++){let h=c.addedNodes[u];h.nodeType===Node.ELEMENT_NODE&&o(h)}}});return a.observe(e,{childList:!0,subtree:!0}),a}else return null}var ZG="disable-upgrade",JG=e=>{for(;e;){let t=Object.getOwnPropertyDescriptor(e,"observedAttributes");if(t)return t.get;e=Object.getPrototypeOf(e.prototype).constructor}return()=>[]},E1r=Nn(e=>{let t=Mm(e),r=JG(t);class n extends t{constructor(){super(),this.__isUpgradeDisabled}static get observedAttributes(){return r.call(this).concat(ZG)}_initializeProperties(){this.hasAttribute(ZG)?this.__isUpgradeDisabled=!0:super._initializeProperties()}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(o){return super._canApplyPropertyDefault(o)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(o))}attributeChangedCallback(o,a,s,l){o==ZG?this.__isUpgradeDisabled&&s==null&&(super._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&super.connectedCallback()):super.attributeChangedCallback(o,a,s,l)}connectedCallback(){this.__isUpgradeDisabled||super.connectedCallback()}disconnectedCallback(){this.__isUpgradeDisabled||super.disconnectedCallback()}}return n});var a9="disable-upgrade",Dxe=window.ShadyCSS,Gt=Nn(e=>{let t=vh(Mm(e)),r=UI?t:dgt(t),n=JG(r),i={x:"pan-x",y:"pan-y",none:"none",all:"auto"};class o extends r{constructor(){super(),this.isAttached,this.__boundListeners,this._debouncers,this.__isUpgradeDisabled,this.__needsAttributesAtConnected,this._legacyForceObservedAttributes}static get importMeta(){return this.prototype.importMeta}created(){}__attributeReaction(s,l,c){(this.__dataAttributes&&this.__dataAttributes[s]||s===a9)&&this.attributeChangedCallback(s,l,c,null)}setAttribute(s,l){if(qM&&!this._legacyForceObservedAttributes){let c=this.getAttribute(s);super.setAttribute(s,l),this.__attributeReaction(s,c,String(l))}else super.setAttribute(s,l)}removeAttribute(s){if(qM&&!this._legacyForceObservedAttributes){let l=this.getAttribute(s);super.removeAttribute(s),this.__attributeReaction(s,l,null)}else super.removeAttribute(s)}static get observedAttributes(){return qM&&!this.prototype._legacyForceObservedAttributes?(this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))||(this.__observedAttributes=[],VI(this.prototype)),this.__observedAttributes):n.call(this).concat(a9)}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(s){return super._canApplyPropertyDefault(s)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(s))}connectedCallback(){this.__needsAttributesAtConnected&&this._takeAttributes(),this.__isUpgradeDisabled||(super.connectedCallback(),this.isAttached=!0,this.attached())}attached(){}disconnectedCallback(){this.__isUpgradeDisabled||(super.disconnectedCallback(),this.isAttached=!1,this.detached())}detached(){}attributeChangedCallback(s,l,c,u){l!==c&&(s==a9?this.__isUpgradeDisabled&&c==null&&(this._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&this.connectedCallback()):(super.attributeChangedCallback(s,l,c,u),this.attributeChanged(s,l,c)))}attributeChanged(s,l,c){}_initializeProperties(){if(dp&&this.hasAttribute(a9))this.__isUpgradeDisabled=!0;else{let s=Object.getPrototypeOf(this);s.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",s))||(this._registered(),s.__hasRegisterFinished=!0),super._initializeProperties(),this.root=this,this.created(),qM&&!this._legacyForceObservedAttributes&&(this.hasAttributes()?this._takeAttributes():this.parentNode||(this.__needsAttributesAtConnected=!0)),this._applyListeners()}}_takeAttributes(){let s=this.attributes;for(let l=0,c=s.length;l<c;l++){let u=s[l];this.__attributeReaction(u.name,null,u.value)}}_registered(){}ready(){this._ensureAttributes(),super.ready()}_ensureAttributes(){}_applyListeners(){}serialize(s){return this._serializeValue(s)}deserialize(s,l){return this._deserializeValue(s,l)}reflectPropertyToAttribute(s,l,c){this._propertyToAttribute(s,l,c)}serializeValueToAttribute(s,l,c){this._valueToNodeAttribute(c||this,s,l)}extend(s,l){if(!(s&&l))return s||l;let c=Object.getOwnPropertyNames(l);for(let u=0,h;u<c.length&&(h=c[u]);u++){let f=Object.getOwnPropertyDescriptor(l,h);f&&Object.defineProperty(s,h,f)}return s}mixin(s,l){for(let c in l)s[c]=l[c];return s}chainObject(s,l){return s&&l&&s!==l&&(s.__proto__=l),s}instanceTemplate(s){let l=this.constructor._contentForTemplate(s);return document.importNode(l,!0)}fire(s,l,c){c=c||{},l=l==null?{}:l;let u=new Event(s,{bubbles:c.bubbles===void 0?!0:c.bubbles,cancelable:Boolean(c.cancelable),composed:c.composed===void 0?!0:c.composed});u.detail=l;let h=c.node||this;return ue(h).dispatchEvent(u),u}listen(s,l,c){s=s||this;let u=this.__boundListeners||(this.__boundListeners=new WeakMap),h=u.get(s);h||(h={},u.set(s,h));let f=l+c;h[f]||(h[f]=this._addMethodEventListenerToNode(s,l,c,this))}unlisten(s,l,c){s=s||this;let u=this.__boundListeners&&this.__boundListeners.get(s),h=l+c,f=u&&u[h];f&&(this._removeEventListenerFromNode(s,l,f),u[h]=null)}setScrollDirection(s,l){m_(l||this,i[s]||"auto")}$$(s){return this.root.querySelector(s)}get domHost(){let s=ue(this).getRootNode();return s instanceof DocumentFragment?s.host:s}distributeContent(){let l=zt(this);window.ShadyDOM&&l.shadowRoot&&ShadyDOM.flush()}getEffectiveChildNodes(){return zt(this).getEffectiveChildNodes()}queryDistributedElements(s){return zt(this).queryDistributedElements(s)}getEffectiveChildren(){return this.getEffectiveChildNodes().filter(function(l){return l.nodeType===Node.ELEMENT_NODE})}getEffectiveTextContent(){let s=this.getEffectiveChildNodes(),l=[];for(let c=0,u;u=s[c];c++)u.nodeType!==Node.COMMENT_NODE&&l.push(u.textContent);return l.join("")}queryEffectiveChildren(s){let l=this.queryDistributedElements(s);return l&&l[0]}queryAllEffectiveChildren(s){return this.queryDistributedElements(s)}getContentChildNodes(s){let l=this.root.querySelector(s||"slot");return l?zt(l).getDistributedNodes():[]}getContentChildren(s){return this.getContentChildNodes(s).filter(function(c){return c.nodeType===Node.ELEMENT_NODE})}isLightDescendant(s){let l=this;return l!==s&&ue(l).contains(s)&&ue(l).getRootNode()===ue(s).getRootNode()}isLocalDescendant(s){return this.root===ue(s).getRootNode()}scopeSubtree(s,l=!1){return Tgt(s,l)}getComputedStyleValue(s){return Dxe.getComputedStyleValue(this,s)}debounce(s,l,c){return this._debouncers=this._debouncers||{},this._debouncers[s]=sr.debounce(this._debouncers[s],c>0?mo.after(c):li,l.bind(this))}isDebouncerActive(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];return!!(l&&l.isActive())}flushDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.flush()}cancelDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.cancel()}async(s,l){return l>0?mo.run(s.bind(this),l):~li.run(s.bind(this))}cancelAsync(s){s<0?li.cancel(~s):mo.cancel(s)}create(s,l){let c=document.createElement(s);if(l)if(c.setProperties)c.setProperties(l);else for(let u in l)c[u]=l[u];return c}elementMatches(s,l){return $G(l||this,s)}toggleAttribute(s,l){let c=this;return arguments.length===3&&(c=arguments[2]),arguments.length==1&&(l=!c.hasAttribute(s)),l?(ue(c).setAttribute(s,""),!0):(ue(c).removeAttribute(s),!1)}toggleClass(s,l,c){c=c||this,arguments.length==1&&(l=!c.classList.contains(s)),l?c.classList.add(s):c.classList.remove(s)}transform(s,l){l=l||this,l.style.webkitTransform=s,l.style.transform=s}translate3d(s,l,c,u){u=u||this,this.transform("translate3d("+s+","+l+","+c+")",u)}arrayDelete(s,l){let c;if(Array.isArray(s)){if(c=s.indexOf(l),c>=0)return s.splice(c,1)}else if(c=No(this,s).indexOf(l),c>=0)return this.splice(s,c,1);return null}_logger(s,l){switch(Array.isArray(l)&&l.length===1&&Array.isArray(l[0])&&(l=l[0]),s){case"log":case"warn":case"error":console[s](...l)}}_log(...s){this._logger("log",s)}_warn(...s){this._logger("warn",s)}_error(...s){this._logger("error",s)}_logf(s,...l){return["[%s::%s]",this.is,s,...l]}}return o.prototype.is="",o});var Am=Ee(Oe(),1);function bh(e,t){let r=0,n=0;for(;;){if(r===e.length)return n===t.length?0:-1;if(n===t.length)return 1;if(g_(e[r])&&g_(t[n])){let i=r,o=n;r=Cgt(e,r+1),n=Cgt(t,n+1);let a=parseFloat(e.slice(i,r)),s=parseFloat(t.slice(o,n));if(a<s)return-1;if(a>s)return 1;continue}if(QG(e[r])){if(!QG(t[n]))return-1}else{if(QG(t[n]))return 1;if(e[r]<t[n])return-1;if(e[r]>t[n])return 1}r++,n++}}function Cgt(e,t){let r;(function(i){i[i.NATURAL=0]="NATURAL",i[i.REAL=1]="REAL",i[i.EXPONENT_SIGN=2]="EXPONENT_SIGN",i[i.EXPONENT=3]="EXPONENT"})(r||(r={}));let n=r.NATURAL;for(;t<e.length;t++)if(n===r.NATURAL){if(e[t]===".")n=r.REAL;else if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!g_(e[t]))break}else if(n===r.REAL){if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!g_(e[t]))break}else if(n===r.EXPONENT_SIGN)if(g_(e[t])||e[t]==="+"||e[t]==="-")n=r.EXPONENT;else break;else if(n===r.EXPONENT&&!g_(e[t]))break;return t}function g_(e){return"0"<=e&&e<="9"}function QG(e){return e==="/"||e==="_"||g_(e)}var Oxe=[];function zxe(e){return Am.keys(e).sort(bh)}function $i(e){return Am.union.apply(null,Am.values(e)).sort(bh)}function Fxe(e,t){let r=[];return t.forEach(n=>r=r.concat(e[n])),Am.uniq(r).sort(bh)}var Pgt="X-TensorBoard-Feature-Flags",Igt="tensorBoardFeatureFlags";var tW={};Zs(tW,{getFeatureFlags:()=>Hxe,getFeatureFlagsToSendToServer:()=>cE,initializeFeatureFlags:()=>Lgt,setFeatureFlags:()=>Bxe});var s9,l9;Lgt();function Lgt(){s9=null,l9=null}function Bxe(e,t){s9=e,l9=t}function Hxe(){if(s9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return s9}function cE(){if(l9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return l9}var c9=class extends Error{constructor(){super(...arguments),this.name="RequestCancellationError"}},Vx=class extends Error{constructor(t){super(t),this.name="InvalidRequestOptionsError",Object.setPrototypeOf(this,Vx.prototype)}},uE=class extends Error{constructor(t,r){super(),this.message=`RequestNetworkError: ${t.status} at ${r}`,this.name="RequestNetworkError",this.req=t,this.url=r}},Pm;(function(e){e.GET="GET",e.POST="POST"})(Pm||(Pm={}));var Ux=class{validate(){if(this.methodType===Pm.GET&&this.body)throw new Vx("body must be missing for a GET request.")}},Ae=class{constructor(t=1e3,r=3){this._queue=[],this._nActiveRequests=0,this._nSimultaneousRequests=t,this._maxRetries=r}request(t,r){let n=Uxe(r);return this.requestWithOptions(t,n)}requestWithOptions(t,r){return r.validate(),new Promise((i,o)=>{let a={resolve:i,reject:o};this._queue.push(a),this.launchRequests()}).then(()=>this.promiseWithRetries(t,this._maxRetries,r)).then(i=>(this._nActiveRequests--,this.launchRequests(),i),i=>(i.name==="RequestNetworkError"&&(this._nActiveRequests--,this.launchRequests()),Promise.reject(i)))}fetch(t,r){return new Promise((n,i)=>{let o={resolve:n,reject:i};this._queue.push(o),this.launchRequests()}).then(()=>{let n=1;return new Promise(i=>{let o=()=>{fetch(t,r).then(a=>{if(!a.ok&&this._maxRetries>n){n++,o();return}i(a),this._nActiveRequests--,this.launchRequests()})};o()})})}clearQueue(){var t;for(;this._queue.length>0;)(t=this._queue.pop())==null||t.reject(new c9("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&this._queue.length>0;)this._nActiveRequests++,this._queue.pop().resolve(void 0)}promiseWithRetries(t,r,n){var i=a=>a,o=a=>r>0?this.promiseWithRetries(t,r-1,n):Promise.reject(a);return this._promiseFromUrl(t,n).then(i,o)}_promiseFromUrl(t,r){return new Promise((n,i)=>{let o=Vxe(r.methodType,t,r.withCredentials,r.contentType);o.setRequestHeader(Pgt,JSON.stringify(cE())),o.onload=function(){o.status===200?n(JSON.parse(o.responseText)):i(new uE(o,t))},o.onerror=function(){i(new uE(o,t))},r.body?o.send(r.body):o.send()})}};function Vxe(e,t,r,n){let i=new XMLHttpRequest;return i.open(e,t),r&&(i.withCredentials=r),n&&i.setRequestHeader("Content-Type",n),i}function Uxe(e){let t=new Ux;return e?(t.methodType=Pm.POST,t.body=qxe(e),t):(t.methodType=Pm.GET,t)}function qxe(e){let t=new FormData;for(let[r,n]of Object.entries(e)){let i=Array.isArray(n)?n:[n];for(let o of i)t.append(r,o)}return t}var kgt="experimentalPlugin",Gxe=new URLSearchParams(window.location.search),Wxe=Rgt();function Rgt(){return{environment:()=>qx("/environment"),experiments:()=>qx("/experiments"),pluginRoute:(e,t,r)=>qx(`/plugin/${e}${t}`,r),pluginRouteForSrc:(e,t,r=new URLSearchParams)=>{let n=cE();return Object.keys(n).length>0&&r.append(Igt,JSON.stringify(n)),qx(`/plugin/${e}${t}`,r)},pluginsListing:()=>qx("/plugins_listing",Ngt({[kgt]:Gxe.getAll(kgt)})),runs:()=>qx("/runs")}}function _e(){return Wxe}function qx(e,t=new URLSearchParams){let r="data"+e;return String(t)&&(r+=(e.includes("?")?"&":"?")+String(t)),r}function Ngt(e={}){let t=Object.keys(e).sort().filter(n=>e[n]),r=new URLSearchParams;return t.forEach(n=>{let i=e[n];(Array.isArray(i)?i:[i]).forEach(a=>r.append(n,a))}),r}var u9=Ee(Oe(),1);var Da;(function(e){e[e.SEARCH_RESULTS=0]="SEARCH_RESULTS",e[e.PREFIX_GROUP=1]="PREFIX_GROUP"})(Da||(Da={}));function Yxe(e,t){let r=(()=>{try{return new RegExp(t)}catch(n){return null}})();return{name:t,metadata:{type:Da.SEARCH_RESULTS,validRegex:!!r,universalRegex:t===".*"},items:r?e.filter(n=>n.match(r)):[]}}function jxe(e,t="/"){let r=[],n={};return e.forEach(i=>{let o=i.indexOf(t),a=o>=0?i.slice(0,o):i;if(!n[a]){let s={name:a,metadata:{type:Da.PREFIX_GROUP},items:[]};n[a]=s,r.push(s)}n[a].items.push(i)}),r}function Xxe(e,t=""){let r=[Yxe(e,t)],n=jxe(e);return Array().concat(r,n)}function hE(e,t,r){let n=$i(e),i=Xxe(n,r),o=$xe(u9.pick(e,t));return i.map(({name:a,metadata:s,items:l})=>({name:a,metadata:s,items:l.map(c=>({tag:c,runs:(o.get(c)||[]).slice()}))}))}function $xe(e){let t=new Map;return Object.keys(e).forEach(r=>{e[r].forEach(n=>{let i=t.get(n)||[];i.push(r),t.set(n,i)})}),t}function Kxe(e,t){let r=bh(e.tag,t.tag);return r!=0?r:bh(e.run,t.run)}function Ql(e,t,r){let n=hE(e,t,r);function i(o){let a=u9.flatten(o.items.map(({tag:s,runs:l})=>l.map(c=>({tag:s,run:c}))));return a.sort(Kxe),{name:o.name,metadata:o.metadata,items:a}}return n.map(i)}var cW={};Zs(cW,{IronResizableBehavior:()=>Qs});var Zxe={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,listeners:!0,hostAttributes:!0},Fgt={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,behaviors:!0,_noAccessors:!0},Jxe=Object.assign({listeners:!0,hostAttributes:!0,properties:!0,observers:!0},Fgt);function Qxe(e,t,r){let n=e._noAccessors,i=Object.getOwnPropertyNames(e);for(let o=0;o<i.length;o++){let a=i[o];if(!(a in r))if(n)t[a]=e[a];else{let s=Object.getOwnPropertyDescriptor(e,a);s&&(s.configurable=!0,Object.defineProperty(t,a,s))}}}function Bgt(e,t){return Ugt({},Gt(t),e)}function tbe(e,t,r){for(let n=0;n<t.length;n++)Hgt(e,t[n],r,Jxe)}function Hgt(e,t,r,n){Qxe(t,e,n);for(let i in Zxe)t[i]&&(r[i]=r[i]||[],r[i].push(t[i]))}function Vgt(e,t,r){t=t||[];for(let n=e.length-1;n>=0;n--){let i=e[n];i?Array.isArray(i)?Vgt(i,t):t.indexOf(i)<0&&(!r||r.indexOf(i)<0)&&t.unshift(i):console.warn("behavior is null, check for missing or 404 import")}return t}function Ogt(e,t){for(let r in t){let n=e[r],i=t[r];!("value"in i)&&n&&"value"in n?e[r]=Object.assign({value:n.value},i):e[r]=i}}var zgt=Gt(HTMLElement);function Ugt(e,t,r){let n,i={};class o extends t{static _finalizeClass(){if(!this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom",this)))t._finalizeClass.call(this);else{if(n)for(let l=0,c;l<n.length;l++)c=n[l],c.properties&&this.createProperties(c.properties),c.observers&&this.createObservers(c.observers,c.properties);e.properties&&this.createProperties(e.properties),e.observers&&this.createObservers(e.observers,e.properties),this._prepareTemplate()}}static get properties(){let l={};if(n)for(let c=0;c<n.length;c++)Ogt(l,n[c].properties);return Ogt(l,e.properties),l}static get observers(){let l=[];if(n)for(let c=0,u;c<n.length;c++)u=n[c],u.observers&&(l=l.concat(u.observers));return e.observers&&(l=l.concat(e.observers)),l}created(){super.created();let l=i.created;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}_registered(){let l=o.prototype;if(!l.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",l))){l.__hasRegisterFinished=!0,super._registered(),dp&&a(l);let c=Object.getPrototypeOf(this),u=i.beforeRegister;if(u)for(let h=0;h<u.length;h++)u[h].call(c);if(u=i.registered,u)for(let h=0;h<u.length;h++)u[h].call(c)}}_applyListeners(){super._applyListeners();let l=i.listeners;if(l)for(let c=0;c<l.length;c++){let u=l[c];if(u)for(let h in u)this._addMethodEventListenerToNode(this,h,u[h])}}_ensureAttributes(){let l=i.hostAttributes;if(l)for(let c=l.length-1;c>=0;c--){let u=l[c];for(let h in u)this._ensureAttribute(h,u[h])}super._ensureAttributes()}ready(){super.ready();let l=i.ready;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attached(){super.attached();let l=i.attached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}detached(){super.detached();let l=i.detached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attributeChanged(l,c,u){super.attributeChanged();let h=i.attributeChanged;if(h)for(let f=0;f<h.length;f++)h[f].call(this,l,c,u)}}if(r){Array.isArray(r)||(r=[r]);let s=t.prototype.behaviors;n=Vgt(r,null,s),o.prototype.behaviors=s?s.concat(r):n}let a=s=>{n&&tbe(s,n,i),Hgt(s,e,i,Fgt)};return dp||a(o.prototype),o.generatedFrom=e,o}var h9=function(e,t){e||console.warn("Polymer.Class requires `info` argument");let r=t?t(zgt):zgt;return r=Ugt(e,r,e.behaviors),r.is=r.prototype.is=e.is,r};var Yt=function(e){let t;return typeof e=="function"?t=e:t=Yt.Class(e),e._legacyForceObservedAttributes&&(t.prototype._legacyForceObservedAttributes=e._legacyForceObservedAttributes),customElements.define(t.is,t),t};Yt.Class=h9;function eW(e,t,r,n,i){let o;i&&(o=typeof r=="object"&&r!==null,o&&(n=e.__dataTemp[t]));let a=n!==r&&(n===n||r===r);return o&&a&&(e.__dataTemp[t]=r),a}var Gx=Nn(e=>{class t extends e{_shouldPropertyChange(n,i,o){return eW(this,n,i,o,!0)}}return t}),f9=Nn(e=>{class t extends e{static get properties(){return{mutableData:Boolean}}_shouldPropertyChange(n,i,o){return eW(this,n,i,o,this.mutableData)}}return t});Gx._mutablePropertyChange=eW;var rW=null;function nW(){return rW}nW.prototype=Object.create(HTMLTemplateElement.prototype,{constructor:{value:nW,writable:!0}});var Ggt=h_(nW),ebe=Gx(Ggt);function rbe(e,t){rW=e,Object.setPrototypeOf(e,t.prototype),new t,rW=null}var nbe=h_(class{});function iW(e,t){for(let r=0;r<t.length;r++){let n=t[r];if(Boolean(e)!=Boolean(n.__hideTemplateChildren__))if(n.nodeType===Node.TEXT_NODE)e?(n.__polymerTextContent__=n.textContent,n.textContent=""):n.textContent=n.__polymerTextContent__;else if(n.localName==="slot")if(e)n.__polymerReplaced__=document.createComment("hidden-slot"),ue(ue(n).parentNode).replaceChild(n.__polymerReplaced__,n);else{let i=n.__polymerReplaced__;i&&ue(ue(i).parentNode).replaceChild(n,i)}else n.style&&(e?(n.__polymerDisplay__=n.style.display,n.style.display="none"):n.style.display=n.__polymerDisplay__);n.__hideTemplateChildren__=e,n._showHideChildren&&n._showHideChildren(e)}}var wh=class extends nbe{constructor(t){super(),this._configureProperties(t),this.root=this._stampTemplate(this.__dataHost);let r=[];this.children=r;for(let i=this.root.firstChild;i;i=i.nextSibling)r.push(i),i.__templatizeInstance=this;this.__templatizeOwner&&this.__templatizeOwner.__hideTemplateChildren__&&this._showHideChildren(!0);let n=this.__templatizeOptions;(t&&n.instanceProps||!n.instanceProps)&&this._enableProperties()}_configureProperties(t){if(this.__templatizeOptions.forwardHostProp)for(let n in this.__hostProps)this._setPendingProperty(n,this.__dataHost["_host_"+n]);for(let n in t)this._setPendingProperty(n,t[n])}forwardHostProp(t,r){this._setPendingPropertyOrPath(t,r,!1,!0)&&this.__dataHost._enqueueClient(this)}_addEventListenerToNode(t,r,n){if(this._methodHost&&this.__templatizeOptions.parentModel)this._methodHost._addEventListenerToNode(t,r,i=>{i.model=this,n(i)});else{let i=this.__dataHost.__dataHost;i&&i._addEventListenerToNode(t,r,n)}}_showHideChildren(t){iW(t,this.children)}_setUnmanagedPropertyToNode(t,r,n){t.__hideTemplateChildren__&&t.nodeType==Node.TEXT_NODE&&r=="textContent"?t.__polymerTextContent__=n:super._setUnmanagedPropertyToNode(t,r,n)}get parentModel(){let t=this.__parentModel;if(!t){let r;t=this;do t=t.__dataHost.__dataHost;while((r=t.__templatizeOptions)&&!r.parentModel);this.__parentModel=t}return t}dispatchEvent(t){return!0}};wh.prototype.__dataHost;wh.prototype.__templatizeOptions;wh.prototype._methodHost;wh.prototype.__templatizeOwner;wh.prototype.__hostProps;var ibe=Gx(wh);function qgt(e){let t=e.__dataHost;return t&&t._methodHost||t}function obe(e,t,r){let n=r.mutableData?ibe:wh;tc.mixin&&(n=tc.mixin(n));let i=class extends n{};return i.prototype.__templatizeOptions=r,i.prototype._bindTemplate(e),lbe(i,e,t,r),i}function abe(e,t,r,n){let i=r.forwardHostProp;if(i&&t.hasHostProps){let o=e.localName=="template",a=t.templatizeTemplateClass;if(!a){if(o){let l=r.mutableData?ebe:Ggt;class c extends l{}a=t.templatizeTemplateClass=c}else{let l=e.constructor;class c extends l{}a=t.templatizeTemplateClass=c}let s=t.hostProps;for(let l in s)a.prototype._addPropertyEffect("_host_"+l,a.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,{fn:sbe(l,i)}),a.prototype._createNotifyingProperty("_host_"+l);LI&&n&&hbe(t,r,n)}if(e.__dataProto&&Object.assign(e.__data,e.__dataProto),o)rbe(e,a),e.__dataTemp={},e.__dataPending=null,e.__dataOld=null,e._enableProperties();else{Object.setPrototypeOf(e,a.prototype);let s=t.hostProps;for(let l in s)if(l="_host_"+l,l in e){let c=e[l];delete e[l],e.__data[l]=c}}}}function sbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,i.substring(6),o[i])}}function lbe(e,t,r,n){let i=r.hostProps||{};for(let o in n.instanceProps){delete i[o];let a=n.notifyInstanceProp;a&&e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:cbe(o,a)})}if(n.forwardHostProp&&t.__dataHost)for(let o in i)r.hasHostProps||(r.hasHostProps=!0),e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:ube()})}function cbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,n,i,o[i])}}function ube(){return function(t,r,n){t.__dataHost._setPendingPropertyOrPath("_host_"+r,n[r],!0,!0)}}function tc(e,t,r){if(iu&&!qgt(e))throw new Error("strictTemplatePolicy: template owner not trusted");if(r=r||{},e.__templatizeOwner)throw new Error("A <template> can only be templatized once");e.__templatizeOwner=t;let i=(t?t.constructor:wh)._parseTemplate(e),o=i.templatizeInstanceClass;o||(o=obe(e,i,r),i.templatizeInstanceClass=o);let a=qgt(e);abe(e,i,r,a);let s=class extends o{};return s.prototype._methodHost=a,s.prototype.__dataHost=e,s.prototype.__templatizeOwner=t,s.prototype.__hostProps=i.hostProps,s=s,s}function hbe(e,t,r){let n=r.constructor._properties,{propertyEffects:i}=e,{instanceProps:o}=t;for(let a in i)if(!n[a]&&!(o&&o[a])){let s=i[a];for(let l=0;l<s.length;l++){let{part:c}=s[l].info;if(!(c.signature&&c.signature.static)){console.warn(`Property '${a}' used in template but not declared in 'properties'; attribute will not be observed.`);break}}}}function p9(e,t){let r;for(;t;)if(r=t.__dataHost?t:t.__templatizeInstance)if(r.__dataHost!=e)t=r.__dataHost;else return r;else t=ue(t).parentNode;return null}var Wgt={templatize(e,t){this._templatizerTemplate=e,this.ctor=tc(e,this,{mutableData:Boolean(t),parentModel:this._parentModel,instanceProps:this._instanceProps,forwardHostProp:this._forwardHostPropV2,notifyInstanceProp:this._notifyInstancePropV2})},stamp(e){return new this.ctor(e)},modelForElement(e){return p9(this._templatizerTemplate,e)}};var Ygt=!1;function Wx(){if(dp&&!u_){if(!Ygt){Ygt=!0;let e=document.createElement("style");e.textContent="dom-bind,dom-if,dom-repeat{display:none;}",document.head.appendChild(e)}return!0}return!1}var fbe=vh(f9(h_(HTMLElement))),oW=class extends fbe{static get observedAttributes(){return["mutable-data"]}constructor(){if(super(),iu)throw new Error("strictTemplatePolicy: dom-bind not allowed");this.root=null,this.$=null,this.__children=null}attributeChangedCallback(t,r,n,i){this.mutableData=!0}connectedCallback(){Wx()||(this.style.display="none"),this.render()}disconnectedCallback(){this.__removeChildren()}__insertChildren(){ue(ue(this).parentNode).insertBefore(this.root,this)}__removeChildren(){if(this.__children)for(let t=0;t<this.__children.length;t++)this.root.appendChild(this.__children[t])}render(){let t;if(!this.__children){if(t=t||this.querySelector("template"),!t){let r=new MutationObserver(()=>{if(t=this.querySelector("template"),t)r.disconnect(),this.render();else throw new Error("dom-bind requires a <template> child")});r.observe(this,{childList:!0});return}this.root=this._stampTemplate(t),this.$=this.root.$,this.__children=[];for(let r=this.root.firstChild;r;r=r.nextSibling)this.__children[this.__children.length]=r;this._enableProperties()}this.__insertChildren(),this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}};customElements.define("dom-bind",oW);var pbe=f9(mt),d9=class extends pbe{static get is(){return"dom-repeat"}static get template(){return null}static get properties(){return{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},itemsIndexAs:{type:String,value:"itemsIndex"},sort:{type:Function,observer:"__sortChanged"},filter:{type:Function,observer:"__filterChanged"},observe:{type:String,observer:"__observeChanged"},delay:Number,renderedItemCount:{type:Number,notify:!UM,readOnly:!0},initialCount:{type:Number},targetFramerate:{type:Number,value:20},_targetFrameTime:{type:Number,computed:"__computeFrameTime(targetFramerate)"},notifyDomChange:{type:Boolean},reuseChunkedInstances:{type:Boolean}}}static get observers(){return["__itemsChanged(items.*)"]}constructor(){super(),this.__instances=[],this.__renderDebouncer=null,this.__itemsIdxToInstIdx={},this.__chunkCount=null,this.__renderStartTime=null,this.__itemsArrayChanged=!1,this.__shouldMeasureChunk=!1,this.__shouldContinueChunking=!1,this.__chunkingId=0,this.__sortFn=null,this.__filterFn=null,this.__observePaths=null,this.__ctor=null,this.__isDetached=!0,this.template=null,this._templateInfo}disconnectedCallback(){super.disconnectedCallback(),this.__isDetached=!0;for(let t=0;t<this.__instances.length;t++)this.__detachInstance(t)}connectedCallback(){if(super.connectedCallback(),Wx()||(this.style.display="none"),this.__isDetached){this.__isDetached=!1;let t=ue(ue(this).parentNode);for(let r=0;r<this.__instances.length;r++)this.__attachInstance(r,t)}}__ensureTemplatized(){if(!this.__ctor){let t=this,r=this.template=t._templateInfo?t:this.querySelector("template");if(!r){let i=new MutationObserver(()=>{if(this.querySelector("template"))i.disconnect(),this.__render();else throw new Error("dom-repeat requires a <template> child")});return i.observe(this,{childList:!0}),!1}let n={};n[this.as]=!0,n[this.indexAs]=!0,n[this.itemsIndexAs]=!0,this.__ctor=tc(r,this,{mutableData:this.mutableData,parentModel:!0,instanceProps:n,forwardHostProp:function(i,o){let a=this.__instances;for(let s=0,l;s<a.length&&(l=a[s]);s++)l.forwardHostProp(i,o)},notifyInstanceProp:function(i,o,a){if(OI(this.as,o)){let s=i[this.itemsIndexAs];o==this.as&&(this.items[s]=a);let l=mp(this.as,`${JSCompiler_renameProperty("items",this)}.${s}`,o);this.notifyPath(l,a)}}})}return!0}__getMethodHost(){return this.__dataHost._methodHost||this.__dataHost}__functionFromPropertyValue(t){if(typeof t=="string"){let r=t,n=this.__getMethodHost();return function(){return n[r].apply(n,arguments)}}return t}__sortChanged(t){this.__sortFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__filterChanged(t){this.__filterFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__computeFrameTime(t){return Math.ceil(1e3/t)}__observeChanged(){this.__observePaths=this.observe&&this.observe.replace(".*",".").split(" ")}__handleObservedPaths(t){if(this.__sortFn||this.__filterFn){if(!t)this.__debounceRender(this.__render,this.delay);else if(this.__observePaths){let r=this.__observePaths;for(let n=0;n<r.length;n++)t.indexOf(r[n])===0&&this.__debounceRender(this.__render,this.delay)}}}__itemsChanged(t){this.items&&!Array.isArray(this.items)&&console.warn("dom-repeat expected array for `items`, found",this.items),this.__handleItemPath(t.path,t.value)||(t.path==="items"&&(this.__itemsArrayChanged=!0),this.__debounceRender(this.__render))}__debounceRender(t,r=0){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,r>0?mo.after(r):li,t.bind(this)),Jl(this.__renderDebouncer)}render(){this.__debounceRender(this.__render),ci()}__render(){if(!this.__ensureTemplatized())return;let t=this.items||[],r=this.__sortAndFilterItems(t),n=this.__calculateLimit(r.length);this.__updateInstances(t,n,r),this.initialCount&&(this.__shouldMeasureChunk||this.__shouldContinueChunking)&&(cancelAnimationFrame(this.__chunkingId),this.__chunkingId=requestAnimationFrame(()=>this.__continueChunking())),this._setRenderedItemCount(this.__instances.length),(!UM||this.notifyDomChange)&&this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}__sortAndFilterItems(t){let r=new Array(t.length);for(let n=0;n<t.length;n++)r[n]=n;return this.__filterFn&&(r=r.filter((n,i,o)=>this.__filterFn(t[n],i,o))),this.__sortFn&&r.sort((n,i)=>this.__sortFn(t[n],t[i])),r}__calculateLimit(t){let r=t,n=this.__instances.length;if(this.initialCount){let i;!this.__chunkCount||this.__itemsArrayChanged&&!this.reuseChunkedInstances?(r=Math.min(t,this.initialCount),i=Math.max(r-n,0),this.__chunkCount=i||1):(i=Math.min(Math.max(t-n,0),this.__chunkCount),r=Math.min(n+i,t)),this.__shouldMeasureChunk=i===this.__chunkCount,this.__shouldContinueChunking=r<t,this.__renderStartTime=performance.now()}return this.__itemsArrayChanged=!1,r}__continueChunking(){if(this.__shouldMeasureChunk){let t=performance.now()-this.__renderStartTime,r=this._targetFrameTime/t;this.__chunkCount=Math.round(this.__chunkCount*r)||1}this.__shouldContinueChunking&&this.__debounceRender(this.__render)}__updateInstances(t,r,n){let i=this.__itemsIdxToInstIdx={},o;for(o=0;o<r;o++){let a=this.__instances[o],s=n[o],l=t[s];i[s]=o,a?(a._setPendingProperty(this.as,l),a._setPendingProperty(this.indexAs,o),a._setPendingProperty(this.itemsIndexAs,s),a._flushProperties()):this.__insertInstance(l,o,s)}for(let a=this.__instances.length-1;a>=o;a--)this.__detachAndRemoveInstance(a)}__detachInstance(t){let r=this.__instances[t],n=ue(r.root);for(let i=0;i<r.children.length;i++){let o=r.children[i];n.appendChild(o)}return r}__attachInstance(t,r){let n=this.__instances[t];r.insertBefore(n.root,this)}__detachAndRemoveInstance(t){this.__detachInstance(t),this.__instances.splice(t,1)}__stampInstance(t,r,n){let i={};return i[this.as]=t,i[this.indexAs]=r,i[this.itemsIndexAs]=n,new this.__ctor(i)}__insertInstance(t,r,n){let i=this.__stampInstance(t,r,n),o=this.__instances[r+1],a=o?o.children[0]:this;return ue(ue(this).parentNode).insertBefore(i.root,a),this.__instances[r]=i,i}_showHideChildren(t){for(let r=0;r<this.__instances.length;r++)this.__instances[r]._showHideChildren(t)}__handleItemPath(t,r){let n=t.slice(6),i=n.indexOf("."),o=i<0?n:n.substring(0,i);if(o==parseInt(o,10)){let a=i<0?"":n.substring(i+1);this.__handleObservedPaths(a);let s=this.__itemsIdxToInstIdx[o],l=this.__instances[s];if(l){let c=this.as+(a?"."+a:"");l._setPendingPropertyOrPath(c,r,!1,!0),l._flushProperties()}return!0}}itemForElement(t){let r=this.modelForElement(t);return r&&r[this.as]}indexForElement(t){let r=this.modelForElement(t);return r&&r[this.indexAs]}modelForElement(t){return p9(this.template,t)}};customElements.define(d9.is,d9);var m9=class extends mt{static get is(){return"dom-if"}static get template(){return null}static get properties(){return{if:{type:Boolean,observer:"__debounceRender"},restamp:{type:Boolean,observer:"__debounceRender"},notifyDomChange:{type:Boolean}}}constructor(){super(),this.__renderDebouncer=null,this._lastIf=!1,this.__hideTemplateChildren__=!1,this.__template,this._templateInfo}__debounceRender(){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,li,()=>this.__render()),Jl(this.__renderDebouncer)}disconnectedCallback(){super.disconnectedCallback();let t=ue(this).parentNode;(!t||t.nodeType==Node.DOCUMENT_FRAGMENT_NODE&&!ue(t).host)&&this.__teardownInstance()}connectedCallback(){super.connectedCallback(),Wx()||(this.style.display="none"),this.if&&this.__debounceRender()}__ensureTemplate(){if(!this.__template){let t=this,r=t._templateInfo?t:ue(t).querySelector("template");if(!r){let n=new MutationObserver(()=>{if(ue(this).querySelector("template"))n.disconnect(),this.__render();else throw new Error("dom-if requires a <template> child")});return n.observe(this,{childList:!0}),!1}this.__template=r}return!0}__ensureInstance(){let t=ue(this).parentNode;if(this.__hasInstance()){let r=this.__getInstanceNodes();if(r&&r.length&&ue(this).previousSibling!==r[r.length-1])for(let i=0,o;i<r.length&&(o=r[i]);i++)ue(t).insertBefore(o,this)}else{if(!t||!this.__ensureTemplate())return!1;this.__createAndInsertInstance(t)}return!0}render(){ci()}__render(){if(this.if){if(!this.__ensureInstance())return}else this.restamp&&this.__teardownInstance();this._showHideChildren(),(!UM||this.notifyDomChange)&&this.if!=this._lastIf&&(this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0})),this._lastIf=this.if)}__hasInstance(){}__getInstanceNodes(){}__createAndInsertInstance(t){}__teardownInstance(){}_showHideChildren(){}},aW=class extends m9{constructor(){super(),this.__instance=null,this.__syncInfo=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.templateInfo.childNodes}__createAndInsertInstance(t){let r=this.__dataHost||this;if(iu&&!this.__dataHost)throw new Error("strictTemplatePolicy: template owner not trusted");let n=r._bindTemplate(this.__template,!0);n.runEffects=(i,o,a)=>{let s=this.__syncInfo;if(this.if)s&&(this.__syncInfo=null,this._showHideChildren(),o=Object.assign(s.changedProps,o)),i(o,a);else if(this.__instance)if(s||(s=this.__syncInfo={runEffects:i,changedProps:{}}),a)for(let l in o){let c=au(l);s.changedProps[c]=this.__dataHost[c]}else Object.assign(s.changedProps,o)},this.__instance=r._stampTemplate(this.__template,n),ue(t).insertBefore(this.__instance,this)}__syncHostProperties(){let t=this.__syncInfo;t&&(this.__syncInfo=null,t.runEffects(t.changedProps,!1))}__teardownInstance(){let t=this.__dataHost||this;this.__instance&&(t._removeBoundDom(this.__instance),this.__instance=null,this.__syncInfo=null)}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,iW(t,this.__instance.templateInfo.childNodes)),t||this.__syncHostProperties()}},sW=class extends m9{constructor(){super(),this.__ctor=null,this.__instance=null,this.__invalidProps=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.children}__createAndInsertInstance(t){this.__ctor||(this.__ctor=tc(this.__template,this,{mutableData:!0,forwardHostProp:function(r,n){this.__instance&&(this.if?this.__instance.forwardHostProp(r,n):(this.__invalidProps=this.__invalidProps||Object.create(null),this.__invalidProps[au(r)]=!0))}})),this.__instance=new this.__ctor,ue(t).insertBefore(this.__instance.root,this)}__teardownInstance(){if(this.__instance){let t=this.__instance.children;if(t&&t.length){let r=ue(t[0]).parentNode;if(r){r=ue(r);for(let n=0,i;n<t.length&&(i=t[n]);n++)r.removeChild(i)}}this.__invalidProps=null,this.__instance=null}}__syncHostProperties(){let t=this.__invalidProps;if(t){this.__invalidProps=null;for(let r in t)this.__instance._setPendingProperty(r,this.__dataHost[r]);this.__instance._flushProperties()}}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,this.__instance._showHideChildren(t)),t||this.__syncHostProperties()}},jgt=RI?aW:sW;customElements.define(jgt.is,jgt);var dbe=Nn(e=>{let t=Mm(e);class r extends t{static get properties(){return{items:{type:Array},multi:{type:Boolean,value:!1},selected:{type:Object,notify:!0},selectedItem:{type:Object,notify:!0},toggle:{type:Boolean,value:!1}}}static get observers(){return["__updateSelection(multi, items.*)"]}constructor(){super(),this.__lastItems=null,this.__lastMulti=null,this.__selectedMap=null}__updateSelection(i,o){let a=o.path;if(a==JSCompiler_renameProperty("items",this)){let s=o.base||[],l=this.__lastItems,c=this.__lastMulti;if(i!==c&&this.clearSelection(),l){let u=o9(s,l);this.__applySplices(u)}this.__lastItems=s,this.__lastMulti=i}else if(o.path==`${JSCompiler_renameProperty("items",this)}.splices`)this.__applySplices(o.value.indexSplices);else{let s=a.slice(`${JSCompiler_renameProperty("items",this)}.`.length),l=parseInt(s,10);s.indexOf(".")<0&&s==l&&this.__deselectChangedIdx(l)}}__applySplices(i){let o=this.__selectedMap;for(let s=0;s<i.length;s++){let l=i[s];o.forEach((c,u)=>{c<l.index||(c>=l.index+l.removed.length?o.set(u,c+l.addedCount-l.removed.length):o.set(u,-1))});for(let c=0;c<l.addedCount;c++){let u=l.index+c;o.has(this.items[u])&&o.set(this.items[u],u)}}this.__updateLinks();let a=0;o.forEach((s,l)=>{s<0?(this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null,o.delete(l)):a++})}__updateLinks(){if(this.__dataLinkedPaths={},this.multi){let i=0;this.__selectedMap.forEach(o=>{o>=0&&this.linkPaths(`${JSCompiler_renameProperty("items",this)}.${o}`,`${JSCompiler_renameProperty("selected",this)}.${i++}`)})}else this.__selectedMap.forEach(i=>{this.linkPaths(JSCompiler_renameProperty("selected",this),`${JSCompiler_renameProperty("items",this)}.${i}`),this.linkPaths(JSCompiler_renameProperty("selectedItem",this),`${JSCompiler_renameProperty("items",this)}.${i}`)})}clearSelection(){this.__dataLinkedPaths={},this.__selectedMap=new Map,this.selected=this.multi?[]:null,this.selectedItem=null}isSelected(i){return this.__selectedMap.has(i)}isIndexSelected(i){return this.isSelected(this.items[i])}__deselectChangedIdx(i){let o=this.__selectedIndexForItemIndex(i);if(o>=0){let a=0;this.__selectedMap.forEach((s,l)=>{o==a++&&this.deselect(l)})}}__selectedIndexForItemIndex(i){let o=this.__dataLinkedPaths[`${JSCompiler_renameProperty("items",this)}.${i}`];if(o)return parseInt(o.slice(`${JSCompiler_renameProperty("selected",this)}.`.length),10)}deselect(i){let o=this.__selectedMap.get(i);if(o>=0){this.__selectedMap.delete(i);let a;this.multi&&(a=this.__selectedIndexForItemIndex(o)),this.__updateLinks(),this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null}}deselectIndex(i){this.deselect(this.items[i])}select(i){this.selectIndex(this.items.indexOf(i))}selectIndex(i){let o=this.items[i];this.isSelected(o)?this.toggle&&this.deselectIndex(i):(this.multi||this.__selectedMap.clear(),this.__selectedMap.set(o,i),this.__updateLinks(),this.multi?this.push(JSCompiler_renameProperty("selected",this),o):this.selected=this.selectedItem=o)}}return r});var mbe=dbe(mt),g9=class extends mbe{static get is(){return"array-selector"}static get template(){return null}};customElements.define(g9.is,g9);var _9=new Zl;window.ShadyCSS||(window.ShadyCSS={prepareTemplate(e,t,r){},prepareTemplateDom(e,t){},prepareTemplateStyles(e,t,r){},styleSubtree(e,t){_9.processStyles(),JM(e,t)},styleElement(e){_9.processStyles()},styleDocument(e){_9.processStyles(),JM(document.body,e)},getComputedStyleValue(e,t){return jI(e,t)},flushCustomStyles(){},nativeCss:Nx,nativeShadow:f_,cssBuild:Em,disableRuntime:WI});window.ShadyCSS.CustomStyleInterface=_9;var Xgt="include",gbe=window.ShadyCSS.CustomStyleInterface,lW=class extends HTMLElement{constructor(){super(),this._style=null,gbe.addCustomStyle(this)}getStyle(){if(this._style)return this._style;let t=this.querySelector("style");if(!t)return null;this._style=t;let r=t.getAttribute(Xgt);return r&&(t.removeAttribute(Xgt),t.textContent=imt(r)+t.textContent),this.ownerDocument!==window.document&&window.document.head.appendChild(this),this._style}};window.customElements.define("custom-style",lW);var $gt;$gt=Gx._mutablePropertyChange;var Kgt={properties:{mutableData:Boolean},_shouldPropertyChange(e,t,r){return $gt(this,e,t,r,this.mutableData)}};var Oa=Gt(HTMLElement).prototype;var y9=new Set,Qs={properties:{_parentResizable:{type:Object,observer:"_parentResizableChanged"},_notifyingDescendant:{type:Boolean,value:!1}},listeners:{"iron-request-resize-notifications":"_onIronRequestResizeNotifications"},created:function(){this._interestedResizables=[],this._boundNotifyResize=this.notifyResize.bind(this),this._boundOnDescendantIronResize=this._onDescendantIronResize.bind(this)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):(y9.delete(this),window.removeEventListener("resize",this._boundNotifyResize)),this._parentResizable=null},notifyResize:function(){!this.isAttached||(this._interestedResizables.forEach(function(e){this.resizerShouldNotify(e)&&this._notifyDescendant(e)},this),this._fireResize())},assignParentResizable:function(e){this._parentResizable&&this._parentResizable.stopResizeNotificationsFor(this),this._parentResizable=e,e&&e._interestedResizables.indexOf(this)===-1&&(e._interestedResizables.push(this),e._subscribeIronResize(this))},stopResizeNotificationsFor:function(e){var t=this._interestedResizables.indexOf(e);t>-1&&(this._interestedResizables.splice(t,1),this._unsubscribeIronResize(e))},_subscribeIronResize:function(e){e.addEventListener("iron-resize",this._boundOnDescendantIronResize)},_unsubscribeIronResize:function(e){e.removeEventListener("iron-resize",this._boundOnDescendantIronResize)},resizerShouldNotify:function(e){return!0},_onDescendantIronResize:function(e){if(this._notifyingDescendant){e.stopPropagation();return}u_||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(e){var t=zt(e).rootTarget;t!==this&&(t.assignParentResizable(this),this._notifyDescendant(t),e.stopPropagation())},_parentResizableChanged:function(e){e&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(e){!this.isAttached||(this._notifyingDescendant=!0,e.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(!!this.isAttached)if(document.readyState==="loading"){var e=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function t(){document.removeEventListener("readystatechange",t),e()})}else this._findParent(),this._parentResizable?this._parentResizable._interestedResizables.forEach(function(t){t!==this&&t._findParent()},this):(y9.forEach(function(t){t!==this&&t._findParent()},this),window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())},_findParent:function(){this.assignParentResizable(null),this.fire("iron-request-resize-notifications",null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable?y9.delete(this):y9.add(this)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        transition-duration: var(--iron-collapse-transition-duration, 300ms);
        /* Safari 10 needs this property prefixed to correctly apply the custom property */
        -webkit-transition-duration: var(--iron-collapse-transition-duration, 300ms);
        overflow: visible;
      }

      :host(.iron-collapse-closed) {
        display: none;
      }

      :host(:not(.iron-collapse-opened)) {
        overflow: hidden;
      }
    </style>

    <slot></slot>
`,is:"iron-collapse",behaviors:[Qs],properties:{horizontal:{type:Boolean,value:!1,observer:"_horizontalChanged"},opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},transitioning:{type:Boolean,notify:!0,readOnly:!0},noAnimation:{type:Boolean},_desiredSize:{type:String,value:""}},get dimension(){return this.horizontal?"width":"height"},get _dimensionMax(){return this.horizontal?"maxWidth":"maxHeight"},get _dimensionMaxCss(){return this.horizontal?"max-width":"max-height"},hostAttributes:{role:"group","aria-hidden":"true"},listeners:{transitionend:"_onTransitionEnd"},toggle:function(){this.opened=!this.opened},show:function(){this.opened=!0},hide:function(){this.opened=!1},updateSize:function(e,t){e=e==="auto"?"":e;var r=t&&!this.noAnimation&&this.isAttached&&this._desiredSize!==e;if(this._desiredSize=e,this._updateTransition(!1),r){var n=this._calcSize();e===""&&(this.style[this._dimensionMax]="",e=this._calcSize()),this.style[this._dimensionMax]=n,this.scrollTop=this.scrollTop,this._updateTransition(!0),r=e!==n}this.style[this._dimensionMax]=e,r||this._transitionEnd()},enableTransition:function(e){Oa._warn("`enableTransition()` is deprecated, use `noAnimation` instead."),this.noAnimation=!e},_updateTransition:function(e){this.style.transitionDuration=e&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;var e=this._dimensionMax==="maxWidth"?"maxHeight":"maxWidth";this.style[e]="",this.updateSize(this.opened?"auto":"0px",!1)},_openedChanged:function(){this.setAttribute("aria-hidden",!this.opened),this._setTransitioning(!0),this.toggleClass("iron-collapse-closed",!1),this.toggleClass("iron-collapse-opened",!1),this.updateSize(this.opened?"auto":"0px",!0),this.opened&&this.focus()},_transitionEnd:function(){this.style[this._dimensionMax]=this._desiredSize,this.toggleClass("iron-collapse-closed",!this.opened),this.toggleClass("iron-collapse-opened",this.opened),this._updateTransition(!1),this.notifyResize(),this._setTransitioning(!1)},_onTransitionEnd:function(e){zt(e).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});var Zgt=Q`
/* Most common used flex styles*/
<dom-module id="iron-flex">
  <template>
    <style>
      .layout.horizontal,
      .layout.vertical {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.inline {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      }

      .layout.horizontal {
        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      }

      .layout.vertical {
        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      }

      .layout.wrap {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      }

      .layout.no-wrap {
        -ms-flex-wrap: nowrap;
        -webkit-flex-wrap: nowrap;
        flex-wrap: nowrap;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .flex {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-auto {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      }

      .flex-none {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      }
    </style>
  </template>
</dom-module>
/* Basic flexbox reverse styles */
<dom-module id="iron-flex-reverse">
  <template>
    <style>
      .layout.horizontal-reverse,
      .layout.vertical-reverse {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.horizontal-reverse {
        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      }

      .layout.vertical-reverse {
        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      }

      .layout.wrap-reverse {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      }
    </style>
  </template>
</dom-module>
/* Flexbox alignment */
<dom-module id="iron-flex-alignment">
  <template>
    <style>
      /**
       * Alignment in cross axis.
       */
      .layout.start {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.end {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      }

      .layout.baseline {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      }

      /**
       * Alignment in main axis.
       */
      .layout.start-justified {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .layout.end-justified {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      }

      .layout.around-justified {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      }

      .layout.justified {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      }

      /**
       * Self alignment.
       */
      .self-start {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      }

      .self-center {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      }

      .self-end {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      }

      .self-stretch {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      }

      .self-baseline {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      }

      /**
       * multi-line alignment in main axis.
       */
      .layout.start-aligned {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      }

      .layout.end-aligned {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      }

      .layout.center-aligned {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      }

      .layout.between-aligned {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      }

      .layout.around-aligned {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      }
    </style>
  </template>
</dom-module>
/* Non-flexbox positioning helper styles */
<dom-module id="iron-flex-factors">
  <template>
    <style>
      .flex,
      .flex-1 {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-2 {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      }

      .flex-3 {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      }

      .flex-4 {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      }

      .flex-5 {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      }

      .flex-6 {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      }

      .flex-7 {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      }

      .flex-8 {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      }

      .flex-9 {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      }

      .flex-10 {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      }

      .flex-11 {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      }

      .flex-12 {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      }
    </style>
  </template>
</dom-module>
<dom-module id="iron-positioning">
  <template>
    <style>
      .block {
        display: block;
      }

      [hidden] {
        display: none !important;
      }

      .invisible {
        visibility: hidden !important;
      }

      .relative {
        position: relative;
      }

      .fit {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      body.fullbleed {
        margin: 0;
        height: 100vh;
      }

      .scroll {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      }

      /* fixed position */
      .fixed-bottom,
      .fixed-left,
      .fixed-right,
      .fixed-top {
        position: fixed;
      }

      .fixed-top {
        top: 0;
        left: 0;
        right: 0;
      }

      .fixed-right {
        top: 0;
        right: 0;
        bottom: 0;
      }

      .fixed-bottom {
        right: 0;
        bottom: 0;
        left: 0;
      }

      .fixed-left {
        top: 0;
        bottom: 0;
        left: 0;
      }
    </style>
  </template>
</dom-module>
`;Zgt.setAttribute("style","display: none;");document.head.appendChild(Zgt.content);var Jgt=Q`
<custom-style>
  <style is="custom-style">
    [hidden] {
      display: none !important;
    }
  </style>
</custom-style>
<custom-style>
  <style is="custom-style">
    html {

      --layout: {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      };

      --layout-inline: {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      };

      --layout-horizontal: {
        @apply --layout;

        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      };

      --layout-horizontal-reverse: {
        @apply --layout;

        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      };

      --layout-vertical: {
        @apply --layout;

        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      };

      --layout-vertical-reverse: {
        @apply --layout;

        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      };

      --layout-wrap: {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      };

      --layout-wrap-reverse: {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      };

      --layout-flex-auto: {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      };

      --layout-flex-none: {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      };

      --layout-flex: {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      };

      --layout-flex-2: {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      };

      --layout-flex-3: {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      };

      --layout-flex-4: {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      };

      --layout-flex-5: {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      };

      --layout-flex-6: {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      };

      --layout-flex-7: {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      };

      --layout-flex-8: {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      };

      --layout-flex-9: {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      };

      --layout-flex-10: {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      };

      --layout-flex-11: {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      };

      --layout-flex-12: {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      };

      /* alignment in cross axis */

      --layout-start: {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      };

      --layout-center: {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      };

      --layout-end: {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      };

      --layout-baseline: {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      };

      /* alignment in main axis */

      --layout-start-justified: {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      };

      --layout-center-justified: {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      };

      --layout-end-justified: {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      };

      --layout-around-justified: {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      };

      --layout-justified: {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      };

      --layout-center-center: {
        @apply --layout-center;
        @apply --layout-center-justified;
      };

      /* self alignment */

      --layout-self-start: {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      };

      --layout-self-center: {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      };

      --layout-self-end: {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      };

      --layout-self-stretch: {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      };

      --layout-self-baseline: {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      };

      /* multi-line alignment in main axis */

      --layout-start-aligned: {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      };

      --layout-end-aligned: {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      };

      --layout-center-aligned: {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      };

      --layout-between-aligned: {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      };

      --layout-around-aligned: {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      };

      /*******************************
                Other Layout
      *******************************/

      --layout-block: {
        display: block;
      };

      --layout-invisible: {
        visibility: hidden !important;
      };

      --layout-relative: {
        position: relative;
      };

      --layout-fit: {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-scroll: {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      };

      --layout-fullbleed: {
        margin: 0;
        height: 100vh;
      };

      /* fixed position */

      --layout-fixed-top: {
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
      };

      --layout-fixed-right: {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
      };

      --layout-fixed-bottom: {
        position: fixed;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-fixed-left: {
        position: fixed;
        top: 0;
        bottom: 0;
        left: 0;
      };

    }
  </style>
</custom-style>`;Jgt.setAttribute("style","display: none;");document.head.appendChild(Jgt.content);var Qgt=document.createElement("style");Qgt.textContent="[hidden] { display: none !important; }";document.head.appendChild(Qgt);var go=class{constructor(t){go[" "](t),this.type=t&&t.type||"default",this.key=t&&t.key,t&&"value"in t&&(this.value=t.value)}get value(){var t=this.type,r=this.key;if(t&&r)return go.types[t]&&go.types[t][r]}set value(t){var r=this.type,n=this.key;r&&n&&(r=go.types[r]=go.types[r]||{},t==null?delete r[n]:r[n]=t)}get list(){var t=this.type;if(t){var r=go.types[this.type];return r?Object.keys(r).map(function(n){return _be[this.type][n]},this):[]}}byKey(t){return this.key=t,this.value}};go[" "]=function(){};go.types={};var _be=go.types;Yt({is:"iron-meta",properties:{type:{type:String,value:"default"},key:{type:String},value:{type:String,notify:!0},self:{type:Boolean,observer:"_selfChanged"},__meta:{type:Boolean,computed:"__computeMeta(type, key, value)"}},hostAttributes:{hidden:!0},__computeMeta:function(e,t,r){var n=new go({type:e,key:t});return r!==void 0&&r!==n.value?n.value=r:this.value!==n.value&&(this.value=n.value),n},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(e){e&&(this.value=this)},byKey:function(e){return new go({type:this.type,key:e}).value}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center-center;
        position: relative;

        vertical-align: middle;

        fill: var(--iron-icon-fill-color, currentcolor);
        stroke: var(--iron-icon-stroke-color, none);

        width: var(--iron-icon-width, 24px);
        height: var(--iron-icon-height, 24px);
        @apply --iron-icon;
      }

      :host([hidden]) {
        display: none;
      }
    </style>
`,is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Oa.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(e){var t=(e||"").split(":");this._iconName=t.pop(),this._iconsetName=t.pop()||this._DEFAULT_ICONSET,this._updateIcon()},_srcChanged:function(e){this._updateIcon()},_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&zt(this.root).removeChild(this._img),this._iconName===""?this._iconset&&this._iconset.removeIcon(this):this._iconsetName&&this._meta&&(this._iconset=this._meta.byKey(this._iconsetName),this._iconset?(this._iconset.applyIcon(this,this._iconName,this.theme),this.unlisten(window,"iron-iconset-added","_updateIcon")):this.listen(window,"iron-iconset-added","_updateIcon"))):(this._iconset&&this._iconset.removeIcon(this),this._img||(this._img=document.createElement("img"),this._img.style.width="100%",this._img.style.height="100%",this._img.draggable=!1),this._img.src=this.src,zt(this.root).appendChild(this._img))}});Yt({is:"iron-iconset-svg",properties:{name:{type:String,observer:"_nameChanged"},size:{type:Number,value:24},rtlMirroring:{type:Boolean,value:!1},useGlobalRtlAttribute:{type:Boolean,value:!1}},created:function(){this._meta=new go({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){return this._icons=this._createIconMap(),Object.keys(this._icons).map(function(e){return this.name+":"+e},this)},applyIcon:function(e,t){this.removeIcon(e);var r=this._cloneIcon(t,this.rtlMirroring&&this._targetIsRTL(e));if(r){var n=zt(e.root||e);return n.insertBefore(r,n.childNodes[0]),e._svgIcon=r}return null},removeIcon:function(e){e._svgIcon&&(zt(e.root||e).removeChild(e._svgIcon),e._svgIcon=null)},_targetIsRTL:function(e){if(this.__targetIsRTL==null)if(this.useGlobalRtlAttribute){var t=document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement;this.__targetIsRTL=t.getAttribute("dir")==="rtl"}else e&&e.nodeType!==Node.ELEMENT_NODE&&(e=e.host),this.__targetIsRTL=e&&window.getComputedStyle(e).direction==="rtl";return this.__targetIsRTL},_nameChanged:function(){this._meta.value=null,this._meta.key=this.name,this._meta.value=this,this.async(function(){this.fire("iron-iconset-added",this,{node:window})})},_createIconMap:function(){var e=Object.create(null);return zt(this).querySelectorAll("[id]").forEach(function(t){e[t.id]=t}),e},_cloneIcon:function(e,t){return this._icons=this._icons||this._createIconMap(),this._prepareSvgClone(this._icons[e],this.size,t)},_prepareSvgClone:function(e,t,r){if(e){var n=e.cloneNode(!0),i=document.createElementNS("http://www.w3.org/2000/svg","svg"),o=n.getAttribute("viewBox")||"0 0 "+t+" "+t,a="pointer-events: none; display: block; width: 100%; height: 100%;";return r&&n.hasAttribute("mirror-in-rtl")&&(a+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;"),i.setAttribute("viewBox",o),i.setAttribute("preserveAspectRatio","xMidYMid meet"),i.setAttribute("focusable","false"),i.style.cssText=a,i.appendChild(n).removeAttribute("id"),i}return null}});var ybe=Q`<iron-iconset-svg name="image" size="24">
<svg><defs>
<g id="add-a-photo"><path d="M3 4V1h2v3h3v2H5v3H3V6H0V4h3zm3 6V7h3V4h7l1.83 2H21c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2V10h3zm7 9c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5zm-3.2-5c0 1.77 1.43 3.2 3.2 3.2s3.2-1.43 3.2-3.2-1.43-3.2-3.2-3.2-3.2 1.43-3.2 3.2z"></path></g>
<g id="add-to-photos"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-1 9h-4v4h-2v-4H9V9h4V5h2v4h4v2z"></path></g>
<g id="adjust"><path d="M12 2C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm3-8c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3z"></path></g>
<g id="assistant"><path d="M19 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h4l3 3 3-3h4c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-5.12 10.88L12 17l-1.88-4.12L6 11l4.12-1.88L12 5l1.88 4.12L18 11l-4.12 1.88z"></path></g>
<g id="assistant-photo"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="audiotrack"><path d="M12 3v9.28c-.47-.17-.97-.28-1.5-.28C8.01 12 6 14.01 6 16.5S8.01 21 10.5 21c2.31 0 4.2-1.75 4.45-4H15V6h4V3h-7z"></path></g>
<g id="blur-circular"><path d="M10 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM7 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-3-3c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3-6c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-1.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm3 6c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-4c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm2-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-3.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z"></path></g>
<g id="blur-linear"><path d="M5 17.5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 13c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zM3 21h18v-2H3v2zM5 9.5c.83 0 1.5-.67 1.5-1.5S5.83 6.5 5 6.5 3.5 7.17 3.5 8 4.17 9.5 5 9.5zm0 4c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 17c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8-.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM3 3v2h18V3H3zm14 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm0 4c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM13 9c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z"></path></g>
<g id="blur-off"><path d="M14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-.2 4.48l.2.02c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5l.02.2c.09.67.61 1.19 1.28 1.28zM14 3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-4 0c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm11 7c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 8c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-4 13.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM2.5 5.27l3.78 3.78L6 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l2.81 2.81c-.71.11-1.25.73-1.25 1.47 0 .83.67 1.5 1.5 1.5.74 0 1.36-.54 1.47-1.25l2.81 2.81c-.09-.03-.18-.06-.28-.06-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l3.78 3.78L20 20.23 3.77 4 2.5 5.27zM10 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm11-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM3 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 11c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5z"></path></g>
<g id="blur-on"><path d="M6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3 .5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm15 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-11 10c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-17c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 5.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm8 .5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm3 8.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM14 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-4-12c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0 8.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm4-4.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-4c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="brightness-1"><circle cx="12" cy="12" r="10"></circle></g>
<g id="brightness-2"><path d="M10 2c-1.82 0-3.53.5-5 1.35C7.99 5.08 10 8.3 10 12s-2.01 6.92-5 8.65C6.47 21.5 8.18 22 10 22c5.52 0 10-4.48 10-10S15.52 2 10 2z"></path></g>
<g id="brightness-3"><path d="M9 2c-1.05 0-2.05.16-3 .46 4.06 1.27 7 5.06 7 9.54 0 4.48-2.94 8.27-7 9.54.95.3 1.95.46 3 .46 5.52 0 10-4.48 10-10S14.52 2 9 2z"></path></g>
<g id="brightness-4"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-5"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6z"></path></g>
<g id="brightness-6"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-7"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zm0-10c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4z"></path></g>
<g id="broken-image"><path d="M21 5v6.59l-3-3.01-4 4.01-4-4-4 4-3-3.01V5c0-1.1.9-2 2-2h14c1.1 0 2 .9 2 2zm-3 6.42l3 3.01V19c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2v-6.58l3 2.99 4-4 4 4 4-3.99z"></path></g>
<g id="brush"><path d="M7 14c-1.66 0-3 1.34-3 3 0 1.31-1.16 2-2 2 .92 1.22 2.49 2 4 2 2.21 0 4-1.79 4-4 0-1.66-1.34-3-3-3zm13.71-9.37l-1.34-1.34c-.39-.39-1.02-.39-1.41 0L9 12.25 11.75 15l8.96-8.96c.39-.39.39-1.02 0-1.41z"></path></g>
<g id="burst-mode"><path d="M1 5h2v14H1zm4 0h2v14H5zm17 0H10c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zM11 17l2.5-3.15L15.29 16l2.5-3.22L21 17H11z"></path></g>
<g id="camera"><path d="M9.4 10.5l4.77-8.26C13.47 2.09 12.75 2 12 2c-2.4 0-4.6.85-6.32 2.25l3.66 6.35.06-.1zM21.54 9c-.92-2.92-3.15-5.26-6-6.34L11.88 9h9.66zm.26 1h-7.49l.29.5 4.76 8.25C21 16.97 22 14.61 22 12c0-.69-.07-1.35-.2-2zM8.54 12l-3.9-6.75C3.01 7.03 2 9.39 2 12c0 .69.07 1.35.2 2h7.49l-1.15-2zm-6.08 3c.92 2.92 3.15 5.26 6 6.34L12.12 15H2.46zm11.27 0l-3.9 6.76c.7.15 1.42.24 2.17.24 2.4 0 4.6-.85 6.32-2.25l-3.66-6.35-.93 1.6z"></path></g>
<g id="camera-alt"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="camera-front"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zM12 8c1.1 0 2-.9 2-2s-.9-2-2-2-1.99.9-1.99 2S10.9 8 12 8zm5-8H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zM7 2h10v10.5c0-1.67-3.33-2.5-5-2.5s-5 .83-5 2.5V2z"></path></g>
<g id="camera-rear"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zm3-20H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zm-5 6c-1.11 0-2-.9-2-2s.89-2 1.99-2 2 .9 2 2C14 5.1 13.1 6 12 6z"></path></g>
<g id="camera-roll"><path d="M14 5c0-1.1-.9-2-2-2h-1V2c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v1H4c-1.1 0-2 .9-2 2v15c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2h8V5h-8zm-2 13h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2z"></path></g>
<g id="center-focus-strong"><path d="M12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm-7 7H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4z"></path></g>
<g id="center-focus-weak"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="collections"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="collections-bookmark"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 10l-2.5-1.5L15 12V4h5v8z"></path></g>
<g id="color-lens"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="colorize"><path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"></path></g>
<g id="compare"><path d="M10 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h5v2h2V1h-2v2zm0 15H5l5-6v6zm9-15h-5v2h5v13l-5-6v9h5c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="control-point"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="control-point-duplicate"><path d="M16 8h-2v3h-3v2h3v3h2v-3h3v-2h-3zM2 12c0-2.79 1.64-5.2 4.01-6.32V3.52C2.52 4.76 0 8.09 0 12s2.52 7.24 6.01 8.48v-2.16C3.64 17.2 2 14.79 2 12zm13-9c-4.96 0-9 4.04-9 9s4.04 9 9 9 9-4.04 9-9-4.04-9-9-9zm0 16c-3.86 0-7-3.14-7-7s3.14-7 7-7 7 3.14 7 7-3.14 7-7 7z"></path></g>
<g id="crop"><path d="M17 15h2V7c0-1.1-.9-2-2-2H9v2h8v8zM7 17V1H5v4H1v2h4v10c0 1.1.9 2 2 2h10v4h2v-4h4v-2H7z"></path></g>
<g id="crop-16-9"><path d="M19 6H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H5V8h14v8z"></path></g>
<g id="crop-3-2"><path d="M19 4H5c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H5V6h14v12z"></path></g>
<g id="crop-5-4"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-7-5"><path d="M19 7H5c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zm0 8H5V9h14v6z"></path></g>
<g id="crop-din"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="crop-free"><path d="M3 5v4h2V5h4V3H5c-1.1 0-2 .9-2 2zm2 10H3v4c0 1.1.9 2 2 2h4v-2H5v-4zm14 4h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zm0-16h-4v2h4v4h2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="crop-landscape"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-original"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14zm-5.04-6.71l-2.75 3.54-1.96-2.36L6.5 17h11l-3.54-4.71z"></path></g>
<g id="crop-portrait"><path d="M17 3H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H7V5h10v14z"></path></g>
<g id="crop-rotate"><path d="M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z"></path></g>
<g id="crop-square"><path d="M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z"></path></g>
<g id="dehaze"><path d="M2 15.5v2h20v-2H2zm0-5v2h20v-2H2zm0-5v2h20v-2H2z"></path></g>
<g id="details"><path d="M3 4l9 16 9-16H3zm3.38 2h11.25L12 16 6.38 6z"></path></g>
<g id="edit"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="exposure"><path d="M15 17v2h2v-2h2v-2h-2v-2h-2v2h-2v2h2zm5-15H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM5 5h6v2H5V5zm15 15H4L20 4v16z"></path></g>
<g id="exposure-neg-1"><path d="M4 11v2h8v-2H4zm15 7h-2V7.38L14 8.4V6.7L18.7 5h.3v13z"></path></g>
<g id="exposure-neg-2"><path d="M15.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17s.19-.79.19-1.18c0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H21v-1.71h-5.95zM2 11v2h8v-2H2z"></path></g>
<g id="exposure-plus-1"><path d="M10 7H8v4H4v2h4v4h2v-4h4v-2h-4V7zm10 11h-2V7.38L15 8.4V6.7L19.7 5h.3v13z"></path></g>
<g id="exposure-plus-2"><path d="M16.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17.13-.39.19-.79.19-1.18 0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H22v-1.71h-5.95zM8 7H6v4H2v2h4v4h2v-4h4v-2H8V7z"></path></g>
<g id="exposure-zero"><path d="M16.14 12.5c0 1-.1 1.85-.3 2.55-.2.7-.48 1.27-.83 1.7-.36.44-.79.75-1.3.95-.51.2-1.07.3-1.7.3-.62 0-1.18-.1-1.69-.3-.51-.2-.95-.51-1.31-.95-.36-.44-.65-1.01-.85-1.7-.2-.7-.3-1.55-.3-2.55v-2.04c0-1 .1-1.85.3-2.55.2-.7.48-1.26.84-1.69.36-.43.8-.74 1.31-.93C10.81 5.1 11.38 5 12 5c.63 0 1.19.1 1.7.29.51.19.95.5 1.31.93.36.43.64.99.84 1.69.2.7.3 1.54.3 2.55v2.04zm-2.11-2.36c0-.64-.05-1.18-.13-1.62-.09-.44-.22-.79-.4-1.06-.17-.27-.39-.46-.64-.58-.25-.13-.54-.19-.86-.19-.32 0-.61.06-.86.18s-.47.31-.64.58c-.17.27-.31.62-.4 1.06s-.13.98-.13 1.62v2.67c0 .64.05 1.18.14 1.62.09.45.23.81.4 1.09s.39.48.64.61.54.19.87.19c.33 0 .62-.06.87-.19s.46-.33.63-.61c.17-.28.3-.64.39-1.09.09-.45.13-.99.13-1.62v-2.66z"></path></g>
<g id="filter"><path d="M15.96 10.29l-2.75 3.54-1.96-2.36L8.5 15h11l-3.54-4.71zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-1"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 10h2V5h-4v2h2v8zm7-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-2"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-4-4h-4v-2h2c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2h-4v2h4v2h-2c-1.1 0-2 .89-2 2v4h6v-2z"></path></g>
<g id="filter-3"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-4v2h4v2h-2v2h2v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-4"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm12 10h2V5h-2v4h-2V5h-2v6h4v4zm6-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-5"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-2c0-1.11-.9-2-2-2h-2V7h4V5h-6v6h4v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-6"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-2c0-1.11-.9-2-2-2h-2V7h4V5h-4c-1.1 0-2 .89-2 2v6c0 1.11.9 2 2 2zm0-4h2v2h-2v-2z"></path></g>
<g id="filter-7"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"></path></g>
<g id="filter-8"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-2c-1.1 0-2 .89-2 2v1.5c0 .83.67 1.5 1.5 1.5-.83 0-1.5.67-1.5 1.5V13c0 1.11.9 2 2 2zm0-8h2v2h-2V7zm0 4h2v2h-2v-2z"></path></g>
<g id="filter-9"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM15 5h-2c-1.1 0-2 .89-2 2v2c0 1.11.9 2 2 2h2v2h-4v2h4c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2zm0 4h-2V7h2v2z"></path></g>
<g id="filter-9-plus"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 7V8c0-1.11-.9-2-2-2h-1c-1.1 0-2 .89-2 2v1c0 1.11.9 2 2 2h1v1H9v2h3c1.1 0 2-.89 2-2zm-3-3V8h1v1h-1zm10-8H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 8h-2V7h-2v2h-2v2h2v2h2v-2h2v6H7V3h14v6z"></path></g>
<g id="filter-b-and-w"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16l-7-8v8H5l7-8V5h7v14z"></path></g>
<g id="filter-center-focus"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="filter-drama"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.61 5.64 5.36 8.04 2.35 8.36 0 10.9 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4h2c0-2.76-1.86-5.08-4.4-5.78C8.61 6.88 10.2 6 12 6c3.03 0 5.5 2.47 5.5 5.5v.5H19c1.65 0 3 1.35 3 3s-1.35 3-3 3z"></path></g>
<g id="filter-frames"><path d="M20 4h-4l-4-4-4 4H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H4V6h4.52l3.52-3.5L15.52 6H20v14zM18 8H6v10h12"></path></g>
<g id="filter-hdr"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="filter-none"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-tilt-shift"><path d="M11 4.07V2.05c-2.01.2-3.84 1-5.32 2.21L7.1 5.69c1.11-.86 2.44-1.44 3.9-1.62zm7.32.19C16.84 3.05 15.01 2.25 13 2.05v2.02c1.46.18 2.79.76 3.9 1.62l1.42-1.43zM19.93 11h2.02c-.2-2.01-1-3.84-2.21-5.32L18.31 7.1c.86 1.11 1.44 2.44 1.62 3.9zM5.69 7.1L4.26 5.68C3.05 7.16 2.25 8.99 2.05 11h2.02c.18-1.46.76-2.79 1.62-3.9zM4.07 13H2.05c.2 2.01 1 3.84 2.21 5.32l1.43-1.43c-.86-1.1-1.44-2.43-1.62-3.89zM15 12c0-1.66-1.34-3-3-3s-3 1.34-3 3 1.34 3 3 3 3-1.34 3-3zm3.31 4.9l1.43 1.43c1.21-1.48 2.01-3.32 2.21-5.32h-2.02c-.18 1.45-.76 2.78-1.62 3.89zM13 19.93v2.02c2.01-.2 3.84-1 5.32-2.21l-1.43-1.43c-1.1.86-2.43 1.44-3.89 1.62zm-7.32-.19C7.16 20.95 9 21.75 11 21.95v-2.02c-1.46-.18-2.79-.76-3.9-1.62l-1.42 1.43z"></path></g>
<g id="filter-vintage"><path d="M18.7 12.4c-.28-.16-.57-.29-.86-.4.29-.11.58-.24.86-.4 1.92-1.11 2.99-3.12 3-5.19-1.79-1.03-4.07-1.11-6 0-.28.16-.54.35-.78.54.05-.31.08-.63.08-.95 0-2.22-1.21-4.15-3-5.19C10.21 1.85 9 3.78 9 6c0 .32.03.64.08.95-.24-.2-.5-.39-.78-.55-1.92-1.11-4.2-1.03-6 0 0 2.07 1.07 4.08 3 5.19.28.16.57.29.86.4-.29.11-.58.24-.86.4-1.92 1.11-2.99 3.12-3 5.19 1.79 1.03 4.07 1.11 6 0 .28-.16.54-.35.78-.54-.05.32-.08.64-.08.96 0 2.22 1.21 4.15 3 5.19 1.79-1.04 3-2.97 3-5.19 0-.32-.03-.64-.08-.95.24.2.5.38.78.54 1.92 1.11 4.2 1.03 6 0-.01-2.07-1.08-4.08-3-5.19zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="flare"><path d="M7 11H1v2h6v-2zm2.17-3.24L7.05 5.64 5.64 7.05l2.12 2.12 1.41-1.41zM13 1h-2v6h2V1zm5.36 6.05l-1.41-1.41-2.12 2.12 1.41 1.41 2.12-2.12zM17 11v2h6v-2h-6zm-5-2c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3zm2.83 7.24l2.12 2.12 1.41-1.41-2.12-2.12-1.41 1.41zm-9.19.71l1.41 1.41 2.12-2.12-1.41-1.41-2.12 2.12zM11 23h2v-6h-2v6z"></path></g>
<g id="flash-auto"><path d="M3 2v12h3v9l7-12H9l4-9H3zm16 0h-2l-3.2 9h1.9l.7-2h3.2l.7 2h1.9L19 2zm-2.15 5.65L18 4l1.15 3.65h-2.3z"></path></g>
<g id="flash-off"><path d="M3.27 3L2 4.27l5 5V13h3v9l3.58-6.14L17.73 20 19 18.73 3.27 3zM17 10h-4l4-8H7v2.18l8.46 8.46L17 10z"></path></g>
<g id="flash-on"><path d="M7 2v11h3v9l7-12h-4l4-8z"></path></g>
<g id="flip"><path d="M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z"></path></g>
<g id="gradient"><path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"></path></g>
<g id="grain"><path d="M10 12c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zM6 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12-8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm-4 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="grid-off"><path d="M8 4v1.45l2 2V4h4v4h-3.45l2 2H14v1.45l2 2V10h4v4h-3.45l2 2H20v1.45l2 2V4c0-1.1-.9-2-2-2H4.55l2 2H8zm8 0h4v4h-4V4zM1.27 1.27L0 2.55l2 2V20c0 1.1.9 2 2 2h15.46l2 2 1.27-1.27L1.27 1.27zM10 12.55L11.45 14H10v-1.45zm-6-6L5.45 8H4V6.55zM8 20H4v-4h4v4zm0-6H4v-4h3.45l.55.55V14zm6 6h-4v-4h3.45l.55.54V20zm2 0v-1.46L17.46 20H16z"></path></g>
<g id="grid-on"><path d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 20H4v-4h4v4zm0-6H4v-4h4v4zm0-6H4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4z"></path></g>
<g id="hdr-off"><path d="M17.5 15v-2h1.1l.9 2H21l-.9-2.1c.5-.2.9-.8.9-1.4v-1c0-.8-.7-1.5-1.5-1.5H16v4.9l1.1 1.1h.4zm0-4.5h2v1h-2v-1zm-4.5 0v.4l1.5 1.5v-1.9c0-.8-.7-1.5-1.5-1.5h-1.9l1.5 1.5h.4zm-3.5-1l-7-7-1.1 1L6.9 9h-.4v2h-2V9H3v6h1.5v-2.5h2V15H8v-4.9l1.5 1.5V15h3.4l7.6 7.6 1.1-1.1-12.1-12z"></path></g>
<g id="hdr-on"><path d="M21 11.5v-1c0-.8-.7-1.5-1.5-1.5H16v6h1.5v-2h1.1l.9 2H21l-.9-2.1c.5-.3.9-.8.9-1.4zm-1.5 0h-2v-1h2v1zm-13-.5h-2V9H3v6h1.5v-2.5h2V15H8V9H6.5v2zM13 9H9.5v6H13c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5zm0 4.5h-2v-3h2v3z"></path></g>
<g id="hdr-strong"><path d="M17 6c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zM5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="hdr-weak"><path d="M5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm12-2c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm0 10c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="healing"><path d="M17.73 12.02l3.98-3.98c.39-.39.39-1.02 0-1.41l-4.34-4.34c-.39-.39-1.02-.39-1.41 0l-3.98 3.98L8 2.29C7.8 2.1 7.55 2 7.29 2c-.25 0-.51.1-.7.29L2.25 6.63c-.39.39-.39 1.02 0 1.41l3.98 3.98L2.25 16c-.39.39-.39 1.02 0 1.41l4.34 4.34c.39.39 1.02.39 1.41 0l3.98-3.98 3.98 3.98c.2.2.45.29.71.29.26 0 .51-.1.71-.29l4.34-4.34c.39-.39.39-1.02 0-1.41l-3.99-3.98zM12 9c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-4.71 1.96L3.66 7.34l3.63-3.63 3.62 3.62-3.62 3.63zM10 13c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2 2c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2-4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2.66 9.34l-3.63-3.62 3.63-3.63 3.62 3.62-3.62 3.63z"></path></g>
<g id="image"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="image-aspect-ratio"><path d="M16 10h-2v2h2v-2zm0 4h-2v2h2v-2zm-8-4H6v2h2v-2zm4 0h-2v2h2v-2zm8-6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V6h16v12z"></path></g>
<g id="iso"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5.5 7.5h2v-2H9v2h2V9H9v2H7.5V9h-2V7.5zM19 19H5L19 5v14zm-2-2v-1.5h-5V17h5z"></path></g>
<g id="landscape"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="leak-add"><path d="M6 3H3v3c1.66 0 3-1.34 3-3zm8 0h-2c0 4.97-4.03 9-9 9v2c6.08 0 11-4.93 11-11zm-4 0H8c0 2.76-2.24 5-5 5v2c3.87 0 7-3.13 7-7zm0 18h2c0-4.97 4.03-9 9-9v-2c-6.07 0-11 4.93-11 11zm8 0h3v-3c-1.66 0-3 1.34-3 3zm-4 0h2c0-2.76 2.24-5 5-5v-2c-3.87 0-7 3.13-7 7z"></path></g>
<g id="leak-remove"><path d="M10 3H8c0 .37-.04.72-.12 1.06l1.59 1.59C9.81 4.84 10 3.94 10 3zM3 4.27l2.84 2.84C5.03 7.67 4.06 8 3 8v2c1.61 0 3.09-.55 4.27-1.46L8.7 9.97C7.14 11.24 5.16 12 3 12v2c2.71 0 5.19-.99 7.11-2.62l2.5 2.5C10.99 15.81 10 18.29 10 21h2c0-2.16.76-4.14 2.03-5.69l1.43 1.43C14.55 17.91 14 19.39 14 21h2c0-1.06.33-2.03.89-2.84L19.73 21 21 19.73 4.27 3 3 4.27zM14 3h-2c0 1.5-.37 2.91-1.02 4.16l1.46 1.46C13.42 6.98 14 5.06 14 3zm5.94 13.12c.34-.08.69-.12 1.06-.12v-2c-.94 0-1.84.19-2.66.52l1.6 1.6zm-4.56-4.56l1.46 1.46C18.09 12.37 19.5 12 21 12v-2c-2.06 0-3.98.58-5.62 1.56z"></path></g>
<g id="lens"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"></path></g>
<g id="linked-camera"><circle cx="12" cy="14" r="3.2"></circle><path d="M16 3.33c2.58 0 4.67 2.09 4.67 4.67H22c0-3.31-2.69-6-6-6v1.33M16 6c1.11 0 2 .89 2 2h1.33c0-1.84-1.49-3.33-3.33-3.33V6"></path><path d="M17 9c0-1.11-.89-2-2-2V4H9L7.17 6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9h-5zm-5 10c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="looks"><path d="M12 10c-3.86 0-7 3.14-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.86-3.14-7-7-7zm0-4C5.93 6 1 10.93 1 17h2c0-4.96 4.04-9 9-9s9 4.04 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="looks-3"><path d="M19.01 3h-14c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 7.5c0 .83-.67 1.5-1.5 1.5.83 0 1.5.67 1.5 1.5V15c0 1.11-.9 2-2 2h-4v-2h4v-2h-2v-2h2V9h-4V7h4c1.1 0 2 .89 2 2v1.5z"></path></g>
<g id="looks-4"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 14h-2v-4H9V7h2v4h2V7h2v10z"></path></g>
<g id="looks-5"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2H9v-2h4v-2H9V7h6v2z"></path></g>
<g id="looks-6"><path d="M11 15h2v-2h-2v2zm8-12H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2h-2c-1.1 0-2-.89-2-2V9c0-1.11.9-2 2-2h4v2z"></path></g>
<g id="looks-one"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-5 14h-2V9h-2V7h4v10z"></path></g>
<g id="looks-two"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 8c0 1.11-.9 2-2 2h-2v2h4v2H9v-4c0-1.11.9-2 2-2h2V9H9V7h4c1.1 0 2 .89 2 2v2z"></path></g>
<g id="loupe"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10h8c1.1 0 2-.9 2-2v-8c0-5.51-4.49-10-10-10zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="monochrome-photos"><path d="M20 5h-3.2L15 3H9L7.2 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-8v-1c-2.8 0-5-2.2-5-5s2.2-5 5-5V7h8v12zm-3-6c0-2.8-2.2-5-5-5v1.8c1.8 0 3.2 1.4 3.2 3.2s-1.4 3.2-3.2 3.2V18c2.8 0 5-2.2 5-5zm-8.2 0c0 1.8 1.4 3.2 3.2 3.2V9.8c-1.8 0-3.2 1.4-3.2 3.2z"></path></g>
<g id="movie-creation"><path d="M18 4l2 4h-3l-2-4h-2l2 4h-3l-2-4H8l2 4H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4z"></path></g>
<g id="movie-filter"><path d="M18 4l2 3h-3l-2-3h-2l2 3h-3l-2-3H8l2 3H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4zm-6.75 11.25L10 18l-1.25-2.75L6 14l2.75-1.25L10 10l1.25 2.75L14 14l-2.75 1.25zm5.69-3.31L16 14l-.94-2.06L13 11l2.06-.94L16 8l.94 2.06L19 11l-2.06.94z"></path></g>
<g id="music-note"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"></path></g>
<g id="nature"><path d="M13 16.12c3.47-.41 6.17-3.36 6.17-6.95 0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H5v2h14v-2h-6v-3.88z"></path></g>
<g id="nature-people"><path d="M22.17 9.17c0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H6v-3h1v-4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v4h1v5h16v-2h-3v-3.88c3.47-.41 6.17-3.36 6.17-6.95zM4.5 11c.83 0 1.5-.67 1.5-1.5S5.33 8 4.5 8 3 8.67 3 9.5 3.67 11 4.5 11z"></path></g>
<g id="navigate-before"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="navigate-next"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="palette"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="panorama"><path d="M23 18V6c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zM8.5 12.5l2.5 3.01L14.5 11l4.5 6H5l3.5-4.5z"></path></g>
<g id="panorama-fish-eye"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="panorama-horizontal"><path d="M20 6.54v10.91c-2.6-.77-5.28-1.16-8-1.16-2.72 0-5.4.39-8 1.16V6.54c2.6.77 5.28 1.16 8 1.16 2.72.01 5.4-.38 8-1.16M21.43 4c-.1 0-.2.02-.31.06C18.18 5.16 15.09 5.7 12 5.7c-3.09 0-6.18-.55-9.12-1.64-.11-.04-.22-.06-.31-.06-.34 0-.57.23-.57.63v14.75c0 .39.23.62.57.62.1 0 .2-.02.31-.06 2.94-1.1 6.03-1.64 9.12-1.64 3.09 0 6.18.55 9.12 1.64.11.04.21.06.31.06.33 0 .57-.23.57-.63V4.63c0-.4-.24-.63-.57-.63z"></path></g>
<g id="panorama-vertical"><path d="M19.94 21.12c-1.1-2.94-1.64-6.03-1.64-9.12 0-3.09.55-6.18 1.64-9.12.04-.11.06-.22.06-.31 0-.34-.23-.57-.63-.57H4.63c-.4 0-.63.23-.63.57 0 .1.02.2.06.31C5.16 5.82 5.71 8.91 5.71 12c0 3.09-.55 6.18-1.64 9.12-.05.11-.07.22-.07.31 0 .33.23.57.63.57h14.75c.39 0 .63-.24.63-.57-.01-.1-.03-.2-.07-.31zM6.54 20c.77-2.6 1.16-5.28 1.16-8 0-2.72-.39-5.4-1.16-8h10.91c-.77 2.6-1.16 5.28-1.16 8 0 2.72.39 5.4 1.16 8H6.54z"></path></g>
<g id="panorama-wide-angle"><path d="M12 6c2.45 0 4.71.2 7.29.64.47 1.78.71 3.58.71 5.36 0 1.78-.24 3.58-.71 5.36-2.58.44-4.84.64-7.29.64s-4.71-.2-7.29-.64C4.24 15.58 4 13.78 4 12c0-1.78.24-3.58.71-5.36C7.29 6.2 9.55 6 12 6m0-2c-2.73 0-5.22.24-7.95.72l-.93.16-.25.9C2.29 7.85 2 9.93 2 12s.29 4.15.87 6.22l.25.89.93.16c2.73.49 5.22.73 7.95.73s5.22-.24 7.95-.72l.93-.16.25-.89c.58-2.08.87-4.16.87-6.23s-.29-4.15-.87-6.22l-.25-.89-.93-.16C17.22 4.24 14.73 4 12 4z"></path></g>
<g id="photo"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="photo-album"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4zm0 15l3-3.86 2.14 2.58 3-3.86L18 19H6z"></path></g>
<g id="photo-camera"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="photo-filter"><path d="M19.02 10v9H5V5h9V3H5.02c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-9h-2zM17 10l.94-2.06L20 7l-2.06-.94L17 4l-.94 2.06L14 7l2.06.94zm-3.75.75L12 8l-1.25 2.75L8 12l2.75 1.25L12 16l1.25-2.75L16 12z"></path></g>
<g id="photo-library"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="photo-size-select-actual"><path d="M21 3H3C2 3 1 4 1 5v14c0 1.1.9 2 2 2h18c1 0 2-1 2-2V5c0-1-1-2-2-2zM5 17l3.5-4.5 2.5 3.01L14.5 11l4.5 6H5z"></path></g>
<g id="photo-size-select-large"><path d="M21 15h2v2h-2v-2zm0-4h2v2h-2v-2zm2 8h-2v2c1 0 2-1 2-2zM13 3h2v2h-2V3zm8 4h2v2h-2V7zm0-4v2h2c0-1-1-2-2-2zM1 7h2v2H1V7zm16-4h2v2h-2V3zm0 16h2v2h-2v-2zM3 3C2 3 1 4 1 5h2V3zm6 0h2v2H9V3zM5 3h2v2H5V3zm-4 8v8c0 1.1.9 2 2 2h12V11H1zm2 8l2.5-3.21 1.79 2.15 2.5-3.22L13 19H3z"></path></g>
<g id="photo-size-select-small"><path d="M23 15h-2v2h2v-2zm0-4h-2v2h2v-2zm0 8h-2v2c1 0 2-1 2-2zM15 3h-2v2h2V3zm8 4h-2v2h2V7zm-2-4v2h2c0-1-1-2-2-2zM3 21h8v-6H1v4c0 1.1.9 2 2 2zM3 7H1v2h2V7zm12 12h-2v2h2v-2zm4-16h-2v2h2V3zm0 16h-2v2h2v-2zM3 3C2 3 1 4 1 5h2V3zm0 8H1v2h2v-2zm8-8H9v2h2V3zM7 3H5v2h2V3z"></path></g>
<g id="picture-as-pdf"><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"></path></g>
<g id="portrait"><path d="M12 12.25c1.24 0 2.25-1.01 2.25-2.25S13.24 7.75 12 7.75 9.75 8.76 9.75 10s1.01 2.25 2.25 2.25zm4.5 4c0-1.5-3-2.25-4.5-2.25s-4.5.75-4.5 2.25V17h9v-.75zM19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="remove-red-eye"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="rotate-90-degrees-ccw"><path d="M7.34 6.41L.86 12.9l6.49 6.48 6.49-6.48-6.5-6.49zM3.69 12.9l3.66-3.66L11 12.9l-3.66 3.66-3.65-3.66zm15.67-6.26C17.61 4.88 15.3 4 13 4V.76L8.76 5 13 9.24V6c1.79 0 3.58.68 4.95 2.05 2.73 2.73 2.73 7.17 0 9.9C16.58 19.32 14.79 20 13 20c-.97 0-1.94-.21-2.84-.61l-1.49 1.49C10.02 21.62 11.51 22 13 22c2.3 0 4.61-.88 6.36-2.64 3.52-3.51 3.52-9.21 0-12.72z"></path></g>
<g id="rotate-left"><path d="M7.11 8.53L5.7 7.11C4.8 8.27 4.24 9.61 4.07 11h2.02c.14-.87.49-1.72 1.02-2.47zM6.09 13H4.07c.17 1.39.72 2.73 1.62 3.89l1.41-1.42c-.52-.75-.87-1.59-1.01-2.47zm1.01 5.32c1.16.9 2.51 1.44 3.9 1.61V17.9c-.87-.15-1.71-.49-2.46-1.03L7.1 18.32zM13 4.07V1L8.45 5.55 13 10V6.09c2.84.48 5 2.94 5 5.91s-2.16 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93s-3.05-7.44-7-7.93z"></path></g>
<g id="rotate-right"><path d="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02c-2.84-.48-5-2.94-5-5.91s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-.17-1.39-.72-2.73-1.62-3.89l-1.42 1.42c.54.75.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-.17 2.74-.71 3.9-1.61l-1.44-1.44c-.75.54-1.59.89-2.46 1.03zm3.89-2.42l1.42 1.41c.9-1.16 1.45-2.5 1.62-3.89h-2.02c-.14.87-.48 1.72-1.02 2.48z"></path></g>
<g id="slideshow"><path d="M10 8v8l5-4-5-4zm9-5H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="straighten"><path d="M21 6H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H3V8h2v4h2V8h2v4h2V8h2v4h2V8h2v4h2V8h2v8z"></path></g>
<g id="style"><path d="M2.53 19.65l1.34.56v-9.03l-2.43 5.86c-.41 1.02.08 2.19 1.09 2.61zm19.5-3.7L17.07 3.98c-.31-.75-1.04-1.21-1.81-1.23-.26 0-.53.04-.79.15L7.1 5.95c-.75.31-1.21 1.03-1.23 1.8-.01.27.04.54.15.8l4.96 11.97c.31.76 1.05 1.22 1.83 1.23.26 0 .52-.05.77-.15l7.36-3.05c1.02-.42 1.51-1.59 1.09-2.6zM7.88 8.75c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-2 11c0 1.1.9 2 2 2h1.45l-3.45-8.34v6.34z"></path></g>
<g id="switch-camera"><path d="M20 4h-3.17L15 2H9L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-5 11.5V13H9v2.5L5.5 12 9 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="switch-video"><path d="M18 9.5V6c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1v-3.5l4 4v-13l-4 4zm-5 6V13H7v2.5L3.5 12 7 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="tag-faces"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"></path></g>
<g id="texture"><path d="M19.51 3.08L3.08 19.51c.09.34.27.65.51.9.25.24.56.42.9.51L20.93 4.49c-.19-.69-.73-1.23-1.42-1.41zM11.88 3L3 11.88v2.83L14.71 3h-2.83zM5 3c-1.1 0-2 .9-2 2v2l4-4H5zm14 18c.55 0 1.05-.22 1.41-.59.37-.36.59-.86.59-1.41v-2l-4 4h2zm-9.71 0h2.83L21 12.12V9.29L9.29 21z"></path></g>
<g id="timelapse"><path d="M16.24 7.76C15.07 6.59 13.54 6 12 6v6l-4.24 4.24c2.34 2.34 6.14 2.34 8.49 0 2.34-2.34 2.34-6.14-.01-8.48zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="timer"><path d="M15 1H9v2h6V1zm-4 13h2V8h-2v6zm8.03-6.61l1.42-1.42c-.43-.51-.9-.99-1.41-1.41l-1.42 1.42C16.07 4.74 14.12 4 12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9 9-4.03 9-9c0-2.12-.74-4.07-1.97-5.61zM12 20c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="timer-10"><path d="M0 7.72V9.4l3-1V18h2V6h-.25L0 7.72zm23.78 6.65c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39 0-.14.03-.28.09-.41.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59C21.49 9.07 21 9 20.46 9c-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.69.23.96c.15.28.36.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02zm-9.96-7.32c-.34-.4-.75-.7-1.23-.88-.47-.18-1.01-.27-1.59-.27-.58 0-1.11.09-1.59.27-.48.18-.89.47-1.23.88-.34.41-.6.93-.79 1.59-.18.65-.28 1.45-.28 2.39v1.92c0 .94.09 1.74.28 2.39.19.66.45 1.19.8 1.6.34.41.75.71 1.23.89.48.18 1.01.28 1.59.28.59 0 1.12-.09 1.59-.28.48-.18.88-.48 1.22-.89.34-.41.6-.94.78-1.6.18-.65.28-1.45.28-2.39v-1.92c0-.94-.09-1.74-.28-2.39-.18-.66-.44-1.19-.78-1.59zm-.92 6.17c0 .6-.04 1.11-.12 1.53-.08.42-.2.76-.36 1.02-.16.26-.36.45-.59.57-.23.12-.51.18-.82.18-.3 0-.58-.06-.82-.18s-.44-.31-.6-.57c-.16-.26-.29-.6-.38-1.02-.09-.42-.13-.93-.13-1.53v-2.5c0-.6.04-1.11.13-1.52.09-.41.21-.74.38-1 .16-.25.36-.43.6-.55.24-.11.51-.17.81-.17.31 0 .58.06.81.17.24.11.44.29.6.55.16.25.29.58.37.99.08.41.13.92.13 1.52v2.51z"></path></g>
<g id="timer-3"><path d="M11.61 12.97c-.16-.24-.36-.46-.62-.65-.25-.19-.56-.35-.93-.48.3-.14.57-.3.8-.5.23-.2.42-.41.57-.64.15-.23.27-.46.34-.71.08-.24.11-.49.11-.73 0-.55-.09-1.04-.28-1.46-.18-.42-.44-.77-.78-1.06-.33-.28-.73-.5-1.2-.64-.45-.13-.97-.2-1.53-.2-.55 0-1.06.08-1.52.24-.47.17-.87.4-1.2.69-.33.29-.6.63-.78 1.03-.2.39-.29.83-.29 1.29h1.98c0-.26.05-.49.14-.69.09-.2.22-.38.38-.52.17-.14.36-.25.58-.33.22-.08.46-.12.73-.12.61 0 1.06.16 1.36.47.3.31.44.75.44 1.32 0 .27-.04.52-.12.74-.08.22-.21.41-.38.57-.17.16-.38.28-.63.37-.25.09-.55.13-.89.13H6.72v1.57H7.9c.34 0 .64.04.91.11.27.08.5.19.69.35.19.16.34.36.44.61.1.24.16.54.16.87 0 .62-.18 1.09-.53 1.42-.35.33-.84.49-1.45.49-.29 0-.56-.04-.8-.13-.24-.08-.44-.2-.61-.36-.17-.16-.3-.34-.39-.56-.09-.22-.14-.46-.14-.72H4.19c0 .55.11 1.03.32 1.45.21.42.5.77.86 1.05s.77.49 1.24.63.96.21 1.48.21c.57 0 1.09-.08 1.58-.23.49-.15.91-.38 1.26-.68.36-.3.64-.66.84-1.1.2-.43.3-.93.3-1.48 0-.29-.04-.58-.11-.86-.08-.25-.19-.51-.35-.76zm9.26 1.4c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39s.03-.28.09-.41c.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59-.43-.15-.92-.22-1.46-.22-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.68.23.96c.15.28.37.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02z"></path></g>
<g id="timer-off"><path d="M19.04 4.55l-1.42 1.42C16.07 4.74 14.12 4 12 4c-1.83 0-3.53.55-4.95 1.48l1.46 1.46C9.53 6.35 10.73 6 12 6c3.87 0 7 3.13 7 7 0 1.27-.35 2.47-.94 3.49l1.45 1.45C20.45 16.53 21 14.83 21 13c0-2.12-.74-4.07-1.97-5.61l1.42-1.42-1.41-1.42zM15 1H9v2h6V1zm-4 8.44l2 2V8h-2v1.44zM3.02 4L1.75 5.27 4.5 8.03C3.55 9.45 3 11.16 3 13c0 4.97 4.02 9 9 9 1.84 0 3.55-.55 4.98-1.5l2.5 2.5 1.27-1.27-7.71-7.71L3.02 4zM12 20c-3.87 0-7-3.13-7-7 0-1.28.35-2.48.95-3.52l9.56 9.56c-1.03.61-2.23.96-3.51.96z"></path></g>
<g id="tonality"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-1 17.93c-3.94-.49-7-3.85-7-7.93s3.05-7.44 7-7.93v15.86zm2-15.86c1.03.13 2 .45 2.87.93H13v-.93zM13 7h5.24c.25.31.48.65.68 1H13V7zm0 3h6.74c.08.33.15.66.19 1H13v-1zm0 9.93V19h2.87c-.87.48-1.84.8-2.87.93zM18.24 17H13v-1h5.92c-.2.35-.43.69-.68 1zm1.5-3H13v-1h6.93c-.04.34-.11.67-.19 1z"></path></g>
<g id="transform"><path d="M22 18v-2H8V4h2L7 1 4 4h2v2H2v2h4v8c0 1.1.9 2 2 2h8v2h-2l3 3 3-3h-2v-2h4zM10 8h6v6h2V8c0-1.1-.9-2-2-2h-6v2z"></path></g>
<g id="tune"><path d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"></path></g>
<g id="view-comfy"><path d="M3 9h4V5H3v4zm0 5h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zM8 9h4V5H8v4zm5-4v4h4V5h-4zm5 9h4v-4h-4v4zM3 19h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zm5 0h4v-4h-4v4zm0-14v4h4V5h-4z"></path></g>
<g id="view-compact"><path d="M3 19h6v-7H3v7zm7 0h12v-7H10v7zM3 5v6h19V5H3z"></path></g>
<g id="vignette"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-9 15c-4.42 0-8-2.69-8-6s3.58-6 8-6 8 2.69 8 6-3.58 6-8 6z"></path></g>
<g id="wb-auto"><path d="M6.85 12.65h2.3L8 9l-1.15 3.65zM22 7l-1.2 6.29L19.3 7h-1.6l-1.49 6.29L15 7h-.76C12.77 5.17 10.53 4 8 4c-4.42 0-8 3.58-8 8s3.58 8 8 8c3.13 0 5.84-1.81 7.15-4.43l.1.43H17l1.5-6.1L20 16h1.75l2.05-9H22zm-11.7 9l-.7-2H6.4l-.7 2H3.8L7 7h2l3.2 9h-1.9z"></path></g>
<g id="wb-cloudy"><path d="M19.36 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.64-4.96z"></path></g>
<g id="wb-incandescent"><path d="M3.55 18.54l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8zM11 22.45h2V19.5h-2v2.95zM4 10.5H1v2h3v-2zm11-4.19V1.5H9v4.81C7.21 7.35 6 9.28 6 11.5c0 3.31 2.69 6 6 6s6-2.69 6-6c0-2.22-1.21-4.15-3-5.19zm5 4.19v2h3v-2h-3zm-2.76 7.66l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4z"></path></g>
<g id="wb-iridescent"><path d="M5 14.5h14v-6H5v6zM11 .55V3.5h2V.55h-2zm8.04 2.5l-1.79 1.79 1.41 1.41 1.8-1.79-1.42-1.41zM13 22.45V19.5h-2v2.95h2zm7.45-3.91l-1.8-1.79-1.41 1.41 1.79 1.8 1.42-1.42zM3.55 4.46l1.79 1.79 1.41-1.41-1.79-1.79-1.41 1.41zm1.41 15.49l1.79-1.8-1.41-1.41-1.79 1.79 1.41 1.42z"></path></g>
<g id="wb-sunny"><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(ybe.content);var vbe=Q`<iron-iconset-svg name="icons" size="24">
<svg><defs>
<g id="3d-rotation"><path d="M7.52 21.48C4.25 19.94 1.91 16.76 1.55 13H.05C.56 19.16 5.71 24 12 24l.66-.03-3.81-3.81-1.33 1.32zm.89-6.52c-.19 0-.37-.03-.52-.08-.16-.06-.29-.13-.4-.24-.11-.1-.2-.22-.26-.37-.06-.14-.09-.3-.09-.47h-1.3c0 .36.07.68.21.95.14.27.33.5.56.69.24.18.51.32.82.41.3.1.62.15.96.15.37 0 .72-.05 1.03-.15.32-.1.6-.25.83-.44s.42-.43.55-.72c.13-.29.2-.61.2-.97 0-.19-.02-.38-.07-.56-.05-.18-.12-.35-.23-.51-.1-.16-.24-.3-.4-.43-.17-.13-.37-.23-.61-.31.2-.09.37-.2.52-.33.15-.13.27-.27.37-.42.1-.15.17-.3.22-.46.05-.16.07-.32.07-.48 0-.36-.06-.68-.18-.96-.12-.28-.29-.51-.51-.69-.2-.19-.47-.33-.77-.43C9.1 8.05 8.76 8 8.39 8c-.36 0-.69.05-1 .16-.3.11-.57.26-.79.45-.21.19-.38.41-.51.67-.12.26-.18.54-.18.85h1.3c0-.17.03-.32.09-.45s.14-.25.25-.34c.11-.09.23-.17.38-.22.15-.05.3-.08.48-.08.4 0 .7.1.89.31.19.2.29.49.29.86 0 .18-.03.34-.08.49-.05.15-.14.27-.25.37-.11.1-.25.18-.41.24-.16.06-.36.09-.58.09H7.5v1.03h.77c.22 0 .42.02.6.07s.33.13.45.23c.12.11.22.24.29.4.07.16.1.35.1.57 0 .41-.12.72-.35.93-.23.23-.55.33-.95.33zm8.55-5.92c-.32-.33-.7-.59-1.14-.77-.43-.18-.92-.27-1.46-.27H12v8h2.3c.55 0 1.06-.09 1.51-.27.45-.18.84-.43 1.16-.76.32-.33.57-.73.74-1.19.17-.47.26-.99.26-1.57v-.4c0-.58-.09-1.1-.26-1.57-.18-.47-.43-.87-.75-1.2zm-.39 3.16c0 .42-.05.79-.14 1.13-.1.33-.24.62-.43.85-.19.23-.43.41-.71.53-.29.12-.62.18-.99.18h-.91V9.12h.97c.72 0 1.27.23 1.64.69.38.46.57 1.12.57 1.99v.4zM12 0l-.66.03 3.81 3.81 1.33-1.33c3.27 1.55 5.61 4.72 5.96 8.48h1.5C23.44 4.84 18.29 0 12 0z"></path></g>
<g id="accessibility"><path d="M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z"></path></g>
<g id="accessible"><circle cx="12" cy="4" r="2"></circle><path d="M19 13v-2c-1.54.02-3.09-.75-4.07-1.83l-1.29-1.43c-.17-.19-.38-.34-.61-.45-.01 0-.01-.01-.02-.01H13c-.35-.2-.75-.3-1.19-.26C10.76 7.11 10 8.04 10 9.09V15c0 1.1.9 2 2 2h5v5h2v-5.5c0-1.1-.9-2-2-2h-3v-3.45c1.29 1.07 3.25 1.94 5 1.95zm-6.17 5c-.41 1.16-1.52 2-2.83 2-1.66 0-3-1.34-3-3 0-1.31.84-2.41 2-2.83V12.1c-2.28.46-4 2.48-4 4.9 0 2.76 2.24 5 5 5 2.42 0 4.44-1.72 4.9-4h-2.07z"></path></g>
<g id="account-balance"><path d="M4 10v7h3v-7H4zm6 0v7h3v-7h-3zM2 22h19v-3H2v3zm14-12v7h3v-7h-3zm-4.5-9L2 6v2h19V6l-9.5-5z"></path></g>
<g id="account-balance-wallet"><path d="M21 18v1c0 1.1-.9 2-2 2H5c-1.11 0-2-.9-2-2V5c0-1.1.89-2 2-2h14c1.1 0 2 .9 2 2v1h-9c-1.11 0-2 .9-2 2v8c0 1.1.89 2 2 2h9zm-9-2h10V8H12v8zm4-2.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="account-box"><path d="M3 5v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2H5c-1.11 0-2 .9-2 2zm12 4c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3zm-9 8c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1H6v-1z"></path></g>
<g id="account-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm0 14.2c-2.5 0-4.71-1.28-6-3.22.03-1.99 4-3.08 6-3.08 1.99 0 5.97 1.09 6 3.08-1.29 1.94-3.5 3.22-6 3.22z"></path></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path></g>
<g id="add-alert"><path d="M10.01 21.01c0 1.1.89 1.99 1.99 1.99s1.99-.89 1.99-1.99h-3.98zm8.87-4.19V11c0-3.25-2.25-5.97-5.29-6.69v-.72C13.59 2.71 12.88 2 12 2s-1.59.71-1.59 1.59v.72C7.37 5.03 5.12 7.75 5.12 11v5.82L3 18.94V20h18v-1.06l-2.12-2.12zM16 13.01h-3v3h-2v-3H8V11h3V8h2v3h3v2.01z"></path></g>
<g id="add-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle-outline"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="add-shopping-cart"><path d="M11 9h2V6h3V4h-3V1h-2v3H8v2h3v3zm-4 9c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zm10 0c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2zm-9.83-3.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.86-7.01L19.42 4h-.01l-1.1 2-2.76 5H8.53l-.13-.27L6.16 6l-.95-2-.94-2H1v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.13 0-.25-.11-.25-.25z"></path></g>
<g id="alarm"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="alarm-add"><path d="M7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm1-11h-2v3H8v2h3v3h2v-3h3v-2h-3V9z"></path></g>
<g id="alarm-off"><path d="M12 6c3.87 0 7 3.13 7 7 0 .84-.16 1.65-.43 2.4l1.52 1.52c.58-1.19.91-2.51.91-3.92 0-4.97-4.03-9-9-9-1.41 0-2.73.33-3.92.91L9.6 6.43C10.35 6.16 11.16 6 12 6zm10-.28l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM2.92 2.29L1.65 3.57 2.98 4.9l-1.11.93 1.42 1.42 1.11-.94.8.8C3.83 8.69 3 10.75 3 13c0 4.97 4.02 9 9 9 2.25 0 4.31-.83 5.89-2.2l2.2 2.2 1.27-1.27L3.89 3.27l-.97-.98zm13.55 16.1C15.26 19.39 13.7 20 12 20c-3.87 0-7-3.13-7-7 0-1.7.61-3.26 1.61-4.47l9.86 9.86zM8.02 3.28L6.6 1.86l-.86.71 1.42 1.42.86-.71z"></path></g>
<g id="alarm-on"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm-1.46-5.47L8.41 12.4l-1.06 1.06 3.18 3.18 6-6-1.06-1.06-4.93 4.95z"></path></g>
<g id="all-out"><path d="M16.21 4.16l4 4v-4zm4 12l-4 4h4zm-12 4l-4-4v4zm-4-12l4-4h-4zm12.95-.95c-2.73-2.73-7.17-2.73-9.9 0s-2.73 7.17 0 9.9 7.17 2.73 9.9 0 2.73-7.16 0-9.9zm-1.1 8.8c-2.13 2.13-5.57 2.13-7.7 0s-2.13-5.57 0-7.7 5.57-2.13 7.7 0 2.13 5.57 0 7.7z"></path></g>
<g id="android"><path d="M6 18c0 .55.45 1 1 1h1v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h2v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h1c.55 0 1-.45 1-1V8H6v10zM3.5 8C2.67 8 2 8.67 2 9.5v7c0 .83.67 1.5 1.5 1.5S5 17.33 5 16.5v-7C5 8.67 4.33 8 3.5 8zm17 0c-.83 0-1.5.67-1.5 1.5v7c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5v-7c0-.83-.67-1.5-1.5-1.5zm-4.97-5.84l1.3-1.3c.2-.2.2-.51 0-.71-.2-.2-.51-.2-.71 0l-1.48 1.48C13.85 1.23 12.95 1 12 1c-.96 0-1.86.23-2.66.63L7.85.15c-.2-.2-.51-.2-.71 0-.2.2-.2.51 0 .71l1.31 1.31C6.97 3.26 6 5.01 6 7h12c0-1.99-.97-3.75-2.47-4.84zM10 5H9V4h1v1zm5 0h-1V4h1v1z"></path></g>
<g id="announcement"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 9h-2V5h2v6zm0 4h-2v-2h2v2z"></path></g>
<g id="apps"><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"></path></g>
<g id="archive"><path d="M20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27zM12 17.5L6.5 12H10v-2h4v2h3.5L12 17.5zM5.12 5l.81-1h12l.94 1H5.12z"></path></g>
<g id="arrow-back"><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"></path></g>
<g id="arrow-downward"><path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"></path></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
<g id="arrow-drop-down-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"></path></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z"></path></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"></path></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"></path></g>
<g id="aspect-ratio"><path d="M19 12h-2v3h-3v2h5v-5zM7 9h3V7H5v5h2V9zm14-6H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="assessment"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"></path></g>
<g id="assignment"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"></path></g>
<g id="assignment-ind"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 4c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1.4c0-2 4-3.1 6-3.1s6 1.1 6 3.1V19z"></path></g>
<g id="assignment-late"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-6 15h-2v-2h2v2zm0-4h-2V8h2v6zm-1-9c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1z"></path></g>
<g id="assignment-return"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm4 12h-4v3l-5-5 5-5v3h4v4z"></path></g>
<g id="assignment-returned"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 15l-5-5h3V9h4v4h3l-5 5z"></path></g>
<g id="assignment-turned-in"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-2 14l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="attachment"><path d="M2 12.5C2 9.46 4.46 7 7.5 7H18c2.21 0 4 1.79 4 4s-1.79 4-4 4H9.5C8.12 15 7 13.88 7 12.5S8.12 10 9.5 10H17v2H9.41c-.55 0-.55 1 0 1H18c1.1 0 2-.9 2-2s-.9-2-2-2H7.5C5.57 9 4 10.57 4 12.5S5.57 16 7.5 16H17v2H7.5C4.46 18 2 15.54 2 12.5z"></path></g>
<g id="autorenew"><path d="M12 6v3l4-4-4-4v3c-4.42 0-8 3.58-8 8 0 1.57.46 3.03 1.24 4.26L6.7 14.8c-.45-.83-.7-1.79-.7-2.8 0-3.31 2.69-6 6-6zm6.76 1.74L17.3 9.2c.44.84.7 1.79.7 2.8 0 3.31-2.69 6-6 6v-3l-4 4 4 4v-3c4.42 0 8-3.58 8-8 0-1.57-.46-3.03-1.24-4.26z"></path></g>
<g id="backspace"><path d="M22 3H7c-.69 0-1.23.35-1.59.88L0 12l5.41 8.11c.36.53.9.89 1.59.89h15c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-3 12.59L17.59 17 14 13.41 10.41 17 9 15.59 12.59 12 9 8.41 10.41 7 14 10.59 17.59 7 19 8.41 15.41 12 19 15.59z"></path></g>
<g id="backup"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="block"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM4 12c0-4.42 3.58-8 8-8 1.85 0 3.55.63 4.9 1.69L5.69 16.9C4.63 15.55 4 13.85 4 12zm8 8c-1.85 0-3.55-.63-4.9-1.69L18.31 7.1C19.37 8.45 20 10.15 20 12c0 4.42-3.58 8-8 8z"></path></g>
<g id="book"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="bookmark"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="bookmark-border"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="bug-report"><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"></path></g>
<g id="build"><path d="M22.7 19l-9.1-9.1c.9-2.3.4-5-1.5-6.9-2-2-5-2.4-7.4-1.3L9 6 6 9 1.6 4.7C.4 7.1.9 10.1 2.9 12.1c1.9 1.9 4.6 2.4 6.9 1.5l9.1 9.1c.4.4 1 .4 1.4 0l2.3-2.3c.5-.4.5-1.1.1-1.4z"></path></g>
<g id="cached"><path d="M19 8l-4 4h3c0 3.31-2.69 6-6 6-1.01 0-1.97-.25-2.8-.7l-1.46 1.46C8.97 19.54 10.43 20 12 20c4.42 0 8-3.58 8-8h3l-4-4zM6 12c0-3.31 2.69-6 6-6 1.01 0 1.97.25 2.8.7l1.46-1.46C15.03 4.46 13.57 4 12 4c-4.42 0-8 3.58-8 8H1l4 4 4-4H6z"></path></g>
<g id="camera-enhance"><path d="M9 3L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2h-3.17L15 3H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-1l1.25-2.75L16 13l-2.75-1.25L12 9l-1.25 2.75L8 13l2.75 1.25z"></path></g>
<g id="cancel"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path></g>
<g id="card-giftcard"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="card-membership"><path d="M20 2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h4v5l4-2 4 2v-5h4c1.11 0 2-.89 2-2V4c0-1.11-.89-2-2-2zm0 13H4v-2h16v2zm0-5H4V4h16v6z"></path></g>
<g id="card-travel"><path d="M20 6h-3V4c0-1.11-.89-2-2-2H9c-1.11 0-2 .89-2 2v2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zM9 4h6v2H9V4zm11 15H4v-2h16v2zm0-5H4V8h3v2h2V8h6v2h2V8h3v6z"></path></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"></path></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g>
<g id="check-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="check-box-outline-blank"><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="check-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="chrome-reader-mode"><path d="M13 12h7v1.5h-7zm0-2.5h7V11h-7zm0 5h7V16h-7zM21 4H3c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 15h-9V6h9v13z"></path></g>
<g id="class"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="clear"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="close"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="cloud"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96z"></path></g>
<g id="cloud-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.5 14H8c-1.66 0-3-1.34-3-3s1.34-3 3-3l.14.01C8.58 8.28 10.13 7 12 7c2.21 0 4 1.79 4 4h.5c1.38 0 2.5 1.12 2.5 2.5S17.88 16 16.5 16z"></path></g>
<g id="cloud-done"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM10 17l-3.5-3.5 1.41-1.41L10 14.17 15.18 9l1.41 1.41L10 17z"></path></g>
<g id="cloud-download"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z"></path></g>
<g id="cloud-off"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4c-1.48 0-2.85.43-4.01 1.17l1.46 1.46C10.21 6.23 11.08 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3 0 1.13-.64 2.11-1.56 2.62l1.45 1.45C23.16 18.16 24 16.68 24 15c0-2.64-2.05-4.78-4.65-4.96zM3 5.27l2.75 2.74C2.56 8.15 0 10.77 0 14c0 3.31 2.69 6 6 6h11.73l2 2L21 20.73 4.27 4 3 5.27zM7.73 10l8 8H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h1.73z"></path></g>
<g id="cloud-queue"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h.71C7.37 7.69 9.48 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3s-1.34 3-3 3z"></path></g>
<g id="cloud-upload"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="code"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"></path></g>
<g id="content-copy"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></g>
<g id="content-cut"><path d="M9.64 7.64c.23-.5.36-1.05.36-1.64 0-2.21-1.79-4-4-4S2 3.79 2 6s1.79 4 4 4c.59 0 1.14-.13 1.64-.36L10 12l-2.36 2.36C7.14 14.13 6.59 14 6 14c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4c0-.59-.13-1.14-.36-1.64L12 14l7 7h3v-1L9.64 7.64zM6 8c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm0 12c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm6-7.5c-.28 0-.5-.22-.5-.5s.22-.5.5-.5.5.22.5.5-.22.5-.5.5zM19 3l-6 6 2 2 7-7V3z"></path></g>
<g id="content-paste"><path d="M19 2h-4.18C14.4.84 13.3 0 12 0c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm7 18H5V4h2v3h10V4h2v16z"></path></g>
<g id="copyright"><path d="M10.08 10.86c.05-.33.16-.62.3-.87s.34-.46.59-.62c.24-.15.54-.22.91-.23.23.01.44.05.63.13.2.09.38.21.52.36s.25.33.34.53.13.42.14.64h1.79c-.02-.47-.11-.9-.28-1.29s-.4-.73-.7-1.01-.66-.5-1.08-.66-.88-.23-1.39-.23c-.65 0-1.22.11-1.7.34s-.88.53-1.2.92-.56.84-.71 1.36S8 11.29 8 11.87v.27c0 .58.08 1.12.23 1.64s.39.97.71 1.35.72.69 1.2.91 1.05.34 1.7.34c.47 0 .91-.08 1.32-.23s.77-.36 1.08-.63.56-.58.74-.94.29-.74.3-1.15h-1.79c-.01.21-.06.4-.15.58s-.21.33-.36.46-.32.23-.52.3c-.19.07-.39.09-.6.1-.36-.01-.66-.08-.89-.23-.25-.16-.45-.37-.59-.62s-.25-.55-.3-.88-.08-.67-.08-1v-.27c0-.35.03-.68.08-1.01zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="create"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="create-new-folder"><path d="M20 6h-8l-2-2H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-1 8h-3v3h-2v-3h-3v-2h3V9h2v3h3v2z"></path></g>
<g id="credit-card"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z"></path></g>
<g id="date-range"><path d="M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"></path></g>
<g id="delete"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-forever"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12l1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-sweep"><path d="M15 16h4v2h-4zm0-8h7v2h-7zm0 4h6v2h-6zM3 18c0 1.1.9 2 2 2h6c1.1 0 2-.9 2-2V8H3v10zM14 5h-3l-1-1H6L5 5H2v2h12z"></path></g>
<g id="description"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 16H8v-2h8v2zm0-4H8v-2h8v2zm-3-5V3.5L18.5 9H13z"></path></g>
<g id="dns"><path d="M20 13H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zM7 19c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM20 3H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1zM7 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"></path></g>
<g id="done-all"><path d="M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z"></path></g>
<g id="donut-large"><path d="M11 5.08V2c-5 .5-9 4.81-9 10s4 9.5 9 10v-3.08c-3-.48-6-3.4-6-6.92s3-6.44 6-6.92zM18.97 11H22c-.47-5-4-8.53-9-9v3.08C16 5.51 18.54 8 18.97 11zM13 18.92V22c5-.47 8.53-4 9-9h-3.03c-.43 3-2.97 5.49-5.97 5.92z"></path></g>
<g id="donut-small"><path d="M11 9.16V2c-5 .5-9 4.79-9 10s4 9.5 9 10v-7.16c-1-.41-2-1.52-2-2.84s1-2.43 2-2.84zM14.86 11H22c-.48-4.75-4-8.53-9-9v7.16c1 .3 1.52.98 1.86 1.84zM13 14.84V22c5-.47 8.52-4.25 9-9h-7.14c-.34.86-.86 1.54-1.86 1.84z"></path></g>
<g id="drafts"><path d="M21.99 8c0-.72-.37-1.35-.94-1.7L12 1 2.95 6.3C2.38 6.65 2 7.28 2 8v10c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2l-.01-10zM12 13L3.74 7.84 12 3l8.26 4.84L12 13z"></path></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z"></path></g>
<g id="error"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"></path></g>
<g id="error-outline"><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="euro-symbol"><path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z"></path></g>
<g id="event"><path d="M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"></path></g>
<g id="event-seat"><path d="M4 18v3h3v-3h10v3h3v-6H4zm15-8h3v3h-3zM2 10h3v3H2zm15 3H7V5c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v8z"></path></g>
<g id="exit-to-app"><path d="M10.09 15.59L11.5 17l5-5-5-5-1.41 1.41L12.67 11H3v2h9.67l-2.58 2.59zM19 3H5c-1.11 0-2 .9-2 2v4h2V5h14v14H5v-4H3v4c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"></path></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"></path></g>
<g id="explore"><path d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"></path></g>
<g id="extension"><path d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"></path></g>
<g id="face"><path d="M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z"></path></g>
<g id="favorite"><path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"></path></g>
<g id="favorite-border"><path d="M16.5 3c-1.74 0-3.41.81-4.5 2.09C10.91 3.81 9.24 3 7.5 3 4.42 3 2 5.42 2 8.5c0 3.78 3.4 6.86 8.55 11.54L12 21.35l1.45-1.32C18.6 15.36 22 12.28 22 8.5 22 5.42 19.58 3 16.5 3zm-4.4 15.55l-.1.1-.1-.1C7.14 14.24 4 11.39 4 8.5 4 6.5 5.5 5 7.5 5c1.54 0 3.04.99 3.57 2.36h1.87C13.46 5.99 14.96 5 16.5 5c2 0 3.5 1.5 3.5 3.5 0 2.89-3.14 5.74-7.9 10.05z"></path></g>
<g id="feedback"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 12h-2v-2h2v2zm0-4h-2V6h2v4z"></path></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z"></path></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"></path></g>
<g id="find-in-page"><path d="M20 19.59V8l-6-6H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c.45 0 .85-.15 1.19-.4l-4.43-4.43c-.8.52-1.74.83-2.76.83-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5c0 1.02-.31 1.96-.83 2.75L20 19.59zM9 13c0 1.66 1.34 3 3 3s3-1.34 3-3-1.34-3-3-3-3 1.34-3 3z"></path></g>
<g id="find-replace"><path d="M11 6c1.38 0 2.63.56 3.54 1.46L12 10h6V4l-2.05 2.05C14.68 4.78 12.93 4 11 4c-3.53 0-6.43 2.61-6.92 6H6.1c.46-2.28 2.48-4 4.9-4zm5.64 9.14c.66-.9 1.12-1.97 1.28-3.14H15.9c-.46 2.28-2.48 4-4.9 4-1.38 0-2.63-.56-3.54-1.46L10 12H4v6l2.05-2.05C7.32 17.22 9.07 18 11 18c1.55 0 2.98-.51 4.14-1.36L20 21.49 21.49 20l-4.85-4.86z"></path></g>
<g id="fingerprint"><path d="M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.47.38z"></path></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"></path></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="flight-land"><path d="M2.5 19h19v2h-19zm7.18-5.73l4.35 1.16 5.31 1.42c.8.21 1.62-.26 1.84-1.06.21-.8-.26-1.62-1.06-1.84l-5.31-1.42-2.76-9.02L10.12 2v8.28L5.15 8.95l-.93-2.32-1.45-.39v5.17l1.6.43 5.31 1.43z"></path></g>
<g id="flight-takeoff"><path d="M2.5 19h19v2h-19zm19.57-9.36c-.21-.8-1.04-1.28-1.84-1.06L14.92 10l-6.9-6.43-1.93.51 4.14 7.17-4.97 1.33-1.97-1.54-1.45.39 1.82 3.16.77 1.33 1.6-.43 5.31-1.42 4.35-1.16L21 11.49c.81-.23 1.28-1.05 1.07-1.85z"></path></g>
<g id="flip-to-back"><path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8c-1.11 0-2 .9-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2c0-1.1-.9-2-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.89 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zM5 7H3v12c0 1.1.89 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"></path></g>
<g id="flip-to-front"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"></path></g>
<g id="folder"><path d="M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"></path></g>
<g id="folder-open"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z"></path></g>
<g id="folder-shared"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-5 3c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm4 8h-8v-1c0-1.33 2.67-2 4-2s4 .67 4 2v1z"></path></g>
<g id="font-download"><path d="M9.93 13.5h4.14L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-4.05 16.5l-1.14-3H9.17l-1.12 3H5.96l5.11-13h1.86l5.11 13h-2.09z"></path></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z"></path></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"></path></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"></path></g>
<g id="g-translate"><path d="M20 5h-9.12L10 2H4c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h7l1 3h8c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zM7.17 14.59c-2.25 0-4.09-1.83-4.09-4.09s1.83-4.09 4.09-4.09c1.04 0 1.99.37 2.74 1.07l.07.06-1.23 1.18-.06-.05c-.29-.27-.78-.59-1.52-.59-1.31 0-2.38 1.09-2.38 2.42s1.07 2.42 2.38 2.42c1.37 0 1.96-.87 2.12-1.46H7.08V9.91h3.95l.01.07c.04.21.05.4.05.61 0 2.35-1.61 4-3.92 4zm6.03-1.71c.33.6.74 1.18 1.19 1.7l-.54.53-.65-2.23zm.77-.76h-.99l-.31-1.04h3.99s-.34 1.31-1.56 2.74c-.52-.62-.89-1.23-1.13-1.7zM21 20c0 .55-.45 1-1 1h-7l2-2-.81-2.77.92-.92L17.79 18l.73-.73-2.71-2.68c.9-1.03 1.6-2.25 1.92-3.51H19v-1.04h-3.64V9h-1.04v1.04h-1.96L11.18 6H20c.55 0 1 .45 1 1v13z"></path></g>
<g id="gavel"><path d="M1 21h12v2H1zM5.245 8.07l2.83-2.827 14.14 14.142-2.828 2.828zM12.317 1l5.657 5.656-2.83 2.83-5.654-5.66zM3.825 9.485l5.657 5.657-2.828 2.828-5.657-5.657z"></path></g>
<g id="gesture"><path d="M4.59 6.89c.7-.71 1.4-1.35 1.71-1.22.5.2 0 1.03-.3 1.52-.25.42-2.86 3.89-2.86 6.31 0 1.28.48 2.34 1.34 2.98.75.56 1.74.73 2.64.46 1.07-.31 1.95-1.4 3.06-2.77 1.21-1.49 2.83-3.44 4.08-3.44 1.63 0 1.65 1.01 1.76 1.79-3.78.64-5.38 3.67-5.38 5.37 0 1.7 1.44 3.09 3.21 3.09 1.63 0 4.29-1.33 4.69-6.1H21v-2.5h-2.47c-.15-1.65-1.09-4.2-4.03-4.2-2.25 0-4.18 1.91-4.94 2.84-.58.73-2.06 2.48-2.29 2.72-.25.3-.68.84-1.11.84-.45 0-.72-.83-.36-1.92.35-1.09 1.4-2.86 1.85-3.52.78-1.14 1.3-1.92 1.3-3.28C8.95 3.69 7.31 3 6.44 3 5.12 3 3.97 4 3.72 4.25c-.36.36-.66.66-.88.93l1.75 1.71zm9.29 11.66c-.31 0-.74-.26-.74-.72 0-.6.73-2.2 2.87-2.76-.3 2.69-1.43 3.48-2.13 3.48z"></path></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="gif"><path d="M11.5 9H13v6h-1.5zM9 9H6c-.6 0-1 .5-1 1v4c0 .5.4 1 1 1h3c.6 0 1-.5 1-1v-2H8.5v1.5h-2v-3H10V10c0-.5-.4-1-1-1zm10 1.5V9h-4.5v6H16v-2h2v-1.5h-2v-1z"></path></g>
<g id="grade"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="group-work"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="help"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"></path></g>
<g id="help-outline"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"></path></g>
<g id="highlight-off"><path d="M14.59 8L12 10.59 9.41 8 8 9.41 10.59 12 8 14.59 9.41 16 12 13.41 14.59 16 16 14.59 13.41 12 16 9.41 14.59 8zM12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="history"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"></path></g>
<g id="hourglass-empty"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6zm10 14.5V20H8v-3.5l4-4 4 4zm-4-5l-4-4V4h8v3.5l-4 4z"></path></g>
<g id="hourglass-full"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6z"></path></g>
<g id="http"><path d="M4.5 11h-2V9H1v6h1.5v-2.5h2V15H6V9H4.5v2zm2.5-.5h1.5V15H10v-4.5h1.5V9H7v1.5zm5.5 0H14V15h1.5v-4.5H17V9h-4.5v1.5zm9-1.5H18v6h1.5v-2h2c.8 0 1.5-.7 1.5-1.5v-1c0-.8-.7-1.5-1.5-1.5zm0 2.5h-2v-1h2v1z"></path></g>
<g id="https"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="important-devices"><path d="M23 11.01L18 11c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5c.55 0 1-.45 1-1v-9c0-.55-.45-.99-1-.99zM23 20h-5v-7h5v7zM20 2H2C.89 2 0 2.89 0 4v12c0 1.1.89 2 2 2h7v2H7v2h8v-2h-2v-2h2v-2H2V4h18v5h2V4c0-1.11-.9-2-2-2zm-8.03 7L11 6l-.97 3H7l2.47 1.76-.94 2.91 2.47-1.8 2.47 1.8-.94-2.91L15 9h-3.03z"></path></g>
<g id="inbox"><path d="M19 3H4.99c-1.11 0-1.98.89-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.11-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10z"></path></g>
<g id="indeterminate-check-box"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></path></g>
<g id="info"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"></path></g>
<g id="info-outline"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"></path></g>
<g id="input"><path d="M21 3.01H3c-1.1 0-2 .9-2 2V9h2V4.99h18v14.03H3V15H1v4.01c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98v-14c0-1.11-.9-2-2-2zM11 16l4-4-4-4v3H1v2h10v3z"></path></g>
<g id="invert-colors"><path d="M17.66 7.93L12 2.27 6.34 7.93c-3.12 3.12-3.12 8.19 0 11.31C7.9 20.8 9.95 21.58 12 21.58c2.05 0 4.1-.78 5.66-2.34 3.12-3.12 3.12-8.19 0-11.31zM12 19.59c-1.6 0-3.11-.62-4.24-1.76C6.62 16.69 6 15.19 6 13.59s.62-3.11 1.76-4.24L12 5.1v14.49z"></path></g>
<g id="label"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16z"></path></g>
<g id="label-outline"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16zM16 17H5V7h11l3.55 5L16 17z"></path></g>
<g id="language"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm6.93 6h-2.95c-.32-1.25-.78-2.45-1.38-3.56 1.84.63 3.37 1.91 4.33 3.56zM12 4.04c.83 1.2 1.48 2.53 1.91 3.96h-3.82c.43-1.43 1.08-2.76 1.91-3.96zM4.26 14C4.1 13.36 4 12.69 4 12s.1-1.36.26-2h3.38c-.08.66-.14 1.32-.14 2 0 .68.06 1.34.14 2H4.26zm.82 2h2.95c.32 1.25.78 2.45 1.38 3.56-1.84-.63-3.37-1.9-4.33-3.56zm2.95-8H5.08c.96-1.66 2.49-2.93 4.33-3.56C8.81 5.55 8.35 6.75 8.03 8zM12 19.96c-.83-1.2-1.48-2.53-1.91-3.96h3.82c-.43 1.43-1.08 2.76-1.91 3.96zM14.34 14H9.66c-.09-.66-.16-1.32-.16-2 0-.68.07-1.35.16-2h4.68c.09.65.16 1.32.16 2 0 .68-.07 1.34-.16 2zm.25 5.56c.6-1.11 1.06-2.31 1.38-3.56h2.95c-.96 1.65-2.49 2.93-4.33 3.56zM16.36 14c.08-.66.14-1.32.14-2 0-.68-.06-1.34-.14-2h3.38c.16.64.26 1.31.26 2s-.1 1.36-.26 2h-3.38z"></path></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"></path></g>
<g id="launch"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="lightbulb-outline"><path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6C7.8 12.16 7 10.63 7 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path></g>
<g id="line-style"><path d="M3 16h5v-2H3v2zm6.5 0h5v-2h-5v2zm6.5 0h5v-2h-5v2zM3 20h2v-2H3v2zm4 0h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM3 12h8v-2H3v2zm10 0h8v-2h-8v2zM3 4v4h18V4H3z"></path></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z"></path></g>
<g id="link"><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"></path></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"></path></g>
<g id="lock"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="lock-open"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6h1.9c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm0 12H6V10h12v10z"></path></g>
<g id="lock-outline"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM8.9 6c0-1.71 1.39-3.1 3.1-3.1s3.1 1.39 3.1 3.1v2H8.9V6zM18 20H6V10h12v10z"></path></g>
<g id="low-priority"><path d="M14 5h8v2h-8zm0 5.5h8v2h-8zm0 5.5h8v2h-8zM2 11.5C2 15.08 4.92 18 8.5 18H9v2l3-3-3-3v2h-.5C6.02 16 4 13.98 4 11.5S6.02 7 8.5 7H12V5H8.5C4.92 5 2 7.92 2 11.5z"></path></g>
<g id="loyalty"><path d="M21.41 11.58l-9-9C12.05 2.22 11.55 2 11 2H4c-1.1 0-2 .9-2 2v7c0 .55.22 1.05.59 1.42l9 9c.36.36.86.58 1.41.58.55 0 1.05-.22 1.41-.59l7-7c.37-.36.59-.86.59-1.41 0-.55-.23-1.06-.59-1.42zM5.5 7C4.67 7 4 6.33 4 5.5S4.67 4 5.5 4 7 4.67 7 5.5 6.33 7 5.5 7zm11.77 8.27L13 19.54l-4.27-4.27C8.28 14.81 8 14.19 8 13.5c0-1.38 1.12-2.5 2.5-2.5.69 0 1.32.28 1.77.74l.73.72.73-.73c.45-.45 1.08-.73 1.77-.73 1.38 0 2.5 1.12 2.5 2.5 0 .69-.28 1.32-.73 1.77z"></path></g>
<g id="mail"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread-mailbox"><path d="M20 6H10v6H8V4h6V0H6v6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2z"></path></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"></path></g>
<g id="more-horiz"><path d="M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="more-vert"><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="motorcycle"><path d="M19.44 9.03L15.41 5H11v2h3.59l2 2H5c-2.8 0-5 2.2-5 5s2.2 5 5 5c2.46 0 4.45-1.69 4.9-4h1.65l2.77-2.77c-.21.54-.32 1.14-.32 1.77 0 2.8 2.2 5 5 5s5-2.2 5-5c0-2.65-1.97-4.77-4.56-4.97zM7.82 15C7.4 16.15 6.28 17 5 17c-1.63 0-3-1.37-3-3s1.37-3 3-3c1.28 0 2.4.85 2.82 2H5v2h2.82zM19 17c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3z"></path></g>
<g id="move-to-inbox"><path d="M19 3H4.99c-1.11 0-1.98.9-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10zm-3-5h-2V7h-4v3H8l4 4 4-4z"></path></g>
<g id="next-week"><path d="M20 7h-4V5c0-.55-.22-1.05-.59-1.41C15.05 3.22 14.55 3 14 3h-4c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v11c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zM10 5h4v2h-4V5zm1 13.5l-1-1 3-3-3-3 1-1 4 4-4 4z"></path></g>
<g id="note-add"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 14h-3v3h-2v-3H8v-2h3v-3h2v3h3v2zm-3-7V3.5L18.5 9H13z"></path></g>
<g id="offline-pin"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"></path></g>
<g id="opacity"><path d="M17.66 8L12 2.35 6.34 8C4.78 9.56 4 11.64 4 13.64s.78 4.11 2.34 5.67 3.61 2.35 5.66 2.35 4.1-.79 5.66-2.35S20 15.64 20 13.64 19.22 9.56 17.66 8zM6 14c.01-2 .62-3.27 1.76-4.4L12 5.27l4.24 4.38C17.38 10.77 17.99 12 18 14H6z"></path></g>
<g id="open-in-browser"><path d="M19 4H5c-1.11 0-2 .9-2 2v12c0 1.1.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-.9 2-2V6c0-1.1-.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"></path></g>
<g id="open-in-new"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="open-with"><path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"></path></g>
<g id="pageview"><path d="M11.5 9C10.12 9 9 10.12 9 11.5s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5S12.88 9 11.5 9zM20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3.21 14.21l-2.91-2.91c-.69.44-1.51.7-2.39.7C9.01 16 7 13.99 7 11.5S9.01 7 11.5 7 16 9.01 16 11.5c0 .88-.26 1.69-.7 2.39l2.91 2.9-1.42 1.42z"></path></g>
<g id="pan-tool"><path d="M23 5.5V20c0 2.2-1.8 4-4 4h-7.3c-1.08 0-2.1-.43-2.85-1.19L1 14.83s1.26-1.23 1.3-1.25c.22-.19.49-.29.79-.29.22 0 .42.06.6.16.04.01 4.31 2.46 4.31 2.46V4c0-.83.67-1.5 1.5-1.5S11 3.17 11 4v7h1V1.5c0-.83.67-1.5 1.5-1.5S15 .67 15 1.5V11h1V2.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5V11h1V5.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5z"></path></g>
<g id="payment"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="perm-camera-mic"><path d="M20 5h-3.17L15 3H9L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h7v-2.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V21h7c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-6 8c0 1.1-.9 2-2 2s-2-.9-2-2V9c0-1.1.9-2 2-2s2 .9 2 2v4z"></path></g>
<g id="perm-contact-calendar"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1z"></path></g>
<g id="perm-data-setting"><path d="M18.99 11.5c.34 0 .67.03 1 .07L20 0 0 20h11.56c-.04-.33-.07-.66-.07-1 0-4.14 3.36-7.5 7.5-7.5zm3.71 7.99c.02-.16.04-.32.04-.49 0-.17-.01-.33-.04-.49l1.06-.83c.09-.08.12-.21.06-.32l-1-1.73c-.06-.11-.19-.15-.31-.11l-1.24.5c-.26-.2-.54-.37-.85-.49l-.19-1.32c-.01-.12-.12-.21-.24-.21h-2c-.12 0-.23.09-.25.21l-.19 1.32c-.3.13-.59.29-.85.49l-1.24-.5c-.11-.04-.24 0-.31.11l-1 1.73c-.06.11-.04.24.06.32l1.06.83c-.02.16-.03.32-.03.49 0 .17.01.33.03.49l-1.06.83c-.09.08-.12.21-.06.32l1 1.73c.06.11.19.15.31.11l1.24-.5c.26.2.54.37.85.49l.19 1.32c.02.12.12.21.25.21h2c.12 0 .23-.09.25-.21l.19-1.32c.3-.13.59-.29.84-.49l1.25.5c.11.04.24 0 .31-.11l1-1.73c.06-.11.03-.24-.06-.32l-1.07-.83zm-3.71 1.01c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="perm-device-information"><path d="M13 7h-2v2h2V7zm0 4h-2v6h2v-6zm4-9.99L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14z"></path></g>
<g id="perm-identity"><path d="M12 5.9c1.16 0 2.1.94 2.1 2.1s-.94 2.1-2.1 2.1S9.9 9.16 9.9 8s.94-2.1 2.1-2.1m0 9c2.97 0 6.1 1.46 6.1 2.1v1.1H5.9V17c0-.64 3.13-2.1 6.1-2.1M12 4C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 9c-2.67 0-8 1.34-8 4v3h16v-3c0-2.66-5.33-4-8-4z"></path></g>
<g id="perm-media"><path d="M2 6H0v5h.01L0 20c0 1.1.9 2 2 2h18v-2H2V6zm20-2h-8l-2-2H6c-1.1 0-1.99.9-1.99 2L4 16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM7 15l4.5-6 3.5 4.51 2.5-3.01L21 15H7z"></path></g>
<g id="perm-phone-msg"><path d="M20 15.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM12 3v10l3-3h6V3h-9z"></path></g>
<g id="perm-scan-wifi"><path d="M12 3C6.95 3 3.15 4.85 0 7.23L12 22 24 7.25C20.85 4.87 17.05 3 12 3zm1 13h-2v-6h2v6zm-2-8V6h2v2h-2z"></path></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5"></circle><circle cx="9" cy="5.5" r="2.5"></circle><circle cx="15" cy="5.5" r="2.5"></circle><circle cx="19.5" cy="9.5" r="2.5"></circle><path d="M17.34 14.86c-.87-1.02-1.6-1.89-2.48-2.91-.46-.54-1.05-1.08-1.75-1.32-.11-.04-.22-.07-.33-.09-.25-.04-.52-.04-.78-.04s-.53 0-.79.05c-.11.02-.22.05-.33.09-.7.24-1.28.78-1.75 1.32-.87 1.02-1.6 1.89-2.48 2.91-1.31 1.31-2.92 2.76-2.62 4.79.29 1.02 1.02 2.03 2.33 2.32.73.15 3.06-.44 5.54-.44h.18c2.48 0 4.81.58 5.54.44 1.31-.29 2.04-1.31 2.33-2.32.31-2.04-1.3-3.49-2.61-4.8z"></path></g>
<g id="picture-in-picture"><path d="M19 7h-8v6h8V7zm2-4H3c-1.1 0-2 .9-2 2v14c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98V5c0-1.1-.9-2-2-2zm0 16.01H3V4.98h18v14.03z"></path></g>
<g id="picture-in-picture-alt"><path d="M19 11h-8v6h8v-6zm4 8V4.98C23 3.88 22.1 3 21 3H3c-1.1 0-2 .88-2 1.98V19c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zm-2 .02H3V4.97h18v14.05z"></path></g>
<g id="play-for-work"><path d="M11 5v5.59H7.5l4.5 4.5 4.5-4.5H13V5h-2zm-5 9c0 3.31 2.69 6 6 6s6-2.69 6-6h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6z"></path></g>
<g id="polymer"><path d="M19 4h-4L7.11 16.63 4.5 12 9 4H5L.5 12 5 20h4l7.89-12.63L19.5 12 15 20h4l4.5-8z"></path></g>
<g id="power-settings-new"><path d="M13 3h-2v10h2V3zm4.83 2.17l-1.42 1.42C17.99 7.86 19 9.81 19 12c0 3.87-3.13 7-7 7s-7-3.13-7-7c0-2.19 1.01-4.14 2.58-5.42L6.17 5.17C4.23 6.82 3 9.26 3 12c0 4.97 4.03 9 9 9s9-4.03 9-9c0-2.74-1.23-5.18-3.17-6.83z"></path></g>
<g id="pregnant-woman"><path d="M9 4c0-1.11.89-2 2-2s2 .89 2 2-.89 2-2 2-2-.89-2-2zm7 9c-.01-1.34-.83-2.51-2-3 0-1.66-1.34-3-3-3s-3 1.34-3 3v7h2v5h3v-5h3v-4z"></path></g>
<g id="print"><path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z"></path></g>
<g id="query-builder"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="question-answer"><path d="M21 6h-2v9H6v2c0 .55.45 1 1 1h11l4 4V7c0-.55-.45-1-1-1zm-4 6V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14l4-4h10c.55 0 1-.45 1-1z"></path></g>
<g id="radio-button-checked"><path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="radio-button-unchecked"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="receipt"><path d="M18 17H6v-2h12v2zm0-4H6v-2h12v2zm0-4H6V7h12v2zM3 22l1.5-1.5L6 22l1.5-1.5L9 22l1.5-1.5L12 22l1.5-1.5L15 22l1.5-1.5L18 22l1.5-1.5L21 22V2l-1.5 1.5L18 2l-1.5 1.5L15 2l-1.5 1.5L12 2l-1.5 1.5L9 2 7.5 3.5 6 2 4.5 3.5 3 2v20z"></path></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4"></circle><path d="M9 15c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4zm7.76-9.64l-1.68 1.69c.84 1.18.84 2.71 0 3.89l1.68 1.69c2.02-2.02 2.02-5.07 0-7.27zM20.07 2l-1.63 1.63c2.77 3.02 2.77 7.56 0 10.74L20.07 16c3.9-3.89 3.91-9.95 0-14z"></path></g>
<g id="redeem"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="redo"><path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z"></path></g>
<g id="refresh"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"></path></g>
<g id="remove"><path d="M19 13H5v-2h14v2z"></path></g>
<g id="remove-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"></path></g>
<g id="remove-circle-outline"><path d="M7 11v2h10v-2H7zm5-9C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="remove-shopping-cart"><path d="M22.73 22.73L2.77 2.77 2 2l-.73-.73L0 2.54l4.39 4.39 2.21 4.66-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h7.46l1.38 1.38c-.5.36-.83.95-.83 1.62 0 1.1.89 2 1.99 2 .67 0 1.26-.33 1.62-.84L21.46 24l1.27-1.27zM7.42 15c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h2.36l2 2H7.42zm8.13-2c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H6.54l9.01 9zM7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2z"></path></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z"></path></g>
<g id="reply"><path d="M10 9V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="reply-all"><path d="M7 8V5l-7 7 7 7v-3l-4-4 4-4zm6 1V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="report"><path d="M15.73 3H8.27L3 8.27v7.46L8.27 21h7.46L21 15.73V8.27L15.73 3zM12 17.3c-.72 0-1.3-.58-1.3-1.3 0-.72.58-1.3 1.3-1.3.72 0 1.3.58 1.3 1.3 0 .72-.58 1.3-1.3 1.3zm1-4.3h-2V7h2v6z"></path></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="restore"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="restore-page"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm-2 16c-2.05 0-3.81-1.24-4.58-3h1.71c.63.9 1.68 1.5 2.87 1.5 1.93 0 3.5-1.57 3.5-3.5S13.93 9.5 12 9.5c-1.35 0-2.52.78-3.1 1.9l1.6 1.6h-4V9l1.3 1.3C8.69 8.92 10.23 8 12 8c2.76 0 5 2.24 5 5s-2.24 5-5 5z"></path></g>
<g id="room"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="rounded-corner"><path d="M19 19h2v2h-2v-2zm0-2h2v-2h-2v2zM3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm0-4h2V3H3v2zm4 0h2V3H7v2zm8 16h2v-2h-2v2zm-4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm-8 0h2v-2H7v2zm-4 0h2v-2H3v2zM21 8c0-2.76-2.24-5-5-5h-5v2h5c1.65 0 3 1.35 3 3v5h2V8z"></path></g>
<g id="rowing"><path d="M8.5 14.5L4 19l1.5 1.5L9 17h2l-2.5-2.5zM15 1c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 20.01L18 24l-2.99-3.01V19.5l-7.1-7.09c-.31.05-.61.07-.91.07v-2.16c1.66.03 3.61-.87 4.67-2.04l1.4-1.55c.19-.21.43-.38.69-.5.29-.14.62-.23.96-.23h.03C15.99 6.01 17 7.02 17 8.26v5.75c0 .84-.35 1.61-.92 2.16l-3.58-3.58v-2.27c-.63.52-1.43 1.02-2.29 1.39L16.5 18H18l3 3.01z"></path></g>
<g id="save"><path d="M17 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"></path></g>
<g id="schedule"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="search"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path></g>
<g id="select-all"><path d="M3 5h2V3c-1.1 0-2 .9-2 2zm0 8h2v-2H3v2zm4 8h2v-2H7v2zM3 9h2V7H3v2zm10-6h-2v2h2V3zm6 0v2h2c0-1.1-.9-2-2-2zM5 21v-2H3c0 1.1.9 2 2 2zm-2-4h2v-2H3v2zM9 3H7v2h2V3zm2 18h2v-2h-2v2zm8-8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zm0-12h2V7h-2v2zm0 8h2v-2h-2v2zm-4 4h2v-2h-2v2zm0-16h2V3h-2v2zM7 17h10V7H7v10zm2-8h6v6H9V9z"></path></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"></path></g>
<g id="settings"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"></path></g>
<g id="settings-applications"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm7-7H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-1.75 9c0 .23-.02.46-.05.68l1.48 1.16c.13.11.17.3.08.45l-1.4 2.42c-.09.15-.27.21-.43.15l-1.74-.7c-.36.28-.76.51-1.18.69l-.26 1.85c-.03.17-.18.3-.35.3h-2.8c-.17 0-.32-.13-.35-.29l-.26-1.85c-.43-.18-.82-.41-1.18-.69l-1.74.7c-.16.06-.34 0-.43-.15l-1.4-2.42c-.09-.15-.05-.34.08-.45l1.48-1.16c-.03-.23-.05-.46-.05-.69 0-.23.02-.46.05-.68l-1.48-1.16c-.13-.11-.17-.3-.08-.45l1.4-2.42c.09-.15.27-.21.43-.15l1.74.7c.36-.28.76-.51 1.18-.69l.26-1.85c.03-.17.18-.3.35-.3h2.8c.17 0 .32.13.35.29l.26 1.85c.43.18.82.41 1.18.69l1.74-.7c.16-.06.34 0 .43.15l1.4 2.42c.09.15.05.34-.08.45l-1.48 1.16c.03.23.05.46.05.69z"></path></g>
<g id="settings-backup-restore"><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"></path></g>
<g id="settings-bluetooth"><path d="M11 24h2v-2h-2v2zm-4 0h2v-2H7v2zm8 0h2v-2h-2v2zm2.71-18.29L12 0h-1v7.59L6.41 3 5 4.41 10.59 10 5 15.59 6.41 17 11 12.41V20h1l5.71-5.71-4.3-4.29 4.3-4.29zM13 3.83l1.88 1.88L13 7.59V3.83zm1.88 10.46L13 16.17v-3.76l1.88 1.88z"></path></g>
<g id="settings-brightness"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02zM8 16h2.5l1.5 1.5 1.5-1.5H16v-2.5l1.5-1.5-1.5-1.5V8h-2.5L12 6.5 10.5 8H8v2.5L6.5 12 8 13.5V16zm4-7c1.66 0 3 1.34 3 3s-1.34 3-3 3V9z"></path></g>
<g id="settings-cell"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM16 .01L8 0C6.9 0 6 .9 6 2v16c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V2c0-1.1-.9-1.99-2-1.99zM16 16H8V4h8v12z"></path></g>
<g id="settings-ethernet"><path d="M7.77 6.76L6.23 5.48.82 12l5.41 6.52 1.54-1.28L3.42 12l4.35-5.24zM7 13h2v-2H7v2zm10-2h-2v2h2v-2zm-6 2h2v-2h-2v2zm6.77-7.52l-1.54 1.28L20.58 12l-4.35 5.24 1.54 1.28L23.18 12l-5.41-6.52z"></path></g>
<g id="settings-input-antenna"><path d="M12 5c-3.87 0-7 3.13-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.87-3.13-7-7-7zm1 9.29c.88-.39 1.5-1.26 1.5-2.29 0-1.38-1.12-2.5-2.5-2.5S9.5 10.62 9.5 12c0 1.02.62 1.9 1.5 2.29v3.3L7.59 21 9 22.41l3-3 3 3L16.41 21 13 17.59v-3.3zM12 1C5.93 1 1 5.93 1 12h2c0-4.97 4.03-9 9-9s9 4.03 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="settings-input-component"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-composite"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-hdmi"><path d="M18 7V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v3H5v6l3 6v3h8v-3l3-6V7h-1zM8 4h8v3h-2V5h-1v2h-2V5h-1v2H8V4z"></path></g>
<g id="settings-input-svideo"><path d="M8 11.5c0-.83-.67-1.5-1.5-1.5S5 10.67 5 11.5 5.67 13 6.5 13 8 12.33 8 11.5zm7-5c0-.83-.67-1.5-1.5-1.5h-3C9.67 5 9 5.67 9 6.5S9.67 8 10.5 8h3c.83 0 1.5-.67 1.5-1.5zM8.5 15c-.83 0-1.5.67-1.5 1.5S7.67 18 8.5 18s1.5-.67 1.5-1.5S9.33 15 8.5 15zM12 1C5.93 1 1 5.93 1 12s4.93 11 11 11 11-4.93 11-11S18.07 1 12 1zm0 20c-4.96 0-9-4.04-9-9s4.04-9 9-9 9 4.04 9 9-4.04 9-9 9zm5.5-11c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm-2 5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="settings-overscan"><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="settings-phone"><path d="M13 9h-2v2h2V9zm4 0h-2v2h2V9zm3 6.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM19 9v2h2V9h-2z"></path></g>
<g id="settings-power"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm2-22h-2v10h2V2zm3.56 2.44l-1.45 1.45C16.84 6.94 18 8.83 18 11c0 3.31-2.69 6-6 6s-6-2.69-6-6c0-2.17 1.16-4.06 2.88-5.12L7.44 4.44C5.36 5.88 4 8.28 4 11c0 4.42 3.58 8 8 8s8-3.58 8-8c0-2.72-1.36-5.12-3.44-6.56zM15 24h2v-2h-2v2z"></path></g>
<g id="settings-remote"><path d="M15 9H9c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h6c.55 0 1-.45 1-1V10c0-.55-.45-1-1-1zm-3 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM7.05 6.05l1.41 1.41C9.37 6.56 10.62 6 12 6s2.63.56 3.54 1.46l1.41-1.41C15.68 4.78 13.93 4 12 4s-3.68.78-4.95 2.05zM12 0C8.96 0 6.21 1.23 4.22 3.22l1.41 1.41C7.26 3.01 9.51 2 12 2s4.74 1.01 6.36 2.64l1.41-1.41C17.79 1.23 15.04 0 12 0z"></path></g>
<g id="settings-voice"><path d="M7 24h2v-2H7v2zm5-11c1.66 0 2.99-1.34 2.99-3L15 4c0-1.66-1.34-3-3-3S9 2.34 9 4v6c0 1.66 1.34 3 3 3zm-1 11h2v-2h-2v2zm4 0h2v-2h-2v2zm4-14h-1.7c0 3-2.54 5.1-5.3 5.1S6.7 13 6.7 10H5c0 3.41 2.72 6.23 6 6.72V20h2v-3.28c3.28-.49 6-3.31 6-6.72z"></path></g>
<g id="shop"><path d="M16 6V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H2v13c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6h-6zm-6-2h4v2h-4V4zM9 18V9l7.5 4L9 18z"></path></g>
<g id="shop-two"><path d="M3 9H1v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2H3V9zm15-4V3c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H5v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2V5h-5zm-6-2h4v2h-4V3zm0 12V8l5.5 3-5.5 4z"></path></g>
<g id="shopping-basket"><path d="M17.21 9l-4.38-6.56c-.19-.28-.51-.42-.83-.42-.32 0-.64.14-.83.43L6.79 9H2c-.55 0-1 .45-1 1 0 .09.01.18.04.27l2.54 9.27c.23.84 1 1.46 1.92 1.46h13c.92 0 1.69-.62 1.93-1.46l2.54-9.27L23 10c0-.55-.45-1-1-1h-4.79zM9 9l3-4.4L15 9H9zm3 8c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="shopping-cart"><path d="M7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zM1 2v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H5.21l-.94-2H1zm16 16c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"></path></g>
<g id="speaker-notes"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z"></path></g>
<g id="speaker-notes-off"><path d="M10.54 11l-.54-.54L7.54 8 6 6.46 2.38 2.84 1.27 1.73 0 3l2.01 2.01L2 22l4-4h9l5.73 5.73L22 22.46 17.54 18l-7-7zM8 14H6v-2h2v2zm-2-3V9l2 2H6zm14-9H4.08L10 7.92V6h8v2h-7.92l1 1H18v2h-4.92l6.99 6.99C21.14 17.95 22 17.08 22 16V4c0-1.1-.9-2-2-2z"></path></g>
<g id="spellcheck"><path d="M12.45 16h2.09L9.43 3H7.57L2.46 16h2.09l1.12-3h5.64l1.14 3zm-6.02-5L8.5 5.48 10.57 11H6.43zm15.16.59l-8.09 8.09L9.83 16l-1.41 1.41 5.09 5.09L23 13l-1.41-1.41z"></path></g>
<g id="star"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="star-border"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="star-half"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4V6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="stars"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm4.24 16L12 15.45 7.77 18l1.12-4.81-3.73-3.23 4.92-.42L12 5l1.92 4.53 4.92.42-3.73 3.23L16.23 18z"></path></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z"></path></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z"></path></g>
<g id="subdirectory-arrow-right"><path d="M19 15l-6 6-1.42-1.42L15.17 16H4V4h2v10h9.17l-3.59-3.58L13 9l6 6z"></path></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z"></path></g>
<g id="supervisor-account"><path d="M16.5 12c1.38 0 2.49-1.12 2.49-2.5S17.88 7 16.5 7C15.12 7 14 8.12 14 9.5s1.12 2.5 2.5 2.5zM9 11c1.66 0 2.99-1.34 2.99-3S10.66 5 9 5C7.34 5 6 6.34 6 8s1.34 3 3 3zm7.5 3c-1.83 0-5.5.92-5.5 2.75V19h11v-2.25c0-1.83-3.67-2.75-5.5-2.75zM9 13c-2.33 0-7 1.17-7 3.5V19h7v-2.25c0-.85.33-2.34 2.37-3.47C10.5 13.1 9.66 13 9 13z"></path></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z"></path></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z"></path></g>
<g id="swap-vertical-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM6.5 9L10 5.5 13.5 9H11v4H9V9H6.5zm11 6L14 18.5 10.5 15H13v-4h2v4h2.5z"></path></g>
<g id="system-update-alt"><path d="M12 16.5l4-4h-3v-9h-2v9H8l4 4zm9-13h-6v1.99h6v14.03H3V5.49h6V3.5H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-14c0-1.1-.9-2-2-2z"></path></g>
<g id="tab"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h10v4h8v10z"></path></g>
<g id="tab-unselected"><path d="M1 9h2V7H1v2zm0 4h2v-2H1v2zm0-8h2V3c-1.1 0-2 .9-2 2zm8 16h2v-2H9v2zm-8-4h2v-2H1v2zm2 4v-2H1c0 1.1.9 2 2 2zM21 3h-8v6h10V5c0-1.1-.9-2-2-2zm0 14h2v-2h-2v2zM9 5h2V3H9v2zM5 21h2v-2H5v2zM5 5h2V3H5v2zm16 16c1.1 0 2-.9 2-2h-2v2zm0-8h2v-2h-2v2zm-8 8h2v-2h-2v2zm4 0h2v-2h-2v2z"></path></g>
<g id="text-format"><path d="M5 17v2h14v-2H5zm4.5-4.2h5l.9 2.2h2.1L12.75 4h-1.5L6.5 15h2.1l.9-2.2zM12 5.98L13.87 11h-3.74L12 5.98z"></path></g>
<g id="theaters"><path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"></path></g>
<g id="thumb-down"><path d="M15 3H6c-.83 0-1.54.5-1.84 1.22l-3.02 7.05c-.09.23-.14.47-.14.73v1.91l.01.01L1 14c0 1.1.9 2 2 2h6.31l-.95 4.57-.03.32c0 .41.17.79.44 1.06L9.83 23l6.59-6.59c.36-.36.58-.86.58-1.41V5c0-1.1-.9-2-2-2zm4 0v12h4V3h-4z"></path></g>
<g id="thumb-up"><path d="M1 21h4V9H1v12zm22-11c0-1.1-.9-2-2-2h-6.31l.95-4.57.03-.32c0-.41-.17-.79-.44-1.06L14.17 1 7.59 7.59C7.22 7.95 7 8.45 7 9v10c0 1.1.9 2 2 2h9c.83 0 1.54-.5 1.84-1.22l3.02-7.05c.09-.23.14-.47.14-.73v-1.91l-.01-.01L23 10z"></path></g>
<g id="thumbs-up-down"><path d="M12 6c0-.55-.45-1-1-1H5.82l.66-3.18.02-.23c0-.31-.13-.59-.33-.8L5.38 0 .44 4.94C.17 5.21 0 5.59 0 6v6.5c0 .83.67 1.5 1.5 1.5h6.75c.62 0 1.15-.38 1.38-.91l2.26-5.29c.07-.17.11-.36.11-.55V6zm10.5 4h-6.75c-.62 0-1.15.38-1.38.91l-2.26 5.29c-.07.17-.11.36-.11.55V18c0 .55.45 1 1 1h5.18l-.66 3.18-.02.24c0 .31.13.59.33.8l.79.78 4.94-4.94c.27-.27.44-.65.44-1.06v-6.5c0-.83-.67-1.5-1.5-1.5z"></path></g>
<g id="timeline"><path d="M23 8c0 1.1-.9 2-2 2-.18 0-.35-.02-.51-.07l-3.56 3.55c.05.16.07.34.07.52 0 1.1-.9 2-2 2s-2-.9-2-2c0-.18.02-.36.07-.52l-2.55-2.55c-.16.05-.34.07-.52.07s-.36-.02-.52-.07l-4.55 4.56c.05.16.07.33.07.51 0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.18 0 .35.02.51.07l4.56-4.55C8.02 9.36 8 9.18 8 9c0-1.1.9-2 2-2s2 .9 2 2c0 .18-.02.36-.07.52l2.55 2.55c.16-.05.34-.07.52-.07s.36.02.52.07l3.55-3.56C19.02 8.35 19 8.18 19 8c0-1.1.9-2 2-2s2 .9 2 2z"></path></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z"></path></g>
<g id="today"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z"></path></g>
<g id="toll"><path d="M15 4c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm0 14c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zM3 12c0-2.61 1.67-4.83 4-5.65V4.26C3.55 5.15 1 8.27 1 12s2.55 6.85 6 7.74v-2.09c-2.33-.82-4-3.04-4-5.65z"></path></g>
<g id="touch-app"><path d="M9 11.24V7.5C9 6.12 10.12 5 11.5 5S14 6.12 14 7.5v3.74c1.21-.81 2-2.18 2-3.74C16 5.01 13.99 3 11.5 3S7 5.01 7 7.5c0 1.56.79 2.93 2 3.74zm9.84 4.63l-4.54-2.26c-.17-.07-.35-.11-.54-.11H13v-6c0-.83-.67-1.5-1.5-1.5S10 6.67 10 7.5v10.74l-3.43-.72c-.08-.01-.15-.03-.24-.03-.31 0-.59.13-.79.33l-.79.8 4.94 4.94c.27.27.65.44 1.06.44h6.79c.75 0 1.33-.55 1.44-1.28l.75-5.27c.01-.07.02-.14.02-.2 0-.62-.38-1.16-.91-1.38z"></path></g>
<g id="track-changes"><path d="M19.07 4.93l-1.41 1.41C19.1 7.79 20 9.79 20 12c0 4.42-3.58 8-8 8s-8-3.58-8-8c0-4.08 3.05-7.44 7-7.93v2.02C8.16 6.57 6 9.03 6 12c0 3.31 2.69 6 6 6s6-2.69 6-6c0-1.66-.67-3.16-1.76-4.24l-1.41 1.41C15.55 9.9 16 10.9 16 12c0 2.21-1.79 4-4 4s-4-1.79-4-4c0-1.86 1.28-3.41 3-3.86v2.14c-.6.35-1 .98-1 1.72 0 1.1.9 2 2 2s2-.9 2-2c0-.74-.4-1.38-1-1.72V2h-1C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10c0-2.76-1.12-5.26-2.93-7.07z"></path></g>
<g id="translate"><path d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></g>
<g id="trending-down"><path d="M16 18l2.29-2.29-4.88-4.88-4 4L2 7.41 3.41 6l6 6 4-4 6.3 6.29L22 12v6z"></path></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z"></path></g>
<g id="trending-up"><path d="M16 6l2.29 2.29-4.88 4.88-4-4L2 16.59 3.41 18l6-6 4 4 6.3-6.29L22 12V6z"></path></g>
<g id="turned-in"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="turned-in-not"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="unarchive"><path d="M20.55 5.22l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28zM12 9.5l5.5 5.5H14v2h-4v-2H6.5L12 9.5zM5.12 5l.82-1h12l.93 1H5.12z"></path></g>
<g id="undo"><path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path></g>
<g id="unfold-less"><path d="M7.41 18.59L8.83 20 12 16.83 15.17 20l1.41-1.41L12 14l-4.59 4.59zm9.18-13.18L15.17 4 12 7.17 8.83 4 7.41 5.41 12 10l4.59-4.59z"></path></g>
<g id="unfold-more"><path d="M12 5.83L15.17 9l1.41-1.41L12 3 7.41 7.59 8.83 9 12 5.83zm0 12.34L8.83 15l-1.41 1.41L12 21l4.59-4.59L15.17 15 12 18.17z"></path></g>
<g id="update"><path d="M21 10.12h-6.78l2.74-2.82c-2.73-2.7-7.15-2.8-9.88-.1-2.73 2.71-2.73 7.08 0 9.79 2.73 2.71 7.15 2.71 9.88 0C18.32 15.65 19 14.08 19 12.1h2c0 1.98-.88 4.55-2.64 6.29-3.51 3.48-9.21 3.48-12.72 0-3.5-3.47-3.53-9.11-.02-12.58 3.51-3.47 9.14-3.47 12.65 0L21 3v7.12zM12.5 8v4.25l3.5 2.08-.72 1.21L11 13V8h1.5z"></path></g>
<g id="verified-user"><path d="M12 1L3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5l-9-4zm-2 16l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="view-agenda"><path d="M20 13H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zm0-10H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1z"></path></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z"></path></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z"></path></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z"></path></g>
<g id="view-day"><path d="M2 21h19v-3H2v3zM20 8H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1zM2 3v3h19V3H2z"></path></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z"></path></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z"></path></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z"></path></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z"></path></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"></path></g>
<g id="view-week"><path d="M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z"></path></g>
<g id="visibility"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="visibility-off"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"></path></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="watch-later"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm4.2 14.2L11 13V7h1.5v5.2l4.5 2.7-.8 1.3z"></path></g>
<g id="weekend"><path d="M21 10c-1.1 0-2 .9-2 2v3H5v-3c0-1.1-.9-2-2-2s-2 .9-2 2v5c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-5c0-1.1-.9-2-2-2zm-3-5H6c-1.1 0-2 .9-2 2v2.15c1.16.41 2 1.51 2 2.82V14h12v-2.03c0-1.3.84-2.4 2-2.82V7c0-1.1-.9-2-2-2z"></path></g>
<g id="work"><path d="M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z"></path></g>
<g id="youtube-searched-for"><path d="M17.01 14h-.8l-.27-.27c.98-1.14 1.57-2.61 1.57-4.23 0-3.59-2.91-6.5-6.5-6.5s-6.5 3-6.5 6.5H2l3.84 4 4.16-4H6.51C6.51 7 8.53 5 11.01 5s4.5 2.01 4.5 4.5c0 2.48-2.02 4.5-4.5 4.5-.65 0-1.26-.14-1.82-.38L7.71 15.1c.97.57 2.09.9 3.3.9 1.61 0 3.08-.59 4.22-1.57l.27.27v.79l5.01 4.99L22 19l-4.99-5z"></path></g>
<g id="zoom-in"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zm2.5-4h-2v2H9v-2H7V9h2V7h1v2h2v1z"></path></g>
<g id="zoom-out"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vbe.content);var t0t={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},xbe={8:"backspace",9:"tab",13:"enter",27:"esc",33:"pageup",34:"pagedown",35:"end",36:"home",32:"space",37:"left",38:"up",39:"right",40:"down",46:"del",106:"*"},e0t={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},bbe=/[a-z0-9*]/,wbe=/U\+/,Sbe=/^arrow/,Mbe=/^space(bar)?/,Ebe=/^escape$/;function r0t(e,t){var r="";if(e){var n=e.toLowerCase();n===" "||Mbe.test(n)?r="space":Ebe.test(n)?r="esc":n.length==1?(!t||bbe.test(n))&&(r=n):Sbe.test(n)?r=n.replace("arrow",""):n=="multiply"?r="*":r=n}return r}function Tbe(e){var t="";return e&&(e in t0t?t=t0t[e]:wbe.test(e)?(e=parseInt(e.replace("U+","0x"),16),t=String.fromCharCode(e).toLowerCase()):t=e.toLowerCase()),t}function Cbe(e){var t="";return Number(e)&&(e>=65&&e<=90?t=String.fromCharCode(32+e):e>=112&&e<=123?t="f"+(e-112+1):e>=48&&e<=57?t=String(e-48):e>=96&&e<=105?t=String(e-96):t=xbe[e]),t}function Abe(e,t){return e.key?r0t(e.key,t):e.detail&&e.detail.key?r0t(e.detail.key,t):Tbe(e.keyIdentifier)||Cbe(e.keyCode)||""}function n0t(e,t){var r=Abe(t,e.hasModifiers);return r===e.key&&(!e.hasModifiers||!!t.shiftKey==!!e.shiftKey&&!!t.ctrlKey==!!e.ctrlKey&&!!t.altKey==!!e.altKey&&!!t.metaKey==!!e.metaKey)}function Pbe(e){return e.length===1?{combo:e,key:e,event:"keydown"}:e.split("+").reduce(function(t,r){var n=r.split(":"),i=n[0],o=n[1];return i in e0t?(t[e0t[i]]=!0,t.hasModifiers=!0):(t.key=i,t.event=o||"keydown"),t},{combo:e.split(":").shift()})}function i0t(e){return e.trim().split(" ").map(function(t){return Pbe(t)})}var Oo={properties:{keyEventTarget:{type:Object,value:function(){return this}},stopKeyboardEventPropagation:{type:Boolean,value:!1},_boundKeyHandlers:{type:Array,value:function(){return[]}},_imperativeKeyBindings:{type:Object,value:function(){return{}}}},observers:["_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)"],keyBindings:{},registered:function(){this._prepKeyBindings()},attached:function(){this._listenKeyEventListeners()},detached:function(){this._unlistenKeyEventListeners()},addOwnKeyBinding:function(e,t){this._imperativeKeyBindings[e]=t,this._prepKeyBindings(),this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={},this._prepKeyBindings(),this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(e,t){for(var r=i0t(t),n=0;n<r.length;++n)if(n0t(r[n],e))return!0;return!1},_collectKeyBindings:function(){var e=this.behaviors.map(function(t){return t.keyBindings});return e.indexOf(this.keyBindings)===-1&&e.push(this.keyBindings),e},_prepKeyBindings:function(){this._keyBindings={},this._collectKeyBindings().forEach(function(r){for(var n in r)this._addKeyBinding(n,r[n])},this);for(var e in this._imperativeKeyBindings)this._addKeyBinding(e,this._imperativeKeyBindings[e]);for(var t in this._keyBindings)this._keyBindings[t].sort(function(r,n){var i=r[0].hasModifiers,o=n[0].hasModifiers;return i===o?0:i?-1:1})},_addKeyBinding:function(e,t){i0t(e).forEach(function(r){this._keyBindings[r.event]=this._keyBindings[r.event]||[],this._keyBindings[r.event].push([r,t])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners(),this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){!this.keyEventTarget||Object.keys(this._keyBindings).forEach(function(e){var t=this._keyBindings[e],r=this._onKeyBindingEvent.bind(this,t);this._boundKeyHandlers.push([this.keyEventTarget,e,r]),this.keyEventTarget.addEventListener(e,r)},this)},_unlistenKeyEventListeners:function(){for(var e,t,r,n;this._boundKeyHandlers.length;)e=this._boundKeyHandlers.pop(),t=e[0],r=e[1],n=e[2],t.removeEventListener(r,n)},_onKeyBindingEvent:function(e,t){if(this.stopKeyboardEventPropagation&&t.stopPropagation(),!t.defaultPrevented)for(var r=0;r<e.length;r++){var n=e[r][0],i=e[r][1];if(n0t(n,t)&&(this._triggerKeyHandler(n,i,t),t.defaultPrevented))return}},_triggerKeyHandler:function(e,t,r){var n=Object.create(e);n.keyboardEvent=r;var i=new CustomEvent(e.event,{detail:n,cancelable:!0});this[t].call(this,i),i.defaultPrevented&&r.preventDefault()}};var v9={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(e,t){var r;if(this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null),!!t)if(e==="document")this.scrollTarget=this._doc;else if(typeof e=="string"){var n=this.domHost;this.scrollTarget=n&&n.$?n.$[e]:zt(this.ownerDocument).querySelector("#"+e)}else this._isValidScrollTarget()&&(this._oldScrollTarget=e,this._toggleScrollListener(this._shouldHaveListener,e))},_scrollHandler:function(){},get _defaultScrollTarget(){return this._doc},get _doc(){return this.ownerDocument.documentElement},get _scrollTop(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageYOffset:this.scrollTarget.scrollTop:0},get _scrollLeft(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageXOffset:this.scrollTarget.scrollLeft:0},set _scrollTop(e){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,e):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=e)},set _scrollLeft(e){this.scrollTarget===this._doc?window.scrollTo(e,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=e)},scroll:function(e,t){var r;typeof e=="object"?(r=e.left,t=e.top):r=e,r=r||0,t=t||0,this.scrollTarget===this._doc?window.scrollTo(r,t):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=r,this.scrollTarget.scrollTop=t)},get _scrollTargetWidth(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerWidth:this.scrollTarget.offsetWidth:0},get _scrollTargetHeight(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerHeight:this.scrollTarget.offsetHeight:0},_isValidScrollTarget:function(){return this.scrollTarget instanceof HTMLElement},_toggleScrollListener:function(e,t){var r=t===this._doc?window:t;e?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),r.addEventListener("scroll",this._boundScrollHandler)):this._boundScrollHandler&&(r.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(e){this._shouldHaveListener=e,this._toggleScrollListener(e,this.scrollTarget)}};var o0t=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Ibe=o0t&&o0t[1]>=8,a0t=3,s0t="-10000px",fE=-100;Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      @media only screen and (-webkit-max-device-pixel-ratio: 1) {
        :host {
          will-change: transform;
        }
      }

      #items {
        @apply --iron-list-items-container;
        position: relative;
      }

      :host(:not([grid])) #items > ::slotted(*) {
        width: 100%;
      }

      #items > ::slotted(*) {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
        top: 0;
        will-change: transform;
      }
    </style>

    <array-selector id="selector" items="{{items}}" selected="{{selectedItems}}" selected-item="{{selectedItem}}"></array-selector>

    <div id="items">
      <slot></slot>
    </div>
`,is:"iron-list",properties:{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},selectedAs:{type:String,value:"selected"},grid:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_gridChanged"},selectionEnabled:{type:Boolean,value:!1},selectedItem:{type:Object,notify:!0},selectedItems:{type:Object,notify:!0},multiSelection:{type:Boolean,value:!1},scrollOffset:{type:Number,value:0}},observers:["_itemsChanged(items.*)","_selectionEnabledChanged(selectionEnabled)","_multiSelectionChanged(multiSelection)","_setOverflow(scrollTarget, scrollOffset)"],behaviors:[Wgt,Qs,v9,Kgt],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedItem:null,_focusedVirtualIndex:-1,_focusedPhysicalIndex:-1,_offscreenFocusedItem:null,_focusBackfillItem:null,_itemsPerRow:1,_itemWidth:0,_rowHeight:0,_templateCost:0,_parentModel:!0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){var e=this.grid?this._physicalRows*this._rowHeight:this._physicalSize;return e-this._viewportHeight},get _itemsParent(){return zt(zt(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var e=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,e-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this.grid&&(e=e-e%this._itemsPerRow),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this.grid&&(e=e-e%this._itemsPerRow),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var e=this._firstVisibleIndexVal;if(e==null){var t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._getPhysicalSizeIncrement(r),t>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){var e=this._lastVisibleIndexVal;if(e==null){if(this.grid)e=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._getPhysicalSizeIncrement(r)})}this._lastVisibleIndexVal=e}return e},get _defaultScrollTarget(){return this},get _virtualRowCount(){return Math.ceil(this._virtualCount/this._itemsPerRow)},get _estRowsInView(){return Math.ceil(this._viewportHeight/this._rowHeight)},get _physicalRows(){return Math.ceil(this._physicalCount/this._itemsPerRow)},get _scrollOffset(){return this._scrollerPaddingTop+this.scrollOffset},ready:function(){this.addEventListener("focus",this._didFocus.bind(this),!0)},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler"),this.listen(this,"keydown","_keydownHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler"),this.unlisten(this,"keydown","_keydownHandler")},_setOverflow:function(e){this.style.webkitOverflowScrolling=e===this?"touch":"",this.style.overflowY=e===this?"auto":"",this._lastVisibleIndexVal=null,this._firstVisibleIndexVal=null,this._debounce("_render",this._render,Ni)},updateViewportBoundaries:function(){var e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;var n=Math.round(t/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.min(Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._scrollPosition),this._update()}else if(this._physicalCount>0){var i=this._getReusables(r);r?(this._physicalTop=i.physicalTop,this._virtualStart=this._virtualStart+i.indexes.length,this._physicalStart=this._physicalStart+i.indexes.length):(this._virtualStart=this._virtualStart-i.indexes.length,this._physicalStart=this._physicalStart-i.indexes.length),this._update(i.indexes,r?null:i.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){var t,r,n,i,o=[],a=this._hiddenContentSize*this._ratio,s=this._virtualStart,l=this._virtualEnd,c=this._physicalCount,u=this._physicalTop+this._scrollOffset,h=this._physicalBottom+this._scrollOffset,f=this._scrollPosition,p=this._scrollBottom;for(e?(t=this._physicalStart,r=this._physicalEnd,n=f-u):(t=this._physicalEnd,r=this._physicalStart,n=h-p);i=this._getPhysicalSizeIncrement(t),n=n-i,!(o.length>=c||n<=a);)if(e){if(l+o.length+1>=this._virtualCount||u+i>=f-this._scrollOffset)break;o.push(t),u=u+i,t=(t+1)%c}else{if(s-o.length<=0||u+this._physicalSize-i<=p)break;o.push(t),u=u-i,t=t===0?c-1:t-1}return{indexes:o,physicalTop:u-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._manageFocus(),this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){var r=t.pop();this._physicalTop-=this._getPhysicalSizeIncrement(r)}this._positionItems(),this._updateScrollerSize()}},_createPool:function(e){this._ensureTemplatized();var t,r,n=new Array(e);for(t=0;t<e;t++)r=this.stamp(null),n[t]=r.root.querySelector("*"),this._itemsParent.appendChild(r.root);return n},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){var t=this._clamp(this._physicalCount+e,a0t,this._virtualCount-this._virtualStart);if(t=this._convertIndexToCompleteRow(t),this.grid){var r=t%this._itemsPerRow;r&&t-r<=this._physicalCount&&(t+=this._itemsPerRow),t-=r}var n=t-this._physicalCount,i=Math.round(this._physicalCount*.5);if(!(n<0)){if(n>0){var o=window.performance.now();[].push.apply(this._physicalItems,this._createPool(n));for(var a=0;a<n;a++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+n,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+n),this._update(),this._templateCost=(window.performance.now()-o)/n,i=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||i===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,i)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,i),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){var e=this._getReusables(!0);this._physicalTop=e.physicalTop,this._virtualStart=this._virtualStart+e.indexes.length,this._physicalStart=this._physicalStart+e.indexes.length,this._update(e.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(a0t))},_ensureTemplatized:function(){if(!this.ctor){this._userTemplate=this.queryEffectiveChildren("template"),this._userTemplate||console.warn("iron-list requires a template to be provided in light-dom");var e={};e.__key__=!0,e[this.as]=!0,e[this.indexAs]=!0,e[this.selectedAs]=!0,e.tabIndex=!0,this._instanceProps=e,this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(e,t){typeof t!="undefined"&&(this.notifyResize(),ci(),e&&this._updateGridMetrics())},_itemsChanged:function(e){if(e.path==="items")this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,Ni);else if(e.path==="items.splices"){this._adjustVirtualIndex(e.value.indexSplices),this._virtualCount=this.items?this.items.length:0;var t=e.value.indexSplices.some(function(i){return i.addedCount>0||i.removed.length>0});if(t){var r=this._getActiveElement();this.contains(r)&&r.blur()}var n=e.value.indexSplices.some(function(i){return i.index+i.addedCount>=this._virtualStart&&i.index<=this._virtualEnd},this);(!this._isClientFull()||n)&&this._debounce("_render",this._render,Ni)}else e.path!=="items.length"&&this._forwardItemPath(e.path,e.value)},_forwardItemPath:function(e,t){e=e.slice(6);var r=e.indexOf(".");r===-1&&(r=e.length);var n,i,o,a=this.modelForElement(this._offscreenFocusedItem),s=parseInt(e.substring(0,r),10);n=this._isIndexRendered(s),n?(i=this._getPhysicalIndex(s),o=this.modelForElement(this._physicalItems[i])):a&&(o=a),!(!o||o[this.indexAs]!==s)&&(e=e.substring(r+1),e=this.as+(e?"."+e:""),o._setPendingPropertyOrPath(e,t,!1,!0),o._flushProperties&&o._flushProperties(),n&&(this._updateMetrics([i]),this._positionItems(),this._updateScrollerSize()))},_adjustVirtualIndex:function(e){e.forEach(function(t){if(t.removed.forEach(this._removeItem,this),t.index<this._virtualStart){var r=Math.max(t.addedCount-t.removed.length,t.index-this._virtualStart);this._virtualStart=this._virtualStart+r,this._focusedVirtualIndex>=0&&(this._focusedVirtualIndex=this._focusedVirtualIndex+r)}},this)},_removeItem:function(e){this.$.selector.deselect(e),this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===e&&this._removeFocusedItem()},_iterateItems:function(e,t){var r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_assignModels:function(e){this._iterateItems(function(t,r){var n=this._physicalItems[t],i=this.items&&this.items[r];if(i!=null){var o=this.modelForElement(n);o.__key__=null,this._forwardProperty(o,this.as,i),this._forwardProperty(o,this.selectedAs,this.$.selector.isSelected(i)),this._forwardProperty(o,this.indexAs,r),this._forwardProperty(o,"tabIndex",this._focusedVirtualIndex===r?0:-1),this._physicalIndexForKey[o.__key__]=t,o._flushProperties&&o._flushProperties(!0),n.removeAttribute("hidden")}else n.setAttribute("hidden","")},e)},_updateMetrics:function(e){ci();var t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o,a){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(r=this._itemsPerRow===1?r:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+t-r,this._itemsPerRow=1),this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=this._physicalCount>0?this._physicalItems[0].getBoundingClientRect().width:200,this._rowHeight=this._physicalCount>0?this._physicalItems[0].offsetHeight:200,this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var e=this._physicalTop;if(this.grid){var t=this._itemsPerRow*this._itemWidth,r=(this._viewportWidth-t)/2;this._iterateItems(function(n,i){var o=i%this._itemsPerRow,a=Math.floor(o*this._itemWidth+r);this._isRTL&&(a=a*-1),this.translate3d(a+"px",e+"px",0,this._physicalItems[n]),this._shouldRenderNextRow(i)&&(e+=this._rowHeight)})}else{let n=[];this._iterateItems(function(i,o){let a=this._physicalItems[i];this.translate3d(0,e+"px",0,a),e+=this._physicalSizes[i];let s=a.id;s&&n.push(s)}),n.length&&this.setAttribute("aria-owns",n.join(" "))}},_getPhysicalSizeIncrement:function(e){return this.grid?this._computeVidx(e)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[e]},_shouldRenderNextRow:function(e){return e%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;var t=this._scrollPosition;!Ibe&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this.grid?this._estScrollHeight=this._virtualRowCount*this._rowHeight:this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,e=e||this.grid&&this.$.items.style.height<this._estScrollHeight,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToItem:function(e){return this.scrollToIndex(this.items.indexOf(e))},scrollToIndex:function(e){if(!(typeof e!="number"||e<0||e>this.items.length-1)&&(ci(),this._physicalCount!==0)){e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=this.grid?e-this._itemsPerRow*2:e-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;r<e&&n<=i;)n=n+this._getPhysicalSizeIncrement(t),t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._isVisible?(this.updateViewportBoundaries(),this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},selectItem:function(e){return this.selectIndex(this.items.indexOf(e))},selectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(!this.multiSelection&&this.selectedItem&&this.clearSelection(),this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t&&(t[this.selectedAs]=!0),this.updateSizeForIndex(e)}this.$.selector.selectIndex(e)}},deselectItem:function(e){return this.deselectIndex(this.items.indexOf(e))},deselectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t[this.selectedAs]=!1,this.updateSizeForIndex(e)}this.$.selector.deselectIndex(e)}},toggleSelectionForItem:function(e){return this.toggleSelectionForIndex(this.items.indexOf(e))},toggleSelectionForIndex:function(e){var t=this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(e):this.$.selector.isSelected(this.items[e]);t?this.deselectIndex(e):this.selectIndex(e)},clearSelection:function(){this._iterateItems(function(e,t){this.modelForElement(this._physicalItems[e])[this.selectedAs]=!1}),this.$.selector.clearSelection()},_selectionEnabledChanged:function(e){var t=e?this.listen:this.unlisten;t.call(this,this,"tap","_selectionHandler")},_selectionHandler:function(e){var t=this.modelForElement(e.target);if(!!t){var r,n,i=zt(e).path[0],o=this._getActiveElement(),a=this._physicalItems[this._getPhysicalIndex(t[this.indexAs])];i.localName==="input"||i.localName==="button"||i.localName==="select"||(r=t.tabIndex,t.tabIndex=fE,n=o?o.tabIndex:-1,t.tabIndex=r,!(o&&a!==o&&a.contains(o)&&n!==fE)&&this.toggleSelectionForItem(t[this.as]))}},_multiSelectionChanged:function(e){this.clearSelection(),this.$.selector.multi=e},updateSizeForItem:function(e){return this.updateSizeForIndex(this.items.indexOf(e))},updateSizeForIndex:function(e){return this._isIndexRendered(e)&&(this._updateMetrics([this._getPhysicalIndex(e)]),this._positionItems()),null},_manageFocus:function(){var e=this._focusedVirtualIndex;e>=0&&e<this._virtualCount?this._isIndexRendered(e)?this._restoreFocusedItem():this._createFocusBackfillItem():this._virtualCount>0&&this._physicalCount>0&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(e){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(e/this._itemsPerRow)*this._itemsPerRow:e},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_isIndexVisible:function(e){return e>=this.firstVisibleIndex&&e<=this.lastVisibleIndex},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},focusItem:function(e){this._focusPhysicalItem(e)},_focusPhysicalItem:function(e){if(!(e<0||e>=this._virtualCount)){this._restoreFocusedItem(),this._isIndexRendered(e)||this.scrollToIndex(e);var t=this._physicalItems[this._getPhysicalIndex(e)],r=this.modelForElement(t),n;r.tabIndex=fE,t.tabIndex===fE&&(n=t),n||(n=zt(t).querySelector('[tabindex="'+fE+'"]')),r.tabIndex=0,this._focusedVirtualIndex=e,n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem),this._offscreenFocusedItem=null,this._focusBackfillItem=null,this._focusedItem=null,this._focusedVirtualIndex=-1,this._focusedPhysicalIndex=-1},_createFocusBackfillItem:function(){var e=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||this._focusedVirtualIndex<0)){if(!this._focusBackfillItem){var t=this.stamp(null);this._focusBackfillItem=t.root.querySelector("*"),this._itemsParent.appendChild(t.root)}this._offscreenFocusedItem=this._physicalItems[e],this.modelForElement(this._offscreenFocusedItem).tabIndex=0,this._physicalItems[e]=this._focusBackfillItem,this._focusedPhysicalIndex=e,this.translate3d(0,s0t,0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(!(!this._offscreenFocusedItem||this._focusedVirtualIndex<0)){this._assignModels();var e=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),t=this._physicalItems[e];if(!!t){var r=this.modelForElement(t),n=this.modelForElement(this._offscreenFocusedItem);r[this.as]===n[this.as]?(this._focusBackfillItem=t,r.tabIndex=-1,this._physicalItems[e]=this._offscreenFocusedItem,this.translate3d(0,s0t,0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null),this._offscreenFocusedItem=null}}},_didFocus:function(e){var t=this.modelForElement(e.target),r=this.modelForElement(this._focusedItem),n=this._offscreenFocusedItem!==null,i=this._focusedVirtualIndex;!t||(r===t?this._isIndexVisible(i)||this.scrollToIndex(i):(this._restoreFocusedItem(),r&&(r.tabIndex=-1),t.tabIndex=0,i=t[this.indexAs],this._focusedVirtualIndex=i,this._focusedPhysicalIndex=this._getPhysicalIndex(i),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],n&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(e){switch(e.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex+(this.grid?this._itemsPerRow:1));break;case 39:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?-1:1));break;case 38:this._focusedVirtualIndex>0&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex-(this.grid?this._itemsPerRow:1));break;case 37:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?1:-1));break;case 13:this._focusPhysicalItem(this._focusedVirtualIndex),this.selectionEnabled&&this._selectionHandler(e);break}},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])},_forwardProperty:function(e,t,r){e._setPendingProperty(t,r)},_forwardHostPropV2:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).forwardHostProp(e,t)},this)},_notifyInstancePropV2:function(e,t,r){if(OI(this.as,t)){var n=e[this.indexAs];t==this.as&&(this.items[n]=r),this.notifyPath(mp(this.as,"items."+n,t),r)}},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(e,t,r){t.indexOf(this.as+".")===0&&this.notifyPath("items."+e.__key__+"."+t.slice(this.as.length+1),r)},_forwardParentPath:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).notifyPath(e,t)},this)},_forwardParentProp:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&(this.modelForElement(r)[e]=t)},this)},_getActiveElement:function(){var e=this._itemsParent.node.domHost;return zt(e?e.root:document).activeElement}});var x9=class{constructor(t){this.selection=[],this.selectCallback=t}get(){return this.multi?this.selection.slice():this.selection[0]}clear(t){this.selection.slice().forEach(function(r){(!t||t.indexOf(r)<0)&&this.setItemSelected(r,!1)},this)}isSelected(t){return this.selection.indexOf(t)>=0}setItemSelected(t,r){if(t!=null&&r!==this.isSelected(t)){if(r)this.selection.push(t);else{var n=this.selection.indexOf(t);n>=0&&this.selection.splice(n,1)}this.selectCallback&&this.selectCallback(t,r)}}select(t){this.multi?this.toggle(t):this.get()!==t&&(this.setItemSelected(this.get(),!1),this.setItemSelected(t,!0))}toggle(t){this.setItemSelected(t,!this.isSelected(t))}};var Sh={properties:{attrForSelected:{type:String,value:null},selected:{type:String,notify:!0},selectedItem:{type:Object,readOnly:!0,notify:!0},activateEvent:{type:String,value:"tap",observer:"_activateEventChanged"},selectable:String,selectedClass:{type:String,value:"iron-selected"},selectedAttribute:{type:String,value:null},fallbackSelection:{type:String,value:null},items:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}},_excludedLocalNames:{type:Object,value:function(){return{template:1,"dom-bind":1,"dom-if":1,"dom-repeat":1}}}},observers:["_updateAttrForSelected(attrForSelected)","_updateSelected(selected)","_checkFallback(fallbackSelection)"],created:function(){this._bindFilterItem=this._filterItem.bind(this),this._selection=new x9(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this),this._addListener(this.activateEvent)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._removeListener(this.activateEvent)},indexOf:function(e){return this.items?this.items.indexOf(e):-1},select:function(e){this.selected=e},selectPrevious:function(){var e=this.items.length,t=e-1;this.selected!==void 0&&(t=(Number(this._valueToIndex(this.selected))-1+e)%e),this.selected=this._indexToValue(t)},selectNext:function(){var e=0;this.selected!==void 0&&(e=(Number(this._valueToIndex(this.selected))+1)%this.items.length),this.selected=this._indexToValue(e)},selectIndex:function(e){this.select(this._indexToValue(e))},forceSynchronousItemUpdate:function(){this._observer&&typeof this._observer.flush=="function"?this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return this.selected!=null},_checkFallback:function(){this._updateSelected()},_addListener:function(e){this.listen(this,e,"_activateHandler")},_removeListener:function(e){this.unlisten(this,e,"_activateHandler")},_activateEventChanged:function(e,t){this._removeListener(t),this._addListener(e)},_updateItems:function(){var e=zt(this).queryDistributedElements(this.selectable||"*");e=Array.prototype.filter.call(e,this._bindFilterItem),this._setItems(e)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(e){if(!!this.items){var t=this._valueToItem(this.selected);t?this._selection.select(t):this._selection.clear(),this.fallbackSelection&&this.items.length&&this._selection.get()===void 0&&(this.selected=this.fallbackSelection)}},_filterItem:function(e){return!this._excludedLocalNames[e.localName]},_valueToItem:function(e){return e==null?null:this.items[this._valueToIndex(e)]},_valueToIndex:function(e){if(this.attrForSelected){for(var t=0,r;r=this.items[t];t++)if(this._valueForItem(r)==e)return t}else return Number(e)},_indexToValue:function(e){if(this.attrForSelected){var t=this.items[e];if(t)return this._valueForItem(t)}else return e},_valueForItem:function(e){if(!e)return null;if(!this.attrForSelected){var t=this.indexOf(e);return t===-1?null:t}var r=e[Sm(this.attrForSelected)];return r!=null?r:e.getAttribute(this.attrForSelected)},_applySelection:function(e,t){this.selectedClass&&this.toggleClass(this.selectedClass,t,e),this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,t,e),this._selectionChange(),this.fire("iron-"+(t?"select":"deselect"),{item:e})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(e){return zt(e).observeNodes(function(t){this._updateItems(),this._updateSelected(),this.fire("iron-items-changed",t,{bubbles:!1,cancelable:!1})})},_activateHandler:function(e){for(var t=e.target,r=this.items;t&&t!=this;){var n=r.indexOf(t);if(n>=0){var i=this._indexToValue(n);this._itemActivate(i,t);return}t=t.parentNode}},_itemActivate:function(e,t){this.fire("iron-activate",{selected:e,item:t},{cancelable:!0}).defaultPrevented||this.select(e)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host > ::slotted(:not(slot):not(.iron-selected)) {
        display: none !important;
      }
    </style>

    <slot></slot>
`,is:"iron-pages",behaviors:[Qs,Sh],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(e,t){this.async(this.notifyResize)}});var l0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      --shadow-transition: {
        transition: box-shadow 0.28s cubic-bezier(0.4, 0, 0.2, 1);
      };

      --shadow-none: {
        box-shadow: none;
      };

      /* from http://codepen.io/shyndman/pen/c5394ddf2e8b2a5c9185904b57421cdb */

      --shadow-elevation-2dp: {
        box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14),
                    0 1px 5px 0 rgba(0, 0, 0, 0.12),
                    0 3px 1px -2px rgba(0, 0, 0, 0.2);
      };

      --shadow-elevation-3dp: {
        box-shadow: 0 3px 4px 0 rgba(0, 0, 0, 0.14),
                    0 1px 8px 0 rgba(0, 0, 0, 0.12),
                    0 3px 3px -2px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-4dp: {
        box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14),
                    0 1px 10px 0 rgba(0, 0, 0, 0.12),
                    0 2px 4px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-6dp: {
        box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14),
                    0 1px 18px 0 rgba(0, 0, 0, 0.12),
                    0 3px 5px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-8dp: {
        box-shadow: 0 8px 10px 1px rgba(0, 0, 0, 0.14),
                    0 3px 14px 2px rgba(0, 0, 0, 0.12),
                    0 5px 5px -3px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-12dp: {
        box-shadow: 0 12px 16px 1px rgba(0, 0, 0, 0.14),
                    0 4px 22px 3px rgba(0, 0, 0, 0.12),
                    0 6px 7px -4px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-16dp: {
        box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14),
                    0  6px 30px 5px rgba(0, 0, 0, 0.12),
                    0  8px 10px -5px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-24dp: {
        box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14),
                    0 9px 46px 8px rgba(0, 0, 0, 0.12),
                    0 11px 15px -7px rgba(0, 0, 0, 0.4);
      };
    }
  </style>
</custom-style>`;l0t.setAttribute("style","display: none;");document.head.appendChild(l0t.content);var c0t=Q`
<dom-module id="paper-material-styles">
  <template>
    <style>
      html {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      .paper-material {
        @apply --paper-material;
      }
      .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }

      /* Duplicate the styles because of https://github.com/webcomponents/shadycss/issues/193 */
      :host {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      :host(.paper-material) {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]) {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]) {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]) {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]) {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]) {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>`;c0t.setAttribute("style","display: none;");document.head.appendChild(c0t.content);var Di={properties:{focused:{type:Boolean,value:!1,notify:!0,readOnly:!0,reflectToAttribute:!0},disabled:{type:Boolean,value:!1,notify:!0,observer:"_disabledChanged",reflectToAttribute:!0},_oldTabIndex:{type:String},_boundFocusBlurHandler:{type:Function,value:function(){return this._focusBlurHandler.bind(this)}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",this._boundFocusBlurHandler,!0),this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(e){this._setFocused(e.type==="focus")},_disabledChanged:function(e,t){this.setAttribute("aria-disabled",e?"true":"false"),this.style.pointerEvents=e?"none":"",e?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):this._oldTabIndex!==void 0&&(this._oldTabIndex===null?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};var Yx={properties:{pressed:{type:Boolean,readOnly:!0,value:!1,reflectToAttribute:!0,observer:"_pressedChanged"},toggles:{type:Boolean,value:!1,reflectToAttribute:!0},active:{type:Boolean,value:!1,notify:!0,reflectToAttribute:!0},pointerDown:{type:Boolean,readOnly:!0,value:!1},receivedFocusFromKeyboard:{type:Boolean,readOnly:!0},ariaActiveAttribute:{type:String,value:"aria-pressed",observer:"_ariaActiveAttributeChanged"}},listeners:{down:"_downHandler",up:"_upHandler",tap:"_tapHandler"},observers:["_focusChanged(focused)","_activeChanged(active, ariaActiveAttribute)"],keyBindings:{"enter:keydown":"_asyncClick","space:keydown":"_spaceKeyDownHandler","space:keyup":"_spaceKeyUpHandler"},_mouseEventRe:/^mouse/,_tapHandler:function(){this.toggles?this._userActivate(!this.active):this.active=!1},_focusChanged:function(e){this._detectKeyboardFocus(e),e||this._setPressed(!1)},_detectKeyboardFocus:function(e){this._setReceivedFocusFromKeyboard(!this.pointerDown&&e)},_userActivate:function(e){this.active!==e&&(this.active=e,this.fire("change"))},_downHandler:function(e){this._setPointerDown(!0),this._setPressed(!0),this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1),this._setPressed(!1)},_spaceKeyDownHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(t.preventDefault(),t.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(e){this._changedButtonState()},_ariaActiveAttributeChanged:function(e,t){t&&t!=e&&this.hasAttribute(t)&&this.removeAttribute(t)},_activeChanged:function(e,t){this.toggles?this.setAttribute(this.ariaActiveAttribute,e?"true":"false"):this.removeAttribute(this.ariaActiveAttribute),this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}},Mh=[Oo,Yx];var Eh={distance:function(e,t,r,n){var i=e-r,o=t-n;return Math.sqrt(i*i+o*o)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};function u0t(e){this.element=e,this.width=this.boundingRect.width,this.height=this.boundingRect.height,this.size=Math.max(this.width,this.height)}u0t.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(e,t){var r=Eh.distance(e,t,0,0),n=Eh.distance(e,t,this.width,0),i=Eh.distance(e,t,0,this.height),o=Eh.distance(e,t,this.width,this.height);return Math.max(r,n,i,o)}};function __(e){this.element=e,this.color=window.getComputedStyle(e).color,this.wave=document.createElement("div"),this.waveContainer=document.createElement("div"),this.wave.style.backgroundColor=this.color,this.wave.classList.add("wave"),this.waveContainer.classList.add("wave-container"),zt(this.waveContainer).appendChild(this.wave),this.resetInteractionState()}__.MAX_RADIUS=300;__.prototype={get recenters(){return this.element.recenters},get center(){return this.element.center},get mouseDownElapsed(){var e;return this.mouseDownStart?(e=Eh.now()-this.mouseDownStart,this.mouseUpStart&&(e-=this.mouseUpElapsed),e):0},get mouseUpElapsed(){return this.mouseUpStart?Eh.now()-this.mouseUpStart:0},get mouseDownElapsedSeconds(){return this.mouseDownElapsed/1e3},get mouseUpElapsedSeconds(){return this.mouseUpElapsed/1e3},get mouseInteractionSeconds(){return this.mouseDownElapsedSeconds+this.mouseUpElapsedSeconds},get initialOpacity(){return this.element.initialOpacity},get opacityDecayVelocity(){return this.element.opacityDecayVelocity},get radius(){var e=this.containerMetrics.width*this.containerMetrics.width,t=this.containerMetrics.height*this.containerMetrics.height,r=Math.min(Math.sqrt(e+t),__.MAX_RADIUS)*1.1+5,n=1.1-.2*(r/__.MAX_RADIUS),i=this.mouseInteractionSeconds/n,o=r*(1-Math.pow(80,-i));return Math.abs(o)},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){var e=this.mouseUpElapsedSeconds*.3,t=this.opacity;return Math.max(0,Math.min(e,t))},get isOpacityFullyDecayed(){return this.opacity<.01&&this.radius>=Math.min(this.maxRadius,__.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,__.MAX_RADIUS)},get isAnimationComplete(){return this.mouseUpStart?this.isOpacityFullyDecayed:this.isRestingAtMaxRadius},get translationFraction(){return Math.min(1,this.radius/this.containerMetrics.size*2/Math.sqrt(2))},get xNow(){return this.xEnd?this.xStart+this.translationFraction*(this.xEnd-this.xStart):this.xStart},get yNow(){return this.yEnd?this.yStart+this.translationFraction*(this.yEnd-this.yStart):this.yStart},get isMouseDown(){return this.mouseDownStart&&!this.mouseUpStart},resetInteractionState:function(){this.maxRadius=0,this.mouseDownStart=0,this.mouseUpStart=0,this.xStart=0,this.yStart=0,this.xEnd=0,this.yEnd=0,this.slideDistance=0,this.containerMetrics=new u0t(this.element)},draw:function(){var e,t,r;this.wave.style.opacity=this.opacity,e=this.radius/(this.containerMetrics.size/2),t=this.xNow-this.containerMetrics.width/2,r=this.yNow-this.containerMetrics.height/2,this.waveContainer.style.webkitTransform="translate("+t+"px, "+r+"px)",this.waveContainer.style.transform="translate3d("+t+"px, "+r+"px, 0)",this.wave.style.webkitTransform="scale("+e+","+e+")",this.wave.style.transform="scale3d("+e+","+e+",1)"},downAction:function(e){var t=this.containerMetrics.width/2,r=this.containerMetrics.height/2;this.resetInteractionState(),this.mouseDownStart=Eh.now(),this.center?(this.xStart=t,this.yStart=r,this.slideDistance=Eh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=e?e.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=e?e.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2),this.recenters&&(this.xEnd=t,this.yEnd=r,this.slideDistance=Eh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)),this.maxRadius=this.containerMetrics.furthestCornerDistanceFrom(this.xStart,this.yStart),this.waveContainer.style.top=(this.containerMetrics.height-this.containerMetrics.size)/2+"px",this.waveContainer.style.left=(this.containerMetrics.width-this.containerMetrics.size)/2+"px",this.waveContainer.style.width=this.containerMetrics.size+"px",this.waveContainer.style.height=this.containerMetrics.size+"px"},upAction:function(e){!this.isMouseDown||(this.mouseUpStart=Eh.now())},remove:function(){zt(zt(this.waveContainer).parentNode).removeChild(this.waveContainer)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        border-radius: inherit;
        overflow: hidden;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;

        /* See PolymerElements/paper-behaviors/issues/34. On non-Chrome browsers,
         * creating a node (with a position:absolute) in the middle of an event
         * handler "interrupts" that event handler (which happens when the
         * ripple is created on demand) */
        pointer-events: none;
      }

      :host([animating]) {
        /* This resolves a rendering issue in Chrome (as of 40) where the
           ripple is not properly clipped by its parent (which may have
           rounded corners). See: http://jsbin.com/temexa/4

           Note: We only apply this style conditionally. Otherwise, the browser
           will create a new compositing layer for every ripple element on the
           page, and that would be bad. */
        -webkit-transform: translate(0, 0);
        transform: translate3d(0, 0, 0);
      }

      #background,
      #waves,
      .wave-container,
      .wave {
        pointer-events: none;
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }

      #background,
      .wave {
        opacity: 0;
      }

      #waves,
      .wave {
        overflow: hidden;
      }

      .wave-container,
      .wave {
        border-radius: 50%;
      }

      :host(.circle) #background,
      :host(.circle) #waves {
        border-radius: 50%;
      }

      :host(.circle) .wave-container {
        overflow: hidden;
      }
    </style>

    <div id="background"></div>
    <div id="waves"></div>
`,is:"paper-ripple",behaviors:[Oo],properties:{initialOpacity:{type:Number,value:.25},opacityDecayVelocity:{type:Number,value:.8},recenters:{type:Boolean,value:!1},center:{type:Boolean,value:!1},ripples:{type:Array,value:function(){return[]}},animating:{type:Boolean,readOnly:!0,reflectToAttribute:!0,value:!1},holdDown:{type:Boolean,value:!1,observer:"_holdDownChanged"},noink:{type:Boolean,value:!1},_animating:{type:Boolean},_boundAnimate:{type:Function,value:function(){return this.animate.bind(this)}}},get target(){return this.keyEventTarget},keyBindings:{"enter:keydown":"_onEnterKeydown","space:keydown":"_onSpaceKeydown","space:keyup":"_onSpaceKeyup"},attached:function(){zt(this).parentNode.nodeType==11?this.keyEventTarget=zt(this).getOwnerRoot().host:this.keyEventTarget=zt(this).parentNode;var e=this.keyEventTarget;this.listen(e,"up","uiUpAction"),this.listen(e,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction"),this.unlisten(this.keyEventTarget,"down","uiDownAction"),this.keyEventTarget=null},get shouldKeepAnimating(){for(var e=0;e<this.ripples.length;++e)if(!this.ripples[e].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null),this.async(function(){this.upAction()},1)},uiDownAction:function(e){this.noink||this.downAction(e)},downAction:function(e){if(!(this.holdDown&&this.ripples.length>0)){var t=this.addRipple();t.downAction(e),this._animating||(this._animating=!0,this.animate())}},uiUpAction:function(e){this.noink||this.upAction(e)},upAction:function(e){this.holdDown||(this.ripples.forEach(function(t){t.upAction(e)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1,this.$.background.style.backgroundColor="",this.fire("transitionend")},addRipple:function(){var e=new __(this);return zt(this.$.waves).appendChild(e.waveContainer),this.$.background.style.backgroundColor=e.color,this.ripples.push(e),this._setAnimating(!0),e},removeRipple:function(e){var t=this.ripples.indexOf(e);t<0||(this.ripples.splice(t,1),e.remove(),this.ripples.length||this._setAnimating(!1))},animate:function(){if(!!this._animating){var e,t;for(e=0;e<this.ripples.length;++e)t=this.ripples[e],t.draw(),this.$.background.style.opacity=t.outerOpacity,t.isOpacityFullyDecayed&&!t.isRestingAtMaxRadius&&this.removeRipple(t);!this.shouldKeepAnimating&&this.ripples.length===0?this.onAnimationComplete():window.requestAnimationFrame(this._boundAnimate)}},animateRipple:function(){return this.animate()},_onEnterKeydown:function(){this.uiDownAction(),this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(e,t){t!==void 0&&(e?this.downAction():this.upAction())}});var su={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(e){Yx._downHandler.call(this,e),this.pressed&&this.ensureRipple(e)},ensureRipple:function(e){if(!this.hasRipple()){this._ripple=this._createRipple(),this._ripple.noink=this.noink;var t=this._rippleContainer||this.root;if(t&&zt(t).appendChild(this._ripple),e){var r=zt(this._rippleContainer||this),n=zt(e).rootTarget;r.deepContains(n)&&this._ripple.uiDownAction(e)}}},getRipple:function(){return this.ensureRipple(),this._ripple},hasRipple:function(){return Boolean(this._ripple)},_createRipple:function(){var e=document.createElement("paper-ripple");return e},_noinkChanged:function(e){this.hasRipple()&&(this._ripple.noink=e)}};var uW={properties:{elevation:{type:Number,reflectToAttribute:!0,readOnly:!0}},observers:["_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)","_computeKeyboardClass(receivedFocusFromKeyboard)"],hostAttributes:{role:"button",tabindex:"0",animated:!0},_calculateElevation:function(){var e=1;this.disabled?e=0:this.active||this.pressed?e=4:this.receivedFocusFromKeyboard&&(e=3),this._setElevation(e)},_computeKeyboardClass:function(e){this.toggleClass("keyboard-focus",e)},_spaceKeyDownHandler:function(e){Yx._spaceKeyDownHandler.call(this,e),this.hasRipple()&&this.getRipple().ripples.length<1&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(e){Yx._spaceKeyUpHandler.call(this,e),this.hasRipple()&&this._ripple.uiUpAction()}},h0t=[Mh,Di,su,uW];var f0t=Q`
  <style include="paper-material-styles">
    /* Need to specify the same specificity as the styles imported from paper-material. */
    :host {
      @apply --layout-inline;
      @apply --layout-center-center;
      position: relative;
      box-sizing: border-box;
      min-width: 5.14em;
      margin: 0 0.29em;
      background: transparent;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      -webkit-tap-highlight-color: transparent;
      font: inherit;
      text-transform: uppercase;
      outline-width: 0;
      border-radius: 3px;
      -moz-user-select: none;
      -ms-user-select: none;
      -webkit-user-select: none;
      user-select: none;
      cursor: pointer;
      z-index: 0;
      padding: 0.7em 0.57em;

      @apply --paper-font-common-base;
      @apply --paper-button;
    }

    :host([elevation="1"]) {
      @apply --paper-material-elevation-1;
    }

    :host([elevation="2"]) {
      @apply --paper-material-elevation-2;
    }

    :host([elevation="3"]) {
      @apply --paper-material-elevation-3;
    }

    :host([elevation="4"]) {
      @apply --paper-material-elevation-4;
    }

    :host([elevation="5"]) {
      @apply --paper-material-elevation-5;
    }

    :host([hidden]) {
      display: none !important;
    }

    :host([raised].keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-raised-keyboard-focus;
    }

    :host(:not([raised]).keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-flat-keyboard-focus;
    }

    :host([disabled]) {
      background: none;
      color: #a8a8a8;
      cursor: auto;
      pointer-events: none;

      @apply --paper-button-disabled;
    }

    :host([disabled][raised]) {
      background: #eaeaea;
    }


    :host([animated]) {
      @apply --shadow-transition;
    }

    paper-ripple {
      color: var(--paper-button-ink-color);
    }
  </style>

  <slot></slot>`;f0t.setAttribute("strip-whitespace","");Yt({_template:f0t,is:"paper-button",behaviors:[h0t],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?uW._calculateElevation.apply(this):this._setElevation(0)}});var p0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      /* Material Design color palette for Google products */

      --google-red-100: #f4c7c3;
      --google-red-300: #e67c73;
      --google-red-500: #db4437;
      --google-red-700: #c53929;

      --google-blue-100: #c6dafc;
      --google-blue-300: #7baaf7;
      --google-blue-500: #4285f4;
      --google-blue-700: #3367d6;

      --google-green-100: #b7e1cd;
      --google-green-300: #57bb8a;
      --google-green-500: #0f9d58;
      --google-green-700: #0b8043;

      --google-yellow-100: #fce8b2;
      --google-yellow-300: #f7cb4d;
      --google-yellow-500: #f4b400;
      --google-yellow-700: #f09300;

      --google-grey-100: #f5f5f5;
      --google-grey-300: #e0e0e0;
      --google-grey-500: #9e9e9e;
      --google-grey-700: #616161;

      /* Material Design color palette from online spec document */

      --paper-red-50: #ffebee;
      --paper-red-100: #ffcdd2;
      --paper-red-200: #ef9a9a;
      --paper-red-300: #e57373;
      --paper-red-400: #ef5350;
      --paper-red-500: #f44336;
      --paper-red-600: #e53935;
      --paper-red-700: #d32f2f;
      --paper-red-800: #c62828;
      --paper-red-900: #b71c1c;
      --paper-red-a100: #ff8a80;
      --paper-red-a200: #ff5252;
      --paper-red-a400: #ff1744;
      --paper-red-a700: #d50000;

      --paper-pink-50: #fce4ec;
      --paper-pink-100: #f8bbd0;
      --paper-pink-200: #f48fb1;
      --paper-pink-300: #f06292;
      --paper-pink-400: #ec407a;
      --paper-pink-500: #e91e63;
      --paper-pink-600: #d81b60;
      --paper-pink-700: #c2185b;
      --paper-pink-800: #ad1457;
      --paper-pink-900: #880e4f;
      --paper-pink-a100: #ff80ab;
      --paper-pink-a200: #ff4081;
      --paper-pink-a400: #f50057;
      --paper-pink-a700: #c51162;

      --paper-purple-50: #f3e5f5;
      --paper-purple-100: #e1bee7;
      --paper-purple-200: #ce93d8;
      --paper-purple-300: #ba68c8;
      --paper-purple-400: #ab47bc;
      --paper-purple-500: #9c27b0;
      --paper-purple-600: #8e24aa;
      --paper-purple-700: #7b1fa2;
      --paper-purple-800: #6a1b9a;
      --paper-purple-900: #4a148c;
      --paper-purple-a100: #ea80fc;
      --paper-purple-a200: #e040fb;
      --paper-purple-a400: #d500f9;
      --paper-purple-a700: #aa00ff;

      --paper-deep-purple-50: #ede7f6;
      --paper-deep-purple-100: #d1c4e9;
      --paper-deep-purple-200: #b39ddb;
      --paper-deep-purple-300: #9575cd;
      --paper-deep-purple-400: #7e57c2;
      --paper-deep-purple-500: #673ab7;
      --paper-deep-purple-600: #5e35b1;
      --paper-deep-purple-700: #512da8;
      --paper-deep-purple-800: #4527a0;
      --paper-deep-purple-900: #311b92;
      --paper-deep-purple-a100: #b388ff;
      --paper-deep-purple-a200: #7c4dff;
      --paper-deep-purple-a400: #651fff;
      --paper-deep-purple-a700: #6200ea;

      --paper-indigo-50: #e8eaf6;
      --paper-indigo-100: #c5cae9;
      --paper-indigo-200: #9fa8da;
      --paper-indigo-300: #7986cb;
      --paper-indigo-400: #5c6bc0;
      --paper-indigo-500: #3f51b5;
      --paper-indigo-600: #3949ab;
      --paper-indigo-700: #303f9f;
      --paper-indigo-800: #283593;
      --paper-indigo-900: #1a237e;
      --paper-indigo-a100: #8c9eff;
      --paper-indigo-a200: #536dfe;
      --paper-indigo-a400: #3d5afe;
      --paper-indigo-a700: #304ffe;

      --paper-blue-50: #e3f2fd;
      --paper-blue-100: #bbdefb;
      --paper-blue-200: #90caf9;
      --paper-blue-300: #64b5f6;
      --paper-blue-400: #42a5f5;
      --paper-blue-500: #2196f3;
      --paper-blue-600: #1e88e5;
      --paper-blue-700: #1976d2;
      --paper-blue-800: #1565c0;
      --paper-blue-900: #0d47a1;
      --paper-blue-a100: #82b1ff;
      --paper-blue-a200: #448aff;
      --paper-blue-a400: #2979ff;
      --paper-blue-a700: #2962ff;

      --paper-light-blue-50: #e1f5fe;
      --paper-light-blue-100: #b3e5fc;
      --paper-light-blue-200: #81d4fa;
      --paper-light-blue-300: #4fc3f7;
      --paper-light-blue-400: #29b6f6;
      --paper-light-blue-500: #03a9f4;
      --paper-light-blue-600: #039be5;
      --paper-light-blue-700: #0288d1;
      --paper-light-blue-800: #0277bd;
      --paper-light-blue-900: #01579b;
      --paper-light-blue-a100: #80d8ff;
      --paper-light-blue-a200: #40c4ff;
      --paper-light-blue-a400: #00b0ff;
      --paper-light-blue-a700: #0091ea;

      --paper-cyan-50: #e0f7fa;
      --paper-cyan-100: #b2ebf2;
      --paper-cyan-200: #80deea;
      --paper-cyan-300: #4dd0e1;
      --paper-cyan-400: #26c6da;
      --paper-cyan-500: #00bcd4;
      --paper-cyan-600: #00acc1;
      --paper-cyan-700: #0097a7;
      --paper-cyan-800: #00838f;
      --paper-cyan-900: #006064;
      --paper-cyan-a100: #84ffff;
      --paper-cyan-a200: #18ffff;
      --paper-cyan-a400: #00e5ff;
      --paper-cyan-a700: #00b8d4;

      --paper-teal-50: #e0f2f1;
      --paper-teal-100: #b2dfdb;
      --paper-teal-200: #80cbc4;
      --paper-teal-300: #4db6ac;
      --paper-teal-400: #26a69a;
      --paper-teal-500: #009688;
      --paper-teal-600: #00897b;
      --paper-teal-700: #00796b;
      --paper-teal-800: #00695c;
      --paper-teal-900: #004d40;
      --paper-teal-a100: #a7ffeb;
      --paper-teal-a200: #64ffda;
      --paper-teal-a400: #1de9b6;
      --paper-teal-a700: #00bfa5;

      --paper-green-50: #e8f5e9;
      --paper-green-100: #c8e6c9;
      --paper-green-200: #a5d6a7;
      --paper-green-300: #81c784;
      --paper-green-400: #66bb6a;
      --paper-green-500: #4caf50;
      --paper-green-600: #43a047;
      --paper-green-700: #388e3c;
      --paper-green-800: #2e7d32;
      --paper-green-900: #1b5e20;
      --paper-green-a100: #b9f6ca;
      --paper-green-a200: #69f0ae;
      --paper-green-a400: #00e676;
      --paper-green-a700: #00c853;

      --paper-light-green-50: #f1f8e9;
      --paper-light-green-100: #dcedc8;
      --paper-light-green-200: #c5e1a5;
      --paper-light-green-300: #aed581;
      --paper-light-green-400: #9ccc65;
      --paper-light-green-500: #8bc34a;
      --paper-light-green-600: #7cb342;
      --paper-light-green-700: #689f38;
      --paper-light-green-800: #558b2f;
      --paper-light-green-900: #33691e;
      --paper-light-green-a100: #ccff90;
      --paper-light-green-a200: #b2ff59;
      --paper-light-green-a400: #76ff03;
      --paper-light-green-a700: #64dd17;

      --paper-lime-50: #f9fbe7;
      --paper-lime-100: #f0f4c3;
      --paper-lime-200: #e6ee9c;
      --paper-lime-300: #dce775;
      --paper-lime-400: #d4e157;
      --paper-lime-500: #cddc39;
      --paper-lime-600: #c0ca33;
      --paper-lime-700: #afb42b;
      --paper-lime-800: #9e9d24;
      --paper-lime-900: #827717;
      --paper-lime-a100: #f4ff81;
      --paper-lime-a200: #eeff41;
      --paper-lime-a400: #c6ff00;
      --paper-lime-a700: #aeea00;

      --paper-yellow-50: #fffde7;
      --paper-yellow-100: #fff9c4;
      --paper-yellow-200: #fff59d;
      --paper-yellow-300: #fff176;
      --paper-yellow-400: #ffee58;
      --paper-yellow-500: #ffeb3b;
      --paper-yellow-600: #fdd835;
      --paper-yellow-700: #fbc02d;
      --paper-yellow-800: #f9a825;
      --paper-yellow-900: #f57f17;
      --paper-yellow-a100: #ffff8d;
      --paper-yellow-a200: #ffff00;
      --paper-yellow-a400: #ffea00;
      --paper-yellow-a700: #ffd600;

      --paper-amber-50: #fff8e1;
      --paper-amber-100: #ffecb3;
      --paper-amber-200: #ffe082;
      --paper-amber-300: #ffd54f;
      --paper-amber-400: #ffca28;
      --paper-amber-500: #ffc107;
      --paper-amber-600: #ffb300;
      --paper-amber-700: #ffa000;
      --paper-amber-800: #ff8f00;
      --paper-amber-900: #ff6f00;
      --paper-amber-a100: #ffe57f;
      --paper-amber-a200: #ffd740;
      --paper-amber-a400: #ffc400;
      --paper-amber-a700: #ffab00;

      --paper-orange-50: #fff3e0;
      --paper-orange-100: #ffe0b2;
      --paper-orange-200: #ffcc80;
      --paper-orange-300: #ffb74d;
      --paper-orange-400: #ffa726;
      --paper-orange-500: #ff9800;
      --paper-orange-600: #fb8c00;
      --paper-orange-700: #f57c00;
      --paper-orange-800: #ef6c00;
      --paper-orange-900: #e65100;
      --paper-orange-a100: #ffd180;
      --paper-orange-a200: #ffab40;
      --paper-orange-a400: #ff9100;
      --paper-orange-a700: #ff6500;

      --paper-deep-orange-50: #fbe9e7;
      --paper-deep-orange-100: #ffccbc;
      --paper-deep-orange-200: #ffab91;
      --paper-deep-orange-300: #ff8a65;
      --paper-deep-orange-400: #ff7043;
      --paper-deep-orange-500: #ff5722;
      --paper-deep-orange-600: #f4511e;
      --paper-deep-orange-700: #e64a19;
      --paper-deep-orange-800: #d84315;
      --paper-deep-orange-900: #bf360c;
      --paper-deep-orange-a100: #ff9e80;
      --paper-deep-orange-a200: #ff6e40;
      --paper-deep-orange-a400: #ff3d00;
      --paper-deep-orange-a700: #dd2c00;

      --paper-brown-50: #efebe9;
      --paper-brown-100: #d7ccc8;
      --paper-brown-200: #bcaaa4;
      --paper-brown-300: #a1887f;
      --paper-brown-400: #8d6e63;
      --paper-brown-500: #795548;
      --paper-brown-600: #6d4c41;
      --paper-brown-700: #5d4037;
      --paper-brown-800: #4e342e;
      --paper-brown-900: #3e2723;

      --paper-grey-50: #fafafa;
      --paper-grey-100: #f5f5f5;
      --paper-grey-200: #eeeeee;
      --paper-grey-300: #e0e0e0;
      --paper-grey-400: #bdbdbd;
      --paper-grey-500: #9e9e9e;
      --paper-grey-600: #757575;
      --paper-grey-700: #616161;
      --paper-grey-800: #424242;
      --paper-grey-900: #212121;

      --paper-blue-grey-50: #eceff1;
      --paper-blue-grey-100: #cfd8dc;
      --paper-blue-grey-200: #b0bec5;
      --paper-blue-grey-300: #90a4ae;
      --paper-blue-grey-400: #78909c;
      --paper-blue-grey-500: #607d8b;
      --paper-blue-grey-600: #546e7a;
      --paper-blue-grey-700: #455a64;
      --paper-blue-grey-800: #37474f;
      --paper-blue-grey-900: #263238;

      /* opacity for dark text on a light background */
      --dark-divider-opacity: 0.12;
      --dark-disabled-opacity: 0.38; /* or hint text or icon */
      --dark-secondary-opacity: 0.54;
      --dark-primary-opacity: 0.87;

      /* opacity for light text on a dark background */
      --light-divider-opacity: 0.12;
      --light-disabled-opacity: 0.3; /* or hint text or icon */
      --light-secondary-opacity: 0.7;
      --light-primary-opacity: 1.0;

    }

  </style>
</custom-style>
`;p0t.setAttribute("style","display: none;");document.head.appendChild(p0t.content);var d0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      /*
       * You can use these generic variables in your elements for easy theming.
       * For example, if all your elements use \`--primary-text-color\` as its main
       * color, then switching from a light to a dark theme is just a matter of
       * changing the value of \`--primary-text-color\` in your application.
       */
      --primary-text-color: var(--light-theme-text-color);
      --primary-background-color: var(--light-theme-background-color);
      --secondary-text-color: var(--light-theme-secondary-color);
      --disabled-text-color: var(--light-theme-disabled-color);
      --divider-color: var(--light-theme-divider-color);
      --error-color: var(--paper-deep-orange-a700);

      /*
       * Primary and accent colors. Also see color.js for more colors.
       */
      --primary-color: var(--paper-indigo-500);
      --light-primary-color: var(--paper-indigo-100);
      --dark-primary-color: var(--paper-indigo-700);

      --accent-color: var(--paper-pink-a200);
      --light-accent-color: var(--paper-pink-a100);
      --dark-accent-color: var(--paper-pink-a400);


      /*
       * Material Design Light background theme
       */
      --light-theme-background-color: #ffffff;
      --light-theme-base-color: #000000;
      --light-theme-text-color: var(--paper-grey-900);
      --light-theme-secondary-color: #737373;  /* for secondary text and icons */
      --light-theme-disabled-color: #9b9b9b;  /* disabled/hint text */
      --light-theme-divider-color: #dbdbdb;

      /*
       * Material Design Dark background theme
       */
      --dark-theme-background-color: var(--paper-grey-900);
      --dark-theme-base-color: #ffffff;
      --dark-theme-text-color: #ffffff;
      --dark-theme-secondary-color: #bcbcbc;  /* for secondary text and icons */
      --dark-theme-disabled-color: #646464;  /* disabled/hint text */
      --dark-theme-divider-color: #3c3c3c;

      /*
       * Deprecated values because of their confusing names.
       */
      --text-primary-color: var(--dark-theme-text-color);
      --default-primary-color: var(--primary-color);
    }
  </style>
</custom-style>`;d0t.setAttribute("style","display: none;");document.head.appendChild(d0t.content);var Th={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1}},attached:function(){},detached:function(){}};var hW=null,Ch={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){hW=new go({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return hW&&hW.byKey(this.validator)},hasValidator:function(){return this._validator!=null},validate:function(e){return e===void 0&&this.value!==void 0?this.invalid=!this._getValidity(this.value):this.invalid=!this._getValidity(e),!this.invalid},_getValidity:function(e){return this.hasValidator()?this._validator.validate(e):!0}};var fW={properties:{checked:{type:Boolean,value:!1,reflectToAttribute:!0,notify:!0,observer:"_checkedChanged"},toggles:{type:Boolean,value:!0,reflectToAttribute:!0},value:{type:String,value:"on",observer:"_valueChanged"}},observers:["_requiredChanged(required)"],created:function(){this._hasIronCheckedElementBehavior=!0},_getValidity:function(e){return this.disabled||!this.required||this.checked},_requiredChanged:function(){this.required?this.setAttribute("aria-required","true"):this.removeAttribute("aria-required")},_checkedChanged:function(){this.active=this.checked,this.fire("iron-change")},_valueChanged:function(){(this.value===void 0||this.value===null)&&(this.value="on")}},m0t=[Th,Ch,fW];var pE={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(this._ripple.holdDown=e)},_createRipple:function(){var e=su._createRipple();return e.id="ink",e.setAttribute("center",""),e.classList.add("circle"),e}},jx=[Mh,Di,su,pE];var Lbe={_checkedChanged:function(){fW._checkedChanged.call(this),this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){su._buttonStateChanged.call(this),!this.disabled&&this.isAttached&&(this.checked=this.active)}},Xx=[jx,m0t,Lbe];var g0t=Q`<style>
  :host {
    display: inline-block;
    white-space: nowrap;
    cursor: pointer;
    --calculated-paper-checkbox-size: var(--paper-checkbox-size, 18px);
    /* -1px is a sentinel for the default and is replaced in \`attached\`. */
    --calculated-paper-checkbox-ink-size: var(--paper-checkbox-ink-size, -1px);
    @apply --paper-font-common-base;
    line-height: 0;
    -webkit-tap-highlight-color: transparent;
  }

  :host([hidden]) {
    display: none !important;
  }

  :host(:focus) {
    outline: none;
  }

  .hidden {
    display: none;
  }

  #checkboxContainer {
    display: inline-block;
    position: relative;
    width: var(--calculated-paper-checkbox-size);
    height: var(--calculated-paper-checkbox-size);
    min-width: var(--calculated-paper-checkbox-size);
    margin: var(--paper-checkbox-margin, initial);
    vertical-align: var(--paper-checkbox-vertical-align, middle);
    background-color: var(--paper-checkbox-unchecked-background-color, transparent);
  }

  #ink {
    position: absolute;

    /* Center the ripple in the checkbox by negative offsetting it by
     * (inkWidth - rippleWidth) / 2 */
    top: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    width: var(--calculated-paper-checkbox-ink-size);
    height: var(--calculated-paper-checkbox-ink-size);
    color: var(--paper-checkbox-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
  }

  #ink:dir(rtl) {
    right: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: auto;
  }

  #ink[checked] {
    color: var(--paper-checkbox-checked-ink-color, var(--primary-color));
  }

  #checkbox {
    position: relative;
    box-sizing: border-box;
    height: 100%;
    border: solid 2px;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    border-radius: 2px;
    pointer-events: none;
    -webkit-transition: background-color 140ms, border-color 140ms;
    transition: background-color 140ms, border-color 140ms;

    -webkit-transition-duration: var(--paper-checkbox-animation-duration, 140ms);
    transition-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  /* checkbox checked animations */
  #checkbox.checked #checkmark {
    -webkit-animation: checkmark-expand 140ms ease-out forwards;
    animation: checkmark-expand 140ms ease-out forwards;

    -webkit-animation-duration: var(--paper-checkbox-animation-duration, 140ms);
    animation-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  @-webkit-keyframes checkmark-expand {
    0% {
      -webkit-transform: scale(0, 0) rotate(45deg);
    }
    100% {
      -webkit-transform: scale(1, 1) rotate(45deg);
    }
  }

  @keyframes checkmark-expand {
    0% {
      transform: scale(0, 0) rotate(45deg);
    }
    100% {
      transform: scale(1, 1) rotate(45deg);
    }
  }

  #checkbox.checked {
    background-color: var(--paper-checkbox-checked-color, var(--primary-color));
    border-color: var(--paper-checkbox-checked-color, var(--primary-color));
  }

  #checkmark {
    position: absolute;
    width: 36%;
    height: 70%;
    border-style: solid;
    border-top: none;
    border-left: none;
    border-right-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-bottom-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-color: var(--paper-checkbox-checkmark-color, white);
    -webkit-transform-origin: 97% 86%;
    transform-origin: 97% 86%;
    box-sizing: content-box; /* protect against page-level box-sizing */
  }

  #checkmark:dir(rtl) {
    -webkit-transform-origin: 50% 14%;
    transform-origin: 50% 14%;
  }

  /* label */
  #checkboxLabel {
    position: relative;
    display: inline-block;
    vertical-align: middle;
    padding-left: var(--paper-checkbox-label-spacing, 8px);
    white-space: normal;
    line-height: normal;
    color: var(--paper-checkbox-label-color, var(--primary-text-color));
    @apply --paper-checkbox-label;
  }

  :host([checked]) #checkboxLabel {
    color: var(--paper-checkbox-label-checked-color, var(--paper-checkbox-label-color, var(--primary-text-color)));
    @apply --paper-checkbox-label-checked;
  }

  #checkboxLabel:dir(rtl) {
    padding-right: var(--paper-checkbox-label-spacing, 8px);
    padding-left: 0;
  }

  #checkboxLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #checkbox {
    opacity: 0.5;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
  }

  :host([disabled][checked]) #checkbox {
    background-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #checkboxLabel  {
    opacity: 0.65;
  }

  /* invalid state */
  #checkbox.invalid:not(.checked) {
    border-color: var(--paper-checkbox-error-color, var(--error-color));
  }
</style>

<div id="checkboxContainer">
  <div id="checkbox" class$="[[_computeCheckboxClass(checked, invalid)]]">
    <div id="checkmark" class$="[[_computeCheckmarkClass(checked)]]"></div>
  </div>
</div>

<div id="checkboxLabel"><slot></slot></div>`;g0t.setAttribute("strip-whitespace","");Yt({_template:g0t,is:"paper-checkbox",behaviors:[Xx],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Cm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim();if(e==="-1px"){var t=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),r="px",n=t.match(/[A-Za-z]+$/);n!==null&&(r=n[0]);var i=parseFloat(t),o=8/3*i;r==="px"&&(o=Math.floor(o),o%2!==i%2&&o++),this.updateStyles({"--paper-checkbox-ink-size":o+r})}})},_computeCheckboxClass:function(e,t){var r="";return e&&(r+="checked "),t&&(r+="invalid"),r},_computeCheckmarkClass:function(e){return e?"":"hidden"},_createRipple:function(){return this._rippleContainer=this.$.checkboxContainer,pE._createRipple.call(this)}});if(!window.polymerSkipLoadingFontRoboto){let e=document.createElement("link");e.rel="stylesheet",e.type="text/css",e.crossOrigin="anonymous",e.href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,700|Roboto:400,300,300italic,400italic,500,500italic,700,700italic",document.head.appendChild(e)}var _0t=Q`<custom-style>
  <style is="custom-style">
    html {

      /* Shared Styles */
      --paper-font-common-base: {
        font-family: 'Roboto', 'Noto', sans-serif;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-code: {
        font-family: 'Roboto Mono', 'Consolas', 'Menlo', monospace;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-expensive-kerning: {
        text-rendering: optimizeLegibility;
      };

      --paper-font-common-nowrap: {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      };

      /* Material Font Styles */

      --paper-font-display4: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 112px;
        font-weight: 300;
        letter-spacing: -.044em;
        line-height: 120px;
      };

      --paper-font-display3: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 56px;
        font-weight: 400;
        letter-spacing: -.026em;
        line-height: 60px;
      };

      --paper-font-display2: {
        @apply --paper-font-common-base;

        font-size: 45px;
        font-weight: 400;
        letter-spacing: -.018em;
        line-height: 48px;
      };

      --paper-font-display1: {
        @apply --paper-font-common-base;

        font-size: 34px;
        font-weight: 400;
        letter-spacing: -.01em;
        line-height: 40px;
      };

      --paper-font-headline: {
        @apply --paper-font-common-base;

        font-size: 24px;
        font-weight: 400;
        letter-spacing: -.012em;
        line-height: 32px;
      };

      --paper-font-title: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 20px;
        font-weight: 500;
        line-height: 28px;
      };

      --paper-font-subhead: {
        @apply --paper-font-common-base;

        font-size: 16px;
        font-weight: 400;
        line-height: 24px;
      };

      --paper-font-body2: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-body1: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 400;
        line-height: 20px;
      };

      --paper-font-caption: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 12px;
        font-weight: 400;
        letter-spacing: 0.011em;
        line-height: 20px;
      };

      --paper-font-menu: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 13px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-button: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 14px;
        font-weight: 500;
        letter-spacing: 0.018em;
        line-height: 24px;
        text-transform: uppercase;
      };

      --paper-font-code2: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 700;
        line-height: 20px;
      };

      --paper-font-code1: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 500;
        line-height: 20px;
      };

    }

  </style>
</custom-style>`;_0t.setAttribute("style","display: none;");document.head.appendChild(_0t.content);var pW=document.createElement("template");pW.setAttribute("style","display: none;");pW.innerHTML=`<dom-module id="paper-dialog-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        margin: 24px 40px;

        background: var(--paper-dialog-background-color, var(--primary-background-color));
        color: var(--paper-dialog-color, var(--primary-text-color));

        @apply --paper-font-body1;
        @apply --shadow-elevation-16dp;
        @apply --paper-dialog;
      }

      :host > ::slotted(*) {
        margin-top: 20px;
        padding: 0 24px;
      }

      :host > ::slotted(.no-padding) {
        padding: 0;
      }

      
      :host > ::slotted(*:first-child) {
        margin-top: 24px;
      }

      :host > ::slotted(*:last-child) {
        margin-bottom: 24px;
      }

      /* In 1.x, this selector was \`:host > ::content h2\`. In 2.x <slot> allows
      to select direct children only, which increases the weight of this
      selector, so we have to re-define first-child/last-child margins below. */
      :host > ::slotted(h2) {
        position: relative;
        margin: 0;

        @apply --paper-font-title;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-top. */
      :host > ::slotted(h2:first-child) {
        margin-top: 24px;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-bottom. */
      :host > ::slotted(h2:last-child) {
        margin-bottom: 24px;
        @apply --paper-dialog-title;
      }

      :host > ::slotted(.paper-dialog-buttons),
      :host > ::slotted(.buttons) {
        position: relative;
        padding: 8px 8px 8px 24px;
        margin: 0;

        color: var(--paper-dialog-button-color, var(--primary-color));

        @apply --layout-horizontal;
        @apply --layout-end-justified;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(pW.content);var y0t={properties:{animationConfig:{type:Object},entryAnimation:{observer:"_entryAnimationChanged",type:String},exitAnimation:{observer:"_exitAnimationChanged",type:String}},_entryAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.entry=[{name:this.entryAnimation,node:this}]},_exitAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.exit=[{name:this.exitAnimation,node:this}]},_copyProperties:function(e,t){for(var r in t)e[r]=t[r]},_cloneConfig:function(e){var t={isClone:!0};return this._copyProperties(t,e),t},_getAnimationConfigRecursive:function(e,t,r){if(!!this.animationConfig){if(this.animationConfig.value&&typeof this.animationConfig.value=="function"){this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));return}var n;if(e?n=this.animationConfig[e]:n=this.animationConfig,Array.isArray(n)||(n=[n]),n)for(var i,o=0;i=n[o];o++)if(i.animatable)i.animatable._getAnimationConfigRecursive(i.type||e,t,r);else if(i.id){var a=t[i.id];a?(a.isClone||(t[i.id]=this._cloneConfig(a),a=t[i.id]),this._copyProperties(a,i)):t[i.id]=i}else r.push(i)}},getAnimationConfig:function(e){var t={},r=[];this._getAnimationConfigRecursive(e,t,r);for(var n in t)r.push(t[n]);return r}};var kbe={_configureAnimations:function(e){var t=[],r=[];if(e.length>0)for(let i,o=0;i=e[o];o++){let a=document.createElement(i.name);if(a.isNeonAnimation){let s=null;a.configure||(a.configure=function(l){return null}),s=a.configure(i),r.push({result:s,config:i,neonAnimation:a})}else console.warn(this.is+":",i.name,"not found!")}for(var n=0;n<r.length;n++){let i=r[n].result,o=r[n].config,a=r[n].neonAnimation;try{typeof i.cancel!="function"&&(i=document.timeline.play(i))}catch(s){i=null,console.warn("Couldnt play","(",o.name,").",s)}i&&t.push({neonAnimation:a,config:o,animation:i})}return t},_shouldComplete:function(e){for(var t=!0,r=0;r<e.length;r++)if(e[r].animation.playState!="finished"){t=!1;break}return t},_complete:function(e){for(var t=0;t<e.length;t++)e[t].neonAnimation.complete(e[t].config);for(var t=0;t<e.length;t++)e[t].animation.cancel()},playAnimation:function(e,t){var r=this.getAnimationConfig(e);if(!!r){this._active=this._active||{},this._active[e]&&(this._complete(this._active[e]),delete this._active[e]);var n=this._configureAnimations(r);if(n.length==0){this.fire("neon-animation-finish",t,{bubbles:!1});return}this._active[e]=n;for(var i=0;i<n.length;i++)n[i].animation.onfinish=function(){this._shouldComplete(n)&&(this._complete(n),delete this._active[e],this.fire("neon-animation-finish",t,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var e in this._active){var t=this._active[e];for(var r in t)t[r].animation.cancel()}this._active={}}},b9=[y0t,kbe];var w9,Rbe=()=>{if(w9!==void 0)return w9;let e=document.createElement("div");Object.assign(e.style,{overflow:"auto",position:"fixed",left:"0px",top:"0px",maxWidth:"100px",maxHeight:"100px"});let t=document.createElement("div");return t.style.width="200px",t.style.height="200px",e.appendChild(t),document.body.appendChild(e),w9=Math.abs(e.offsetWidth-100)>1?e.offsetWidth-e.clientWidth:0,document.body.removeChild(e),w9},v0t={properties:{sizingTarget:{type:Object,value:function(){return this}},fitInto:{type:Object,value:window},noOverlap:{type:Boolean},positionTarget:{type:Element},horizontalAlign:{type:String},verticalAlign:{type:String},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},autoFitOnAttach:{type:Boolean,value:!1},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_fitInfo:{type:Object}},get _fitWidth(){var e;return this.fitInto===window?e=this.fitInto.innerWidth:e=this.fitInto.getBoundingClientRect().width,e},get _fitHeight(){var e;return this.fitInto===window?e=this.fitInto.innerHeight:e=this.fitInto.getBoundingClientRect().height,e},get _fitLeft(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().left,e},get _fitTop(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().top,e},get _defaultPositionTarget(){var e=zt(this).parentNode;return e&&e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(e=e.host),e},get _localeHorizontalAlign(){if(this._isRTL){if(this.horizontalAlign==="right")return"left";if(this.horizontalAlign==="left")return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},get _isRTL(){return typeof this._memoizedIsRTL=="undefined"&&(this._memoizedIsRTL=window.getComputedStyle(this).direction=="rtl"),this._memoizedIsRTL},attached:function(){this.positionTarget=this.positionTarget||this._defaultPositionTarget,this.autoFitOnAttach&&(window.getComputedStyle(this).display==="none"?setTimeout(function(){this.fit()}.bind(this)):(window.ShadyDOM&&ShadyDOM.flush(),this.fit()))},detached:function(){this.__deferredFit&&(clearTimeout(this.__deferredFit),this.__deferredFit=null)},fit:function(){this.position(),this.constrain(),this.center()},_discoverInfo:function(){if(!this._fitInfo){var e=window.getComputedStyle(this),t=window.getComputedStyle(this.sizingTarget);this._fitInfo={inlineStyle:{top:this.style.top||"",left:this.style.left||"",position:this.style.position||""},sizerInlineStyle:{maxWidth:this.sizingTarget.style.maxWidth||"",maxHeight:this.sizingTarget.style.maxHeight||"",boxSizing:this.sizingTarget.style.boxSizing||""},positionedBy:{vertically:e.top!=="auto"?"top":e.bottom!=="auto"?"bottom":null,horizontally:e.left!=="auto"?"left":e.right!=="auto"?"right":null},sizedBy:{height:t.maxHeight!=="none",width:t.maxWidth!=="none",minWidth:parseInt(t.minWidth,10)||0,minHeight:parseInt(t.minHeight,10)||0},margin:{top:parseInt(e.marginTop,10)||0,right:parseInt(e.marginRight,10)||0,bottom:parseInt(e.marginBottom,10)||0,left:parseInt(e.marginLeft,10)||0}}}},resetFit:function(){var e=this._fitInfo||{};for(var t in e.sizerInlineStyle)this.sizingTarget.style[t]=e.sizerInlineStyle[t];for(var t in e.inlineStyle)this.style[t]=e.inlineStyle[t];this._fitInfo=null},refit:function(){var e=this.sizingTarget.scrollLeft,t=this.sizingTarget.scrollTop;this.resetFit(),this.fit(),this.sizingTarget.scrollLeft=e,this.sizingTarget.scrollTop=t},position:function(){if(!this.__shouldPosition)return;this._discoverInfo(),window.ShadyDOM&&window.ShadyDOM.flush(),this.style.position="fixed",this.sizingTarget.style.boxSizing="border-box",this.style.left="0px",this.style.top="0px";var e=this.getBoundingClientRect(),t=this.__getNormalizedRect(this.positionTarget),r=this.__getNormalizedRect(this.fitInto);let n,i,o,a;this.expandSizingTargetForScrollbars&&(n=this.sizingTarget.offsetWidth,i=this.sizingTarget.offsetHeight,o=this.sizingTarget.clientWidth,a=this.sizingTarget.clientHeight);var s=this._fitInfo.margin,l={width:e.width+s.left+s.right,height:e.height+s.top+s.bottom},c=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,l,e,t,r),u=c.left+s.left,h=c.top+s.top,f=Math.min(r.right-s.right,u+e.width),p=Math.min(r.bottom-s.bottom,h+e.height);u=Math.max(r.left+s.left,Math.min(u,f-this._fitInfo.sizedBy.minWidth)),h=Math.max(r.top+s.top,Math.min(h,p-this._fitInfo.sizedBy.minHeight));let d=Math.max(f-u,this._fitInfo.sizedBy.minWidth),g=Math.max(p-h,this._fitInfo.sizedBy.minHeight);this.sizingTarget.style.maxWidth=d+"px",this.sizingTarget.style.maxHeight=g+"px";let _=u-e.left,y=h-e.top;if(this.style.left=`${_}px`,this.style.top=`${y}px`,this.expandSizingTargetForScrollbars){let x=this.sizingTarget.offsetHeight,b=this.sizingTarget.clientHeight,S=i-a,P=x-b-S;if(P>0){let L=r.height-s.top-s.bottom,R=Math.min(L,g+P);this.sizingTarget.style.maxHeight=`${R}px`;let F=this.sizingTarget.offsetHeight,z=F-x,U;c.verticalAlign==="top"?U=y:c.verticalAlign==="middle"?U=y-z/2:c.verticalAlign==="bottom"&&(U=y-z),U=Math.max(r.top+s.top,Math.min(U,r.bottom-s.bottom-F)),this.style.top=`${U}px`}let k=this.sizingTarget.offsetWidth,O=this.sizingTarget.clientWidth,D=n-o,I=k-O-D;if(I>0){let L=Rbe(),R=r.width-s.left-s.right,F=Math.min(R,d+I-L);this.sizingTarget.style.maxWidth=`${F}px`;let z=this.sizingTarget.offsetWidth+L,U=z-k,W;c.horizontalAlign==="left"?W=_:c.horizontalAlign==="center"?W=_-U/2:c.horizontalAlign==="right"&&(W=_-U),W=Math.max(r.left+s.left,Math.min(W,r.right-s.right-z)),this.style.left=`${W}px`}}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo;e.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px"),e.positionedBy.horizontally||(this.style.position="fixed",this.style.left="0px"),this.sizingTarget.style.boxSizing="border-box";var t=this.getBoundingClientRect();e.sizedBy.height||this.__sizeDimension(t,e.positionedBy.vertically,"top","bottom","Height"),e.sizedBy.width||this.__sizeDimension(t,e.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(e,t,r,n,i){this.__sizeDimension(e,t,r,n,i)},__sizeDimension:function(e,t,r,n,i){var o=this._fitInfo,a=this.__getNormalizedRect(this.fitInto),s=i==="Width"?a.width:a.height,l=t===n,c=l?s-e[n]:e[r],u=o.margin[l?r:n],h="offset"+i,f=this[h]-this.sizingTarget[h];this.sizingTarget.style["max"+i]=s-u-c-f+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo.positionedBy;if(!(e.vertically&&e.horizontally)){this.style.position="fixed",e.vertically||(this.style.top="0px"),e.horizontally||(this.style.left="0px");var t=this.getBoundingClientRect(),r=this.__getNormalizedRect(this.fitInto);if(!e.vertically){var n=r.top-t.top+(r.height-t.height)/2;this.style.top=n+"px"}if(!e.horizontally){var i=r.left-t.left+(r.width-t.width)/2;this.style.left=i+"px"}}}},__getNormalizedRect:function(e){return e===document.documentElement||e===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:e.getBoundingClientRect()},__getOffscreenArea:function(e,t,r){var n=Math.min(0,e.top)+Math.min(0,r.bottom-(e.top+t.height)),i=Math.min(0,e.left)+Math.min(0,r.right-(e.left+t.width));return Math.abs(n)*t.width+Math.abs(i)*t.height},__getPosition:function(e,t,r,n,i,o){var a=[{verticalAlign:"top",horizontalAlign:"left",top:i.top+this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:i.top+this.verticalOffset,left:i.right-r.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:i.bottom-r.height-this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:i.bottom-r.height-this.verticalOffset,left:i.right-r.width-this.horizontalOffset}];if(this.noOverlap){for(var s=0,l=a.length;s<l;s++){var c={};for(var u in a[s])c[u]=a[s][u];a.push(c)}a[0].top=a[1].top+=i.height,a[2].top=a[3].top-=i.height,a[4].left=a[6].left+=i.width,a[5].left=a[7].left-=i.width}t=t==="auto"?null:t,e=e==="auto"?null:e,(!e||e==="center")&&(a.push({verticalAlign:"top",horizontalAlign:"center",top:i.top+this.verticalOffset+(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset}),a.push({verticalAlign:"bottom",horizontalAlign:"center",top:i.bottom-r.height-this.verticalOffset-(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset})),(!t||t==="middle")&&(a.push({verticalAlign:"middle",horizontalAlign:"left",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left+this.horizontalOffset+(this.noOverlap?i.width:0)}),a.push({verticalAlign:"middle",horizontalAlign:"right",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.right-r.width-this.horizontalOffset-(this.noOverlap?i.width:0)})),t==="middle"&&e==="center"&&a.push({verticalAlign:"middle",horizontalAlign:"center",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left-n.width/2+i.width/2+this.horizontalOffset});for(var h,s=0;s<a.length;s++){var f=a[s],p=f.verticalAlign===t,d=f.horizontalAlign===e;if(!this.dynamicAlign&&!this.noOverlap&&p&&d){h=f;break}var g=(!t||p)&&(!e||d);if(!(!this.dynamicAlign&&!g)){if(f.offscreenArea=this.__getOffscreenArea(f,r,o),f.offscreenArea===0&&g){h=f;break}h=h||f;var _=f.offscreenArea-h.offscreenArea;(_<0||_===0&&(p||d))&&(h=f)}}return h}};var $x=Element.prototype,S9=$x.matches||$x.matchesSelector||$x.mozMatchesSelector||$x.msMatchesSelector||$x.oMatchesSelector||$x.webkitMatchesSelector,dW=class{getTabbableNodes(t){var r=[],n=this._collectTabbableNodes(t,r);return n?this._sortByTabIndex(r):r}isFocusable(t){return S9.call(t,"input, select, textarea, button, object")?S9.call(t,":not([disabled])"):S9.call(t,"a[href], area[href], iframe, [tabindex], [contentEditable]")}isTabbable(t){return this.isFocusable(t)&&S9.call(t,':not([tabindex="-1"])')&&this._isVisible(t)}_normalizedTabIndex(t){if(this.isFocusable(t)){var r=t.getAttribute("tabindex")||0;return Number(r)}return-1}_collectTabbableNodes(t,r){if(t.nodeType!==Node.ELEMENT_NODE)return!1;var n=t;if(!this._isVisible(n))return!1;var i=this._normalizedTabIndex(n),o=i>0;i>=0&&r.push(n);var a;n.localName==="content"||n.localName==="slot"?a=zt(n).getDistributedNodes():a=zt(n.root||n).children;for(var s=0;s<a.length;s++)o=this._collectTabbableNodes(a[s],r)||o;return o}_isVisible(t){var r=t.style;return r.visibility!=="hidden"&&r.display!=="none"?(r=window.getComputedStyle(t),r.visibility!=="hidden"&&r.display!=="none"):!1}_sortByTabIndex(t){var r=t.length;if(r<2)return t;var n=Math.ceil(r/2),i=this._sortByTabIndex(t.slice(0,n)),o=this._sortByTabIndex(t.slice(n));return this._mergeSortByTabIndex(i,o)}_mergeSortByTabIndex(t,r){for(var n=[];t.length>0&&r.length>0;)this._hasLowerTabOrder(t[0],r[0])?n.push(r.shift()):n.push(t.shift());return n.concat(t,r)}_hasLowerTabOrder(t,r){var n=Math.max(t.tabIndex,0),i=Math.max(r.tabIndex,0);return n===0||i===0?i>n:n>i}},x0t=new dW;Yt({_template:Q`
    <style>
      :host {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: var(--iron-overlay-backdrop-background-color, #000);
        opacity: 0;
        transition: opacity 0.2s;
        pointer-events: none;
        @apply --iron-overlay-backdrop;
      }

      :host(.opened) {
        opacity: var(--iron-overlay-backdrop-opacity, 0.6);
        pointer-events: auto;
        @apply --iron-overlay-backdrop-opened;
      }
    </style>

    <slot></slot>
`,is:"iron-overlay-backdrop",properties:{opened:{reflectToAttribute:!0,type:Boolean,value:!1,observer:"_openedChanged"}},listeners:{transitionend:"_onTransitionend"},created:function(){this.__openedRaf=null},attached:function(){this.opened&&this._openedChanged(this.opened)},prepare:function(){this.opened&&!this.parentNode&&zt(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){!this.opened&&this.parentNode===document.body&&zt(this.parentNode).removeChild(this)},_onTransitionend:function(e){e&&e.target===this&&this.complete()},_openedChanged:function(e){if(e)this.prepare();else{var t=window.getComputedStyle(this);(t.transitionDuration==="0s"||t.opacity==0)&&this.complete()}!this.isAttached||(this.__openedRaf&&(window.cancelAnimationFrame(this.__openedRaf),this.__openedRaf=null),this.scrollTop=this.scrollTop,this.__openedRaf=window.requestAnimationFrame(function(){this.__openedRaf=null,this.toggleClass("opened",this.opened)}.bind(this)))}});var mW=class{constructor(){this._overlays=[],this._minimumZ=101,this._backdropElement=null,Tm(document.documentElement,"tap",function(){}),document.addEventListener("tap",this._onCaptureClick.bind(this),!0),document.addEventListener("focus",this._onCaptureFocus.bind(this),!0),document.addEventListener("keydown",this._onCaptureKeyDown.bind(this),!0)}get backdropElement(){return this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop")),this._backdropElement}get deepActiveElement(){var t=document.activeElement;for((!t||!(t instanceof Element))&&(t=document.body);t.root&&zt(t.root).activeElement;)t=zt(t.root).activeElement;return t}_bringOverlayAtIndexToFront(t){var r=this._overlays[t];if(!!r){var n=this._overlays.length-1,i=this._overlays[n];if(i&&this._shouldBeBehindOverlay(r,i)&&n--,!(t>=n)){var o=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(r)<=o&&this._applyOverlayZ(r,o);t<n;)this._overlays[t]=this._overlays[t+1],t++;this._overlays[n]=r}}}addOrRemoveOverlay(t){t.opened?this.addOverlay(t):this.removeOverlay(t)}addOverlay(t){var r=this._overlays.indexOf(t);if(r>=0){this._bringOverlayAtIndexToFront(r),this.trackBackdrop();return}var n=this._overlays.length,i=this._overlays[n-1],o=Math.max(this._getZ(i),this._minimumZ),a=this._getZ(t);if(i&&this._shouldBeBehindOverlay(t,i)){this._applyOverlayZ(i,o),n--;var s=this._overlays[n-1];o=Math.max(this._getZ(s),this._minimumZ)}a<=o&&this._applyOverlayZ(t,o),this._overlays.splice(n,0,t),this.trackBackdrop()}removeOverlay(t){var r=this._overlays.indexOf(t);r!==-1&&(this._overlays.splice(r,1),this.trackBackdrop())}currentOverlay(){var t=this._overlays.length-1;return this._overlays[t]}currentOverlayZ(){return this._getZ(this.currentOverlay())}ensureMinimumZ(t){this._minimumZ=Math.max(this._minimumZ,t)}focusOverlay(){var t=this.currentOverlay();t&&t._applyFocus()}trackBackdrop(){var t=this._overlayWithBackdrop();!t&&!this._backdropElement||(this.backdropElement.style.zIndex=this._getZ(t)-1,this.backdropElement.opened=!!t,this.backdropElement.prepare())}getBackdrops(){for(var t=[],r=0;r<this._overlays.length;r++)this._overlays[r].withBackdrop&&t.push(this._overlays[r]);return t}backdropZ(){return this._getZ(this._overlayWithBackdrop())-1}_overlayWithBackdrop(){for(var t=this._overlays.length-1;t>=0;t--)if(this._overlays[t].withBackdrop)return this._overlays[t]}_getZ(t){var r=this._minimumZ;if(t){var n=Number(t.style.zIndex||window.getComputedStyle(t).zIndex);n===n&&(r=n)}return r}_setZ(t,r){t.style.zIndex=r}_applyOverlayZ(t,r){this._setZ(t,r+2)}_overlayInPath(t){t=t||[];for(var r=0;r<t.length;r++)if(t[r]._manager===this)return t[r]}_onCaptureClick(t){var r=this._overlays.length-1;if(r!==-1)for(var n=zt(t).path,i;(i=this._overlays[r])&&this._overlayInPath(n)!==i&&(i._onCaptureClick(t),i.allowClickThrough);)r--}_onCaptureFocus(t){var r=this.currentOverlay();r&&r._onCaptureFocus(t)}_onCaptureKeyDown(t){var r=this.currentOverlay();r&&(Oo.keyboardEventMatchesKeys(t,"esc")?r._onCaptureEsc(t):Oo.keyboardEventMatchesKeys(t,"tab")&&r._onCaptureTab(t))}_shouldBeBehindOverlay(t,r){return!t.alwaysOnTop&&r.alwaysOnTop}},b0t=new mW;var E9={pageX:0,pageY:0},w0t=null,gW=[],T9=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"],M9,_W;function S0t(e){Ah.indexOf(e)>=0||(Ah.length===0&&Dbe(),Ah.push(e),_W=Ah[Ah.length-1],E0t=[],T0t=[])}function M0t(e){var t=Ah.indexOf(e);t!==-1&&(Ah.splice(t,1),_W=Ah[Ah.length-1],E0t=[],T0t=[],Ah.length===0&&Obe())}var Ah=[],E0t=null,T0t=null;function Nbe(e){if(e.cancelable&&zbe(e)&&e.preventDefault(),e.targetTouches){var t=e.targetTouches[0];E9.pageX=t.pageX,E9.pageY=t.pageY}}function Dbe(){M9=M9||Nbe.bind(void 0);for(var e=0,t=T9.length;e<t;e++)document.addEventListener(T9[e],M9,{capture:!0,passive:!1})}function Obe(){for(var e=0,t=T9.length;e<t;e++)document.removeEventListener(T9[e],M9,{capture:!0,passive:!1})}function zbe(e){var t=zt(e).rootTarget;if(e.type!=="touchmove"&&w0t!==t&&(w0t=t,gW=Fbe(zt(e).path)),!gW.length)return!0;if(e.type==="touchstart")return!1;var r=Hbe(e);return!Bbe(gW,r.deltaX,r.deltaY)}function Fbe(e){for(var t=[],r=e.indexOf(_W),n=0;n<=r;n++)if(e[n].nodeType===Node.ELEMENT_NODE){var i=e[n],o=i.style;o.overflow!=="scroll"&&o.overflow!=="auto"&&(o=window.getComputedStyle(i)),(o.overflow==="scroll"||o.overflow==="auto")&&t.push(i)}return t}function Bbe(e,t,r){if(!(!t&&!r))for(var n=Math.abs(r)>=Math.abs(t),i=0;i<e.length;i++){var o=e[i],a=!1;if(n?a=r<0?o.scrollTop>0:o.scrollTop<o.scrollHeight-o.clientHeight:a=t<0?o.scrollLeft>0:o.scrollLeft<o.scrollWidth-o.clientWidth,a)return o}}function Hbe(e){var t={deltaX:e.deltaX,deltaY:e.deltaY};if(!("deltaX"in e)){if("wheelDeltaX"in e&&"wheelDeltaY"in e)t.deltaX=-e.wheelDeltaX,t.deltaY=-e.wheelDeltaY;else if("wheelDelta"in e)t.deltaX=0,t.deltaY=-e.wheelDelta;else if("axis"in e)t.deltaX=e.axis===1?e.detail:0,t.deltaY=e.axis===2?e.detail:0;else if(e.targetTouches){var r=e.targetTouches[0];t.deltaX=E9.pageX-r.pageX,t.deltaY=E9.pageY-r.pageY}}return t}var Im={properties:{opened:{observer:"_openedChanged",type:Boolean,value:!1,notify:!0},canceled:{observer:"_canceledChanged",readOnly:!0,type:Boolean,value:!1},withBackdrop:{observer:"_withBackdropChanged",type:Boolean},noAutoFocus:{type:Boolean,value:!1},noCancelOnEscKey:{type:Boolean,value:!1},noCancelOnOutsideClick:{type:Boolean,value:!1},closingReason:{type:Object},restoreFocusOnClose:{type:Boolean,value:!1},allowClickThrough:{type:Boolean},alwaysOnTop:{type:Boolean},scrollAction:{type:String},_manager:{type:Object,value:b0t},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||zt(this).querySelector("[autofocus]")||this},get _focusableNodes(){return x0t.getTabbableNodes(this)},ready:function(){this.__isAnimating=!1,this.__shouldRemoveTabIndex=!1,this.__firstFocusableNode=this.__lastFocusableNode=null,this.__rafs={},this.__restoreFocusNode=null,this.__scrollTop=this.__scrollLeft=null,this.__onCaptureScroll=this.__onCaptureScroll.bind(this),this.__rootNodes=null,this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened),this._observer=zt(this).observeNodes(this._onNodesChange)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._observer=null;for(var e in this.__rafs)this.__rafs[e]!==null&&cancelAnimationFrame(this.__rafs[e]);this.__rafs={},this._manager.removeOverlay(this),this.__isAnimating&&(this.opened?this._finishRenderOpened():(this._applyFocus(),this._finishRenderClosed()))},toggle:function(){this._setCanceled(!1),this.opened=!this.opened},open:function(){this._setCanceled(!1),this.opened=!0},close:function(){this._setCanceled(!1),this.opened=!1},cancel:function(e){var t=this.fire("iron-overlay-canceled",e,{cancelable:!0});t.defaultPrevented||(this._setCanceled(!0),this.opened=!1)},invalidateTabbables:function(){this.__firstFocusableNode=this.__lastFocusableNode=null},_ensureSetup:function(){this._overlaySetup||(this._overlaySetup=!0,this.style.outline="none",this.style.display="none")},_openedChanged:function(e){e?this.removeAttribute("aria-hidden"):this.setAttribute("aria-hidden","true"),this.isAttached&&(this.__isAnimating=!0,this.__deraf("__openedChanged",this.__openedChanged))},_canceledChanged:function(){this.closingReason=this.closingReason||{},this.closingReason.canceled=this.canceled},_withBackdropChanged:function(){this.withBackdrop&&!this.hasAttribute("tabindex")?(this.setAttribute("tabindex","-1"),this.__shouldRemoveTabIndex=!0):this.__shouldRemoveTabIndex&&(this.removeAttribute("tabindex"),this.__shouldRemoveTabIndex=!1),this.opened&&this.isAttached&&this._manager.trackBackdrop()},_prepareRenderOpened:function(){this.__restoreFocusNode=this._manager.deepActiveElement,this._preparePositioning(),this.refit(),this._finishPositioning(),this.noAutoFocus&&document.activeElement===this._focusNode&&(this._focusNode.blur(),this.__restoreFocusNode.focus())},_renderOpened:function(){this._finishRenderOpened()},_renderClosed:function(){this._finishRenderClosed()},_finishRenderOpened:function(){this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-opened")},_finishRenderClosed:function(){this.style.display="none",this.style.zIndex="",this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-closed",this.closingReason)},_preparePositioning:function(){this.style.transition=this.style.webkitTransition="none",this.style.transform=this.style.webkitTransform="none",this.style.display=""},_finishPositioning:function(){this.style.display="none",this.scrollTop=this.scrollTop,this.style.transition=this.style.webkitTransition="",this.style.transform=this.style.webkitTransform="",this.style.display="",this.scrollTop=this.scrollTop},_applyFocus:function(){if(this.opened)this.noAutoFocus||this._focusNode.focus();else{if(this.restoreFocusOnClose&&this.__restoreFocusNode){var e=this._manager.deepActiveElement;(e===document.body||Ube(this,e))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null,this._focusNode.blur(),this._focusedChild=null}},_onCaptureClick:function(e){this.noCancelOnOutsideClick||this.cancel(e)},_onCaptureFocus:function(e){if(!!this.withBackdrop){var t=zt(e).path;t.indexOf(this)===-1?(e.stopPropagation(),this._applyFocus()):this._focusedChild=t[0]}},_onCaptureEsc:function(e){this.noCancelOnEscKey||this.cancel(e)},_onCaptureTab:function(e){if(!!this.withBackdrop){this.__ensureFirstLastFocusables();var t=e.shiftKey,r=t?this.__firstFocusableNode:this.__lastFocusableNode,n=t?this.__lastFocusableNode:this.__firstFocusableNode,i=!1;if(r===n)i=!0;else{var o=this._manager.deepActiveElement;i=o===r||o===this}i&&(e.preventDefault(),this._focusedChild=n,this._applyFocus())}},_onIronResize:function(){this.opened&&!this.__isAnimating&&this.__deraf("refit",this.refit)},_onNodesChange:function(){this.opened&&!this.__isAnimating&&(this.invalidateTabbables(),this.notifyResize())},__ensureFirstLastFocusables:function(){var e=this._focusableNodes;this.__firstFocusableNode=e[0],this.__lastFocusableNode=e[e.length-1]},__openedChanged:function(){this.opened?(this._prepareRenderOpened(),this._manager.addOverlay(this),this._applyFocus(),this._renderOpened()):(this._manager.removeOverlay(this),this._applyFocus(),this._renderClosed())},__deraf:function(e,t){var r=this.__rafs;r[e]!==null&&cancelAnimationFrame(r[e]),r[e]=requestAnimationFrame(function(){r[e]=null,t.call(this)}.bind(this))},__updateScrollObservers:function(e,t,r){!e||!t||!this.__isValidScrollAction(r)?(M0t(this),this.__removeScrollListeners()):(r==="lock"&&(this.__saveScrollPosition(),S0t(this)),this.__addScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){if(this.__rootNodes=[],u_)for(var e=this;e;)e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&e.host&&this.__rootNodes.push(e),e=e.host||e.assignedSlot||e.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(t){t.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(e){e.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this),this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(e){return e==="lock"||e==="refit"||e==="cancel"},__onCaptureScroll:function(e){if(!this.__isAnimating&&!(zt(e).path.indexOf(this)>=0))switch(this.scrollAction){case"lock":this.__restoreScrollPosition();break;case"refit":this.__deraf("refit",this.refit);break;case"cancel":this.cancel(e);break}},__saveScrollPosition:function(){document.scrollingElement?(this.__scrollTop=document.scrollingElement.scrollTop,this.__scrollLeft=document.scrollingElement.scrollLeft):(this.__scrollTop=Math.max(document.documentElement.scrollTop,document.body.scrollTop),this.__scrollLeft=Math.max(document.documentElement.scrollLeft,document.body.scrollLeft))},__restoreScrollPosition:function(){document.scrollingElement?(document.scrollingElement.scrollTop=this.__scrollTop,document.scrollingElement.scrollLeft=this.__scrollLeft):(document.documentElement.scrollTop=document.body.scrollTop=this.__scrollTop,document.documentElement.scrollLeft=document.body.scrollLeft=this.__scrollLeft)}},Vbe=e=>e.assignedSlot||e.parentNode||e.host,Ube=(e,t)=>{for(let r=t;r;r=Vbe(r))if(r===e)return!0;return!1},Kx=[v0t,Qs,Im];var yW={hostAttributes:{role:"dialog",tabindex:"-1"},properties:{modal:{type:Boolean,value:!1},__readied:{type:Boolean,value:!1}},observers:["_modalChanged(modal, __readied)"],listeners:{tap:"_onDialogClick"},ready:function(){this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.__readied=!0},_modalChanged:function(e,t){!t||(e?(this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.noCancelOnOutsideClick=!0,this.noCancelOnEscKey=!0,this.withBackdrop=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(e){this.closingReason=this.closingReason||{},this.closingReason.confirmed=e},_onDialogClick:function(e){for(var t=zt(e).path,r=0,n=t.indexOf(this);r<n;r++){var i=t[r];if(i.hasAttribute&&(i.hasAttribute("dialog-dismiss")||i.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(i.hasAttribute("dialog-confirm")),this.close(),e.stopPropagation();break}}}},C0t=[Kx,yW];Yt({_template:Q`
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
`,is:"paper-dialog",behaviors:[C0t,b9],listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},_renderOpened:function(){this.cancelAnimation(),this.playAnimation("entry")},_renderClosed:function(){this.cancelAnimation(),this.playAnimation("exit")},_onNeonAnimationFinish:function(){this.opened?this._finishRenderOpened():this._finishRenderClosed()}});Yt({_template:Q`
    <style>

      :host {
        display: block;
        @apply --layout-relative;
      }

      :host(.is-scrolled:not(:first-child))::before {
        content: '';
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      :host(.can-scroll:not(.scrolled-to-bottom):not(:last-child))::after {
        content: '';
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      .scrollable {
        padding: 0 24px;

        @apply --layout-scroll;
        @apply --paper-dialog-scrollable;
      }

      .fit {
        @apply --layout-fit;
      }
    </style>

    <div id="scrollable" class="scrollable" on-scroll="updateScrollState">
      <slot></slot>
    </div>
`,is:"paper-dialog-scrollable",properties:{dialogElement:{type:Object}},get scrollTarget(){return this.$.scrollable},ready:function(){this._ensureTarget(),this.classList.add("no-padding")},attached:function(){this._ensureTarget(),requestAnimationFrame(this.updateScrollState.bind(this))},updateScrollState:function(){this.toggleClass("is-scrolled",this.scrollTarget.scrollTop>0),this.toggleClass("can-scroll",this.scrollTarget.offsetHeight<this.scrollTarget.scrollHeight),this.toggleClass("scrolled-to-bottom",this.scrollTarget.scrollTop+this.scrollTarget.offsetHeight>=this.scrollTarget.scrollHeight)},_ensureTarget:function(){this.dialogElement=this.dialogElement||this.parentElement,this.dialogElement&&this.dialogElement.behaviors&&this.dialogElement.behaviors.indexOf(yW)>=0?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});var ec=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
`,is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},timeout:{type:Number,value:150},_text:{type:String,value:""}},created:function(){ec.instance||(ec.instance=this),document.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(e){this._text="",this.async(function(){this._text=e},this.timeout)},_onIronAnnounce:function(e){e.detail&&e.detail.text&&this.announce(e.detail.text)}});ec.instance=null;ec.requestAvailability=function(){ec.instance||(ec.instance=document.createElement("iron-a11y-announcer")),document.body?document.body.appendChild(ec.instance):document.addEventListener("load",function(){document.body.appendChild(ec.instance)})};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
`,is:"iron-input",behaviors:[Ch],properties:{bindValue:{type:String,value:""},value:{type:String,computed:"_computeValue(bindValue)"},allowedPattern:{type:String},autoValidate:{type:Boolean,value:!1},_inputElement:Object},observers:["_bindValueChanged(bindValue, _inputElement)"],listeners:{input:"_onInput",keypress:"_onKeypress"},created:function(){ec.requestAvailability(),this._previousValidInput="",this._patternAlreadyChecked=!1},attached:function(){this._observer=zt(this).observeNodes(function(e){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(zt(this).unobserveNodes(this._observer),this._observer=null)},get inputElement(){return this._inputElement},_initSlottedInput:function(){this._inputElement=this.getEffectiveChildren()[0],this.inputElement&&this.inputElement.value&&(this.bindValue=this.inputElement.value),this.fire("iron-input-ready")},get _patternRegExp(){var e;if(this.allowedPattern)e=new RegExp(this.allowedPattern);else switch(this.inputElement.type){case"number":e=/[0-9.,e-]/;break}return e},_bindValueChanged:function(e,t){!t||(e===void 0?t.value=null:e!==t.value&&(this.inputElement.value=e),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:e}))},_onInput:function(){if(this.allowedPattern&&!this._patternAlreadyChecked){var e=this._checkPatternValidity();e||(this._announceInvalidCharacter("Invalid string of characters not entered."),this.inputElement.value=this._previousValidInput)}this.bindValue=this._previousValidInput=this.inputElement.value,this._patternAlreadyChecked=!1},_isPrintable:function(e){var t=e.keyCode==8||e.keyCode==9||e.keyCode==13||e.keyCode==27,r=e.keyCode==19||e.keyCode==20||e.keyCode==45||e.keyCode==46||e.keyCode==144||e.keyCode==145||e.keyCode>32&&e.keyCode<41||e.keyCode>111&&e.keyCode<124;return!t&&!(e.charCode==0&&r)},_onKeypress:function(e){if(!(!this.allowedPattern&&this.inputElement.type!=="number")){var t=this._patternRegExp;if(!!t&&!(e.metaKey||e.ctrlKey||e.altKey)){this._patternAlreadyChecked=!0;var r=String.fromCharCode(e.charCode);this._isPrintable(e)&&!t.test(r)&&(e.preventDefault(),this._announceInvalidCharacter("Invalid character "+r+" not entered."))}}},_checkPatternValidity:function(){var e=this._patternRegExp;if(!e)return!0;for(var t=0;t<this.inputElement.value.length;t++)if(!e.test(this.inputElement.value[t]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var e=this.inputElement.checkValidity();return e&&(this.required&&this.bindValue===""?e=!1:this.hasValidator()&&(e=Ch.validate.call(this,this.bindValue))),this.invalid=!e,this.fire("iron-input-validate"),e},_announceInvalidCharacter:function(e){this.fire("iron-announce",{text:e})},_computeValue:function(e){return e}});var C9={attached:function(){this.fire("addon-attached")},update:function(e){}};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        float: right;

        @apply --paper-font-caption;
        @apply --paper-input-char-counter;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:dir(rtl)) {
        float: left;
      }
    </style>

    <span>[[_charCounterStr]]</span>
`,is:"paper-input-char-counter",behaviors:[C9],properties:{_charCounterStr:{type:String,value:"0"}},update:function(e){if(!!e.inputElement){e.value=e.value||"";var t=e.value.toString().length.toString();e.inputElement.hasAttribute("maxlength")&&(t+="/"+e.inputElement.getAttribute("maxlength")),this._charCounterStr=t}}});var A0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      --paper-input-container-shared-input-style: {
        position: relative; /* to make a stacking context */
        outline: none;
        box-shadow: none;
        padding: 0;
        margin: 0;
        width: 100%;
        max-width: 100%;
        background: transparent;
        border: none;
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        -webkit-appearance: none;
        text-align: inherit;
        vertical-align: var(--paper-input-container-input-align, bottom);

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>
`;A0t.setAttribute("style","display: none;");document.head.appendChild(A0t.content);Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;
        @apply --paper-input-container;
      }

      :host([inline]) {
        display: inline-block;
      }

      :host([disabled]) {
        pointer-events: none;
        opacity: 0.33;

        @apply --paper-input-container-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      [hidden] {
        display: none !important;
      }

      .floated-label-placeholder {
        @apply --paper-font-caption;
      }

      .underline {
        height: 2px;
        position: relative;
      }

      .focused-line {
        @apply --layout-fit;
        border-bottom: 2px solid var(--paper-input-container-focus-color, var(--primary-color));

        -webkit-transform-origin: center center;
        transform-origin: center center;
        -webkit-transform: scale3d(0,1,1);
        transform: scale3d(0,1,1);

        @apply --paper-input-container-underline-focus;
      }

      .underline.is-highlighted .focused-line {
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .underline.is-invalid .focused-line {
        border-color: var(--paper-input-container-invalid-color, var(--error-color));
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .unfocused-line {
        @apply --layout-fit;
        border-bottom: 1px solid var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline;
      }

      :host([disabled]) .unfocused-line {
        border-bottom: 1px dashed;
        border-color: var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline-disabled;
      }

      .input-wrapper {
        @apply --layout-horizontal;
        @apply --layout-center;
        position: relative;
      }

      .input-content {
        @apply --layout-flex-auto;
        @apply --layout-relative;
        max-width: 100%;
      }

      .input-content ::slotted(label),
      .input-content ::slotted(.paper-input-label) {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        font: inherit;
        color: var(--paper-input-container-color, var(--secondary-text-color));
        -webkit-transition: -webkit-transform 0.25s, width 0.25s;
        transition: transform 0.25s, width 0.25s;
        -webkit-transform-origin: left top;
        transform-origin: left top;
        /* Fix for safari not focusing 0-height date/time inputs with -webkit-apperance: none; */
        min-height: 1px;

        @apply --paper-font-common-nowrap;
        @apply --paper-font-subhead;
        @apply --paper-input-container-label;
        @apply --paper-transition-easing;
      }


      .input-content ::slotted(label):before,
      .input-content ::slotted(.paper-input-label):before {
        @apply --paper-input-container-label-before;
      }

      .input-content ::slotted(label):after,
      .input-content ::slotted(.paper-input-label):after {
        @apply --paper-input-container-label-after;
      }

      .input-content.label-is-floating ::slotted(label),
      .input-content.label-is-floating ::slotted(.paper-input-label) {
        -webkit-transform: translateY(-75%) scale(0.75);
        transform: translateY(-75%) scale(0.75);

        /* Since we scale to 75/100 of the size, we actually have 100/75 of the
        original space now available */
        width: 133%;

        @apply --paper-input-container-label-floating;
      }

      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(label),
      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(.paper-input-label) {
        right: 0;
        left: auto;
        -webkit-transform-origin: right top;
        transform-origin: right top;
      }

      .input-content.label-is-highlighted ::slotted(label),
      .input-content.label-is-highlighted ::slotted(.paper-input-label) {
        color: var(--paper-input-container-focus-color, var(--primary-color));

        @apply --paper-input-container-label-focus;
      }

      .input-content.is-invalid ::slotted(label),
      .input-content.is-invalid ::slotted(.paper-input-label) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .input-content.label-is-hidden ::slotted(label),
      .input-content.label-is-hidden ::slotted(.paper-input-label) {
        visibility: hidden;
      }

      .input-content ::slotted(input),
      .input-content ::slotted(iron-input),
      .input-content ::slotted(textarea),
      .input-content ::slotted(iron-autogrow-textarea),
      .input-content ::slotted(.paper-input-input) {
        @apply --paper-input-container-shared-input-style;
        /* The apply shim doesn't apply the nested color custom property,
          so we have to re-apply it here. */
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        @apply --paper-input-container-input;
      }

      .input-content ::slotted(input)::-webkit-outer-spin-button,
      .input-content ::slotted(input)::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      .input-content.focused ::slotted(input),
      .input-content.focused ::slotted(iron-input),
      .input-content.focused ::slotted(textarea),
      .input-content.focused ::slotted(iron-autogrow-textarea),
      .input-content.focused ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-focus;
      }

      .input-content.is-invalid ::slotted(input),
      .input-content.is-invalid ::slotted(iron-input),
      .input-content.is-invalid ::slotted(textarea),
      .input-content.is-invalid ::slotted(iron-autogrow-textarea),
      .input-content.is-invalid ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-invalid;
      }

      .prefix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;
        @apply --paper-input-prefix;
      }

      .suffix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;

        @apply --paper-input-suffix;
      }

      /* Firefox sets a min-width on the input, which can cause layout issues */
      .input-content ::slotted(input) {
        min-width: 0;
      }

      .input-content ::slotted(textarea) {
        resize: none;
      }

      .add-on-content {
        position: relative;
      }

      .add-on-content.is-invalid ::slotted(*) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .add-on-content.is-highlighted ::slotted(*) {
        color: var(--paper-input-container-focus-color, var(--primary-color));
      }
    </style>

    <div class="floated-label-placeholder" aria-hidden="true" hidden="[[noLabelFloat]]">&nbsp;</div>

    <div class="input-wrapper">
      <span class="prefix"><slot name="prefix"></slot></span>

      <div class$="[[_computeInputContentClass(noLabelFloat,alwaysFloatLabel,focused,invalid,_inputHasContent)]]" id="labelAndInputContainer">
        <slot name="label"></slot>
        <slot name="input"></slot>
      </div>

      <span class="suffix"><slot name="suffix"></slot></span>
    </div>

    <div class$="[[_computeUnderlineClass(focused,invalid)]]">
      <div class="unfocused-line"></div>
      <div class="focused-line"></div>
    </div>

    <div class$="[[_computeAddOnContentClass(focused,invalid)]]">
      <slot name="add-on"></slot>
    </div>
`,is:"paper-input-container",properties:{noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},attrForValue:{type:String,value:"bind-value"},autoValidate:{type:Boolean,value:!1},invalid:{observer:"_invalidChanged",type:Boolean,value:!1},focused:{readOnly:!0,type:Boolean,value:!1,notify:!0},_addons:{type:Array},_inputHasContent:{type:Boolean,value:!1},_inputSelector:{type:String,value:"input,iron-input,textarea,.paper-input-input"},_boundOnFocus:{type:Function,value:function(){return this._onFocus.bind(this)}},_boundOnBlur:{type:Function,value:function(){return this._onBlur.bind(this)}},_boundOnInput:{type:Function,value:function(){return this._onInput.bind(this)}},_boundValueChanged:{type:Function,value:function(){return this._onValueChanged.bind(this)}}},listeners:{"addon-attached":"_onAddonAttached","iron-input-validate":"_onIronInputValidate"},get _valueChangedEvent(){return this.attrForValue+"-changed"},get _propertyForValue(){return Sm(this.attrForValue)},get _inputElement(){return zt(this).querySelector(this._inputSelector)},get _inputElementValue(){return this._inputElement[this._propertyForValue]||this._inputElement.value},ready:function(){this.__isFirstValueUpdate=!0,this._addons||(this._addons=[]),this.addEventListener("focus",this._boundOnFocus,!0),this.addEventListener("blur",this._boundOnBlur,!0)},attached:function(){this.attrForValue?this._inputElement.addEventListener(this._valueChangedEvent,this._boundValueChanged):this.addEventListener("input",this._onInput),this._inputElementValue&&this._inputElementValue!=""?this._handleValueAndAutoValidate(this._inputElement):this._handleValue(this._inputElement)},_onAddonAttached:function(e){this._addons||(this._addons=[]);var t=e.target;this._addons.indexOf(t)===-1&&(this._addons.push(t),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1),this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(e){this._handleValueAndAutoValidate(e.target)},_onValueChanged:function(e){var t=e.target;this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,t.value===void 0||t.value==="")||this._handleValueAndAutoValidate(e.target)},_handleValue:function(e){var t=this._inputElementValue;t||t===0||e.type==="number"&&!e.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1,this.updateAddons({inputElement:e,value:t,invalid:this.invalid})},_handleValueAndAutoValidate:function(e){if(this.autoValidate&&e){var t;e.validate?t=e.validate(this._inputElementValue):t=e.checkValidity(),this.invalid=!t}this._handleValue(e)},_onIronInputValidate:function(e){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(e){for(var t,r=0;t=this._addons[r];r++)t.update(e)},_computeInputContentClass:function(e,t,r,n,i){var o="input-content";if(e)i&&(o+=" label-is-hidden"),n&&(o+=" is-invalid");else{var a=this.querySelector("label");t||i?(o+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",n?o+=" is-invalid":r&&(o+=" label-is-highlighted")):(a&&(this.$.labelAndInputContainer.style.position="relative"),n&&(o+=" is-invalid"))}return r&&(o+=" focused"),o},_computeUnderlineClass:function(e,t){var r="underline";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r},_computeAddOnContentClass:function(e,t){var r="add-on-content";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        visibility: hidden;

        color: var(--paper-input-container-invalid-color, var(--error-color));

        @apply --paper-font-caption;
        @apply --paper-input-error;
        position: absolute;
        left:0;
        right:0;
      }

      :host([invalid]) {
        visibility: visible;
      }

      #a11yWrapper {
        visibility: hidden;
      }

      :host([invalid]) #a11yWrapper {
        visibility: visible;
      }
    </style>

    <!--
    If the paper-input-error element is directly referenced by an
    \`aria-describedby\` attribute, such as when used as a paper-input add-on,
    then applying \`visibility: hidden;\` to the paper-input-error element itself
    does not hide the error.

    For more information, see:
    https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
    -->
    <div id="a11yWrapper">
      <slot></slot>
    </div>
`,is:"paper-input-error",behaviors:[C9],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(e){this._setInvalid(e.invalid)}});var Zx={};Zx.NextLabelID=1;Zx.NextAddonID=1;Zx.NextInputID=1;var qbe={properties:{label:{type:String},value:{notify:!0,type:String},disabled:{type:Boolean,value:!1},invalid:{type:Boolean,value:!1,notify:!0},allowedPattern:{type:String},type:{type:String},list:{type:String},pattern:{type:String},required:{type:Boolean,value:!1},errorMessage:{type:String},charCounter:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},autoValidate:{type:Boolean,value:!1},validator:{type:String},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,observer:"_autofocusChanged"},inputmode:{type:String},minlength:{type:Number},maxlength:{type:Number},min:{type:String},max:{type:String},step:{type:String},name:{type:String},placeholder:{type:String,value:""},readonly:{type:Boolean,value:!1},size:{type:Number},autocapitalize:{type:String,value:"none"},autocorrect:{type:String,value:"off"},autosave:{type:String},results:{type:Number},accept:{type:String},multiple:{type:Boolean},_ariaDescribedBy:{type:String,value:""},_ariaLabelledBy:{type:String,value:""},_inputId:{type:String,value:""}},listeners:{"addon-attached":"_onAddonAttached"},keyBindings:{"shift+tab:keydown":"_onShiftTabDown"},hostAttributes:{tabindex:0},get inputElement(){return this.$||(this.$={}),this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId)),this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText=["date","datetime","datetime-local","month","time","week","file"]},attached:function(){this._updateAriaLabelledBy(),!mt&&this.inputElement&&this._typesThatHaveText.indexOf(this.inputElement.type)!==-1&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(e,t){return e?e=e+" "+t:e=t,e},_onAddonAttached:function(e){var t=zt(e).rootTarget;if(t.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,t.id);else{var r="paper-input-add-on-"+Zx.NextAddonID++;t.id=r,this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,r)}},validate:function(){return this.inputElement.validate()},_focusBlurHandler:function(e){Di._focusBlurHandler.call(this,e),this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");this._shiftTabPressed=!0,this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(e){try{var t=this.inputElement.selectionStart;this.value=e,this.inputElement.selectionStart=t,this.inputElement.selectionEnd=t}catch(r){this.value=e}},_computeAlwaysFloatLabel:function(e,t){return t||e},_updateAriaLabelledBy:function(){var e=zt(this.root).querySelector("label");if(!e){this._ariaLabelledBy="";return}var t;e.id?t=e.id:(t="paper-input-label-"+Zx.NextLabelID++,e.id=t),this._ariaLabelledBy=t},_generateInputId:function(){(!this._inputId||this._inputId==="")&&(this._inputId="input-"+Zx.NextInputID++)},_onChange:function(e){this.shadowRoot&&this.fire(e.type,{sourceEvent:e},{node:this,bubbles:e.bubbles,cancelable:e.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var e=document.activeElement,t=e instanceof HTMLElement,r=t&&e!==document.body&&e!==document.documentElement;r||this._focusableElement.focus()}}},A9=[Di,Oo,qbe];Yt({is:"paper-input",_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([focused]) {
        outline: none;
      }

      :host([hidden]) {
        display: none !important;
      }

      input {
        /* Firefox sets a min-width on the input, which can cause layout issues */
        min-width: 0;
      }

      /* In 1.x, the <input> is distributed to paper-input-container, which styles it.
      In 2.x the <iron-input> is distributed to paper-input-container, which styles
      it, but in order for this to work correctly, we need to reset some
      of the native input's properties to inherit (from the iron-input) */
      iron-input > input {
        @apply --paper-input-container-shared-input-style;
        font-family: inherit;
        font-weight: inherit;
        font-size: inherit;
        letter-spacing: inherit;
        word-spacing: inherit;
        line-height: inherit;
        text-shadow: inherit;
        color: inherit;
        cursor: inherit;
      }

      input:disabled {
        @apply --paper-input-container-input-disabled;
      }

      input::-webkit-outer-spin-button,
      input::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      input::-webkit-clear-button {
        @apply --paper-input-container-input-webkit-clear;
      }

      input::-webkit-calendar-picker-indicator {
        @apply --paper-input-container-input-webkit-calendar-picker-indicator;
      }

      input::-webkit-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input:-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-ms-clear {
        @apply --paper-input-container-ms-clear;
      }

      input::-ms-reveal {
        @apply --paper-input-container-ms-reveal;
      }

      input:-ms-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container id="container" no-label-float="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <slot name="prefix" slot="prefix"></slot>

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <!-- Need to bind maxlength so that the paper-input-char-counter works correctly -->
      <iron-input bind-value="{{value}}" slot="input" class="input-element" id$="[[_inputId]]" maxlength$="[[maxlength]]" allowed-pattern="[[allowedPattern]]" invalid="{{invalid}}" validator="[[validator]]">
        <input aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" type$="[[type]]" pattern$="[[pattern]]" required$="[[required]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" min$="[[min]]" max$="[[max]]" step$="[[step]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" list$="[[list]]" size$="[[size]]" autocapitalize$="[[autocapitalize]]" autocorrect$="[[autocorrect]]" on-change="_onChange" tabindex$="[[tabIndex]]" autosave$="[[autosave]]" results$="[[results]]" accept$="[[accept]]" multiple$="[[multiple]]" role$="[[inputRole]]" aria-haspopup$="[[inputAriaHaspopup]]">
      </iron-input>

      <slot name="suffix" slot="suffix"></slot>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
  `,behaviors:[A9,Th],properties:{value:{type:String},inputRole:{type:String,value:void 0},inputAriaHaspopup:{type:String,value:void 0}},get _focusableElement(){return this.inputElement._inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input")),this.inputElement&&this._typesThatHaveText.indexOf(this.$.nativeInput.type)!==-1&&(this.alwaysFloatLabel=!0),this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});Yt({_template:Q`
    <style>
      :host {
        position: fixed;
      }

      #contentWrapper ::slotted(*) {
        overflow: auto;
      }

      #contentWrapper.animating ::slotted(*) {
        overflow: hidden;
        pointer-events: none;
      }
    </style>

    <div id="contentWrapper">
      <slot id="content" name="dropdown-content"></slot>
    </div>
`,is:"iron-dropdown",behaviors:[Di,Oo,Kx,b9],properties:{horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},openAnimationConfig:{type:Object},closeAnimationConfig:{type:Object},focusTarget:{type:Object},noAnimations:{type:Boolean,value:!1},allowOutsideScroll:{type:Boolean,value:!1,observer:"_allowOutsideScrollChanged"}},listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},observers:["_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)"],get containedElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},ready:function(){this.scrollAction||(this.scrollAction=this.allowOutsideScroll?"refit":"lock"),this._readied=!0},attached:function(){(!this.sizingTarget||this.sizingTarget===this)&&(this.sizingTarget=this.containedElement||this)},detached:function(){this.cancelAnimation()},_openedChanged:function(){this.opened&&this.disabled?this.cancel():(this.cancelAnimation(),this._updateAnimationConfig(),Im._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Im._renderOpened.apply(this,arguments)},_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Im._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating"),this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var e=this.containedElement,t=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||[]),r=0;r<t.length;r++)t[r].node=e;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(e){!this._readied||(e?(!this.scrollAction||this.scrollAction==="lock")&&(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var e=this.focusTarget||this.containedElement;e&&this.opened&&!this.noAutoFocus?e.focus():Im._applyFocus.apply(this,arguments)}});var vp={properties:{animationTiming:{type:Object,value:function(){return{duration:500,easing:"cubic-bezier(0.4, 0, 0.2, 1)",fill:"both"}}}},isNeonAnimation:!0,created:function(){document.body.animate||console.warn("No web animations detected. This element will not function without a web animations polyfill.")},timingFromConfig:function(e){if(e.timing)for(var t in e.timing)this.animationTiming[t]=e.timing[t];return this.animationTiming},setPrefixedProperty:function(e,t,r){for(var n={transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]},i=n[t],o,a=0;o=i[a];a++)e.style[o]=r;e.style[t]=r},complete:function(e){}};Yt({is:"fade-in-animation",behaviors:[vp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(e)),this._effect}});Yt({is:"fade-out-animation",behaviors:[vp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-height-animation",_template:null,behaviors:[vp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this._effect=new KeyframeEffect(t,[{height:n/2+"px"},{height:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-width-animation",_template:null,behaviors:[vp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n/2+"px"},{width:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-width-animation",_template:null,behaviors:[vp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n+"px"},{width:n-n/20+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-height-animation",_template:null,behaviors:[vp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this.setPrefixedProperty(t,"transformOrigin","0 0"),this._effect=new KeyframeEffect(t,[{height:n+"px",transform:"translateY(0)"},{height:n/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(e)),this._effect}});var dE={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400},Gbe=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;

        @apply --paper-menu-button;
      }

      :host([disabled]) {
        cursor: auto;
        color: var(--disabled-text-color);

        @apply --paper-menu-button-disabled;
      }

      iron-dropdown {
        @apply --paper-menu-button-dropdown;
      }

      .dropdown-content {
        @apply --shadow-elevation-2dp;

        position: relative;
        border-radius: 2px;
        background-color: var(--paper-menu-button-dropdown-background, var(--primary-background-color));

        @apply --paper-menu-button-content;
      }

      :host([vertical-align="top"]) .dropdown-content {
        margin-bottom: 20px;
        margin-top: -10px;
        top: 10px;
      }

      :host([vertical-align="bottom"]) .dropdown-content {
        bottom: 10px;
        margin-bottom: -10px;
        margin-top: 20px;
      }

      #trigger {
        cursor: pointer;
      }
    </style>

    <div id="trigger" on-tap="toggle">
      <slot name="dropdown-trigger"></slot>
    </div>

    <iron-dropdown id="dropdown" opened="{{opened}}" horizontal-align="[[horizontalAlign]]" vertical-align="[[verticalAlign]]" dynamic-align="[[dynamicAlign]]" horizontal-offset="[[horizontalOffset]]" vertical-offset="[[verticalOffset]]" no-overlap="[[noOverlap]]" open-animation-config="[[openAnimationConfig]]" close-animation-config="[[closeAnimationConfig]]" no-animations="[[noAnimations]]" focus-target="[[_dropdownContent]]" allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" on-iron-overlay-canceled="__onIronOverlayCanceled" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
`,is:"paper-menu-button",behaviors:[Oo,Di],properties:{opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},noOverlap:{type:Boolean},noAnimations:{type:Boolean,value:!1},ignoreSelect:{type:Boolean,value:!1},closeOnActivate:{type:Boolean,value:!1},openAnimationConfig:{type:Object,value:function(){return[{name:"fade-in-animation",timing:{delay:100,duration:200}},{name:"paper-menu-grow-width-animation",timing:{delay:100,duration:150,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:dE.ANIMATION_CUBIC_BEZIER}}]}},closeAnimationConfig:{type:Object,value:function(){return[{name:"fade-out-animation",timing:{duration:150}},{name:"paper-menu-shrink-width-animation",timing:{delay:100,duration:50,easing:dE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-shrink-height-animation",timing:{duration:200,easing:"ease-in"}}]}},allowOutsideScroll:{type:Boolean,value:!1},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},toggle:function(){this.opened?this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(e){this.ignoreSelect||this.close()},_onIronActivate:function(e){this.closeOnActivate&&this.close()},_openedChanged:function(e,t){e?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):t!=null&&this.fire("paper-dropdown-close")},_disabledChanged:function(e){Di._disabledChanged.apply(this,arguments),e&&this.opened&&this.close()},__onIronOverlayCanceled:function(e){var t=e.detail,r=this.$.trigger,n=zt(t).path;n.indexOf(r)>-1&&e.preventDefault()}});Object.keys(dE).forEach(function(e){Gbe[e]=dE[e]});var vW=document.createElement("template");vW.setAttribute("style","display: none;");vW.innerHTML=`<iron-iconset-svg name="paper-dropdown-menu" size="24">
<svg><defs>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(vW.content);var xW=document.createElement("template");xW.setAttribute("style","display: none;");xW.innerHTML=`<dom-module id="paper-dropdown-menu-shared-styles">
  <template>
    <style>
      :host {
        display: inline-block;
        position: relative;
        text-align: left;

        /* NOTE(cdata): Both values are needed, since some phones require the
         * value to be \`transparent\`.
         */
        -webkit-tap-highlight-color: rgba(0,0,0,0);
        -webkit-tap-highlight-color: transparent;

        --paper-input-container-input: {
          overflow: hidden;
          white-space: nowrap;
          text-overflow: ellipsis;
          max-width: 100%;
          box-sizing: border-box;
          cursor: pointer;
        };

        @apply --paper-dropdown-menu;
      }

      /* paper-dropdown-menu and paper-dropdown-menu-light both delegate focus
       * to other internal elements which manage focus styling. */
      :host(:focus) {
        outline: none;
      }

      :host(:dir(rtl)) {
        text-align: right;

        @apply(--paper-dropdown-menu);
      }

      :host([disabled]) {
        @apply --paper-dropdown-menu-disabled;
      }

      :host([noink]) paper-ripple {
        display: none;
      }

      :host([no-label-float]) paper-ripple {
        top: 8px;
      }

      paper-ripple {
        top: 12px;
        left: 0px;
        bottom: 8px;
        right: 0px;

        @apply --paper-dropdown-menu-ripple;
      }

      paper-menu-button {
        display: block;
        padding: 0;

        @apply --paper-dropdown-menu-button;
      }

      paper-input {
        @apply --paper-dropdown-menu-input;
      }

      iron-icon {
        color: var(--disabled-text-color);

        @apply --paper-dropdown-menu-icon;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(xW.content);var Wbe=Gt(HTMLElement);Yt({_template:Q`
    <style include="paper-dropdown-menu-shared-styles"></style>

    <paper-menu-button id="menuButton" vertical-align="[[verticalAlign]]" horizontal-align="[[horizontalAlign]]" dynamic-align="[[dynamicAlign]]" vertical-offset="[[_computeMenuVerticalOffset(noLabelFloat, verticalOffset)]]" disabled="[[disabled]]" no-animations="[[noAnimations]]" on-iron-select="_onIronSelect" on-iron-deselect="_onIronDeselect" opened="{{opened}}" close-on-activate allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <!-- support hybrid mode: user might be using paper-menu-button 1.x which distributes via <content> -->
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        <!-- paper-input has type="text" for a11y, do not remove -->
        <paper-input id="input" type="text" invalid="[[invalid]]" readonly disabled="[[disabled]]" value="[[value]]" placeholder="[[placeholder]]" error-message="[[errorMessage]]" always-float-label="[[alwaysFloatLabel]]" no-label-float="[[noLabelFloat]]" label="[[label]]" input-role="button" input-aria-haspopup="listbox" autocomplete="off">
          <!-- support hybrid mode: user might be using paper-input 1.x which distributes via <content> -->
          <iron-icon icon="paper-dropdown-menu:arrow-drop-down" suffix slot="suffix"></iron-icon>
        </paper-input>
      </div>
      <slot id="content" name="dropdown-content" slot="dropdown-content"></slot>
    </paper-menu-button>
`,is:"paper-dropdown-menu",behaviors:[Mh,Di,Th,Ch],properties:{selectedItemLabel:{type:String,notify:!0,readOnly:!0},selectedItem:{type:Object,notify:!0,readOnly:!0},value:{type:String,notify:!0},label:{type:String},placeholder:{type:String},errorMessage:{type:String},opened:{type:Boolean,notify:!0,value:!1,observer:"_openedChanged"},allowOutsideScroll:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1,reflectToAttribute:!0},alwaysFloatLabel:{type:Boolean,value:!1},noAnimations:{type:Boolean,value:!1},horizontalAlign:{type:String,value:"right"},verticalAlign:{type:String,value:"top"},verticalOffset:Number,dynamicAlign:{type:Boolean},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},observers:["_selectedItemChanged(selectedItem)"],_attachDom(e){let t=ue(this);return t.attachShadow({mode:"open",delegatesFocus:!0,shadyUpgradeFragment:e}),t.shadowRoot.appendChild(e),Wbe.prototype._attachDom.call(this,e)},focus(){this.$.input._focusableElement.focus()},attached:function(){var e=this.contentElement;e&&e.selectedItem&&this._setSelectedItem(e.selectedItem)},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(e){this._setSelectedItem(e.detail.item)},_onIronDeselect:function(e){this._setSelectedItem(null)},_onTap:function(e){lgt(e)===this&&this.open()},_selectedItemChanged:function(e){var t="";e?t=e.label||e.getAttribute("label")||e.textContent.trim():t="",this.value=t,this._setSelectedItemLabel(t)},_computeMenuVerticalOffset:function(e,t){return t||(e?-4:8)},_getValidity:function(e){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var e=this.opened?"true":"false",t=this.contentElement;t&&t.setAttribute("aria-expanded",e)}});var bW=1,P0t=2,P9={outerScroll:{scroll:!0},shadowMode:{standard:P0t,waterfall:bW,"waterfall-tall":bW},tallMode:{"waterfall-tall":!0}};Yt({_template:Q`
    <style>
      :host {
        @apply --layout-vertical;
        position: relative;
        height: 100%;
        @apply --paper-header-panel;
      }

      #mainContainer {
        @apply --layout-flex;
        position: relative;
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      #mainPanel {
        @apply --layout-vertical;
        @apply --layout-flex;
        position: relative;
        min-height: 0;
        @apply --paper-header-panel-body;
      }

      #mainContainer {
        @apply --paper-header-panel-container;
      }

      /*
       * mode: scroll
       */
      :host([mode=scroll]) #mainContainer {
        @apply --paper-header-panel-scroll-container;
        overflow: visible;
      }

      :host([mode=scroll]) {
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      /*
       * mode: cover
       */
      :host([mode=cover]) #mainContainer {
        @apply --paper-header-panel-cover-container;
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      :host([mode=cover]) #mainPanel {
        position: static;
      }

      /*
       * mode: standard
       */
      :host([mode=standard]) #mainContainer {
        @apply --paper-header-panel-standard-container;
      }

      /*
       * mode: seamed
       */
      :host([mode=seamed]) #mainContainer {
        @apply --paper-header-panel-seamed-container;
      }


      /*
       * mode: waterfall
       */
      :host([mode=waterfall]) #mainContainer {
        @apply --paper-header-panel-waterfall-container;
      }

      /*
       * mode: waterfall-tall
       */
      :host([mode=waterfall-tall]) #mainContainer {
        @apply --paper-header-panel-waterfall-tall-container;
      }

      #dropShadow {
        transition: opacity 0.5s;
        height: 6px;
        box-shadow: inset 0px 5px 6px -3px rgba(0, 0, 0, 0.4);
        @apply --paper-header-panel-shadow;
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        opacity: 0;
        pointer-events: none;
      }

      #dropShadow.has-shadow {
        opacity: 1;
      }

      #mainContainer > ::slotted(.fit) {
        @apply --layout-fit;
      }

    </style>

    <slot id="headerSlot" name="header"></slot>

    <div id="mainPanel">
      <div id="mainContainer" class\$="[[_computeMainContainerClass(mode)]]">
        <slot></slot>
      </div>
      <div id="dropShadow"></div>
    </div>
`,is:"paper-header-panel",properties:{mode:{type:String,value:"standard",observer:"_modeChanged",reflectToAttribute:!0},shadow:{type:Boolean,value:!1},tallClass:{type:String,value:"tall"},atTop:{type:Boolean,value:!0,notify:!0,readOnly:!0,reflectToAttribute:!0}},observers:["_computeDropShadowHidden(atTop, mode, shadow)"],attached:function(){this._addListener(),this._keepScrollingState()},detached:function(){this._removeListener()},ready:function(){this.scrollHandler=this._scroll.bind(this),console.warn(this.is,"is deprecated. Please use app-layout instead!")},get header(){return zt(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(e,t,r){var n=P9.shadowMode[t];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===P0t?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===bW&&!e?this.toggleClass("has-shadow",!0,this.$.dropShadow):this.toggleClass("has-shadow",!1,this.$.dropShadow)},_computeMainContainerClass:function(e){var t={};return t.flex=e!=="cover",Object.keys(t).filter(function(r){return t[r]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(e,t){var r=P9,n=this.header,i=200;n&&(r.tallMode[t]&&!r.tallMode[e]?(n.classList.remove(this.tallClass),this.async(function(){n.classList.remove("animate")},i)):this.toggleClass("animate",r.tallMode[e],n)),this._keepScrollingState()},_keepScrollingState:function(){var e=this.scroller,t=this.header;this._setAtTop(e.scrollTop===0),t&&this.tallClass&&P9.tallMode[this.mode]&&this.toggleClass(this.tallClass,this.atTop||t.classList.contains(this.tallClass)&&e.scrollHeight<this.offsetHeight,t)},_scroll:function(){this._keepScrollingState(),this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(e){return P9.outerScroll[e]?this:this.$.mainContainer}});Yt({is:"paper-icon-button",_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: pointer;
        z-index: 0;
        line-height: 1;

        width: 40px;
        height: 40px;

        /*
          NOTE: Both values are needed, since some phones require the value to
          be \`transparent\`.
        */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        /* Because of polymer/2558, this style has lower specificity than * */
        box-sizing: border-box !important;

        @apply --paper-icon-button;
      }

      :host #ink {
        color: var(--paper-icon-button-ink-color, var(--primary-text-color));
        opacity: 0.6;
      }

      :host([disabled]) {
        color: var(--paper-icon-button-disabled-text, var(--disabled-text-color));
        pointer-events: none;
        cursor: auto;

        @apply --paper-icon-button-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:hover) {
        @apply --paper-icon-button-hover;
      }

      iron-icon {
        --iron-icon-width: 100%;
        --iron-icon-height: 100%;
      }
    </style>

    <iron-icon id="icon" src="[[src]]" icon="[[icon]]"
               alt$="[[alt]]"></iron-icon>
  `,hostAttributes:{role:"button",tabindex:"0"},behaviors:[jx],registered:function(){this._template.setAttribute("strip-whitespace","")},properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(e,t){var r=this.getAttribute("aria-label");(!r||t==r)&&this.setAttribute("aria-label",e)}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        width: 400px;
        border: 1px solid;
        padding: 2px;
        -moz-appearance: textarea;
        -webkit-appearance: textarea;
        overflow: hidden;
      }

      .mirror-text {
        visibility: hidden;
        word-wrap: break-word;
        @apply --iron-autogrow-textarea;
      }

      .fit {
        @apply --layout-fit;
      }

      textarea {
        position: relative;
        outline: none;
        border: none;
        resize: none;
        background: inherit;
        color: inherit;
        /* see comments in template */
        width: 100%;
        height: 100%;
        font-size: inherit;
        font-family: inherit;
        line-height: inherit;
        text-align: inherit;
        @apply --iron-autogrow-textarea;
      }

      textarea::-webkit-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea::-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-ms-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }
    </style>

    <!-- the mirror sizes the input/textarea so it grows with typing -->
    <!-- use &#160; instead &nbsp; of to allow this element to be used in XHTML -->
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    <!-- size the input/textarea with a div, because the textarea has intrinsic size in ff -->
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" autocapitalize$="[[autocapitalize]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
`,is:"iron-autogrow-textarea",behaviors:[Ch,Di],properties:{value:{observer:"_valueChanged",type:String,notify:!0},bindValue:{observer:"_bindValueChanged",type:String,notify:!0},rows:{type:Number,value:1,observer:"_updateCached"},maxRows:{type:Number,value:0,observer:"_updateCached"},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,value:!1},autocapitalize:{type:String,value:"none"},inputmode:{type:String},placeholder:{type:String},readonly:{type:String},required:{type:Boolean},minlength:{type:Number},maxlength:{type:Number},label:{type:String}},listeners:{input:"_onInput"},get textarea(){return this.$.textarea},get selectionStart(){return this.$.textarea.selectionStart},get selectionEnd(){return this.$.textarea.selectionEnd},set selectionStart(e){this.$.textarea.selectionStart=e},set selectionEnd(e){this.$.textarea.selectionEnd=e},attached:function(){var e=navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&!navigator.userAgent.match(/OS 1[3456789]/);e&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var e=this.$.textarea.validity.valid;return e&&(this.required&&this.value===""?e=!1:this.hasValidator()&&(e=Ch.validate.call(this,this.value))),this.invalid=!e,this.fire("iron-input-validate"),e},_bindValueChanged:function(e){this.value=e},_valueChanged:function(e){var t=this.textarea;!t||(t.value!==e&&(t.value=e||e===0?e:""),this.bindValue=e,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(e){var t=zt(e).path;this.value=t?t[0].value:e.target.value},_constrain:function(e){var t;for(e=e||[""],this.maxRows>0&&e.length>this.maxRows?t=e.slice(0,this.maxRows):t=e.slice(0);this.rows>0&&t.length<this.rows;)t.push("");return t.join("<br/>")+"&#160;"},_valueForMirror:function(){var e=this.textarea;if(!!e)return this.tokens=e&&e.value?e.value.replace(/&/gm,"&amp;").replace(/"/gm,"&quot;").replace(/'/gm,"&#39;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").split(`
`):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=this._constrain(this.tokens)}});Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container no-label-float$="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <iron-autogrow-textarea class="paper-input-input" slot="input" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" bind-value="{{value}}" invalid="{{invalid}}" validator$="[[validator]]" disabled$="[[disabled]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" autocapitalize$="[[autocapitalize]]" rows$="[[rows]]" max-rows$="[[maxRows]]" on-change="_onChange"></iron-autogrow-textarea>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
`,is:"paper-textarea",behaviors:[A9,Th],properties:{_ariaLabelledBy:{observer:"_ariaLabelledByChanged",type:String},_ariaDescribedBy:{observer:"_ariaDescribedByChanged",type:String},value:{type:String},rows:{type:Number,value:1},maxRows:{type:Number,value:0}},get selectionStart(){return this.$.input.textarea.selectionStart},set selectionStart(e){this.$.input.textarea.selectionStart=e},get selectionEnd(){return this.$.input.textarea.selectionEnd},set selectionEnd(e){this.$.input.textarea.selectionEnd=e},_ariaLabelledByChanged:function(e){this._focusableElement.setAttribute("aria-labelledby",e)},_ariaDescribedByChanged:function(e){this._focusableElement.setAttribute("aria-describedby",e)},get _focusableElement(){return this.inputElement.textarea}});var wW=document.createElement("template");wW.setAttribute("style","display: none;");wW.innerHTML=`<dom-module id="paper-item-shared-styles">
  <template>
    <style>
      :host, .paper-item {
        display: block;
        position: relative;
        min-height: var(--paper-item-min-height, 48px);
        padding: 0px 16px;
      }

      .paper-item {
        @apply --paper-font-subhead;
        border:none;
        outline: none;
        background: white;
        width: 100%;
        text-align: left;
      }

      :host([hidden]), .paper-item[hidden] {
        display: none !important;
      }

      :host(.iron-selected), .paper-item.iron-selected {
        font-weight: var(--paper-item-selected-weight, bold);

        @apply --paper-item-selected;
      }

      :host([disabled]), .paper-item[disabled] {
        color: var(--paper-item-disabled-color, var(--disabled-text-color));

        @apply --paper-item-disabled;
      }

      :host(:focus), .paper-item:focus {
        position: relative;
        outline: 0;

        @apply --paper-item-focused;
      }

      :host(:focus):before, .paper-item:focus:before {
        @apply --layout-fit;

        background: currentColor;
        content: '';
        opacity: var(--dark-divider-opacity);
        pointer-events: none;

        @apply --paper-item-focused-before;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(wW.content);var Ybe={hostAttributes:{role:"option",tabindex:"0"}},I9=[Mh,Di,Ybe];Yt({_template:Q`
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
`,is:"paper-item",behaviors:[I9]});Yt({_template:Q`
    <style>
      :host {
        overflow: hidden; /* needed for text-overflow: ellipsis to work on ff */
        @apply --layout-vertical;
        @apply --layout-center-justified;
        @apply --layout-flex;
      }

      :host([two-line]) {
        min-height: var(--paper-item-body-two-line-min-height, 72px);
      }

      :host([three-line]) {
        min-height: var(--paper-item-body-three-line-min-height, 88px);
      }

      :host > ::slotted(*) {
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
      }

      :host > ::slotted([secondary]) {
        @apply --paper-font-body1;

        color: var(--paper-item-body-secondary-color, var(--secondary-text-color));

        @apply --paper-item-body-secondary;
      }
    </style>

    <slot></slot>
`,is:"paper-item-body"});Yt({_template:Q`
    <style include="paper-item-shared-styles"></style>
    <style>
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
        @apply --paper-icon-item;
      }

      .content-icon {
        @apply --layout-horizontal;
        @apply --layout-center;

        width: var(--paper-item-icon-width, 56px);
        @apply --paper-item-icon;
      }
    </style>

    <div id="contentIcon" class="content-icon">
      <slot name="item-icon"></slot>
    </div>
    <slot></slot>
`,is:"paper-icon-item",behaviors:[I9]});var SW={properties:{multi:{type:Boolean,value:!1,observer:"multiChanged"},selectedValues:{type:Array,notify:!0,value:function(){return[]}},selectedItems:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}}},observers:["_updateSelected(selectedValues.splices)"],select:function(e){this.multi?this._toggleSelected(e):this.selected=e},multiChanged:function(e){this._selection.multi=e,this._updateSelected()},get _shouldUpdateSelection(){return this.selected!=null||this.selectedValues!=null&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&this.selectedItems.length>0&&(this.selectedValues=this.selectedItems.map(function(e){return this._indexToValue(this.indexOf(e))},this).filter(function(e){return e!=null},this)):Sh._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(e){e=e||[];var t=(this._valuesToItems(e)||[]).filter(function(i){return i!=null});this._selection.clear(t);for(var r=0;r<t.length;r++)this._selection.setItemSelected(t[r],!0);if(this.fallbackSelection&&!this._selection.get().length){var n=this._valueToItem(this.fallbackSelection);n&&this.select(this.fallbackSelection)}},_selectionChange:function(){var e=this._selection.get();this.multi?(this._setSelectedItems(e),this._setSelectedItem(e.length?e[0]:null)):e!=null?(this._setSelectedItems([e]),this._setSelectedItem(e)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(e){var t=this.selectedValues.indexOf(e),r=t<0;r?this.push("selectedValues",e):this.splice("selectedValues",t,1)},_valuesToItems:function(e){return e==null?null:e.map(function(t){return this._valueToItem(t)},this)}},I0t=[Sh,SW];var y_={properties:{focusedItem:{observer:"_focusedItemChanged",readOnly:!0,type:Object},attrForItemTitle:{type:String},disabled:{type:Boolean,value:!1,observer:"_disabledChanged"}},_MODIFIER_KEYS:["Alt","AltGraph","CapsLock","Control","Fn","FnLock","Hyper","Meta","NumLock","OS","ScrollLock","Shift","Super","Symbol","SymbolLock"],_SEARCH_RESET_TIMEOUT_MS:1e3,_previousTabIndex:0,hostAttributes:{role:"menu"},observers:["_updateMultiselectable(multi)"],listeners:{focus:"_onFocus",keydown:"_onKeydown","iron-items-changed":"_onIronItemsChanged"},keyBindings:{up:"_onUpKey",down:"_onDownKey",esc:"_onEscKey","shift+tab:keydown":"_onShiftTabDown"},attached:function(){this._resetTabindices()},select:function(e){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var t=this._valueToItem(e);t&&t.hasAttribute("disabled")||(this._setFocusedItem(t),SW.select.apply(this,arguments))},_resetTabindices:function(){var e=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(t){t.setAttribute("tabindex",t===e?"0":"-1"),t.setAttribute("aria-selected",this._selection.isSelected(t))},this)},_updateMultiselectable:function(e){e?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(e){if(this._MODIFIER_KEYS.indexOf(e.key)===-1){this.cancelDebouncer("_clearSearchText");var t=this._searchText||"",r=e.key&&e.key.length==1?e.key:String.fromCharCode(e.keyCode);t+=r.toLocaleLowerCase();for(var n=t.length,i=0,o;o=this.items[i];i++)if(!o.hasAttribute("disabled")){var a=this.attrForItemTitle||"textContent",s=(o[a]||o.getAttribute(a)||"").trim();if(!(s.length<n)&&s.slice(0,n).toLocaleLowerCase()==t){this._setFocusedItem(o);break}}this._searchText=t,this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t-r+e)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_focusNext:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t+r)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_applySelection:function(e,t){t?e.setAttribute("aria-selected","true"):e.setAttribute("aria-selected","false"),Sh._applySelection.apply(this,arguments)},_focusedItemChanged:function(e,t){t&&t.setAttribute("tabindex","-1"),e&&!e.hasAttribute("disabled")&&!this.disabled&&(e.setAttribute("tabindex","0"),e.focus())},_onIronItemsChanged:function(e){e.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");y_._shiftTabPressed=!0,this._setFocusedItem(null),this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),y_._shiftTabPressed=!1},1)},_onFocus:function(e){if(!y_._shiftTabPressed){var t=zt(e).rootTarget;t!==this&&typeof t.tabIndex!="undefined"&&!this.isLightDescendant(t)||(this._defaultFocusAsync=this.async(function(){var r=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null),r?this._setFocusedItem(r):this.items[0]&&this._focusNext()}))}},_onUpKey:function(e){this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onEscKey:function(e){var t=this.focusedItem;t&&t.blur()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down esc")||this._focusWithKeyboardEvent(e),e.stopPropagation()},_activateHandler:function(e){Sh._activateHandler.call(this,e),e.stopPropagation()},_disabledChanged:function(e){e?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};y_._shiftTabPressed=!1;var L9=[I0t,Oo,y_];Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;

        background: var(--paper-listbox-background-color, var(--primary-background-color));
        color: var(--paper-listbox-color, var(--primary-text-color));

        @apply --paper-listbox;
      }
    </style>

    <slot></slot>
`,is:"paper-listbox",behaviors:[L9],hostAttributes:{role:"listbox"}});var L0t=Q`
<dom-module id="paper-material-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        position: relative;
      }

      :host([elevation="1"]) {
        @apply --shadow-elevation-2dp;
      }

      :host([elevation="2"]) {
        @apply --shadow-elevation-4dp;
      }

      :host([elevation="3"]) {
        @apply --shadow-elevation-6dp;
      }

      :host([elevation="4"]) {
        @apply --shadow-elevation-8dp;
      }

      :host([elevation="5"]) {
        @apply --shadow-elevation-16dp;
      }
    </style>
  </template>
</dom-module>
`;L0t.setAttribute("style","display: none;");document.body.appendChild(L0t.content);Yt({_template:Q`
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
`,is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});var k9={properties:{value:{type:Number,value:0,notify:!0,reflectToAttribute:!0},min:{type:Number,value:0,notify:!0},max:{type:Number,value:100,notify:!0},step:{type:Number,value:1,notify:!0},ratio:{type:Number,value:0,readOnly:!0,notify:!0}},observers:["_update(value, min, max, step)"],_calcRatio:function(e){return(this._clampValue(e)-this.min)/(this.max-this.min)},_clampValue:function(e){return Math.min(this.max,Math.max(this.min,this._calcStep(e)))},_calcStep:function(e){if(e=parseFloat(e),!this.step)return e;var t=Math.round((e-this.min)/this.step);return this.step<1?t/(1/this.step)+this.min:t*this.step+this.min},_validateValue:function(){var e=this._clampValue(this.value);return this.value=this.oldValue=isNaN(e)?this.oldValue:e,this.value!==e},_update:function(){this._validateValue(),this._setRatio(this._calcRatio(this.value)*100)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        width: 200px;
        position: relative;
        overflow: hidden;
      }

      :host([hidden]), [hidden] {
        display: none !important;
      }

      #progressContainer {
        @apply --paper-progress-container;
        position: relative;
      }

      #progressContainer,
      /* the stripe for the indeterminate animation*/
      .indeterminate::after {
        height: var(--paper-progress-height, 4px);
      }

      #primaryProgress,
      #secondaryProgress,
      .indeterminate::after {
        @apply --layout-fit;
      }

      #progressContainer,
      .indeterminate::after {
        background: var(--paper-progress-container-color, var(--google-grey-300));
      }

      :host(.transiting) #primaryProgress,
      :host(.transiting) #secondaryProgress {
        -webkit-transition-property: -webkit-transform;
        transition-property: transform;

        /* Duration */
        -webkit-transition-duration: var(--paper-progress-transition-duration, 0.08s);
        transition-duration: var(--paper-progress-transition-duration, 0.08s);

        /* Timing function */
        -webkit-transition-timing-function: var(--paper-progress-transition-timing-function, ease);
        transition-timing-function: var(--paper-progress-transition-timing-function, ease);

        /* Delay */
        -webkit-transition-delay: var(--paper-progress-transition-delay, 0s);
        transition-delay: var(--paper-progress-transition-delay, 0s);
      }

      #primaryProgress,
      #secondaryProgress {
        @apply --layout-fit;
        -webkit-transform-origin: left center;
        transform-origin: left center;
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
        will-change: transform;
      }

      #primaryProgress {
        background: var(--paper-progress-active-color, var(--google-green-500));
      }

      #secondaryProgress {
        background: var(--paper-progress-secondary-color, var(--google-green-100));
      }

      :host([disabled]) #primaryProgress {
        background: var(--paper-progress-disabled-active-color, var(--google-grey-500));
      }

      :host([disabled]) #secondaryProgress {
        background: var(--paper-progress-disabled-secondary-color, var(--google-grey-300));
      }

      :host(:not([disabled])) #primaryProgress.indeterminate {
        -webkit-transform-origin: right center;
        transform-origin: right center;
        -webkit-animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      :host(:not([disabled])) #primaryProgress.indeterminate::after {
        content: "";
        -webkit-transform-origin: center center;
        transform-origin: center center;

        -webkit-animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      @-webkit-keyframes indeterminate-bar {
        0% {
          -webkit-transform: scaleX(1) translateX(-100%);
        }
        50% {
          -webkit-transform: scaleX(1) translateX(0%);
        }
        75% {
          -webkit-transform: scaleX(1) translateX(0%);
          -webkit-animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          -webkit-transform: scaleX(0) translateX(0%);
        }
      }

      @-webkit-keyframes indeterminate-splitter {
        0% {
          -webkit-transform: scaleX(.75) translateX(-125%);
        }
        30% {
          -webkit-transform: scaleX(.75) translateX(-125%);
          -webkit-animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
        100% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
      }

      @keyframes indeterminate-bar {
        0% {
          transform: scaleX(1) translateX(-100%);
        }
        50% {
          transform: scaleX(1) translateX(0%);
        }
        75% {
          transform: scaleX(1) translateX(0%);
          animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          transform: scaleX(0) translateX(0%);
        }
      }

      @keyframes indeterminate-splitter {
        0% {
          transform: scaleX(.75) translateX(-125%);
        }
        30% {
          transform: scaleX(.75) translateX(-125%);
          animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          transform: scaleX(.75) translateX(125%);
        }
        100% {
          transform: scaleX(.75) translateX(125%);
        }
      }
    </style>

    <div id="progressContainer">
      <div id="secondaryProgress" hidden\$="[[_hideSecondaryProgress(secondaryRatio)]]"></div>
      <div id="primaryProgress"></div>
    </div>
`,is:"paper-progress",behaviors:[k9],properties:{secondaryProgress:{type:Number,value:0},secondaryRatio:{type:Number,value:0,readOnly:!0},indeterminate:{type:Boolean,value:!1,observer:"_toggleIndeterminate"},disabled:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_disabledChanged"}},observers:["_progressChanged(secondaryProgress, value, min, max, indeterminate)"],hostAttributes:{role:"progressbar"},_toggleIndeterminate:function(e){this.toggleClass("indeterminate",e,this.$.primaryProgress)},_transformProgress:function(e,t){var r="scaleX("+t/100+")";e.style.transform=e.style.webkitTransform=r},_mainRatioChanged:function(e){this._transformProgress(this.$.primaryProgress,e)},_progressChanged:function(e,t,r,n,i){e=this._clampValue(e),t=this._clampValue(t);var o=this._calcRatio(e)*100,a=this._calcRatio(t)*100;this._setSecondaryRatio(o),this._transformProgress(this.$.secondaryProgress,o),this._transformProgress(this.$.primaryProgress,a),this.secondaryProgress=e,i?this.removeAttribute("aria-valuenow"):this.setAttribute("aria-valuenow",t),this.setAttribute("aria-valuemin",r),this.setAttribute("aria-valuemax",n)},_disabledChanged:function(e){this.setAttribute("aria-disabled",e?"true":"false")},_hideSecondaryProgress:function(e){return e===0}});var k0t=Q`
<style>
  :host {
    display: inline-block;
    line-height: 0;
    white-space: nowrap;
    cursor: pointer;
    @apply --paper-font-common-base;
    --calculated-paper-radio-button-size: var(--paper-radio-button-size, 16px);
    /* -1px is a sentinel for the default and is replace in \`attached\`. */
    --calculated-paper-radio-button-ink-size: var(--paper-radio-button-ink-size, -1px);
  }

  :host(:focus) {
    outline: none;
  }

  #radioContainer {
    @apply --layout-inline;
    @apply --layout-center-center;
    position: relative;
    width: var(--calculated-paper-radio-button-size);
    height: var(--calculated-paper-radio-button-size);
    vertical-align: middle;

    @apply --paper-radio-button-radio-container;
  }

  #ink {
    position: absolute;
    top: 50%;
    left: 50%;
    right: auto;
    width: var(--calculated-paper-radio-button-ink-size);
    height: var(--calculated-paper-radio-button-ink-size);
    color: var(--paper-radio-button-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
    -webkit-transform: translate(-50%, -50%);
    transform: translate(-50%, -50%);
  }

  #ink[checked] {
    color: var(--paper-radio-button-checked-ink-color, var(--primary-color));
  }

  #offRadio, #onRadio {
    position: absolute;
    box-sizing: border-box;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    border-radius: 50%;
  }

  #offRadio {
    border: 2px solid var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    background-color: var(--paper-radio-button-unchecked-background-color, transparent);
    transition: border-color 0.28s;
  }

  #onRadio {
    background-color: var(--paper-radio-button-checked-color, var(--primary-color));
    -webkit-transform: scale(0);
    transform: scale(0);
    transition: -webkit-transform ease 0.28s;
    transition: transform ease 0.28s;
    will-change: transform;
  }

  :host([checked]) #offRadio {
    border-color: var(--paper-radio-button-checked-color, var(--primary-color));
  }

  :host([checked]) #onRadio {
    -webkit-transform: scale(0.5);
    transform: scale(0.5);
  }

  #radioLabel {
    line-height: normal;
    position: relative;
    display: inline-block;
    vertical-align: middle;
    margin-left: var(--paper-radio-button-label-spacing, 10px);
    white-space: normal;
    color: var(--paper-radio-button-label-color, var(--primary-text-color));

    @apply --paper-radio-button-label;
  }

  :host([checked]) #radioLabel {
    @apply --paper-radio-button-label-checked;
  }

  #radioLabel:dir(rtl) {
    margin-left: 0;
    margin-right: var(--paper-radio-button-label-spacing, 10px);
  }

  #radioLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #offRadio {
    border-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled][checked]) #onRadio {
    background-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #radioLabel {
    /* slightly darker than the button, so that it's readable */
    opacity: 0.65;
  }
</style>

<div id="radioContainer">
  <div id="offRadio"></div>
  <div id="onRadio"></div>
</div>

<div id="radioLabel"><slot></slot></div>`;k0t.setAttribute("strip-whitespace","");Yt({_template:k0t,is:"paper-radio-button",behaviors:[Xx],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Cm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim();if(e==="-1px"){var t=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),r=Math.floor(3*t);r%2!==t%2&&r++,this.updateStyles({"--paper-radio-button-ink-size":r+"px"})}})}});var R9={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},get _isRTL(){return window.getComputedStyle(this).direction==="rtl"},_onLeftKey:function(e){this._isRTL?this._focusNext():this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onRightKey:function(e){this._isRTL?this._focusPrevious():this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down left right esc")||this._focusWithKeyboardEvent(e)}},N9=[L9,R9];Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }

      :host ::slotted(*) {
        padding: var(--paper-radio-group-item-padding, 12px);
      }
    </style>

    <slot></slot>
`,is:"paper-radio-group",behaviors:[N9],hostAttributes:{role:"radiogroup"},properties:{attrForSelected:{type:String,value:"name"},selectedAttribute:{type:String,value:"checked"},selectable:{type:String,value:"paper-radio-button"},allowEmptySelection:{type:Boolean,value:!1}},select:function(e){var t=this._valueToItem(e);if(!(t&&t.hasAttribute("disabled"))){if(this.selected){var r=this._valueToItem(this.selected);if(this.selected==e)if(this.allowEmptySelection)e="";else{r&&(r.checked=!0);return}r&&(r.checked=!1)}Sh.select.apply(this,[e]),this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(e){this._focusPrevious(),e.preventDefault(),this._activateFocusedItem()},_onDownKey:function(e){this._focusNext(),e.preventDefault(),this._activateFocusedItem()},_onLeftKey:function(e){R9._onLeftKey.apply(this,arguments),this._activateFocusedItem()},_onRightKey:function(e){R9._onRightKey.apply(this,arguments),this._activateFocusedItem()}});var R0t=Q`
  <style>
    :host {
      @apply --layout;
      @apply --layout-justified;
      @apply --layout-center;
      width: 200px;
      cursor: default;
      -webkit-user-select: none;
      -moz-user-select: none;
      -ms-user-select: none;
      user-select: none;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      --paper-progress-active-color: var(--paper-slider-active-color, var(--google-blue-700));
      --paper-progress-secondary-color: var(--paper-slider-secondary-color, var(--google-blue-300));
      --paper-progress-disabled-active-color: var(--paper-slider-disabled-active-color, var(--paper-grey-400));
      --paper-progress-disabled-secondary-color: var(--paper-slider-disabled-secondary-color, var(--paper-grey-400));
      --calculated-paper-slider-height: var(--paper-slider-height, 2px);
    }

    /* focus shows the ripple */
    :host(:focus) {
      outline: none;
    }

    /**
      * NOTE(keanulee): Though :host-context is not universally supported, some pages
      * still rely on paper-slider being flipped when dir="rtl" is set on body. For full
      * compatibility, dir="rtl" must be explicitly set on paper-slider.
      */
    :dir(rtl) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): This is separate from the rule above because :host-context may
      * not be recognized.
      */
    :host([dir="rtl"]) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): Needed to override the :host-context rule (where supported)
      * to support LTR sliders in RTL pages.
      */
    :host([dir="ltr"]) #sliderContainer {
      -webkit-transform: scaleX(1);
      transform: scaleX(1);
    }

    #sliderContainer {
      position: relative;
      width: 100%;
      height: calc(30px + var(--calculated-paper-slider-height));
      margin-left: calc(15px + var(--calculated-paper-slider-height)/2);
      margin-right: calc(15px + var(--calculated-paper-slider-height)/2);
    }

    #sliderContainer:focus {
      outline: 0;
    }

    #sliderContainer.editable {
      margin-top: 12px;
      margin-bottom: 12px;
    }

    .bar-container {
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      overflow: hidden;
    }

    .ring > .bar-container {
      left: calc(5px + var(--calculated-paper-slider-height)/2);
      transition: left 0.18s ease;
    }

    .ring.expand.dragging > .bar-container {
      transition: none;
    }

    .ring.expand:not(.pin) > .bar-container {
      left: calc(8px + var(--calculated-paper-slider-height)/2);
    }

    #sliderBar {
      padding: 15px 0;
      width: 100%;
      background-color: var(--paper-slider-bar-color, transparent);
      --paper-progress-container-color: var(--paper-slider-container-color, var(--paper-grey-400));
      --paper-progress-height: var(--calculated-paper-slider-height);
    }

    .slider-markers {
      position: absolute;
      /* slider-knob is 30px + the slider-height so that the markers should start at a offset of 15px*/
      top: 15px;
      height: var(--calculated-paper-slider-height);
      left: 0;
      right: -1px;
      box-sizing: border-box;
      pointer-events: none;
      @apply --layout-horizontal;
    }

    .slider-marker {
      @apply --layout-flex;
    }
    .slider-markers::after,
    .slider-marker::after {
      content: "";
      display: block;
      margin-left: -1px;
      width: 2px;
      height: var(--calculated-paper-slider-height);
      border-radius: 50%;
      background-color: var(--paper-slider-markers-color, #000);
    }

    .slider-knob {
      position: absolute;
      left: 0;
      top: 0;
      margin-left: calc(-15px - var(--calculated-paper-slider-height)/2);
      width: calc(30px + var(--calculated-paper-slider-height));
      height: calc(30px + var(--calculated-paper-slider-height));
    }

    .transiting > .slider-knob {
      transition: left 0.08s ease;
    }

    .slider-knob:focus {
      outline: none;
    }

    .slider-knob.dragging {
      transition: none;
    }

    .snaps > .slider-knob.dragging {
      transition: -webkit-transform 0.08s ease;
      transition: transform 0.08s ease;
    }

    .slider-knob-inner {
      margin: 10px;
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: var(--paper-slider-knob-color, var(--google-blue-700));
      border: 2px solid var(--paper-slider-knob-color, var(--google-blue-700));
      border-radius: 50%;

      -moz-box-sizing: border-box;
      box-sizing: border-box;

      transition-property: -webkit-transform, background-color, border;
      transition-property: transform, background-color, border;
      transition-duration: 0.18s;
      transition-timing-function: ease;
    }

    .expand:not(.pin) > .slider-knob > .slider-knob-inner {
      -webkit-transform: scale(1.5);
      transform: scale(1.5);
    }

    .ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-color, var(--google-blue-700));
    }

    .pin > .slider-knob > .slider-knob-inner::before {
      content: "";
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -13px;
      width: 26px;
      height: 26px;
      border-radius: 50% 50% 50% 0;

      -webkit-transform: rotate(-45deg) scale(0) translate(0);
      transform: rotate(-45deg) scale(0) translate(0);
    }

    .slider-knob-inner::before,
    .slider-knob-inner::after {
      transition: -webkit-transform .18s ease, background-color .18s ease;
      transition: transform .18s ease, background-color .18s ease;
    }

    .pin.ring > .slider-knob > .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-start-color, var(--paper-grey-400));
    }

    .pin.expand > .slider-knob > .slider-knob-inner::before {
      -webkit-transform: rotate(-45deg) scale(1) translate(17px, -17px);
      transform: rotate(-45deg) scale(1) translate(17px, -17px);
    }

    .pin > .slider-knob > .slider-knob-inner::after {
      content: attr(value);
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -16px;
      width: 32px;
      height: 26px;
      text-align: center;
      color: var(--paper-slider-font-color, #fff);
      font-size: 10px;

      -webkit-transform: scale(0) translate(0);
      transform: scale(0) translate(0);
    }

    .pin.expand > .slider-knob > .slider-knob-inner::after {
      -webkit-transform: scale(1) translate(0, -17px);
      transform: scale(1) translate(0, -17px);
    }

    /* paper-input */
    .slider-input {
      width: 50px;
      overflow: hidden;
      --paper-input-container-input: {
        text-align: center;
        @apply --paper-slider-input-container-input;
      };
      @apply --paper-slider-input;
    }

    /* disabled state */
    #sliderContainer.disabled {
      pointer-events: none;
    }

    .disabled > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      border: 2px solid var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      -webkit-transform: scale3d(0.75, 0.75, 1);
      transform: scale3d(0.75, 0.75, 1);
    }

    .disabled.ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    paper-ripple {
      color: var(--paper-slider-knob-color, var(--google-blue-700));
    }
  </style>

  <div id="sliderContainer" class\$="[[_getClassNames(disabled, pin, snaps, immediateValue, min, expand, dragging, transiting, editable)]]">
    <div class="bar-container">
      <paper-progress disabled\$="[[disabled]]" id="sliderBar" aria-hidden="true" min="[[min]]" max="[[max]]" step="[[step]]" value="[[immediateValue]]" secondary-progress="[[secondaryProgress]]" on-down="_bardown" on-up="_resetKnob" on-track="_bartrack" on-tap="_barclick">
      </paper-progress>
    </div>

    <template is="dom-if" if="[[snaps]]">
      <div class="slider-markers">
        <template is="dom-repeat" items="[[markers]]">
          <div class="slider-marker"></div>
        </template>
      </div>
    </template>

    <div id="sliderKnob" class="slider-knob" on-down="_knobdown" on-up="_resetKnob" on-track="_onTrack" on-transitionend="_knobTransitionEnd">
        <div class="slider-knob-inner" value\$="[[immediateValue]]"></div>
    </div>
  </div>

  <template is="dom-if" if="[[editable]]">
    <paper-input id="input" type="number" step="[[step]]" min="[[min]]" max="[[max]]" class="slider-input" disabled\$="[[disabled]]" value="[[immediateValue]]" on-change="_changeValue" on-keydown="_inputKeyDown" no-label-float>
    </paper-input>
  </template>
`;R0t.setAttribute("strip-whitespace","");Yt({_template:R0t,is:"paper-slider",behaviors:[Oo,Th,jx,k9],properties:{value:{type:Number,value:0},snaps:{type:Boolean,value:!1,notify:!0},pin:{type:Boolean,value:!1,notify:!0},secondaryProgress:{type:Number,value:0,notify:!0,observer:"_secondaryProgressChanged"},editable:{type:Boolean,value:!1},immediateValue:{type:Number,value:0,readOnly:!0,notify:!0},maxMarkers:{type:Number,value:0,notify:!0},expand:{type:Boolean,value:!1,readOnly:!0},ignoreBarTouch:{type:Boolean,value:!1},dragging:{type:Boolean,value:!1,readOnly:!0,notify:!0},transiting:{type:Boolean,value:!1,readOnly:!0},markers:{type:Array,readOnly:!0,value:function(){return[]}}},observers:["_updateKnob(value, min, max, snaps, step)","_valueChanged(value)","_immediateValueChanged(immediateValue)","_updateMarkers(maxMarkers, min, max, snaps)"],hostAttributes:{role:"slider",tabindex:0},keyBindings:{left:"_leftKey",right:"_rightKey","down pagedown home":"_decrementKey","up pageup end":"_incrementKey"},ready:function(){this.ignoreBarTouch&&m_(this.$.sliderBar,"auto")},increment:function(){this.value=this._clampValue(this.value+this.step)},decrement:function(){this.value=this._clampValue(this.value-this.step)},_updateKnob:function(e,t,r,n,i){this.setAttribute("aria-valuemin",t),this.setAttribute("aria-valuemax",r),this.setAttribute("aria-valuenow",e),this._positionKnob(this._calcRatio(e)*100)},_valueChanged:function(){this.fire("value-change",{composed:!0})},_immediateValueChanged:function(){this.dragging?this.fire("immediate-value-change",{composed:!0}):this.value=this.immediateValue},_secondaryProgressChanged:function(){this.secondaryProgress=this._clampValue(this.secondaryProgress)},_expandKnob:function(){this._setExpand(!0)},_resetKnob:function(){this.cancelDebouncer("expandKnob"),this._setExpand(!1)},_positionKnob:function(e){this._setImmediateValue(this._calcStep(this._calcKnobPosition(e))),this._setRatio(this._calcRatio(this.immediateValue)*100),this.$.sliderKnob.style.left=this.ratio+"%",this.dragging&&(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(e){return(this.max-this.min)*e/100+this.min},_onTrack:function(e){switch(e.stopPropagation(),e.detail.state){case"start":this._trackStart(e);break;case"track":this._trackX(e);break;case"end":this._trackEnd();break}},_trackStart:function(e){this._setTransiting(!1),this._w=this.$.sliderBar.offsetWidth,this._x=this.ratio*this._w/100,this._startx=this._x,this._knobstartx=this._startx,this._minx=-this._startx,this._maxx=this._w-this._startx,this.$.sliderKnob.classList.add("dragging"),this._setDragging(!0)},_trackX:function(e){this.dragging||this._trackStart(e);var t=this._isRTL?-1:1,r=Math.min(this._maxx,Math.max(this._minx,e.detail.dx*t));this._x=this._startx+r;var n=this._calcStep(this._calcKnobPosition(this._x/this._w*100));this._setImmediateValue(n);var i=this._calcRatio(this.immediateValue)*this._w-this._knobstartx;this.translate3d(i+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var e=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging"),this._setDragging(!1),this._resetKnob(),this.value=this.immediateValue,e.transform=e.webkitTransform="",this.fire("change",{composed:!0})},_knobdown:function(e){this._expandKnob(),e.preventDefault(),this.focus()},_bartrack:function(e){this._allowBarEvent(e)&&this._onTrack(e)},_barclick:function(e){this._w=this.$.sliderBar.offsetWidth;var t=this.$.sliderBar.getBoundingClientRect(),r=(e.detail.x-t.left)/this._w*100;this._isRTL&&(r=100-r);var n=this.ratio;this._setTransiting(!0),this._positionKnob(r),n===this.ratio&&this._setTransiting(!1),this.async(function(){this.fire("change",{composed:!0})}),e.preventDefault(),this.focus()},_bardown:function(e){this._allowBarEvent(e)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(e))},_knobTransitionEnd:function(e){e.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(e,t,r,n){n||this._setMarkers([]);var i=Math.round((r-t)/this.step);i>e&&(i=e),(i<0||!isFinite(i))&&(i=0),this._setMarkers(new Array(i))},_mergeClasses:function(e){return Object.keys(e).filter(function(t){return e[t]}).join(" ")},_getClassNames:function(){return this._mergeClasses({disabled:this.disabled,pin:this.pin,snaps:this.snaps,ring:this.immediateValue<=this.min,expand:this.expand,dragging:this.dragging,transiting:this.transiting,editable:this.editable})},_allowBarEvent:function(e){return!this.ignoreBarTouch||e.detail.sourceEvent instanceof MouseEvent},get _isRTL(){return this.__isRTL===void 0&&(this.__isRTL=window.getComputedStyle(this).direction==="rtl"),this.__isRTL},_leftKey:function(e){this._isRTL?this._incrementKey(e):this._decrementKey(e)},_rightKey:function(e){this._isRTL?this._decrementKey(e):this._incrementKey(e)},_incrementKey:function(e){this.disabled||(e.detail.key==="end"?this.value=this.max:this.increment(),this.fire("change"),e.preventDefault())},_decrementKey:function(e){this.disabled||(e.detail.key==="home"?this.value=this.min:this.decrement(),this.fire("change"),e.preventDefault())},_changeValue:function(e){this.value=e.target.value,this.fire("change",{composed:!0})},_inputKeyDown:function(e){e.stopPropagation()},_createRipple:function(){return this._rippleContainer=this.$.sliderKnob,pE._createRipple.call(this)},_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(e?this._ripple.style.display="":this._ripple.style.display="none",this._ripple.holdDown=e)}});var MW=document.createElement("template");MW.setAttribute("style","display: none;");MW.innerHTML=`<dom-module id="paper-spinner-styles">
  <template>
    <style>
      /*
      /**************************/
      /* STYLES FOR THE SPINNER */
      /**************************/

      /*
       * Constants:
       *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)
       *      ARCTIME     = 1333ms (time it takes to expand and contract arc)
       *      ARCSTARTROT = 216 degrees (how much the start location of the arc
       *                                should rotate each time, 216 gives us a
       *                                5 pointed star shape (it's 360/5 * 3).
       *                                For a 7 pointed star, we might do
       *                                360/7 * 3 = 154.286)
       *      SHRINK_TIME = 400ms
       */

      :host {
        display: inline-block;
        position: relative;
        width: 28px;
        height: 28px;

        /* 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */
        --paper-spinner-container-rotation-duration: 1568ms;

        /* ARCTIME */
        --paper-spinner-expand-contract-duration: 1333ms;

        /* 4 * ARCTIME */
        --paper-spinner-full-cycle-duration: 5332ms;

        /* SHRINK_TIME */
        --paper-spinner-cooldown-duration: 400ms;
      }

      #spinnerContainer {
        width: 100%;
        height: 100%;

        /* The spinner does not have any contents that would have to be
         * flipped if the direction changes. Always use ltr so that the
         * style works out correctly in both cases. */
        direction: ltr;
      }

      #spinnerContainer.active {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
      }

      @-webkit-keyframes container-rotate {
        to { -webkit-transform: rotate(360deg) }
      }

      @keyframes container-rotate {
        to { transform: rotate(360deg) }
      }

      .spinner-layer {
        position: absolute;
        width: 100%;
        height: 100%;
        opacity: 0;
        white-space: nowrap;
        color: var(--paper-spinner-color, var(--google-blue-500));
      }

      .layer-1 {
        color: var(--paper-spinner-layer-1-color, var(--google-blue-500));
      }

      .layer-2 {
        color: var(--paper-spinner-layer-2-color, var(--google-red-500));
      }

      .layer-3 {
        color: var(--paper-spinner-layer-3-color, var(--google-yellow-500));
      }

      .layer-4 {
        color: var(--paper-spinner-layer-4-color, var(--google-green-500));
      }

      /**
       * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):
       *
       * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't
       * guarantee that the animation will start _exactly_ after that value. So we avoid using
       * animation-delay and instead set custom keyframes for each color (as layer-2undant as it
       * seems).
       */
      .active .spinner-layer {
        -webkit-animation-name: fill-unfill-rotate;
        -webkit-animation-duration: var(--paper-spinner-full-cycle-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-name: fill-unfill-rotate;
        animation-duration: var(--paper-spinner-full-cycle-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
        opacity: 1;
      }

      .active .spinner-layer.layer-1 {
        -webkit-animation-name: fill-unfill-rotate, layer-1-fade-in-out;
        animation-name: fill-unfill-rotate, layer-1-fade-in-out;
      }

      .active .spinner-layer.layer-2 {
        -webkit-animation-name: fill-unfill-rotate, layer-2-fade-in-out;
        animation-name: fill-unfill-rotate, layer-2-fade-in-out;
      }

      .active .spinner-layer.layer-3 {
        -webkit-animation-name: fill-unfill-rotate, layer-3-fade-in-out;
        animation-name: fill-unfill-rotate, layer-3-fade-in-out;
      }

      .active .spinner-layer.layer-4 {
        -webkit-animation-name: fill-unfill-rotate, layer-4-fade-in-out;
        animation-name: fill-unfill-rotate, layer-4-fade-in-out;
      }

      @-webkit-keyframes fill-unfill-rotate {
        12.5% { -webkit-transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { -webkit-transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { -webkit-transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { -webkit-transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { -webkit-transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { -webkit-transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { -webkit-transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { -webkit-transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @keyframes fill-unfill-rotate {
        12.5% { transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @-webkit-keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @-webkit-keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      .circle-clipper {
        display: inline-block;
        position: relative;
        width: 50%;
        height: 100%;
        overflow: hidden;
      }

      /**
       * Patch the gap that appear between the two adjacent div.circle-clipper while the
       * spinner is rotating (appears on Chrome 50, Safari 9.1.1, and Edge).
       */
      .spinner-layer::after {
        content: '';
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

      .spinner-layer::after,
      .circle-clipper .circle {
        box-sizing: border-box;
        position: absolute;
        top: 0;
        border-width: var(--paper-spinner-stroke-width, 3px);
        border-radius: 50%;
      }

      .circle-clipper .circle {
        bottom: 0;
        width: 200%;
        border-style: solid;
        border-bottom-color: transparent !important;
      }

      .circle-clipper.left .circle {
        left: 0;
        border-right-color: transparent !important;
        -webkit-transform: rotate(129deg);
        transform: rotate(129deg);
      }

      .circle-clipper.right .circle {
        left: -100%;
        border-left-color: transparent !important;
        -webkit-transform: rotate(-129deg);
        transform: rotate(-129deg);
      }

      .active .gap-patch::after,
      .active .circle-clipper .circle {
        -webkit-animation-duration: var(--paper-spinner-expand-contract-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-duration: var(--paper-spinner-expand-contract-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
      }

      .active .circle-clipper.left .circle {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right .circle {
        -webkit-animation-name: right-spin;
        animation-name: right-spin;
      }

      @-webkit-keyframes left-spin {
        0% { -webkit-transform: rotate(130deg) }
        50% { -webkit-transform: rotate(-5deg) }
        to { -webkit-transform: rotate(130deg) }
      }

      @keyframes left-spin {
        0% { transform: rotate(130deg) }
        50% { transform: rotate(-5deg) }
        to { transform: rotate(130deg) }
      }

      @-webkit-keyframes right-spin {
        0% { -webkit-transform: rotate(-130deg) }
        50% { -webkit-transform: rotate(5deg) }
        to { -webkit-transform: rotate(-130deg) }
      }

      @keyframes right-spin {
        0% { transform: rotate(-130deg) }
        50% { transform: rotate(5deg) }
        to { transform: rotate(-130deg) }
      }

      #spinnerContainer.cooldown {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
      }

      @-webkit-keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(MW.content);var D9={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(e,t){return[e||t?"active":"",t?"cooldown":""].join(" ")},__activeChanged:function(e,t){this.__setAriaHidden(!e),this.__coolingDown=!e&&t},__altChanged:function(e){e==="loading"?this.alt=this.getAttribute("aria-label")||e:(this.__setAriaHidden(e===""),this.setAttribute("aria-label",e))},__setAriaHidden:function(e){var t="aria-hidden";e?this.setAttribute(t,"true"):this.removeAttribute(t)},__reset:function(){this.active=!1,this.__coolingDown=!1}};var N0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer layer-1">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-2">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-3">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-4">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;N0t.setAttribute("strip-whitespace","");Yt({_template:N0t,is:"paper-spinner",behaviors:[D9]});var D0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;D0t.setAttribute("strip-whitespace","");Yt({_template:D0t,is:"paper-spinner-lite",behaviors:[D9]});var jbe=Q`<iron-iconset-svg name="paper-tabs" size="24">
<svg><defs>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(jbe.content);Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center;
        @apply --layout-center-justified;
        @apply --layout-flex-auto;

        position: relative;
        padding: 0 12px;
        overflow: hidden;
        cursor: pointer;
        vertical-align: middle;

        @apply --paper-font-common-base;
        @apply --paper-tab;
      }

      :host(:focus) {
        outline: none;
      }

      :host([link]) {
        padding: 0;
      }

      .tab-content {
        height: 100%;
        transform: translateZ(0);
          -webkit-transform: translateZ(0);
        transition: opacity 0.1s cubic-bezier(0.4, 0.0, 1, 1);
        @apply --layout-horizontal;
        @apply --layout-center-center;
        @apply --layout-flex-auto;
        @apply --paper-tab-content;
      }

      :host(:not(.iron-selected)) > .tab-content {
        opacity: 0.8;

        @apply --paper-tab-content-unselected;
      }

      :host(:focus) .tab-content {
        opacity: 1;
        font-weight: 700;

        @apply --paper-tab-content-focused;
      }

      paper-ripple {
        color: var(--paper-tab-ink, var(--paper-yellow-a100));
      }

      .tab-content > ::slotted(a) {
        @apply --layout-flex-auto;

        height: 100%;
      }
    </style>

    <div class="tab-content">
      <slot></slot>
    </div>
`,is:"paper-tab",behaviors:[Di,Mh,su],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var e=zt(this).parentNode;return!!e&&!!e.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(e){if(this.link){var t=this.queryEffectiveChildren("a");if(!t||e.target===t)return;t.click()}}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout;
        @apply --layout-center;

        height: 48px;
        font-size: 14px;
        font-weight: 500;
        overflow: hidden;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;

        /* NOTE: Both values are needed, since some phones require the value to be \`transparent\`. */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        @apply --paper-tabs;
      }

      :host(:dir(rtl)) {
        @apply --layout-horizontal-reverse;
      }

      #tabsContainer {
        position: relative;
        height: 100%;
        white-space: nowrap;
        overflow: hidden;
        @apply --layout-flex-auto;
        @apply --paper-tabs-container;
      }

      #tabsContent {
        height: 100%;
        -moz-flex-basis: auto;
        -ms-flex-basis: auto;
        flex-basis: auto;
        @apply --paper-tabs-content;
      }

      #tabsContent.scrollable {
        position: absolute;
        white-space: nowrap;
      }

      #tabsContent:not(.scrollable),
      #tabsContent.scrollable.fit-container {
        @apply --layout-horizontal;
      }

      #tabsContent.scrollable.fit-container {
        min-width: 100%;
      }

      #tabsContent.scrollable.fit-container > ::slotted(*) {
        /* IE - prevent tabs from compressing when they should scroll. */
        -ms-flex: 1 0 auto;
        -webkit-flex: 1 0 auto;
        flex: 1 0 auto;
      }

      .hidden {
        display: none;
      }

      .not-visible {
        opacity: 0;
        cursor: default;
      }

      paper-icon-button {
        width: 48px;
        height: 48px;
        padding: 12px;
        margin: 0 4px;
      }

      #selectionBar {
        position: absolute;
        height: 0;
        bottom: 0;
        left: 0;
        right: 0;
        border-bottom: 2px solid var(--paper-tabs-selection-bar-color, var(--paper-yellow-a100));
          -webkit-transform: scale(0);
        transform: scale(0);
          -webkit-transform-origin: left center;
        transform-origin: left center;
          transition: -webkit-transform;
        transition: transform;

        @apply --paper-tabs-selection-bar;
      }

      #selectionBar.align-bottom {
        top: 0;
        bottom: auto;
      }

      #selectionBar.expand {
        transition-duration: 0.15s;
        transition-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
      }

      #selectionBar.contract {
        transition-duration: 0.18s;
        transition-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
      }

      #tabsContent > ::slotted(:not(#selectionBar)) {
        height: 100%;
      }
    </style>

    <paper-icon-button icon="paper-tabs:chevron-left" class$="[[_computeScrollButtonClass(_leftHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onLeftScrollButtonDown" tabindex="-1"></paper-icon-button>

    <div id="tabsContainer" on-track="_scroll" on-down="_down">
      <div id="tabsContent" class$="[[_computeTabsContentClass(scrollable, fitContainer)]]">
        <div id="selectionBar" class$="[[_computeSelectionBarClass(noBar, alignBottom)]]" on-transitionend="_onBarTransitionEnd"></div>
        <slot></slot>
      </div>
    </div>

    <paper-icon-button icon="paper-tabs:chevron-right" class$="[[_computeScrollButtonClass(_rightHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onRightScrollButtonDown" tabindex="-1"></paper-icon-button>
`,is:"paper-tabs",behaviors:[Qs,N9],properties:{noink:{type:Boolean,value:!1,observer:"_noinkChanged"},noBar:{type:Boolean,value:!1},noSlide:{type:Boolean,value:!1},scrollable:{type:Boolean,value:!1},fitContainer:{type:Boolean,value:!1},disableDrag:{type:Boolean,value:!1},hideScrollButtons:{type:Boolean,value:!1},alignBottom:{type:Boolean,value:!1},selectable:{type:String,value:"paper-tab"},autoselect:{type:Boolean,value:!1},autoselectDelay:{type:Number,value:0},_step:{type:Number,value:10},_holdDelay:{type:Number,value:1},_leftHidden:{type:Boolean,value:!1},_rightHidden:{type:Boolean,value:!1},_previousTab:{type:Object}},hostAttributes:{role:"tablist"},listeners:{"iron-resize":"_onTabSizingChanged","iron-items-changed":"_onTabSizingChanged","iron-select":"_onIronSelect","iron-deselect":"_onIronDeselect"},keyBindings:{"left:keyup right:keyup":"_onArrowKeyup"},created:function(){this._holdJob=null,this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,this._bindDelayedActivationHandler=this._delayedActivationHandler.bind(this),this.addEventListener("blur",this._onBlurCapture.bind(this),!0)},ready:function(){this.setScrollDirection("y",this.$.tabsContainer)},detached:function(){this._cancelPendingActivation()},_noinkChanged:function(e){var t=zt(this).querySelectorAll("paper-tab");t.forEach(e?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(e){e.setAttribute("noink","")},_removeNoinkAttribute:function(e){e.removeAttribute("noink")},_computeScrollButtonClass:function(e,t,r){return!t||r?"hidden":e?"not-visible":""},_computeTabsContentClass:function(e,t){return e?"scrollable"+(t?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(e,t){return e?"hidden":t?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll(),this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(e){this._tabChanged(e.detail.item,this._previousTab),this._previousTab=e.detail.item,this.cancelDebouncer("tab-changed")},_onIronDeselect:function(e){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab),this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation(),y_._activateHandler.apply(this,arguments)},_scheduleActivation:function(e,t){this._pendingActivationItem=e,this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,t)},_delayedActivationHandler:function(){var e=this._pendingActivationItem;this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,e.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){this._pendingActivationTimeout!==void 0&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0)},_onArrowKeyup:function(e){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(e){e.target===this._pendingActivationItem&&this._cancelPendingActivation()},get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(e,t){if(!!this.scrollable){var r=t&&-t.ddx||0;this._affectScroll(r)}},_down:function(e){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(e){this.$.tabsContainer.scrollLeft+=e;var t=this.$.tabsContainer.scrollLeft;this._leftHidden=t===0,this._rightHidden=t===this._tabContainerScrollSize},_onLeftScrollButtonDown:function(){this._scrollToLeft(),this._holdJob=setInterval(this._scrollToLeft.bind(this),this._holdDelay)},_onRightScrollButtonDown:function(){this._scrollToRight(),this._holdJob=setInterval(this._scrollToRight.bind(this),this._holdDelay)},_onScrollButtonUp:function(){clearInterval(this._holdJob),this._holdJob=null},_scrollToLeft:function(){this._affectScroll(-this._step)},_scrollToRight:function(){this._affectScroll(this._step)},_tabChanged:function(e,t){if(!e){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0);return}var r=this.$.tabsContent.getBoundingClientRect(),n=r.width,i=e.getBoundingClientRect(),o=i.left-r.left;if(this._pos={width:this._calcPercent(i.width,n),left:this._calcPercent(o,n)},this.noSlide||t==null){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);return}var a=t.getBoundingClientRect(),s=this.items.indexOf(t),l=this.items.indexOf(e),c=5;this.$.selectionBar.classList.add("expand");var u=s<l,h=this._isRTL;h&&(u=!u),u?this._positionBar(this._calcPercent(i.left+i.width-a.left,n)-c,this._left):this._positionBar(this._calcPercent(a.left+a.width-i.left,n)-c,this._calcPercent(o,n)+c),this.scrollable&&this._scrollToSelectedIfNeeded(i.width,o)},_scrollToSelectedIfNeeded:function(e,t){var r=t-this.$.tabsContainer.scrollLeft;r<0?this.$.tabsContainer.scrollLeft+=r:(r+=e-this.$.tabsContainer.offsetWidth,r>0&&(this.$.tabsContainer.scrollLeft+=r))},_calcPercent:function(e,t){return 100*e/t},_positionBar:function(e,t){e=e||0,t=t||0,this._width=e,this._left=t,this.transform("translateX("+t+"%) scaleX("+e/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(e){var t=this.$.selectionBar.classList;t.contains("expand")?(t.remove("expand"),t.add("contract"),this._positionBar(this._pos.width,this._pos.left)):t.contains("contract")&&t.remove("contract")}});var Jx=null;Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: fixed;
        background-color: var(--paper-toast-background-color, #323232);
        color: var(--paper-toast-color, #f1f1f1);
        min-height: 48px;
        min-width: 288px;
        padding: 16px 24px;
        box-sizing: border-box;
        box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.26);
        border-radius: 2px;
        margin: 12px;
        font-size: 14px;
        cursor: default;
        -webkit-transition: -webkit-transform 0.3s, opacity 0.3s;
        transition: transform 0.3s, opacity 0.3s;
        opacity: 0;
        -webkit-transform: translateY(100px);
        transform: translateY(100px);
        @apply --paper-font-common-base;
      }

      :host(.capsule) {
        border-radius: 24px;
      }

      :host(.fit-bottom) {
        width: 100%;
        min-width: 0;
        border-radius: 0;
        margin: 0;
      }

      :host(.paper-toast-open) {
        opacity: 1;
        -webkit-transform: translateY(0px);
        transform: translateY(0px);
      }
    </style>

    <span id="label">{{text}}</span>
    <slot></slot>
`,is:"paper-toast",behaviors:[Kx],properties:{fitInto:{type:Object,value:window,observer:"_onFitIntoChanged"},horizontalAlign:{type:String,value:"left"},verticalAlign:{type:String,value:"bottom"},duration:{type:Number,value:3e3},text:{type:String,value:""},noCancelOnOutsideClick:{type:Boolean,value:!0},noAutoFocus:{type:Boolean,value:!0}},listeners:{transitionend:"__onTransitionEnd"},get visible(){return Oa._warn("`visible` is deprecated, use `opened` instead"),this.opened},get _canAutoClose(){return this.duration>0&&this.duration!==1/0},created:function(){this._autoClose=null,ec.requestAvailability()},show:function(e){typeof e=="string"&&(e={text:e});for(var t in e)t.indexOf("_")===0?Oa._warn('The property "'+t+'" is private and was not set.'):t in this?this[t]=e[t]:Oa._warn('The property "'+t+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(e){e&&e.target===this&&e.propertyName==="opacity"&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){this._autoClose!==null&&(this.cancelAsync(this._autoClose),this._autoClose=null),this.opened?(Jx&&Jx!==this&&Jx.close(),Jx=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):Jx===this&&(Jx=null),Im._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(e){this.positionTarget=e}});var O0t=Q`

    <style>
      :host {
        display: inline-block;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-common-base;
      }

      :host([disabled]) {
        pointer-events: none;
      }

      :host(:focus) {
        outline:none;
      }

      .toggle-bar {
        position: absolute;
        height: 100%;
        width: 100%;
        border-radius: 8px;
        pointer-events: none;
        opacity: 0.4;
        transition: background-color linear .08s;
        background-color: var(--paper-toggle-button-unchecked-bar-color, #000000);

        @apply --paper-toggle-button-unchecked-bar;
      }

      .toggle-button {
        position: absolute;
        top: -3px;
        left: 0;
        height: 20px;
        width: 20px;
        border-radius: 50%;
        box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.6);
        transition: -webkit-transform linear .08s, background-color linear .08s;
        transition: transform linear .08s, background-color linear .08s;
        will-change: transform;
        background-color: var(--paper-toggle-button-unchecked-button-color, var(--paper-grey-50));

        @apply --paper-toggle-button-unchecked-button;
      }

      .toggle-button.dragging {
        -webkit-transition: none;
        transition: none;
      }

      :host([checked]:not([disabled])) .toggle-bar {
        opacity: 0.5;
        background-color: var(--paper-toggle-button-checked-bar-color, var(--primary-color));

        @apply --paper-toggle-button-checked-bar;
      }

      :host([disabled]) .toggle-bar {
        background-color: #000;
        opacity: 0.12;
      }

      :host([checked]) .toggle-button {
        -webkit-transform: translate(16px, 0);
        transform: translate(16px, 0);
      }

      :host([checked]:not([disabled])) .toggle-button {
        background-color: var(--paper-toggle-button-checked-button-color, var(--primary-color));

        @apply --paper-toggle-button-checked-button;
      }

      :host([disabled]) .toggle-button {
        background-color: #bdbdbd;
        opacity: 1;
      }

      .toggle-ink {
        position: absolute;
        top: -14px;
        left: -14px;
        right: auto;
        bottom: auto;
        width: 48px;
        height: 48px;
        opacity: 0.5;
        pointer-events: none;
        color: var(--paper-toggle-button-unchecked-ink-color, var(--primary-text-color));

        @apply --paper-toggle-button-unchecked-ink;
      }

      :host([checked]) .toggle-ink {
        color: var(--paper-toggle-button-checked-ink-color, var(--primary-color));

        @apply --paper-toggle-button-checked-ink;
      }

      .toggle-container {
        display: inline-block;
        position: relative;
        width: 36px;
        height: 14px;
        /* The toggle button has an absolute position of -3px; The extra 1px
        /* accounts for the toggle button shadow box. */
        margin: 4px 1px;
      }

      .toggle-label {
        position: relative;
        display: inline-block;
        vertical-align: middle;
        padding-left: var(--paper-toggle-button-label-spacing, 8px);
        pointer-events: none;
        color: var(--paper-toggle-button-label-color, var(--primary-text-color));
      }

      /* invalid state */
      :host([invalid]) .toggle-bar {
        background-color: var(--paper-toggle-button-invalid-bar-color, var(--error-color));
      }

      :host([invalid]) .toggle-button {
        background-color: var(--paper-toggle-button-invalid-button-color, var(--error-color));
      }

      :host([invalid]) .toggle-ink {
        color: var(--paper-toggle-button-invalid-ink-color, var(--error-color));
      }
    </style>

    <div class="toggle-container">
      <div id="toggleBar" class="toggle-bar"></div>
      <div id="toggleButton" class="toggle-button"></div>
    </div>

    <div class="toggle-label"><slot></slot></div>

  `;O0t.setAttribute("strip-whitespace","");Yt({_template:O0t,is:"paper-toggle-button",behaviors:[Xx],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Cm(this,function(){m_(this,"pan-y")})},_ontrack:function(e){var t=e.detail;t.state==="start"?this._trackStart(t):t.state==="track"?this._trackMove(t):t.state==="end"&&this._trackEnd(t)},_trackStart:function(e){this._width=this.$.toggleBar.offsetWidth/2,this._trackChecked=this.checked,this.$.toggleButton.classList.add("dragging")},_trackMove:function(e){var t=e.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+t:t)),this.translate3d(this._x+"px",0,0,this.$.toggleButton),this._userActivate(this._x>this._width/2)},_trackEnd:function(e){this.$.toggleButton.classList.remove("dragging"),this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var e=su._createRipple();return e.id="ink",e.setAttribute("recenters",""),e.classList.add("circle","toggle-ink"),e}});Yt({_template:Q`
    <style>
      :host {
        --calculated-paper-toolbar-height: var(--paper-toolbar-height, 64px);
        --calculated-paper-toolbar-sm-height: var(--paper-toolbar-sm-height, 56px);
        display: block;
        position: relative;
        box-sizing: border-box;
        -moz-box-sizing: border-box;
        height: var(--calculated-paper-toolbar-height);
        background: var(--paper-toolbar-background, var(--primary-color));
        color: var(--paper-toolbar-color, var(--dark-theme-text-color));
        @apply --paper-toolbar;
      }

      :host(.animate) {
        transition: var(--paper-toolbar-transition, height 0.18s ease-in);
      }

      :host(.medium-tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 2);
        @apply --paper-toolbar-medium;
      }

      :host(.tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 3);
        @apply --paper-toolbar-tall;
      }

      .toolbar-tools {
        position: relative;
        height: var(--calculated-paper-toolbar-height);
        padding: 0 16px;
        pointer-events: none;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-toolbar-content;
      }

      /*
       * TODO: Where should media query breakpoints live so they can be shared between elements?
       */

      @media (max-width: 600px) {
        :host {
          height: var(--calculated-paper-toolbar-sm-height);
        }

        :host(.medium-tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 2);
        }

        :host(.tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 3);
        }

        .toolbar-tools {
          height: var(--calculated-paper-toolbar-sm-height);
        }
      }

      #topBar {
        position: relative;
      }

      /* middle bar */
      #middleBar {
        position: absolute;
        top: 0;
        right: 0;
        left: 0;
      }

      :host(.tall) #middleBar,
      :host(.medium-tall) #middleBar {
        -webkit-transform: translateY(100%);
        transform: translateY(100%);
      }

      /* bottom bar */
      #bottomBar {
        position: absolute;
        right: 0;
        bottom: 0;
        left: 0;
      }

      /*
       * make elements (e.g. buttons) respond to mouse/touch events
       *
       * \`.toolbar-tools\` disables touch events so multiple toolbars can stack and not
       * absorb events. All children must have pointer events re-enabled to work as
       * expected.
       */
      .toolbar-tools > ::slotted(*:not([disabled])) {
        pointer-events: auto;
      }

      .toolbar-tools > ::slotted(.title) {
        @apply --paper-font-common-base;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        font-size: 20px;
        font-weight: 400;
        line-height: 1;
        pointer-events: none;
        @apply --layout-flex;
      }

      .toolbar-tools > ::slotted(.title) {
        margin-left: 56px;
      }

      .toolbar-tools > ::slotted(paper-icon-button + .title) {
        margin-left: 0;
      }

      /**
       * The --paper-toolbar-title mixin is applied here instead of above to
       * fix the issue with margin-left being ignored due to css ordering.
       */
      .toolbar-tools > ::slotted(.title) {
        @apply --paper-toolbar-title;
      }

      .toolbar-tools > ::slotted(paper-icon-button[icon=menu]) {
        margin-right: 24px;
      }

      .toolbar-tools > ::slotted(.fit) {
        position: absolute;
        top: auto;
        right: 0;
        bottom: 0;
        left: 0;
        width: auto;
        margin: 0;
      }

      /* TODO(noms): Until we have a better solution for classes that don't use
       * /deep/ create our own.
       */
      .start-justified {
        @apply --layout-start-justified;
      }

      .center-justified {
        @apply --layout-center-justified;
      }

      .end-justified {
        @apply --layout-end-justified;
      }

      .around-justified {
        @apply --layout-around-justified;
      }

      .justified {
        @apply --layout-justified;
      }
    </style>

    <div id="topBar" class\$="toolbar-tools [[_computeBarExtraClasses(justify)]]">
      <slot name="top"></slot>
    </div>

    <div id="middleBar" class\$="toolbar-tools [[_computeBarExtraClasses(middleJustify)]]">
      <slot name="middle"></slot>
    </div>

    <div id="bottomBar" class\$="toolbar-tools [[_computeBarExtraClasses(bottomJustify)]]">
      <slot name="bottom"></slot>
    </div>
`,is:"paper-toolbar",hostAttributes:{role:"toolbar"},properties:{bottomJustify:{type:String,value:""},justify:{type:String,value:""},middleJustify:{type:String,value:""}},ready:function(){console.warn(this.is,"is deprecated. Please use app-layout instead!")},attached:function(){this._observer=this._observe(this),this._updateAriaLabelledBy()},detached:function(){this._observer&&this._observer.disconnect()},_observe:function(e){var t=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));return t.observe(e,{childList:!0,subtree:!0}),t},_updateAriaLabelledBy:function(){ci();for(var e=[],t=Array.prototype.slice.call(zt(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(zt(this.root).querySelectorAll("content"))),r,n=0;r=t[n];n++)for(var i=zt(r).getDistributedNodes(),o,a=0;o=i[a];a++)if(o.classList&&o.classList.contains("title"))if(o.id)e.push(o.id);else{var s="paper-toolbar-label-"+Math.floor(Math.random()*1e4);o.id=s,e.push(s)}e.length>0&&this.setAttribute("aria-labelledby",e.join(" "))},_computeBarExtraClasses:function(e){return e?e+(e==="justified"?"":"-justified"):""}});Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        outline: none;
        z-index: 1002;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;
        cursor: default;
      }

      #tooltip {
        display: block;
        outline: none;
        @apply --paper-font-common-base;
        font-size: 10px;
        line-height: 1;
        background-color: var(--paper-tooltip-background, #616161);
        color: var(--paper-tooltip-text-color, white);
        padding: 8px;
        border-radius: 2px;
        @apply --paper-tooltip;
      }

      @keyframes keyFrameScaleUp {
        0% {
          transform: scale(0.0);
        }
        100% {
          transform: scale(1.0);
        }
      }

      @keyframes keyFrameScaleDown {
        0% {
          transform: scale(1.0);
        }
        100% {
          transform: scale(0.0);
        }
      }

      @keyframes keyFrameFadeInOpacity {
        0% {
          opacity: 0;
        }
        100% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameFadeOutOpacity {
        0% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        100% {
          opacity: 0;
        }
      }

      @keyframes keyFrameSlideDownIn {
        0% {
          transform: translateY(-2000px);
          opacity: 0;
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameSlideDownOut {
        0% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(-2000px);
          opacity: 0;
        }
      }

      .fade-in-animation {
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameFadeInOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .fade-out-animation {
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 0ms);
        animation-name: keyFrameFadeOutOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-up-animation {
        transform: scale(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameScaleUp;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-down-animation {
        transform: scale(1);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameScaleDown;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation {
        transform: translateY(-2000px);
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownIn;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation-out {
        transform: translateY(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownOut;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .cancel-animation {
        animation-delay: -30s !important;
      }

      /* Thanks IE 10. */

      .hidden {
        display: none !important;
      }
    </style>

    <div id="tooltip" class="hidden">
      <slot></slot>
    </div>
`,is:"paper-tooltip",hostAttributes:{role:"tooltip",tabindex:-1},properties:{for:{type:String,observer:"_findTarget"},manualMode:{type:Boolean,value:!1,observer:"_manualModeChanged"},position:{type:String,value:"bottom"},fitToVisibleBounds:{type:Boolean,value:!1},offset:{type:Number,value:14},marginTop:{type:Number,value:14},animationDelay:{type:Number,value:500,observer:"_delayChange"},animationEntry:{type:String,value:""},animationExit:{type:String,value:""},animationConfig:{type:Object,value:function(){return{entry:[{name:"fade-in-animation",node:this,timing:{delay:0}}],exit:[{name:"fade-out-animation",node:this}]}}},_showing:{type:Boolean,value:!1}},listeners:{webkitAnimationEnd:"_onAnimationEnd"},get target(){var e=zt(this).parentNode,t=zt(this).getOwnerRoot(),r;return this.for?r=zt(t).querySelector("#"+this.for):r=e.nodeType==Node.DOCUMENT_FRAGMENT_NODE?t.host:e,r},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},playAnimation:function(e){e==="entry"?this.show():e==="exit"&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(zt(this).textContent.trim()===""){for(var e=!0,t=zt(this).getEffectiveChildNodes(),r=0;r<t.length;r++)if(t[r].textContent.trim()!==""){e=!1;break}if(e)return}this._showing=!0,this.$.tooltip.classList.remove("hidden"),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.updatePosition(),this._animationPlaying=!0,this.$.tooltip.classList.add(this._getAnimationType("entry"))}},hide:function(){if(!!this._showing){if(this._animationPlaying){this._showing=!1,this._cancelAnimation();return}else this._onAnimationFinish();this._showing=!1,this._animationPlaying=!0}},updatePosition:function(){if(!(!this._target||!this.offsetParent)){var e=this.offset;this.marginTop!=14&&this.offset==14&&(e=this.marginTop);var t=this.offsetParent.getBoundingClientRect(),r=this._target.getBoundingClientRect(),n=this.getBoundingClientRect(),i=(r.width-n.width)/2,o=(r.height-n.height)/2,a=r.left-t.left,s=r.top-t.top,l,c;switch(this.position){case"top":l=a+i,c=s-n.height-e;break;case"bottom":l=a+i,c=s+r.height+e;break;case"left":l=a-n.width-e,c=s+o;break;case"right":l=a+r.width+e,c=s+o;break}this.fitToVisibleBounds?(t.left+l+n.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,l)+"px",this.style.right="auto"),t.top+c+n.height>window.innerHeight?(this.style.bottom=t.height-s+e+"px",this.style.top="auto"):(this.style.top=Math.max(-t.top,c)+"px",this.style.bottom="auto")):(this.style.left=l+"px",this.style.top=c+"px")}},_addListeners:function(){this._target&&(this.listen(this._target,"mouseenter","show"),this.listen(this._target,"focus","show"),this.listen(this._target,"mouseleave","hide"),this.listen(this._target,"blur","hide"),this.listen(this._target,"tap","hide")),this.listen(this.$.tooltip,"animationend","_onAnimationEnd"),this.listen(this,"mouseenter","hide")},_findTarget:function(){this.manualMode||this._removeListeners(),this._target=this.target,this.manualMode||this._addListeners()},_delayChange:function(e){e!==500&&this.updateStyles({"--paper-tooltip-delay-in":e+"ms"})},_manualModeChanged:function(){this.manualMode?this._removeListeners():this._addListeners()},_cancelAnimation:function(){this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add("hidden")},_onAnimationFinish:function(){this._showing&&(this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add(this._getAnimationType("exit")))},_onAnimationEnd:function(){this._animationPlaying=!1,this._showing||(this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.add("hidden"))},_getAnimationType:function(e){if(e==="entry"&&this.animationEntry!=="")return this.animationEntry;if(e==="exit"&&this.animationExit!=="")return this.animationExit;if(this.animationConfig[e]&&typeof this.animationConfig[e][0].name=="string"){if(this.animationConfig[e][0].timing&&this.animationConfig[e][0].timing.delay&&this.animationConfig[e][0].timing.delay!==0){var t=this.animationConfig[e][0].timing.delay;e==="entry"?this.updateStyles({"--paper-tooltip-delay-in":t+"ms"}):e==="exit"&&this.updateStyles({"--paper-tooltip-delay-out":t+"ms"})}return this.animationConfig[e][0].name}},_removeListeners:function(){this._target&&(this.unlisten(this._target,"mouseenter","show"),this.unlisten(this._target,"focus","show"),this.unlisten(this._target,"mouseleave","hide"),this.unlisten(this._target,"blur","hide"),this.unlisten(this._target,"tap","hide")),this.unlisten(this.$.tooltip,"animationend","_onAnimationEnd"),this.unlisten(this,"mouseenter","hide")}});var rb=Ee(Oe(),1);var mE=class{constructor(t){this.listener=t}},EW=new Set,O9=new Set;window.addEventListener("hashchange",()=>{EW.forEach(e=>e.listener())});window.addEventListener("storage",()=>{O9.forEach(e=>e.listener())});function gE(e){let t=new mE(e);return EW.add(t),t}function TW(e){let t=new mE(e);return O9.add(t),t}function CW(){O9.forEach(e=>e.listener())}function AW(e){EW.delete(e)}function PW(e){O9.delete(e)}var kW={};Zs(kW,{getFakeHash:()=>LW,setFakeHash:()=>IW,setUseHash:()=>Xbe,useHash:()=>z9});var z0t=!1;function Xbe(e){z0t=e}function z9(){return z0t}var F0t="";function IW(e){F0t=e}function LW(){return F0t}var Qx="__tab__",RW={};function B0t(){return RW}function H0t(e){RW=e}gE(()=>{RW=eb(tb())});function tb(){return z9()?window.location.hash.slice(1):LW()}function eb(e){let t={};return e.split("&").forEach(n=>{let i=n.split("=");i.length===1?t[Qx]=i[0]:i.length===2&&(t[decodeURIComponent(i[0])]=decodeURIComponent(i[1]))}),t}function F9(e,t=!1){if(z9())if(t){let r=new URL(window.location.href);r.hash=e,window.history.replaceState(window.history.state,"",r.toString())}else window.location.hash=e;else IW(e)}function B9(e){let t="";e[Qx]!==void 0&&(t+=e[Qx]);let r=Object.keys(e).map(n=>[n,e[n]]).filter(n=>n[0]!==Qx).map(n=>encodeURIComponent(n[0])+"="+encodeURIComponent(n[1])).join("&");return r.length>0?t+"&"+r:t}function V0t(e,t=!1){let r=eb(tb());delete r[e],F9(B9(r),t)}var q0t="disambiguator",{get:$be,set:Kbe,getInitializer:v_,getObserver:x_,disposeBinding:Zbe}=vE(e=>e,e=>e),{get:Jbe,set:Qbe,getInitializer:xp,getObserver:bp,disposeBinding:t2e}=vE(e=>e==="true"?!0:e==="false"?!1:void 0,e=>e.toString()),{get:NW,set:DW,getInitializer:_E,getObserver:yE,disposeBinding:e2e}=vE(e=>+e,e=>e.toString()),{get:r2e,set:n2e,getInitializer:OW,getObserver:zW,disposeBinding:i2e}=vE(e=>JSON.parse(atob(e)),e=>btoa(JSON.stringify(e)));function vE(e,t){let r=[],n=[];function i(c,u={}){let{defaultValue:h,useLocalStorage:f=!1}=u,p=f?window.localStorage.getItem(c):eb(tb())[c];return p==null?rb.cloneDeep(h):e(p)}function o(c,u,h={}){let{defaultValue:f,useLocalStorage:p=!1,useLocationReplace:d=!1}=h,g=t(u);if(p)window.localStorage.setItem(c,g),CW();else if(!rb.isEqual(u,i(c,{useLocalStorage:p})))if(rb.isEqual(u,f))V0t(c,d);else{let _=eb(tb());_[c]=g,F9(B9(_),d)}}function a(c,u){let h=ia({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=()=>{let _=i(f,h),y=this[h.polymerProperty];rb.isEqual(_,y)||(this[h.polymerProperty]=_)},g=(h.useLocalStorage?TW:gE)(()=>p());return h.useLocalStorage?n.push(g):r.push(g),p(),this[h.polymerProperty]}}function s(){r.forEach(c=>AW(c)),n.forEach(c=>PW(c))}function l(c,u){let h=ia({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=U0t(this,c),p=this[h.polymerProperty];o(f,p,h)}}return{get:i,set:o,getInitializer:a,getObserver:l,disposeBinding:s}}function o2e(){let e=new Set(["examplesPath","hideModelPane2","modelName1","modelName2","inferenceAddress1","inferenceAddress2","modelType","modelVersion1","modelVersion2","modelSignature1","modelSignature2","maxExamples","labelVocabPath","multiClass","sequenceExamples","maxClassesToDisplay","samplingOdds","usePredictApi","predictInputTensor","predictOutputTensor"]),t=eb(tb());if(t[Qx]==="whatif"){for(let r of e)if(r in t){let n=t[r];t[`p.whatif.${r}`]=n}}F9(B9(t)),H0t(t)}function U0t(e,t){let r=e[q0t];return(r==null?[t]:[r,t]).join(".")}var xE=class extends mt{constructor(){super(...arguments),this._tagFilter=v_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}).call(this),this._tagFilterObserver=x_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"})}_computeTagFilter(){return this._tagFilter}};xE.template=Q`
    <paper-input
      no-label-float=""
      label="Filter tags (regular expressions supported)"
      value="{{_tagFilter}}"
      class="search-input"
    >
      <iron-icon prefix="" icon="search" slot="prefix"></iron-icon>
    </paper-input>
    <style>
      :host {
        display: block;
        margin: 10px 5px 10px 10px;
      }
    </style>
  `;E([A({type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"}),w("design:type",String)],xE.prototype,"tagFilter",void 0);E([A({type:String,observer:"_tagFilterObserver"}),w("design:type",String)],xE.prototype,"_tagFilter",void 0);xE=E([yt("tf-tag-filterer")],xE);function ys(e){let{moduleName:t,styleContent:r}=e,n=document.createElement("dom-module"),i=document.createElement("template"),o=[];e.styleDependencies&&e.styleDependencies.forEach(s=>{let l=document.createElement("style");l.setAttribute("include",s),o.push(l)});let a=document.createElement("style");Object.assign(a,{textContent:r}),o.forEach(s=>{i.content.appendChild(s)}),i.content.appendChild(a),n.appendChild(i),n.register(t)}ys({moduleName:"dashboard-style",styleDependencies:["iron-flex"],styleContent:`
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

      [slot='sidebar'] {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        height: 100%;
        margin-right: 10px;
        overflow-x: hidden;
        padding: 5px 0;
        text-overflow: ellipsis;
      }

      .settings {
        min-height: 50px;
        overflow-x: hidden;
        overflow-y: auto;
        will-change: transform;
      }

      .runs-selector {
        display: flex;
        flex-grow: 1;
        min-height: 200px;
      }

      tf-runs-selector {
        flex-grow: 1;
        flex-shrink: 1;
        left: var(--sidebar-left-padding);
        max-height: calc(100% - var(--sidebar-vertical-padding) * 2);
        overflow: hidden;
        position: absolute;
        right: 0;
      }

      .search-input {
        margin: 10px 5px 0 10px;
      }

      .sidebar-section {
        border-top: solid 1px var(--tb-ui-border);
        margin-right: 10px;
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
        overflow: hidden;
      }

      .sidebar-section:first-of-type {
        border: none;
      }

      .sidebar-section paper-button {
        margin: 5px;
      }

      .sidebar-section paper-button:first-of-type {
        margin-left: 0 !important;
      }

      .sidebar-section paper-button:last-of-type {
        margin-right: 0 !important;
      }

      .sidebar-section > :first-child {
        margin-top: 0;
        padding-top: 0;
      }

      .sidebar-section > :last-child {
        margin-bottom: 0;
        padding-bottom: 0;
      }

      .sidebar-section h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 10px 0 5px;
        pointer-events: none;
      }

      paper-checkbox {
        --paper-checkbox-checked-color: var(--tb-ui-dark-accent);
        --paper-checkbox-unchecked-color: var(--tb-ui-dark-accent);
        font-size: 15px;
        margin-top: 5px;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
  `});function _o(e){return class extends e{connectedCallback(){super.connectedCallback(),this._maybeSetDarkMode(),this.observer=new MutationObserver(r=>{r.some(i=>i.attributeName==="class")&&this._maybeSetDarkMode()}),this.observer.observe(document.body,{attributes:!0})}disconnectedCallback(){var r;super.disconnectedCallback(),(r=this.observer)==null||r.disconnect()}_maybeSetDarkMode(){this.classList.toggle("dark-mode",document.body.classList.contains("dark-mode"))}}}ys({moduleName:"scrollbar-style",styleContent:`
    .scrollbar::-webkit-scrollbar-track {
      visibility: hidden;
    }

    .scrollbar::-webkit-scrollbar {
      width: 10px;
    }

    .scrollbar::-webkit-scrollbar-thumb {
      border-radius: 10px;
      -webkit-box-shadow: inset 0 0 2px rgba(0, 0, 0, 0.3);
      background-color: var(--paper-grey-500);
      color: var(--paper-grey-900);
    }
    .scrollbar {
      box-sizing: border-box;
    }
  `});var BW=document.createElement("style");BW.setAttribute("is","custom-style");BW.textContent=`
  :root {
    --tb-orange-weak: #ffa726;
    --tb-orange-strong: #f57c00;
    --tb-orange-dark: #dc7320;
    --tb-grey-darker: #e2e2e2;
    --tb-grey-lighter: #f3f3f3;
    --tb-ui-dark-accent: #757575;
    --tb-ui-light-accent: #e0e0e0;
    --tb-ui-border: var(--paper-grey-300);
    --tb-graph-faded: #e0d4b3;
    --tb-secondary-text-color: var(--paper-grey-800);
    --tb-raised-button-shadow-color: rgba(0, 0, 0, 0.2);
    --primary-background-color: #fff;
    --secondary-background-color: #e9e9e9;
    --tb-layout-background-color: #f5f5f5;
    --tb-link: #1976d2; /* material blue 700. */
    --tb-link-visited: #7b1fa2; /* material purple 700. */
  }

  :root .dark-mode {
    --tb-ui-border: var(--paper-grey-700);
    --tb-ui-dark-accent: var(--paper-grey-400);
    --tb-ui-light-accent: var(--paper-grey-600);
    --tb-secondary-text-color: var(--paper-grey-400);
    --tb-raised-button-shadow-color: rgba(255, 255, 255, 0.5);
    --primary-text-color: #fff;
    --secondary-text-color: var(--paper-grey-400);
    --primary-background-color: #303030;  /* material grey A400. */
    --secondary-background-color: #3a3a3a;
    --tb-layout-background-color: #3a3a3a;
    --tb-link: #42a5f5; /* material blue 400. */
    --tb-link-visited: #ba68c8; /* material purple 300. */
    /* Overrides paper-material */
    --shadow-elevation-2dp_-_box-shadow: 0 2px 2px 0 rgba(255, 255, 255, 0.14),
      0 1px 5px 0 rgba(255, 255, 255, 0.12),
      0 3px 1px -2px rgba(255, 255, 255, 0.2);
  }
`;document.head.appendChild(BW);var HW=class extends _o(mt){};HW.template=Q`
    <div id="sidebar">
      <slot name="sidebar"></slot>
    </div>

    <div id="center">
      <slot name="center" class="scollbar"></slot>
    </div>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        background-color: #f5f5f5;
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      :host(.dark-mode) {
        background-color: var(--secondary-background-color);
      }

      #sidebar {
        flex: 0 0 var(--tf-dashboard-layout-sidebar-basis, 25%);
        height: 100%;
        max-width: var(--tf-dashboard-layout-sidebar-max-width, 350px);
        min-width: var(--tf-dashboard-layout-sidebar-min-width, 270px);
        overflow-y: auto;
        text-overflow: ellipsis;
      }

      #center {
        flex-grow: 1;
        flex-shrink: 1;
        height: 100%;
        overflow: hidden;
      }

      ::slotted([slot='center']) {
        contain: strict;
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  `;HW=E([yt("tf-dashboard-layout")],HW);var G0t="TF.TensorBoard.PaginatedView.limit",a2e=12,Ph=null,VW=new Set;function UW(e){VW.add(e)}function qW(e){VW.delete(e)}function GW(){return Ph==null&&(Ph=NW(G0t,{useLocalStorage:!0}),(Ph==null||!isFinite(Ph)||Ph<=0)&&(Ph=a2e)),Ph}function s2e(e){if(e!==Math.floor(e))throw new Error(`limit must be an integer, but got: ${e}`);if(e<=0)throw new Error(`limit must be positive, but got: ${e}`);e!==Ph&&(Ph=e,DW(G0t,Ph,{useLocalStorage:!0}),VW.forEach(t=>{t()}))}var nb=class extends mt{updateArrayProp(t,r,n){let i=this.get(t),o=r;if(!Array.isArray(o))throw RangeError(`Expected new value to '${t}' to be an array.`);Array.isArray(i)||(i=[],this.set(t,i));let a=new Set(o.map((c,u)=>n(c,u))),s=0,l=0;for(;s<i.length&&l<o.length;){if(a.has(n(i[s],s)))n(i[s],s)==n(o[l],l)?this.set(`${t}.${s}`,o[l]):this.splice(t,s,0,o[l]);else{this.splice(t,s,1);continue}l++,s++}s<i.length&&this.splice(t,s),l<o.length&&this.push(t,...o.slice(l))}};var Oi=class extends nb{constructor(){super(...arguments),this.as="item",this._contentActive=!0,this._domBootstrapped=!1,this._ctor=null,this._renderedItems=[],this._renderedTemplateInst=new Map,this._lruCachedItems=new Map,this._cacheSize=10,this._getItemKey=t=>JSON.stringify(t),this._isConnected=!1}connectedCallback(){super.connectedCallback(),this._isConnected=!0}setCacheSize(t){this._cacheSize=t}setGetItemKey(t){this._getItemKey=t}updateDom(t){this.updateArrayProp("_renderedItems",t,this._getItemKey)}_ensureTemplatized(){if(!this.isConnected)return!1;if(!this._ctor){let t=this.querySelector("template");this._ctor=tc(t,this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(r,n){this._renderedTemplateInst.forEach(i=>{i.forwardHostProp(r,n)})}})}return!0}_bootstrapDom(){if(!this._ensureTemplatized()||this._domBootstrapped)return;new MutationObserver(r=>{for(let n of r)if(n.type==="childList")for(let i of Array.from(n.addedNodes))i instanceof Element&&i.setAttribute("slot","items")}).observe(this,{childList:!0}),Array.from(this.children).forEach(r=>{this.removeChild(r)}),this._lruCachedItems.clear(),this._renderedItems.forEach((r,n)=>this._insertItem(r,n)),this._domBootstrapped=!0}_updateActive(){!this._domBootstrapped||Array.from(this._renderedTemplateInst.values()).forEach(t=>{t.notifyPath("active",this._contentActive)})}_updateDom(t){if(!!this._domBootstrapped&&!(t.path=="_renderedItems"||t.path=="_renderedItems.length"))if(t.path==="_renderedItems.splices")t.value.indexSplices.forEach(n=>{let{index:i,addedCount:o,object:a,removed:s}=n;s.forEach(l=>{this._removeItem(l,this.children[i])}),a.slice(i,i+o).forEach((l,c)=>this._insertItem(l,i+c)),this._trimCache()});else{let r=this._getItemKey(t.value);this._renderedTemplateInst.has(r)?this._renderedTemplateInst.get(r).notifyPath(this.as,t.value):console.warn(`Expected '${r}' to exist in the DOM but could not find one.`)}}_insertItem(t,r){if(!this._ensureTemplatized())throw new Error("Expected templatized before inserting an item");let n,i=this._getItemKey(t);if(this._lruCachedItems.has(i))n=this._lruCachedItems.get(i),this._lruCachedItems.delete(i),this._renderedTemplateInst.get(i).notifyPath("active",this._contentActive);else{let o={[this.as]:t,active:this._contentActive},a=new this._ctor(o);n=a.root,this._renderedTemplateInst.set(i,a)}this.children[r]?this.insertBefore(n,this.children[r]):((n.nodeType==Node.DOCUMENT_FRAGMENT_NODE?Array.from(n.children):[n]).forEach(a=>a.setAttribute("slot","items")),this.appendChild(n))}_removeItem(t,r){r.parentNode&&r.parentNode.removeChild(r);let n=this._getItemKey(t);this._lruCachedItems.set(n,r),this._renderedTemplateInst.get(n).notifyPath("active",!1)}_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){let[t]=this._lruCachedItems.keys();this._lruCachedItems.delete(t),this._renderedTemplateInst.delete(t)}}};E([A({type:String}),w("design:type",Object)],Oi.prototype,"as",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"items",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Oi.prototype,"_contentActive",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_domBootstrapped",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_ctor",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"_renderedItems",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_renderedTemplateInst",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_lruCachedItems",void 0);E([A({type:Number}),w("design:type",Object)],Oi.prototype,"_cacheSize",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_getItemKey",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_isConnected",void 0);E([Bt("_isConnected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_bootstrapDom",null);E([Bt("_contentActive"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_updateActive",null);E([Bt("_renderedItems.*","_domBootstrapped"),w("design:type",Function),w("design:paramtypes",[Object]),w("design:returntype",void 0)],Oi.prototype,"_updateDom",null);E([Bt("_cacheSize"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_trimCache",null);var hn=class extends Oi{constructor(){super(...arguments),this.disablePagination=!1,this.getCategoryItemKey=t=>JSON.stringify(t),this._limit=12,this._activeIndex=0,this._pageInputRawValue="",this._pageInputFocused=!1}_computeCount(){return this.category.items.length}get _hasMultiple(){return this._count>1}_togglePane(){this.opened=!this.opened}_changeContentActive(t){this._contentActive=t}_onPaneRenderedChanged(t,r){t&&t!==r&&this.$.ifRendered.render()}_computePaneRendered(t){return!(t.metadata.type===Da.SEARCH_RESULTS&&t.name==="")}get _itemsRendered(){return this._paneRendered&&this.opened}_computeIsSearchResults(t){return t===Da.SEARCH_RESULTS}_computeIsInvalidSearchResults(t){return t.type===Da.SEARCH_RESULTS&&!t.validRegex}_computeIsUniversalSearchQuery(t){return t.type===Da.SEARCH_RESULTS&&t.universalRegex}_isCompositeSearch(){let{type:t,compositeSearch:r}=this.category.metadata;return r&&t===Da.SEARCH_RESULTS}ready(){super.ready(),this.opened=this.initialOpened==null?!0:this.initialOpened,this._limitListener=()=>{this.set("_limit",GW())},UW(this._limitListener),this._limitListener()}detached(){qW(this._limitListener)}_updateRenderedItems(){var t=this._itemsRendered,r=this._limit,n=this._activeIndex,i=this.disablePagination;if(!t)return;let o=Math.floor(n/r),a=this.category.items||[],s=i?a:a.slice(o*r,(o+1)*r);this.updateDom(s)}_limitChanged(t){this.setCacheSize(t*2)}_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)}get _currentPage(){var t=this._limit,r=this._activeIndex;return Math.floor(r/t)+1}_computePageCount(t,r){return this.category?Math.ceil(this.category.items.length/r):0}get _multiplePagesExist(){var t=this._pageCount,r=this.disablePagination;return!r&&t>1}get _hasPreviousPage(){var t=this._currentPage;return t>1}get _hasNextPage(){var t=this._currentPage,r=this._pageCount;return t<r}_computeInputWidth(t){return`calc(${t.toString().length}em + 20px)`}_setActiveIndex(t){let r=(this.category.items||[]).length-1;t>r&&(t=r),t<0&&(t=0),this.set("_activeIndex",t)}_clampActiveIndex(){this._setActiveIndex(this._activeIndex)}_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)}_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)}_computePageInputValue(t,r,n){return t?r:n.toString()}_handlePageInputEvent(t){this.set("_pageInputRawValue",t.target.value);let r=Number(t.target.value||NaN);if(isNaN(r))return;let n=Math.max(1,Math.min(r,this._pageCount))-1;this._setActiveIndex(this._limit*n)}_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())}_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue),this.set("_pageInputFocused",!0)}_handlePageBlurEvent(){this.set("_pageInputFocused",!1)}_updatePageInputValue(t){var n;let r=(n=this.shadowRoot)==null?void 0:n.querySelector("#page-input input");r&&(r.value=t)}_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}};hn.template=Q`
    <template is="dom-if" if="[[_paneRendered]]" id="ifRendered">
      <button class="heading" on-tap="_togglePane" open-button$="[[opened]]">
        <span class="name">
          <template is="dom-if" if="[[_isSearchResults]]">
            <template is="dom-if" if="[[_isCompositeSearch(category)]]">
              <span>Tags matching multiple experiments</span>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span
                  >&nbsp;<strong>(malformed regular expression)</strong></span
                >
              </template>
            </template>
            <template is="dom-if" if="[[!_isCompositeSearch(category)]]">
              <span class="light">Tags matching /</span>
              <span class="category-name" title$="[[category.name]]"
                >[[category.name]]</span
              >
              <span class="light">/</span>
              <template is="dom-if" if="[[_isUniversalSearchQuery]]">
                <span> (all tags)</span>
              </template>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span> <strong>(malformed regular expression)</strong></span>
              </template>
            </template>
          </template>
          <template is="dom-if" if="[[!_isSearchResults]]">
            <span class="category-name" title$="[[category.name]]"
              >[[category.name]]</span
            >
          </template>
        </span>
        <span class="count">
          <template is="dom-if" if="[[_hasMultiple]]">
            <span>[[_count]]</span>
          </template>
          <iron-icon icon="expand-more" class="expand-arrow"></iron-icon>
        </span>
      </button>
      <!-- TODO(stephanwlee): investigate further. For some reason,
        transitionend that the iron-collapse relies on sometimes does not
        trigger when rendering a chart with a spinner. A toy example cannot
        reproduce this bug. -->
      <iron-collapse opened="[[opened]]" no-animation="">
        <div class="content">
          <span id="top-of-container"></span>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div class="big-page-buttons" style="margin-bottom: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>

          <div id="items">
            <slot name="items"></slot>
          </div>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div id="controls-container">
              <div style="display: inline-block; padding: 0 5px">
                Page
                <paper-input
                  id="page-input"
                  type="number"
                  no-label-float=""
                  min="1"
                  max="[[_pageCount]]"
                  value="[[_pageInputValue]]"
                  on-input="_handlePageInputEvent"
                  on-change="_handlePageChangeEvent"
                  on-focus="_handlePageFocusEvent"
                  on-blur="_handlePageBlurEvent"
                ></paper-input>
                of [[_pageCount]]
              </div>
            </div>

            <div class="big-page-buttons" style="margin-top: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>
    <style>
      :host {
        display: block;
        margin: 0 5px 1px 10px;
      }

      :host(:first-of-type) {
        margin-top: 10px;
      }

      :host(:last-of-type) {
        margin-bottom: 20px;
      }

      .heading {
        background-color: var(--primary-background-color);
        border: none;
        color: inherit;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px var(--tb-raised-button-shadow-color);
        padding: 10px 15px;
        display: flex;
        align-items: center;
        justify-content: space-between;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      [open-button] {
        border-bottom-left-radius: 0 !important;
        border-bottom-right-radius: 0 !important;
      }

      [open-button] .expand-arrow {
        transform: rotateZ(180deg);
      }

      .name {
        display: inline-flex;
        overflow: hidden;
      }

      .light {
        color: var(--paper-grey-500);
      }

      .category-name {
        white-space: pre;
        overflow: hidden;
        text-overflow: ellipsis;
        padding: 2px 0;
      }

      .count {
        margin: 0 5px;
        font-size: 12px;
        color: var(--paper-grey-500);
        display: flex;
        align-items: center;
        flex: none;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      .content {
        display: flex;
        flex-direction: column;
        background-color: var(--primary-background-color);
        border-bottom-left-radius: 2px;
        border-bottom-right-radius: 2px;
        border-top: none;
        border: 1px solid #dedede;
        padding: 15px;
      }

      .light {
        color: var(--paper-grey-500);
      }

      #controls-container {
        justify-content: center;
        display: flex;
        flex-direction: row;
        flex-grow: 0;
        flex-shrink: 0;
        width: 100%;
      }

      #controls-container paper-button {
        display: inline-block;
      }

      .big-page-buttons {
        display: flex;
      }

      .big-page-buttons paper-button {
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
        display: inline-block;
        flex-basis: 0;
        flex-grow: 1;
        flex-shrink: 1;
        font-size: 13px;
      }

      .big-page-buttons paper-button[disabled] {
        background: none;
      }

      slot {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }

      ::slotted([slot='items']) {
        /* Tooltip for descriptions and others break with more strict ones. */
        contain: style;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],hn.prototype,"category",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"initialOpened",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],hn.prototype,"opened",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"disablePagination",void 0);E([A({type:Number,computed:"_computeCount(category.items.*)"}),w("design:type",Number)],hn.prototype,"_count",void 0);E([A({type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"}),w("design:type",Boolean)],hn.prototype,"_paneRendered",void 0);E([A({type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"}),w("design:type",Boolean)],hn.prototype,"_isSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isInvalidSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isUniversalSearchQuery",void 0);E([A({type:Object,observer:"_getCategoryItemKeyChanged"}),w("design:type",Object)],hn.prototype,"getCategoryItemKey",void 0);E([A({type:Number,observer:"_limitChanged"}),w("design:type",Number)],hn.prototype,"_limit",void 0);E([A({type:Number}),w("design:type",Number)],hn.prototype,"_activeIndex",void 0);E([A({type:Number,computed:"_computePageCount(category.items.*, _limit)"}),w("design:type",Number)],hn.prototype,"_pageCount",void 0);E([A({type:String,computed:"_computeInputWidth(_pageCount)",observer:"_updateInputWidth"}),w("design:type",String)],hn.prototype,"_inputWidth",void 0);E([A({type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"}),w("design:type",String)],hn.prototype,"_pageInputValue",void 0);E([A({type:String}),w("design:type",String)],hn.prototype,"_pageInputRawValue",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"_pageInputFocused",void 0);E([Rt("_count"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasMultiple",null);E([Bt("opened"),w("design:type",Function),w("design:paramtypes",[Boolean]),w("design:returntype",void 0)],hn.prototype,"_changeContentActive",null);E([Rt("opened","_paneRendered"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_itemsRendered",null);E([Bt("_itemsRendered","category.items.*","_limit","_activeIndex","_pageCount","disablePagination"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_updateRenderedItems",null);E([Rt("_limit","_activeIndex"),w("design:type",Number),w("design:paramtypes",[])],hn.prototype,"_currentPage",null);E([Rt("_pageCount","disablePagination"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_multiplePagesExist",null);E([Rt("_currentPage"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasPreviousPage",null);E([Rt("_currentPage","_pageCount"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasNextPage",null);E([Bt("category.items.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_clampActiveIndex",null);hn=E([yt("tf-category-paginated-view")],hn);var W0t=Ee(Oe(),1);var H9=class{constructor(t){this.listener=t}},wp=class{constructor(){this.requestManager=new Ae(1),this._listeners=new Set,this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(t){let r=new H9(t);return this._listeners.add(r),r}removeListenerByKey(t){this._listeners.delete(t)}emitChange(){this._listeners.forEach(t=>{try{t.listener()}catch(r){}})}};var V9=class extends wp{load(){let t=_e().environment();return this.requestManager.request(t).then(r=>{let n={dataLocation:r.data_location,windowTitle:r.window_title};r.experiment_name!==void 0&&(n.experimentName=r.experiment_name),r.experiment_description!==void 0&&(n.experimentDescription=r.experiment_description),r.creation_time!==void 0&&(n.creationTime=r.creation_time),!W0t.isEqual(this.environment,n)&&(this.environment=n,this.emitChange())})}getDataLocation(){return this.environment?this.environment.dataLocation:""}getWindowTitle(){return this.environment?this.environment.windowTitle:""}getExperimentName(){return this.environment?this.environment.experimentName:""}getExperimentDescription(){return this.environment?this.environment.experimentDescription:""}getCreationTime(){return this.environment?this.environment.creationTime:null}},ib=new V9;var Y0t=Ee(Oe(),1);var U9=class extends wp{constructor(){super(...arguments),this._runs=[]}load(){let t=_e().runs();return this.requestManager.request(t).then(r=>{Y0t.isEqual(this._runs,r)||(this._runs=r,this.emitChange())})}getRuns(){return this._runs.slice()}},Sp=new U9;var Vr={};Zs(Vr,{FormatSpecifier:()=>GE,active:()=>Vvt,arc:()=>BSt,area:()=>z8,areaRadial:()=>o$,ascending:()=>aa,autoType:()=>ij,axisBottom:()=>Z9,axisLeft:()=>lb,axisRight:()=>m_t,axisTop:()=>d_t,bisect:()=>vs,bisectLeft:()=>$0t,bisectRight:()=>WW,bisector:()=>ob,blob:()=>D1t,brush:()=>GL,brushSelection:()=>UL,brushX:()=>jvt,brushY:()=>qL,buffer:()=>O1t,chord:()=>$vt,clientPoint:()=>Om,cluster:()=>Wbt,color:()=>rc,contourDensity:()=>g1t,contours:()=>ZL,create:()=>syt,creator:()=>Nm,cross:()=>q9,csv:()=>F1t,csvFormat:()=>b1t,csvFormatBody:()=>w1t,csvFormatRow:()=>M1t,csvFormatRows:()=>S1t,csvFormatValue:()=>E1t,csvParse:()=>Cb,csvParseRows:()=>x1t,cubehelix:()=>ca,curveBasis:()=>W8,curveBasisClosed:()=>QSt,curveBasisOpen:()=>e3t,curveBundle:()=>n3t,curveCardinal:()=>i3t,curveCardinalClosed:()=>o3t,curveCardinalOpen:()=>a3t,curveCatmullRom:()=>l3t,curveCatmullRomClosed:()=>u3t,curveCatmullRomOpen:()=>f3t,curveLinear:()=>jh,curveLinearClosed:()=>d3t,curveMonotoneX:()=>x3t,curveMonotoneY:()=>b3t,curveNatural:()=>M3t,curveStep:()=>E3t,curveStepAfter:()=>C3t,curveStepBefore:()=>T3t,customEvent:()=>Ep,descending:()=>Z0t,deviation:()=>W9,dispatch:()=>xs,drag:()=>pb,dragDisable:()=>Fm,dragEnable:()=>Bm,dsv:()=>oj,dsvFormat:()=>Ym,easeBack:()=>OL,easeBackIn:()=>OY,easeBackInOut:()=>OL,easeBackOut:()=>zY,easeBounce:()=>I_,easeBounceIn:()=>RY,easeBounceInOut:()=>NY,easeBounceOut:()=>I_,easeCircle:()=>NL,easeCircleIn:()=>IY,easeCircleInOut:()=>NL,easeCircleOut:()=>LY,easeCubic:()=>bs,easeCubicIn:()=>xY,easeCubicInOut:()=>bs,easeCubicOut:()=>bY,easeElastic:()=>zL,easeElasticIn:()=>HY,easeElasticInOut:()=>VY,easeElasticOut:()=>zL,easeExp:()=>RL,easeExpIn:()=>AY,easeExpInOut:()=>RL,easeExpOut:()=>PY,easeLinear:()=>_Y,easePoly:()=>LL,easePolyIn:()=>SY,easePolyInOut:()=>LL,easePolyOut:()=>MY,easeQuad:()=>IL,easeQuadIn:()=>yY,easeQuadInOut:()=>IL,easeQuadOut:()=>vY,easeSin:()=>kL,easeSinIn:()=>EY,easeSinInOut:()=>kL,easeSinOut:()=>TY,entries:()=>u1t,event:()=>qt,extent:()=>sa,forceCenter:()=>W1t,forceCollide:()=>uxt,forceLink:()=>fxt,forceManyBody:()=>gxt,forceRadial:()=>_xt,forceSimulation:()=>mxt,forceX:()=>yxt,forceY:()=>vxt,format:()=>xn,formatDefaultLocale:()=>nk,formatLocale:()=>ek,formatPrefix:()=>WE,formatSpecifier:()=>kp,geoAlbers:()=>Uk,geoAlbersUsa:()=>Lbt,geoArea:()=>Nxt,geoAzimuthalEqualArea:()=>kbt,geoAzimuthalEqualAreaRaw:()=>Gk,geoAzimuthalEquidistant:()=>Rbt,geoAzimuthalEquidistantRaw:()=>Wk,geoBounds:()=>Uxt,geoCentroid:()=>Xxt,geoCircle:()=>Qxt,geoClipAntimeridian:()=>e5,geoClipCircle:()=>Ak,geoClipExtent:()=>rbt,geoClipRectangle:()=>Op,geoConicConformal:()=>Dbt,geoConicConformalRaw:()=>jj,geoConicEqualArea:()=>Y_,geoConicEqualAreaRaw:()=>Wj,geoConicEquidistant:()=>zbt,geoConicEquidistantRaw:()=>Xj,geoContains:()=>cbt,geoDistance:()=>Nb,geoEqualEarth:()=>Fbt,geoEqualEarthRaw:()=>Xk,geoEquirectangular:()=>Obt,geoEquirectangularRaw:()=>X_,geoGnomonic:()=>Bbt,geoGnomonicRaw:()=>$k,geoGraticule:()=>Nk,geoGraticule10:()=>fbt,geoIdentity:()=>Hbt,geoInterpolate:()=>pbt,geoLength:()=>kk,geoMercator:()=>Nbt,geoMercatorRaw:()=>j_,geoNaturalEarth1:()=>Vbt,geoNaturalEarth1Raw:()=>Kk,geoOrthographic:()=>Ubt,geoOrthographicRaw:()=>Zk,geoPath:()=>Tbt,geoProjection:()=>Si,geoProjectionMutator:()=>l5,geoRotation:()=>wk,geoStereographic:()=>qbt,geoStereographicRaw:()=>Jk,geoStream:()=>vo,geoTransform:()=>Cbt,geoTransverseMercator:()=>Gbt,geoTransverseMercatorRaw:()=>Qk,gray:()=>Syt,hcl:()=>gb,hierarchy:()=>p5,histogram:()=>r_t,hsl:()=>Um,html:()=>q1t,image:()=>H1t,interpolate:()=>nc,interpolateArray:()=>Dyt,interpolateBasis:()=>lL,interpolateBasisClosed:()=>cL,interpolateBlues:()=>xSt,interpolateBrBG:()=>Qwt,interpolateBuGn:()=>lSt,interpolateBuPu:()=>cSt,interpolateCividis:()=>TSt,interpolateCool:()=>PSt,interpolateCubehelix:()=>Jyt,interpolateCubehelixDefault:()=>CSt,interpolateCubehelixLong:()=>T_,interpolateDate:()=>fL,interpolateDiscrete:()=>Oyt,interpolateGnBu:()=>uSt,interpolateGreens:()=>bSt,interpolateGreys:()=>wSt,interpolateHcl:()=>$yt,interpolateHclLong:()=>Kyt,interpolateHsl:()=>Yyt,interpolateHslLong:()=>jyt,interpolateHue:()=>zyt,interpolateInferno:()=>DSt,interpolateLab:()=>E_,interpolateMagma:()=>NSt,interpolateNumber:()=>zi,interpolateNumberArray:()=>yb,interpolateObject:()=>pL,interpolateOrRd:()=>hSt,interpolateOranges:()=>ESt,interpolatePRGn:()=>tSt,interpolatePiYG:()=>eSt,interpolatePlasma:()=>OSt,interpolatePuBu:()=>pSt,interpolatePuBuGn:()=>fSt,interpolatePuOr:()=>rSt,interpolatePuRd:()=>dSt,interpolatePurples:()=>SSt,interpolateRainbow:()=>ISt,interpolateRdBu:()=>nSt,interpolateRdGy:()=>iSt,interpolateRdPu:()=>mSt,interpolateRdYlBu:()=>oSt,interpolateRdYlGn:()=>aSt,interpolateReds:()=>MSt,interpolateRgb:()=>Gm,interpolateRgbBasis:()=>uL,interpolateRgbBasisClosed:()=>Nyt,interpolateRound:()=>dL,interpolateSinebow:()=>LSt,interpolateSpectral:()=>sSt,interpolateString:()=>vb,interpolateTransformCss:()=>_L,interpolateTransformSvg:()=>yL,interpolateTurbo:()=>kSt,interpolateViridis:()=>RSt,interpolateWarm:()=>ASt,interpolateYlGn:()=>_St,interpolateYlGnBu:()=>gSt,interpolateYlOrBr:()=>ySt,interpolateYlOrRd:()=>vSt,interpolateZoom:()=>vL,interrupt:()=>hu,interval:()=>nvt,isoFormat:()=>Fwt,isoParse:()=>Bwt,json:()=>V1t,keys:()=>$L,lab:()=>S_,lch:()=>Eyt,line:()=>vu,lineRadial:()=>i$,linkHorizontal:()=>WSt,linkRadial:()=>jSt,linkVertical:()=>YSt,local:()=>eL,map:()=>Ji,matcher:()=>ub,max:()=>lu,mean:()=>o_t,median:()=>a_t,merge:()=>Lm,min:()=>km,mouse:()=>zo,namespace:()=>Ih,namespaces:()=>SE,nest:()=>r1t,now:()=>Pp,pack:()=>d2t,packEnclose:()=>e8,packSiblings:()=>u2t,pairs:()=>K0t,partition:()=>m2t,path:()=>ws,permute:()=>s_t,pie:()=>qSt,piecewise:()=>dY,pointRadial:()=>cy,polygonArea:()=>M2t,polygonCentroid:()=>E2t,polygonContains:()=>P2t,polygonHull:()=>A2t,polygonLength:()=>I2t,precisionFixed:()=>ik,precisionPrefix:()=>ok,precisionRound:()=>ak,quadtree:()=>Fh,quantile:()=>la,quantize:()=>Qyt,radialArea:()=>o$,radialLine:()=>i$,randomBates:()=>R2t,randomExponential:()=>N2t,randomIrwinHall:()=>s8,randomLogNormal:()=>k2t,randomNormal:()=>a8,randomUniform:()=>L2t,range:()=>Ir,rgb:()=>cu,ribbon:()=>Jvt,scaleBand:()=>tg,scaleDiverging:()=>I8,scaleDivergingLog:()=>CX,scaleDivergingPow:()=>L8,scaleDivergingSqrt:()=>qwt,scaleDivergingSymlog:()=>AX,scaleIdentity:()=>u8,scaleImplicit:()=>l8,scaleLinear:()=>zn,scaleLog:()=>cc,scaleOrdinal:()=>gu,scalePoint:()=>eg,scalePow:()=>Z_,scaleQuantile:()=>rg,scaleQuantize:()=>qb,scaleSequential:()=>T8,scaleSequentialLog:()=>EX,scaleSequentialPow:()=>C8,scaleSequentialQuantile:()=>A8,scaleSequentialSqrt:()=>Uwt,scaleSequentialSymlog:()=>TX,scaleSqrt:()=>Y2t,scaleSymlog:()=>f8,scaleThreshold:()=>p8,scaleTime:()=>Yb,scaleUtc:()=>Vwt,scan:()=>l_t,schemeAccent:()=>Gwt,schemeBlues:()=>KX,schemeBrBG:()=>PX,schemeBuGn:()=>FX,schemeBuPu:()=>BX,schemeCategory10:()=>jb,schemeDark2:()=>Wwt,schemeGnBu:()=>HX,schemeGreens:()=>ZX,schemeGreys:()=>JX,schemeOrRd:()=>VX,schemeOranges:()=>e$,schemePRGn:()=>IX,schemePaired:()=>Ywt,schemePastel1:()=>jwt,schemePastel2:()=>Xwt,schemePiYG:()=>LX,schemePuBu:()=>qX,schemePuBuGn:()=>UX,schemePuOr:()=>kX,schemePuRd:()=>GX,schemePurples:()=>QX,schemeRdBu:()=>RX,schemeRdGy:()=>NX,schemeRdPu:()=>WX,schemeRdYlBu:()=>DX,schemeRdYlGn:()=>OX,schemeReds:()=>t$,schemeSet1:()=>$wt,schemeSet2:()=>Kwt,schemeSet3:()=>Zwt,schemeSpectral:()=>zX,schemeTableau10:()=>Jwt,schemeYlGn:()=>jX,schemeYlGnBu:()=>YX,schemeYlOrBr:()=>XX,schemeYlOrRd:()=>$X,select:()=>Ht,selectAll:()=>Tp,selection:()=>Lh,selector:()=>Dm,selectorAll:()=>cb,set:()=>o1t,shuffle:()=>c_t,stack:()=>A3t,stackOffsetDiverging:()=>I3t,stackOffsetExpand:()=>P3t,stackOffsetNone:()=>xu,stackOffsetSilhouette:()=>L3t,stackOffsetWiggle:()=>k3t,stackOrderAppearance:()=>Z8,stackOrderAscending:()=>J8,stackOrderDescending:()=>R3t,stackOrderInsideOut:()=>N3t,stackOrderNone:()=>bu,stackOrderReverse:()=>D3t,stratify:()=>y2t,style:()=>Mp,sum:()=>u_t,svg:()=>G1t,symbol:()=>ZSt,symbolCircle:()=>k5,symbolCross:()=>B8,symbolDiamond:()=>H8,symbolSquare:()=>U8,symbolStar:()=>V8,symbolTriangle:()=>q8,symbolWye:()=>G8,symbols:()=>KSt,text:()=>O_,thresholdFreedmanDiaconis:()=>n_t,thresholdScott:()=>i_t,thresholdSturges:()=>sb,tickFormat:()=>c8,tickIncrement:()=>b_,tickStep:()=>el,ticks:()=>ab,timeDay:()=>ey,timeDays:()=>Q2t,timeFormat:()=>M5,timeFormatDefaultLocale:()=>S8,timeFormatLocale:()=>S5,timeFriday:()=>uX,timeFridays:()=>iwt,timeHour:()=>y8,timeHours:()=>Z2t,timeInterval:()=>br,timeMillisecond:()=>J_,timeMilliseconds:()=>aX,timeMinute:()=>_8,timeMinutes:()=>$2t,timeMonday:()=>ny,timeMondays:()=>twt,timeMonth:()=>v8,timeMonths:()=>swt,timeParse:()=>wX,timeSaturday:()=>hX,timeSaturdays:()=>owt,timeSecond:()=>ty,timeSeconds:()=>sX,timeSunday:()=>ng,timeSundays:()=>fX,timeThursday:()=>Fp,timeThursdays:()=>nwt,timeTuesday:()=>lX,timeTuesdays:()=>ewt,timeWednesday:()=>cX,timeWednesdays:()=>rwt,timeWeek:()=>ng,timeWeeks:()=>fX,timeYear:()=>Wh,timeYears:()=>lwt,timeout:()=>zE,timer:()=>P_,timerFlush:()=>gY,touch:()=>Cp,touches:()=>lyt,transition:()=>PL,transpose:()=>Y9,tree:()=>v2t,treemap:()=>x2t,treemapBinary:()=>b2t,treemapDice:()=>qh,treemapResquarify:()=>S2t,treemapSlice:()=>Qm,treemapSliceDice:()=>w2t,treemapSquarify:()=>o8,tsv:()=>B1t,tsvFormat:()=>A1t,tsvFormatBody:()=>P1t,tsvFormatRow:()=>L1t,tsvFormatRows:()=>I1t,tsvFormatValue:()=>k1t,tsvParse:()=>Ab,tsvParseRows:()=>C1t,utcDay:()=>iy,utcDays:()=>dwt,utcFormat:()=>sy,utcFriday:()=>gX,utcFridays:()=>vwt,utcHour:()=>b8,utcHours:()=>fwt,utcMillisecond:()=>J_,utcMilliseconds:()=>aX,utcMinute:()=>x8,utcMinutes:()=>uwt,utcMonday:()=>ay,utcMondays:()=>mwt,utcMonth:()=>w8,utcMonths:()=>wwt,utcParse:()=>E5,utcSaturday:()=>_X,utcSaturdays:()=>xwt,utcSecond:()=>ty,utcSeconds:()=>sX,utcSunday:()=>ig,utcSundays:()=>yX,utcThursday:()=>Bp,utcThursdays:()=>ywt,utcTuesday:()=>dX,utcTuesdays:()=>gwt,utcWednesday:()=>mX,utcWednesdays:()=>_wt,utcWeek:()=>ig,utcWeeks:()=>yX,utcYear:()=>Yh,utcYears:()=>Swt,values:()=>l1t,variance:()=>G9,version:()=>j0t,voronoi:()=>K3t,window:()=>hb,xml:()=>U1t,zip:()=>h_t,zoom:()=>eR,zoomIdentity:()=>$h,zoomTransform:()=>i2});var j0t="5.7.0";function aa(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function ob(e){return e.length===1&&(e=l2e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function l2e(e){return function(t,r){return aa(e(t),r)}}var X0t=ob(aa),WW=X0t.right,$0t=X0t.left,vs=WW;function K0t(e,t){t==null&&(t=YW);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function YW(e,t){return[e,t]}function q9(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=YW),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}function Z0t(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function tl(e){return e===null?NaN:+e}function G9(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=tl(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=tl(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}function W9(e,t){var r=G9(e,t);return r&&Math.sqrt(r)}function sa(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var J0t=Array.prototype,Q0t=J0t.slice,t_t=J0t.map;function bE(e){return function(){return e}}function e_t(e){return e}function Ir(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var jW=Math.sqrt(50),XW=Math.sqrt(10),$W=Math.sqrt(2);function ab(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=b_(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function b_(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=jW?10:o>=XW?5:o>=$W?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=jW?10:o>=XW?5:o>=$W?2:1)}function el(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=jW?i*=10:o>=XW?i*=5:o>=$W&&(i*=2),t<e?-i:i}function sb(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}function r_t(){var e=e_t,t=sa,r=sb;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=el(u,h,f),f=Ir(Math.ceil(u/f)*f,h,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[vs(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:bE(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:bE([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?bE(Q0t.call(i)):bE(i),n):r},n}function la(e,t,r){if(r==null&&(r=tl),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}function n_t(e,t,r){return e=t_t.call(e,tl).sort(aa),Math.ceil((r-t)/(2*(la(e,.75)-la(e,.25))*Math.pow(e.length,-1/3)))}function i_t(e,t,r){return Math.ceil((r-t)/(3.5*W9(e)*Math.pow(e.length,-1/3)))}function lu(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}function o_t(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=tl(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=tl(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}function a_t(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=tl(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=tl(t(e[n],n,e)))||o.push(i);return la(o.sort(aa),.5)}function Lm(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}function km(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}function s_t(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}function l_t(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=aa);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}function c_t(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}function u_t(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}function Y9(e){if(!(o=e.length))return[];for(var t=-1,r=km(e,c2e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function c2e(e){return e.length}function h_t(){return Y9(arguments)}var j9=Array.prototype.slice;function f_t(e){return e}var X9=1,$9=2,KW=3,wE=4,p_t=1e-6;function u2e(e){return"translate("+(e+.5)+",0)"}function h2e(e){return"translate(0,"+(e+.5)+")"}function f2e(e){return function(t){return+e(t)}}function p2e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function d2e(){return!this.__axis}function K9(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===X9||e===wE?-1:1,c=e===wE||e===$9?"x":"y",u=e===X9||e===KW?u2e:h2e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):f_t:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?p2e:f2e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","currentColor").attr(c,l*g).attr("dy",e===X9?"0em":e===KW?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",p_t).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",p_t).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===wE||e==$9?a?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M0.5,"+y+"V"+x:a?"M"+y+","+l*a+"V0.5H"+x+"V"+l*a:"M"+y+",0.5H"+x),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(d2e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===$9?"start":e===wE?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=j9.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:j9.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:j9.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function d_t(e){return K9(X9,e)}function m_t(e){return K9($9,e)}function Z9(e){return K9(KW,e)}function lb(e){return K9(wE,e)}Rm();Rm();var Q9="http://www.w3.org/1999/xhtml",SE={svg:"http://www.w3.org/2000/svg",xhtml:Q9,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Ih(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),SE.hasOwnProperty(t)?{space:SE[t],local:e}:e}function y2e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Q9&&t.documentElement.namespaceURI===Q9?t.createElement(e):t.createElementNS(r,e)}}function v2e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Nm(e){var t=Ih(e);return(t.local?v2e:y2e)(t)}function x2e(){}function Dm(e){return e==null?x2e:function(){return this.querySelector(e)}}function v_t(e){typeof e!="function"&&(e=Dm(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Dn(n,this._parents)}function b2e(){return[]}function cb(e){return e==null?b2e:function(){return this.querySelectorAll(e)}}function x_t(e){typeof e!="function"&&(e=cb(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Dn(n,i)}function ub(e){return function(){return this.matches(e)}}function b_t(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Dn(n,this._parents)}function tL(e){return new Array(e.length)}function w_t(){return new Dn(this._enter||this._groups.map(tL),this._parents)}function ME(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}ME.prototype={constructor:ME,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}};function S_t(e){return function(){return e}}var M_t="$";function w2e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new ME(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function S2e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=M_t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=M_t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new ME(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function E_t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?S2e:w2e,n=this._parents,i=this._groups;typeof e!="function"&&(e=S_t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Dn(a,n),a._enter=s,a._exit=l,a}function T_t(){return new Dn(this._exit||this._groups.map(tL),this._parents)}function C_t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}function A_t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Dn(a,this._parents)}function P_t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}function I_t(e){e||(e=M2e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Dn(i,this._parents).order()}function M2e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function L_t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function k_t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}function R_t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}function N_t(){var e=0;return this.each(function(){++e}),e}function D_t(){return!this.node()}function O_t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}function E2e(e){return function(){this.removeAttribute(e)}}function T2e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function C2e(e,t){return function(){this.setAttribute(e,t)}}function A2e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function P2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function I2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function z_t(e,t){var r=Ih(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?T2e:E2e:typeof t=="function"?r.local?I2e:P2e:r.local?A2e:C2e)(r,t))}function hb(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}function L2e(e){return function(){this.style.removeProperty(e)}}function k2e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function R2e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function F_t(e,t,r){return arguments.length>1?this.each((t==null?L2e:typeof t=="function"?R2e:k2e)(e,t,r==null?"":r)):Mp(this.node(),e)}function Mp(e,t){return e.style.getPropertyValue(t)||hb(e).getComputedStyle(e,null).getPropertyValue(t)}function N2e(e){return function(){delete this[e]}}function D2e(e,t){return function(){this[e]=t}}function O2e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function B_t(e,t){return arguments.length>1?this.each((t==null?N2e:typeof t=="function"?O2e:D2e)(e,t)):this.node()[e]}function H_t(e){return e.trim().split(/^|\s+/)}function ZW(e){return e.classList||new V_t(e)}function V_t(e){this._node=e,this._names=H_t(e.getAttribute("class")||"")}V_t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}};function U_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function q_t(e,t){for(var r=ZW(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function z2e(e){return function(){U_t(this,e)}}function F2e(e){return function(){q_t(this,e)}}function B2e(e,t){return function(){(t.apply(this,arguments)?U_t:q_t)(this,e)}}function G_t(e,t){var r=H_t(e+"");if(arguments.length<2){for(var n=ZW(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?B2e:t?z2e:F2e)(r,t))}function H2e(){this.textContent=""}function V2e(e){return function(){this.textContent=e}}function U2e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function W_t(e){return arguments.length?this.each(e==null?H2e:(typeof e=="function"?U2e:V2e)(e)):this.node().textContent}function q2e(){this.innerHTML=""}function G2e(e){return function(){this.innerHTML=e}}function W2e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Y_t(e){return arguments.length?this.each(e==null?q2e:(typeof e=="function"?W2e:G2e)(e)):this.node().innerHTML}function Y2e(){this.nextSibling&&this.parentNode.appendChild(this)}function j_t(){return this.each(Y2e)}function j2e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function X_t(){return this.each(j2e)}function $_t(e){var t=typeof e=="function"?e:Nm(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function X2e(){return null}function K_t(e,t){var r=typeof e=="function"?e:Nm(e),n=t==null?X2e:typeof t=="function"?t:Dm(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}function $2e(){var e=this.parentNode;e&&e.removeChild(this)}function Z_t(){return this.each($2e)}function K2e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Z2e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function J_t(e){return this.select(e?Z2e:K2e)}function Q_t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var eyt={},qt=null;typeof document!="undefined"&&(tyt=document.documentElement,"onmouseenter"in tyt||(eyt={mouseenter:"mouseover",mouseleave:"mouseout"}));var tyt;function J2e(e,t,r){return e=ryt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function ryt(e,t,r){return function(n){var i=qt;qt=n;try{e.call(this,this.__data__,t,r)}finally{qt=i}}}function Q2e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function twe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function ewe(e,t,r){var n=eyt.hasOwnProperty(e.type)?J2e:ryt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function nyt(e,t,r){var n=Q2e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?ewe:twe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Ep(e,t,r,n){var i=qt;e.sourceEvent=qt,qt=e;try{return t.apply(r,n)}finally{qt=i}}function iyt(e,t,r){var n=hb(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function rwe(e,t){return function(){return iyt(this,e,t)}}function nwe(e,t){return function(){return iyt(this,e,t.apply(this,arguments))}}function oyt(e,t){return this.each((typeof t=="function"?nwe:rwe)(e,t))}var EE=[null];function Dn(e,t){this._groups=e,this._parents=t}function ayt(){return new Dn([[document.documentElement]],EE)}Dn.prototype=ayt.prototype={constructor:Dn,select:v_t,selectAll:x_t,filter:b_t,data:E_t,enter:w_t,exit:T_t,join:C_t,merge:A_t,order:P_t,sort:I_t,call:L_t,nodes:k_t,node:R_t,size:N_t,empty:D_t,each:O_t,attr:z_t,style:F_t,property:B_t,classed:G_t,text:W_t,html:Y_t,raise:j_t,lower:X_t,append:$_t,insert:K_t,remove:Z_t,clone:J_t,datum:Q_t,on:nyt,dispatch:oyt};var Lh=ayt;function Ht(e){return typeof e=="string"?new Dn([[document.querySelector(e)]],[document.documentElement]):new Dn([[e]],EE)}function syt(e){return Ht(Nm(e).call(document.documentElement))}var iwe=0;function eL(){return new JW}function JW(){this._="@"+(++iwe).toString(36)}JW.prototype=eL.prototype={constructor:JW,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}};function fb(){for(var e=qt,t;t=e.sourceEvent;)e=t;return e}function Om(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}function zo(e){var t=fb();return t.changedTouches&&(t=t.changedTouches[0]),Om(e,t)}function Tp(e){return typeof e=="string"?new Dn([document.querySelectorAll(e)],[document.documentElement]):new Dn([e==null?[]:e],EE)}function Cp(e,t,r){arguments.length<3&&(r=t,t=fb().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Om(e,o);return null}function lyt(e,t){t==null&&(t=fb().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Om(e,t[r]);return i}function rL(){qt.stopImmediatePropagation()}function zm(){qt.preventDefault(),qt.stopImmediatePropagation()}function Fm(e){var t=e.document.documentElement,r=Ht(e).on("dragstart.drag",zm,!0);"onselectstart"in t?r.on("selectstart.drag",zm,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Bm(e,t){var r=e.document.documentElement,n=Ht(e).on("dragstart.drag",null);t&&(n.on("click.drag",zm,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}function TE(e){return function(){return e}}function CE(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}CE.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e};function owe(){return!qt.ctrlKey&&!qt.button}function awe(){return this.parentNode}function swe(e){return e==null?{x:qt.x,y:qt.y}:e}function lwe(){return navigator.maxTouchPoints||"ontouchstart"in this}function pb(){var e=owe,t=awe,r=swe,n=lwe,i={},o=xs("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),zo,this,arguments);!S||(Ht(qt.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),Fm(qt.view),rL(),c=!1,s=qt.clientX,l=qt.clientY,S("start"))}}function d(){if(zm(),!c){var S=qt.clientX-s,C=qt.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ht(qt.view).on("mousemove.drag mouseup.drag",null),Bm(qt.view,c),zm(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=qt.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,Cp,this,arguments))&&(rL(),O("start"))}}function y(){var S=qt.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(zm(),k("drag"))}function x(){var S=qt.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(rL(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!Ep(new CE(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(qt.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}Ep(new CE(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:TE(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:TE(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:TE(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:TE(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}function Ap(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Hm(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}function Nh(){}var Vm=.7,w_=1/Vm,db="\\s*([+-]?\\d+)\\s*",AE="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Rh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",cwe=/^#([0-9a-f]{3,8})$/,uwe=new RegExp("^rgb\\("+[db,db,db]+"\\)$"),hwe=new RegExp("^rgb\\("+[Rh,Rh,Rh]+"\\)$"),fwe=new RegExp("^rgba\\("+[db,db,db,AE]+"\\)$"),pwe=new RegExp("^rgba\\("+[Rh,Rh,Rh,AE]+"\\)$"),dwe=new RegExp("^hsl\\("+[AE,Rh,Rh]+"\\)$"),mwe=new RegExp("^hsla\\("+[AE,Rh,Rh,AE]+"\\)$"),cyt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Ap(Nh,rc,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:uyt,formatHex:uyt,formatHsl:gwe,formatRgb:hyt,toString:hyt});function uyt(){return this.rgb().formatHex()}function gwe(){return gyt(this).formatHsl()}function hyt(){return this.rgb().formatRgb()}function rc(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=cwe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?fyt(t):r===3?new Ki(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?nL(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?nL(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=uwe.exec(e))?new Ki(t[1],t[2],t[3],1):(t=hwe.exec(e))?new Ki(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=fwe.exec(e))?nL(t[1],t[2],t[3],t[4]):(t=pwe.exec(e))?nL(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=dwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,1):(t=mwe.exec(e))?myt(t[1],t[2]/100,t[3]/100,t[4]):cyt.hasOwnProperty(e)?fyt(cyt[e]):e==="transparent"?new Ki(NaN,NaN,NaN,0):null}function fyt(e){return new Ki(e>>16&255,e>>8&255,e&255,1)}function nL(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ki(e,t,r,n)}function PE(e){return e instanceof Nh||(e=rc(e)),e?(e=e.rgb(),new Ki(e.r,e.g,e.b,e.opacity)):new Ki}function cu(e,t,r,n){return arguments.length===1?PE(e):new Ki(e,t,r,n==null?1:n)}function Ki(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}Ap(Ki,cu,Hm(Nh,{brighter:function(e){return e=e==null?w_:Math.pow(w_,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Vm:Math.pow(Vm,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:pyt,formatHex:pyt,formatRgb:dyt,toString:dyt}));function pyt(){return"#"+QW(this.r)+QW(this.g)+QW(this.b)}function dyt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function QW(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function myt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new kh(e,t,r,n)}function gyt(e){if(e instanceof kh)return new kh(e.h,e.s,e.l,e.opacity);if(e instanceof Nh||(e=rc(e)),!e)return new kh;if(e instanceof kh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new kh(a,s,l,e.opacity)}function Um(e,t,r,n){return arguments.length===1?gyt(e):new kh(e,t,r,n==null?1:n)}function kh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Ap(kh,Um,Hm(Nh,{brighter:function(e){return e=e==null?w_:Math.pow(w_,e),new kh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Vm:Math.pow(Vm,e),new kh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ki(tY(e>=240?e-240:e+120,i,n),tY(e,i,n),tY(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}));function tY(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var iL=Math.PI/180,oL=180/Math.PI;var aL=18,_yt=.96422,yyt=1,vyt=.82521,xyt=4/29,mb=6/29,byt=3*mb*mb,_we=mb*mb*mb;function wyt(e){if(e instanceof uu)return new uu(e.l,e.a,e.b,e.opacity);if(e instanceof Dh)return Tyt(e);e instanceof Ki||(e=PE(e));var t=iY(e.r),r=iY(e.g),n=iY(e.b),i=eY((.2225045*t+.7168786*r+.0606169*n)/yyt),o,a;return t===r&&r===n?o=a=i:(o=eY((.4360747*t+.3850649*r+.1430804*n)/_yt),a=eY((.0139322*t+.0971045*r+.7141733*n)/vyt)),new uu(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Syt(e,t){return new uu(e,0,0,t==null?1:t)}function S_(e,t,r,n){return arguments.length===1?wyt(e):new uu(e,t,r,n==null?1:n)}function uu(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}Ap(uu,S_,Hm(Nh,{brighter:function(e){return new uu(this.l+aL*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new uu(this.l-aL*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=_yt*rY(t),e=yyt*rY(e),r=vyt*rY(r),new Ki(nY(3.1338561*t-1.6168667*e-.4906146*r),nY(-.9787684*t+1.9161415*e+.033454*r),nY(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));function eY(e){return e>_we?Math.pow(e,1/3):e/byt+xyt}function rY(e){return e>mb?e*e*e:byt*(e-xyt)}function nY(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function iY(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function Myt(e){if(e instanceof Dh)return new Dh(e.h,e.c,e.l,e.opacity);if(e instanceof uu||(e=wyt(e)),e.a===0&&e.b===0)return new Dh(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*oL;return new Dh(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function Eyt(e,t,r,n){return arguments.length===1?Myt(e):new Dh(r,t,e,n==null?1:n)}function gb(e,t,r,n){return arguments.length===1?Myt(e):new Dh(e,t,r,n==null?1:n)}function Dh(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function Tyt(e){if(isNaN(e.h))return new uu(e.l,0,0,e.opacity);var t=e.h*iL;return new uu(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}Ap(Dh,gb,Hm(Nh,{brighter:function(e){return new Dh(this.h,this.c,this.l+aL*(e==null?1:e),this.opacity)},darker:function(e){return new Dh(this.h,this.c,this.l-aL*(e==null?1:e),this.opacity)},rgb:function(){return Tyt(this).rgb()}}));var Iyt=-.14861,oY=1.78277,aY=-.29227,sL=-.90649,IE=1.97294,Cyt=IE*sL,Ayt=IE*oY,Pyt=oY*aY-sL*Iyt;function ywe(e){if(e instanceof M_)return new M_(e.h,e.s,e.l,e.opacity);e instanceof Ki||(e=PE(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(Pyt*n+Cyt*t-Ayt*r)/(Pyt+Cyt-Ayt),o=n-i,a=(IE*(r-i)-aY*o)/sL,s=Math.sqrt(a*a+o*o)/(IE*i*(1-i)),l=s?Math.atan2(a,o)*oL-120:NaN;return new M_(l<0?l+360:l,s,i,e.opacity)}function ca(e,t,r,n){return arguments.length===1?ywe(e):new M_(e,t,r,n==null?1:n)}function M_(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Ap(M_,ca,Hm(Nh,{brighter:function(e){return e=e==null?w_:Math.pow(w_,e),new M_(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Vm:Math.pow(Vm,e),new M_(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*iL,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new Ki(255*(t+r*(Iyt*n+oY*i)),255*(t+r*(aY*n+sL*i)),255*(t+r*(IE*n)),this.opacity)}}));function sY(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function lL(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return sY((r-n/t)*t,a,i,o,s)}}function cL(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return sY((r-n/t)*t,i,o,a,s)}}function _b(e){return function(){return e}}function Lyt(e,t){return function(r){return e+r*t}}function vwe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function qm(e,t){var r=t-e;return r?Lyt(e,r>180||r<-180?r-360*Math.round(r/360):r):_b(isNaN(e)?t:e)}function kyt(e){return(e=+e)==1?Zn:function(t,r){return r-t?vwe(t,r,e):_b(isNaN(t)?r:t)}}function Zn(e,t){var r=t-e;return r?Lyt(e,r):_b(isNaN(e)?t:e)}var Gm=function e(t){var r=kyt(t);function n(i,o){var a=r((i=cu(i)).r,(o=cu(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Zn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);function Ryt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=cu(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var uL=Ryt(lL),Nyt=Ryt(cL);function yb(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function hL(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Dyt(e,t){return(hL(t)?yb:lY)(e,t)}function lY(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nc(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}function fL(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}function zi(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}function pL(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nc(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var uY=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,cY=new RegExp(uY.source,"g");function xwe(e){return function(){return e}}function bwe(e){return function(t){return e(t)+""}}function vb(e,t){var r=uY.lastIndex=cY.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=uY.exec(e))&&(i=cY.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:zi(n,i)})),r=cY.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?bwe(l[0].x):xwe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}function nc(e,t){var r=typeof t,n;return t==null||r==="boolean"?_b(t):(r==="number"?zi:r==="string"?(n=rc(t))?(t=n,Gm):vb:t instanceof rc?Gm:t instanceof Date?fL:hL(t)?yb:Array.isArray(t)?lY:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?pL:zi)(e,t)}function Oyt(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}function zyt(e,t){var r=qm(+e,+t);return function(n){var i=r(n);return i-360*Math.floor(i/360)}}function dL(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var Fyt=180/Math.PI,mL={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function hY(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Fyt,skewX:Math.atan(l)*Fyt,scaleX:a,scaleY:s}}var LE,fY,Byt,gL;function Hyt(e){return e==="none"?mL:(LE||(LE=document.createElement("DIV"),fY=document.documentElement,Byt=document.defaultView),LE.style.transform=e,e=Byt.getComputedStyle(fY.appendChild(LE),null).getPropertyValue("transform"),fY.removeChild(LE),e=e.slice(7,-1).split(","),hY(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Vyt(e){return e==null?mL:(gL||(gL=document.createElementNS("http://www.w3.org/2000/svg","g")),gL.setAttribute("transform",e),(e=gL.transform.baseVal.consolidate())?(e=e.matrix,hY(e.a,e.b,e.c,e.d,e.e,e.f)):mL)}function Uyt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:zi(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:zi(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var _L=Uyt(Hyt,"px, ","px)","deg)"),yL=Uyt(Vyt,", ",")",")");var kE=Math.SQRT2,pY=2,qyt=4,wwe=1e-12;function Gyt(e){return((e=Math.exp(e))+1/e)/2}function Swe(e){return((e=Math.exp(e))-1/e)/2}function Mwe(e){return((e=Math.exp(2*e))-1)/(e+1)}function vL(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<wwe)f=Math.log(s/i)/kE,h=function(x){return[r+x*l,n+x*c,i*Math.exp(kE*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+qyt*u)/(2*i*pY*p),g=(s*s-i*i-qyt*u)/(2*s*pY*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/kE,h=function(x){var b=x*f,S=Gyt(_),C=i/(pY*p)*(S*Mwe(kE*b+_)-Swe(_));return[r+C*l,n+C*c,i*S/Gyt(kE*b+_)]}}return h.duration=f*1e3,h}function Wyt(e){return function(t,r){var n=e((t=Um(t)).h,(r=Um(r)).h),i=Zn(t.s,r.s),o=Zn(t.l,r.l),a=Zn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var Yyt=Wyt(qm),jyt=Wyt(Zn);function E_(e,t){var r=Zn((e=S_(e)).l,(t=S_(t)).l),n=Zn(e.a,t.a),i=Zn(e.b,t.b),o=Zn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}function Xyt(e){return function(t,r){var n=e((t=gb(t)).h,(r=gb(r)).h),i=Zn(t.c,r.c),o=Zn(t.l,r.l),a=Zn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var $yt=Xyt(qm),Kyt=Xyt(Zn);function Zyt(e){return function t(r){r=+r;function n(i,o){var a=e((i=ca(i)).h,(o=ca(o)).h),s=Zn(i.s,o.s),l=Zn(i.l,o.l),c=Zn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var Jyt=Zyt(qm),T_=Zyt(Zn);function dY(e,t){for(var r=0,n=t.length-1,i=t[0],o=new Array(n<0?0:n);r<n;)o[r]=e(i,i=t[++r]);return function(a){var s=Math.max(0,Math.min(n-1,Math.floor(a*=n)));return o[s](a-s)}}function Qyt(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}Rm();var xb=0,NE=0,RE=0,evt=1e3,xL,DE,bL=0,C_=0,wL=0,OE=typeof performance=="object"&&performance.now?performance:Date,rvt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};function Pp(){return C_||(rvt(Ewe),C_=OE.now()+wL)}function Ewe(){C_=0}function A_(){this._call=this._time=this._next=null}A_.prototype=P_.prototype={constructor:A_,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Pp():+r)+(t==null?0:+t),!this._next&&DE!==this&&(DE?DE._next=this:xL=this,DE=this),this._call=e,this._time=r,mY()},stop:function(){this._call&&(this._call=null,this._time=1/0,mY())}};function P_(e,t,r){var n=new A_;return n.restart(e,t,r),n}function gY(){Pp(),++xb;for(var e=xL,t;e;)(t=C_-e._time)>=0&&e._call.call(null,t),e=e._next;--xb}function tvt(){C_=(bL=OE.now())+wL,xb=NE=0;try{gY()}finally{xb=0,Cwe(),C_=0}}function Twe(){var e=OE.now(),t=e-bL;t>evt&&(wL-=t,bL=e)}function Cwe(){for(var e,t=xL,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:xL=r);DE=e,mY(n)}function mY(e){if(!xb){NE&&(NE=clearTimeout(NE));var t=e-C_;t>24?(e<1/0&&(NE=setTimeout(tvt,e-OE.now()-wL)),RE&&(RE=clearInterval(RE))):(RE||(bL=OE.now(),RE=setInterval(Twe,evt)),xb=1,rvt(tvt))}}function zE(e,t,r){var n=new A_;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}function nvt(e,t,r){var n=new A_,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Pp():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var Awe=xs("start","end","cancel","interrupt"),Pwe=[],ovt=0,ML=1,EL=2,SL=3,ivt=4,TL=5,FE=6;function Wm(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;Iwe(e,r,{name:t,index:n,group:i,on:Awe,tween:Pwe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:ovt})}function BE(e,t){var r=Zi(e,t);if(r.state>ovt)throw new Error("too late; already scheduled");return r}function za(e,t){var r=Zi(e,t);if(r.state>SL)throw new Error("too late; already running");return r}function Zi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function Iwe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=P_(o,0,r.time);function o(c){r.state=ML,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==ML)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===SL)return zE(a);p.state===ivt?(p.state=FE,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=FE,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(zE(function(){r.state===SL&&(r.state=ivt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=EL,r.on.call("start",e,e.__data__,r.index,r.group),r.state===EL){for(r.state=SL,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=TL,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===TL&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=FE,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}function hu(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>EL&&n.state<TL,n.state=FE,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}function avt(e){return this.each(function(){hu(this,e)})}function Lwe(e,t){var r,n;return function(){var i=za(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function kwe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=za(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function svt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Zi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?Lwe:kwe)(r,e,t))}function bb(e,t,r){var n=e._id;return e.each(function(){var i=za(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Zi(i,n).value[t]}}function CL(e,t){var r;return(typeof t=="number"?zi:t instanceof rc?Gm:(r=rc(t))?(t=r,Gm):vb)(e,t)}function Rwe(e){return function(){this.removeAttribute(e)}}function Nwe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function Dwe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function Owe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function zwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function Fwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function lvt(e,t){var r=Ih(e),n=r==="transform"?yL:CL;return this.attrTween(e,typeof t=="function"?(r.local?Fwe:zwe)(r,n,bb(this,"attr."+e,t)):t==null?(r.local?Nwe:Rwe)(r):(r.local?Owe:Dwe)(r,n,t))}function Bwe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function Hwe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function Vwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Hwe(e,o)),r}return i._value=t,i}function Uwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Bwe(e,o)),r}return i._value=t,i}function cvt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Ih(e);return this.tween(r,(n.local?Vwe:Uwe)(n,t))}function qwe(e,t){return function(){BE(this,e).delay=+t.apply(this,arguments)}}function Gwe(e,t){return t=+t,function(){BE(this,e).delay=t}}function uvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?qwe:Gwe)(t,e)):Zi(this.node(),t).delay}function Wwe(e,t){return function(){za(this,e).duration=+t.apply(this,arguments)}}function Ywe(e,t){return t=+t,function(){za(this,e).duration=t}}function hvt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?Wwe:Ywe)(t,e)):Zi(this.node(),t).duration}function jwe(e,t){if(typeof t!="function")throw new Error;return function(){za(this,e).ease=t}}function fvt(e){var t=this._id;return arguments.length?this.each(jwe(t,e)):Zi(this.node(),t).ease}function pvt(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Fo(n,this._parents,this._name,this._id)}function dvt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Fo(a,this._parents,this._name,this._id)}function Xwe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function $we(e,t,r){var n,i,o=Xwe(t)?BE:za;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function mvt(e,t){var r=this._id;return arguments.length<2?Zi(this.node(),r).on.on(e):this.each($we(r,e,t))}function Kwe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function gvt(){return this.on("end.remove",Kwe(this._id))}function _vt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Dm(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Wm(c[f],t,r,f,c,Zi(u,r)));return new Fo(o,this._parents,t,r)}function yvt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=cb(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Zi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Wm(p,t,r,g,f,d);o.push(f),a.push(u)}return new Fo(o,a,t,r)}var Zwe=Lh.prototype.constructor;function vvt(){return new Zwe(this._groups,this._parents)}function Jwe(e,t){var r,n,i;return function(){var o=Mp(this,e),a=(this.style.removeProperty(e),Mp(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function xvt(e){return function(){this.style.removeProperty(e)}}function Qwe(e,t,r){var n,i=r+"",o;return function(){var a=Mp(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function tSe(e,t,r){var n,i,o;return function(){var a=Mp(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Mp(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function eSe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=za(this,e),c=l.on,u=l.value[o]==null?s||(s=xvt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function bvt(e,t,r){var n=(e+="")=="transform"?_L:CL;return t==null?this.styleTween(e,Jwe(e,n)).on("end.style."+e,xvt(e)):typeof t=="function"?this.styleTween(e,tSe(e,n,bb(this,"style."+e,t))).each(eSe(this._id,e)):this.styleTween(e,Qwe(e,n,t),r).on("end.style."+e,null)}function rSe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function nSe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&rSe(e,a,r)),n}return o._value=t,o}function wvt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,nSe(e,t,r==null?"":r))}function iSe(e){return function(){this.textContent=e}}function oSe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function Svt(e){return this.tween("text",typeof e=="function"?oSe(bb(this,"text",e)):iSe(e==null?"":e+""))}function aSe(e){return function(t){this.textContent=e.call(this,t)}}function sSe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&aSe(i)),t}return n._value=e,n}function Mvt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,sSe(e))}function Evt(){for(var e=this._name,t=this._id,r=AL(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Zi(l,t);Wm(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Fo(n,this._parents,e,r)}function Tvt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=za(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var lSe=0;function Fo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function PL(e){return Lh().transition(e)}function AL(){return++lSe}var wb=Lh.prototype;Fo.prototype=PL.prototype={constructor:Fo,select:_vt,selectAll:yvt,filter:pvt,merge:dvt,selection:vvt,transition:Evt,call:wb.call,nodes:wb.nodes,node:wb.node,size:wb.size,empty:wb.empty,each:wb.each,on:mvt,attr:lvt,attrTween:cvt,style:bvt,styleTween:wvt,text:Svt,textTween:Mvt,remove:gvt,tween:svt,delay:uvt,duration:hvt,ease:fvt,end:Tvt};L_();var UY={time:null,delay:0,duration:250,ease:bs};function _Se(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return UY.time=Pp(),UY;return r}function Hvt(e){var t,r;e instanceof Fo?(t=e._id,e=e._name):(t=AL(),(r=UY).time=Pp(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Wm(l,e,t,c,a,r||_Se(l,t));return new Fo(n,this._parents,e,t)}Lh.prototype.interrupt=avt;Lh.prototype.transition=Hvt;var ySe=[null];function Vvt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>ML&&n.name===t)return new Fo([[e]],ySe,t,+i)}return null}function FL(e){return function(){return e}}function Uvt(e,t,r){this.target=e,this.type=t,this.selection=r}function qY(){qt.stopImmediatePropagation()}function BL(){qt.preventDefault(),qt.stopImmediatePropagation()}var qvt={name:"drag"},GY={name:"space"},Mb={name:"handle"},Eb={name:"center"};function Gvt(e){return[+e[0],+e[1]]}function YY(e){return[Gvt(e[0]),Gvt(e[1])]}function vSe(e){return function(t){return Cp(t,qt.touches,e)}}var HL={name:"x",handles:["w","e"].map(HE),input:function(e,t){return e==null?null:[[+e[0],t[0][1]],[+e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},VL={name:"y",handles:["n","s"].map(HE),input:function(e,t){return e==null?null:[[t[0][0],+e[0]],[t[1][0],+e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},xSe={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(HE),input:function(e){return e==null?null:YY(e)},output:function(e){return e}},Ip={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Wvt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Yvt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},bSe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},wSe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function HE(e){return{type:e}}function SSe(){return!qt.ctrlKey&&!qt.button}function MSe(){var e=this.ownerSVGElement||this;return e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function ESe(){return navigator.maxTouchPoints||"ontouchstart"in this}function WY(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function TSe(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function UL(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function jvt(){return jY(HL)}function qL(){return jY(VL)}function GL(){return jY(xSe)}function jY(e){var t=MSe,r=SSe,n=ESe,i=!0,o=xs("start","brush","end"),a=6,s;function l(_){var y=_.property("__brush",g).selectAll(".overlay").data([HE("overlay")]);y.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Ip.overlay).merge(y).each(function(){var b=WY(this).extent;Ht(this).attr("x",b[0][0]).attr("y",b[0][1]).attr("width",b[1][0]-b[0][0]).attr("height",b[1][1]-b[0][1])}),_.selectAll(".selection").data([HE("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Ip.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var x=_.selectAll(".handle").data(e.handles,function(b){return b.type});x.exit().remove(),x.enter().append("rect").attr("class",function(b){return"handle handle--"+b.type}).attr("cursor",function(b){return Ip[b.type]}),_.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",f).filter(n).on("touchstart.brush",f).on("touchmove.brush",p).on("touchend.brush touchcancel.brush",d).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}l.move=function(_,y){_.selection?_.on("start.brush",function(){u(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){u(this,arguments).end()}).tween("brush",function(){var x=this,b=x.__brush,S=u(x,arguments),C=b.selection,P=e.input(typeof y=="function"?y.apply(this,arguments):y,b.extent),k=nc(C,P);function O(D){b.selection=D===1&&P===null?null:k(D),c.call(x),S.brush()}return C!==null&&P!==null?O:O(1)}):_.each(function(){var x=this,b=arguments,S=x.__brush,C=e.input(typeof y=="function"?y.apply(x,b):y,S.extent),P=u(x,b).beforestart();hu(x),S.selection=C===null?null:C,c.call(x),P.start().brush().end()})},l.clear=function(_){l.move(_,null)};function c(){var _=Ht(this),y=WY(this).selection;y?(_.selectAll(".selection").style("display",null).attr("x",y[0][0]).attr("y",y[0][1]).attr("width",y[1][0]-y[0][0]).attr("height",y[1][1]-y[0][1]),_.selectAll(".handle").style("display",null).attr("x",function(x){return x.type[x.type.length-1]==="e"?y[1][0]-a/2:y[0][0]-a/2}).attr("y",function(x){return x.type[0]==="s"?y[1][1]-a/2:y[0][1]-a/2}).attr("width",function(x){return x.type==="n"||x.type==="s"?y[1][0]-y[0][0]+a:a}).attr("height",function(x){return x.type==="e"||x.type==="w"?y[1][1]-y[0][1]+a:a})):_.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(_,y,x){var b=_.__brush.emitter;return b&&(!x||!b.clean)?b:new h(_,y,x)}function h(_,y,x){this.that=_,this.args=y,this.state=_.__brush,this.active=0,this.clean=x}h.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(_){Ep(new Uvt(l,_,e.output(this.state.selection)),o.apply,o,[_,this.that,this.args])}};function f(){if(s&&!qt.touches||!r.apply(this,arguments))return;var _=this,y=qt.target.__data__.type,x=(i&&qt.metaKey?y="overlay":y)==="selection"?qvt:i&&qt.altKey?Eb:Mb,b=e===VL?null:bSe[y],S=e===HL?null:wSe[y],C=WY(_),P=C.extent,k=C.selection,O=P[0][0],D,B,I=P[0][1],L,R,F=P[1][0],z,U,W=P[1][1],Z,rt,ot=0,st=0,St,bt=b&&S&&i&&qt.shiftKey,Mt,lt,Kt=qt.touches?vSe(qt.changedTouches[0].identifier):zo,_t=Kt(_),ct=_t,X=u(_,arguments,!0).beforestart();y==="overlay"?(k&&(St=!0),C.selection=k=[[D=e===VL?O:_t[0],L=e===HL?I:_t[1]],[z=e===VL?F:D,Z=e===HL?W:L]]):(D=k[0][0],L=k[0][1],z=k[1][0],Z=k[1][1]),B=D,R=L,U=z,rt=Z;var et=Ht(_).attr("pointer-events","none"),dt=et.selectAll(".overlay").attr("cursor",Ip[y]);if(qt.touches)X.moved=pt,X.ended=wt;else{var q=Ht(qt.view).on("mousemove.brush",pt,!0).on("mouseup.brush",wt,!0);i&&q.on("keydown.brush",kt,!0).on("keyup.brush",ie,!0),Fm(qt.view)}qY(),hu(_),c.call(_),X.start();function pt(){var ee=Kt(_);bt&&!Mt&&!lt&&(Math.abs(ee[0]-ct[0])>Math.abs(ee[1]-ct[1])?lt=!0:Mt=!0),ct=ee,St=!0,BL(),ht()}function ht(){var ee;switch(ot=ct[0]-_t[0],st=ct[1]-_t[1],x){case GY:case qvt:{b&&(ot=Math.max(O-D,Math.min(F-z,ot)),B=D+ot,U=z+ot),S&&(st=Math.max(I-L,Math.min(W-Z,st)),R=L+st,rt=Z+st);break}case Mb:{b<0?(ot=Math.max(O-D,Math.min(F-D,ot)),B=D+ot,U=z):b>0&&(ot=Math.max(O-z,Math.min(F-z,ot)),B=D,U=z+ot),S<0?(st=Math.max(I-L,Math.min(W-L,st)),R=L+st,rt=Z):S>0&&(st=Math.max(I-Z,Math.min(W-Z,st)),R=L,rt=Z+st);break}case Eb:{b&&(B=Math.max(O,Math.min(F,D-ot*b)),U=Math.max(O,Math.min(F,z+ot*b))),S&&(R=Math.max(I,Math.min(W,L-st*S)),rt=Math.max(I,Math.min(W,Z+st*S)));break}}U<B&&(b*=-1,ee=D,D=z,z=ee,ee=B,B=U,U=ee,y in Wvt&&dt.attr("cursor",Ip[y=Wvt[y]])),rt<R&&(S*=-1,ee=L,L=Z,Z=ee,ee=R,R=rt,rt=ee,y in Yvt&&dt.attr("cursor",Ip[y=Yvt[y]])),C.selection&&(k=C.selection),Mt&&(B=k[0][0],U=k[1][0]),lt&&(R=k[0][1],rt=k[1][1]),(k[0][0]!==B||k[0][1]!==R||k[1][0]!==U||k[1][1]!==rt)&&(C.selection=[[B,R],[U,rt]],c.call(_),X.brush())}function wt(){if(qY(),qt.touches){if(qt.touches.length)return;s&&clearTimeout(s),s=setTimeout(function(){s=null},500)}else Bm(qt.view,St),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);et.attr("pointer-events","all"),dt.attr("cursor",Ip.overlay),C.selection&&(k=C.selection),TSe(k)&&(C.selection=null,c.call(_)),X.end()}function kt(){switch(qt.keyCode){case 16:{bt=b&&S;break}case 18:{x===Mb&&(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb,ht());break}case 32:{(x===Mb||x===Eb)&&(b<0?z=U-ot:b>0&&(D=B-ot),S<0?Z=rt-st:S>0&&(L=R-st),x=GY,dt.attr("cursor",Ip.selection),ht());break}default:return}BL()}function ie(){switch(qt.keyCode){case 16:{bt&&(Mt=lt=bt=!1,ht());break}case 18:{x===Eb&&(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb,ht());break}case 32:{x===GY&&(qt.altKey?(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb):(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb),dt.attr("cursor",Ip[y]),ht());break}default:return}BL()}}function p(){u(this,arguments).moved()}function d(){u(this,arguments).ended()}function g(){var _=this.__brush||{selection:null};return _.extent=YY(t.apply(this,arguments)),_.dim=e,_}return l.extent=function(_){return arguments.length?(t=typeof _=="function"?_:FL(YY(_)),l):t},l.filter=function(_){return arguments.length?(r=typeof _=="function"?_:FL(!!_),l):r},l.touchable=function(_){return arguments.length?(n=typeof _=="function"?_:FL(!!_),l):n},l.handleSize=function(_){return arguments.length?(a=+_,l):a},l.keyModifiers=function(_){return arguments.length?(i=!!_,l):i},l.on=function(){var _=o.on.apply(o,arguments);return _===o?l:_},l}var XY=Math.cos,$Y=Math.sin,Xvt=Math.PI,VE=Xvt/2,KY=Xvt*2,ZY=Math.max;function CSe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function $vt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=Ir(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(Ir(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=ZY(0,KY-e*a)/p,_=p?e:KY/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=ZY(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=CSe(o))._=o,i):n&&n._},i}var Kvt=Array.prototype.slice;function WL(e){return function(){return e}}var JY=Math.PI,QY=2*JY,k_=1e-6,ASe=QY-k_;function tj(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Zvt(){return new tj}tj.prototype=Zvt.prototype={constructor:tj,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>k_)if(!(Math.abs(u*s-l*c)>k_)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((JY-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>k_&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>k_||Math.abs(this._y1-c)>k_)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%QY+QY),h>ASe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>k_&&(this._+="A"+r+","+r+",0,"+ +(h>=JY)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};var ws=Zvt;function PSe(e){return e.source}function ISe(e){return e.target}function LSe(e){return e.radius}function kSe(e){return e.startAngle}function RSe(e){return e.endAngle}function Jvt(){var e=PSe,t=ISe,r=LSe,n=kSe,i=RSe,o=null;function a(){var s,l=Kvt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-VE,p=i.apply(this,l)-VE,d=h*XY(f),g=h*$Y(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-VE,x=i.apply(this,l)-VE;if(o||(o=s=ws()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*XY(y),_*$Y(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:WL(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:WL(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:WL(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}Tb();var OSe=Array.prototype,KL=OSe.slice;function f1t(e,t){return e-t}function p1t(e){for(var t=0,r=e.length,n=e[r-1][1]*e[0][0]-e[r-1][0]*e[0][1];++t<r;)n+=e[t-1][1]*e[t][0]-e[t-1][0]*e[t][1];return n}function zh(e){return function(){return e}}function d1t(e,t){for(var r=-1,n=t.length,i;++r<n;)if(i=zSe(e,t[r]))return i;return 0}function zSe(e,t){for(var r=t[0],n=t[1],i=-1,o=0,a=e.length,s=a-1;o<a;s=o++){var l=e[o],c=l[0],u=l[1],h=e[s],f=h[0],p=h[1];if(FSe(l,h,t))return 0;u>n!=p>n&&r<(f-c)*(n-u)/(p-u)+c&&(i=-i)}return i}function FSe(e,t,r){var n;return BSe(e,t,r)&&HSe(e[n=+(e[0]===t[0])],r[n],t[n])}function BSe(e,t,r){return(t[0]-e[0])*(r[1]-e[1])===(r[0]-e[0])*(t[1]-e[1])}function HSe(e,t,r){return e<=t&&t<=r||r<=t&&t<=e}function m1t(){}var Lp=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function ZL(){var e=1,t=1,r=sb,n=l;function i(c){var u=r(c);if(Array.isArray(u))u=u.slice().sort(f1t);else{var h=sa(c),f=h[0],p=h[1];u=el(f,p,u),u=Ir(Math.floor(f/u)*u,Math.floor(p/u)*u,u)}return u.map(function(d){return o(c,d)})}function o(c,u){var h=[],f=[];return a(c,u,function(p){n(p,c,u),p1t(p)>0?h.push([p]):f.push(p)}),f.forEach(function(p){for(var d=0,g=h.length,_;d<g;++d)if(d1t((_=h[d])[0],p)!==-1){_.push(p);return}}),{type:"MultiPolygon",value:u,coordinates:h}}function a(c,u,h){var f=new Array,p=new Array,d,g,_,y,x,b;for(d=g=-1,y=c[0]>=u,Lp[y<<1].forEach(S);++d<e-1;)_=y,y=c[d+1]>=u,Lp[_|y<<1].forEach(S);for(Lp[y<<0].forEach(S);++g<t-1;){for(d=-1,y=c[g*e+e]>=u,x=c[g*e]>=u,Lp[y<<1|x<<2].forEach(S);++d<e-1;)_=y,y=c[g*e+e+d+1]>=u,b=x,x=c[g*e+d+1]>=u,Lp[_|y<<1|x<<2|b<<3].forEach(S);Lp[y|x<<3].forEach(S)}for(d=-1,x=c[g*e]>=u,Lp[x<<2].forEach(S);++d<e-1;)b=x,x=c[g*e+d+1]>=u,Lp[x<<2|b<<3].forEach(S);Lp[x<<3].forEach(S);function S(C){var P=[C[0][0]+d,C[0][1]+g],k=[C[1][0]+d,C[1][1]+g],O=s(P),D=s(k),B,I;(B=p[O])?(I=f[D])?(delete p[B.end],delete f[I.start],B===I?(B.ring.push(k),h(B.ring)):f[B.start]=p[I.end]={start:B.start,end:I.end,ring:B.ring.concat(I.ring)}):(delete p[B.end],B.ring.push(k),p[B.end=D]=B):(B=f[D])?(I=p[O])?(delete f[B.start],delete p[I.end],B===I?(B.ring.push(k),h(B.ring)):f[I.start]=p[B.end]={start:I.start,end:B.end,ring:I.ring.concat(B.ring)}):(delete f[B.start],B.ring.unshift(P),f[B.start=O]=B):f[O]=p[D]={start:O,end:D,ring:[P,k]}}}function s(c){return c[0]*2+c[1]*(e+1)*4}function l(c,u,h){c.forEach(function(f){var p=f[0],d=f[1],g=p|0,_=d|0,y,x=u[_*e+g];p>0&&p<e&&g===p&&(y=u[_*e+g-1],f[0]=p+(h-y)/(x-y)-.5),d>0&&d<t&&_===d&&(y=u[(_-1)*e+g],f[1]=d+(h-y)/(x-y)-.5)})}return i.contour=o,i.size=function(c){if(!arguments.length)return[e,t];var u=Math.ceil(c[0]),h=Math.ceil(c[1]);if(!(u>0)||!(h>0))throw new Error("invalid size");return e=u,t=h,i},i.thresholds=function(c){return arguments.length?(r=typeof c=="function"?c:Array.isArray(c)?zh(KL.call(c)):zh(c),i):r},i.smooth=function(c){return arguments.length?(n=c?l:m1t,i):n===l},i}function JL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<i;++a)for(var s=0,l=0;s<n+r;++s)s<n&&(l+=e.data[s+a*n]),s>=r&&(s>=o&&(l-=e.data[s-o+a*n]),t.data[s-r+a*n]=l/Math.min(s+1,n-1+o-s,o))}function QL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<n;++a)for(var s=0,l=0;s<i+r;++s)s<i&&(l+=e.data[a+s*n]),s>=r&&(s>=o&&(l-=e.data[a+(s-o)*n]),t.data[a+(s-r)*n]=l/Math.min(s+1,i-1+o-s,o))}function VSe(e){return e[0]}function USe(e){return e[1]}function qSe(){return 1}function g1t(){var e=VSe,t=USe,r=qSe,n=960,i=500,o=20,a=2,s=o*3,l=n+s*2>>a,c=i+s*2>>a,u=zh(20);function h(y){var x=new Float32Array(l*c),b=new Float32Array(l*c);y.forEach(function(P,k,O){var D=+e(P,k,O)+s>>a,B=+t(P,k,O)+s>>a,I=+r(P,k,O);D>=0&&D<l&&B>=0&&B<c&&(x[D+B*l]+=I)}),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),JL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),QL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a);var S=u(x);if(!Array.isArray(S)){var C=lu(x);S=el(0,C,S),S=Ir(0,Math.floor(C/S)*S,S),S.shift()}return ZL().thresholds(S).size([l,c])(x).map(f)}function f(y){return y.value*=Math.pow(2,-2*a),y.coordinates.forEach(p),y}function p(y){y.forEach(d)}function d(y){y.forEach(g)}function g(y){y[0]=y[0]*Math.pow(2,a)-s,y[1]=y[1]*Math.pow(2,a)-s}function _(){return s=o*3,l=n+s*2>>a,c=i+s*2>>a,h}return h.x=function(y){return arguments.length?(e=typeof y=="function"?y:zh(+y),h):e},h.y=function(y){return arguments.length?(t=typeof y=="function"?y:zh(+y),h):t},h.weight=function(y){return arguments.length?(r=typeof y=="function"?y:zh(+y),h):r},h.size=function(y){if(!arguments.length)return[n,i];var x=Math.ceil(y[0]),b=Math.ceil(y[1]);if(!(x>=0)&&!(x>=0))throw new Error("invalid size");return n=x,i=b,_()},h.cellSize=function(y){if(!arguments.length)return 1<<a;if(!((y=+y)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(y)/Math.LN2),_()},h.thresholds=function(y){return arguments.length?(u=typeof y=="function"?y:Array.isArray(y)?zh(KL.call(y)):zh(y),h):u},h.bandwidth=function(y){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((y=+y)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*y*y+1)-1)/2),_()},h}Rm();qE();L_();function XSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.blob()}function D1t(e,t){return fetch(e,t).then(XSe)}function $Se(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.arrayBuffer()}function O1t(e,t){return fetch(e,t).then($Se)}qE();function KSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.text()}function O_(e,t){return fetch(e,t).then(KSe)}function z1t(e){return function(t,r,n){return arguments.length===2&&typeof r=="function"&&(n=r,r=void 0),O_(t,r).then(function(i){return e(i,n)})}}function oj(e,t,r,n){arguments.length===3&&typeof r=="function"&&(n=r,r=void 0);var i=Ym(e);return O_(t,r).then(function(o){return i.parse(o,n)})}var F1t=z1t(Cb),B1t=z1t(Ab);function H1t(e,t){return new Promise(function(r,n){var i=new Image;for(var o in t)i[o]=t[o];i.onerror=n,i.onload=function(){r(i)},i.src=e})}function ZSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);if(!(e.status===204||e.status===205))return e.json()}function V1t(e,t){return fetch(e,t).then(ZSe)}function aj(e){return function(t,r){return O_(t,r).then(function(n){return new DOMParser().parseFromString(n,e)})}}var U1t=aj("application/xml"),q1t=aj("text/html"),G1t=aj("image/svg+xml");function W1t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}function On(e){return function(){return e}}function fu(){return(Math.random()-.5)*1e-6}function Y1t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return j1t(this.cover(t,r),t,r,e)}function j1t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function X1t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)j1t(this,a[r],s[r],e[r]);return this}function $1t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}function K1t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}function Z1t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function yo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}function J1t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new yo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new yo(p[3],_,y,l,c),new yo(p[2],a,y,_,c),new yo(p[1],_,s,l,y),new yo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}function Q1t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function txt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}function ext(){return this._root}function rxt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}function nxt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new yo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new yo(i,c,u,s,l)),(i=n[2])&&t.push(new yo(i,o,u,c,l)),(i=n[1])&&t.push(new yo(i,c,a,s,u)),(i=n[0])&&t.push(new yo(i,o,a,c,u))}return this}function ixt(e){var t=[],r=[],n;for(this._root&&t.push(new yo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new yo(o,a,s,u,h)),(o=i[1])&&t.push(new yo(o,u,s,l,h)),(o=i[2])&&t.push(new yo(o,a,h,u,c)),(o=i[3])&&t.push(new yo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}function oxt(e){return e[0]}function axt(e){return arguments.length?(this._x=e,this):this._x}function sxt(e){return e[1]}function lxt(e){return arguments.length?(this._y=e,this):this._y}function Fh(e,t,r){var n=new sj(t==null?oxt:t,r==null?sxt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function sj(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function cxt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Fa=Fh.prototype=sj.prototype;Fa.copy=function(){var e=new sj(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=cxt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=cxt(n));return e};Fa.add=Y1t;Fa.addAll=X1t;Fa.cover=$1t;Fa.data=K1t;Fa.extent=Z1t;Fa.find=J1t;Fa.remove=Q1t;Fa.removeAll=txt;Fa.root=ext;Fa.size=rxt;Fa.visit=nxt;Fa.visitAfter=ixt;Fa.x=axt;Fa.y=lxt;function JSe(e){return e.x+e.vx}function QSe(e){return e.y+e.vy}function uxt(e){var t,r,n=1,i=1;typeof e!="function"&&(e=On(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=Fh(t,JSe,QSe).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=fu(),L+=B*B),I===0&&(I=fu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:On(+l),s(),o):e},o}Tb();function t3e(e){return e.index}function hxt(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function fxt(e){var t=t3e,r=u,n,i=On(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||fu(),k=C.y+C.vy-S.y-S.vy||fu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=Ji(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=hxt(x,b.source)),typeof b.target!="object"&&(b.target=hxt(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:On(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:On(+g),d(),h):i},h}Rm();Tb();function pxt(e){return e.x}function dxt(e){return e.y}var e3e=10,r3e=Math.PI*(3-Math.sqrt(5));function mxt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=Ji(),l=P_(u),c=xs("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(d){var g,_=e.length,y;d===void 0&&(d=1);for(var x=0;x<d;++x)for(r+=(o-r)*i,s.each(function(b){b(r)}),g=0;g<_;++g)y=e[g],y.fx==null?y.x+=y.vx*=a:(y.x=y.fx,y.vx=0),y.fy==null?y.y+=y.vy*=a:(y.y=y.fy,y.vy=0);return t}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,_.fx!=null&&(_.x=_.fx),_.fy!=null&&(_.y=_.fy),isNaN(_.x)||isNaN(_.y)){var y=e3e*Math.sqrt(d),x=d*r3e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}function gxt(){var e,t,r,n=On(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=Fh(e,pxt,dxt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:On(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}function _xt(e,t,r){var n,i=On(.1),o,a;typeof e!="function"&&(e=On(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:On(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:On(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}function yxt(e){var t=On(.1),r,n,i;typeof e!="function"&&(e=On(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:On(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:On(+s),a(),o):e},o}function vxt(e){var t=On(.1),r,n,i;typeof e!="function"&&(e=On(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:On(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:On(+s),a(),o):e},o}function xxt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function z_(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function Bh(e){return e=z_(Math.abs(e)),e?e[1]:NaN}function bxt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}function wxt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var n3e=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function kp(e){if(!(t=n3e.exec(e)))throw new Error("invalid format: "+e);var t;return new GE({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}kp.prototype=GE.prototype;function GE(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}GE.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function Sxt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var lj;function Mxt(e,t){var r=z_(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(lj=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+z_(e,Math.max(0,t+o-1))[0]}function cj(e,t){var r=z_(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var uj={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:xxt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return cj(e*100,t)},r:cj,s:Mxt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}};function hj(e){return e}var Ext=Array.prototype.map,Txt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function ek(e){var t=e.grouping===void 0||e.thousands===void 0?hj:bxt(Ext.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?hj:wxt(Ext.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=kp(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):uj[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=uj[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=Sxt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?Txt[8+lj/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=kp(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(Bh(f)/3)))*3,g=Math.pow(10,-d),_=Txt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var rk,xn,WE;nk({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function nk(e){return rk=ek(e),xn=rk.format,WE=rk.formatPrefix,rk}function ik(e){return Math.max(0,-Bh(Math.abs(e)))}function ok(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Bh(t)/3)))*3-Bh(Math.abs(e)))}function ak(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,Bh(t)-Bh(e))+1}function Ms(){return new lk}function lk(){this.reset()}lk.prototype={constructor:lk,reset:function(){this.s=this.t=0},add:function(e){Cxt(sk,e,this.t),Cxt(this,sk.s,this.s),this.s?this.t+=sk.t:this.s=sk.t},valueOf:function(){return this.s}};var sk=new lk;function Cxt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var le=1e-6,F_=1e-12,Be=Math.PI,mn=Be/2,Pb=Be/4,wi=Be*2,vr=180/Be,ye=Be/180,Re=Math.abs,ic=Math.atan,bn=Math.atan2,Zt=Math.cos,YE=Math.ceil,ck=Math.exp;var B_=Math.log,uk=Math.pow,Xt=Math.sin,ua=Math.sign||function(e){return e>0?1:e<0?-1:0},xr=Math.sqrt,Ib=Math.tan;function hk(e){return e>1?0:e<-1?Be:Math.acos(e)}function wn(e){return e>1?mn:e<-1?-mn:Math.asin(e)}function fj(e){return(e=Xt(e/2))*e}function Fr(){}function fk(e,t){e&&Pxt.hasOwnProperty(e.type)&&Pxt[e.type](e,t)}var Axt={Feature:function(e,t){fk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)fk(r[n].geometry,t)}},Pxt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){pj(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)pj(r[n],t,0)},Polygon:function(e,t){Ixt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)Ixt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)fk(r[n],t)}};function pj(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function Ixt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)pj(e[r],t,1);t.polygonEnd()}function vo(e,t){e&&Axt.hasOwnProperty(e.type)?Axt[e.type](e,t):fk(e,t)}var jE=Ms(),pk=Ms(),Lxt,kxt,dj,mj,gj,pu={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){jE.reset(),pu.lineStart=i3e,pu.lineEnd=o3e},polygonEnd:function(){var e=+jE;pk.add(e<0?wi+e:e),this.lineStart=this.lineEnd=this.point=Fr},sphere:function(){pk.add(wi)}};function i3e(){pu.point=a3e}function o3e(){Rxt(Lxt,kxt)}function a3e(e,t){pu.point=Rxt,Lxt=e,kxt=t,e*=ye,t*=ye,dj=e,mj=Zt(t=t/2+Pb),gj=Xt(t)}function Rxt(e,t){e*=ye,t*=ye,t=t/2+Pb;var r=e-dj,n=r>=0?1:-1,i=n*r,o=Zt(t),a=Xt(t),s=gj*a,l=mj*o+s*Zt(i),c=s*n*Xt(i);jE.add(bn(c,l)),dj=e,mj=o,gj=a}function Nxt(e){return pk.reset(),vo(e,pu),pk*2}function H_(e){return[bn(e[1],e[0]),wn(e[2])]}function oc(e){var t=e[0],r=e[1],n=Zt(r);return[n*Zt(t),n*Xt(t),Xt(r)]}function XE(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function Rp(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function dk(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function $E(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function V_(e){var t=xr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var ri,Es,ui,il,U_,Fxt,Bxt,Lb,KE=Ms(),jm,Dp,Np={point:_j,lineStart:Dxt,lineEnd:Oxt,polygonStart:function(){Np.point=Vxt,Np.lineStart=s3e,Np.lineEnd=l3e,KE.reset(),pu.polygonStart()},polygonEnd:function(){pu.polygonEnd(),Np.point=_j,Np.lineStart=Dxt,Np.lineEnd=Oxt,jE<0?(ri=-(ui=180),Es=-(il=90)):KE>le?il=90:KE<-le&&(Es=-90),Dp[0]=ri,Dp[1]=ui},sphere:function(){ri=-(ui=180),Es=-(il=90)}};function _j(e,t){jm.push(Dp=[ri=e,ui=e]),t<Es&&(Es=t),t>il&&(il=t)}function Hxt(e,t){var r=oc([e*ye,t*ye]);if(Lb){var n=Rp(Lb,r),i=[n[1],-n[0],0],o=Rp(i,n);V_(o),o=H_(o);var a=e-U_,s=a>0?1:-1,l=o[0]*vr*s,c,u=Re(a)>180;u^(s*U_<l&&l<s*e)?(c=o[1]*vr,c>il&&(il=c)):(l=(l+360)%360-180,u^(s*U_<l&&l<s*e)?(c=-o[1]*vr,c<Es&&(Es=c)):(t<Es&&(Es=t),t>il&&(il=t))),u?e<U_?nl(ri,e)>nl(ri,ui)&&(ui=e):nl(e,ui)>nl(ri,ui)&&(ri=e):ui>=ri?(e<ri&&(ri=e),e>ui&&(ui=e)):e>U_?nl(ri,e)>nl(ri,ui)&&(ui=e):nl(e,ui)>nl(ri,ui)&&(ri=e)}else jm.push(Dp=[ri=e,ui=e]);t<Es&&(Es=t),t>il&&(il=t),Lb=r,U_=e}function Dxt(){Np.point=Hxt}function Oxt(){Dp[0]=ri,Dp[1]=ui,Np.point=_j,Lb=null}function Vxt(e,t){if(Lb){var r=e-U_;KE.add(Re(r)>180?r+(r>0?360:-360):r)}else Fxt=e,Bxt=t;pu.point(e,t),Hxt(e,t)}function s3e(){pu.lineStart()}function l3e(){Vxt(Fxt,Bxt),pu.lineEnd(),Re(KE)>le&&(ri=-(ui=180)),Dp[0]=ri,Dp[1]=ui,Lb=null}function nl(e,t){return(t-=e)<0?t+360:t}function c3e(e,t){return e[0]-t[0]}function zxt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function Uxt(e){var t,r,n,i,o,a,s;if(il=ui=-(ri=Es=1/0),jm=[],vo(e,Np),r=jm.length){for(jm.sort(c3e),t=1,n=jm[0],o=[n];t<r;++t)i=jm[t],zxt(n,i[0])||zxt(n,i[1])?(nl(n[0],i[1])>nl(n[0],n[1])&&(n[1]=i[1]),nl(i[0],n[1])>nl(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=nl(n[1],i[0]))>a&&(a=s,ri=i[0],ui=n[1])}return jm=Dp=null,ri===1/0||Es===1/0?[[NaN,NaN],[NaN,NaN]]:[[ri,Es],[ui,il]]}var ZE,mk,gk,_k,yk,vk,xk,bk,yj,vj,xj,Wxt,Yxt,Ba,Ha,Va,du={sphere:Fr,point:bj,lineStart:qxt,lineEnd:Gxt,polygonStart:function(){du.lineStart=f3e,du.lineEnd=p3e},polygonEnd:function(){du.lineStart=qxt,du.lineEnd=Gxt}};function bj(e,t){e*=ye,t*=ye;var r=Zt(t);JE(r*Zt(e),r*Xt(e),Xt(t))}function JE(e,t,r){++ZE,gk+=(e-gk)/ZE,_k+=(t-_k)/ZE,yk+=(r-yk)/ZE}function qxt(){du.point=u3e}function u3e(e,t){e*=ye,t*=ye;var r=Zt(t);Ba=r*Zt(e),Ha=r*Xt(e),Va=Xt(t),du.point=h3e,JE(Ba,Ha,Va)}function h3e(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=bn(xr((a=Ha*o-Va*i)*a+(a=Va*n-Ba*o)*a+(a=Ba*i-Ha*n)*a),Ba*n+Ha*i+Va*o);mk+=a,vk+=a*(Ba+(Ba=n)),xk+=a*(Ha+(Ha=i)),bk+=a*(Va+(Va=o)),JE(Ba,Ha,Va)}function Gxt(){du.point=bj}function f3e(){du.point=d3e}function p3e(){jxt(Wxt,Yxt),du.point=bj}function d3e(e,t){Wxt=e,Yxt=t,e*=ye,t*=ye,du.point=jxt;var r=Zt(t);Ba=r*Zt(e),Ha=r*Xt(e),Va=Xt(t),JE(Ba,Ha,Va)}function jxt(e,t){e*=ye,t*=ye;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=Ha*o-Va*i,s=Va*n-Ba*o,l=Ba*i-Ha*n,c=xr(a*a+s*s+l*l),u=wn(c),h=c&&-u/c;yj+=h*a,vj+=h*s,xj+=h*l,mk+=u,vk+=u*(Ba+(Ba=n)),xk+=u*(Ha+(Ha=i)),bk+=u*(Va+(Va=o)),JE(Ba,Ha,Va)}function Xxt(e){ZE=mk=gk=_k=yk=vk=xk=bk=yj=vj=xj=0,vo(e,du);var t=yj,r=vj,n=xj,i=t*t+r*r+n*n;return i<F_&&(t=vk,r=xk,n=bk,mk<le&&(t=gk,r=_k,n=yk),i=t*t+r*r+n*n,i<F_)?[NaN,NaN]:[bn(r,t)*vr,wn(n/xr(i))*vr]}function q_(e){return function(){return e}}function QE(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}function wj(e,t){return[Re(e)>Be?e+Math.round(-e/wi)*wi:e,t]}wj.invert=wj;function t5(e,t,r){return(e%=wi)?t||r?QE(Kxt(e),Zxt(t,r)):Kxt(e):t||r?Zxt(t,r):wj}function $xt(e){return function(t,r){return t+=e,[t>Be?t-wi:t<-Be?t+wi:t,r]}}function Kxt(e){var t=$xt(e);return t.invert=$xt(-e),t}function Zxt(e,t){var r=Zt(e),n=Xt(e),i=Zt(t),o=Xt(t);function a(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*r+u*n;return[bn(h*i-p*o,u*r-f*n),wn(p*i+h*o)]}return a.invert=function(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*i-h*o;return[bn(h*i+f*o,u*r+p*n),wn(p*r-u*n)]},a}function wk(e){e=t5(e[0]*ye,e[1]*ye,e.length>2?e[2]*ye:0);function t(r){return r=e(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r}return t.invert=function(r){return r=e.invert(r[0]*ye,r[1]*ye),r[0]*=vr,r[1]*=vr,r},t}function Sj(e,t,r,n,i,o){if(!!r){var a=Zt(t),s=Xt(t),l=n*r;i==null?(i=t+n*wi,o=t-l/2):(i=Jxt(a,i),o=Jxt(a,o),(n>0?i<o:i>o)&&(i+=n*wi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=H_([a,-s*Zt(u),-s*Xt(u)]),e.point(c[0],c[1])}}function Jxt(e,t){t=oc(t),t[0]-=e,V_(t);var r=hk(-t[1]);return((-t[2]<0?-r:r)+wi-le)%wi}function Qxt(){var e=q_([0,0]),t=q_(90),r=q_(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=vr,l[1]*=vr}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*ye,u=r.apply(this,arguments)*ye;return n=[],i=t5(-l[0]*ye,-l[1]*ye,0).invert,Sj(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:q_([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:q_(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:q_(+l),s):r},s}function Sk(){var e=[],t;return{point:function(r,n,i){t.push([r,n,i])},lineStart:function(){e.push(t=[])},lineEnd:Fr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}function kb(e,t){return Re(e[0]-t[0])<le&&Re(e[1]-t[1])<le}function Mk(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function Ek(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(kb(_,y)){if(!_[2]&&!y[2]){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}y[0]+=2*le}o.push(x=new Mk(_,d,null,!0)),a.push(x.o=new Mk(_,null,x,!1)),o.push(x=new Mk(y,d,null,!1)),a.push(x.o=new Mk(y,null,x,!0))}}),!!o.length){for(a.sort(t),tbt(o),tbt(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function tbt(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var Mj=Ms();function Ej(e){return Re(e[0])<=Be?e[0]:ua(e[0])*((Re(e[0])+Be)%wi-Be)}function Tk(e,t){var r=Ej(t),n=t[1],i=Xt(n),o=[Xt(r),-Zt(r),0],a=0,s=0;Mj.reset(),i===1?n=mn+le:i===-1&&(n=-mn-le);for(var l=0,c=e.length;l<c;++l)if(!!(h=(u=e[l]).length))for(var u,h,f=u[h-1],p=Ej(f),d=f[1]/2+Pb,g=Xt(d),_=Zt(d),y=0;y<h;++y,p=b,g=C,_=P,f=x){var x=u[y],b=Ej(x),S=x[1]/2+Pb,C=Xt(S),P=Zt(S),k=b-p,O=k>=0?1:-1,D=O*k,B=D>Be,I=g*C;if(Mj.add(bn(I*O*Xt(D),_*P+I*Zt(D))),a+=B?k+O*wi:k,B^p>=r^b>=r){var L=Rp(oc(f),oc(x));V_(L);var R=Rp(o,L);V_(R);var F=(B^k>=0?-1:1)*wn(R[2]);(n>F||n===F&&(L[0]||L[1]))&&(s+=B^k>=0?1:-1)}}return(a<-le||a<le&&Mj<-le)^s&1}function Ck(e,t,r,n){return function(i){var o=t(i),a=Sk(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=Lm(u);var S=Tk(c,n);u.length?(l||(i.polygonStart(),l=!0),Ek(u,g3e,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(m3e))}}return f}}function m3e(e){return e.length>1}function g3e(e,t){return((e=e.x)[0]<0?e[1]-mn-le:mn-e[1])-((t=t.x)[0]<0?t[1]-mn-le:mn-t[1])}var e5=Ck(function(){return!0},_3e,v3e,[-Be,-mn]);function _3e(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?Be:-Be,l=Re(o-t);Re(l-Be)<le?(e.point(t,r=(r+a)/2>0?mn:-mn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=Be&&(Re(t-n)<le&&(t-=n*le),Re(o-s)<le&&(o-=s*le),r=y3e(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function y3e(e,t,r,n){var i,o,a=Xt(e-r);return Re(a)>le?ic((Xt(t)*(o=Zt(n))*Xt(r)-Xt(n)*(i=Zt(t))*Xt(e))/(i*o*a)):(t+n)/2}function v3e(e,t,r,n){var i;if(e==null)i=r*mn,n.point(-Be,i),n.point(0,i),n.point(Be,i),n.point(Be,0),n.point(Be,-i),n.point(0,-i),n.point(-Be,-i),n.point(-Be,0),n.point(-Be,i);else if(Re(e[0]-t[0])>le){var o=e[0]<t[0]?Be:-Be;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}function Ak(e){var t=Zt(e),r=6*ye,n=t>0,i=Re(t)>le;function o(u,h,f,p){Sj(p,e,r,f,u,h)}function a(u,h){return Zt(u)*Zt(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?Be:-Be),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||kb(h,b)||kb(x,b))&&(x[2]=1)),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1],2),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1],3)))}S&&(!h||!kb(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=oc(u),d=oc(h),g=[1,0,0],_=Rp(p,d),y=XE(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=Rp(g,_),k=$E(g,S),O=$E(_,C);dk(k,O);var D=P,B=XE(k,D),I=XE(D,D),L=B*B-I*(XE(k,k)-1);if(!(L<0)){var R=xr(L),F=$E(D,(-B-R)/I);if(dk(F,k),F=H_(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Re(ot-Be)<le,St=st||ot<le;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Re(F[0]-z)<le?W:Z):W<=F[1]&&F[1]<=Z:ot>Be^(z<=F[0]&&F[0]<=U)){var bt=$E(D,(-B+R)/I);return dk(bt,k),[F,H_(bt)]}}}function c(u,h){var f=n?e:Be-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return Ck(a,s,o,n?[0,-e]:[-Be,e-Be])}function ebt(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var r5=1e9,Pk=-r5;function Op(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Re(c[0]-e)<le?u>0?0:3:Re(c[0]-r)<le?u>0?2:1:Re(c[1]-t)<le?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=Sk(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=Lm(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&Ek(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(Pk,Math.min(r5,x)),b=Math.max(Pk,Math.min(r5,b))],rt=[z=Math.max(Pk,Math.min(r5,z)),U=Math.max(Pk,Math.min(r5,U))];ebt(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}function rbt(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Op(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var Tj=Ms(),Cj,Ik,Lk,Rb={sphere:Fr,point:Fr,lineStart:x3e,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr};function x3e(){Rb.point=w3e,Rb.lineEnd=b3e}function b3e(){Rb.point=Rb.lineEnd=Fr}function w3e(e,t){e*=ye,t*=ye,Cj=e,Ik=Xt(t),Lk=Zt(t),Rb.point=S3e}function S3e(e,t){e*=ye,t*=ye;var r=Xt(t),n=Zt(t),i=Re(e-Cj),o=Zt(i),a=Xt(i),s=n*a,l=Lk*r-Ik*n*o,c=Ik*r+Lk*n*o;Tj.add(bn(xr(s*s+l*l),c)),Cj=e,Ik=r,Lk=n}function kk(e){return Tj.reset(),vo(e,Rb),+Tj}var Aj=[null,null],M3e={type:"LineString",coordinates:Aj};function Nb(e,t){return Aj[0]=e,Aj[1]=t,kk(M3e)}var nbt={Feature:function(e,t){return Rk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(Rk(r[n].geometry,t))return!0;return!1}},ibt={Sphere:function(){return!0},Point:function(e,t){return obt(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(obt(r[n],t))return!0;return!1},LineString:function(e,t){return abt(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(abt(r[n],t))return!0;return!1},Polygon:function(e,t){return sbt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(sbt(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(Rk(r[n],t))return!0;return!1}};function Rk(e,t){return e&&ibt.hasOwnProperty(e.type)?ibt[e.type](e,t):!1}function obt(e,t){return Nb(e,t)===0}function abt(e,t){for(var r,n,i,o=0,a=e.length;o<a;o++){if(n=Nb(e[o],t),n===0||o>0&&(i=Nb(e[o],e[o-1]),i>0&&r<=i&&n<=i&&(r+n-i)*(1-Math.pow((r-n)/i,2))<F_*i))return!0;r=n}return!1}function sbt(e,t){return!!Tk(e.map(E3e),lbt(t))}function E3e(e){return e=e.map(lbt),e.pop(),e}function lbt(e){return[e[0]*ye,e[1]*ye]}function cbt(e,t){return(e&&nbt.hasOwnProperty(e.type)?nbt[e.type]:Rk)(e,t)}function ubt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function hbt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function Nk(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Ir(YE(n/u)*u,r,u).map(d).concat(Ir(YE(s/h)*h,a,h).map(g)).concat(Ir(YE(t/l)*l,e,l).filter(function(b){return Re(b%u)>le}).map(f)).concat(Ir(YE(o/c)*c,i,c).filter(function(b){return Re(b%h)>le}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=ubt(o,i,90),p=hbt(t,e,_),d=ubt(s,a,90),g=hbt(n,r,_),y):_},y.extentMajor([[-180,-90+le],[180,90-le]]).extentMinor([[-180,-80-le],[180,80+le]])}function fbt(){return Nk()()}function pbt(e,t){var r=e[0]*ye,n=e[1]*ye,i=t[0]*ye,o=t[1]*ye,a=Zt(n),s=Xt(n),l=Zt(o),c=Xt(o),u=a*Zt(r),h=a*Xt(r),f=l*Zt(i),p=l*Xt(i),d=2*wn(xr(fj(o-n)+a*l*fj(i-r))),g=Xt(d),_=d?function(y){var x=Xt(y*=d)/g,b=Xt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[bn(C,S)*vr,bn(P,xr(S*S+C*C))*vr]}:function(){return[r*vr,n*vr]};return _.distance=d,_}function Xm(e){return e}var Pj=Ms(),Ij=Ms(),dbt,mbt,Lj,kj,$m={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){$m.lineStart=T3e,$m.lineEnd=A3e},polygonEnd:function(){$m.lineStart=$m.lineEnd=$m.point=Fr,Pj.add(Re(Ij)),Ij.reset()},result:function(){var e=Pj/2;return Pj.reset(),e}};function T3e(){$m.point=C3e}function C3e(e,t){$m.point=gbt,dbt=Lj=e,mbt=kj=t}function gbt(e,t){Ij.add(kj*e-Lj*t),Lj=e,kj=t}function A3e(){gbt(dbt,mbt)}var Rj=$m;var Db=1/0,Dk=Db,n5=-Db,Ok=n5,P3e={point:I3e,lineStart:Fr,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr,result:function(){var e=[[Db,Dk],[n5,Ok]];return n5=Ok=-(Dk=Db=1/0),e}};function I3e(e,t){e<Db&&(Db=e),e>n5&&(n5=e),t<Dk&&(Dk=t),t>Ok&&(Ok=t)}var Ob=P3e;var Nj=0,Dj=0,i5=0,zk=0,Fk=0,zb=0,Oj=0,zj=0,o5=0,vbt,xbt,Hh,Vh,mu={point:G_,lineStart:_bt,lineEnd:ybt,polygonStart:function(){mu.lineStart=R3e,mu.lineEnd=N3e},polygonEnd:function(){mu.point=G_,mu.lineStart=_bt,mu.lineEnd=ybt},result:function(){var e=o5?[Oj/o5,zj/o5]:zb?[zk/zb,Fk/zb]:i5?[Nj/i5,Dj/i5]:[NaN,NaN];return Nj=Dj=i5=zk=Fk=zb=Oj=zj=o5=0,e}};function G_(e,t){Nj+=e,Dj+=t,++i5}function _bt(){mu.point=L3e}function L3e(e,t){mu.point=k3e,G_(Hh=e,Vh=t)}function k3e(e,t){var r=e-Hh,n=t-Vh,i=xr(r*r+n*n);zk+=i*(Hh+e)/2,Fk+=i*(Vh+t)/2,zb+=i,G_(Hh=e,Vh=t)}function ybt(){mu.point=G_}function R3e(){mu.point=D3e}function N3e(){bbt(vbt,xbt)}function D3e(e,t){mu.point=bbt,G_(vbt=Hh=e,xbt=Vh=t)}function bbt(e,t){var r=e-Hh,n=t-Vh,i=xr(r*r+n*n);zk+=i*(Hh+e)/2,Fk+=i*(Vh+t)/2,zb+=i,i=Vh*e-Hh*t,Oj+=i*(Hh+e),zj+=i*(Vh+t),o5+=i*3,G_(Hh=e,Vh=t)}var Fj=mu;function Bk(e){this._context=e}Bk.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,wi);break}}},result:Fr};var Hj=Ms(),Bj,wbt,Sbt,a5,s5,Hk={point:Fr,lineStart:function(){Hk.point=O3e},lineEnd:function(){Bj&&Mbt(wbt,Sbt),Hk.point=Fr},polygonStart:function(){Bj=!0},polygonEnd:function(){Bj=null},result:function(){var e=+Hj;return Hj.reset(),e}};function O3e(e,t){Hk.point=Mbt,wbt=a5=e,Sbt=s5=t}function Mbt(e,t){a5-=e,s5-=t,Hj.add(xr(a5*a5+s5*s5)),a5=e,s5=t}var Vj=Hk;function Vk(){this._string=[]}Vk.prototype={_radius:4.5,_circle:Ebt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=Ebt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}};function Ebt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}function Tbt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),vo(a,n(i))),i.result()}return o.area=function(a){return vo(a,n(Rj)),Rj.result()},o.measure=function(a){return vo(a,n(Vj)),Vj.result()},o.bounds=function(a){return vo(a,n(Ob)),Ob.result()},o.centroid=function(a){return vo(a,n(Fj)),Fj.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,Xm):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new Vk):new Bk(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}function Cbt(e){return{stream:Km(e)}}function Km(e){return function(t){var r=new Uj;for(var n in e)r[n]=e[n];return r.stream=t,r}}function Uj(){}Uj.prototype={constructor:Uj,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function qj(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),vo(r,e.stream(Ob)),t(Ob.result()),n!=null&&e.clipExtent(n),e}function W_(e,t,r){return qj(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function Fb(e,t,r){return W_(e,[[0,0],t],r)}function Bb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function Hb(e,t,r){return qj(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var Abt=16,z3e=Zt(30*ye);function Gj(e,t){return+t?B3e(e,t):F3e(e)}function F3e(e){return Km({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function B3e(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=xr(S*S+C*C+P*P),O=wn(P/=k),D=Re(Re(P)-1)<le||Re(o-h)<le?(o+h)/2:bn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Re((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<z3e)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=oc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],Abt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,Abt,n),_.lineEnd=S,S()}return _}}var H3e=Km({point:function(e,t){this.stream.point(e*ye,t*ye)}});function V3e(e){return Km({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function U3e(e,t,r,n,i){function o(a,s){return a*=n,s*=i,[t+e*a,r-e*s]}return o.invert=function(a,s){return[(a-t)/e*n,(r-s)/e*i]},o}function Pbt(e,t,r,n,i,o){var a=Zt(o),s=Xt(o),l=a*e,c=s*e,u=a/e,h=s/e,f=(s*r-a*t)/e,p=(s*t+a*r)/e;function d(g,_){return g*=n,_*=i,[l*g-c*_+t,r-c*g-l*_]}return d.invert=function(g,_){return[n*(u*g-h*_+f),i*(p-h*g-u*_)]},d}function Si(e){return l5(function(){return e})()}function l5(e){var t,r=150,n=480,i=250,o=0,a=0,s=0,l=0,c=0,u,h=0,f=1,p=1,d=null,g=e5,_=null,y,x,b,S=Xm,C=.5,P,k,O,D,B;function I(z){return O(z[0]*ye,z[1]*ye)}function L(z){return z=O.invert(z[0],z[1]),z&&[z[0]*vr,z[1]*vr]}I.stream=function(z){return D&&B===z?D:D=H3e(V3e(u)(g(P(S(B=z)))))},I.preclip=function(z){return arguments.length?(g=z,d=void 0,F()):g},I.postclip=function(z){return arguments.length?(S=z,_=y=x=b=null,F()):S},I.clipAngle=function(z){return arguments.length?(g=+z?Ak(d=z*ye):(d=null,e5),F()):d*vr},I.clipExtent=function(z){return arguments.length?(S=z==null?(_=y=x=b=null,Xm):Op(_=+z[0][0],y=+z[0][1],x=+z[1][0],b=+z[1][1]),F()):_==null?null:[[_,y],[x,b]]},I.scale=function(z){return arguments.length?(r=+z,R()):r},I.translate=function(z){return arguments.length?(n=+z[0],i=+z[1],R()):[n,i]},I.center=function(z){return arguments.length?(o=z[0]%360*ye,a=z[1]%360*ye,R()):[o*vr,a*vr]},I.rotate=function(z){return arguments.length?(s=z[0]%360*ye,l=z[1]%360*ye,c=z.length>2?z[2]%360*ye:0,R()):[s*vr,l*vr,c*vr]},I.angle=function(z){return arguments.length?(h=z%360*ye,R()):h*vr},I.reflectX=function(z){return arguments.length?(f=z?-1:1,R()):f<0},I.reflectY=function(z){return arguments.length?(p=z?-1:1,R()):p<0},I.precision=function(z){return arguments.length?(P=Gj(k,C=z*z),F()):xr(C)},I.fitExtent=function(z,U){return W_(I,z,U)},I.fitSize=function(z,U){return Fb(I,z,U)},I.fitWidth=function(z,U){return Bb(I,z,U)},I.fitHeight=function(z,U){return Hb(I,z,U)};function R(){var z=Pbt(r,0,0,f,p,h).apply(null,t(o,a)),U=(h?Pbt:U3e)(r,n-z[0],i-z[1],f,p,h);return u=t5(s,l,c),k=QE(t,U),O=QE(u,k),P=Gj(k,C),F()}function F(){return D=B=null,I}return function(){return t=e.apply(this,arguments),I.invert=t.invert&&L,R()}}function Vb(e){var t=0,r=Be/3,n=l5(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*ye,r=o[1]*ye):[t*vr,r*vr]},i}function Ibt(e){var t=Zt(e);function r(n,i){return[n*t,Xt(i)/t]}return r.invert=function(n,i){return[n/t,wn(i*t)]},r}function Wj(e,t){var r=Xt(e),n=(r+Xt(t))/2;if(Re(n)<le)return Ibt(e);var i=1+r*(2*n-r),o=xr(i)/n;function a(s,l){var c=xr(i-2*n*Xt(l))/n;return[c*Xt(s*=n),o-c*Zt(s)]}return a.invert=function(s,l){var c=o-l,u=bn(s,Re(c))*ua(c);return c*n<0&&(u-=Be*ua(s)*ua(c)),[u/n,wn((i-(s*s+c*c)*n*n)/(2*n))]},a}function Y_(){return Vb(Wj).scale(155.424).center([0,33.6442])}function Uk(){return Y_().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function q3e(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function Lbt(){var e,t,r=Uk(),n,i=Y_().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=Y_().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=q3e([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+le,g+.12*p+le],[d-.214*p-le,g+.234*p-le]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+le,g+.166*p+le],[d-.115*p-le,g+.234*p-le]]).stream(c),h()},u.fitExtent=function(f,p){return W_(u,f,p)},u.fitSize=function(f,p){return Fb(u,f,p)},u.fitWidth=function(f,p){return Bb(u,f,p)},u.fitHeight=function(f,p){return Hb(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}function qk(e){return function(t,r){var n=Zt(t),i=Zt(r),o=e(n*i);return[o*i*Xt(t),o*Xt(r)]}}function Uh(e){return function(t,r){var n=xr(t*t+r*r),i=e(n),o=Xt(i),a=Zt(i);return[bn(t*o,n*a),wn(n&&r*o/n)]}}var Gk=qk(function(e){return xr(2/(1+e))});Gk.invert=Uh(function(e){return 2*wn(e/2)});function kbt(){return Si(Gk).scale(124.75).clipAngle(180-.001)}var Wk=qk(function(e){return(e=hk(e))&&e/Xt(e)});Wk.invert=Uh(function(e){return e});function Rbt(){return Si(Wk).scale(79.4188).clipAngle(180-.001)}function j_(e,t){return[e,B_(Ib((mn+t)/2))]}j_.invert=function(e,t){return[e,2*ic(ck(t))-mn]};function Nbt(){return Yj(j_).scale(961/wi)}function Yj(e){var t=Si(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=Be*n(),f=t(wk(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===j_?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}function Yk(e){return Ib((mn+e)/2)}function jj(e,t){var r=Zt(e),n=e===t?Xt(e):B_(r/Zt(t))/B_(Yk(t)/Yk(e)),i=r*uk(Yk(e),n)/n;if(!n)return j_;function o(a,s){i>0?s<-mn+le&&(s=-mn+le):s>mn-le&&(s=mn-le);var l=i/uk(Yk(s),n);return[l*Xt(n*a),i-l*Zt(n*a)]}return o.invert=function(a,s){var l=i-s,c=ua(n)*xr(a*a+l*l),u=bn(a,Re(l))*ua(l);return l*n<0&&(u-=Be*ua(a)*ua(l)),[u/n,2*ic(uk(i/c,1/n))-mn]},o}function Dbt(){return Vb(jj).scale(109.5).parallels([30,30])}function X_(e,t){return[e,t]}X_.invert=X_;function Obt(){return Si(X_).scale(152.63)}function Xj(e,t){var r=Zt(e),n=e===t?Xt(e):(r-Zt(t))/(t-e),i=r/n+e;if(Re(n)<le)return X_;function o(a,s){var l=i-s,c=n*a;return[l*Xt(c),i-l*Zt(c)]}return o.invert=function(a,s){var l=i-s,c=bn(a,Re(l))*ua(l);return l*n<0&&(c-=Be*ua(a)*ua(l)),[c/n,i-ua(n)*xr(a*a+l*l)]},o}function zbt(){return Vb(Xj).scale(131.154).center([0,13.9389])}var c5=1.340264,u5=-.081106,h5=893e-6,f5=.003796,jk=xr(3)/2,G3e=12;function Xk(e,t){var r=wn(jk*Xt(t)),n=r*r,i=n*n*n;return[e*Zt(r)/(jk*(c5+3*u5*n+i*(7*h5+9*f5*n))),r*(c5+u5*n+i*(h5+f5*n))]}Xk.invert=function(e,t){for(var r=t,n=r*r,i=n*n*n,o=0,a,s,l;o<G3e&&(s=r*(c5+u5*n+i*(h5+f5*n))-t,l=c5+3*u5*n+i*(7*h5+9*f5*n),r-=a=s/l,n=r*r,i=n*n*n,!(Re(a)<F_));++o);return[jk*e*(c5+3*u5*n+i*(7*h5+9*f5*n))/Zt(r),wn(Xt(r)/jk)]};function Fbt(){return Si(Xk).scale(177.158)}function $k(e,t){var r=Zt(t),n=Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}$k.invert=Uh(ic);function Bbt(){return Si($k).scale(144.049).clipAngle(60)}function Hbt(){var e=1,t=0,r=0,n=1,i=1,o=0,a,s,l=null,c,u,h,f=1,p=1,d=Km({point:function(S,C){var P=b([S,C]);this.stream.point(P[0],P[1])}}),g=Xm,_,y;function x(){return f=e*n,p=e*i,_=y=null,b}function b(S){var C=S[0]*f,P=S[1]*p;if(o){var k=P*a-C*s;C=C*a+P*s,P=k}return[C+t,P+r]}return b.invert=function(S){var C=S[0]-t,P=S[1]-r;if(o){var k=P*a+C*s;C=C*a-P*s,P=k}return[C/f,P/p]},b.stream=function(S){return _&&y===S?_:_=d(g(y=S))},b.postclip=function(S){return arguments.length?(g=S,l=c=u=h=null,x()):g},b.clipExtent=function(S){return arguments.length?(g=S==null?(l=c=u=h=null,Xm):Op(l=+S[0][0],c=+S[0][1],u=+S[1][0],h=+S[1][1]),x()):l==null?null:[[l,c],[u,h]]},b.scale=function(S){return arguments.length?(e=+S,x()):e},b.translate=function(S){return arguments.length?(t=+S[0],r=+S[1],x()):[t,r]},b.angle=function(S){return arguments.length?(o=S%360*ye,s=Xt(o),a=Zt(o),x()):o*vr},b.reflectX=function(S){return arguments.length?(n=S?-1:1,x()):n<0},b.reflectY=function(S){return arguments.length?(i=S?-1:1,x()):i<0},b.fitExtent=function(S,C){return W_(b,S,C)},b.fitSize=function(S,C){return Fb(b,S,C)},b.fitWidth=function(S,C){return Bb(b,S,C)},b.fitHeight=function(S,C){return Hb(b,S,C)},b}function Kk(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}Kk.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Re(i)>le&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]};function Vbt(){return Si(Kk).scale(175.295)}function Zk(e,t){return[Zt(t)*Xt(e),Xt(t)]}Zk.invert=Uh(wn);function Ubt(){return Si(Zk).scale(249.5).clipAngle(90+le)}function Jk(e,t){var r=Zt(t),n=1+Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}Jk.invert=Uh(function(e){return 2*ic(e)});function qbt(){return Si(Jk).scale(250).clipAngle(142)}function Qk(e,t){return[B_(Ib((mn+t)/2)),-e]}Qk.invert=function(e,t){return[-t,2*ic(ck(e))-mn]};function Gbt(){var e=Yj(Qk),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}function W3e(e,t){return e.parent===t.parent?1:2}function Y3e(e){return e.reduce(j3e,0)/e.length}function j3e(e,t){return e+t.x}function X3e(e){return 1+e.reduce($3e,0)}function $3e(e,t){return Math.max(e,t.y)}function K3e(e){for(var t;t=e.children;)e=t[0];return e}function Z3e(e){for(var t;t=e.children;)e=t[t.length-1];return e}function Wbt(){var e=W3e,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=Y3e(p),f.y=X3e(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=K3e(o),c=Z3e(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}function J3e(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function Ybt(){return this.eachAfter(J3e)}function jbt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}function Xbt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}function $bt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}function Kbt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}function Zbt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}function Jbt(e){for(var t=this,r=Q3e(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function Q3e(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}function Qbt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}function t2t(){var e=[];return this.each(function(t){e.push(t)}),e}function e2t(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}function r2t(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}function p5(e,t){var r=new Zm(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=eMe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new Zm(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore($j)}function tMe(){return p5(this).eachBefore(rMe)}function eMe(e){return e.children}function rMe(e){e.data=e.data.data}function $j(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function Zm(e){this.data=e,this.depth=this.height=0,this.parent=null}Zm.prototype=p5.prototype={constructor:Zm,count:Ybt,each:jbt,eachAfter:$bt,eachBefore:Xbt,sum:Kbt,sort:Zbt,path:Jbt,ancestors:Qbt,descendants:t2t,leaves:e2t,links:r2t,copy:tMe};var n2t=Array.prototype.slice;function i2t(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}function e8(e){for(var t=0,r=(e=i2t(n2t.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&o2t(o,i)?++t:(o=iMe(n=nMe(n,i)),t=0);return o}function nMe(e,t){var r,n;if(Kj(t,e))return[t];for(r=0;r<e.length;++r)if(t8(t,e[r])&&Kj(d5(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(t8(d5(e[r],e[n]),t)&&t8(d5(e[r],t),e[n])&&t8(d5(e[n],t),e[r])&&Kj(a2t(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function t8(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function o2t(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function Kj(e,t){for(var r=0;r<t.length;++r)if(!o2t(e,t[r]))return!1;return!0}function iMe(e){switch(e.length){case 1:return oMe(e[0]);case 2:return d5(e[0],e[1]);case 3:return a2t(e[0],e[1],e[2])}}function oMe(e){return{x:e.x,y:e.y,r:e.r}}function d5(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function a2t(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}function s2t(e,t,r){var n=e.x-t.x,i,o,a=e.y-t.y,s,l,c=n*n+a*a;c?(o=t.r+r.r,o*=o,l=e.r+r.r,l*=l,o>l?(i=(c+l-o)/(2*c),s=Math.sqrt(Math.max(0,l/c-i*i)),r.x=e.x-i*n-s*a,r.y=e.y-i*a+s*n):(i=(c+o-l)/(2*c),s=Math.sqrt(Math.max(0,o/c-i*i)),r.x=t.x+i*n-s*a,r.y=t.y+i*a+s*n)):(r.x=t.x+r.r,r.y=t.y)}function l2t(e,t){var r=e.r+t.r-1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function c2t(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function r8(e){this._=e,this.next=null,this.previous=null}function Zj(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;s2t(r,t,n=e[2]),t=new r8(t),r=new r8(r),n=new r8(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){s2t(t._,r._,n=e[s]),n=new r8(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(l2t(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(l2t(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=c2t(t);(n=n.next)!==r;)(a=c2t(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=e8(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function u2t(e){return Zj(e),e}function h2t(e){return e==null?null:Ub(e)}function Ub(e){if(typeof e!="function")throw new Error;return e}function zp(){return 0}function Jm(e){return function(){return e}}function aMe(e){return Math.sqrt(e.value)}function d2t(){var e=null,t=1,r=1,n=zp;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(f2t(e)).eachAfter(Jj(n,.5)).eachBefore(p2t(1)):o.eachBefore(f2t(aMe)).eachAfter(Jj(zp,1)).eachAfter(Jj(n,o.r/Math.min(t,r))).eachBefore(p2t(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=h2t(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:Jm(+o),i):n},i}function f2t(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function Jj(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=Zj(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function p2t(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}function n8(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}function qh(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}function m2t(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(n8),a}function o(a,s){return function(l){l.children&&qh(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var g2t="$",sMe={depth:-1},_2t={};function lMe(e){return e.id}function cMe(e){return e.parentId}function y2t(){var e=lMe,t=cMe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new Zm(i),(h=e(i,o,n))!=null&&(h+="")&&(f=g2t+(c.id=h),p[f]=f in p?_2t:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[g2t+h],!l)throw new Error("missing: "+h);if(l===_2t)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=sMe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore($j),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=Ub(n),r):e},r.parentId=function(n){return arguments.length?(t=Ub(n),r):t},r}function uMe(e,t){return e.parent===t.parent?1:2}function Qj(e){var t=e.children;return t?t[0]:e.t}function tX(e){var t=e.children;return t?t[t.length-1]:e.t}function hMe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function fMe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function pMe(e,t,r){return e.a.parent===t.parent?e.a:r}function i8(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}i8.prototype=Object.create(Zm.prototype);function dMe(e){for(var t=new i8(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new i8(o[a],a)),i.parent=r;return(t.parent=new i8(null,0)).children=[t],t}function v2t(){var e=uMe,t=1,r=1,n=null;function i(c){var u=dMe(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){fMe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=tX(d),f=Qj(f),d&&f;)g=Qj(g),p=tX(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(hMe(pMe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!tX(p)&&(p.t=d,p.m+=x-y),f&&!Qj(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}function Qm(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var eX=(1+Math.sqrt(5))/2;function rX(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?qh(l,r,n,i,g?n+=d*_/g:o):Qm(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var o8=function e(t){function r(n,i,o,a,s){rX(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function x2t(){var e=o8,t=!1,r=1,n=1,i=[0],o=zp,a=zp,s=zp,l=zp,c=zp;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(n8),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=Ub(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:Jm(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:Jm(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:Jm(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:Jm(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:Jm(+f),u):c},u}function b2t(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}function w2t(e,t,r,n,i){(e.depth&1?Qm:qh)(e,t,r,n,i)}var S2t=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?qh(c,i,o,a,o+=(s-o)*c.value/g):Qm(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=rX(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(eX);function M2t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}function E2t(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}function T2t(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}function mMe(e,t){return e[0]-t[0]||e[1]-t[1]}function C2t(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&T2t(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function A2t(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(mMe),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=C2t(n),a=C2t(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}function P2t(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}function I2t(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}function ac(){return Math.random()}var L2t=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(ac);var a8=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(ac);var k2t=function e(t){function r(){var n=a8.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(ac);var s8=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(ac);var R2t=function e(t){function r(n){var i=s8.source(t)(n);return function(){return i()/n}}return r.source=e,r}(ac);var N2t=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(ac);function hi(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e);break}return this}function sc(e,t){switch(arguments.length){case 0:break;case 1:this.interpolator(e);break;default:this.interpolator(t).domain(e);break}return this}Tb();var D2t=Array.prototype,$_=D2t.map,lc=D2t.slice;var l8={name:"implicit"};function gu(){var e=Ji(),t=[],r=[],n=l8;function i(o){var a=o+"",s=e.get(a);if(!s){if(n!==l8)return n;e.set(a,s=t.push(o))}return r[(s-1)%r.length]}return i.domain=function(o){if(!arguments.length)return t.slice();t=[],e=Ji();for(var a=-1,s=o.length,l,c;++a<s;)e.has(c=(l=o[a])+"")||e.set(c,t.push(l));return i},i.range=function(o){return arguments.length?(r=lc.call(o),i):r.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return gu(t,r).unknown(n)},hi.apply(i,arguments),i}function tg(){var e=gu().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=Ir(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=Math.min(1,l=+h),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.min(1,h),u()):s},e.paddingOuter=function(h){return arguments.length?(l=+h,u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return tg(t(),n).round(a).paddingInner(s).paddingOuter(l).align(c)},hi.apply(u(),arguments)}function O2t(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return O2t(t())},e}function eg(){return O2t(tg.apply(null,arguments).paddingInner(1))}function z2t(e){return function(){return e}}function m5(e){return+e}var F2t=[0,1];function ni(e){return e}function nX(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:z2t(isNaN(t)?NaN:.5)}function B2t(e){var t=e[0],r=e[e.length-1],n;return t>r&&(n=t,t=r,r=n),function(i){return Math.max(t,Math.min(r,i))}}function gMe(e,t,r){var n=e[0],i=e[1],o=t[0],a=t[1];return i<n?(n=nX(i,n),o=r(a,o)):(n=nX(n,i),o=r(o,a)),function(s){return o(n(s))}}function _Me(e,t,r){var n=Math.min(e.length,t.length)-1,i=new Array(n),o=new Array(n),a=-1;for(e[n]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++a<n;)i[a]=nX(e[a],e[a+1]),o[a]=r(t[a],t[a+1]);return function(s){var l=vs(e,s,1,n)-1;return o[l](i[l](s))}}function Gh(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown())}function K_(){var e=F2t,t=F2t,r=nc,n,i,o,a=ni,s,l,c;function u(){return s=Math.min(e.length,t.length)>2?_Me:gMe,l=c=null,h}function h(f){return isNaN(f=+f)?o:(l||(l=s(e.map(n),t,r)))(n(a(f)))}return h.invert=function(f){return a(i((c||(c=s(t,e.map(n),zi)))(f)))},h.domain=function(f){return arguments.length?(e=$_.call(f,m5),a===ni||(a=B2t(e)),u()):e.slice()},h.range=function(f){return arguments.length?(t=lc.call(f),u()):t.slice()},h.rangeRound=function(f){return t=lc.call(f),r=dL,u()},h.clamp=function(f){return arguments.length?(a=f?B2t(e):ni,h):a!==ni},h.interpolate=function(f){return arguments.length?(r=f,u()):r},h.unknown=function(f){return arguments.length?(o=f,h):o},function(f,p){return n=f,i=p,u()}}function g5(e,t){return K_()(e,t)}function c8(e,t,r,n){var i=el(e,t,r),o;switch(n=kp(n==null?",f":n),n.type){case"s":{var a=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(o=ok(i,a))&&(n.precision=o),WE(n,a)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(o=ak(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=o-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(o=ik(i))&&(n.precision=o-(n.type==="%")*2);break}}return xn(n)}function ol(e){var t=e.domain;return e.ticks=function(r){var n=t();return ab(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){var i=t();return c8(i[0],i[i.length-1],r==null?10:r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=b_(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=b_(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=b_(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function zn(){var e=g5(ni,ni);return e.copy=function(){return Gh(e,zn())},hi.apply(e,arguments),ol(e)}function u8(e){var t;function r(n){return isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=$_.call(n,m5),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return u8(e).unknown(t)},e=arguments.length?$_.call(e,m5):[0,1],ol(r)}function h8(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}function H2t(e){return Math.log(e)}function V2t(e){return Math.exp(e)}function yMe(e){return-Math.log(-e)}function vMe(e){return-Math.exp(-e)}function xMe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function bMe(e){return e===10?xMe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function wMe(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function U2t(e){return function(t){return-e(-t)}}function _5(e){var t=e(H2t,V2t),r=t.domain,n=10,i,o;function a(){return i=wMe(n),o=bMe(n),r()[0]<0?(i=U2t(i),o=U2t(o),e(yMe,vMe)):e(H2t,V2t),t}return t.base=function(s){return arguments.length?(n=+s,a()):n},t.domain=function(s){return arguments.length?(r(s),a()):r()},t.ticks=function(s){var l=r(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=i(c),p=i(u),d,g,_,y=s==null?10:+s,x=[];if(!(n%1)&&p-f<y){if(f=Math.round(f)-1,p=Math.round(p)+1,c>0){for(;f<p;++f)for(g=1,d=o(f);g<n;++g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else for(;f<p;++f)for(g=n-1,d=o(f);g>=1;--g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else x=ab(f,p,Math.min(p-f,y)).map(o);return h?x.reverse():x},t.tickFormat=function(s,l){if(l==null&&(l=n===10?".0e":","),typeof l!="function"&&(l=xn(l)),s===1/0)return l;s==null&&(s=10);var c=Math.max(1,n*s/t.ticks().length);return function(u){var h=u/o(Math.round(i(u)));return h*n<n-.5&&(h*=n),h<=c?l(u):""}},t.nice=function(){return r(h8(r(),{floor:function(s){return o(Math.floor(i(s)))},ceil:function(s){return o(Math.ceil(i(s)))}}))},t}function cc(){var e=_5(K_()).domain([1,10]);return e.copy=function(){return Gh(e,cc()).base(e.base())},hi.apply(e,arguments),e}function q2t(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function G2t(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function y5(e){var t=1,r=e(q2t(t),G2t(t));return r.constant=function(n){return arguments.length?e(q2t(t=+n),G2t(t)):t},ol(r)}function f8(){var e=y5(K_());return e.copy=function(){return Gh(e,f8()).constant(e.constant())},hi.apply(e,arguments)}function W2t(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function SMe(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function MMe(e){return e<0?-e*e:e*e}function v5(e){var t=e(ni,ni),r=1;function n(){return r===1?e(ni,ni):r===.5?e(SMe,MMe):e(W2t(r),W2t(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},ol(t)}function Z_(){var e=v5(K_());return e.copy=function(){return Gh(e,Z_()).exponent(e.exponent())},hi.apply(e,arguments),e}function Y2t(){return Z_.apply(null,arguments).exponent(.5)}function rg(){var e=[],t=[],r=[],n;function i(){var a=0,s=Math.max(1,t.length);for(r=new Array(s-1);++a<s;)r[a-1]=la(e,a/s);return o}function o(a){return isNaN(a=+a)?n:t[vs(r,a)]}return o.invertExtent=function(a){var s=t.indexOf(a);return s<0?[NaN,NaN]:[s>0?r[s-1]:e[0],s<r.length?r[s]:e[e.length-1]]},o.domain=function(a){if(!arguments.length)return e.slice();e=[];for(var s=0,l=a.length,c;s<l;++s)c=a[s],c!=null&&!isNaN(c=+c)&&e.push(c);return e.sort(aa),i()},o.range=function(a){return arguments.length?(t=lc.call(a),i()):t.slice()},o.unknown=function(a){return arguments.length?(n=a,o):n},o.quantiles=function(){return r.slice()},o.copy=function(){return rg().domain(e).range(t).unknown(n)},hi.apply(o,arguments)}function qb(){var e=0,t=1,r=1,n=[.5],i=[0,1],o;function a(l){return l<=l?i[vs(n,l,0,r)]:o}function s(){var l=-1;for(n=new Array(r);++l<r;)n[l]=((l+1)*t-(l-r)*e)/(r+1);return a}return a.domain=function(l){return arguments.length?(e=+l[0],t=+l[1],s()):[e,t]},a.range=function(l){return arguments.length?(r=(i=lc.call(l)).length-1,s()):i.slice()},a.invertExtent=function(l){var c=i.indexOf(l);return c<0?[NaN,NaN]:c<1?[e,n[0]]:c>=r?[n[r-1],t]:[n[c-1],n[c]]},a.unknown=function(l){return arguments.length&&(o=l),a},a.thresholds=function(){return n.slice()},a.copy=function(){return qb().domain([e,t]).range(i).unknown(o)},hi.apply(ol(a),arguments)}function p8(){var e=[.5],t=[0,1],r,n=1;function i(o){return o<=o?t[vs(e,o,0,n)]:r}return i.domain=function(o){return arguments.length?(e=lc.call(o),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(o){return arguments.length?(t=lc.call(o),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(o){var a=t.indexOf(o);return[e[a-1],e[a]]},i.unknown=function(o){return arguments.length?(r=o,i):r},i.copy=function(){return p8().domain(e).range(t).unknown(r)},hi.apply(i,arguments)}var iX=new Date,oX=new Date;function br(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return br(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return iX.setTime(+o),oX.setTime(+a),e(iX),e(oX),Math.floor(r(iX,oX))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var d8=br(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});d8.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?br(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):d8};var J_=d8,aX=d8.range;var Q_=1e3,uc=6e4,Gb=36e5,m8=864e5,g8=6048e5;var j2t=br(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*Q_)},function(e,t){return(t-e)/Q_},function(e){return e.getUTCSeconds()}),ty=j2t,sX=j2t.range;var X2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*Q_)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getMinutes()}),_8=X2t,$2t=X2t.range;var K2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*Q_-e.getMinutes()*uc)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getHours()}),y8=K2t,Z2t=K2t.range;var J2t=br(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*uc)/m8},function(e){return e.getDate()-1}),ey=J2t,Q2t=J2t.range;function ry(e){return br(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*uc)/g8})}var ng=ry(0),ny=ry(1),lX=ry(2),cX=ry(3),Fp=ry(4),uX=ry(5),hX=ry(6),fX=ng.range,twt=ny.range,ewt=lX.range,rwt=cX.range,nwt=Fp.range,iwt=uX.range,owt=hX.range;var awt=br(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),v8=awt,swt=awt.range;var pX=br(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});pX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};var Wh=pX,lwt=pX.range;var cwt=br(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getUTCMinutes()}),x8=cwt,uwt=cwt.range;var hwt=br(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getUTCHours()}),b8=hwt,fwt=hwt.range;var pwt=br(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/m8},function(e){return e.getUTCDate()-1}),iy=pwt,dwt=pwt.range;function oy(e){return br(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/g8})}var ig=oy(0),ay=oy(1),dX=oy(2),mX=oy(3),Bp=oy(4),gX=oy(5),_X=oy(6),yX=ig.range,mwt=ay.range,gwt=dX.range,_wt=mX.range,ywt=Bp.range,vwt=gX.range,xwt=_X.range;var bwt=br(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),w8=bwt,wwt=bwt.range;var vX=br(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});vX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};var Yh=vX,Swt=vX.range;function xX(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function bX(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function x5(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function S5(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=b5(i),u=w5(i),h=b5(o),f=w5(o),p=b5(a),d=w5(a),g=b5(s),_=w5(s),y=b5(l),x=w5(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:Pwt,e:Pwt,f:jMe,g:nEe,G:oEe,H:GMe,I:WMe,j:YMe,L:Nwt,m:XMe,M:$Me,p:st,q:St,Q:kwt,s:Rwt,S:KMe,u:ZMe,U:JMe,V:QMe,w:tEe,W:eEe,x:null,X:null,y:rEe,Y:iEe,Z:aEe,"%":Lwt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:Iwt,e:Iwt,f:uEe,g:xEe,G:wEe,H:sEe,I:lEe,j:cEe,L:Owt,m:hEe,M:fEe,p:_t,q:ct,Q:kwt,s:Rwt,S:pEe,u:dEe,U:mEe,V:gEe,w:_Ee,W:yEe,x:null,X:null,y:vEe,Y:bEe,Z:SEe,"%":Lwt},C={a:B,A:I,b:L,B:R,c:F,d:Cwt,e:Cwt,f:HMe,g:Twt,G:Ewt,H:Awt,I:Awt,j:OMe,L:BMe,m:DMe,M:zMe,p:D,q:NMe,Q:UMe,s:qMe,S:FMe,u:PMe,U:IMe,V:LMe,w:AMe,W:kMe,x:z,X:U,y:Twt,Y:Ewt,Z:RMe,"%":VMe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=Mwt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=x5(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=bX(x5(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?ay.ceil(ht):ay(ht),ht=iy.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=xX(x5(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?ny.ceil(ht):ny(ht),ht=ey.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?bX(x5(q.y,0,1)).getUTCDay():xX(x5(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,bX(q)):xX(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in Mwt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}var Mwt={"-":"",_:" ",0:"0"},xo=/^\s*\d+/,EMe=/^%/,TMe=/[\\^$*+?|[\]().{}]/g;function Br(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function CMe(e){return e.replace(TMe,"\\$&")}function b5(e){return new RegExp("^(?:"+e.map(CMe).join("|")+")","i")}function w5(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function AMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function PMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function IMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function LMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function kMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function Ewt(e,t,r){var n=xo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function Twt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function RMe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function NMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function DMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function Cwt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function OMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function Awt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function zMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function FMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function BMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function HMe(e,t,r){var n=xo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function VMe(e,t,r){var n=EMe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function UMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function qMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function Pwt(e,t){return Br(e.getDate(),t,2)}function GMe(e,t){return Br(e.getHours(),t,2)}function WMe(e,t){return Br(e.getHours()%12||12,t,2)}function YMe(e,t){return Br(1+ey.count(Wh(e),e),t,3)}function Nwt(e,t){return Br(e.getMilliseconds(),t,3)}function jMe(e,t){return Nwt(e,t)+"000"}function XMe(e,t){return Br(e.getMonth()+1,t,2)}function $Me(e,t){return Br(e.getMinutes(),t,2)}function KMe(e,t){return Br(e.getSeconds(),t,2)}function ZMe(e){var t=e.getDay();return t===0?7:t}function JMe(e,t){return Br(ng.count(Wh(e)-1,e),t,2)}function Dwt(e){var t=e.getDay();return t>=4||t===0?Fp(e):Fp.ceil(e)}function QMe(e,t){return e=Dwt(e),Br(Fp.count(Wh(e),e)+(Wh(e).getDay()===4),t,2)}function tEe(e){return e.getDay()}function eEe(e,t){return Br(ny.count(Wh(e)-1,e),t,2)}function rEe(e,t){return Br(e.getFullYear()%100,t,2)}function nEe(e,t){return e=Dwt(e),Br(e.getFullYear()%100,t,2)}function iEe(e,t){return Br(e.getFullYear()%1e4,t,4)}function oEe(e,t){var r=e.getDay();return e=r>=4||r===0?Fp(e):Fp.ceil(e),Br(e.getFullYear()%1e4,t,4)}function aEe(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Br(t/60|0,"0",2)+Br(t%60,"0",2)}function Iwt(e,t){return Br(e.getUTCDate(),t,2)}function sEe(e,t){return Br(e.getUTCHours(),t,2)}function lEe(e,t){return Br(e.getUTCHours()%12||12,t,2)}function cEe(e,t){return Br(1+iy.count(Yh(e),e),t,3)}function Owt(e,t){return Br(e.getUTCMilliseconds(),t,3)}function uEe(e,t){return Owt(e,t)+"000"}function hEe(e,t){return Br(e.getUTCMonth()+1,t,2)}function fEe(e,t){return Br(e.getUTCMinutes(),t,2)}function pEe(e,t){return Br(e.getUTCSeconds(),t,2)}function dEe(e){var t=e.getUTCDay();return t===0?7:t}function mEe(e,t){return Br(ig.count(Yh(e)-1,e),t,2)}function zwt(e){var t=e.getUTCDay();return t>=4||t===0?Bp(e):Bp.ceil(e)}function gEe(e,t){return e=zwt(e),Br(Bp.count(Yh(e),e)+(Yh(e).getUTCDay()===4),t,2)}function _Ee(e){return e.getUTCDay()}function yEe(e,t){return Br(ay.count(Yh(e)-1,e),t,2)}function vEe(e,t){return Br(e.getUTCFullYear()%100,t,2)}function xEe(e,t){return e=zwt(e),Br(e.getUTCFullYear()%100,t,2)}function bEe(e,t){return Br(e.getUTCFullYear()%1e4,t,4)}function wEe(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Bp(e):Bp.ceil(e),Br(e.getUTCFullYear()%1e4,t,4)}function SEe(){return"+0000"}function Lwt(){return"%"}function kwt(e){return+e}function Rwt(e){return Math.floor(+e/1e3)}var Wb,M5,wX,sy,E5;S8({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function S8(e){return Wb=S5(e),M5=Wb.format,wX=Wb.parse,sy=Wb.utcFormat,E5=Wb.utcParse,Wb}var SX="%Y-%m-%dT%H:%M:%S.%LZ";function MEe(e){return e.toISOString()}var EEe=Date.prototype.toISOString?MEe:sy(SX),Fwt=EEe;function TEe(e){var t=new Date(e);return isNaN(t)?null:t}var CEe=+new Date("2000-01-01T00:00:00.000Z")?TEe:E5(SX),Bwt=CEe;var T5=1e3,C5=T5*60,A5=C5*60,P5=A5*24,AEe=P5*7,Hwt=P5*30,MX=P5*365;function PEe(e){return new Date(e)}function IEe(e){return e instanceof Date?+e:+new Date(+e)}function M8(e,t,r,n,i,o,a,s,l){var c=g5(ni,ni),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,T5],[a,5,5*T5],[a,15,15*T5],[a,30,30*T5],[o,1,C5],[o,5,5*C5],[o,15,15*C5],[o,30,30*C5],[i,1,A5],[i,3,3*A5],[i,6,6*A5],[i,12,12*A5],[n,1,P5],[n,2,2*P5],[r,1,AEe],[t,1,Hwt],[t,3,3*Hwt],[e,1,MX]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=ob(function(R){return R[2]}).right(S,I);L===S.length?(B=el(O/MX,D/MX,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(el(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h($_.call(k,IEe)):h().map(PEe)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(h8(D,k)):c},c.copy=function(){return Gh(c,M8(e,t,r,n,i,o,a,s,l))},c}function Yb(){return hi.apply(M8(Wh,v8,ng,ey,y8,_8,ty,J_,M5).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Vwt(){return hi.apply(M8(Yh,w8,ig,iy,b8,x8,ty,J_,sy).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)}function E8(){var e=0,t=1,r,n,i,o,a=ni,s=!1,l;function c(u){return isNaN(u=+u)?l:a(i===0?.5:(u=(o(u)-r)*i,s?Math.max(0,Math.min(1,u)):u))}return c.domain=function(u){return arguments.length?(r=o(e=+u[0]),n=o(t=+u[1]),i=r===n?0:1/(n-r),c):[e,t]},c.clamp=function(u){return arguments.length?(s=!!u,c):s},c.interpolator=function(u){return arguments.length?(a=u,c):a},c.unknown=function(u){return arguments.length?(l=u,c):l},function(u){return o=u,r=u(e),n=u(t),i=r===n?0:1/(n-r),c}}function Hp(e,t){return t.domain(e.domain()).interpolator(e.interpolator()).clamp(e.clamp()).unknown(e.unknown())}function T8(){var e=ol(E8()(ni));return e.copy=function(){return Hp(e,T8())},sc.apply(e,arguments)}function EX(){var e=_5(E8()).domain([1,10]);return e.copy=function(){return Hp(e,EX()).base(e.base())},sc.apply(e,arguments)}function TX(){var e=y5(E8());return e.copy=function(){return Hp(e,TX()).constant(e.constant())},sc.apply(e,arguments)}function C8(){var e=v5(E8());return e.copy=function(){return Hp(e,C8()).exponent(e.exponent())},sc.apply(e,arguments)}function Uwt(){return C8.apply(null,arguments).exponent(.5)}function A8(){var e=[],t=ni;function r(n){if(!isNaN(n=+n))return t((vs(e,n)-1)/(e.length-1))}return r.domain=function(n){if(!arguments.length)return e.slice();e=[];for(var i=0,o=n.length,a;i<o;++i)a=n[i],a!=null&&!isNaN(a=+a)&&e.push(a);return e.sort(aa),r},r.interpolator=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return A8(t).domain(e)},sc.apply(r,arguments)}function P8(){var e=0,t=.5,r=1,n,i,o,a,s,l=ni,c,u=!1,h;function f(p){return isNaN(p=+p)?h:(p=.5+((p=+c(p))-i)*(p<i?a:s),l(u?Math.max(0,Math.min(1,p)):p))}return f.domain=function(p){return arguments.length?(n=c(e=+p[0]),i=c(t=+p[1]),o=c(r=+p[2]),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f):[e,t,r]},f.clamp=function(p){return arguments.length?(u=!!p,f):u},f.interpolator=function(p){return arguments.length?(l=p,f):l},f.unknown=function(p){return arguments.length?(h=p,f):h},function(p){return c=p,n=p(e),i=p(t),o=p(r),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f}}function I8(){var e=ol(P8()(ni));return e.copy=function(){return Hp(e,I8())},sc.apply(e,arguments)}function CX(){var e=_5(P8()).domain([.1,1,10]);return e.copy=function(){return Hp(e,CX()).base(e.base())},sc.apply(e,arguments)}function AX(){var e=y5(P8());return e.copy=function(){return Hp(e,AX()).constant(e.constant())},sc.apply(e,arguments)}function L8(){var e=v5(P8());return e.copy=function(){return Hp(e,L8()).exponent(e.exponent())},sc.apply(e,arguments)}function qwt(){return L8.apply(null,arguments).exponent(.5)}function te(e){for(var t=e.length/6|0,r=new Array(t),n=0;n<t;)r[n]="#"+e.slice(n*6,++n*6);return r}var jb=te("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf");var Gwt=te("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666");var Wwt=te("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");var Ywt=te("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");var jwt=te("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2");var Xwt=te("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc");var $wt=te("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999");var Kwt=te("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3");var Zwt=te("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");var Jwt=te("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function Ie(e){return uL(e[e.length-1])}var PX=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(te),Qwt=Ie(PX);var IX=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(te),tSt=Ie(IX);var LX=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(te),eSt=Ie(LX);var kX=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(te),rSt=Ie(kX);var RX=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(te),nSt=Ie(RX);var NX=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(te),iSt=Ie(NX);var DX=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(te),oSt=Ie(DX);var OX=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(te),aSt=Ie(OX);var zX=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(te),sSt=Ie(zX);var FX=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(te),lSt=Ie(FX);var BX=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(te),cSt=Ie(BX);var HX=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(te),uSt=Ie(HX);var VX=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(te),hSt=Ie(VX);var UX=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(te),fSt=Ie(UX);var qX=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(te),pSt=Ie(qX);var GX=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(te),dSt=Ie(GX);var WX=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(te),mSt=Ie(WX);var YX=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(te),gSt=Ie(YX);var jX=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(te),_St=Ie(jX);var XX=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(te),ySt=Ie(XX);var $X=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(te),vSt=Ie($X);var KX=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(te),xSt=Ie(KX);var ZX=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(te),bSt=Ie(ZX);var JX=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(te),wSt=Ie(JX);var QX=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(te),SSt=Ie(QX);var t$=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(te),MSt=Ie(t$);var e$=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(te),ESt=Ie(e$);function TSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-e*(35.34-e*(2381.73-e*(6402.7-e*(7024.72-e*2710.57)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+e*(170.73+e*(52.82-e*(131.46-e*(176.58-e*67.37)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+e*(442.36-e*(2482.43-e*(6167.24-e*(6614.94-e*2475.67)))))))+")"}var CSt=T_(ca(300,.5,0),ca(-240,.5,1));var ASt=T_(ca(-100,.75,.35),ca(80,1.5,.8)),PSt=T_(ca(260,.75,.35),ca(80,1.5,.8)),k8=ca();function ISt(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return k8.h=360*e-100,k8.s=1.5-1.5*t,k8.l=.8-.9*t,k8+""}var R8=cu(),LEe=Math.PI/3,kEe=Math.PI*2/3;function LSt(e){var t;return e=(.5-e)*Math.PI,R8.r=255*(t=Math.sin(e))*t,R8.g=255*(t=Math.sin(e+LEe))*t,R8.b=255*(t=Math.sin(e+kEe))*t,R8+""}function kSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+e*(1172.33-e*(10793.56-e*(33300.12-e*(38394.49-e*14825.05)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+e*(557.33+e*(1225.33-e*(3574.96-e*(1073.77+e*707.56)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+e*(3211.1-e*(15327.97-e*(27814-e*(22569.18-e*6838.66)))))))+")"}function N8(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var RSt=N8(te("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),NSt=N8(te("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),DSt=N8(te("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),OSt=N8(te("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function qe(e){return function(){return e}}var r$=Math.abs,Bo=Math.atan2,og=Math.cos,zSt=Math.max,D8=Math.min,_u=Math.sin,ly=Math.sqrt,bo=1e-12,yu=Math.PI,I5=yu/2,hc=2*yu;function FSt(e){return e>1?0:e<-1?yu:Math.acos(e)}function n$(e){return e>=1?I5:e<=-1?-I5:Math.asin(e)}function REe(e){return e.innerRadius}function NEe(e){return e.outerRadius}function DEe(e){return e.startAngle}function OEe(e){return e.endAngle}function zEe(e){return e&&e.padAngle}function FEe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=h*l-u*c;if(!(f*f<bo))return f=(u*(t-o)-h*(e-i))/f,[e+f*l,t+f*c]}function O8(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/ly(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*ly(zSt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function BSt(){var e=REe,t=NEe,r=qe(0),n=null,i=DEe,o=OEe,a=zEe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-I5,d=o.apply(this,arguments)-I5,g=r$(d-p),_=d>p;if(s||(s=c=ws()),f<h&&(u=f,f=h,h=u),!(f>bo))s.moveTo(0,0);else if(g>hc-bo)s.moveTo(f*og(p),f*_u(p)),s.arc(0,0,f,p,d,!_),h>bo&&(s.moveTo(h*og(d),h*_u(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>bo&&(n?+n.apply(this,arguments):ly(h*h+f*f)),D=D8(r$(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>bo){var F=n$(O/h*_u(k)),z=n$(O/f*_u(k));(C-=F*2)>bo?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>bo?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*og(y),W=f*_u(y),Z=h*og(S),rt=h*_u(S);if(D>bo){var ot=f*og(x),st=f*_u(x),St=h*og(b),bt=h*_u(b),Mt;if(g<yu&&(Mt=FEe(U,W,St,bt,ot,st,Z,rt))){var lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/_u(FSt((lt*_t+Kt*ct)/(ly(lt*lt+Kt*Kt)*ly(_t*_t+ct*ct)))/2),et=ly(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=D8(D,(h-et)/(X-1)),I=D8(D,(f-et)/(X+1))}}P>bo?I>bo?(L=O8(St,bt,U,W,f,I,_),R=O8(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,f,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>bo)||!(C>bo)?s.lineTo(Z,rt):B>bo?(L=O8(Z,rt,ot,st,h,-B,_),R=O8(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,h,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-yu/2;return[og(u)*c,_u(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:qe(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:qe(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:qe(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:qe(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:qe(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:qe(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:qe(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}function HSt(e){this._context=e}HSt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function jh(e){return new HSt(e)}function Xb(e){return e[0]}function $b(e){return e[1]}function vu(){var e=Xb,t=$b,r=qe(!0),n=null,i=jh,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=ws())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:qe(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:qe(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}function z8(){var e=Xb,t=null,r=qe(0),n=$b,i=qe(!0),o=null,a=jh,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=ws())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return vu().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:qe(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:qe(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:qe(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}function VSt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function USt(e){return e}function qSt(){var e=USt,t=VSt,r=null,n=qe(0),i=qe(hc),o=qe(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(hc,Math.max(-hc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:qe(+s),a):o},a}var F8=Kb(jh);function GSt(e){this._curve=e}GSt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}};function Kb(e){function t(r){return new GSt(e(r))}return t._curve=e,t}function Zb(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Kb(r)):t()._curve},e}function i$(){return Zb(vu().curve(F8))}function o$(){var e=z8().curve(F8),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Zb(r())},delete e.lineX0,e.lineEndAngle=function(){return Zb(n())},delete e.lineX1,e.lineInnerRadius=function(){return Zb(i())},delete e.lineY0,e.lineOuterRadius=function(){return Zb(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Kb(a)):t()._curve},e}function cy(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var L5=Array.prototype.slice;function BEe(e){return e.source}function HEe(e){return e.target}function a$(e){var t=BEe,r=HEe,n=Xb,i=$b,o=null;function a(){var s,l=L5.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=ws()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function VEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function UEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function qEe(e,t,r,n,i){var o=cy(t,r),a=cy(t,r=(r+i)/2),s=cy(n,r),l=cy(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function WSt(){return a$(VEe)}function YSt(){return a$(UEe)}function jSt(){var e=a$(qEe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var k5={draw:function(e,t){var r=Math.sqrt(t/yu);e.moveTo(r,0),e.arc(0,0,r,0,hc)}};var B8={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}};var XSt=Math.sqrt(.3333333333333333),GEe=XSt*2,H8={draw:function(e,t){var r=Math.sqrt(t/GEe),n=r*XSt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}};var WEe=.8908130915292852,$St=Math.sin(yu/10)/Math.sin(7*yu/10),YEe=Math.sin(hc/10)*$St,jEe=-Math.cos(hc/10)*$St,V8={draw:function(e,t){var r=Math.sqrt(t*WEe),n=YEe*r,i=jEe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=hc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}};var U8={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}};var s$=Math.sqrt(3),q8={draw:function(e,t){var r=-Math.sqrt(t/(s$*3));e.moveTo(0,r*2),e.lineTo(-s$*r,-r),e.lineTo(s$*r,-r),e.closePath()}};var fc=-.5,pc=Math.sqrt(3)/2,l$=1/Math.sqrt(12),XEe=(l$/2+1)*3,G8={draw:function(e,t){var r=Math.sqrt(t/XEe),n=r/2,i=r*l$,o=n,a=r*l$+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(fc*n-pc*i,pc*n+fc*i),e.lineTo(fc*o-pc*a,pc*o+fc*a),e.lineTo(fc*s-pc*l,pc*s+fc*l),e.lineTo(fc*n+pc*i,fc*i-pc*n),e.lineTo(fc*o+pc*a,fc*a-pc*o),e.lineTo(fc*s+pc*l,fc*l-pc*s),e.closePath()}};var KSt=[k5,B8,H8,U8,V8,q8,G8];function ZSt(){var e=qe(k5),t=qe(64),r=null;function n(){var i;if(r||(r=i=ws()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:qe(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:qe(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}function dc(){}function Jb(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function R5(e){this._context=e}R5.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Jb(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function W8(e){return new R5(e)}function JSt(e){this._context=e}JSt.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function QSt(e){return new JSt(e)}function t3t(e){this._context=e}t3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function e3t(e){return new t3t(e)}function r3t(e,t){this._basis=new R5(e),this._beta=t}r3t.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};var n3t=function e(t){function r(n){return t===1?new R5(n):new r3t(n,t)}return r.beta=function(n){return e(+n)},r}(.85);function Qb(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function Y8(e,t){this._context=e,this._k=(1-t)/6}Y8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Qb(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var i3t=function e(t){function r(n){return new Y8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function j8(e,t){this._context=e,this._k=(1-t)/6}j8.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var o3t=function e(t){function r(n){return new j8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function X8(e,t){this._context=e,this._k=(1-t)/6}X8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var a3t=function e(t){function r(n){return new X8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function N5(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>bo){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>bo){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function s3t(e,t){this._context=e,this._alpha=t}s3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var l3t=function e(t){function r(n){return t?new s3t(n,t):new Y8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function c3t(e,t){this._context=e,this._alpha=t}c3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var u3t=function e(t){function r(n){return t?new c3t(n,t):new j8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function h3t(e,t){this._context=e,this._alpha=t}h3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:N5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var f3t=function e(t){function r(n){return t?new h3t(n,t):new X8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function p3t(e){this._context=e}p3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function d3t(e){return new p3t(e)}function m3t(e){return e<0?-1:1}function g3t(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(m3t(o)+m3t(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function _3t(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function c$(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function $8(e){this._context=e}$8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:c$(this,this._t0,_3t(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,c$(this,_3t(this,r=g3t(this,e,t)),r);break;default:c$(this,this._t0,r=g3t(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function y3t(e){this._context=new v3t(e)}(y3t.prototype=Object.create($8.prototype)).point=function(e,t){$8.prototype.point.call(this,t,e)};function v3t(e){this._context=e}v3t.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}};function x3t(e){return new $8(e)}function b3t(e){return new y3t(e)}function S3t(e){this._context=e}S3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=w3t(e),i=w3t(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}};function w3t(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function M3t(e){return new S3t(e)}function K8(e,t){this._context=e,this._t=t}K8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function E3t(e){return new K8(e,.5)}function T3t(e){return new K8(e,0)}function C3t(e){return new K8(e,1)}function xu(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function bu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}function $Ee(e,t){return e[t]}function A3t(){var e=qe([]),t=bu,r=xu,n=$Ee;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:qe(L5.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:qe(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?bu:typeof o=="function"?o:qe(L5.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?xu:o,i):r},i}function P3t(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}xu(e,t)}}function I3t(e,t){if((l=e.length)>0)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):(i[0]=0,i[1]=o)}function L3t(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}xu(e,t)}}function k3t(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,xu(e,t)}}function Z8(e){var t=e.map(KEe);return bu(e).sort(function(r,n){return t[r]-t[n]})}function KEe(e){for(var t=-1,r=0,n=e.length,i,o=-1/0;++t<n;)(i=+e[t][1])>o&&(o=i,r=t);return r}function J8(e){var t=e.map(u$);return bu(e).sort(function(r,n){return t[r]-t[n]})}function u$(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}function R3t(e){return J8(e).reverse()}function N3t(e){var t=e.length,r,n,i=e.map(u$),o=Z8(e),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}function D3t(e){return bu(e).reverse()}function h$(e){return function(){return e}}function O3t(e){return e[0]}function z3t(e){return e[1]}function f$(){this._=null}function t2(e){e.U=e.C=e.L=e.R=e.P=e.N=null}f$.prototype={constructor:f$,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=F3t(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(D5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,O5(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(O5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,D5(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=F3t(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,D5(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,O5(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,D5(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,O5(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,D5(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,O5(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};function D5(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function O5(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function F3t(e){for(;e.L;)e=e.L;return e}var p$=f$;function e2(e,t,r,n){var i=[null,null],o=wo.push(i)-1;return i.left=e,i.right=t,r&&z5(i,e,t,r),n&&z5(i,t,e,n),Ua[e.index].halfedges.push(o),Ua[t.index].halfedges.push(o),i}function r2(e,t,r){var n=[t,r];return n.left=e,n}function z5(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function ZEe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function JEe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function B3t(e,t,r,n){for(var i=wo.length,o;i--;)(!JEe(o=wo[i],e,t,r,n)||!ZEe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Hr||Math.abs(o[0][1]-o[1][1])>Hr))&&delete wo[i]}function H3t(e){return Ua[e.index]={site:e,halfedges:[]}}function QEe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function d$(e,t){return t[+(t.left!==e.site)]}function t5e(e,t){return t[+(t.left===e.site)]}function V3t(){for(var e=0,t=Ua.length,r,n,i,o;e<t;++e)if((r=Ua[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=QEe(r,wo[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function U3t(e,t,r,n){var i=Ua.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Ua[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)wo[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=t5e(a,wo[c[l]]),g=d[0],_=d[1],h=d$(a,wo[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Hr||Math.abs(_-p)>Hr)&&(c.splice(l,0,wo.push(r2(s,d,Math.abs(g-e)<Hr&&n-_>Hr?[e,Math.abs(f-e)<Hr?p:n]:Math.abs(_-n)<Hr&&r-g>Hr?[Math.abs(p-n)<Hr?f:r,n]:Math.abs(g-r)<Hr&&_-t>Hr?[r,Math.abs(f-r)<Hr?p:t]:Math.abs(_-t)<Hr&&g-e>Hr?[Math.abs(p-t)<Hr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Ua[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(wo.push(r2(s=y.site,P,k))-1,wo.push(r2(s,k,O))-1,wo.push(r2(s,O,D))-1,wo.push(r2(s,D,P))-1)}}for(o=0;o<i;++o)(a=Ua[o])&&(a.halfedges.length||delete Ua[o])}var q3t=[],Q8;function e5e(){t2(this),this.x=this.y=this.arc=this.site=this.cy=null}function uy(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-G3t)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=q3t.pop()||new e5e;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=n2._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}n2.insert(x,y),x||(Q8=y)}}}}function hy(e){var t=e.circle;t&&(t.P||(Q8=t.N),n2.remove(t),q3t.push(t),t2(t),e.circle=null)}var Y3t=[];function r5e(){t2(this),this.edge=this.site=this.circle=null}function W3t(e){var t=Y3t.pop()||new r5e;return t.site=e,t}function m$(e){hy(e),fy.remove(e),Y3t.push(e),t2(e)}function j3t(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];m$(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Hr&&Math.abs(n-l.circle.cy)<Hr;)o=l.P,s.unshift(l),m$(l),l=o;s.unshift(l),hy(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Hr&&Math.abs(n-c.circle.cy)<Hr;)a=c.N,s.push(c),m$(c),c=a;s.push(c),hy(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],z5(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=e2(l.site,c.site,null,i),uy(l),uy(c)}function X3t(e){for(var t=e[0],r=e[1],n,i,o,a,s=fy._;s;)if(o=$3t(s,r)-t,o>Hr)s=s.L;else if(a=t-n5e(s,r),a>Hr){if(!s.R){n=s;break}s=s.R}else{o>-Hr?(n=s.P,i=s):a>-Hr?(n=s,i=s.N):n=i=s;break}H3t(e);var l=W3t(e);if(fy.insert(n,l),!(!n&&!i)){if(n===i){hy(n),i=W3t(n.site),fy.insert(l,i),l.edge=i.edge=e2(n.site,l.site),uy(n),uy(i);return}if(!i){l.edge=e2(n.site,l.site);return}hy(n),hy(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];z5(i.edge,c,d,S),l.edge=e2(c,e,null,S),i.edge=e2(e,d,null,S),uy(n),uy(i)}}function $3t(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function n5e(e,t){var r=e.N;if(r)return $3t(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var Hr=1e-6,G3t=1e-12,fy,Ua,n2,wo;function i5e(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function o5e(e,t){return t[1]-e[1]||t[0]-e[0]}function F5(e,t){var r=e.sort(o5e).pop(),n,i,o;for(wo=[],Ua=new Array(e.length),fy=new p$,n2=new p$;;)if(o=Q8,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(X3t(r),n=r[0],i=r[1]),r=e.pop();else if(o)j3t(o.arc);else break;if(V3t(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];B3t(a,s,l,c),U3t(a,s,l,c)}this.edges=wo,this.cells=Ua,fy=n2=wo=Ua=null}F5.prototype={constructor:F5,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return d$(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&i5e(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}};function K3t(){var e=O3t,t=z3t,r=null;function n(i){return new F5(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Hr)*Hr,Math.round(t(o,a,i)/Hr)*Hr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:h$(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:h$(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}Rm();function B5(e){return function(){return e}}function g$(e,t,r){this.target=e,this.type=t,this.transform=r}function Xh(e,t,r){this.k=e,this.x=t,this.y=r}Xh.prototype={constructor:Xh,scale:function(e){return e===1?this:new Xh(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new Xh(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var $h=new Xh(1,0,0);i2.prototype=Xh.prototype;function i2(e){for(;!e.__zoom;)if(!(e=e.parentNode))return $h;return e.__zoom}function tR(){qt.stopImmediatePropagation()}function o2(){qt.preventDefault(),qt.stopImmediatePropagation()}function a5e(){return!qt.ctrlKey&&!qt.button}function s5e(){var e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]):[[0,0],[e.clientWidth,e.clientHeight]]}function Z3t(){return this.__zoom||$h}function l5e(){return-qt.deltaY*(qt.deltaMode===1?.05:qt.deltaMode?1:.002)}function c5e(){return navigator.maxTouchPoints||"ontouchstart"in this}function u5e(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function eR(){var e=a5e,t=s5e,r=u5e,n=l5e,i=c5e,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=vL,c=xs("start","zoom","end"),u,h,f=500,p=150,d=0;function g(L){L.property("__zoom",Z3t).on("wheel.zoom",P).on("mousedown.zoom",k).on("dblclick.zoom",O).filter(i).on("touchstart.zoom",D).on("touchmove.zoom",B).on("touchend.zoom touchcancel.zoom",I).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}g.transform=function(L,R,F){var z=L.selection?L.selection():L;z.property("__zoom",Z3t),L!==z?b(L,R,F):z.interrupt().each(function(){S(this,arguments).start().zoom(null,typeof R=="function"?R.apply(this,arguments):R).end()})},g.scaleBy=function(L,R,F){g.scaleTo(L,function(){var z=this.__zoom.k,U=typeof R=="function"?R.apply(this,arguments):R;return z*U},F)},g.scaleTo=function(L,R,F){g.transform(L,function(){var z=t.apply(this,arguments),U=this.__zoom,W=F==null?x(z):typeof F=="function"?F.apply(this,arguments):F,Z=U.invert(W),rt=typeof R=="function"?R.apply(this,arguments):R;return r(y(_(U,rt),W,Z),z,a)},F)},g.translateBy=function(L,R,F){g.transform(L,function(){return r(this.__zoom.translate(typeof R=="function"?R.apply(this,arguments):R,typeof F=="function"?F.apply(this,arguments):F),t.apply(this,arguments),a)})},g.translateTo=function(L,R,F,z){g.transform(L,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=z==null?x(U):typeof z=="function"?z.apply(this,arguments):z;return r($h.translate(Z[0],Z[1]).scale(W.k).translate(typeof R=="function"?-R.apply(this,arguments):-R,typeof F=="function"?-F.apply(this,arguments):-F),U,a)},z)};function _(L,R){return R=Math.max(o[0],Math.min(o[1],R)),R===L.k?L:new Xh(R,L.x,L.y)}function y(L,R,F){var z=R[0]-F[0]*L.k,U=R[1]-F[1]*L.k;return z===L.x&&U===L.y?L:new Xh(L.k,z,U)}function x(L){return[(+L[0][0]+ +L[1][0])/2,(+L[0][1]+ +L[1][1])/2]}function b(L,R,F){L.on("start.zoom",function(){S(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){S(this,arguments).end()}).tween("zoom",function(){var z=this,U=arguments,W=S(z,U),Z=t.apply(z,U),rt=F==null?x(Z):typeof F=="function"?F.apply(z,U):F,ot=Math.max(Z[1][0]-Z[0][0],Z[1][1]-Z[0][1]),st=z.__zoom,St=typeof R=="function"?R.apply(z,U):R,bt=l(st.invert(rt).concat(ot/st.k),St.invert(rt).concat(ot/St.k));return function(Mt){if(Mt===1)Mt=St;else{var lt=bt(Mt),Kt=ot/lt[2];Mt=new Xh(Kt,rt[0]-lt[0]*Kt,rt[1]-lt[1]*Kt)}W.zoom(null,Mt)}})}function S(L,R,F){return!F&&L.__zooming||new C(L,R)}function C(L,R){this.that=L,this.args=R,this.active=0,this.extent=t.apply(L,R),this.taps=0}C.prototype={start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(L,R){return this.mouse&&L!=="mouse"&&(this.mouse[1]=R.invert(this.mouse[0])),this.touch0&&L!=="touch"&&(this.touch0[1]=R.invert(this.touch0[0])),this.touch1&&L!=="touch"&&(this.touch1[1]=R.invert(this.touch1[0])),this.that.__zoom=R,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(L){Ep(new g$(g,L,this.that.__zoom),c.apply,c,[L,this.that,this.args])}};function P(){if(!e.apply(this,arguments))return;var L=S(this,arguments),R=this.__zoom,F=Math.max(o[0],Math.min(o[1],R.k*Math.pow(2,n.apply(this,arguments)))),z=zo(this);if(L.wheel)(L.mouse[0][0]!==z[0]||L.mouse[0][1]!==z[1])&&(L.mouse[1]=R.invert(L.mouse[0]=z)),clearTimeout(L.wheel);else{if(R.k===F)return;L.mouse=[z,R.invert(z)],hu(this),L.start()}o2(),L.wheel=setTimeout(U,p),L.zoom("mouse",r(y(_(R,F),L.mouse[0],L.mouse[1]),L.extent,a));function U(){L.wheel=null,L.end()}}function k(){if(h||!e.apply(this,arguments))return;var L=S(this,arguments,!0),R=Ht(qt.view).on("mousemove.zoom",W,!0).on("mouseup.zoom",Z,!0),F=zo(this),z=qt.clientX,U=qt.clientY;Fm(qt.view),tR(),L.mouse=[F,this.__zoom.invert(F)],hu(this),L.start();function W(){if(o2(),!L.moved){var rt=qt.clientX-z,ot=qt.clientY-U;L.moved=rt*rt+ot*ot>d}L.zoom("mouse",r(y(L.that.__zoom,L.mouse[0]=zo(L.that),L.mouse[1]),L.extent,a))}function Z(){R.on("mousemove.zoom mouseup.zoom",null),Bm(qt.view,L.moved),o2(),L.end()}}function O(){if(!!e.apply(this,arguments)){var L=this.__zoom,R=zo(this),F=L.invert(R),z=L.k*(qt.shiftKey?.5:2),U=r(y(_(L,z),R,F),t.apply(this,arguments),a);o2(),s>0?Ht(this).transition().duration(s).call(b,U,R):Ht(this).call(g.transform,U)}}function D(){if(!!e.apply(this,arguments)){var L=qt.touches,R=L.length,F=S(this,arguments,qt.changedTouches.length===R),z,U,W,Z;for(tR(),U=0;U<R;++U)W=L[U],Z=Cp(this,L,W.identifier),Z=[Z,this.__zoom.invert(Z),W.identifier],F.touch0?!F.touch1&&F.touch0[2]!==Z[2]&&(F.touch1=Z,F.taps=0):(F.touch0=Z,z=!0,F.taps=1+!!u);u&&(u=clearTimeout(u)),z&&(F.taps<2&&(u=setTimeout(function(){u=null},f)),hu(this),F.start())}}function B(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U,W,Z;for(o2(),u&&(u=clearTimeout(u)),L.taps=0,z=0;z<F;++z)U=R[z],W=Cp(this,R,U.identifier),L.touch0&&L.touch0[2]===U.identifier?L.touch0[0]=W:L.touch1&&L.touch1[2]===U.identifier&&(L.touch1[0]=W);if(U=L.that.__zoom,L.touch1){var rt=L.touch0[0],ot=L.touch0[1],st=L.touch1[0],St=L.touch1[1],bt=(bt=st[0]-rt[0])*bt+(bt=st[1]-rt[1])*bt,Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt;U=_(U,Math.sqrt(bt/Mt)),W=[(rt[0]+st[0])/2,(rt[1]+st[1])/2],Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2]}else if(L.touch0)W=L.touch0[0],Z=L.touch0[1];else return;L.zoom("touch",r(y(U,W,Z),L.extent,a))}}function I(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U;for(tR(),h&&clearTimeout(h),h=setTimeout(function(){h=null},f),z=0;z<F;++z)U=R[z],L.touch0&&L.touch0[2]===U.identifier?delete L.touch0:L.touch1&&L.touch1[2]===U.identifier&&delete L.touch1;if(L.touch1&&!L.touch0&&(L.touch0=L.touch1,delete L.touch1),L.touch0)L.touch0[1]=this.__zoom.invert(L.touch0[0]);else if(L.end(),L.taps===2){var W=Ht(this).on("dblclick.zoom");W&&W.apply(this,arguments)}}}return g.wheelDelta=function(L){return arguments.length?(n=typeof L=="function"?L:B5(+L),g):n},g.filter=function(L){return arguments.length?(e=typeof L=="function"?L:B5(!!L),g):e},g.touchable=function(L){return arguments.length?(i=typeof L=="function"?L:B5(!!L),g):i},g.extent=function(L){return arguments.length?(t=typeof L=="function"?L:B5([[+L[0][0],+L[0][1]],[+L[1][0],+L[1][1]]]),g):t},g.scaleExtent=function(L){return arguments.length?(o[0]=+L[0],o[1]=+L[1],g):[o[0],o[1]]},g.translateExtent=function(L){return arguments.length?(a[0][0]=+L[0][0],a[1][0]=+L[1][0],a[0][1]=+L[0][1],a[1][1]=+L[1][1],g):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},g.constrain=function(L){return arguments.length?(r=L,g):r},g.duration=function(L){return arguments.length?(s=+L,g):s},g.interpolate=function(L){return arguments.length?(l=L,g):l},g.on=function(){var L=c.on.apply(c,arguments);return L===c?g:L},g.clickDistance=function(L){return arguments.length?(d=(L=+L)*L,g):Math.sqrt(d)},g}var J3t=Ee(Oe(),1);var rR=class extends wp{constructor(){super(...arguments),this._experiments=[]}load(){let t=_e().experiments();return this.requestManager.request(t).then(r=>{J3t.isEqual(this._experiments,r)||(this._experiments=r,this.emitChange())})}getExperiments(){return this._experiments.slice()}},nR=new rR;var h5e={googleStandard:["#db4437","#ff7043","#f4b400","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#ab47bc"],googleCool:["#9e9d24","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#607d8b"],googleWarm:["#795548","#ab47bc","#f06292","#c2185b","#db4437","#ff7043","#f4b400"],googleColorBlindAssist:["#ff7043","#00ACC1","#AB47BC","#2A56C6","#0b8043","#F7CB4D","#c0ca33","#5e35b1","#A52714"],tensorboardColorBlindAssist:["#ff7043","#0077bb","#cc3311","#33bbee","#ee3377","#009988","#bbbbbb"],colorBlindAssist1:["#4477aa","#44aaaa","#aaaa44","#aa7744","#aa4455","#aa4488"],colorBlindAssist2:["#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#882255","#aa4499"],colorBlindAssist3:["#332288","#6699cc","#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#aa4466","#882255","#661100","#aa4499"],colorBlindAssist4:["#4477aa","#66ccee","#228833","#ccbb44","#ee6677","#aa3377","#bbbbbb"],colorBlindAssist5:["#FF6DB6","#920000","#924900","#DBD100","#24FF24","#006DDB","#490092"],mldash:["#E47EAD","#F4640D","#FAA300","#F5E636","#00A077","#0077B8","#00B7ED"]},iR=h5e.tensorboardColorBlindAssist;var _$=class{constructor(t=iR){this.palette=t,this.identifiers=Ji()}setDomain(t){return this.identifiers=Ji(),t.forEach((r,n)=>{this.identifiers.set(r,this.palette[n%this.palette.length])}),this}getColor(t){if(!this.identifiers.has(t))throw new Error(`String ${t} was not in the domain.`);return this.identifiers.get(t)}};function Q3t(e,t){let r=new _$;function n(){r.setDomain(t())}return e.addListener(n),n(),i=>r.getColor(i)}var fn=Q3t(Sp,()=>Sp.getRuns()),vQr=Q3t(nR,()=>nR.getExperiments().map(({name:e})=>e));var ag=Ee(Oe(),1);ys({moduleName:"run-color-style",styleContent:`
    [color-class='light-blue'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-light-blue-500);
      --paper-checkbox-checked-ink-color: var(--paper-light-blue-500);
      --paper-checkbox-unchecked-color: var(--paper-light-blue-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-light-blue-900);
    }
    [color-class='red'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-red-500);
      --paper-checkbox-checked-ink-color: var(--paper-red-500);
      --paper-checkbox-unchecked-color: var(--paper-red-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-red-900);
    }
    [color-class='green'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-green-500);
      --paper-checkbox-checked-ink-color: var(--paper-green-500);
      --paper-checkbox-unchecked-color: var(--paper-green-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-green-900);
    }
    [color-class='purple'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-purple-500);
      --paper-checkbox-checked-ink-color: var(--paper-purple-500);
      --paper-checkbox-unchecked-color: var(--paper-purple-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-purple-900);
    }
    [color-class='teal'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-teal-500);
      --paper-checkbox-checked-ink-color: var(--paper-teal-500);
      --paper-checkbox-unchecked-color: var(--paper-teal-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-teal-900);
    }
    [color-class='pink'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-pink-500);
      --paper-checkbox-checked-ink-color: var(--paper-pink-500);
      --paper-checkbox-unchecked-color: var(--paper-pink-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-pink-900);
    }
    [color-class='orange'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-orange-500);
      --paper-checkbox-checked-ink-color: var(--paper-orange-500);
      --paper-checkbox-unchecked-color: var(--paper-orange-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-orange-900);
    }
    [color-class='brown'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-brown-500);
      --paper-checkbox-checked-ink-color: var(--paper-brown-500);
      --paper-checkbox-unchecked-color: var(--paper-brown-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-brown-900);
    }
    [color-class='indigo'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-indigo-500);
      --paper-checkbox-checked-ink-color: var(--paper-indigo-500);
      --paper-checkbox-unchecked-color: var(--paper-indigo-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-indigo-900);
    }
  `});var al=class extends Gt(mt){constructor(){super(...arguments),this.names=[],this.coloring={getColor:()=>""},this.regex="",this.selectionState={},this.maxNamesToEnableByDefault=40,this._debouncedRegexChange=this._debouncedRegexChangeImpl()}_debouncedRegexChangeImpl(){var t=ag.debounce(r=>{this.regex=r},150,{leading:!1});return function(){var r=this.$$("#names-regex").value;r==""?this.async(()=>{this.regex=r},30):t(r)}}get _regex(){var t=this.regex;try{return new RegExp(t)}catch(r){return null}}_setIsolatorIcon(){var i;var t=this.selectionState,r=ag.filter(ag.values(t)).length,n=Array.prototype.slice.call((i=this.root)==null?void 0:i.querySelectorAll(".isolator"));n.forEach(function(o){r===1&&t[o.name]?o.icon="radio-button-checked":o.icon="radio-button-unchecked"})}computeNamesMatchingRegex(t,r){let n=this._regex;return n?this.names.filter(i=>n.test(i)):this.names}computeOutSelected(t,r){var n=this.selectionState,i=this.maxNamesToEnableByDefault,o=this.namesMatchingRegex.length<=i;return this.namesMatchingRegex.filter(a=>n[a]==null?o:n[a])}synchronizeColors(t){var i,o,a,s;this._setIsolatorIcon(),((o=(i=this.root)==null?void 0:i.querySelectorAll("paper-checkbox"))!=null?o:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.updateStyles({"--paper-checkbox-checked-color":c,"--paper-checkbox-checked-ink-color":c,"--paper-checkbox-unchecked-color":c,"--paper-checkbox-unchecked-ink-color":c})}),((s=(a=this.root)==null?void 0:a.querySelectorAll(".isolator"))!=null?s:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.style.color=c}),window.requestAnimationFrame(()=>{this.updateStyles()})}_isolateName(t){var r=t.target.name,n={};this.names.forEach(function(i){n[i]=i==r}),this.selectionState=n}_checkboxChange(t){var r=t.target;let n=ag.clone(this.selectionState);n[r.name]=r.checked,this.selectionState=n}_isChecked(t,r){return this.outSelected.indexOf(t)!=-1}toggleAll(){let t=this.namesMatchingRegex.some(n=>this.outSelected.includes(n)),r={};this.names.forEach(n=>{r[n]=!t}),this.selectionState=r}};al.template=Q`
    <style include="scrollbar-style"></style>
    <style include="run-color-style"></style>

    <paper-input
      id="names-regex"
      no-label-float=""
      label="Write a regex to filter runs"
      value="[[regex]]"
      on-bind-value-changed="_debouncedRegexChange"
    ></paper-input>
    <div id="outer-container" class="scrollbar">
      <template
        is="dom-repeat"
        items="[[namesMatchingRegex]]"
        on-dom-change="synchronizeColors"
      >
        <div class="name-row">
          <div
            class="icon-container checkbox-container vertical-align-container"
          >
            <paper-checkbox
              class="checkbox vertical-align-center"
              id$="checkbox-[[item]]"
              name="[[item]]"
              checked$="[[_isChecked(item, selectionState.*)]]"
              on-change="_checkboxChange"
            ></paper-checkbox>
          </div>
          <div
            class="icon-container isolator-container vertical-align-container"
          >
            <paper-icon-button
              icon="radio-button-unchecked"
              class="isolator vertical-align-center"
              on-tap="_isolateName"
              name="[[item]]"
            ></paper-icon-button>
          </div>
          <div class="item-label-container">
            <span>[[item]]</span>
          </div>
        </div>
      </template>
    </div>
    <style>
      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
      }
      :host {
        display: flex;
        flex-direction: column;
        height: 100%;
        overflow: hidden;
      }
      #outer-container {
        contain: content;
        flex-grow: 1;
        flex-shrink: 1;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
        word-wrap: break-word;
      }
      .name-row {
        contain: content;
        padding-top: 5px;
        padding-bottom: 5px;
        display: flex;
        flex-direction: row;
        font-size: 13px;
        word-break: break-all; /* makes wrapping of hyperparam strings better */
      }
      .icon-container {
        flex-grow: 0;
        flex-shrink: 0;
        padding-left: 2px;
      }
      .checkbox {
        padding-left: 2px;
        width: 18px;
        height: 18px;
      }
      .isolator {
        width: 18px;
        height: 18px;
        padding: 0px;
      }
      .isolator-container {
        padding-left: 6px;
        padding-right: 3px;
      }
      .checkbox-container {
        padding-left: 2px;
      }
      .item-label-container {
        padding-left: 5px;
        flex-grow: 1;
        flex-shrink: 1;
        width: 0px; /* hack to get the flex-grow to work properly */
      }
      .tooltip-value-container {
        display: flex;
        justify-content: center;
        flex-grow: 0;
        flex-shrink: 0;
        text-align: right;
        padding-left: 2px;
      }
      .vertical-align-container {
        display: flex;
        justify-content: center;
      }
      .vertical-align-container .vertical-align-center {
        align-self: center;
      }
      .vertical-align-container .vertical-align-top {
        align-self: start;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],al.prototype,"names",void 0);E([A({type:Object}),w("design:type",Object)],al.prototype,"coloring",void 0);E([A({type:String,notify:!0}),w("design:type",String)],al.prototype,"regex",void 0);E([A({type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"}),w("design:type",Array)],al.prototype,"namesMatchingRegex",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],al.prototype,"selectionState",void 0);E([A({type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"}),w("design:type",Array)],al.prototype,"outSelected",void 0);E([A({type:Number}),w("design:type",Number)],al.prototype,"maxNamesToEnableByDefault",void 0);E([A({type:Object}),w("design:type",Object)],al.prototype,"_debouncedRegexChange",void 0);E([Rt("regex"),w("design:type",Object),w("design:paramtypes",[])],al.prototype,"_regex",null);E([Bt("selectionState","names"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],al.prototype,"_setIsolatorIcon",null);al=E([yt("tf-multi-checkbox")],al);var a2=class extends mt{get _parts(){var t=this.value,r=this.delimiterPattern;let n=[];for(;;){let i=new RegExp(r,"g");if(i.test(t),i.lastIndex===0){n.push(t);break}else n.push(t.slice(0,i.lastIndex)),t=t.slice(i.lastIndex)}return n}};a2.template=Q`
    <!--
      This ugly formatting is required to prevent spaces from slipping
      into the HTML.
    -->
    <template is="dom-repeat" items="[[_parts]]" as="part"
      >[[part]]<wbr
    /></template>
  `;E([A({type:String}),w("design:type",String)],a2.prototype,"value",void 0);E([A({type:String}),w("design:type",String)],a2.prototype,"delimiterPattern",void 0);E([Rt("value","delimiterPattern"),w("design:type",Array),w("design:paramtypes",[])],a2.prototype,"_parts",null);a2=E([yt("tf-wbr-string")],a2);var mc=class extends Gt(mt){constructor(){super(...arguments),this.runSelectionState=OW("runSelectionState",{defaultValue:{}}).call(this),this.regexInput=v_("regexInput",{defaultValue:""}).call(this),this._dataLocationClipLength=250,this._dataLocationDelimiterPattern="[/=_,-]",this.coloring={getColor:fn},this._storeRunSelectionState=zW("runSelectionState",{defaultValue:{}}),this._regexObserver=x_("regexInput",{defaultValue:""})}attached(){this._runStoreListener=Sp.addListener(()=>{this.set("runs",Sp.getRuns())}),this.set("runs",Sp.getRuns()),this._envStoreListener=ib.addListener(()=>{this.set("dataLocation",ib.getDataLocation())}),this.set("dataLocation",ib.getDataLocation())}detached(){Sp.removeListenerByKey(this._runStoreListener),ib.removeListenerByKey(this._envStoreListener)}_toggleAll(){this.$.multiCheckbox.toggleAll()}get _clippedDataLocation(){var t=this.dataLocation,r=this._dataLocationClipLength;if(t!==void 0)return t.length>r?t.substring(0,r):t}_openDataLocationDialog(t){t.preventDefault(),this.$$("#data-location-dialog").open()}_shouldShowExpandDataLocationButton(t,r){return t&&t.length>r}};mc.template=Q`
    <paper-dialog with-backdrop="" id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string
        value="[[dataLocation]]"
        delimiter-pattern="[[_dataLocationDelimiterPattern]]"
      >
      </tf-wbr-string
    ></paper-dialog>
    <div id="top-text">
      <h3 id="tooltip-help" class="tooltip-container">Runs</h3>
    </div>
    <tf-multi-checkbox
      id="multiCheckbox"
      names="[[runs]]"
      selection-state="{{runSelectionState}}"
      out-selected="{{selectedRuns}}"
      regex="{{regexInput}}"
      coloring="[[coloring]]"
    ></tf-multi-checkbox>
    <paper-button class="x-button" id="toggle-all" on-tap="_toggleAll">
      Toggle All Runs
    </paper-button>
    <template is="dom-if" if="[[dataLocation]]">
      <div id="data-location">
        <tf-wbr-string
          value="[[_clippedDataLocation]]"
          delimiter-pattern="[[_dataLocationDelimiterPattern]]"
        ></tf-wbr-string
        ><!--
          We use HTML comments to remove spaces before the ellipsis.
        --><template
          is="dom-if"
          if="[[_shouldShowExpandDataLocationButton(dataLocation, _dataLocationClipLength)]]"
          ><!--
          --><a href="" on-click="_openDataLocationDialog">…</a>
        </template>
      </div>
    </template>
    <style>
      :host {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        padding-bottom: 10px;
      }
      #top-text {
        color: var(--tb-secondary-text-color);
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
      }
      tf-wbr-string {
        overflow-wrap: break-word;
      }
      tf-multi-checkbox {
        display: flex;
        flex-grow: 1;
        flex-shrink: 1;
        overflow: hidden;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      #tooltip-help {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }
      paper-button {
        margin-left: 0;
      }
      #data-location {
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin: 5px 0 0 0;
        max-width: 288px;
      }
    </style>
  `;E([A({type:Object,observer:"_storeRunSelectionState"}),w("design:type",Object)],mc.prototype,"runSelectionState",void 0);E([A({type:String,observer:"_regexObserver"}),w("design:type",String)],mc.prototype,"regexInput",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],mc.prototype,"selectedRuns",void 0);E([A({type:Array}),w("design:type",Array)],mc.prototype,"runs",void 0);E([A({type:String,notify:!0}),w("design:type",String)],mc.prototype,"dataLocation",void 0);E([A({type:Number}),w("design:type",Number)],mc.prototype,"_dataLocationClipLength",void 0);E([A({type:String}),w("design:type",String)],mc.prototype,"_dataLocationDelimiterPattern",void 0);E([A({type:Object}),w("design:type",Object)],mc.prototype,"coloring",void 0);E([Rt("dataLocation","_dataLocationClipLength"),w("design:type",Object),w("design:paramtypes",[])],mc.prototype,"_clippedDataLocation",null);mc=E([yt("tf-runs-selector")],mc);var an=class{constructor(){this.cancellationCount=0}cancellable(t){let r=this.cancellationCount;return n=>{let i=this.cancellationCount!==r;return t({value:n,cancelled:i})}}cancelAll(){this.cancellationCount++}};var H5=class extends Gt(mt){constructor(){super(...arguments),this.html=""}get sanitizedHtml(){return this.html}attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}};H5.template=Q`
    <div id="markdown" inner-h-t-m-l="[[sanitizedHtml]]"></div>
    <style>
      /*
       * Reduce topmost and bottommost margins from 16px to 0.3em (renders
       * at about 4.8px) to keep the layout compact. This improves the
       * appearance when there is only one line of text; standard Markdown
       * renderers will still include a \`<p>\` element.
       *
       * By targeting only the top-level, extremal elements, we preserve any
       * actual paragraph breaks and only change the padding against the
       * component edges.
       */
      #markdown > p:first-child {
        margin-top: 0.3em;
      }
      #markdown > p:last-child {
        margin-bottom: 0.3em;
      }
      #markdown p {
        /* Some users include multiple spaces and would like them preserved in
         * the text visualization in TB. Googlers, see b/335770352.
         */
        white-space: break-spaces;
      }

      /* Pleasant styles for Markdown tables. */
      #markdown table {
        border-collapse: collapse;
      }
      #markdown table th {
        font-weight: 600;
      }
      #markdown table th,
      #markdown table td {
        padding: 6px 13px;
        border: 1px solid var(--tb-ui-border, #dfe2e5);
      }
      #markdown table tr {
        background-color: inherit;
        border-top: 1px solid var(--tb-ui-border, #c6cbd1);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],H5.prototype,"html",void 0);E([Rt("html"),w("design:type",Object),w("design:paramtypes",[])],H5.prototype,"sanitizedHtml",null);H5=E([yt("tf-markdown-view")],H5);ys({moduleName:"tf-card-heading-style",styleContent:`
    figcaption {
      width: 100%;
    }

    /** Horizontal line of labels. */
    .heading-row {
      margin-top: -4px;
      display: flex;
      flex-direction: row;
      flex-wrap: wrap;
    }

    /** Piece of text in the figure caption. */
    .heading-label {
      flex-grow: 1;
      margin-top: 4px;
      max-width: 100%;
      word-wrap: break-word;
    }

    /** Makes label show on the right. */
    .heading-right {
      flex-grow: 0;
    }
  `});function s2(e){return e?e.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""}function tMt(e){let t=p5e(e);return t?Math.round((t[0]*299+t[1]*587+t[2]*114)/1e3)>125?"inherit":"#eee":"inherit"}function p5e(e){if(!e)return null;let t=e.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!t)return null;if(e.length==4)for(var r=1;r<=3;r++)t[r]=t[r]+t[r];return[parseInt(t[1],16),parseInt(t[2],16),parseInt(t[3],16)]}var gc=class extends mt{constructor(){super(...arguments),this.displayName=null,this.tag=null,this.run=null,this.description=null,this.color=null}_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})}_computeRunBackground(t){return t||"none"}_computeRunColor(t){return tMt(t)}get _nameLabel(){var t=this.displayName,r=this.tag;return t||r||""}get _tagLabel(){var t=this.displayName,r=this.tag;return r&&r!==t?r:""}_toggleDescriptionDialog(t){let r=this.$.descriptionDialog;r.positionTarget=t.target,r.toggle()}};gc.template=Q`
    <div class="container">
      <figcaption class="content">
        <div class="heading-row">
          <template is="dom-if" if="[[_nameLabel]]">
            <div itemprop="name" class="heading-label name">[[_nameLabel]]</div>
          </template>
          <template is="dom-if" if="[[run]]">
            <!-- Extra wrapping span needed to avoid flexbox blockification. -->
            <!-- (see flexbox spec, section 4 "Flex Items") -->
            <span>
              <span
                itemprop="run"
                id="heading-run"
                class="heading-label heading-right run"
                >[[run]]</span
              >
            </span>
          </template>
        </div>
        <template is="dom-if" if="[[_tagLabel]]">
          <div class="heading-row">
            <div class="heading-label">
              tag: <span itemprop="tag">[[_tagLabel]]</span>
            </div>
          </div>
        </template>
        <slot></slot>
      </figcaption>
      <template is="dom-if" if="[[description]]">
        <paper-icon-button
          icon="info"
          on-tap="_toggleDescriptionDialog"
          title="Show summary description"
        ></paper-icon-button>
      </template>
      <paper-dialog
        id="descriptionDialog"
        no-overlap=""
        horizontal-align="auto"
        vertical-align="auto"
      >
        <paper-dialog-scrollable>
          <tf-markdown-view html="[[description]]"></tf-markdown-view>
        </paper-dialog-scrollable>
      </paper-dialog>
    </div>
    <style include="tf-card-heading-style">
      .container {
        display: flex;
      }
      .content {
        font-size: 12px;
        flex-grow: 1;
      }
      .name {
        font-size: 14px;
      }
      .run {
        font-size: 11px;
        width: auto;
        border-radius: 3px;
        font-weight: bold;
        padding: 1px 4px 2px;
      }
      paper-icon-button {
        flex-grow: 0;
      }
      paper-dialog-scrollable {
        max-width: 640px;
      }
      #heading-run {
        background: var(--tf-card-heading-background-color);
        color: var(--tf-card-heading-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",Object)],gc.prototype,"displayName",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"tag",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"run",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"description",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"color",void 0);E([A({type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runBackground",void 0);E([A({type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runColor",void 0);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_nameLabel",null);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_tagLabel",null);gc=E([yt("tf-card-heading")],gc);var Fi=class extends Gt(mt){constructor(){super(...arguments),this._metadataCanceller=new an,this._steps=[],this._attached=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _maxStepIndex(){var t=this._steps;return t.length-1}get _currentDatum(){var t=this._steps,r=this._stepIndex;return t[r]}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.totalSamples;return t>1}attached(){this._attached=!0,this.reload()}_reloadOnRunTagChange(){this.reload()}reload(){if(!this._attached)return;this._metadataCanceller.cancelAll();let r=_e().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:String(this.sample)})),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",String(t.wall_time));let n=_e().pluginRouteForSrc("audio","/individualAudio",r);return{wall_time:s2(new Date(t.wall_time*1e3)),step:t.step,label:t.label,contentType:t.contentType,url:n}}};Fi.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div class="heading-row">
          <div class="heading-label">
            sample: [[_sampleText]] of [[totalSamples]]
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step <strong>[[_currentDatum.step]]</strong>
          </div>
          <template is="dom-if" if="[[_currentDatum.wall_time]]">
            <div class="heading-label heading-right">
              [[_currentDatum.wall_time]]
            </div>
          </template>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div class="heading-row">
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps=""
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <template is="dom-if" if="[[_hasAtLeastOneStep]]">
      <audio
        controls=""
        src$="[[_currentDatum.url]]"
        type$="[[_currentDatum.contentType]]"
      ></audio>
      <tf-markdown-view html="[[_currentDatum.label]]"></tf-markdown-view>
    </template>
    <div id="main-audio-container"></div>

    <style include="tf-card-heading-style">
      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        --step-slider-knob-color: #424242;
        margin-right: 15px;
        margin-bottom: 15px;
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        width: 100%;
        box-sizing: border-box;
        padding: 0 5px; /* so the slider knob doesn't butt out */
        margin-top: 5px;
        --paper-slider-active-color: var(--step-slider-knob-color);
        --paper-slider-knob-color: var(--step-slider-knob-color);
        --paper-slider-pin-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-border-color: var(--step-slider-knob-color);
        --paper-slider-pin-start-color: var(--step-slider-knob-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Fi.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Fi.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"totalSamples",void 0);E([A({type:Object}),w("design:type",Object)],Fi.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Ae)],Fi.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],Fi.prototype,"_metadataCanceller",void 0);E([A({type:Array}),w("design:type",Array)],Fi.prototype,"_steps",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"_stepIndex",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSteps",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],Fi.prototype,"_maxStepIndex",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Fi.prototype,"_currentDatum",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_sampleText",null);E([Rt("totalSamples"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Fi.prototype,"_reloadOnRunTagChange",null);Fi=E([yt("tf-audio-loader")],Fi);var Kh=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._tagFilter="",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadAudio()})}_fetchTags(){let t=_e().pluginRoute("audio","/tags");return this._requestManager.request(t).then(r=>{if(py.isEqual(r,this._runToTagInfo))return;let n=py.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r)})}_reloadAudio(){var t;(t=this.root)==null||t.querySelectorAll("tf-audio-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=py.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return py.range(c).map(u=>Object.assign({},l,{sample:u,totalSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}_tagMetadata(t,r,n){return t[r][n]}};Kh.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No audio data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any audio data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-audio-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  total-samples="[[item.totalSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                ></tf-audio-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Kh.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],Kh.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Kh.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Kh.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Kh.prototype,"_tagFilter",void 0);E([A({type:Object}),w("design:type",Ae)],Kh.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],Kh.prototype,"_categories",null);Kh=E([yt("tf-audio-dashboard")],Kh);var V5=class extends Gt(mt){attached(){this.async(function(){this.getEffectiveChildren().forEach(function(t){this.listen(t,"tap","_selectTarget")}.bind(this))})}_selectTarget(t){this.selectedId=t.currentTarget.id}_selectedIdChanged(){var t=this.queryEffectiveChildren("#"+this.selectedId);!t||(this.getEffectiveChildren().forEach(function(r){r.classList.remove("selected")}),t.classList.add("selected"))}};V5.template=Q`
    <div id="wrap">
      <h3>[[name]]</h3>
      <div class="content-wrapper"><slot></slot></div>
    </div>
    <style>
      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(.selected) {
        background-color: var(--tb-ui-dark-accent);
        color: white !important;
      }

      h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],V5.prototype,"name",void 0);E([A({type:String,notify:!0,observer:"_selectedIdChanged"}),w("design:type",String)],V5.prototype,"selectedId",void 0);V5=E([yt("tf-option-selector")],V5);function oR(e,t){let r,n={};Object.keys(e).forEach(a=>{let s=e[a];r===void 0&&(r=s.displayName),r!==s.displayName&&(r=null),n[s.description]===void 0&&(n[s.description]=[]),n[s.description].push(a)});let i=r!=null?r:t,o=(()=>{let a=Object.keys(n);return a.length===0?"":a.length===1?a[0]:`<p><strong>Multiple descriptions:</strong></p><ul>${a.map(c=>{let u=n[c].map(p=>`<code>${p.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/&/g,"&amp;")}</code>`),h=u.length>2?u.slice(0,u.length-1).join(", ")+", and "+u[u.length-1]:u.join(" and ");return`<li><p>For ${d5e(u.length,"run","runs")} ${h}:</p>${c}</li>`}).join("")}</ul>`})();return{displayName:i,description:o}}function d5e(e,t,r){return e===1?t:r}var rMt=Ee(Oe(),1);var Vp=class extends mt{constructor(){super(...arguments),this.weight=.6,this._updateWeight=rMt.debounce(function(t){this.weight=t},250)}_immediateWeightNumberForPaperSliderChanged(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString(),this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)}_inputWeightStringForPaperInputChanged(){+this._inputWeightStringForPaperInput<0?this._inputWeightStringForPaperInput="0":+this._inputWeightStringForPaperInput>1&&(this._inputWeightStringForPaperInput="1");var t=+this._inputWeightStringForPaperInput;isNaN(t)||this._updateWeight.call(this,t)}};Vp.template=Q`
    <h3 class="title">Smoothing</h3>
    <div class="smoothing-block">
      <paper-slider
        id="slider"
        immediate-value="{{_immediateWeightNumberForPaperSlider}}"
        max="[[max]]"
        min="[[min]]"
        pin
        step="[[step]]"
        type="number"
        value="{{weight}}"
      ></paper-slider>
      <paper-input
        id="input"
        label="weight"
        no-label-float
        value="{{_inputWeightStringForPaperInput}}"
        type="number"
        step="[[step]]"
        min="[[min]]"
        max="[[max]]"
      ></paper-input>
    </div>
    <style>
      .title {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .smoothing-block {
        display: flex;
      }

      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
        flex-grow: 2;
      }

      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
        width: 60px;
      }
    </style>
  `;E([A({type:Number}),w("design:type",Number)],Vp.prototype,"step",void 0);E([A({type:Number}),w("design:type",Number)],Vp.prototype,"max",void 0);E([A({type:Number}),w("design:type",Number)],Vp.prototype,"min",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Vp.prototype,"weight",void 0);E([A({type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"}),w("design:type",Number)],Vp.prototype,"_immediateWeightNumberForPaperSlider",void 0);E([A({type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}),w("design:type",String)],Vp.prototype,"_inputWeightStringForPaperInput",void 0);Vp=E([yt("tf-smoothing-input")],Vp);var Yo=Ee(Oe(),1);function Mi(e,t){let r=Object.keys(t).sort().filter(a=>t[a]!==void 0);if(!r.length)return e;let n=e.indexOf("?")!==-1?"&":"?",o=Array().concat(...r.map(a=>{let s=t[a];return(Array.isArray(s)?s:[s]).map(c=>`${a}=${m5e(c)}`)})).join("&");return e+n+o}function m5e(e){return encodeURIComponent(e).replace(/\(/g,"%28").replace(/\)/g,"%29")}var $Kt=Ee(Oe(),1),ZWn=Ee(Sl(),1);var DKt=Ee(Oe(),1);var x4;(function(e){e[e.LOADING=0]="LOADING",e[e.LOADED=1]="LOADED"})(x4||(x4={}));function kS(e){return class extends e{constructor(){super(...arguments),this.loadKey="",this.dataToLoad=[],this.getDataLoadName=r=>String(r),this.dataLoading=!1,this.dataLoadedAtLeastOnce=!1,this._isConnected=!1,this._dataLoadState=new Map,this._canceller=new an,this._loadDataAsync=null,this._loadData=DKt.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})}connectedCallback(){super.connectedCallback(),this._isConnected=!0}disconnectedCallback(){super.disconnectedCallback(),this._isConnected=!1}static get properties(){return{active:{type:Boolean,observer:"_loadDataIfActive"},_isConnected:{type:Boolean},loadKey:{type:String},dataToLoad:{type:Array},getDataLoadName:{type:Object},loadDataCallback:{type:Object},requestData:{type:Object}}}static get observers(){return["_dataToLoadChanged(_isConnected, dataToLoad.*)"]}onLoadFinish(){}reload(){this._dataLoadState.clear(),this._loadData()}reset(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null),this._canceller&&this._canceller.cancelAll(),this._dataLoadState&&this._dataLoadState.clear(),this._isConnected&&this._loadData()}_dataToLoadChanged(){this._isConnected&&this._loadData()}detached(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null)}_loadDataIfActive(){this.active&&this._loadData()}_loadDataImpl(){!this.active||(this._loadDataAsync!==null&&clearTimeout(this._loadDataAsync),this._loadDataAsync=setTimeout(this._canceller.cancellable(r=>{if(r.cancelled)return;this.dataLoading=!0;let n=this.dataToLoad.filter(a=>{let s=this.getDataLoadName(a);return!this._dataLoadState.has(s)});for(let a of n){let s=this.getDataLoadName(a);this._dataLoadState.set(s,x4.LOADING)}let i=this._canceller.cancellable(a=>{if(a.cancelled)return;let{item:s,data:l}=a.value,c=this.getDataLoadName(s);this._dataLoadState.set(c,x4.LOADED),this.loadDataCallback(this,s,l)}),o=this._canceller.cancellable(a=>{if(!a.cancelled){let l=a.value,c=new Set(n.map(h=>this.getDataLoadName(h)));this.dataToLoad.some(h=>c.has(this.getDataLoadName(h)))&&this.onLoadFinish(),this._loadDataAsync=null,this.dataLoadedAtLeastOnce=!0}Array.from(this._dataLoadState.values()).includes(x4.LOADING)||(this.dataLoading=!1)});this.requestData(n,i,()=>o(void 0))})))}}}var bqe=Ee(Oe(),1),Wo=Ee(Sl(),1),RS=[{character:"\u25FC",method:Wo.SymbolFactories.square},{character:"\u25C6",method:Wo.SymbolFactories.diamond},{character:"\u25B2",method:Wo.SymbolFactories.triangle},{character:"\u2605",method:Wo.SymbolFactories.star},{character:"\u271A",method:Wo.SymbolFactories.cross}],Td;(function(e){e.STEP="step",e.RELATIVE="relative",e.WALL_TIME="wall_time"})(Td||(Td={}));var r0=4,wqe=4,mB=3,gB=20,_B=4,OKt=6;function Wu(e){return t=>{let r=Math.abs(t);r<1e-15&&(r=0);let n;return r>=1e4?n=xn("."+e+"~e"):r>0&&r<.01?n=xn("."+e+"~e"):n=xn("."+e+"~g"),n(t)}}var b4=xn(`.${wqe}~s`);function Xat(){let e=new Wo.Scales.Linear;e.tickGenerator(Wo.Scales.TickGenerators.integerTickGenerator());let t=new Wo.Axes.Numeric(e,"bottom");return t.formatter(b4),{scale:e,axis:t,accessor:r=>r.step}}var yB=Wo.Formatters.time("%a %b %e, %H:%M:%S");function Sqe(){let e=new Wo.Scales.Time;return{scale:e,axis:new Wo.Axes.Time(e,"bottom"),accessor:t=>t.wall_time}}var n0=(e,t,r)=>{if(e.relative!=null)return e.relative;let n=r.data(),i=n.length>0?+n[0].wall_time:0;return(+e.wall_time-i)/(60*60*1e3)},vB=e=>{let t="",r=Math.floor(e/24);e-=r*24,r&&(t+=r+"d ");let n=Math.floor(e);e-=n,e*=60,(n||r)&&(t+=n+"h ");let i=Math.floor(e);e-=i,e*=60,(i||n||r)&&(t+=i+"m ");let o=Math.floor(e);return t+o+"s"};function Mqe(){let e=new Wo.Scales.Linear;return{scale:e,axis:new Wo.Axes.Numeric(e,"bottom"),accessor:n0}}function xB(e){switch(e){case Td.STEP:return Xat();case Td.WALL_TIME:return Sqe();case Td.RELATIVE:return Mqe();default:throw new Error("invalid xType: "+e)}}var Fs=Ee(Oe(),1),Mn=Ee(Sl(),1);var xa=Ee(Sl(),1);function Eqe(e){let t=[],r=e;for(;r&&r instanceof HTMLElement;)if(t.push(r),r.assignedSlot)r=r.assignedSlot;else if(r.parentElement)r=r.parentElement;else{let n=r.parentNode;n instanceof DocumentFragment?r=n.host:r=n!==r?n:null}return t}var Tqe=[1,0,0,1,0,0];function Cqe(e){let t=Eqe(e),r=Tqe,n=null;for(let i of t){let o=xa.Utils.DOM.getElementTransform(i);if(o!=null){let l=i.clientWidth/2,c=i.clientHeight/2;r=xa.Utils.Math.multiplyTranslate(r,[l,c]),r=xa.Utils.Math.multiplyMatrix(r,xa.Utils.Math.invertMatrix(o)),r=xa.Utils.Math.multiplyTranslate(r,[-l,-c])}let a=i.scrollLeft,s=i.scrollTop;(n===null||i===n)&&(a-=i.offsetLeft+i.clientLeft,s-=i.offsetTop+i.clientTop,n=i.offsetParent),r=xa.Utils.Math.multiplyTranslate(r,[a,s])}return r}var wB=class extends xa.Utils.Translator{computePosition(t,r){let n={x:t,y:r},i=Cqe(this._rootElement);return i==null?n:xa.Utils.Math.applyTransform(i,n)}},qv=class extends xa.Dispatchers.Mouse{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[qv._DISPATCHER_KEY];return n||(n=new qv(t),r[qv._DISPATCHER_KEY]=n),n}},Gv=class extends xa.Dispatchers.Touch{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new wB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[Gv._DISPATCHER_KEY];return n||(n=new Gv(t),r[Gv._DISPATCHER_KEY]=n),n}};xa.Interaction.prototype._isInsideComponent=function(e){return 0<=e.x&&0<=e.y&&e.x<this._componentAttachedTo.width()&&e.y<this._componentAttachedTo.height()};var SB=class extends xa.Interactions.Pointer{_anchor(t){let r=this;r._isAnchored=!0,r._mouseDispatcher=qv.getDispatcher(r._componentAttachedTo),r._mouseDispatcher.onMouseMove(r._mouseMoveCallback),r._touchDispatcher=Gv.getDispatcher(r._componentAttachedTo),r._touchDispatcher.onTouchStart(r._touchStartCallback)}};var zKt=Ee(Oe(),1);var Wv;(function(e){e.AUTO="auto",e.BOTTOM="bottom",e.RIGHT="right"})(Wv||(Wv={}));var Aqe={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5},w4=class extends Gt(mt){constructor(){super(...arguments),this.position=Wv.AUTO,this.minDistFromEdge=15,this._styleCache=null,this._raf=null,this._tunnel=null}ready(){this._styleCache=null,this._raf=null,this._tunnel=null}attached(){this._tunnel=this._createTunnel(),this._hideOnBlur=()=>{document.hidden&&this.hide()},window.addEventListener("visibilitychange",this._hideOnBlur)}detached(){this.hide(),this._removeTunnel(this._tunnel),this._tunnel=null,window.removeEventListener("visibilitychange",this._hideOnBlur)}content(){return this._tunnel.shadowRoot}hide(){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._styleCache=null,this._tunnel.style.opacity=0}updateAndPosition(t){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._raf=window.requestAnimationFrame(()=>{!this.isAttached||this._repositionImpl(t)})}_repositionImpl(t){let r=this._tunnel,n=t.getBoundingClientRect(),i=r.getBoundingClientRect(),o=window.innerHeight,a=document.body.clientWidth,s=n.top,l=s+n.height,c=i.height+gB,u=null,h=Math.max(this.minDistFromEdge,n.left),f=null,p=s;this.position==Wv.RIGHT?h=n.right:(p=l+gB,a<h+i.width+this.minDistFromEdge&&(h=null,f=this.minDistFromEdge)),this.position==Wv.AUTO&&n.top-c>0&&o<n.top+n.height+c&&(p=null,u=o-s+gB);let d={contain:"content",opacity:1,left:h?`${h}px`:null,right:f?`${f}px`:null,top:p?`${p}px`:null,bottom:u?`${u}px`:null};zKt.isEqual(this._styleCache,d)||(Object.assign(r.style,d),this._styleCache=d)}_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");let t=document.createElement(this.contentComponentName);return Object.assign(t.style,Aqe),document.body.appendChild(t),t}_removeTunnel(t){document.body.removeChild(t)}};E([A({type:String}),w("design:type",String)],w4.prototype,"contentComponentName",void 0);E([A({type:String}),w("design:type",String)],w4.prototype,"position",void 0);E([A({type:Number}),w("design:type",Number)],w4.prototype,"minDistFromEdge",void 0);w4=E([yt("vz-chart-tooltip")],w4);var NS=Ee(Sl(),1);var HKt=1e4,VKt=.001,UKt=xn(".2~e"),Pqe=xn(".4~r"),FKt=xn(",~");function BKt(e){if(e===0)return"0";let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):Pqe(e)}var Kat={formatTick:BKt,formatShort:BKt,formatReadable(e){let t=Math.abs(e);return t>=HKt||t<VKt?UKt(e):FKt(e)},formatLong:FKt},iWn=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var oWn=xn("0.3~s"),aWn=xn(",.3~f");var Iqe=1e3,Lqe=60*Iqe,kqe=60*Lqe,Rqe=24*kqe,sWn=365*Rqe,lWn=xn(".4~");var Nqe=Yb().tickFormat(),$at,qKt={formatTick(e){return Nqe(new Date(e))},formatShort(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(e){return new Date(e).toLocaleString($at,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};var Cd;(function(e){e[e.LINEAR=0]="LINEAR",e[e.LOG10=1]="LOG10",e[e.TIME=2]="TIME"})(Cd||(Cd={}));function GKt(e){switch(e){case Cd.LINEAR:return new Zat;case Cd.LOG10:return new Jat;case Cd.TIME:return new Qat;default:let t=e;throw new RangeError(`ScaleType ${t} not supported.`)}}var Dqe=.05,Zat=class{constructor(){this.defaultFormatter=Kat}transform(t,r,n){let[i,o]=t,a=o-i,[s,l]=r,c=l-s;return a===0?s:c/a*(n-i)+s}forward(t,r,n){return this.transform(t,r,n)}reverse(t,r,n){return this.transform(r,t,n)}niceDomain(t){let[r,n]=t;if(n<r)throw new Error("Unexpected input: min is larger than max");if(n===r)return r===0?[-1,1]:r<0?[2*r,0]:[0,2*r];let i=zn(),o=(n-r+Number.EPSILON)*Dqe,[a,s]=i.domain([r-o,n+o]).nice().domain();return[a,s]}ticks(t,r){return zn().domain(t).ticks(r)}isSafeNumber(t){return Number.isFinite(t)}},Jat=class{constructor(){this.defaultFormatter=Kat}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,r,n){if(n<=0)return r[0];let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a;return n=this.transform(n),h/(u+Number.EPSILON)*(n-l)+a}reverse(t,r,n){let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a,f=u/(h+Number.EPSILON)*(n-a)+l;return this.untransform(f)}niceDomain(t){let[r,n]=t;if(r>n)throw new Error("Unexpected input: min is larger than max");let i=Math.max(r,Number.MIN_VALUE),o=Math.max(n,Number.MIN_VALUE);return n<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,i*.5),o*2]}ticks(t,r){let n=t[0]<=0?Number.MIN_VALUE:t[0],i=t[1]<=0?Number.MIN_VALUE:t[1],o=cc().domain([n,i]).ticks(r);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Qat=class{constructor(){this.scale=Yb(),this.defaultFormatter=qKt}forward(t,r,n){return this.scale.domain(t).range(r)(n)}reverse(t,r,n){return this.scale.domain(t).range(r).invert(n).getTime()}niceDomain(t){let[r,n]=this.scale.domain(t).nice().domain();return[r.getTime(),n.getTime()]}ticks(t,r){return this.scale.domain(t).ticks(r).map(n=>n.getTime())}isSafeNumber(t){return Number.isFinite(t)}};var MB=class extends NS.Scales.Linear{constructor(){super(),this._ignoreOutlier=!1,this.padProportion(.2)}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}_niceDomain(t,r){let[n,i]=t;return GKt(Cd.LINEAR).niceDomain([n,i])}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[NS.Utils.Math.min(r,n[0]),NS.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}extentOfValues(t){let r=t.filter(o=>NS.Utils.Math.isValidNumber(o)),n=r;if(this.ignoreOutlier()){let o=r.sort((l,c)=>l-c),a=la(o,.05),s=la(o,.95);n=r.filter(l=>l>=a&&l<=s)}let i=sa(n);return i[0]==null||i[1]==null?[]:i}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}};var CB=Ee(Sl(),1);var WKt=Ee(Sl(),1),EB=class extends WKt.QuantitativeScale{constructor(){super(...arguments),this._ignoreOutlier=!1}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}};var TB=Math.pow(2,-1074);function S4(e){return Math.log10(e)}function tst(e){return Math.pow(10,e)}var AB=class extends EB{constructor(){super(),this._d3LogScale=cc(),this.padProportion(.2)}scale(t){return t<=0?NaN:this._d3LogScale(t)}invert(t){return this._d3LogScale.invert(t)}scaleTransformation(t){return this.scale(t)}invertedTransformation(t){return this.invert(t)}getTransformationDomain(){return this.domain()}setTransformationDomain(t){this.domain(t)}getTransformationExtent(){return this._getUnboundedExtent(!0)}_getDomain(){return this._untransformedDomain}_setDomain(t){this._untransformedDomain=t;let[r,n]=t;super._setDomain([Math.max(TB,r),n])}_niceDomain(t,r){let[n,i]=t,o=Math.max(S4(TB),S4(n)),a=S4(i),s=a-o,l=s?s*this.padProportion():1;return[tst(Math.max(S4(TB),o-l)),tst(a+l)]}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[CB.Utils.Math.min(r,n[0]),CB.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){return super._getAllIncludedValues().map(n=>n>0?n:TB)}_defaultExtent(){return[1,10]}_backingScaleDomain(t){return t==null?this._d3LogScale.domain():(this._d3LogScale.domain(t),this)}_getRange(){return this._d3LogScale.range()}_setRange(t){this._d3LogScale.range(t)}defaultTicks(){return this._d3LogScale.ticks(1)}ticks(){return this._d3LogScale.ticks()}extentOfValues(t){let r=t.filter(o=>CB.Utils.Math.isValidNumber(o)&&o>0),n=r;if(this.ignoreOutlier()){let a=r.map(S4).sort((c,u)=>c-u),s=la(a,.05),l=la(a,.95);n=a.filter(c=>c>=s&&c<=l).map(tst)}let i=sa(n);return i[0]==null||i[1]==null?[]:i}};var Ad=Ee(Sl(),1);var i0=Ee(Sl(),1),PB=class extends i0.Components.SelectionBoxLayer{constructor(t,r,n){super(),this.easeFn=bs,this._animationTime=750,this.xScale(t),this.yScale(r),this._dragInteraction=new i0.Interactions.Drag,this._doubleClickInteraction=new i0.Interactions.Click,this.setupCallbacks(),this.unzoomMethod=n,this.onDetach(()=>{this._doubleClickInteraction.detachFrom(this),this._dragInteraction.detachFrom(this)}),this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this),this._dragInteraction.attachTo(this)})}interactionStart(t){this.onStart=t}interactionEnd(t){this.onEnd=t}dragInteraction(){return this._dragInteraction}setupCallbacks(){let t=!1;this._dragInteraction.onDragStart(r=>{this.bounds({topLeft:r,bottomRight:r}),this.onStart()}),this._dragInteraction.onDrag((r,n)=>{this.bounds({topLeft:r,bottomRight:n}),this.boxVisible(!0),t=!0}),this._dragInteraction.onDragEnd((r,n)=>{this.boxVisible(!1),this.bounds({topLeft:r,bottomRight:n}),t?this.zoom():this.onEnd(),t=!1}),this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(t){if(t==null)return this._animationTime;if(t<0)throw new Error("animationTime cannot be negative");return this._animationTime=t,this}ease(t){if(typeof t!="function")throw new Error("ease function must be a function");return(t(0)!==0||t(1)!==1)&&i0.Utils.Window.warn("Easing function does not maintain invariant f(0)==0 && f(1)==1. Bad behavior may result."),this.easeFn=t,this}zoom(){let t=this.xExtent()[0].valueOf(),r=this.xExtent()[1].valueOf(),n=this.yExtent()[1].valueOf(),i=this.yExtent()[0].valueOf();t===r||n===i||this.interpolateZoom(t,r,n,i)}unzoom(){let t=this.xScale();t._domainMin=null,t._domainMax=null;let r=t._getExtent();this.xScale().domain(r),this.unzoomMethod()}isZooming(t){this._dragInteraction.enabled(!t),this._doubleClickInteraction.enabled(!t)}interpolateZoom(t,r,n,i){let o=this.xScale().domain()[0].valueOf(),a=this.xScale().domain()[1].valueOf(),s=this.yScale().domain()[0].valueOf(),l=this.yScale().domain()[1].valueOf(),c=this.easeFn,u=(p,d,g)=>zi(p,d)(c(g));this.isZooming(!0);let h=Date.now(),f=()=>{let d=Date.now()-h,g=this._animationTime===0?1:Math.min(1,d/this._animationTime),_=u(o,t,g),y=u(a,r,g),x=u(s,n,g),b=u(l,i,g);this.xScale().domain([_,y]),this.yScale().domain([x,b]),g<1?i0.Utils.DOM.requestAnimationFramePolyfill(f):(this.onEnd(),this.isZooming(!1))};f()}};var ba;(function(e){e[e.NONE=0]="NONE",e[e.DRAG_ZOOMING=1]="DRAG_ZOOMING",e[e.PANNING=2]="PANNING"})(ba||(ba={}));var Ff=class extends Ad.Components.Group{constructor(t,r,n){super(),this.state=ba.NONE,this.panStartCallback=new Ad.Utils.CallbackSet,this.panEndCallback=new Ad.Utils.CallbackSet,this.panZoom=new Ad.Interactions.PanZoom(t,r),this.panZoom.dragInteraction().mouseFilter(o=>Ff.isPanKey(o)&&o.button===0),this.panZoom.wheelFilter(this.canScrollZoom),this.dragZoomLayer=new PB(t,r,n),this.dragZoomLayer.dragInteraction().mouseFilter(o=>!Ff.isPanKey(o)&&o.button===0),this.append(this.dragZoomLayer);let i=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Ad.Dispatchers.Mouse.getDispatcher(this),this._mouseDispatcher.onWheel(i),this.panZoom.attachTo(this)}),this.onDetach(()=>{this.panZoom.detachFrom(this),this._mouseDispatcher&&(this._mouseDispatcher.offWheel(i),this._mouseDispatcher=null)}),this.panZoom.dragInteraction().onDragStart(()=>{this.state==ba.NONE&&this.setState(ba.PANNING)}),this.panZoom.dragInteraction().onDragEnd(()=>{this.state==ba.PANNING&&this.setState(ba.NONE)}),this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==ba.NONE&&this.setState(ba.DRAG_ZOOMING)}),this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==ba.DRAG_ZOOMING&&this.setState(ba.NONE)})}onWheel(t,r){if(this.canScrollZoom(r))return;let n=this.element();if(!n.select(".help").empty())return;let i=n.append("div").classed("help",!0);i.append("span").text("Alt + Scroll to Zoom"),i.on("animationend",()=>void i.remove())}static isPanKey(t){return Boolean(t.altKey)||Boolean(t.shiftKey)}canScrollZoom(t){return t.altKey}setState(t){if(this.state==t)return;let r=this.state;this.state=t,this.root().removeClass(this.stateClassName(r)),this.root().addClass(this.stateClassName(t)),r==ba.PANNING&&this.panEndCallback.callCallbacks(),t==ba.PANNING&&this.panStartCallback.callCallbacks()}stateClassName(t){switch(t){case ba.PANNING:return"panning";case ba.DRAG_ZOOMING:return"drag-zooming";case ba.NONE:default:return""}}onPanStart(t){this.panStartCallback.add(t)}onPanEnd(t){this.panEndCallback.add(t)}onScrollZoom(t){this.panZoom.onZoomEnd(t)}onDragZoomStart(t){this.dragZoomLayer.interactionStart(t)}onDragZoomEnd(t){this.dragZoomLayer.interactionEnd(t)}};var IB;(function(e){e[e.TEXT=0]="TEXT",e[e.DOM=1]="DOM"})(IB||(IB={}));var Bf;(function(e){e.LOG="log",e.LINEAR="linear"})(Bf||(Bf={}));var YKt=20,DS=class{constructor(t,r,n,i,o,a,s,l,c,u,h){this.dirtyDatasets=new Set,this.seriesNames=[],this.name2datasets={},this.colorScale=i,this.tooltip=o,this.datasets=[],this._ignoreYOutliers=!1,this.lastPointsDataset=new Mn.Dataset,this.nanDataset=new Mn.Dataset,this.yValueAccessor=r,this.symbolFunction=u,this._defaultXRange=l,this._defaultYRange=c,this.tooltipColumns=a,this.buildChart(t,r,n,s,h)}buildChart(t,r,n,i,o){this.destroy();let a=t();this.xAccessor=a.accessor,this.xScale=a.scale,this.xAxis=a.axis,this.xAxis.margin(1).tickLabelPadding(3),o&&this.xAxis.formatter(o),this.yScale=DS.getYScaleFromType(n),this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute()),this.yAxis=new Mn.Axes.Numeric(this.yScale,"left");let s=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(s),this.yAxis.usesTextWidthApproximation(!0),this.fillArea=i;let l=new Ff(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(l),this.tooltipPointsComponent=new Mn.Component;let c=this.buildPlot(this.xScale,this.yScale,i);this.gridlines=new Mn.Components.Gridlines(this.xScale,this.yScale);let u=null;n!==Bf.LOG&&(u=new Mn.Components.GuideLineLayer("horizontal"),u.scale(this.yScale).value(0));let h=new Mn.Components.GuideLineLayer("vertical");h.scale(this.xScale).value(0),this.center=new Mn.Components.Group([this.gridlines,u,h,c,this.tooltipPointsComponent,l]),this.center.addClass("main"),this.outer=new Mn.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){n&&(this.marginAreaPlot=new Mn.Plots.Area,this.marginAreaPlot.x(this.xAccessor,t),this.marginAreaPlot.y(n.higherAccessor,r),this.marginAreaPlot.y0(n.lowerAccessor),this.marginAreaPlot.attr("fill",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0)),this.smoothedAccessor=c=>c.smoothed;let i=new Mn.Plots.Line;i.x(this.xAccessor,t),i.y(this.yValueAccessor,r),i.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.linePlot=i,this.setupTooltips(i);let o=new Mn.Plots.Line;if(o.x(this.xAccessor,t),o.y(this.smoothedAccessor,r),o.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.smoothLinePlot=o,this.symbolFunction){let c=new Mn.Plots.Scatter;c.x(this.xAccessor,t),c.y(this.yValueAccessor,r),c.attr("fill",(u,h,f)=>this.colorScale.scale(f.metadata().name)),c.attr("opacity",1),c.size(_B*2),c.symbol((u,h,f)=>this.symbolFunction(f.metadata().name)),this.markersScatterPlot=c}let a=new Mn.Plots.Scatter;a.x(this.xAccessor,t),a.y(this.yValueAccessor,r),a.attr("fill",c=>this.colorScale.scale(c.name)),a.attr("opacity",1),a.size(_B*2),a.datasets([this.lastPointsDataset]),this.scatterPlot=a;let s=new Mn.Plots.Scatter;s.x(this.xAccessor,t),s.y(c=>c.displayY,r),s.attr("fill",c=>this.colorScale.scale(c.name)),s.attr("opacity",1),s.size(OKt*2),s.datasets([this.nanDataset]),s.symbol(Mn.SymbolFactories.triangle),this.nanDisplay=s;let l=[s,a,o,i];return this.marginAreaPlot&&l.push(this.marginAreaPlot),this.markersScatterPlot&&l.push(this.markersScatterPlot),new Mn.Components.Group(l)}ignoreYOutliers(t){t!==this._ignoreYOutliers&&(this._ignoreYOutliers=t,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(t),this.resetYDomain())}getValuesForYAxisDomainCompute(){let t=this.getAccessorsForComputingYRange(),r=n=>t.map(i=>n.data().map(o=>i(o,-1,n)));return Fs.flattenDeep(this.datasets.map(r)).filter(isFinite)}updateSpecialDatasets(){let t=this.getYAxisAccessor(),r=this.datasets.map(o=>{let a=null,s=o.data().filter(l=>!isNaN(t(l,-1,o)));if(s.length>0){let l=s.length-1;a=s[l],a.name=o.metadata().name,a.relative=n0(a,-1,o)}return a}).filter(o=>o!=null);this.lastPointsDataset.data(r),this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));let n=o=>{let a=null,s=o.data(),l=0;for(;l<s.length&&a==null;)isNaN(t(s[l],-1,o))||(a=t(s[l],-1,o)),l++;a==null&&(a=0);let c=[];for(l=0;l<s.length;l++)isNaN(t(s[l],-1,o))?(s[l].name=o.metadata().name,s[l].displayY=a,s[l].relative=n0(s[l],-1,o),c.push(s[l])):a=t(s[l],-1,o);return c},i=Fs.flatten(this.datasets.map(n));this.nanDataset.data(i)}resetDomain(){this.resetXDomain(),this.resetYDomain()}resetXDomain(){let t;if(this._defaultXRange!=null)t=this._defaultXRange;else{let r=this.xScale;r._domainMin=null,r._domainMax=null,t=r._getExtent()}this.xScale.domain(t)}resetYDomain(){this._defaultYRange!=null?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){let t=[this.getYAxisAccessor()];return this.fillArea&&t.push(this.fillArea.lowerAccessor,this.fillArea.higherAccessor),t}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(t){let r=new SB,n=()=>{r.enabled(!1),this.hideTooltips()},i=()=>r.enabled(!0);return t.onPanStart(n),t.onDragZoomStart(n),t.onPanEnd(i),t.onDragZoomEnd(i),t.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition)),r.onPointerMove(o=>{this._lastMousePosition=o,this.updateTooltipContent(o)}),r.onPointerExit(()=>this.hideTooltips()),r}updateTooltipContent(t){!this.linePlot||(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let r={x:t.x,y:t.y},n=this.gridlines.content().node().getBBox(),i=this.linePlot.datasets().map(l=>this.findClosestPoint(r,l)).filter(l=>Boolean(l)),o=Mn.Utils.DOM.intersectsBBox,a=i.filter(l=>o(l.x,l.y,n)||isNaN(this.yValueAccessor(l.datum,0,l.dataset))),s=a.filter(l=>!isNaN(this.yValueAccessor(l.datum,0,l.dataset)));if(i.length!==0){this.scatterPlot.attr("display","none");let l=this.tooltipPointsComponent.content().selectAll(".point").data(s,c=>c.dataset.metadata().name);l.enter().append("circle").classed("point",!0),l.attr("r",_B).attr("cx",c=>c.x).attr("cy",c=>c.y).style("stroke","none").attr("fill",c=>this.colorScale.scale(c.dataset.metadata().name)),l.exit().remove(),this.drawTooltips(a,r,this.tooltipColumns)}else this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this.tooltip.hide(),this.scatterPlot.attr("display","block"),this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(t){t.onDetach(()=>{this.tooltipInteraction.detachFrom(t),this.tooltipInteraction.enabled(!1)}),t.onAnchor(()=>{this.tooltipInteraction.attachTo(t),this.tooltipInteraction.enabled(!0)})}drawTooltips(t,r,n){if(!t.length){this.tooltip.hide();return}let{colorScale:i}=this;n=[{title:"",static:!1,evalType:IB.DOM,evaluate(d){return Ht(this).select("span").style("background-color",()=>i.scale(d.dataset.metadata().name)),""},enter(d){Ht(this).append("span").classed("swatch",!0).style("background-color",()=>i.scale(d.dataset.metadata().name))}},...n];let a=Wu(r0),s=d=>Math.pow(d.x-r.x,2)+Math.pow(d.y-r.y,2),l=Fs.min(t.map(s)),c=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;this.tooltipSortingMethod==="ascending"?t=Fs.sortBy(t,d=>c(d.datum,-1,d.dataset)):this.tooltipSortingMethod==="descending"?t=Fs.sortBy(t,d=>c(d.datum,-1,d.dataset)).reverse():this.tooltipSortingMethod==="nearest"?t=Fs.sortBy(t,s):t=t.slice(0).reverse();let u=this,h=Ht(this.tooltip.content()).select("table"),f=h.select("thead").selectAll("th").data(n,(d,g,_)=>d.title);f.enter().append("th").text(d=>d.title).nodes(),f.exit().remove();let p=h.select("tbody").selectAll("tr").data(t,(d,g,_)=>d.dataset.metadata().name);p.classed("distant",d=>{let g=d.dataset.data()[0],_=Fs.last(d.dataset.data()),y=this.xScale.scale(this.xAccessor(g,0,d.dataset)),x=this.xScale.scale(this.xAccessor(_,0,d.dataset)),b=this.smoothingEnabled?d.datum.smoothed:this.yValueAccessor(d.datum,0,d.dataset);return r.x<y||r.x>x||isNaN(b)}).classed("closest",d=>s(d)===l).each(function(d){u.drawTooltipRow(this,n,d)}).order(),p.exit().remove(),p.enter().append("tr").each(function(d){u.drawTooltipRow(this,n,d)}).nodes(),this.tooltip.updateAndPosition(this.targetSVG.node())}drawTooltipRow(t,r,n){let i=this,o=Ht(t).selectAll("td").data(r);o.each(function(a){a.static||i.drawTooltipColumn.call(i,this,a,n)}),o.exit().remove(),o.enter().append("td").each(function(a){"enter"in a&&a.enter.call(this,n),i.drawTooltipColumn.call(i,this,a,n)})}drawTooltipColumn(t,r,n){let{smoothingEnabled:i}=this;"evalType"in r&&r.evalType==IB.DOM?r.evaluate.call(t,n,{smoothingEnabled:i}):Ht(t).text(r.evaluate.call(t,n,{smoothingEnabled:i}))}findClosestPoint(t,r){let n=r.data().map((s,l)=>this.xScale.scale(this.xAccessor(s,l,r))),i=Fs.sortedIndex(n,t.x);if(n.length==0)return null;if(i===n.length)i=i-1;else if(i!==0){let s=Math.abs(n[i-1]-t.x),l=Math.abs(n[i]-t.x);i=s<l?i-1:i}let o=r.data()[i],a=this.smoothingEnabled?this.smoothedAccessor(o,i,r):this.yValueAccessor(o,i,r);return{x:n[i],y:this.yScale.scale(a),datum:o,dataset:r}}resmoothDataset(t){let r=t.data(),n=this.smoothingWeight,i=r.length>0?0:NaN,o=0,a=r.map((l,c)=>this.yValueAccessor(l,c,t)),s=a.every(l=>l==a[0]);r.forEach((l,c)=>{let u=a[c];if(s||!Number.isFinite(u))l.smoothed=u;else{i=i*n+(1-n)*u,o++;let h=1;n!==1&&(h=1-Math.pow(n,o)),l.smoothed=i/h}})}getDataset(t){return this.name2datasets[t]===void 0&&(this.name2datasets[t]=new Mn.Dataset([],{name:t,meta:null})),this.name2datasets[t]}static getYScaleFromType(t){if(t===Bf.LOG)return new AB;if(t===Bf.LINEAR)return new MB;throw new Error("Unrecognized yScale type "+t)}setVisibleSeries(t){this.disableChanges(),t=t.sort(),t.reverse(),this.seriesNames=t}disableChanges(){this.dirtyDatasets.size||(this.linePlot.datasets([]),this.smoothLinePlot&&this.smoothLinePlot.datasets([]),this.marginAreaPlot&&this.marginAreaPlot.datasets([]))}commitChanges(){this.datasets=this.seriesNames.map(t=>this.getDataset(t)),[...this.dirtyDatasets].forEach(t=>{this.smoothingEnabled&&this.resmoothDataset(this.getDataset(t))}),this.updateSpecialDatasets(),this.linePlot.datasets(this.datasets),this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets),this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets),this.measureBBoxAndMaybeInvalidateLayoutInRaf(),this.dirtyDatasets.clear()}createSampledDatasetForMarkers(t){let r=t.data();if(r.length<=YKt)return t;let n=Math.ceil(r.length/YKt),i=new Array(Math.floor(r.length/n));for(let o=0,a=0;o<i.length;o++,a+=n)i[o]=r[a];return new Mn.Dataset(i,t.metadata())}setSeriesData(t,r){this.disableChanges(),this.getDataset(t).data(r),this.dirtyDatasets.add(t)}setSeriesMetadata(t,r){this.disableChanges(),this.getDataset(t).metadata(yh(ia({},this.getDataset(t).metadata()),{meta:r})),this.dirtyDatasets.add(t)}smoothingUpdate(t){this.smoothingWeight=t,this.datasets.forEach(r=>this.resmoothDataset(r)),this.smoothingEnabled||(this.linePlot.addClass("ghost"),this.scatterPlot.y(this.smoothedAccessor,this.yScale),this.smoothingEnabled=!0,this.smoothLinePlot.datasets(this.datasets)),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale),this.updateSpecialDatasets()}smoothingDisable(){this.smoothingEnabled&&(this.linePlot.removeClass("ghost"),this.scatterPlot.y(this.yValueAccessor,this.yScale),this.smoothLinePlot.datasets([]),this.smoothingEnabled=!1,this.updateSpecialDatasets()),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale)}setColorScale(t){this.colorScale=t}setTooltipColumns(t){this.tooltipColumns=t}setTooltipSortingMethod(t){this.tooltipSortingMethod=t}renderTo(t){this.targetSVG=t,this.outer.renderTo(t),this._defaultXRange!=null&&this.resetXDomain(),this._defaultYRange!=null&&this.resetYDomain(),this.measureBBoxAndMaybeInvalidateLayoutInRaf()}redraw(){window.cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout(),this.outer.redraw()})}measureBBoxAndMaybeInvalidateLayoutInRaf(){window.cancelAnimationFrame(this._invalidateLayoutRaf),this._invalidateLayoutRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout()})}measureBBoxAndMaybeInvalidateLayout(){if(this._lastDrawBBox){let{width:t}=this._lastDrawBBox,{width:r}=this.targetSVG.node().getBoundingClientRect();t==0&&t<r&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf),window.cancelAnimationFrame(this._invalidateLayoutRaf),this.outer&&this.outer.destroy()}onAnchor(t){this.outer&&this.outer.onAnchor(t)}isDataFitToDomain(){return t(this.xAxis.getScale())&&t(this.yAxis.getScale());function t(r){let n=r.getTransformationDomain(),i=r.getTransformationExtent();return i[0]===n[0]&&i[1]===n[1]}}};var XKt=Ee(Oe(),1),nst=Ee(Sl(),1);ys({moduleName:"plottable-style",styleContent:`
    
.plottable-colors-0 {
  background-color: #5279c7; /* INDIGO */
}

.plottable-colors-1 {
  background-color: #fd373e; /* CORAL_RED */
}

.plottable-colors-2 {
  background-color: #63c261; /* FERN */
}

.plottable-colors-3 {
  background-color: #fad419; /* BRIGHT_SUN */
}

.plottable-colors-4 {
  background-color: #2c2b6f; /* JACARTA */
}

.plottable-colors-5 {
  background-color: #ff7939; /* BURNING_ORANGE */
}

.plottable-colors-6 {
  background-color: #db2e65; /* CERISE_RED */
}

.plottable-colors-7 {
  background-color: #99ce50; /* CONIFER */
}

.plottable-colors-8 {
  background-color: #962565; /* ROYAL_HEATH */
}

.plottable-colors-9 {
  background-color: #06cccc; /* ROBINS_EGG_BLUE */
}

/**
 * User-supplied renderTo element.
 */
.plottable {
  display: block; /* must be block elements for width/height calculations to work in Firefox. */
  pointer-events: visibleFill;
  position: relative;
  /**
   * Pre 3.0, users could set the dimension of the root element in two ways: either using CSS
   * (inline or through a stylesheet), or using the SVG width/height attributes. By default, we
   * set the SVG width/height attributes to 100%.
   *
   * Post 3.0 the root element is always a normal div and the only way to set the dimensions is
   * to use CSS. To replicate the "100%-by-default" behavior, we apply width/height 100%.
   */
  width: 100%;
  height: 100%;
}

/**
 * The _element that roots each Component's DOM.
 */
.plottable .component {
  /* Allow components to be positioned with explicit left/top/width/height styles */
  position: absolute;
}

.plottable .background-container,
.plottable .content,
.plottable .foreground-container {
  position: absolute;
  width: 100%;
  height: 100%;
}

/**
 * Don't allow svg elements above the content to steal events
 */
.plottable .foreground-container {
  pointer-events: none;
}

.plottable .component-overflow-hidden {
  overflow: hidden;
}

.plottable .component-overflow-visible {
  overflow: visible;
}

.plottable .plot-canvas-container {
  width: 100%;
  height: 100%;
  overflow: hidden;
}

.plottable .plot-canvas {
  width: 100%;
  height: 100%;
  /**
   * Play well with deferred rendering.
   */
  transform-origin: 0px 0px 0px;
}

.plottable text {
  text-rendering: geometricPrecision;
}

.plottable .label text {
  fill: #32313F;
}

.plottable .bar-label-text-area text,
.plottable .scatter-label-text-area text {
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-size: 14px;
}

.plottable .light-label text {
  fill: white;
}

.plottable .dark-label text {
  fill: #32313F;
}

.plottable .off-bar-label text {
  fill: #32313F;
}

.plottable .stacked-bar-label text {
  fill: #32313F;
  font-style: normal;
}

.plottable .stacked-bar-plot .off-bar-label {
  /* HACKHACK #2795: correct off-bar label logic to be implemented on StackedBar */
  visibility: hidden !important;
}

.plottable .axis-label text {
  font-size: 10px;
  font-weight: bold;
  letter-spacing: 1px;
  line-height: normal;
  text-transform: uppercase;
}

.plottable .title-label text {
  font-size: 20px;
  font-weight: bold;
}

.plottable .axis line.baseline {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis line.tick-mark {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis text {
  fill: #32313F;
  font-size: 12px;
  font-weight: 200;
  line-height: normal;
}

.plottable .axis .annotation-circle {
  fill: white;
  stroke-width: 1px;
  stroke: #CCC;
}

.plottable .axis .annotation-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis .annotation-rect {
  stroke: #CCC;
  stroke-width: 1px;
  fill: white;
}

.plottable .bar-plot .baseline {
  stroke: #999;
}

.plottable .gridlines line {
  stroke: #3C3C3C; /* hackhack: gridlines should be solid; see #820 */
  opacity: 0.25;
  stroke-width: 1px;
}

.plottable .selection-box-layer .selection-area {
  fill: black;
  fill-opacity: 0.03;
  stroke: #CCC;
}
/* DragBoxLayer */
.plottable .drag-box-layer.x-resizable .drag-edge-lr {
  cursor: ew-resize;
}
.plottable .drag-box-layer.y-resizable .drag-edge-tb {
  cursor: ns-resize;
}

.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tl {
  cursor: nwse-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tr {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-bl {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-br {
  cursor: nwse-resize;
}

.plottable .drag-box-layer.movable .selection-area {
  cursor: move; /* IE fallback */
  cursor: -moz-grab;
  cursor: -webkit-grab;
  cursor: grab;
}

.plottable .drag-box-layer.movable .selection-area:active {
  cursor: -moz-grabbing;
  cursor: -webkit-grabbing;
  cursor: grabbing;
}
/* /DragBoxLayer */

.plottable .guide-line-layer line.guide-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .drag-line-layer.enabled.vertical line.drag-edge {
  cursor: ew-resize;
}

.plottable .drag-line-layer.enabled.horizontal line.drag-edge {
  cursor: ns-resize;
}

.plottable .legend text {
  fill: #32313F;
  font-size: 12px;
  font-weight: bold;
  line-height: normal;
}

.plottable .interpolated-color-legend rect.swatch-bounding-box {
  fill: none;
  stroke: #CCC;
  stroke-width: 1px;
  pointer-events: none;
}

.plottable .waterfall-plot line.connector {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .pie-plot .arc.outline {
  stroke-linejoin: round;
}

`});var o0;(function(e){e.GROUP="G",e.DIV="DIV",e.SVG="SVG",e.TEXT="TEXT"})(o0||(o0={}));var est=class{constructor(t){this.uniqueId=0,this.root=t}exportAsString(){let t=this.convert(this.root);if(!t)return"";let r=this.createRootSvg();return r.appendChild(t),r.outerHTML}createUniqueId(t){return`${t}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){let t=document.createElement("svg"),r=this.getSize();return t.setAttributeNS("svg","viewBox",`0 0 ${r.width} ${r.height}`),t.setAttribute("xmlns","http://www.w3.org/2000/svg"),t}createConvertedNode(t){let r=t.nodeName.toUpperCase();if(t.nodeType==Node.ELEMENT_NODE&&(r==o0.DIV||r==o0.SVG)){let n=document.createElement(o0.GROUP),i=window.getComputedStyle(t),o=parseInt(i.left,10),a=parseInt(i.top,10);if(o||a){let s=this.createUniqueId("clip");n.setAttribute("transform",`translate(${o}, ${a})`),n.setAttribute("clip-path",`url(#${s})`);let l=parseInt(i.width,10),c=parseInt(i.height,10),u=document.createElement("rect");u.setAttribute("width",String(l)),u.setAttribute("height",String(c));let h=document.createElementNS("svg","clipPath");h.id=s,h.appendChild(u),n.appendChild(h)}return n}else return t.cloneNode()}convert(t){let r=this.createConvertedNode(t);return Array.from(t.childNodes).map(i=>this.convert(i)).filter(Boolean).forEach(i=>{r.appendChild(i)}),r.nodeName.toUpperCase()==o0.GROUP&&!r.hasChildNodes()||this.shouldOmitNode(t)?null:this.stripClass(this.transferStyle(t,r))}stripClass(t){return t.nodeType==Node.ELEMENT_NODE&&t.removeAttribute("class"),t}transferStyle(t,r){if(r.nodeType!=Node.ELEMENT_NODE)return r;let n=r,i=r.nodeName.toUpperCase(),o=window.getComputedStyle(t);return i==o0.TEXT&&Object.assign(n.style,{fontFamily:o.fontFamily,fontSize:o.fontSize,fontWeight:o.fontWeight}),i!=o0.GROUP&&(n.setAttribute("fill",o.fill),n.setAttribute("stroke",o.stroke),n.setAttribute("stroke-width",o.strokeWidth)),o.opacity!="1"&&n.setAttribute("opacity",o.opacity),r}shouldOmitNode(t){return!1}},LB=class extends est{shouldOmitNode(t){return t.nodeType==Node.ELEMENT_NODE?t.classList.contains("scatter-plot"):!1}};ys({moduleName:"vz-pan-zoom-style",styleContent:`
    .help {
      align-items: center;
      animation-delay: 1s;
      animation-duration: 1s;
      animation-name: fade-out;
      background: rgba(30, 30, 30, 0.6);
      bottom: 0;
      color: #fff;
      display: flex;
      justify-content: center;
      left: 0;
      opacity: 1;
      padding: 20px;
      pointer-events: none;
      position: absolute;
      right: 0;
      top: 0;
    }

    .help > span {
      white-space: normal;
    }

    @keyframes fade-out {
      0% {
        opacity: 1;
      }

      100% {
        opacity: 0;
      }
    }
  `});var Oqe=Wu(r0),jKt=e=>isNaN(e)?"NaN":Oqe(e),ist=[{title:"Name",evaluate:e=>e.dataset.metadata().name},{title:"Smoothed",evaluate(e,t){let{smoothingEnabled:r}=t;return jKt(r?e.datum.smoothed:e.datum.scalar)}},{title:"Value",evaluate:e=>jKt(e.datum.scalar)},{title:"Step",evaluate:e=>b4(e.datum.step)},{title:"Time",evaluate:e=>yB(e.datum.wall_time)},{title:"Relative",evaluate:e=>vB(n0(e.datum,-1,e.dataset))}],Zr=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new nst.Scales.Color().range(jb.slice(0)),this.smoothingEnabled=!1,this.smoothingWeight=.6,this.xType=null,this.xComponentsCreationMethod=null,this.yValueAccessor=t=>t.scalar,this.tooltipColumns=ist,this.yScaleType=Bf.LINEAR,this.ignoreYOutliers=!1,this.tooltipSortingMethod="default",this.tooltipPosition=Wv.BOTTOM,this._visibleSeriesCache=[],this._seriesDataCache={},this._seriesMetadataCache={},this._makeChartAsyncCallbackId=null}ready(){super.ready(),this.scopeSubtree(this.$.chartdiv,!0)}attached(){let t={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),t),this._listen(this,"mouseup",this._onMouseUp.bind(this),t),this._listen(window,"keydown",this._onKeyDown.bind(this),t),this._listen(window,"keyup",this._onKeyUp.bind(this),t)}detached(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._chart&&(this._chart.destroy(),this._chart=void 0),this._listeners&&(this._listeners.forEach(({node:t,eventName:r,func:n,option:i})=>{t.removeEventListener(r,n,i)}),this._listeners.clear())}_listen(t,r,n,i={}){this._listeners||(this._listeners=new Set),this._listeners.add({node:t,eventName:r,func:n,option:i}),t.addEventListener(r,n,i)}_onKeyDown(t){this.toggleClass("pankey",Ff.isPanKey(t))}_onKeyUp(t){this.toggleClass("pankey",Ff.isPanKey(t))}_onMouseDown(t){this.toggleClass("mousedown",!0)}_onMouseUp(t){this.toggleClass("mousedown",!1)}isDataFitToDomain(){return this._chart?this._chart.isDataFitToDomain():!0}setVisibleSeries(t){XKt.isEqual(this._visibleSeriesCache,t)||(this._visibleSeriesCache=t)}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}setSeriesMetadata(t,r){this._seriesMetadataCache[t]=r,this._chart&&this._chart.setSeriesMetadata(t,r)}commitChanges(){!this._chart||this._chart.commitChanges()}resetDomain(){this._chart&&this._chart.resetDomain()}redraw(){this._chart&&this._chart.redraw()}_makeChart(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;let t=this.xComponentsCreationMethod;if(!this.xType&&!t?t=Xat:this.xType&&(t=()=>xB(this.xType)),!(!t||!this.yValueAccessor||!this.tooltipColumns)){var r=new DS(t,this.yValueAccessor,this.yScaleType,this.colorScale,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,this.symbolFunction,this.xAxisFormatter),n=Ht(this.$.chartdiv);r.renderTo(n),this._chart&&this._chart.destroy(),this._chart=r,this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)}_reloadFromCache(){!this._chart||(this._visibleSeriesCache.forEach(t=>{this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}),this._visibleSeriesCache.filter(t=>this._seriesMetadataCache[t]).forEach(t=>{this._chart.setSeriesMetadata(t,this._seriesMetadataCache[t])}),this._chart.setVisibleSeries(this._visibleSeriesCache),this._chart.commitChanges())}_smoothingChanged(){!this._chart||(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())}_outliersChanged(){!this._chart||this._chart.ignoreYOutliers(this.ignoreYOutliers)}_colorScaleChanged(){!this._chart||(this._chart.setColorScale(this.colorScale),this._chart.redraw())}_tooltipColumnsChanged(){!this._chart||this._chart.setTooltipColumns(this.tooltipColumns)}_tooltipSortingMethodChanged(){!this._chart||this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)}getExporter(){return new LB(this.$.chartdiv)}};Zr.template=Q`
    <div id="chartdiv"></div>
    <vz-chart-tooltip
      id="tooltip"
      position="[[tooltipPosition]]"
      content-component-name="vz-line-chart-tooltip"
    ></vz-chart-tooltip>
    <style include="plottable-style"></style>
    <style include="vz-pan-zoom-style"></style>
    <style>
      :host {
        -moz-user-select: none;
        -webkit-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        outline: none;
        position: relative;
        white-space: nowrap;
      }
      div {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #chartdiv .main {
        contain: strict;
        cursor: crosshair;
      }

      :host(.pankey) #chartdiv :not(.drag-zooming) .main {
        cursor: -webkit-grab;
        cursor: grab;
      }

      :host(.mousedown) #chartdiv .panning .main {
        cursor: -webkit-grabbing;
        cursor: grabbing;
      }

      #chartdiv {
        contain: strict;
      }

      #chartdiv line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover .main {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }

      .plottable .axis text {
        fill: currentColor;
      }

      .plottable .gridlines line {
        stroke: var(--tb-secondary-text-color);
      }
    </style>
  `;E([A({type:Object}),w("design:type",nst.Scales.Color)],Zr.prototype,"colorScale",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"symbolFunction",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Zr.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Zr.prototype,"smoothingWeight",void 0);E([A({type:String}),w("design:type",Object)],Zr.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"xAxisFormatter",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"tooltipColumns",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultYRange",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"yScaleType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zr.prototype,"ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipPosition",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesDataCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesMetadataCache",void 0);E([A({type:Number}),w("design:type",Object)],Zr.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xComponentsCreationMethod","xType","yValueAccessor","yScaleType","isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_makeChart",null);E([Bt("_chart","_visibleSeriesCache"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_reloadFromCache",null);E([Bt("smoothingEnabled","smoothingWeight","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_smoothingChanged",null);E([Bt("ignoreYOutliers","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_outliersChanged",null);E([Bt("colorScale"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_colorScaleChanged",null);E([Bt("tooltipColumns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipColumnsChanged",null);E([Bt("tooltipSortingMethod","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipSortingMethodChanged",null);Zr=E([yt("vz-line-chart2")],Zr);var rst=class extends mt{};rst.template=Q`
    <div class="content">
      <table>
        <thead></thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host {
        pointer-events: none;
      }

      .content {
        background: rgba(0, 0, 0, 0.8);
        border-radius: 4px;
        color: #fff;
        overflow: hidden;
        pointer-events: none;
      }

      table {
        font-size: 13px;
        line-height: 1.4em;
        margin-top: 10px;
        padding: 8px;
      }

      thead {
        font-size: 14px;
      }

      tbody {
        font-size: 13px;
        line-height: 21px;
        white-space: nowrap;
      }

      td {
        padding: 0 5px;
      }

      .swatch {
        border-radius: 50%;
        display: block;
        height: 18px;
        width: 18px;
      }

      .closest .swatch {
        box-shadow: inset 0 0 0 2px #fff;
      }

      th {
        padding: 0 5px;
        text-align: left;
      }

      .distant td:not(.swatch) {
        opacity: 0.8;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `;rst=E([yt("vz-line-chart-tooltip")],rst);var ost=[],zqe=0,Fqe=$Kt.throttle(function e(){if(ost.length==0)return;let t=ost.shift();t&&t.active&&(t.redraw(),t._maybeRenderedInBadState=!1),window.cancelAnimationFrame(zqe),window.requestAnimationFrame(e)},100),Vn=class extends kS(Gt(mt)){constructor(){super(...arguments),this._redrawRaf=null,this.active=!1,this.logScaleActive=!1,this.colorScale={scale:fn},this._resetDomainOnNextLoad=!0,this._maybeRenderedInBadState=!1}onLoadFinish(){this.commitChanges(),this.dataToLoad.length>0&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.getChart().resetDomain()),this.redraw()}disconnectedCallback(){super.disconnectedCallback(),this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf)}exportAsSvgString(){return this.getChart().getExporter().exportAsString()}getChart(){return this.$.chart}resetDomain(){this.getChart().resetDomain()}setSeriesData(t,r){this.getChart().setSeriesData(t,r)}setSeriesMetadata(t,r){this.getChart().setSeriesMetadata(t,r)}commitChanges(){this.getChart().commitChanges()}redraw(){this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.active?this.getChart().redraw():this._maybeRenderedInBadState=!0})}_loadKeyChanged(){this.reset(),this._resetDomainOnNextLoad=!0}_dataSeriesChanged(){this.getChart().setVisibleSeries(this.dataSeries)}_logScaleChanged(t){let r=this.getChart();r.yScaleType=t?Bf.LOG:Bf.LINEAR,this.redraw()}_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(ost.push(this),Fqe())}_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}};Vn.template=Q`
    <div id="chart-and-spinner-container">
      <vz-line-chart2
        id="chart"
        data-loading$="[[dataLoading]]"
        data-loaded-once$="[[dataLoadedAtLeastOnce]]"
        color-scale="[[colorScale]]"
        default-x-range="[[defaultXRange]]"
        default-y-range="[[defaultYRange]]"
        fill-area="[[fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        on-chart-attached="_onChartAttached"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[symbolFunction]]"
        tooltip-columns="[[tooltipColumns]]"
        tooltip-position="[[tooltipPosition]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-components-creation-method="[[xComponentsCreationMethod]]"
        x-type="[[xType]]"
        y-value-accessor="[[yValueAccessor]]"
      ></vz-line-chart2>
      <template is="dom-if" if="[[dataLoading]]">
        <div id="loading-spinner-container">
          <paper-spinner-lite active=""></paper-spinner-lite>
        </div>
      </template>
    </div>
    <style>
      :host {
        height: 100%;
        width: 100%;
        display: flex;
        flex-direction: column;
      }

      :host([_maybe-rendered-in-bad-state]) vz-line-chart {
        visibility: hidden;
      }

      #chart-and-spinner-container {
        display: flex;
        flex-grow: 1;
        position: relative;
      }

      #loading-spinner-container {
        align-items: center;
        bottom: 0;
        display: flex;
        display: flex;
        justify-content: center;
        left: 0;
        pointer-events: none;
        position: absolute;
        right: 0;
        top: 0;
      }

      vz-line-chart2 {
        -webkit-user-select: none;
        -moz-user-select: none;
      }

      vz-line-chart2[data-loading] {
        opacity: 0.3;
      }
    </style>
  `;E([A({type:Boolean,observer:"_fixBadStateWhenActive"}),w("design:type",Boolean)],Vn.prototype,"active",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"dataSeries",void 0);E([A({type:Object}),w("design:type",Ae)],Vn.prototype,"requestManager",void 0);E([A({type:Boolean,observer:"_logScaleChanged"}),w("design:type",Boolean)],Vn.prototype,"logScaleActive",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"xComponentsCreationMethod",void 0);E([A({type:String}),w("design:type",String)],Vn.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Function)],Vn.prototype,"yValueAccessor",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"fillArea",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Vn.prototype,"smoothingWeight",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"tooltipColumns",void 0);E([A({type:String}),w("design:type",Object)],Vn.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Vn.prototype,"tooltipPosition",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"ignoreYOutliers",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],Vn.prototype,"symbolFunction",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"_resetDomainOnNextLoad",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Vn.prototype,"_maybeRenderedInBadState",void 0);E([Bt("loadKey"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vn.prototype,"_loadKeyChanged",null);E([Bt("dataSeries.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vn.prototype,"_dataSeriesChanged",null);Vn=E([yt("tf-line-chart-data-loader")],Vn);ys({moduleName:"tf-custom-scalar-card-style",styleContent:`
    :host {
      margin: 5px 10px;
      display: inline-block;
      width: 330px;
      vertical-align: text-top;
    }

    :host([_expanded]) {
      width: 100%;
    }

    :host([_expanded]) #tf-line-chart-data-loader-container {
      height: 400px;
    }

    h1 {
      font-size: 19px;
      font-weight: normal;
    }

    #tf-line-chart-data-loader-container {
      height: 200px;
      width: 100%;
    }

    #buttons {
      display: flex;
      flex-direction: row;
    }

    paper-icon-button {
      color: #2196f3;
      border-radius: 100%;
      width: 32px;
      height: 32px;
      padding: 4px;
    }

    paper-icon-button[selected] {
      background: var(--tb-ui-light-accent);
    }

    .download-links {
      display: flex;
      height: 32px;
    }

    .download-links a {
      font-size: 10px;
      align-self: center;
      margin: 2px;
    }

    .download-links paper-dropdown-menu {
      width: 100px;
      --paper-input-container-label: {
        font-size: 10px;
      }
      --paper-input-container-input: {
        font-size: 10px;
      }
    }
  `});var OS=class{constructor(t,r,n,i,o){this.run=t,this.tag=r,this.name=n,this.scalarData=i,this.symbol=o}getName(){return this.name}setData(t){this.scalarData=t}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}};function kB(e,t){return`${t} (${e})`}var Yv=class{constructor(t){this.runBasedColorScale=t}scale(t){return this.runBasedColorScale.scale(this.parseRunName(t))}parseRunName(t){let r=t.match(/\((.*)\)$/);return r?r[1]:""}};var Jr=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Yv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1,this._fillArea={lowerAccessor:t=>t.lower,higherAccessor:t=>t.upper},this._tooltipColumns=(()=>{let t=Wu(r0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Name",evaluate:n=>n.dataset.metadata().name},{title:"Value",evaluate:n=>r(n.datum.scalar)},{title:"Lower Margin",evaluate:n=>r(n.datum.lower)},{title:"Upper Margin",evaluate:n=>r(n.datum.upper)},{title:"Step",evaluate:n=>b4(n.datum.step)},{title:"Time",evaluate:n=>yB(n.datum.wall_time)},{title:"Relative",evaluate:n=>vB(n0(n.datum,-1,n.dataset))}]})(),this._missingTags=[],this._missingTagsCollapsibleOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(t){return(r,n,i)=>{if(!i.regex_valid){this.set("_tagFilterInvalid",!0);return}let o=Yo.clone(this._nameToDataSeries),a=[];Yo.forEach(t,l=>{let c=!1,u=i.tag_to_events[l.value],h=i.tag_to_events[l.lower],f=i.tag_to_events[l.upper];if(Yo.isUndefined(u)&&(a.push(l.value),c=!0),Yo.isUndefined(h)&&(a.push(l.lower),c=!0),Yo.isUndefined(f)&&(a.push(l.upper),c=!0),c)return;let p=b=>b[1],d=this._findStepMismatch(l,u.map(p),h.map(p),f.map(p));if(d){this.set("_stepsMismatch",d);return}let g=b=>b[2],_=u.map((b,S)=>({wall_time:new Date(b[0]*1e3),step:p(b),scalar:g(b),lower:g(h[S]),upper:g(f[S])})),y=kB(n,l.value),x=o[y];if(x)x.setData(_);else{let b=this._createNewDataSeries(n,l.value,y,_);o[y]=b}}),this.set("_nameToDataSeries",o);let s=Yo.findIndex(this._missingTags,l=>l.run===n);if(a.length&&a.length!=3){let l={run:n,tags:a};s>=0?this.splice("_missingTags",s,1,l):this.push("_missingTags",l)}else s>=0&&this.splice("_missingTags",s,1)}}_findStepMismatch(t,r,n,i){return Yo.isEqual(n,r)&&Yo.isEqual(i,r)?null:{seriesObject:t,valueSteps:r,lowerSteps:n,upperSteps:i}}_createNewDataSeries(t,r,n,i){this._runToNextAvailableSymbolIndex[t]|=0;let o=RS[this._runToNextAvailableSymbolIndex[t]],a=new OS(t,r,n,i,o),s=RS.length;return this._runToNextAvailableSymbolIndex[t]=(this._runToNextAvailableSymbolIndex[t]+1)%s,a}_updateChart(){var t=this._nameToDataSeries;Yo.forOwn(t,r=>{this.$.loader.setSeriesData(r.getName(),r.getData())}),this.$.loader.commitChanges()}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.marginChartSeries;return Yo.flatten(t.map(i=>[i.value,i.lower,i.upper])).map(i=>"("+this._escapeRegexCharacters(i)+")").join("|")}_escapeRegexCharacters(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}_getToggleCollapsibleIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_separateWithCommas(t){return t.join(", ")}_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)}_matchListEntryColorUpdated(){var r;let t=this.$$("#match-list-repeat");!t||(r=this.root)==null||r.querySelectorAll(".match-list-entry").forEach(n=>{let i=t.itemForElement(n);n.style.color=this._determineColor(this._colorScale,i)})}};Jr.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        fill-area="[[_fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction(marginChartSeries)]]"
        request-manager="[[requestManager]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>

    <!-- here -->
    <template is="dom-if" if="[[_missingTags.length]]">
      <div class="collapsible-list-title">
        <paper-icon-button
          icon="[[_getToggleCollapsibleIcon(_missingTagsCollapsibleOpened)]]"
          on-click="_toggleMissingTagsCollapsibleOpen"
          class="toggle-collapsible-button"
        >
        </paper-icon-button>
        <span class="collapsible-title-text">
          <iron-icon icon="icons:error"></iron-icon> Missing Tags
        </span>
      </div>
      <iron-collapse opened="[[_missingTagsCollapsibleOpened]]">
        <div class="error-content">
          <iron-icon class="error-icon" icon="icons:error"></iron-icon>
          <template is="dom-repeat" items="[[_missingTags]]" as="missingEntry">
            <div class="missing-tags-for-run-container">
              Run "[[missingEntry.run]]" lacks data for tags
              <ul>
                <template
                  is="dom-repeat"
                  items="[[missingEntry.tags]]"
                  as="tag"
                >
                  <li>[[tag]]</li>
                </template>
              </ul>
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>

    <template is="dom-if" if="[[_tagFilterInvalid]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        This regular expresion is invalid:<br />
        <span class="invalid-regex">[[_tagFilter]]</span>
      </div>
    </template>

    <template is="dom-if" if="[[_stepsMismatch]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        The steps for value, lower, and upper tags do not match:
        <ul>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.value]]</span>:
            [[_separateWithCommas(_stepsMismatch.valueSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.lower]]</span>:
            [[_separateWithCommas(_stepsMismatch.lowerSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.upper]]</span>:
            [[_separateWithCommas(_stepsMismatch.upperSteps)]]
          </li>
        </ul>
      </div>
    </template>

    <div id="matches-container">
      <div class="collapsible-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleCollapsibleIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="collapsible-title-text">
          Matches ([[_seriesNames.length]])
        </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      .error-content {
        background: #f00;
        border-radius: 5px;
        color: #fff;
        margin: 10px 0 0 0;
        padding: 10px;
      }

      .error-icon {
        display: block;
        fill: #fff;
        margin: 0 auto 5px auto;
      }

      .invalid-regex {
        font-weight: bold;
      }

      .error-content ul {
        margin: 1px 0 0 0;
        padding: 0 0 0 19px;
      }

      .tag-name {
        font-weight: bold;
      }

      .collapsible-list-title {
        margin: 10px 0 5px 0;
      }

      .collapsible-title-text {
        vertical-align: middle;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .missing-tags-for-run-container {
        margin: 8px 0 0 0;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Jr.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"marginChartSeries",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Jr.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"showDownloadLinks",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_tagFilterInvalid",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Jr.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],Jr.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_matchesListOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_missingTags",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_missingTagsCollapsibleOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_stepsMismatch",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],Jr.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_refreshDataSeries",null);E([Rt("marginChartSeries"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_titleDisplayString",null);Jr=E([yt("tf-custom-scalar-margin-chart-card")],Jr);var a0=Ee(Oe(),1);var RB={};Zs(RB,{BaseStore:()=>wp,Canceller:()=>an,EnvironmentStore:()=>V9,ExperimentsStore:()=>rR,HttpMethodType:()=>Pm,InvalidRequestOptionsError:()=>Vx,ListenKey:()=>H9,RequestCancellationError:()=>c9,RequestManager:()=>Ae,RequestNetworkError:()=>uE,RequestOptions:()=>Ux,RunsStore:()=>U9,TYPES:()=>Oxe,addParams:()=>Mi,createRouter:()=>Rgt,createSearchParam:()=>Ngt,environmentStore:()=>ib,experimentsStore:()=>nR,filterTags:()=>Fxe,getRouter:()=>_e,getRunsNamed:()=>zxe,getTags:()=>$i,runsStore:()=>Sp});var En=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new Yv({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=_e().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Mi(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i=new URLSearchParams({tag:n.getTag(),run:n.getRun()});return _e().pluginRouteForSrc("custom_scalars","/download_data",i)}_createProcessDataFunction(){return(t,r,n)=>{if(n.regex_valid){let i=a0.clone(this._nameToDataSeries);a0.forOwn(n.tag_to_events,(o,a)=>{let s=o.map(u=>({wall_time:new Date(u[0]*1e3),step:u[1],scalar:u[2]})),l=kB(r,a),c=i[l];if(c)c.setData(s);else{a0.isUndefined(this._runToNextAvailableSymbolIndex[r])&&(this._runToNextAvailableSymbolIndex[r]=0);let u=RS[this._runToNextAvailableSymbolIndex[r]],h=new OS(r,a,l,s,u);i[l]=h;let f=RS.length;this._runToNextAvailableSymbolIndex[r]=(this._runToNextAvailableSymbolIndex[r]+1)%f}}),this.set("_nameToDataSeries",i)}}}_updateChart(){var t=this._nameToDataSeries;Object.entries(t).forEach(([r,n])=>{this.$.loader.setSeriesData(r,n.getData())}),this.$.loader.commitChanges()}_computeSelectedRunsSet(t){let r={};return a0.forEach(t,n=>{r[n]=1}),r}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.tagRegexes;return t.length===1?t[0]:t.map(r=>"("+r+")").join("|")}_getToggleMatchesIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_matchListEntryColorUpdated(t){var n;let r=this.$$("#match-list-repeat");!r||(n=this.root)==null||n.querySelectorAll(".match-list-entry").forEach(i=>{let o=r.itemForElement(i);i.style.color=this._determineColor(this._colorScale,o)})}};En.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction()]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>
    <div id="matches-container">
      <div id="matches-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleMatchesIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="matches-text"> Matches ([[_seriesNames.length]]) </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      #matches-list-title {
        margin: 10px 0 5px 0;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .matches-text {
        vertical-align: middle;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],En.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],En.prototype,"tagRegexes",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],En.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"showDownloadLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],En.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Yv)],En.prototype,"_colorScale",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],En.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],En.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_matchesListOpened",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],En.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_refreshDataSeries",null);E([Rt("tagRegexes"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_titleDisplayString",null);En=E([yt("tf-custom-scalar-multi-line-chart-card")],En);var jo=class extends mt{constructor(){super(...arguments),this._requestManager=new Ae(50),this._canceller=new an,this._showDownloadLinks=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType="step",this._active=!0,this.reloadOnReady=!0,this._showDownloadLinksObserver=bp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=bp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){let t=_e().pluginsListing(),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_dataNotFound",!n.value.custom_scalars),!this._dataNotFound&&this._retrieveLayoutAndData())});this._requestManager.request(t).then(r)}_reloadCharts(){var r;let t=(r=this.root)==null?void 0:r.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card");t==null||t.forEach(n=>{n.reload()})}_retrieveLayoutAndData(){let t=_e().pluginRoute("custom_scalars","/layout"),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_layout",n.value),this._dataNotFound||this._reloadCharts())});this._requestManager.request(t).then(r)}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}get _categories(){var t=this._layout;if(!t.category)return[];let r=!1;return this._openedCategories||(r=!0,this._openedCategories={}),t.category.map(i=>(r&&!i.closed&&(this._openedCategories[i.title]=!0),{name:i.title,items:i.chart,metadata:{type:Da.PREFIX_GROUP,opened:!!this._openedCategories[i.title]}}))}_categoryOpenedToggled(t){let r=t.target;r.opened?this._openedCategories[r.category.name]=!0:delete this._openedCategories[r.category.name]}};jo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div id="tooltip-sorting-label">Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float=""
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="1"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center" id="categories-container">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>The custom scalars dashboard is inactive.</h3>
            <p>Probable causes:</p>
            <ol>
              <li>You haven't laid out the dashboard.</li>
              <li>You haven’t written any scalar data to your event files.</li>
            </ol>

            <p>
              To lay out the dashboard, pass a <code>Layout</code> protobuffer
              to the <code>set_layout</code> method. For example,
            </p>
            <pre>
from tensorboard import summary
from tensorboard.plugins.custom_scalar import layout_pb2
...
# This action does not have to be performed at every step, so the action is not
# taken care of by an op in the graph. We only need to specify the layout once
# (instead of per step).
layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(
  category=[
    layout_pb2.Category(
      title='losses',
      chart=[
          layout_pb2.Chart(
              title='losses',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'loss.*'],
              )),
          layout_pb2.Chart(
              title='baz',
              margin=layout_pb2.MarginChartContent(
                series=[
                  layout_pb2.MarginChartContent.Series(
                    value='loss/baz/scalar_summary',
                    lower='baz_lower/baz/scalar_summary',
                    upper='baz_upper/baz/scalar_summary'),
                ],
              )),
      ]),
    layout_pb2.Category(
      title='trig functions',
      chart=[
          layout_pb2.Chart(
              title='wave trig functions',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/cosine', r'trigFunctions/sine'],
              )),
          # The range of tangent is different. Let's give it its own chart.
          layout_pb2.Chart(
              title='tan',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/tangent'],
              )),
      ],
      # This category we care less about. Let's make it initially closed.
      closed=True),
  ]))
writer.add_summary(layout_summary)
</pre
            >
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              as="chart"
              category="[[category]]"
              disable-pagination
              initial-opened="[[category.metadata.opened]]"
            >
              <template>
                <template is="dom-if" if="[[chart.multiline]]">
                  <tf-custom-scalar-multi-line-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    smoothing-enabled="[[_smoothingEnabled]]"
                    smoothing-weight="[[_smoothingWeight]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    tag-regexes="[[chart.multiline.tag]]"
                  ></tf-custom-scalar-multi-line-chart-card>
                </template>
                <template is="dom-if" if="[[chart.margin]]">
                  <tf-custom-scalar-margin-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    margin-chart-series="[[chart.margin.series]]"
                  ></tf-custom-scalar-margin-chart-card>
                </template>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Ae)],jo.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],jo.prototype,"_canceller",void 0);E([A({type:Array}),w("design:type",Array)],jo.prototype,"_selectedRuns",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],jo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],jo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],jo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],jo.prototype,"_xType",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_layout",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_dataNotFound",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_openedCategories",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"reloadOnReady",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],jo.prototype,"_smoothingEnabled",null);E([Rt("_layout"),w("design:type",Array),w("design:paramtypes",[])],jo.prototype,"_categories",null);jo=E([yt("tf-custom-scalar-dashboard")],jo);var DB=Ee(Oe(),1);var ast=Ee(Oe(),1),wa=Ee(Sl(),1);var NB=class{constructor(t,r){this.run2datasets={},this.colorScale=r,this.buildChart(t)}getDataset(t){return this.run2datasets[t]===void 0&&(this.run2datasets[t]=new wa.Dataset([],{run:t})),this.run2datasets[t]}buildChart(t){this.outer&&this.outer.destroy();let r=xB(t);this.xAccessor=r.accessor,this.xScale=r.scale,this.xAxis=r.axis,this.xAxis.margin(0),this.xAxis.tickLabelPadding(3),this.yScale=new wa.Scales.Linear,this.yAxis=new wa.Axes.Numeric(this.yScale,"left");let n=Wu(mB);this.yAxis.margin(0).tickLabelPadding(5).formatter(n),this.yAxis.usesTextWidthApproximation(!0);let i=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new wa.Components.Gridlines(this.xScale,this.yScale),this.center=new wa.Components.Group([this.gridlines,i]),this.outer=new wa.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){let i=[0,228,1587,3085,5e3,6915,8413,9772,1e4],o=ast.range(i.length-1).map(h=>(i[h+1]-i[h])/2500),a=i.map((h,f)=>p=>p[f][1]),s=4,l=a[s],c=ast.range(a.length-1).map(h=>{let f=new wa.Plots.Area;f.x(t,r);let p=h>s?a[h]:a[h+1],d=h>s?a[h+1]:a[h];return f.y(d,n),f.y0(p),f.attr("fill",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke-weight",(g,_,y)=>"0.5px"),f.attr("stroke-opacity",()=>o[h]),f.attr("fill-opacity",()=>o[h]),f}),u=new wa.Plots.Line;return u.x(t,r),u.y(l,n),u.attr("stroke",(h,f,p)=>this.colorScale.scale(p.run)),this.plots=c,new wa.Components.Group(c)}setVisibleSeries(t){this.runs=t;let r=t.map(n=>this.getDataset(n));this.plots.forEach(n=>n.datasets(r))}setSeriesData(t,r){this.getDataset(t).data(r)}renderTo(t){this.targetSVG=t,this.outer.renderTo(t)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}},Bc=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new wa.Scales.Color().range(jb.slice()),this.xType="step",this._visibleSeriesCache=[],this._seriesDataCache={},this._makeChartAsyncCallbackId=null}setVisibleSeries(t){this._visibleSeriesCache=t,this._chart&&(this._chart.setVisibleSeries(t),this.redraw())}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}redraw(){this._chart.redraw()}_makeChart(){var t=this.xType,r=this.colorScale,n=this._attached;this._makeChartAsyncCallbackId!==null&&this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=this.async(function(){if(this._makeChartAsyncCallbackId=null,!!n){this._chart&&this._chart.destroy();var i=new NB(t,r),o=Ht(this.$.chartdiv);i.renderTo(o),this._chart=i}},350)}_reloadFromCache(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),this._visibleSeriesCache.forEach(function(t){this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}.bind(this)))}attached(){this._attached=!0}detached(){this._attached=!1}};Bc.template=Q`
    <style include="plottable-style"></style>
    <div id="chartdiv"></div>
    <style>
      :host {
        -webkit-user-select: none;
        -moz-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }
      #chartdiv {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }
      .plottable .axis text {
        fill: currentColor;
      }
    </style>
  `;E([A({type:Object}),w("design:type",wa.Scales.Color)],Bc.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Bc.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bc.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",NB)],Bc.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Bc.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Bc.prototype,"_seriesDataCache",void 0);E([A({type:Number}),w("design:type",Object)],Bc.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xType","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_makeChart",null);E([Bt("_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_reloadFromCache",null);Bc=E([yt("vz-distribution-chart")],Bc);var Sa=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("distributions","/distributions");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=n.map(a=>{let[s,l,c]=a;return c.wall_time=new Date(s*1e3),c.step=l,c}),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i),this.$.chart.setVisibleSeries([o])},this._colorScale={scale:fn},this._expanded=!1,this._canceller=new an}_reloadOnRunTagChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScale.scale(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};Sa.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main distribution that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-distribution-chart
      id="chart"
      x-type="[[xType]]"
      color-scale="[[_colorScale]]"
    ></vz-distribution-chart>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Sa.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Sa.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],Sa.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Sa.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],Sa.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Object)],Sa.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],Sa.prototype,"_colorScale",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Sa.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Ae)],Sa.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],Sa.prototype,"_canceller",void 0);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Sa.prototype,"_reloadOnRunTagChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Sa.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Sa.prototype,"_runColor",null);Sa=E([yt("tf-distribution-loader")],Sa);var Ml=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._xType="step",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadDistributions()})}_fetchTags(){let t=_e().pluginRoute("distributions","/tags");return this._requestManager.request(t).then(r=>{if(DB.isEqual(r,this._runToTagInfo))return;let n=DB.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadDistributions(){var t;(t=this.root)==null||t.querySelectorAll("tf-distribution-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};Ml.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="xTypeSelector"
              name="Horizontal axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>

      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No distribution data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
                (Histograms and distributions both use the histogram summary
                operation.)
              </li>

              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-distribution-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  x-type="[[_xType]]"
                  request-manager="[[_requestManager]]"
                ></tf-distribution-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Ml.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],Ml.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],Ml.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Ml.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],Ml.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ml.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Ml.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ml.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],Ml.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Ml.prototype,"_categories",null);Ml=E([yt("tf-distribution-dashboard")],Ml);var OB={};Zs(OB,{DISAMBIGUATOR:()=>q0t,ListenKey:()=>mE,addHashListener:()=>gE,addStorageListener:()=>TW,disposeBooleanBinding:()=>t2e,disposeNumberBinding:()=>e2e,disposeObjectBinding:()=>i2e,disposeStringBinding:()=>Zbe,fireStorageChanged:()=>CW,getBoolean:()=>Jbe,getBooleanInitializer:()=>xp,getBooleanObserver:()=>bp,getNumber:()=>NW,getNumberInitializer:()=>_E,getNumberObserver:()=>yE,getObject:()=>r2e,getObjectInitializer:()=>OW,getObjectObserver:()=>zW,getString:()=>$be,getStringInitializer:()=>v_,getStringObserver:()=>x_,getUrlHashDict:()=>B0t,makeBindings:()=>vE,migrateLegacyURLScheme:()=>o2e,removeHashListenerByKey:()=>AW,removeStorageListenerByKey:()=>PW,setBoolean:()=>Qbe,setNumber:()=>DW,setObject:()=>n2e,setString:()=>Kbe});var ict=Ee(Oe(),1);var KKt="Graph dashboard actions",ZKt="Graph dashboard timings",sst;(function(e){e.FETCH_PBTXT_BYTES="FETCH_PBTXT_BYTES",e.FETCH_PBTXT_BYTES_FROM_FILESYSTEM="FETCH_PBTXT_BYTES_FROM_FILESYSTEM",e.FETCH_PBTXT_BYTES_FROM_SERVER="FETCH_PBTXT_BYTES_FROM_SERVER",e.PARSE_PBTXT_INTO_OBJECT="PARSE_PBTXT_INTO_OBJECT",e.FETCH_METADATA_PBTXT_BYTES="FETCH_METADATA_PBTXT_BYTES",e.PARSE_METADATA_PBTXT_INTO_OBJECT="PARSE_METADATA_PBTXT_INTO_OBJECT",e.NORMALIZING_NAMES="NORMALIZING_NAMES",e.BUILD_SLIM_GRAPH="BUILD_SLIM_GRAPH",e.HIERARCHY_ADD_NODES="HIERARCHY_ADD_NODES",e.HIERARCHY_DETECT_SERIES="HIERARCHY_DETECT_SERIES",e.HIERARCHY_ADD_EDGES="HIERARCHY_ADD_EDGES",e.HIERARCHY_FIND_SIMILAR_SUBGRAPHS="HIERARCHY_FIND_SIMILAR_SUBGRAPHS",e.RENDER_BUILD_HIERARCHY="RENDER_BUILD_HIERARCHY",e.RENDER_SCENE_LAYOUT="RENDER_SCENE_LAYOUT",e.RENDER_SCENE_BUILD_SCENE="RENDER_SCENE_BUILD_SCENE",e.GRAPH_LOAD_SUCCEEDED="GRAPH_LOAD_SUCCEEDED",e.GRAPH_LOAD_FAILED="GRAPH_LOAD_FAILED"})(sst||(sst={}));var lst;(function(e){e.NODE_EXPANSION_TOGGLED="NODE_EXPANSION_TOGGLED",e.NODE_SEARCH_RESULT_FOCUSED="NODE_SEARCH_RESULT_FOCUSED",e.NODE_AUXILIARY_EXTRACTION_CHANGED="NODE_AUXILIARY_EXTRACTION_CHANGED",e.GRAPH_TYPE_CHANGED="GRAPH_TYPE_CHANGED",e.TRACE_INPUT_MODE_TOGGLED="TRACE_INPUT_MODE_TOGGLED",e.NODE_COLOR_MODE_CHANGED="NODE_COLOR_MODE_CHANGED",e.UPLOADED_GRAPH_FROM_FILESYSTEM="UPLOADED_GRAPH_FROM_FILESYSTEM"})(lst||(lst={}));var jr=ia(ia({},sst),lst);var nle=Ee(Olt(),1),pn=Ee(Oe(),1);var Bs;(function(e){e.OP_GRAPH="op_graph",e.CONCEPTUAL_GRAPH="conceptual_graph",e.PROFILE="profile"})(Bs||(Bs={}));var ve={Node:{CONTAINER:"nodes",GROUP:"node",SHAPE:"nodeshape",COLOR_TARGET:"nodecolortarget",LABEL:"nodelabel",BUTTON_CONTAINER:"buttoncontainer",BUTTON_CIRCLE:"buttoncircle",EXPAND_BUTTON:"expandbutton",COLLAPSE_BUTTON:"collapsebutton"},Edge:{CONTAINER:"edges",GROUP:"edge",LINE:"edgeline",REFERENCE_EDGE:"referenceedge",REF_LINE:"refline",SELECTABLE:"selectableedge",SELECTED:"selectededge",STRUCTURAL:"structural"},Annotation:{OUTBOX:"out-annotations",INBOX:"in-annotations",GROUP:"annotation",NODE:"annotation-node",EDGE:"annotation-edge",CONTROL_EDGE:"annotation-control-edge",LABEL:"annotation-label",ELLIPSIS:"annotation-ellipsis"},Scene:{GROUP:"scene",CORE:"core",FUNCTION_LIBRARY:"function-library",INEXTRACT:"in-extract",OUTEXTRACT:"out-extract"},Subscene:{GROUP:"subscene"},OPNODE:"op",METANODE:"meta",SERIESNODE:"series",BRIDGENODE:"bridge",ELLIPSISNODE:"ellipsis"},J4={Edge:{LABEL:3.5},Annotation:{LABEL:5},Node:{EXPANDED_LABEL:9,SERIES_LABEL:8,OP_LABEL:6,HEALTH_PILL_STAT_LABEL:4}},ju="http://www.w3.org/2000/svg";function g0(e,t,r){let n=e.node().childNodes;for(let i=0;i<n.length;i++){let o=n[i];if(o.tagName===t){if(r instanceof Array){let a=!0;for(let s=0;s<r.length;s++)a=a&&o.classList.contains(r[s]);if(a)return Ht(o)}else if(!r||o.classList.contains(r))return Ht(o)}}return Ht(null)}function An(e,t,r,n){let i=g0(e,t,r);if(!i.empty())return i;let o=document.createElementNS("http://www.w3.org/2000/svg",t);if(r instanceof Array)for(let a=0;a<r.length;a++)o.classList.add(r[a]);else o.classList.add(r);return n?e.node().insertBefore(o,n):e.node().appendChild(o),Ht(o).datum(e.datum())}var KS=class{constructor(t){this.totalBytes=0,this.outputSize=t}addExecutionTime(t,r){this.startTime!=null?this.startTime=Math.min(this.startTime,t):this.startTime=t,this.endTime!=null?this.endTime=Math.max(this.endTime,r):this.endTime=r}addBytesAllocation(t){this.totalBytes!=null?this.totalBytes=Math.max(this.totalBytes,t):this.totalBytes=t}combine(t){t.totalBytes!=null&&(this.totalBytes+=t.totalBytes),t.getTotalMicros()!=null&&this.addExecutionTime(t.startTime,t.endTime)}getTotalMicros(){return this.startTime==null||this.endTime==null?null:this.endTime-this.startTime}},Q4=.75,tP=12,tcr=.3,ecr=[1,5e6],Xse=Z_().exponent(tcr).domain(ecr).range([Q4,tP]).clamp(!0);var ZS=Ee(Oe(),1);var Kse=20;function rcr(e){return e.hasOwnProperty("timingId")}function Po(e){rcr(e)?(ZKt,e.timingId,e.eventValue,void 0):(KKt,e.actionId,e.eventLabel,void 0)}function Nd(e,t,r){let n=Date.now(),i=t(),o=Date.now()-n;return console.log(e,":",o,"ms"),r&&Po({timingId:r,eventValue:o}),i}function nP(e){return{setMessage:function(t){e.set("progress",{value:e.progress.value,msg:t})},updateProgress:function(t){e.set("progress",{value:e.progress.value+t,msg:e.progress.msg})},reportError:function(t,r){console.error(r.stack),e.set("progress",{value:e.progress.value,msg:t,error:!0})}}}function JS(e,t,r){return{setMessage:function(n){e.setMessage(r+": "+n)},updateProgress:function(n){e.updateProgress(n*t/100)},reportError:function(n,i){e.reportError(r+": "+n,i)}}}function Zse(e,t,r,n,i){n.setMessage(e);try{let o=Nd(e,r,i);return n.updateProgress(t),o}catch(o){return n.reportError("Failed "+e,o),null}}function r1(e,t,r,n,i){return new Promise((o,a)=>{n.setMessage(e),setTimeout(function(){try{let s=Nd(e,r,i);n.updateProgress(t),o(s)}catch(s){n.reportError("Failed "+e,s)}},Kse)})}function mH(e,t,r,n,i){return new Promise((o,a)=>{let s=function(l){n.reportError("Failed "+e,l),a(l)};n.setMessage(e),setTimeout(function(){try{let l=Date.now();r().then(function(c){let u=Date.now()-l;console.log(e,":",u,"ms"),n.updateProgress(t),Po({timingId:i,eventValue:u}),o(c)}).catch(s)}catch(l){s(l)}},Kse)})}function Jse(e){return e.replace(/([:.\[\],/\\\(\)])/g,"\\$1")}var iP=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",numUnits:1024},{symbol:"PB",numUnits:1024}],oP=[{symbol:"\xB5s"},{symbol:"ms",numUnits:1e3},{symbol:"s",numUnits:1e3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];function Dd(e,t,r=0){return r+1<t.length&&e>=t[r+1].numUnits?Dd(e/t[r+1].numUnits,t,r+1):Number(e.toPrecision(3))+" "+t[r].symbol}function gH(e){return!!(e&&(e.totalBytes>0||e.getTotalMicros()>0||e.outputSize))}function zlt(e){if(e.length<2)return e;let t=0,r=0,n=ZS.min(ZS.map(e,i=>i.length));for(;;){t++;let i=ZS.map(e,a=>a.substring(0,t));if(i.every((a,s)=>s===0?!0:a===i[s-1])){if(t>=n)return e;r=t}else break}return ZS.map(e,i=>i.substring(r))}function Qse(e){var t=+new Date-+new Date(e/1e3);return t<3e4?"just now":t<6e4?Math.floor(t/1e3)+" seconds ago":t<12e4?"a minute ago":t<36e5?Math.floor(t/6e4)+" minutes ago":Math.floor(t/36e5)==1?"an hour ago":t<864e5?Math.floor(t/36e5)+" hours ago":t<1728e5?"yesterday":Math.floor(t/864e5)+" days ago"}var ncr=document.createElement("canvas"),rP=ncr.getContext("2d");function $se(e,t){return rP&&(rP.font=`${t}px Roboto, sans-serif`),rP==null?void 0:rP.measureText(e).width}function tle(e,t,r){if(!e)return"";if($se(e,t)<=r)return e;let n=0,i=e.length;for(;n<i;){let o=n+Math.round((i-n)/2),a=e.slice(0,o)+"\u2026";$se(a,t)<=r?n=o:i=o-1}return n===0?e[0]:e.slice(0,n)+"\u2026"}var dH=class{constructor(){this.eventTypeToListeners=new Map}getListeners(t){return this.eventTypeToListeners.has(t)||this.eventTypeToListeners.set(t,[]),this.eventTypeToListeners.get(t)}addListener(t,r){var n;(n=this.getListeners(t))==null||n.push(r)}removeListener(t,r){var i;let n=(i=this.getListeners(t))==null?void 0:i.filter(o=>o!==r);this.eventTypeToListeners.set(t,n)}dispatchEvent(t,r){for(let n of this.getListeners(t))n(r)}};var Pl="/",qc="__root__",Ma="__function_library__",ile="_too_large_attrs";var ole="--",_0;(function(e){e[e.FULL=0]="FULL",e[e.EMBEDDED=1]="EMBEDDED",e[e.META=2]="META",e[e.SERIES=3]="SERIES",e[e.CORE=4]="CORE",e[e.SHADOW=5]="SHADOW",e[e.BRIDGE=6]="BRIDGE",e[e.EDGE=7]="EDGE"})(_0||(_0={}));var jt;(function(e){e[e.META=0]="META",e[e.OP=1]="OP",e[e.SERIES=2]="SERIES",e[e.BRIDGE=3]="BRIDGE",e[e.ELLIPSIS=4]="ELLIPSIS"})(jt||(jt={}));var ur;(function(e){e[e.INCLUDE=0]="INCLUDE",e[e.EXCLUDE=1]="EXCLUDE",e[e.UNSPECIFIED=2]="UNSPECIFIED"})(ur||(ur={}));var os;(function(e){e[e.GROUP=0]="GROUP",e[e.UNGROUP=1]="UNGROUP"})(os||(os={}));var icr="_output_shapes",ocr="_XlaCluster",Xu=class{constructor(){this.nodes={},this.edges=[]}},_H=class{constructor(t){this.type=jt.ELLIPSIS,this.isGroupNode=!1,this.cardinality=1,this.parentNode=null,this.stats=null,this.setNumMoreNodes(t),this.include=ur.UNSPECIFIED}setNumMoreNodes(t){this.numMoreNodes=t,this.name="... "+t+" more"}},y0=class{constructor(t){this.op=t.op,this.name=t.name,this.device=t.device,this.attr=t.attr,this.inputs=ccr(t.input),this.outputShapes=acr(t.attr),this.xlaCluster=scr(t.attr),this.compatible=!1,this.type=jt.OP,this.isGroupNode=!1,this.cardinality=1,this.inEmbeddings=[],this.outEmbeddings=[],this.parentNode=null,this.include=ur.UNSPECIFIED,this.owningSeries=null}};function lP(e,t={}){return new aP(e,t)}function ale(e,t,r){pn.each(e.nodes,n=>{n.stats=null}),pn.each(t.dev_stats,n=>{r&&!r[n.device]||pn.each(n.node_stats,i=>{let o=i.node_name in e.nodes?i.node_name:sP(i.node_name);if(!(o in e.nodes))return;let a=0;i.memory&&pn.each(i.memory,l=>{l.total_bytes&&(l.total_bytes>0?a+=Number(l.total_bytes):console.log("ignoring negative memory allocation for "+o))});let s=null;i.output&&(s=pn.map(i.output,l=>pn.map(l.tensor_description.shape.dim,c=>Number(c.size)))),e.nodes[o].device=n.device,e.nodes[o].stats==null&&(e.nodes[o].stats=new KS(s)),e.nodes[o].stats.addBytesAllocation(a),i.all_end_rel_micros&&(i.all_end_rel_micros>0?e.nodes[o].stats.addExecutionTime(i.all_start_micros,i.all_start_micros+i.all_end_rel_micros):console.log("ignoring negative runtime for "+o))})})}var aP=class{constructor(t,r={}){this.name=t,this.type=jt.META,this.depth=1,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(t,_0.META,r),this.bridgegraph=null,this.opHistogram={},this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.templateId=null,this.parentNode=null,this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED,this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let t=this.name.split("/"),r=this.name+"/("+t[t.length-1]+")";return this.metagraph.node(r)}leaves(){let t=[],r=[this],n;for(;r.length;){let i=r.shift();i!=null&&i.isGroupNode?(n=i.metagraph,pn.each(n.nodes(),o=>r.push(n.node(o)))):t.push(i==null?void 0:i.name)}return t}};function Hlt(e,t){return new Gf(e,t)}var Gf=class{constructor(t,r){this.v=t,this.w=r,this.baseEdgeList=[],this.inbound=null,this.numRegularEdges=0,this.numControlEdges=0,this.numRefEdges=0,this.totalSize=0}addBaseEdge(t,r){this.baseEdgeList.push(t),t.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1,t.isReferenceEdge&&(this.numRefEdges+=1),this.totalSize+=Gf.computeSizeOfEdge(t,r),r.maxMetaEdgeSize=Math.max(r.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(t,r){let n=r.node(t.v);if(!n.outputShapes)return 1;r.hasShapeInfo=!0;let i=Object.keys(n.outputShapes).map(o=>n.outputShapes[o]).map(o=>o==null?1:o.reduce((a,s)=>(s===-1&&(s=1),a*s),1));return pn.sum(i)}};function QS(e,t,r,n,i,o){return new Blt(e,t,r,n,i,o)}function t3(e,t,r,n,i){let o=typeof n!="undefined"&&typeof i!="undefined"?"["+n+"-"+i+"]":"#",a=e+o+t;return(r?r+"/":"")+a}var Blt=class{constructor(t,r,n,i,o,a){this.name=o||t3(t,r,n),this.type=jt.SERIES,this.hasLoop=!1,this.prefix=t,this.suffix=r,this.clusterId=i,this.ids=[],this.parent=n,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(o,_0.SERIES,a),this.bridgegraph=null,this.parentNode=null,this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED}};function acr(e){let t=null;if(!e)return null;for(let r=0;r<e.length;r++){let{key:n,value:i}=e[r];if(n===icr){if(!i.list||!i.list.shape)return null;let o=i.list.shape.map(a=>a.unknown_rank?null:a.dim==null||a.dim.length===1&&a.dim[0].size==null?[]:a.dim.map(s=>s.size||0));return e.splice(r,1),o}}return null}function scr(e){if(!e)return null;for(let t=0;t<e.length;t++)if(e[t].key===ocr)return e[t].value.s||null;return null}var lcr=/^([^:]+):((\w+:|)\d+)$/;function ccr(e){let t=[],r=null;for(let n of e||[]){let i=n.startsWith("^");i&&(n=n.substring(1));let o=n,a="0",s=n.includes(":")&&n.match(lcr);s&&(o=s[1],a=s[2]),r!==o&&(r=o,t.push({name:o,outputTensorKey:a,isControlDependency:i}))}return t}function Flt(e,t,r,n,i,o){if(t===r.name)return;let a=i.refEdges[r.op+" "+o]===!0;e.edges.push({v:t,w:r.name,outputTensorKey:n.outputTensorKey,isControlDependency:n.isControlDependency,isReferenceEdge:a})}var sle={enableEmbedding:!0,inEmbeddingTypes:["Const"],outEmbeddingTypes:["^[a-zA-Z]+Summary$"],refEdges:{"Assign 0":!0,"AssignAdd 0":!0,"AssignSub 0":!0,"assign 0":!0,"assign_add 0":!0,"assign_sub 0":!0,"count_up_to 0":!0,"ScatterAdd 0":!0,"ScatterSub 0":!0,"ScatterUpdate 0":!0,"scatter_add 0":!0,"scatter_sub 0":!0,"scatter_update 0":!0}};function lle(e,t,r){let n={},i={},o={},a=ele(t.inEmbeddingTypes),s=ele(t.outEmbeddingTypes),l=[],c=e.node,u=new Array(c.length);return r1("Normalizing names",30,()=>{let h=new Array(c.length),f=0,p=g=>{let _=new y0(g);return a(_)?(l.push(_.name),n[_.name]=_,_):s(_)?(l.push(_.name),i[_.name]=_,pn.each(_.inputs,y=>{let x=y.name;o[x]=o[x]||[],o[x].push(_)}),_):(h[f]=_,u[f]=_.name,f++,_)};pn.each(c,p);let d=g=>{let _=Ma+g.signature.name;if(p({name:_,input:[],device:"",op:"",attr:[]}),g.signature.input_arg){let b=0,S=C=>{let P=p({name:_+Pl+C.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:C.type}}]});P.functionInputIndex=b,b++};g.signature.input_arg.name?S(g.signature.input_arg):pn.each(g.signature.input_arg,S)}let y=0,x={};if(g.signature.output_arg){let b=S=>{x[_+Pl+S.name]=y,y++};g.signature.output_arg.name?b(g.signature.output_arg):pn.each(g.signature.output_arg,b)}pn.each(g.node_def,b=>{b.name=_+"/"+b.name,typeof b.input=="string"&&(b.input=[b.input]);let S=p(b);pn.isNumber(x[b.name])&&(S.functionOutputIndex=x[b.name]),pn.each(S.inputs,C=>{C.name=_+Pl+C.name})})};return e.library&&e.library.function&&pn.each(e.library.function,d),h.splice(f),u.splice(f),h},r,jr.NORMALIZING_NAMES).then(h=>r1("Building the data structure",70,()=>{let f=ucr(u,l),p=new Xu;return pn.each(h,d=>{let g=f[d.name]||d.name;p.nodes[g]=d,d.name in o&&(d.outEmbeddings=o[d.name],pn.each(d.outEmbeddings,_=>{_.name=f[_.name]||_.name})),d.name=g}),pn.each(h,d=>{pn.each(d.inputs,(g,_)=>{let y=g.name;if(y in n){let x=n[y];d.inEmbeddings.push(x);for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,b,t,_)}else if(y in i){let x=i[y];for(let b of x.inputs)Flt(p,f[b.name]||b.name,d,g,t,_)}else Flt(p,f[y]||y,d,g,t,_)})}),pn.each(n,(d,g)=>{d.name=f[d.name]||d.name}),p},r,jr.BUILD_SLIM_GRAPH))}function e3(e,t,r={}){let n=new nle.graphlib.Graph(r);return n.setGraph({name:e,rankdir:r.rankdir||"BT",type:t}),n}function ele(e){return function(t){for(let r=0;r<e.length;r++){let n=new RegExp(e[r]);if(typeof t.op=="string"&&t.op.match(n))return!0}return!1}}function sP(e){let t=e.split(Pl);return e+Pl+"("+t[t.length-1]+")"}function ucr(e,t){let r={},n={};e.sort();for(let i=0;i<e.length-1;++i){let o=e[i];pn.each(cP(o).slice(0,-1),a=>{n[a]=!0});for(let a=i+1;a<e.length;++a){let s=e[a];if(pn.startsWith(s,o)){if(s.length>o.length&&s.charAt(o.length)===Pl){r[o]=sP(o);break}}else break}}return pn.each(t,i=>{i in n&&(r[i]=sP(i))}),r}function rle(e){let t=e.nodes().map(function(r){var n;return(n=e.neighbors(r))==null?void 0:n.length});return t.sort(),t}function cle(e,t){let r=rle(e),n=rle(t);for(let i=0;i<r.length;i++)if(r[i]!==n[i])return!1;return!0}function cP(e,t){let r=[],n=e.indexOf(Pl);for(;n>=0;)r.push(e.substring(0,n)),n=e.indexOf(Pl,n+1);if(t){let i=t[e];i&&r.push(i)}return r.push(e),r}function yH(e){return e===ur.EXCLUDE?"Add to main graph":"Remove from main graph"}function ule(e){return e===os.GROUP?"Ungroup this series of nodes":"Group this series of nodes"}var He=Ee(Oe(),1);var n1=Ee(Oe(),1);function hle(e,t){let r=fcr(e),n=pcr(r,t);return Object.keys(n).sort(i=>n[i].level).reduce((i,o)=>(i[o]=n[o],i),{})}function hcr(e){let t=n1.map({depth:e.depth,"|V|":e.metagraph.nodes().length,"|E|":e.metagraph.edges().length},function(n,i){return i+"="+n}).join(" "),r=n1.map(e.opHistogram,function(n,i){return i+"="+n}).join(",");return t+" [ops] "+r}function fcr(e){let t=e.getNodeMap(),r=Object.keys(t).reduce((n,i)=>{let o=t[i];if(o.type!==jt.META)return n;let a=i.split("/").length-1,s=hcr(o),l=n[s]||{nodes:[],level:a};return n[s]=l,l.nodes.push(o),l.level>a&&(l.level=a),n},{});return Object.keys(r).map(n=>[n,r[n]]).filter(([n,i])=>{let{nodes:o}=i;if(o.length>1)return!0;let a=o[0];return a.type===jt.META&&a.associatedFunction}).sort(([n,i])=>i.nodes[0].depth)}function pcr(e,t){return n1.reduce(e,function(n,i){let o=i[0],a=i[1].nodes,s=[];return a.forEach(function(l){for(let c=0;c<s.length;c++)if(!t||dcr(s[c].metanode.metagraph,l.metagraph)){l.templateId=s[c].metanode.templateId,s[c].members.push(l.name);return}l.templateId=o+"["+s.length+"]",s.push({metanode:l,members:[l.name]})}),s.forEach(function(l){n[l.metanode.templateId]={level:i[1].level,nodes:l.members}}),n},{})}function vH(e,t,r){return n1.sortBy(e,[n=>t.node(n).op,n=>t.node(n).templateId,n=>{var i;return(i=t.neighbors(n))==null?void 0:i.length},n=>{var i;return(i=t.predecessors(n))==null?void 0:i.length},n=>{var i;return(i=t.successors(n))==null?void 0:i.length},n=>n.substr(r.length)])}function dcr(e,t){if(!cle(e,t))return!1;let r=e.graph().name,n=t.graph().name,i={},o={},a=[];function s(u,h){let f=u.substr(r.length),p=h.substr(n.length);return i[f]^o[p]?(console.warn("different visit pattern","["+r+"]",f,"["+n+"]",p),!0):(i[f]||(i[f]=o[p]=!0,a.push({n1:u,n2:h})),!1)}let l=e.sources(),c=t.sources();if(l.length!==c.length)return console.log("different source length"),!1;l=vH(l,e,r),c=vH(c,t,n);for(let u=0;u<l.length;u++)if(s(l[u],c[u]))return!1;for(;a.length>0;){let u=a.pop();if(!mcr(e.node(u==null?void 0:u.n1),t.node(u==null?void 0:u.n2)))return!1;let f=e.successors(u==null?void 0:u.n1),p=t.successors(u==null?void 0:u.n2);if((f==null?void 0:f.length)!==(p==null?void 0:p.length))return console.log("# of successors mismatch",f,p),!1;f=vH(f,e,r),p=vH(p,t,n);for(let d=0;d<(f==null?void 0:f.length);d++)if(s(f==null?void 0:f[d],p==null?void 0:p[d]))return!1}return!0}function mcr(e,t){if(e.type===jt.META){let r=e,n=t;return!!r.templateId&&!!n.templateId&&r.templateId===n.templateId}else{if(e.type===jt.OP&&t.type===jt.OP)return e.op===t.op;if(e.type===jt.SERIES&&t.type===jt.SERIES){let r=e,n=t,i=r.metagraph.nodeCount();return i===n.metagraph.nodeCount()&&(i===0||r.metagraph.node(r.metagraph.nodes()[0]).op===n.metagraph.node(n.metagraph.nodes()[0]).op)}}return!1}var Od;(function(e){e[e.TEMPLATES_UPDATED=0]="TEMPLATES_UPDATED"})(Od||(Od={}));var as=class extends dH{constructor(t){super(),this.hasShapeInfo=!1,this.maxMetaEdgeSize=1,this.graphOptions={},this.templates=null,this.graphOptions.compound=!0,this.graphOptions.rankdir=t.rankDirection,this.root=lP(qc,this.graphOptions),this.libraryFunctions={},this.seriesGroupMap=new Map(t.seriesMap),this.devices=null,this.xlaClusters=null,this.verifyTemplate=t.verifyTemplate,this.index={},this.index[qc]=this.root,this.orderings={}}getSeriesGroupType(t){var r;return(r=this.seriesGroupMap.get(t))!=null?r:os.GROUP}setSeriesGroupType(t,r){return this.seriesGroupMap.set(t,r)}buildSeriesGroupMapToggled(t){let r=this.getSeriesGroupType(t)===os.GROUP?os.UNGROUP:os.GROUP;return new Map([...this.seriesGroupMap,[t,r]])}getNodeMap(){return this.index}node(t){return this.index[t]}setNode(t,r){this.index[t]=r}getBridgegraph(t){let r=this.index[t];if(!r)throw Error("Could not find node in hierarchy: "+t);if(!("metagraph"in r))return null;let n=r;if(n.bridgegraph)return n.bridgegraph;let i=n.bridgegraph=e3("BRIDGEGRAPH",_0.BRIDGE,this.graphOptions);if(!r.parentNode||!("metagraph"in r.parentNode))return i;let o=r.parentNode,a=o.metagraph,s=this.getBridgegraph(o.name);return He.each([a,s],l=>{l.edges().filter(c=>c.v===t||c.w===t).forEach(c=>{let u=c.w===t,h=l.edge(c);He.each(h.baseEdgeList,f=>{let[p,d]=u?[f.w,c.v]:[f.v,c.w],g=this.getChildName(t,p),_={v:u?d:g,w:u?g:d},y=i.edge(_);y||(y=Hlt(_.v,_.w),y.inbound=u,i.setEdge(_.v,_.w,y)),y.addBaseEdge(f,this)})})}),i}getChildName(t,r){let n=this.index[r];for(;n;){if(n.parentNode&&n.parentNode.name===t)return n.name;n=n.parentNode}throw Error("Could not find immediate child for descendant: "+r)}getPredecessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!0);return r.isGroupNode||He.each(r.inEmbeddings,i=>{He.each(r.inputs,o=>{if(o.name===i.name){let a=new Gf(i.name,t);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:i.name,w:t},this),n.regular.push(a)}})}),n}getSuccessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!1);return r.isGroupNode||He.each(r.outEmbeddings,i=>{He.each(i.inputs,o=>{if(o.name===t){let a=new Gf(t,i.name);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:t,w:i.name},this),n.regular.push(a)}})}),n}getOneWayEdges(t,r){let n={control:[],regular:[]};if(!t.parentNode||!t.parentNode.isGroupNode)return n;let i=t.parentNode,o=i.metagraph,a=this.getBridgegraph(i.name);return fle(o,t,r,n),fle(a,t,r,n),n}getTopologicalOrdering(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);if(!r.isGroupNode)return null;if(t in this.orderings)return this.orderings[t];let n={},i={},o=r.metagraph;He.each(o.edges(),c=>{!o.edge(c).numRegularEdges||(c.v in n||(n[c.v]=[]),n[c.v].push(c.w),i[c.w]=!0)});let a=He.difference(He.keys(n),He.keys(i)),s=this.orderings[t]={},l=0;for(;a.length;){let c=a.shift();s[c]=l++,He.each(n[c],u=>a.push(u)),delete n[c]}return s}getTemplateIndex(){if(!this.templates)return null;let t=$L(this.templates);if(!t.length)return null;let r=gu().domain(t).range(Ir(0,t.length));return n=>r(n)}updateTemplates(){Nd("Finding similar subgraphs",()=>{this.templates=hle(this,this.verifyTemplate),this.dispatchEvent(Od.TEMPLATES_UPDATED)},jr.HIERARCHY_FIND_SIMILAR_SUBGRAPHS)}};function fle(e,t,r,n){let i=r?e.inEdges(t.name):e.outEdges(t.name);He.each(i,o=>{let a=e.edge(o);(a.numRegularEdges?n.regular:n.control).push(a)})}var r3={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:new Map,rankDirection:"BT",useGeneralizedSeriesPatterns:!1};function bH(e,t,r){let n=new as(t),i={};return r1("Adding nodes",30,()=>{let o={},a={};He.each(e.nodes,(s,l)=>{s.device&&(o[s.device]=!0),s.xlaCluster&&(a[s.xlaCluster]=!0)}),n.devices=He.keys(o),n.xlaClusters=He.keys(a),_cr(n,e)},r,jr.HIERARCHY_ADD_NODES).then(()=>r1("Detect series",30,()=>{t.seriesNodeMinSize>0&&mle(n.root,n,i,t.seriesNodeMinSize,t.seriesMap,t.useGeneralizedSeriesPatterns)},r,jr.HIERARCHY_DETECT_SERIES)).then(()=>r1("Adding edges",40,()=>{ycr(n,e,i)},r,jr.HIERARCHY_ADD_EDGES)).then(()=>n)}function ple(e,t){let r={},n={};He.each(e.root.leaves(),i=>{let o=e.node(i);o.device!=null&&(r[o.device]=!0),o.xlaCluster!=null&&(n[o.xlaCluster]=!0)}),e.devices=He.keys(r),e.xlaClusters=He.keys(n),He.each(e.getNodeMap(),(i,o)=>{i.isGroupNode&&(i.stats=new KS(null),i.deviceHistogram={})}),He.each(e.root.leaves(),i=>{let o=e.node(i),a=o;for(;a.parentNode!=null;){if(o.device!=null){let s=a.parentNode.deviceHistogram;s[o.device]=(s[o.device]||0)+1}if(o.xlaCluster!=null){let s=a.parentNode.xlaClusterHistogram;s[o.xlaCluster]=(s[o.xlaCluster]||0)+1}o.stats!=null&&a.parentNode.stats.combine(o.stats),a=a.parentNode}})}function dle(e){let t=[],r={};return He.each(e.root.leaves(),n=>{let i=e.node(n);if(i.type==jt.OP){let o=i;if(!o.compatible)if(o.owningSeries){if(e.getSeriesGroupType(o.owningSeries)===os.UNGROUP)t.push(o);else if(!r[o.owningSeries]){let a=e.node(o.owningSeries);a&&(r[o.owningSeries]=a,t.push(a))}}else t.push(o);He.each(o.inEmbeddings,a=>{a.compatible||t.push(a)}),He.each(o.outEmbeddings,a=>{a.compatible||t.push(a)})}}),t}function _cr(e,t){let r={};He.each(t.nodes,(n,i)=>{let o=cP(n.name),a=e.root;a.depth=Math.max(o.length,a.depth),r[n.op]||(r[n.op]=[]),r[n.op].push(n);for(let s=0;s<o.length&&(a.depth=Math.max(a.depth,o.length-s),a.cardinality+=n.cardinality,a.opHistogram[n.op]=(a.opHistogram[n.op]||0)+1,n.device!=null&&(a.deviceHistogram[n.device]=(a.deviceHistogram[n.device]||0)+1),n.xlaCluster!=null&&(a.xlaClusterHistogram[n.xlaCluster]=(a.xlaClusterHistogram[n.xlaCluster]||0)+1),n.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1,He.each(n.inEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),He.each(n.outEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),s!==o.length-1);s++){let l=o[s],c=e.node(l);if(!c&&(c=lP(l,e.graphOptions),c.parentNode=a,e.setNode(l,c),a.metagraph.setNode(l,c),l.indexOf(Ma)===0&&a.name===qc)){let u=l.substring(Ma.length);r[u]||(r[u]=[]),e.libraryFunctions[u]={node:c,usages:r[u]},c.associatedFunction=u}a=c}e.setNode(n.name,n),n.parentNode=a,a.metagraph.setNode(n.name,n),He.each(n.inEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n}),He.each(n.outEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n})})}function ycr(e,t,r){let n=e.getNodeMap(),i=[],o=[],a=(s,l)=>{let c=0;for(;s;)l[c++]=s.name,s=s.parentNode;return c-1};He.each(t.edges,s=>{let l=a(t.nodes[s.v],i),c=a(t.nodes[s.w],o);if(l===-1||c===-1)return;for(;i[l]===o[c];)if(l--,c--,l<0||c<0)throw Error("No difference found between ancestor paths.");let u=n[i[l+1]],h=i[l],f=o[c],p=u.metagraph.edge(h,f);p||(p=Hlt(h,f),u.metagraph.setEdge(h,f,p)),!u.hasNonControlEdges&&!s.isControlDependency&&(u.hasNonControlEdges=!0),p.addBaseEdge(s,e)})}function mle(e,t,r,n,i,o){let a=e.metagraph;He.each(a.nodes(),u=>{let h=a.node(u);h.type===jt.META&&mle(h,t,r,n,i,o)});let s=vcr(a),c=(o?bcr:xcr)(s,a,t.graphOptions);He.each(c,function(u,h){let f=u.metagraph.nodes();He.each(f,p=>{let d=a.node(p);d.owningSeries||(d.owningSeries=h)}),f.length<n&&t.getSeriesGroupType(u.name)===os.GROUP&&t.setSeriesGroupType(u.name,os.UNGROUP),t.getSeriesGroupType(u.name)!==os.UNGROUP&&(t.setNode(h,u),a.setNode(h,u),He.each(f,p=>{let d=a.node(p);u.metagraph.setNode(p,d),u.parentNode=d.parentNode,u.cardinality++,d.device!=null&&(u.deviceHistogram[d.device]=(u.deviceHistogram[d.device]||0)+1),d.xlaCluster!=null&&(u.xlaClusterHistogram[d.xlaCluster]=(u.xlaClusterHistogram[d.xlaCluster]||0)+1),d.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1,He.each(d.inEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),He.each(d.outEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),d.parentNode=u,r[p]=h,a.removeNode(p)}))})}function vcr(e){let t={};return He.reduce(e.nodes(),(r,n)=>{let i=e.node(n);if(i.type===jt.META)return r;let o=i.op;return o&&(r[o]=r[o]||[],r[o].push(i.name)),r},t)}function xcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={};He.each(i,function(s){let l=s.charAt(s.length-1)==="*",c=s.split("/"),u=c[c.length-1],h=c.slice(0,c.length-1).join("/"),f=u.match(/^(\D*)(\d+)$/),p,d,g="";f?(p=f[1],d=f[2]):(p=l?u.substr(0,u.length-1):u,d=0,g=l?"*":"");let _=t3(p,g,h);a[_]=a[_]||[];let y=QS(p,g,h,+d,s,r);a[_].push(y)}),He.each(a,function(s,l){if(s.length<2)return;s.sort(function(u,h){return+u.clusterId-+h.clusterId});let c=[s[0]];for(let u=1;u<s.length;u++){let h=s[u];if(h.clusterId===c[c.length-1].clusterId+1){c.push(h);continue}xH(c,n,+o,t,r),c=[h]}xH(c,n,+o,t,r)})}),n}function bcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={},s={};He.each(i,function(c){let u=c.charAt(c.length-1)==="*",h=c.split("/"),f=h[h.length-1],p=h.slice(0,h.length-1).join("/"),d=/(\d+)/g,g=[],_,y,x,b,S,C=0;for(;_=d.exec(f);)++C,y=f.slice(0,_.index),x=_[0],b=f.slice(_.index+_[0].length),S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]);C<1&&(y=u?f.substr(0,f.length-1):f,x=0,b=u?"*":"",S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]))});var l={};He.each(s,function(c,u){c.sort(function(y,x){return a[x[0]].ids.length-a[y[0]].ids.length});var h=c[0][0],f=c[0][1];l[h]=l[h]||[];let p=u.split("/"),d=p[p.length-1],g=p.slice(0,p.length-1).join("/");var _=QS(a[h].prefix,a[h].suffix,g,+f,u,r);l[h].push(_)}),He.each(l,function(c,u){if(c.length<2)return;c.sort(function(f,p){return+f.clusterId-+p.clusterId});let h=[c[0]];for(let f=1;f<c.length;f++){let p=c[f];if(p.clusterId===h[h.length-1].clusterId+1){h.push(p);continue}xH(h,n,+o,t,r),h=[p]}xH(h,n,+o,t,r)})}),n}function xH(e,t,r,n,i){if(e.length>1){let o=t3(e[0].prefix,e[0].suffix,e[0].parent,e[0].clusterId,e[e.length-1].clusterId),a=QS(e[0].prefix,e[0].suffix,e[0].parent,r,o,i);He.each(e,function(s){a.ids.push(s.clusterId),a.metagraph.setNode(s.name,n.node(s.name))}),t[o]=a}}var me=Ee(Oe(),1);var v0={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"},Ku={DEFAULT_FILL:"#d9d9d9",DEFAULT_STROKE:"#a6a6a6",SATURATION:.6,LIGHTNESS:.85,EXPANDED_COLOR:"#f0f0f0",HUES:[220,100,180,40,20,340,260,300,140,60],STRUCTURE_PALETTE(e,t){let r=Ku.HUES,n=r.length,i=r[e%n],o=Math.sin(i*Math.PI/360),a=t?30:90-60*o,s=t?95:80;return Um(i,.01*a,.01*s).toString()},DEVICE_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},XLA_CLUSTER_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"},Vlt={DEFAULT_FILL:"white",DEFAULT_STROKE:"#b2b2b2"},Xo={minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},wcr=new RegExp("^(?:"+Ma+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$"),lo=class{constructor(t,r,n){this.hierarchy=t,this.displayingStats=r,this.autoExtractNodes=n,this.index={},this.renderedOpNames=[],this.computeScales(),this.hasSubhierarchy={},this.root=new SH(t.root,t.graphOptions),this.index[t.root.name]=this.root,this.renderedOpNames.push(t.root.name),this.buildSubhierarchy(t.root.name),this.root.expanded=!0,this.traceInputs=!1}computeScales(){this.deviceColorMap=gu().domain(this.hierarchy.devices).range(me.map(Ir(this.hierarchy.devices.length),Ku.DEVICE_PALETTE)),this.xlaClusterColorMap=gu().domain(this.hierarchy.xlaClusters).range(me.map(Ir(this.hierarchy.xlaClusters.length),Ku.XLA_CLUSTER_PALETTE));let t=this.hierarchy.root.metagraph,r=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.totalBytes});this.memoryUsageScale=zn().domain([0,r]).range(Xo.minMaxColors);let n=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.getTotalMicros()});this.computeTimeScale=zn().domain([0,n]).range(Xo.minMaxColors),this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?Xse:zn().domain([1,this.hierarchy.maxMetaEdgeSize]).range([Q4,tP])}getRenderNodeByName(t){return this.index[t]}getNodeByName(t){return this.hierarchy.node(t)}colorHistogram(t,r){if(Object.keys(t).length>0){let n=me.sum(Object.keys(t).map(i=>t[i]));return Object.keys(t).map(i=>({color:r(i),proportion:t[i]/n}))}return null}getOrCreateRenderNodeByName(t){if(!t)return null;if(t in this.index)return this.index[t];let r=this.hierarchy.node(t);if(!r)return null;let n=r.isGroupNode?new SH(r,this.hierarchy.graphOptions):new Wf(r);this.index[t]=n,this.renderedOpNames.push(t),r.stats&&(n.memoryColor=this.memoryUsageScale(r.stats.totalBytes),n.computeTimeColor=this.computeTimeScale(r.stats.getTotalMicros())),n.isFadedOut=this.displayingStats&&!gH(r.stats);var i=null,o=null,a=null;if(r.isGroupNode){i=r.deviceHistogram,o=r.xlaClusterHistogram;let s=r.compatibilityHistogram.compatible,l=r.compatibilityHistogram.incompatible;(s!=0||l!=0)&&(a=s/(s+l))}else{let s=n.node.device;s&&(i={[s]:1});let l=n.node.xlaCluster;l&&(o={[l]:1}),n.node.type===jt.OP&&(a=n.node.compatible?1:0)}return i&&(n.deviceColors=this.colorHistogram(i,this.deviceColorMap)),o&&(n.xlaClusterColors=this.colorHistogram(o,this.xlaClusterColorMap)),a!=null&&(n.compatibilityColors=[{color:v0.COMPATIBLE,proportion:a},{color:v0.INCOMPATIBLE,proportion:1-a}]),this.index[t]}getNearestVisibleAncestor(t){let r=cP(t),n=0,i=null,o=t;for(;n<r.length&&(o=r[n],i=this.getRenderNodeByName(o),!!i.expanded);n++);if(n==r.length-2){let a=r[n+1];if(i!=null&&i.inAnnotations.nodeNames[a]||i!=null&&i.outAnnotations.nodeNames[a])return a}return o}setDepth(t){yle(this.root,+t)}isNodeAuxiliary(t){let r=this.getRenderNodeByName(t.node.parentNode.name),n=me.find(r.isolatedInExtract,i=>i.node.name===t.node.name);return n?!0:(n=me.find(r.isolatedOutExtract,i=>i.node.name===t.node.name),!!n)}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(t,r,n,i){let o=n.name.replace(r,i),a=t.metagraph.node(o);if(a)return a;a=new y0({name:o,input:[],device:n.device,op:n.op,attr:me.cloneDeep(n.attr)}),a.cardinality=n.cardinality,a.include=n.include,a.outputShapes=me.cloneDeep(n.outputShapes),a.xlaCluster=n.xlaCluster,a.functionInputIndex=n.functionInputIndex,a.functionOutputIndex=n.functionOutputIndex,a.inputs=n.inputs.map(l=>{let c=me.clone(l);return c.name=l.name.replace(r,i),c}),a.parentNode=t,t.metagraph.setNode(a.name,a),this.hierarchy.setNode(a.name,a);let s=l=>this.cloneAndAddFunctionOpNode(t,r,l,i);return a.inEmbeddings=n.inEmbeddings.map(s),a.outEmbeddings=n.outEmbeddings.map(s),a}cloneFunctionLibraryMetanode(t,r,n,i,o){let a={},s=this.cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a);return me.isEmpty(a)||this.patchEdgesFromFunctionOutputs(r,a),s}cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a){let s=lP(n.name.replace(i,o));return s.depth=n.depth,s.cardinality=n.cardinality,s.templateId=n.templateId,s.opHistogram=me.clone(n.opHistogram),s.deviceHistogram=me.clone(n.deviceHistogram),s.xlaClusterHistogram=me.clone(n.xlaClusterHistogram),s.hasNonControlEdges=n.hasNonControlEdges,s.include=n.include,s.nodeAttributes=me.clone(n.nodeAttributes),s.associatedFunction=n.associatedFunction,me.each(n.metagraph.nodes(),l=>{let c=n.metagraph.node(l);switch(c.type){case jt.META:let u=this.cloneFunctionLibraryMetanodeHelper(t,r,c,i,o,a);u.parentNode=s,s.metagraph.setNode(u.name,u),this.hierarchy.setNode(u.name,u);break;case jt.OP:let h=this.cloneAndAddFunctionOpNode(s,i,c,o);me.isNumber(h.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(r,h),me.isNumber(h.functionOutputIndex)&&(a[h.functionOutputIndex]=h);break;default:console.warn(c.name+" is oddly neither a metanode nor an opnode.")}}),this.cloneLibraryMetanodeEdges(n,s,i,o),s}cloneLibraryMetanodeEdges(t,r,n,i){me.each(t.metagraph.edges(),o=>{let a=t.metagraph.edge(o),s=a.v.replace(n,i),l=a.w.replace(n,i),c=new Gf(s,l);c.inbound=a.inbound,c.numRegularEdges=a.numRegularEdges,c.numControlEdges=a.numControlEdges,c.numRefEdges=a.numRefEdges,c.totalSize=a.totalSize,a.baseEdgeList&&(c.baseEdgeList=a.baseEdgeList.map(u=>{let h=me.clone(u);return h.v=u.v.replace(n,i),h.w=u.w.replace(n,i),h})),r.metagraph.node(l)?r.metagraph.setEdge(s,l,c):r.metagraph.setEdge(l,s,c)})}patchEdgesIntoFunctionInputs(t,r){let n=Math.min(r.functionInputIndex,t.inputs.length-1),i=me.clone(t.inputs[n]);for(;i.isControlDependency;)n++,i=t.inputs[n];r.inputs.push(i);let o=this.hierarchy.getPredecessors(t.name),a,s=0;me.each(o.regular,l=>{if(s+=l.numRegularEdges,s>n)return a=l,!1}),me.each(a.baseEdgeList,l=>{l.w===t.name&&(l.w=r.name),l.v===t.name&&(l.v=r.name)})}patchEdgesFromFunctionOutputs(t,r){let n=this.hierarchy.getSuccessors(t.name);me.each(n.regular,i=>{me.each(i.baseEdgeList,o=>{let a=this.hierarchy.node(o.w);me.each(a.inputs,s=>{if(s.name===t.name){let l=r[s.outputTensorKey];s.name=l.name,s.outputTensorKey=o.outputTensorKey}})}),me.each(i.baseEdgeList,o=>{o.v=r[o.outputTensorKey].name,o.outputTensorKey="0"})})}buildSubhierarchy(t){if(t in this.hasSubhierarchy)return;this.hasSubhierarchy[t]=!0;let r=this.index[t];if(r.node.type!==jt.META&&r.node.type!==jt.SERIES)return;let n=r,i=n.node.metagraph,o=n.coreGraph,a=[],s=[];me.isEmpty(this.hierarchy.libraryFunctions)||(me.each(i.nodes(),d=>{let g=i.node(d),_=this.hierarchy.libraryFunctions[g.op];if(!_||d.indexOf(Ma)===0)return;let y=this.cloneFunctionLibraryMetanode(i,g,_.node,_.node.name,g.name);a.push(g),s.push(y)}),me.each(s,(d,g)=>{let _=a[g];d.parentNode=_.parentNode,i.setNode(_.name,d),this.hierarchy.setNode(_.name,d)})),me.each(i.nodes(),d=>{let g=this.getOrCreateRenderNodeByName(d),_=g.node;o.setNode(d,g),_.isGroupNode||(me.each(_.inEmbeddings,y=>{let x=new zd(null),b=new Wf(y);gle(g,y,b,x,gi.CONSTANT),this.index[y.name]=b}),me.each(_.outEmbeddings,y=>{let x=new zd(null),b=new Wf(y);_le(g,y,b,x,gi.SUMMARY),this.index[y.name]=b}))}),me.each(i.edges(),d=>{let g=i.edge(d),_=new zd(g);_.isFadedOut=this.index[d.v].isFadedOut||this.index[d.w].isFadedOut,o.setEdge(d.v,d.w,_)}),n.node.type===jt.META&&Pcr(n,this.autoExtractNodes),me.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(i),t===qc&&me.forOwn(this.hierarchy.libraryFunctions,(d,g)=>{let _=d.node,y=this.getOrCreateRenderNodeByName(_.name);n.libraryFunctionsExtract.push(y),y.node.include=ur.EXCLUDE,o.removeNode(_.name)});let l=n.node.parentNode;if(!l)return;let c=this.index[l.name],u=(d,...g)=>g.concat([d?"IN":"OUT"]).join("~~"),h=this.hierarchy.getBridgegraph(t),f={in:{},out:{},control:{}};me.each(h.edges(),d=>{let g=!!i.node(d.w),_=g?d.v:d.w;h.edge(d).numRegularEdges?g?f.out[_]=(f.out[_]||0)+1:f.in[_]=(f.in[_]||0)+1:f.control[_]=(f.control[_]||0)+1});let p=this.hierarchy.getNodeMap();me.each(h.edges(),d=>{let g=h.edge(d),_=!!i.node(d.w),[y,x]=_?[d.w,d.v]:[d.v,d.w],b=this.index[y],S=this.index[x],C=S?S.node:p[x],P=!g.numRegularEdges&&f.control[x]>Xo.maxControlDegree,[,k]=_?[r.inAnnotations,b.inAnnotations]:[r.outAnnotations,b.outAnnotations],D=(_?f.out:f.in)[x]>Xo.maxBridgePathDegree,B=null,I=!1;if(Xo.enableBridgegraph&&!D&&!P&&b.isInCore()){let W=Z=>{let rt=_?{v:Z,w:t}:{v:t,w:Z};return c.coreGraph.edge(rt)};B=W(x),B||(B=W(u(_,x,l.name))),I=!!B}let L=!1;if(B&&!g.numRegularEdges){let W=B,Z=c.node;for(;W.adjoiningMetaedge;)W=W.adjoiningMetaedge,Z=Z.parentNode;let rt=this.hierarchy.getTopologicalOrdering(Z.name),ot=W.metaedge;L=rt[ot.v]>rt[ot.w]}if(I=I&&!L,!I){k.push(new i3(C,S,new zd(g),gi.SHORTCUT,_));return}let R=u(_,t),F=u(_,x,t),z=o.node(F);if(!z){let W=o.node(R);if(!W){let rt={name:R,type:jt.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};W=new Wf(rt),this.index[R]=W,o.setNode(R,W)}let Z={name:F,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};z=new Wf(Z),this.index[F]=z,o.setNode(F,z),o.setParent(F,R),W.node.cardinality++}let U=new zd(g);U.adjoiningMetaedge=B,_?o.setEdge(F,y,U):o.setEdge(y,F,U)}),me.each([!0,!1],d=>{let g=u(d,t),_=o.node(g);!_||me.each(o.nodes(),y=>{var k,O;if(o.node(y).node.type===jt.BRIDGE||!(d?!((k=o.predecessors(y))!=null&&k.length):!((O=o.successors(y))!=null&&O.length)))return;let S=u(d,t,"STRUCTURAL_TARGET"),C=o.node(S);if(!C){let D={name:S,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:d,nodeAttributes:{}};C=new Wf(D),C.structural=!0,this.index[S]=C,o.setNode(S,C),_.node.cardinality++,o.setParent(S,g)}let P=new zd(null);P.structural=!0,P.weight--,d?o.setEdge(S,y,P):o.setEdge(y,S,P)})})}buildSubhierarchiesForNeededFunctions(t){me.each(t.edges(),r=>{let n=t.edge(r),i=new zd(n);me.forEach(i.metaedge.baseEdgeList,o=>{let a=o.v.split(Pl);for(let s=a.length;s>=0;s--){let l=a.slice(0,s),c=this.hierarchy.node(l.join(Pl));if(c){if(c.type===jt.OP&&this.hierarchy.libraryFunctions[c.op])for(let u=1;u<l.length;u++){let h=l.slice(0,u).join(Pl);!h||this.buildSubhierarchy(h)}break}}})})}},i3=class{constructor(t,r,n,i,o){this.node=t,this.renderNodeInfo=r,this.renderMetaedgeInfo=n,this.annotationType=i,this.dx=0,this.dy=0,this.width=0,this.height=0,n&&n.metaedge&&(this.v=n.metaedge.v,this.w=n.metaedge.w),this.isIn=o,this.points=[]}},gi;(function(e){e[e.SHORTCUT=0]="SHORTCUT",e[e.CONSTANT=1]="CONSTANT",e[e.SUMMARY=2]="SUMMARY",e[e.ELLIPSIS=3]="ELLIPSIS"})(gi||(gi={}));var wH=class{constructor(){this.list=[],this.nodeNames={}}push(t){if(t.node.name in this.nodeNames)return;if(this.nodeNames[t.node.name]=!0,this.list.length<Xo.maxAnnotations){this.list.push(t);return}let r=this.list[this.list.length-1];if(r.annotationType===gi.ELLIPSIS){let i=r.node;i.setNumMoreNodes(++i.numMoreNodes);return}let n=new _H(1);this.list.push(new i3(n,new Wf(n),null,gi.ELLIPSIS,t.isIn))}},Wf=class{constructor(t){if(this.node=t,this.expanded=!1,this.inAnnotations=new wH,this.outAnnotations=new wH,this.x=0,this.y=0,this.width=0,this.height=0,this.inboxWidth=0,this.outboxWidth=0,this.excluded=!1,this.structural=!1,this.labelOffset=0,this.radius=0,this.labelHeight=0,this.paddingTop=0,this.paddingLeft=0,this.paddingRight=0,this.paddingBottom=0,this.isInExtract=!1,this.isOutExtract=!1,this.coreBox={width:0,height:0},this.isFadedOut=!1,this.displayName=t.name.substring(t.name.lastIndexOf(Pl)+1),t.type===jt.META&&t.associatedFunction){let r=this.displayName.match(wcr);r?this.displayName=r[1]:me.startsWith(this.displayName,Ma)&&(this.displayName=this.displayName.substring(Ma.length))}}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}},zd=class{constructor(t){this.metaedge=t,this.adjoiningMetaedge=null,this.structural=!1,this.weight=1,this.isFadedOut=!1}};function gle(e,t,r,n,i){let o=new i3(t,r,n,i,!0);e.inAnnotations.push(o)}function _le(e,t,r,n,i){let o=new i3(t,r,n,i,!1);e.outAnnotations.push(o)}function Scr(e,t){me.each(e.nodes(),r=>{let n=e.node(r);if(n.expanded=t>1,t>0)switch(n.node.type){case jt.META:case jt.SERIES:yle(n,t-1);break}})}var SH=class extends Wf{constructor(t,r){super(t);let i=t.metagraph.graph();this.coreGraph=e3(i.name,_0.CORE,r),this.inExtractBox={width:0,height:0},this.outExtractBox={width:0,height:0},this.libraryFunctionsBox={width:0,height:0},this.isolatedInExtract=[],this.isolatedOutExtract=[],this.libraryFunctionsExtract=[]}};function yle(e,t){e.coreGraph&&Scr(e.coreGraph,t)}function uP(e,t,r){let n=e.node(t),i=e.node(r),o=e.edge(t,r);(n.node.include===ur.INCLUDE||i.node.include===ur.INCLUDE)&&n.node.include!==ur.EXCLUDE&&i.node.include!==ur.EXCLUDE||(_le(n,i.node,i,o,gi.SHORTCUT),gle(i,n.node,n,o,gi.SHORTCUT),e.removeEdge(t,r))}function Ult(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isOutExtract=!0,me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedOutExtract.push(i),n.removeNode(t))}function qlt(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isInExtract=!0,me.each(n.successors(t),(a,s)=>{uP(n,t,a)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.predecessors(t),(a,s)=>{uP(n,a,t)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedInExtract.push(i),n.removeNode(t))}function vle(e,t){if(e.type===jt.OP){for(let r=0;r<t.length;r++)if(e.op===t[r])return!0}else if(e.type===jt.META){let r=e.getRootOp();if(r){for(let n=0;n<t.length;n++)if(r.op===t[n])return!0}}return!1}function Mcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{var i,o;t.node(r).node.include===ur.EXCLUDE&&!r.startsWith(Ma)&&(((i=e.coreGraph.outEdges(r))==null?void 0:i.length)>((o=e.coreGraph.inEdges(r))==null?void 0:o.length)?Ult(e,r,!0):qlt(e,r,!0))})}function Ecr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.outExtractTypes)&&Ult(e,r)})}function Tcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&vle(n.node,Xo.inExtractTypes)&&qlt(e,r)})}function Ccr(e){let t=e.coreGraph,r={},n={},i=0;if(me.each(t.nodes(),_=>{var b,S,C,P;if(t.node(_).node.include!==ur.UNSPECIFIED)return;let y=me.reduce(t.predecessors(_),(k,O)=>{let D=t.edge(O,_).metaedge;return k+(D.numRegularEdges?1:0)},0);y===0&&((b=t.predecessors(_))==null?void 0:b.length)>0&&(y=(S=t.predecessors(_))==null?void 0:S.length);let x=me.reduce(t.successors(_),(k,O)=>{let D=t.edge(_,O).metaedge;return k+(D.numRegularEdges?1:0)},0);x===0&&((C=t.successors(_))==null?void 0:C.length)>0&&(x=(P=t.successors(_))==null?void 0:P.length),r[_]=y,n[_]=x,i++}),i<Xo.minNodeCountForExtraction)return;let o=Xo.minDegreeForExtraction-1,a=Math.round(i*.75),s=Math.round(i*.25),l=Object.keys(r).sort((_,y)=>r[_]-r[y]),c=r[l[a]],u=r[l[s]],h=c+c-u;h=Math.max(h,o);for(let _=i-1;r[l[_]]>h;_--)qlt(e,l[_]);let f=Object.keys(n).sort((_,y)=>n[_]-n[y]),p=n[f[a]],d=n[f[s]],g=p+(p-d)*4;g=Math.max(g,o);for(let _=i-1;n[f[_]]>g;_--){let y=t.node(f[_]);!y||y.isInExtract||Ult(e,f[_])}}function Acr(e){let t=e.coreGraph,r={};me.each(t.edges(),n=>{t.edge(n).metaedge.numRegularEdges||((r[n.v]=r[n.v]||[]).push(n),(r[n.w]=r[n.w]||[]).push(n))}),me.each(r,(n,i)=>{n.length>Xo.maxControlDegree&&me.each(n,o=>uP(t,o.v,o.w))})}function Pcr(e,t){Mcr(e),Xo.outExtractTypes.length&&Ecr(e),Xo.inExtractTypes.length&&Tcr(e),t&&Ccr(e),Xo.maxControlDegree&&Acr(e);let r=e.coreGraph;me.each(r.nodes(),n=>{var a;let i=r.node(n),o=(a=r.neighbors(n))==null?void 0:a.length;if(i.node.include===ur.UNSPECIFIED&&o===0){let s=i.outAnnotations.list.length>0,l=i.inAnnotations.list.length>0;i.isInExtract?(e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):i.isOutExtract?(e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):Xo.extractIsolatedNodesWithAnnotationsOnOneSide&&(s&&!l?(i.isInExtract=!0,e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):l&&!s&&(i.isOutExtract=!0,e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)))}})}function xle(e,t,r){let n=r.split("/"),i=n[n.length-1].match(/(.*):\w+/);(i==null?void 0:i.length)===2&&(n[n.length-1]=i==null?void 0:i[1]);let o=n[0],a=t.getRenderNodeByName(o);for(let s=1;s<n.length&&a.node.type!==jt.OP;s++)t.buildSubhierarchy(o),a.expanded=!0,e.setNodeExpanded(a),o+="/"+n[s],a=t.getRenderNodeByName(o);return a.node.name}var Mle=Ee(Olt(),1),Ze=Ee(Oe(),1);var Tr={animation:{duration:250},graph:{meta:{nodeSep:5,rankSep:25,edgeSep:5},series:{nodeSep:5,rankSep:25,edgeSep:5},padding:{paddingTop:40,paddingLeft:20}},subscene:{meta:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:20,extractXOffset:15,extractYOffset:20},series:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:10}},nodeSize:{meta:{radius:5,width:60,maxLabelWidth:52,height:zn().domain([1,200]).range([15,60]).clamp(!0),expandButtonRadius:3},op:{width:15,height:6,radius:3,labelOffset:-8,maxLabelWidth:30},series:{expanded:{radius:10,labelOffset:0},vertical:{width:16,height:13,labelOffset:-13},horizontal:{width:24,height:8,radius:10,labelOffset:-10}},bridge:{width:20,height:20,radius:2,labelOffset:0}},shortcutSize:{op:{width:10,height:4},meta:{width:12,height:4,radius:1},series:{width:14,height:4}},annotations:{inboxWidth:50,outboxWidth:50,xOffset:10,yOffset:3,labelOffset:2,maxLabelWidth:40},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}},o3=140;function MH(e){e.node.isGroupNode&&Lcr(e),e.node.type===jt.META?kcr(e):e.node.type===jt.SERIES&&Rcr(e)}function Icr(e){e.inboxWidth=e.inAnnotations.list.length>0?Tr.annotations.inboxWidth:0,e.outboxWidth=e.outAnnotations.list.length>0?Tr.annotations.outboxWidth:0,e.coreBox.width=e.width,e.coreBox.height=e.height;let t=e.displayName.length,r=3;e.width=Math.max(e.coreBox.width+e.inboxWidth+e.outboxWidth,t*r)}function Lcr(e){let t=e.coreGraph.nodes().map(r=>e.coreGraph.node(r)).concat(e.isolatedInExtract,e.isolatedOutExtract,e.libraryFunctionsExtract);Ze.each(t,r=>{switch(r.node.type){case jt.OP:Ze.extend(r,Tr.nodeSize.op);break;case jt.BRIDGE:Ze.extend(r,Tr.nodeSize.bridge);break;case jt.META:r.expanded?MH(r):(Ze.extend(r,Tr.nodeSize.meta),r.height=Tr.nodeSize.meta.height(r.node.cardinality));break;case jt.SERIES:if(r.expanded)Ze.extend(r,Tr.nodeSize.series.expanded),MH(r);else{let i=r.node.hasNonControlEdges?Tr.nodeSize.series.vertical:Tr.nodeSize.series.horizontal;Ze.extend(r,i)}break;default:throw Error("Unrecognized node type: "+r.node.type)}r.expanded||Icr(r),Ncr(r)})}function Ele(e,t){Ze.extend(e.graph(),{nodesep:t.nodeSep,ranksep:t.rankSep,edgesep:t.edgeSep});let r=[],n=[];if(Ze.each(e.nodes(),l=>{e.node(l).node.type===jt.BRIDGE?r.push(l):n.push(l)}),!n.length)return{width:0,height:0};Mle.layout(e);let i=1/0,o=1/0,a=-1/0,s=-1/0;return Ze.each(n,l=>{let c=e.node(l),u=.5*c.width,h=c.x-u,f=c.x+u;i=h<i?h:i,a=f>a?f:a;let p=.5*c.height,d=c.y-p,g=c.y+p;o=d<o?d:o,s=g>s?g:s}),Ze.each(e.edges(),l=>{let c=e.edge(l);if(c.structural)return;let u=e.node(c.metaedge.v),h=e.node(c.metaedge.w);if(c.points.length===3&&Dcr(c.points)){if(u!=null){let d=u.expanded?u.x:x0(u);c.points[0].x=d}if(h!=null){let d=h.expanded?h.x:x0(h);c.points[2].x=d}c.points=[c.points[0],c.points[1]]}let f=c.points[c.points.length-2];h!=null&&(c.points[c.points.length-1]=Sle(f,h));let p=c.points[1];u!=null&&(c.points[0]=Sle(p,u)),Ze.each(c.points,d=>{i=d.x<i?d.x:i,a=d.x>a?d.x:a,o=d.y<o?d.y:o,s=d.y>s?d.y:s})}),Ze.each(e.nodes(),l=>{let c=e.node(l);c.x-=i,c.y-=o}),Ze.each(e.edges(),l=>{Ze.each(e.edge(l).points,c=>{c.x-=i,c.y-=o})}),{width:a-i,height:s-o}}function kcr(e){let t=Tr.subscene.meta;Ze.extend(e,t),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.meta));let r=e.isolatedInExtract.length?Ze.maxBy(e.isolatedInExtract,c=>c.width).width:null;e.inExtractBox.width=r!=null?r:0,e.inExtractBox.height=Ze.reduce(e.isolatedInExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let n=e.isolatedOutExtract.length?Ze.maxBy(e.isolatedOutExtract,c=>c.width).width:null;e.outExtractBox.width=n!=null?n:0,e.outExtractBox.height=Ze.reduce(e.isolatedOutExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let i=e.libraryFunctionsExtract.length?Ze.maxBy(e.libraryFunctionsExtract,c=>c.width).width:null;e.libraryFunctionsBox.width=i!=null?i:0,e.libraryFunctionsBox.height=Ze.reduce(e.libraryFunctionsExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let o=0;e.isolatedInExtract.length>0&&o++,e.isolatedOutExtract.length>0&&o++,e.libraryFunctionsExtract.length>0&&o++,e.coreGraph.nodeCount()>0&&o++;let a=Tr.subscene.meta.extractXOffset,s=o<=1?0:o*a,l=Math.max(o3,e.inExtractBox.width+e.outExtractBox.width);e.coreBox.width+=l+s+e.libraryFunctionsBox.width+s,e.coreBox.height=t.labelHeight+Math.max(e.inExtractBox.height,e.coreBox.height,e.libraryFunctionsBox.height,e.outExtractBox.height),e.width=e.coreBox.width+t.paddingLeft+t.paddingRight,e.height=e.paddingTop+e.coreBox.height+e.paddingBottom}function Rcr(e){let t=e.coreGraph,r=Tr.subscene.series;Ze.extend(e,r),Ze.extend(e.coreBox,Ele(e.coreGraph,Tr.graph.series)),Ze.each(t.nodes(),n=>{t.node(n).excluded=!1}),e.width=e.coreBox.width+r.paddingLeft+r.paddingRight,e.height=e.coreBox.height+r.paddingTop+r.paddingBottom}function Ncr(e){if(e.expanded)return;let t=e.inAnnotations.list,r=e.outAnnotations.list;Ze.each(t,u=>ble(u)),Ze.each(r,u=>ble(u));let n=Tr.annotations,i=Ze.reduce(t,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=-(e.coreBox.width+h.width)/2-n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(t,u=>{u.dy-=i/2,u.labelOffset=n.labelOffset});let o=Ze.reduce(r,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=(e.coreBox.width+h.width)/2+n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(r,u=>{u.dy-=o/2,u.labelOffset=n.labelOffset});let a=Math.min(e.height/2-e.radius,i/2);a=a<0?0:a;let s=zn().domain([0,t.length-1]).range([-a,a]);Ze.each(t,(u,h)=>{u.points=[{dx:u.dx+u.width/2,dy:u.dy},{dx:-e.coreBox.width/2,dy:t.length>1?s(h):0}]});let l=Math.min(e.height/2-e.radius,o/2);l=l<0?0:l;let c=zn().domain([0,r.length-1]).range([-l,l]);Ze.each(r,(u,h)=>{u.points=[{dx:e.coreBox.width/2,dy:r.length>1?c(h):0},{dx:u.dx-u.width/2,dy:u.dy}]}),e.height=Math.max(e.height,i,o)}function ble(e){switch(e.annotationType){case gi.CONSTANT:Ze.extend(e,Tr.constant.size);break;case gi.SHORTCUT:if(e.node.type===jt.OP)Ze.extend(e,Tr.shortcutSize.op);else if(e.node.type===jt.META)Ze.extend(e,Tr.shortcutSize.meta);else if(e.node.type===jt.SERIES)Ze.extend(e,Tr.shortcutSize.series);else throw Error("Invalid node type: "+e.node.type);break;case gi.SUMMARY:Ze.extend(e,Tr.constant.size);break}}function x0(e){if(e.expanded)return e.x;let t=e.inAnnotations.list.length?e.inboxWidth:0;return e.x-e.width/2+t+e.coreBox.width/2}function wle(e,t){let r=t.x-e.x,n=t.y-e.y;return 180*Math.atan(n/r)/Math.PI}function Dcr(e){let t=wle(e[0],e[1]);for(let r=1;r<e.length-1;r++){let n=wle(e[r],e[r+1]);if(Math.abs(n-t)>1)return!1;t=n}return!0}function Sle(e,t){let r=t.expanded?t.x:x0(t),n=t.y,i=e.x-r,o=e.y-n,a=t.expanded?t.width:t.coreBox.width,s=t.expanded?t.height:t.coreBox.height,l,c;return Math.abs(o)*a/2>Math.abs(i)*s/2?(o<0&&(s=-s),l=o===0?0:s/2*i/o,c=s/2):(i<0&&(a=-a),l=a/2,c=i===0?0:a/2*o/i),{x:r+l,y:n+c}}var Il=g0,Hi=ve,Ocr=320,zcr=150,fP=[{background_color:"#CC2F2C",label:"NaN"},{background_color:"#FF8D00",label:"-\u221E"},{background_color:"#EAEAEA",label:"-"},{background_color:"#A5A5A5",label:"0"},{background_color:"#262626",label:"+"},{background_color:"#003ED4",label:"+\u221E"}];function Cle(e,t,r,n){let i=e.getBoundingClientRect(),o=null;try{if(o=t.getBBox(),(o==null?void 0:o.width)===0)return}catch(c){return}let a=.9*Math.min(i.width/(o==null?void 0:o.width),i.height/(o==null?void 0:o.height),2),s=Tr.graph,l=$h.scale(a).translate(s.padding.paddingLeft,s.padding.paddingTop);Ht(e).transition().duration(500).call(r.transform,l).on("end.fitted",()=>{r.on("end.fitted",null),n()})}function Ale(e,t,r,n){let i=Ht(t).select(`[data-name="${e}"]`).node();if(!i)return console.warn(`panToNode() failed for node name "${e}"`),!1;let o=i.getBBox(),a=i.getScreenCTM(),s=t.createSVGPoint(),l=t.createSVGPoint();s.x=o.x,s.y=o.y,l.x=o.x+o.width,l.y=o.y+o.height,s=s.matrixTransform(a),l=l.matrixTransform(a);let c=(p,d,g,_)=>!(p>g&&d<_),u=t.getBoundingClientRect(),h=u.left+u.width-Ocr,f=u.top+u.height-zcr;if(c(s.x,l.x,u.left,h)||c(s.y,l.y,u.top,f)){let p=(s.x+l.x)/2,d=(s.y+l.y)/2,g=u.left+u.width/2-p,_=u.top+u.height/2-d,y=i2(t);return Ht(t).transition().duration(500).call(n.translateBy,g/y.k,_/y.k),!0}return!1}function Ple(e,t){let r=t.node.type===jt.SERIES?0:Tr.subscene.meta.labelHeight;a3(Il(e,"g",Hi.Scene.CORE),0,r);let n=t.isolatedInExtract.length>0,i=t.isolatedOutExtract.length>0,o=t.libraryFunctionsExtract.length>0,a=Tr.subscene.meta.extractXOffset,s=0;if(n&&(s+=t.outExtractBox.width),i&&(s+=t.outExtractBox.width),n){let l=t.coreBox.width;s<o3?l=l-o3+t.inExtractBox.width/2:l=l-t.inExtractBox.width/2-t.outExtractBox.width-(i?a:0),l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Il(e,"g",Hi.Scene.INEXTRACT),l,r)}if(i){let l=t.coreBox.width;s<o3?l=l-o3+t.outExtractBox.width/2:l-=t.outExtractBox.width/2,l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Il(e,"g",Hi.Scene.OUTEXTRACT),l,r)}if(o){let l=t.coreBox.width-t.libraryFunctionsBox.width/2;a3(Il(e,"g",Hi.Scene.FUNCTION_LIBRARY),l,r)}}function Ile(e,t){Ht(e).on("click",()=>{t.fire("graph-select")})}function a3(e,t,r){e.attr("transform")!=null&&(e=e.transition("position")),e.attr("transform","translate("+t+","+r+")")}function Fd(e,t,r,n,i){e.transition().attr("x",t-n/2).attr("y",r-i/2).attr("width",n).attr("height",i)}function Lle(e,t,r,n,i){let o=i/2,a=n/2,s=[[t,r-o],[t+a,r+o],[t-a,r+o]];e.transition().attr("points",s.map(l=>l.join(",")).join(" "))}function kle(e,t){let r=x0(t),n=t.expanded?t.width:t.coreBox.width,i=t.expanded?t.height:t.coreBox.height,o=r+n/2-6,a=t.y-i/2+6;t.node.type===jt.SERIES&&!t.expanded&&(o+=10,a-=2);let s="translate("+o+","+a+")";e.selectAll("path").transition().attr("transform",s),e.select("circle").transition().attr({cx:o,cy:a,r:Tr.nodeSize.meta.expandButtonRadius})}function EH(e,t,r,n,i){e.transition().attr("cx",t).attr("cy",r).attr("rx",n/2).attr("ry",i/2)}function Tle(e,t){return t?e.toFixed(0):Math.abs(e)>=1?e.toFixed(1):e.toExponential(1)}function Fcr(e,t,r,n){let i="Device: "+e.device_name+`
`;i+="dtype: "+e.dtype+`
`;let o="(scalar)";e.shape.length>0&&(o="("+e.shape.join(",")+")"),i+=`
shape: `+o+`

`,i+="#(elements): "+t+`
`;let a=[];for(let s=0;s<r.length;s++)r[s]>0&&a.push("#("+fP[s].label+"): "+r[s]);return i+=a.join(", ")+`

`,n.max>=n.min&&(i+="min: "+n.min+", max: "+n.max+`
`,i+="mean: "+n.mean+", stddev: "+n.stddev),i}function Bcr(e,t,r,n,i=60,o=10,a=0,s){if(Ht(e.parentNode).selectAll(".health-pill").remove(),!t)return;let l=t.value,c=l.slice(2,8),u=c[0],h=c[1],f=c[5],p=l[1],d={min:l[8],max:l[9],mean:l[10],stddev:Math.sqrt(l[11])};i==null&&(i=60),o==null&&(o=10),a==null&&(a=0),r!=null&&r.node.type===jt.OP&&(i/=2,o/=2);let g=document.createElementNS(ju,"g");g.classList.add("health-pill");let _=document.createElementNS(ju,"defs");g.appendChild(_);let y=document.createElementNS(ju,"linearGradient"),x="health-pill-gradient-"+n;y.setAttribute("id",x);let b=0,S="0%";for(let D=0;D<c.length;D++){if(!c[D])continue;b+=c[D];let B=document.createElementNS(ju,"stop");B.setAttribute("offset",S),B.setAttribute("stop-color",fP[D].background_color),y.appendChild(B);let I=document.createElementNS(ju,"stop"),L=b*100/p+"%";I.setAttribute("offset",L),I.setAttribute("stop-color",fP[D].background_color),y.appendChild(I),S=L}_.appendChild(y);let C=document.createElementNS(ju,"rect");C.setAttribute("fill","url(#"+x+")"),C.setAttribute("width",String(i)),C.setAttribute("height",String(o)),C.setAttribute("y",String(a)),g.appendChild(C);let P=document.createElementNS(ju,"title");P.textContent=Fcr(t,p,c,d),g.appendChild(P);let k=!1;if(r!=null){let D=r.x-i/2,B=r.y-o-r.height/2-2;if(r.labelOffset<0&&(B+=r.labelOffset),g.setAttribute("transform","translate("+D+", "+B+")"),c[2]||c[3]||c[4]){let L=r.node.attr;if(L&&L.length){for(let R=0;R<L.length;R++)if(L[R].key==="T"){let F=L[R].value.type;k=F&&/^DT_(BOOL|INT|UINT)/.test(F);break}}}}let O=document.createElementNS(ju,"text");if(Number.isFinite(d.min)&&Number.isFinite(d.max)){let D=Tle(d.min,k),B=Tle(d.max,k);if(p>1?O.textContent=D+" ~ "+B:O.textContent=D,u>0||h>0||f>0){O.textContent+=" (";let I=[];u>0&&I.push(`NaN\xD7${u}`),h>0&&I.push(`-\u221E\xD7${h}`),f>0&&I.push(`+\u221E\xD7${f}`),O.textContent+=I.join("; ")+")"}}else O.textContent="(No finite elements)";O.classList.add("health-pill-stats"),s==null&&(s=i/2),O.setAttribute("x",String(s)),O.setAttribute("y",String(a-2)),g.appendChild(O),zt(e.parentNode).appendChild(g)}function Rle(e,t,r){if(!t)return;let n=1;Ht(e).selectAll("g.nodeshape").each(function(o){let a=t[o.node.name],s=a?a[r]:null;Bcr(this,s,o,n++)})}var Gn;(function(e){e.NONE="none",e.COMPUTE_TIME="compute_time",e.DEVICE="device",e.MEMORY="memory",e.OP_COMPATIBILITY="op_compatibility",e.STRUCTURE="structure",e.XLA_CLUSTER="xla_cluster"})(Gn||(Gn={}));var mP=Ee(Oe(),1);var Vi=Ee(Oe(),1);function Hcr(e){let t=0,r=0,n=e;for(;n&&n.offsetLeft>=0&&n.offsetTop>=0;)t+=n.offsetLeft-n.scrollLeft,r+=n.offsetTop-n.scrollTop,n=n.offsetParent;return{left:t,top:r}}function Wlt(e,t){let r=e.getContextMenu(),n=Ht(e.getContextMenu());return function(i,o){let a=qt,s=Hcr(e);n.style("display","block").style("left",a.clientX-s.left+1+"px").style("top",a.clientY-s.top+1+"px"),a.preventDefault(),a.stopPropagation();function l(u){u&&u.composedPath().includes(r)||(n.style("display","none"),document.body.removeEventListener("mousedown",l,{capture:!0}))}document.body.addEventListener("mousedown",l,{capture:!0}),n.text(""),n.append("ul").selectAll("li").data(t).enter().append("li").on("click",(u,h)=>{u.action(this,i,o),l()}).text(function(u){return u.title(i)})}}var AH=Ee(Oe(),1);var Ucr="\xD7",Nle=qb().domain([Q4,tP]).range(["small","medium","large","xlarge"]),qcr=2.5;function pP(e){return e.v+ole+e.w}function zle(e,t,r){let n=r,i=[];i=AH.reduce(t.edges(),(s,l)=>{let c=t.edge(l);return s.push({v:l.v,w:l.w,label:c}),s},i);let a=An(e,"g",ve.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(i,pP);return a.enter().append("g").attr("class",ve.Edge.GROUP).attr("data-edge",pP).each(function(s){let l=Ht(this);s.label.edgeGroup=l,n._edgeGroupIndex[pP(s)]=l,n.handleEdgeSelected&&l.on("click",c=>{qt.stopPropagation(),n.fire("edge-select",{edgeData:c,edgeGroup:l})}),Xlt(l,s,n)}).merge(a).each(function(){Wcr(r,this)}).each(function(s){Ycr(Ht(this),s,n)}),a.exit().each(s=>{delete n._edgeGroupIndex[pP(s)]}).remove(),a}function Ylt(e,t){let r=t.getNodeByName(e.v);if(r.outputShapes==null||AH.isEmpty(r.outputShapes))return null;let n=r.outputShapes[e.outputTensorKey];return n==null?null:n.length===0?"scalar":n.map(i=>i===-1?"?":i).join(Ucr)}function jlt(e,t){return t.edgeLabelFunction?t.edgeLabelFunction(e,t):e.baseEdgeList.length>1?e.baseEdgeList.length+" tensors":Ylt(e.baseEdgeList[0],t)}function Dle(e,t,r){let n=document.createElementNS(ju,"path");for(let i=1;i<e.length;i++)if(n.setAttribute("d",r(e.slice(0,i))),n.getTotalLength()>t)return i-1;return e.length-1}function Ole(e,t,r){let n=vu().x(u=>u.x).y(u=>u.y),i=Ht(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",n(e)),o=+t.attr("markerWidth"),a=t.attr("viewBox").split(" ").map(Number),s=a[2]-a[0],l=+t.attr("refX"),c=i.node();if(r){let u=1-l/s,h=o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p-1]={x:f.x,y:f.y},e.slice(p-1)}else{let u=1-l/s,h=c.getTotalLength()-o*u,f=c.getPointAtLength(h),p=Dle(e,h,n);return e[p]={x:f.x,y:f.y},e.slice(0,p+1)}}function Xlt(e,t,r,n){n=n||ve.Edge.LINE,t.label&&t.label.structural&&(n+=" "+ve.Edge.STRUCTURAL),t.label&&t.label.metaedge&&t.label.metaedge.numRefEdges&&(n+=" "+ve.Edge.REFERENCE_EDGE),r.handleEdgeSelected&&(n+=" "+ve.Edge.SELECTABLE);let i="path_"+pP(t),o;if(r.renderHierarchy.edgeWidthFunction)o=r.renderHierarchy.edgeWidthFunction(t,n);else{let c=1;t.label!=null&&t.label.metaedge!=null&&(c=t.label.metaedge.totalSize),o=r.renderHierarchy.edgeWidthSizedBasedScale(c)}let a=e.append("path").attr("id",i).attr("class",n).style("stroke-width",o+"px");if(t.label&&t.label.metaedge)if(t.label.metaedge.numRefEdges){let c=`reference-arrowhead-${Nle(o)}`;a.style("marker-start",`url(#${c})`),t.label.startMarkerId=c}else{let c=`dataflow-arrowhead-${Nle(o)}`;a.style("marker-end",`url(#${c})`),t.label.endMarkerId=c}if(t.label==null||t.label.metaedge==null)return;let s=jlt(t.label.metaedge,r.renderHierarchy);if(s==null)return;let l=o>qcr?"central":"text-after-edge";e.append("text").append("textPath").attr("xlink:href","#"+i).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(s)}var CH=vu().curve(W8).x(e=>e.x).y(e=>e.y);function Gcr(e,t,r,n,i){let o=r.label,a=o.adjoiningMetaedge,s=o.points,{shadowRoot:l}=e;if(r.label.startMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.startMarkerId)),!0)),r.label.endMarkerId&&(s=Ole(s,Ht(l==null?void 0:l.querySelector("#"+r.label.endMarkerId)),!1)),!a)return nc(i,CH(s));let c=a.edgeGroup.node().firstChild,u=o.metaedge.inbound;return function(h){var g;let f=c.getPointAtLength(u?c.getTotalLength():0).matrixTransform(c.getCTM()).matrixTransform((g=t.getCTM())==null?void 0:g.inverse()),p=u?0:s.length-1;return s[p].x=f.x,s[p].y=f.y,CH(s)}}function Wcr(e,t){Ht(t).select("path."+ve.Edge.LINE).transition().attrTween("d",function(r,n,i){return Gcr(e,this,r,n,i)})}function Ycr(e,t,r){e.classed("faded",t.label.isFadedOut);let n=t.label.metaedge;e.select("path."+ve.Edge.LINE).classed("control-dep",n&&!n.numRegularEdges)}function PH(e,t,r){let i=An(e,"g",ve.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(t,o=>o.node.name+":"+o.node.type);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);r.addNodeGroup(o.node.name,a)}).merge(i).attr("class",o=>ve.Node.GROUP+" "+Wle(o)).each(function(o){let a=Ht(this),s=An(a,"g",ve.Annotation.INBOX);Vle(s,o.inAnnotations,o,r);let l=An(a,"g",ve.Annotation.OUTBOX);Vle(l,o.outAnnotations,o,r);let c=Gle(a,o,ve.Node.SHAPE);o.node.isGroupNode&&Xcr(c,o,r),Hle(c,o,r),jcr(a,o,r);let u=Kcr(a,o,r);Hle(u,o,r,o.node.type===jt.META),s3(a,o,r),Jcr(a,o)}),i.exit().each(function(o){r.removeNodeGroup(o.node.name);let a=Ht(this);o.inAnnotations.list.length>0&&a.select("."+ve.Annotation.INBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)}),o.outAnnotations.list.length>0&&a.select("."+ve.Annotation.OUTBOX).selectAll("."+ve.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)})}).remove(),i}function jcr(e,t,r){if(t.node.isGroupNode){if(t.expanded)return ect(e,t,r,ve.Subscene.GROUP);Il(e,"g",ve.Subscene.GROUP).remove()}return null}function Ble(e,t){let r=t.x-t.width/2+t.paddingLeft,n=t.y-t.height/2+t.paddingTop,i=Il(e,"g",ve.Subscene.GROUP);a3(i,r,n)}function Xcr(e,t,r){let n=An(e,"g",ve.Node.BUTTON_CONTAINER);An(n,"circle",ve.Node.BUTTON_CIRCLE),An(n,"path",ve.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2"),An(n,"path",ve.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2"),n.on("click",i=>{qt.stopPropagation(),r.fire("node-toggle-expand",{name:i.node.name})}),kle(n,t)}function Hle(e,t,r,n){if(n){e.attr("pointer-events","none");return}let i=Wlt(r,Ule(t.node,r));e.on("dblclick",o=>{r.fire("node-toggle-expand",{name:o.node.name})}).on("mouseover",o=>{r.isNodeExpanded(o)||r.fire("node-highlight",{name:o.node.name})}).on("mouseout",o=>{r.isNodeExpanded(o)||r.fire("node-unhighlight",{name:o.node.name})}).on("click",o=>{qt.stopPropagation(),r.fire("node-select",{name:o.node.name})}).on("contextmenu",(o,a)=>{r.fire("node-select",{name:o.node.name}),i.call(o,a)})}function Ule(e,t){let r=[{title:n=>yH(e.include),action:(n,i,o)=>{t.fire("node-toggle-extract",{name:e.name})}}];return t.nodeContextMenuItems&&(r=r.concat(t.nodeContextMenuItems)),Jlt(e)&&r.push({title:n=>Qlt(e),action:(n,i,o)=>{t.fire("node-toggle-seriesgroup",{name:IH(e)})}}),r}function Jlt(e){return IH(e)!==null}function IH(e){return e?e.type===jt.SERIES?e.name:e.type===jt.OP?e.owningSeries:null:null}function $cr(e){let t=null;if(e)e.type===jt.SERIES?t=e:e.parentNode&&e.parentNode.type===jt.SERIES&&(t=e.parentNode);else return null;return t}function Qlt(e){return ule($cr(e)!==null?os.GROUP:os.UNGROUP)}function Kcr(e,t,r){var c;let n=t.displayName,i=t.node.type===jt.META&&!t.expanded,o=An(e,"text",ve.Node.LABEL),a=o.node();(c=a.parentNode)==null||c.appendChild(a),o.attr("dy",".35em").attr("text-anchor","middle");let s=8;switch(t.node.type){case jt.META:s=t.expanded?J4.Node.EXPANDED_LABEL:J4.Node.SERIES_LABEL;break;case jt.OP:s=J4.Node.OP_LABEL;break}if(i){n.length>r.maxMetanodeLabelLength&&(n=n.substr(0,r.maxMetanodeLabelLength-2)+"\u2026");let u=Zcr(r);o.attr("font-size",u(n.length)+"px"),s=u(n.length)}let l=o.text(n);return qle(l,t.node.type,s,t),o}function qle(e,t,r,n){let i=e.node(),o=i.textContent,a=null;switch(t){case jt.META:n&&!n.expanded&&(a=Tr.nodeSize.meta.maxLabelWidth);break;case jt.OP:a=Tr.nodeSize.op.maxLabelWidth;break;case-1:a=Tr.annotations.maxLabelWidth;break;default:break}if(a!==null)return i.textContent=tle(i.textContent,r,a),e.append("title").text(o)}var $lt=null;function Zcr(e){return $lt||($lt=zn().domain([e.maxMetanodeLabelLengthLargeFont,e.maxMetanodeLabelLength]).range([e.maxMetanodeLabelLengthFontSize,e.minMetanodeLabelLengthFontSize]).clamp(!0)),$lt}function dP(e,t,r,n){Il(e,"text",ve.Node.LABEL).transition().attr("x",t).attr("y",r+n)}function Gle(e,t,r){let n=An(e,"g",r);switch(t.node.type){case jt.OP:let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){An(n,"polygon",ve.Node.COLOR_TARGET);break}An(n,"ellipse",ve.Node.COLOR_TARGET);break;case jt.SERIES:let o="annotation",a=t;a.coreGraph&&(o=a.node.hasNonControlEdges?"vertical":"horizontal");let s=[ve.Node.COLOR_TARGET];a.isFadedOut&&s.push("faded-ellipse"),An(n,"use",s).attr("xlink:href","#op-series-"+o+"-stamp"),An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.BRIDGE:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.META:An(n,"rect",ve.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;default:throw Error("Unrecognized node type: "+t.node.type)}return n}function Wle(e){switch(e.node.type){case jt.OP:return ve.OPNODE;case jt.META:return ve.METANODE;case jt.SERIES:return ve.SERIESNODE;case jt.BRIDGE:return ve.BRIDGENODE;case jt.ELLIPSIS:return ve.ELLIPSISNODE}throw Error("Unrecognized node type: "+e.node.type)}function Jcr(e,t){let r=Il(e,"g",ve.Node.SHAPE),n=x0(t);switch(t.node.type){case jt.OP:{let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){let o=Il(r,"polygon");Lle(o,t.x,t.y,t.coreBox.width,t.coreBox.height)}else{let o=Il(r,"ellipse");EH(o,n,t.y,t.coreBox.width,t.coreBox.height)}dP(e,n,t.y,t.labelOffset);break}case jt.META:{let i=r.selectAll("rect");t.expanded?(Fd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(Fd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,0));break}case jt.SERIES:{let i=Il(r,"use");t.expanded?(Fd(i,t.x,t.y,t.width,t.height),Ble(e,t),dP(e,n,t.y,-t.height/2+t.labelHeight/2)):(Fd(i,n,t.y,t.coreBox.width,t.coreBox.height),dP(e,n,t.y,t.labelOffset));break}case jt.BRIDGE:{let i=Il(r,"rect");Fd(i,t.x,t.y,t.width,t.height);break}default:throw Error("Unrecognized node type: "+t.node.type)}}function Klt(e,t,r){let n=Jse(e);if(!r)return`url(#${n})`;let i=Ht(r),o=i.select("defs#_graph-gradients");o.empty()&&(o=i.append("defs").attr("id","_graph-gradients"));let a=o.select("linearGradient#"+n);if(a.empty()){a=o.append("linearGradient").attr("id",e),a.selectAll("*").remove();let s=0;Vi.each(t,l=>{let c=l.color;a.append("stop").attr("offset",s).attr("stop-color",c),a.append("stop").attr("offset",s+l.proportion).attr("stop-color",c),s+=l.proportion})}return`url(#${n})`}function LH(e){Ht(e).select("defs#_graph-gradients").remove()}function kH(e,t,r,n,i){let o=Ku;switch(e=e||(()=>0),t){case Gn.NONE:case Gn.STRUCTURE:if(r.node.type===jt.META){let a=r.node.templateId;return t===Gn.STRUCTURE&&a!==null?o.STRUCTURE_PALETTE(e(a),n):o.UNKNOWN}else return r.node.type===jt.SERIES?n?o.EXPANDED_COLOR:"white":r.node.type===jt.BRIDGE?r.structural?"#f0e":r.node.inbound?"#0ef":"#fe0":Vi.isNumber(r.node.functionInputIndex)?"#795548":Vi.isNumber(r.node.functionOutputIndex)?"#009688":"white";case Gn.DEVICE:return r.deviceColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("device-"+r.node.name,r.deviceColors,i);case Gn.XLA_CLUSTER:return r.xlaClusterColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("xla-"+r.node.name,r.xlaClusterColors,i);case Gn.COMPUTE_TIME:return n?o.EXPANDED_COLOR:r.computeTimeColor||o.UNKNOWN;case Gn.MEMORY:return n?o.EXPANDED_COLOR:r.memoryColor||o.UNKNOWN;case Gn.OP_COMPATIBILITY:return r.compatibilityColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Klt("op-compat-"+r.node.name,r.compatibilityColors,i);default:throw new Error("Unknown case to color nodes by")}}function s3(e,t,r,n){n=n||ve.Node.SHAPE;let i=r.isNodeHighlighted(t.node.name),o=r.isNodeSelected(t.node.name),a=t.isInExtract||t.isOutExtract||t.isLibraryFunction,s=t.expanded&&n!==ve.Annotation.NODE,l=t.isFadedOut;e.classed("highlighted",i),e.classed("selected",o),e.classed("extract",a),e.classed("expanded",s),e.classed("faded",l);let c=e.select("."+n+" ."+ve.Node.COLOR_TARGET),u=kH(r.templateIndex,r.colorBy,t,s,r.getGraphSvgRoot());c.style("fill",u),c.style("stroke",o?null:tct(u))}function tct(e){return e.substring(0,3)==="url"?Ku.GRADIENT_OUTLINE:cu(e).darker().toString()}function Yle(e,t,r,n){let i=Ht(e);if(i.selectAll(".input-highlight").classed("input-highlight",!1),i.selectAll(".non-input").classed("non-input",!1),i.selectAll(".input-parent").classed("input-parent",!1),i.selectAll(".input-child").classed("input-child",!1),i.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1),i.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1),i.selectAll(".input-highlight-selected").classed("input-highlight-selected",!1),!t||!n||!r)return;let o=jle(r,t),a={};Vi.each(o,function(c){a=Xle(e,t,c,a)});let s=Object.keys(a),l=tur(t,s);eur(e,l),i.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(c){let u=c.node.name;i.selectAll(`[data-name="${u}"]`).classed("non-input",!0)}),i.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}function jle(e,t){let r=[],n=t.getNodeByName(e);if(n instanceof y0)return[n].concat(n.inEmbeddings);let i=n.metagraph.nodes();return Vi.each(i,function(o){r=r.concat(jle(o,t))}),r}function Xle(e,t,r,n){if(n[r.name])return n;n[r.name]=!0;let i=r.inputs,o=Zlt(t,r);Ht(e).select(`.node[data-name="${o.name}"]`).classed("input-highlight",!0);let a={};Vi.each(i,function(u){let h=t.getNodeByName(u.name);if(h===void 0)return;if(h instanceof aP){let d=sP(h.name);h=t.getNodeByName(d)}let f=Zlt(t,h),p=a[f.name];p?p.opNodes.push(h):a[f.name]={visibleParent:f,opNodes:[h]}});let s={},l=[o];s[o.name]={traced:!1,index:0,connectionEndpoints:[]};let c=o;for(let u=1;c.name!==qc;u++)c=c.parentNode,s[c.name]={traced:!1,index:u,connectionEndpoints:[]},l[u]=c;return Vi.forOwn(a,function(u,h){let f=u.visibleParent;Vi.each(u.opNodes,function(p){n=Xle(e,t,p,n)}),f.name!==o.name&&Qcr(e,f,s,l)}),n}function Qcr(e,t,r,n){let i=t,o=t,a=[];for(;!r[i.name];)o.name!==i.name&&a.push([o,i]),o=i,i=i.parentNode;let s=r[i.name].index,l=n[Math.max(s-1,0)].name,c=l,u=o.name,h=o.name,f=Ht(e);f.selectAll(`[data-edge="${h}--${l}"]`).classed("input-edge-highlight",!0),Vi.each(a,function(p){let d=p[0],g=p[1],_=`[data-edge="${d.name}--${c}~~${g.name}~~OUT"]`;f.selectAll(_).classed("input-edge-highlight",!0)});for(let p=1;p<s;p++){let d=n[p-1],g=n[p],_=`[data-edge="${u}~~${g.name}~~IN--${d.name}"]`;f.selectAll(_).classed("input-edge-highlight",!0)}}function tur(e,t){let r={};return Vi.each(t,function(n){let i=e.getNodeByName(n),o=Zlt(e,i);r[o.name]=o}),r}function eur(e,t){Vi.forOwn(t,function(r){let n=r;for(;n.name!==qc;){let i=Ht(e).select(`.node[data-name="${n.name}"]`);i.nodes().length&&!i.classed("input-highlight")&&!i.classed("selected")&&!i.classed("op")&&i.classed("input-parent",!0),n=n.parentNode}})}function Zlt(e,t){let r=!1,n=t;for(;!r;)if(t=n,n=t.parentNode,n===void 0)r=!0;else{let i=e.getRenderNodeByName(n.name);i&&(i.expanded||n instanceof y0)&&(r=!0)}return t}function Vle(e,t,r,n){let i=e.selectAll(function(){return this.childNodes}).data(t.list,o=>o.node.name);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);n.addAnnotationGroup(o,r,a);let s=ve.Annotation.EDGE,l=o.renderMetaedgeInfo&&o.renderMetaedgeInfo.metaedge;l&&!l.numRegularEdges&&(s+=" "+ve.Annotation.CONTROL_EDGE),l&&l.numRefEdges&&(s+=" "+ve.Edge.REF_LINE),Xlt(a,o,n,s),o.annotationType!==gi.ELLIPSIS?(iur(a,o),nur(a,o)):$le(a,o.node.name,o,ve.Annotation.ELLIPSIS)}).merge(i).attr("class",o=>ve.Annotation.GROUP+" "+rur(o.annotationType)+" "+Wle(o)).each(function(o){let a=Ht(this);aur(a,r,o,n),o.annotationType!==gi.ELLIPSIS&&our(a,r,o,n)}),i.exit().each(function(o){n.removeAnnotationGroup(o,r)}).remove(),i}function rur(e){return(gi[e]||"").toLowerCase()||null}function nur(e,t){if(t.annotationType===gi.SUMMARY)An(e,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer");else{let r=Gle(e,t,ve.Annotation.NODE);An(r,"title").text(t.node.name)}}function iur(e,t){let r=t.node.name.split("/"),n=r[r.length-1];return $le(e,n,t,null)}function $le(e,t,r,n){let i=ve.Annotation.LABEL;n&&(i+=" "+n);let o=e.append("text").attr("class",i).attr("dy",".35em").attr("text-anchor",r.isIn?"end":"start").text(t);return qle(o,-1,J4.Annotation.LABEL)}function our(e,t,r,n){e.on("mouseover",i=>{n.fire("annotation-highlight",{name:i.node.name,hostName:t.node.name})}).on("mouseout",i=>{n.fire("annotation-unhighlight",{name:i.node.name,hostName:t.node.name})}).on("click",i=>{qt.stopPropagation(),n.fire("annotation-select",{name:i.node.name,hostName:t.node.name})}),r.annotationType!==gi.SUMMARY&&r.annotationType!==gi.CONSTANT&&e.on("contextmenu",Wlt(n,Ule(r.node,n)))}function aur(e,t,r,n){let i=x0(t);r.renderNodeInfo&&r.annotationType!==gi.ELLIPSIS&&s3(e,r.renderNodeInfo,n,ve.Annotation.NODE),r.annotationType===gi.SUMMARY&&(r.width+=10),e.select("text."+ve.Annotation.LABEL).transition().attr("x",i+r.dx+(r.isIn?-1:1)*(r.width/2+r.labelOffset)).attr("y",t.y+r.dy),e.select("use.summary").transition().attr("x",i+r.dx-3).attr("y",t.y+r.dy-6),EH(e.select("."+ve.Annotation.NODE+" ellipse"),i+r.dx,t.y+r.dy,r.width,r.height),Fd(e.select("."+ve.Annotation.NODE+" rect"),i+r.dx,t.y+r.dy,r.width,r.height),Fd(e.select("."+ve.Annotation.NODE+" use"),i+r.dx,t.y+r.dy,r.width,r.height),e.select("path."+ve.Annotation.EDGE).transition().attr("d",o=>{let a=o.points.map(s=>({x:s.dx+i,y:s.dy+t.y}));return CH(a)})}function ect(e,t,r,n){n=n||ve.Scene.GROUP;let i=g0(e,"g",n).empty(),o=An(e,"g",n),a=An(o,"g",ve.Scene.CORE),s=Vi.reduce(t.coreGraph.nodes(),(l,c)=>{let u=t.coreGraph.node(c);return u.excluded||l.push(u),l},Array());if(t.node.type===jt.SERIES&&s.reverse(),zle(a,t.coreGraph,r),PH(a,s,r),t.isolatedInExtract.length>0){let l=An(o,"g",ve.Scene.INEXTRACT);PH(l,t.isolatedInExtract,r)}else g0(o,"g",ve.Scene.INEXTRACT).remove();if(t.isolatedOutExtract.length>0){let l=An(o,"g",ve.Scene.OUTEXTRACT);PH(l,t.isolatedOutExtract,r)}else g0(o,"g",ve.Scene.OUTEXTRACT).remove();if(t.libraryFunctionsExtract.length>0){let l=An(o,"g",ve.Scene.FUNCTION_LIBRARY);PH(l,t.libraryFunctionsExtract,r)}else g0(o,"g",ve.Scene.FUNCTION_LIBRARY).remove();return Ple(o,t),i&&o.attr("opacity",0).transition().attr("opacity",1),o}var sur=.8,RH=class{constructor(t,r,n,i,o,a){this.svg=t,this.labelPadding=a,this.zoomG=r,this.mainZoom=n,this.maxWandH=o;let s=Ht(i.shadowRoot),l=s.select("svg"),c=l.select("rect"),u=f=>{this.viewpointCoord.x=qt.x,this.viewpointCoord.y=qt.y,this.updateViewpoint()};this.viewpointCoord={x:0,y:0};let h=pb().subject(Object).on("drag",u);c.datum(this.viewpointCoord).call(h),l.on("click",()=>{if(qt.defaultPrevented)return;let f=Number(c.attr("width")),p=Number(c.attr("height")),d=zo(l.node());this.viewpointCoord.x=d[0]-f/2,this.viewpointCoord.y=d[1]-p/2,this.updateViewpoint()}),this.viewpoint=c.node(),this.minimapSvg=l.node(),this.minimap=i,this.canvas=s.select("canvas.first").node(),this.canvasBuffer=s.select("canvas.second").node(),this.downloadCanvas=s.select("canvas.download").node(),Ht(this.downloadCanvas).style("display","none"),this.update()}updateViewpoint(){Ht(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let t=-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,r=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;Ht(this.svg).call(this.mainZoom.transform,$h.translate(t,r).scale(this.scaleMain))}getImageBlob(){return new Promise(t=>{this.downloadCanvas.toBlob(r=>{t(r)},"image/png")})}update(){let t=null;try{if(t=this.zoomG.getBBox(),t.width===0)return}catch(p){return}let r=Ht(this.svg),n="",i=this.svg,a=(i.getRootNode?i.getRootNode():this.svg.parentNode).styleSheets;for(let p=0;p<a.length;p++)try{let d=a[p].cssRules||a[p].rules;if(d==null)continue;for(let g=0;g<d.length;g++)n+=d[g].cssText.replace(/ ?tf-[\w-]+ ?/g,"")+`
`}catch(d){if(d.name!=="SecurityError")throw d}let s=r.append("style");s.text(n);let l=Ht(this.zoomG),c=l.attr("transform");l.attr("transform",null),t.height+=t.y,t.width+=t.x,t.height+=this.labelPadding*2,t.width+=this.labelPadding*2,r.attr("width",t.width).attr("height",t.height),this.scaleMinimap=this.maxWandH/Math.max(t.width,t.height),this.minimapSize={width:t.width*this.scaleMinimap,height:t.height*this.scaleMinimap},Ht(this.minimapSvg).attr(this.minimapSize),Ht(this.canvasBuffer).attr(this.minimapSize);let u=Ht(this.downloadCanvas);u.style("width",t.width),u.style("height",t.height),u.attr("width",3*t.width),u.attr("height",3*t.height),this.translate!=null&&this.zoom!=null&&requestAnimationFrame(()=>this.zoom());let h=new XMLSerializer().serializeToString(this.svg);s.remove(),r.attr("width",null).attr("height",null),l.attr("transform",c);let f=new Image;f.onload=()=>{let p=this.canvasBuffer.getContext("2d");p==null||p.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height),p==null||p.drawImage(f,0,0,this.minimapSize.width,this.minimapSize.height),requestAnimationFrame(()=>{Ht(this.canvasBuffer).style("display",null),Ht(this.canvas).style("display","none"),[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});let d=this.downloadCanvas.getContext("2d");d==null||d.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height),d==null||d.drawImage(f,0,0,this.downloadCanvas.width,this.downloadCanvas.height)},f.onerror=()=>{let p=new Blob([h],{type:"image/svg+xml;charset=utf-8"});f.src=URL.createObjectURL(p)},f.src="data:image/svg+xml;charset=utf-8,"+encodeURIComponent(h)}zoom(t){if(this.scaleMinimap==null)return;t&&(this.translate=[t.x,t.y],this.scaleMain=t.k);let r=this.svg.getBoundingClientRect(),n=Ht(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain,this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;let i=r.width*this.scaleMinimap/this.scaleMain,o=r.height*this.scaleMinimap/this.scaleMain;n.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",i).attr("height",o);let a=this.minimapSize.width,s=this.minimapSize.height,l=this.viewpointCoord.x,c=this.viewpointCoord.y,u=Math.min(Math.max(0,l+i),a)-Math.min(Math.max(0,l),a),h=Math.min(Math.max(0,c+o),s)-Math.min(Math.max(0,c),s);u*h/(a*s)<sur?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}};var nct=class extends mt{init(t,r,n,i,o){return new RH(t,r,n,this,i,o)}};nct.template=Q`
    <style>
      :host {
        background-color: white;
        transition: opacity 0.3s linear;
        pointer-events: auto;
      }

      :host(.hidden) {
        opacity: 0;
        pointer-events: none;
      }

      canvas {
        border: 1px solid #999;
      }

      rect {
        fill: white;
        stroke: #111111;
        stroke-width: 1px;
        fill-opacity: 0;
        filter: url(#minimapDropShadow);
        cursor: move;
      }

      svg {
        position: absolute;
      }
    </style>
    <svg>
      <defs>
        <filter
          id="minimapDropShadow"
          x="-20%"
          y="-20%"
          width="150%"
          height="150%"
        >
          <feOffset result="offOut" in="SourceGraphic" dx="1" dy="1"></feOffset>
          <feColorMatrix
            result="matrixOut"
            in="offOut"
            type="matrix"
            values="0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.5 0"
          ></feColorMatrix>
          <feGaussianBlur
            result="blurOut"
            in="matrixOut"
            stdDeviation="2"
          ></feGaussianBlur>
          <feBlend in="SourceGraphic" in2="blurOut" mode="normal"></feBlend>
        </filter>
      </defs>
      <rect></rect>
    </svg>
    <canvas class="first"></canvas>
    <!-- Additional canvas to use as buffer to avoid flickering between updates -->
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  `;nct=E([yt("tf-graph-minimap")],nct);var Kle=Q`
  <style>
    :host(.dark-mode) {
      filter: invert(1);
    }

    :host {
      display: flex;
      font-size: 20px;
      height: 100%;
      width: 100%;
    }

    #svg {
      flex: 1;
      font-family: Roboto, sans-serif;
      height: 100%;
      overflow: hidden;
      width: 100%;
    }

    #hidden {
      position: fixed;
      top: 0px;
      visibility: hidden;
    }

    text {
      user-select: none;
    }

    /* --- Node and annotation-node for Metanode --- */

    .meta > .nodeshape > rect,
    .meta > .annotation-node > rect {
      cursor: pointer;
      fill: hsl(0, 0%, 70%);
    }
    .node.meta.highlighted > .nodeshape > rect,
    .node.meta.highlighted > .annotation-node > rect {
      stroke-width: 2;
    }
    .annotation.meta.highlighted > .nodeshape > rect,
    .annotation.meta.highlighted > .annotation-node > rect {
      stroke-width: 1;
    }
    .meta.selected > .nodeshape > rect,
    .meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded > .nodeshape > rect,
    .node.meta.selected.expanded > .annotation-node > rect {
      stroke: red;
      stroke-width: 3;
    }
    .annotation.meta.selected > .nodeshape > rect,
    .annotation.meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded.highlighted > .nodeshape > rect,
    .node.meta.selected.expanded.highlighted > .annotation-node > rect {
      stroke: red;
      stroke-width: 4;
    }

    .faded,
    .faded rect,
    .faded ellipse,
    .faded path,
    .faded use,
    #rectHatch line,
    #ellipseHatch line {
      color: #e0d4b3 !important;
      fill: white;
      stroke: #e0d4b3 !important;
    }

    .faded path {
      stroke-width: 1px !important;
    }

    .faded rect {
      fill: url(#rectHatch) !important;
    }

    .faded ellipse,
    .faded use {
      fill: url(#ellipseHatch) !important;
    }

    .faded text {
      opacity: 0;
    }

    /* Rules used for input-tracing. */
    .input-highlight > * > rect,
    .input-highlight > * > ellipse,
    .input-highlight > * > use {
      fill: white;
      stroke: #ff9800 !important;
    }

    /*  - Faded non-input styling */
    .non-input > * > rect,
.non-input > * > ellipse,
.non-input > * > use,
/* For Const nodes. */
.non-input > * > .constant:not([class*="input-highlight"]) >
  .annotation-node > ellipse,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      stroke: #e0d4b3 !important;
      stroke-width: inherit;
      stroke-dasharray: inherit;
    }

    .non-input path {
      visibility: hidden;
    }

    .non-input > .nodeshape > rect,
.non-input > .annotation-node > rect,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      fill: url(#rectHatch) !important;
    }

    .non-input ellipse,
    .non-input use {
      fill: url(#ellipseHatch) !important;
    }

    .non-input > text {
      opacity: 0;
    }

    .non-input .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .non-input .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    /* Input edges. */
    .input-edge-highlight > text {
      fill: black !important;
    }
    .input-highlight > .in-annotations > .annotation > .annotation-edge,
    .input-highlight-selected
      > .in-annotations
      > .annotation
      > .annotation-edge {
      stroke: #999 !important;
    }

    /* Non-input edges. */
    .non-input-edge-highlight,
.non-input > g > .annotation > path,
/* Annotation styles (label and edges respectively). */
.non-input > g >
.annotation:not(.input-highlight):not(.input-highlight-selected) >
.annotation-label
/*.annotation-edge*/ {
      visibility: hidden;
    }

    /* --- Op Node --- */

    .op > .nodeshape > .nodecolortarget,
    .op > .annotation-node > .nodecolortarget {
      cursor: pointer;
      fill: #fff;
      stroke: #ccc;
    }

    .op.selected > .nodeshape > .nodecolortarget,
    .op.selected > .annotation-node > .nodecolortarget {
      stroke: red;
      stroke-width: 2;
    }

    .op.highlighted > .nodeshape > .nodecolortarget,
    .op.highlighted > .annotation-node > .nodecolortarget {
      stroke-width: 2;
    }

    /* --- Series Node --- */

    /* By default, don't show the series background <rect>. */
    .series > .nodeshape > rect {
      fill: hsl(0, 0%, 70%);
      fill-opacity: 0;
      stroke-dasharray: 5, 5;
      stroke-opacity: 0;
      cursor: pointer;
    }

    /* Once expanded, show the series background <rect> and hide the <use>. */
    .series.expanded > .nodeshape > rect {
      fill-opacity: 0.15;
      stroke: hsl(0, 0%, 70%);
      stroke-opacity: 1;
    }
    .series.expanded > .nodeshape > use {
      visibility: hidden;
    }

    /**
 * TODO: Simplify this by applying a stable class name to all <g>
 * elements that currently have either the nodeshape or annotation-node classes.
 */
    .series > .nodeshape > use,
    .series > .annotation-node > use {
      stroke: #ccc;
    }
    .series.highlighted > .nodeshape > use,
    .series.highlighted > .annotation-node > use {
      stroke-width: 2;
    }
    .series.selected > .nodeshape > use,
    .series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    .series.selected > .nodeshape > rect {
      stroke: red;
      stroke-width: 2;
    }

    .annotation.series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    /* --- Bridge Node --- */
    .bridge > .nodeshape > rect {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* --- Structural Elements --- */
    .edge > path.edgeline.structural {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* Reference Edge */
    .edge > path.edgeline.referenceedge {
      stroke: #ffb74d;
      opacity: 1;
    }

    /* --- Series Nodes --- */

    /* Hide the rect for a series' annotation. */
    .series > .annotation-node > rect {
      display: none;
    }

    /* --- Node label --- */

    .node {
      /* Provide a hint to browsers to avoid using their static rasterization
      at initial scale, which looks very pixelated on Chromium when zoomed in.
      Note that we intentionally do *not* use 'will-change: transform' and
      'translateZ(0) here, which introduce blurriness on Firefox.
      See https://github.com/tensorflow/tensorboard/issues/4744 */
      transform: translateZ(1px);
    }

    .node > text.nodelabel {
      cursor: pointer;
      fill: #444;
    }

    .meta.expanded > text.nodelabel {
      font-size: 9px;
    }

    .series > text.nodelabel {
      font-size: 8px;
    }

    .op > text.nodelabel {
      font-size: 6px;
    }

    .bridge > text.nodelabel {
      display: none;
    }

    .node.meta.expanded > text.nodelabel {
      cursor: normal;
    }

    .annotation.meta.highlighted > text.annotation-label {
      fill: #50a3f7;
    }

    .annotation.meta.selected > text.annotation-label {
      fill: #4285f4;
    }

    /* --- Annotation --- */

    /* only applied for annotations that are not summary or constant.
(.summary, .constant gets overridden below) */
    .annotation > .annotation-node > * {
      stroke-width: 0.5;
      stroke-dasharray: 1, 1;
    }

    .annotation.summary > .annotation-node > *,
    .annotation.constant > .annotation-node > * {
      stroke-width: 1;
      stroke-dasharray: none;
    }

    .annotation > .annotation-edge {
      fill: none;
      stroke: #aaa;
      stroke-width: 0.5;
      marker-end: url(#annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    .annotation > .annotation-control-edge {
      stroke-dasharray: 1, 1;
    }

    #annotation-arrowhead {
      fill: #aaa;
    }

    #annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    #ref-annotation-arrowhead {
      fill: #aaa;
    }

    #ref-annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    .annotation > .annotation-label {
      font-size: 5px;
      cursor: pointer;
    }
    .annotation > .annotation-label.annotation-ellipsis {
      cursor: default;
    }

    /* Hide annotations on expanded meta nodes since they're redundant. */
    .expanded > .in-annotations,
    .expanded > .out-annotations {
      display: none;
    }

    /* --- Annotation: Constant --- */

    .constant > .annotation-node > ellipse {
      cursor: pointer;
      fill: white;
      stroke: #848484;
    }

    .constant.selected > .annotation-node > ellipse {
      fill: white;
      stroke: red;
    }

    .constant.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Annotation: Summary --- */

    .summary > .annotation-node > ellipse {
      cursor: pointer;
      fill: #db4437;
      stroke: #db4437;
    }

    .summary.selected > .annotation-node > ellipse {
      fill: #a52714;
      stroke: #a52714;
    }

    .summary.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Edge --- */

    .edge > path.edgeline {
      fill: none;
      stroke: #bbb;
      stroke-linecap: round;
      stroke-width: 0.75;
    }

    .edge .selectableedge {
      cursor: pointer;
    }

    .selectededge > path.edgeline {
      cursor: default;
      stroke: #f00;
    }

    .edge.selectededge text {
      fill: #000;
    }

    /* Labels showing tensor shapes on edges */
    .edge > text {
      font-size: 3.5px;
      fill: #666;
    }

    .dataflow-arrowhead {
      fill: #bbb;
    }

    .reference-arrowhead {
      fill: #ffb74d;
    }

    .selected-arrowhead {
      fill: #f00;
    }

    .edge .control-dep {
      stroke-dasharray: 2, 2;
    }

    /* --- Group node expand/collapse button --- */

    /* Hides expand/collapse buttons when a node isn't expanded or highlighted. Using
   incredibly small opacity so that the bounding box of the <g> parent still takes
   this container into account even when it isn't visible */
    .node:not(.highlighted):not(.expanded) > .nodeshape > .buttoncontainer {
      opacity: 0.01;
    }
    .node.highlighted > .nodeshape > .buttoncontainer {
      cursor: pointer;
    }
    .buttoncircle {
      fill: #e7811d;
    }
    .buttoncircle:hover {
      fill: #b96717;
    }
    .expandbutton,
    .collapsebutton {
      stroke: #444;
    }
    /* Do not let the path elements in the button take pointer focus */
    .node > .nodeshape > .buttoncontainer > .expandbutton,
    .node > .nodeshape > .buttoncontainer > .collapsebutton {
      pointer-events: none;
    }
    /* Only show the expand button when a node is collapsed and only show the
   collapse button when a node is expanded. */
    .node.expanded > .nodeshape > .buttoncontainer > .expandbutton {
      display: none;
    }
    .node:not(.expanded) > .nodeshape > .buttoncontainer > .collapsebutton {
      display: none;
    }

    .health-pill-stats {
      font-size: 4px;
      text-anchor: middle;
    }

    .health-pill rect {
      filter: url(#health-pill-shadow);
      rx: 3;
      ry: 3;
    }

    .titleContainer {
      position: relative;
      top: 20px;
    }

    .title,
    .auxTitle,
    .functionLibraryTitle {
      position: absolute;
    }

    #minimap {
      position: absolute;
      right: 20px;
      bottom: 20px;
    }

    .context-menu {
      position: absolute;
      display: none;
      background-color: #e2e2e2;
      border-radius: 2px;
      font-size: 14px;
      min-width: 150px;
      border: 1px solid #d4d4d4;
    }

    .context-menu ul {
      list-style-type: none;
      margin: 0;
      padding: 0;
      cursor: default;
    }

    .context-menu ul li {
      padding: 4px 16px;
    }

    .context-menu ul li:hover {
      background-color: #f3913e;
      color: white;
    }
  </style>
  <div class="titleContainer">
    <div id="title" class="title">Main Graph</div>
    <div id="auxTitle" class="auxTitle">Auxiliary Nodes</div>
    <div id="functionLibraryTitle" class="functionLibraryTitle">Functions</div>
  </div>
  <svg id="svg">
    <defs>
      <!-- Arrow heads for reference edge paths of different predefined sizes per color. -->
      <path
        id="reference-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>

      <!-- Arrow heads for dataflow edge paths of different predefined sizes per color. -->
      <path
        id="dataflow-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>

      <!-- Arrow head for annotation edge paths. -->
      <marker
        id="annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <!-- Template for an Op node ellipse. -->
      <ellipse
        id="op-node-stamp"
        rx="7.5"
        ry="3"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Template for an Op node annotation ellipse (smaller). -->
      <ellipse
        id="op-node-annotation-stamp"
        rx="5"
        ry="2"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Vertically stacked series of Op nodes when unexpanded. -->
      <g id="op-series-vertical-stamp">
        <use xlink:href="#op-node-stamp" x="8" y="9"></use>
        <use xlink:href="#op-node-stamp" x="8" y="6"></use>
        <use xlink:href="#op-node-stamp" x="8" y="3"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes when unexpanded. -->
      <g id="op-series-horizontal-stamp">
        <use xlink:href="#op-node-stamp" x="16" y="4"></use>
        <use xlink:href="#op-node-stamp" x="12" y="4"></use>
        <use xlink:href="#op-node-stamp" x="8" y="4"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes for annotation. -->
      <g id="op-series-annotation-stamp">
        <use xlink:href="#op-node-annotation-stamp" x="9" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="7" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="5" y="2"></use>
      </g>
      <svg
        id="summary-icon"
        fill="#848484"
        height="12"
        viewBox="0 0 24 24"
        width="12"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>

      <!-- Hatch patterns for faded out nodes. -->
      <pattern
        id="rectHatch"
        patternTransform="rotate(45 0 0)"
        width="5"
        height="5"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
      </pattern>
      <pattern
        id="ellipseHatch"
        patternTransform="rotate(45 0 0)"
        width="2"
        height="2"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
      </pattern>

      <!-- A shadow for health pills. -->
      <filter
        id="health-pill-shadow"
        x="-40%"
        y="-40%"
        width="180%"
        height="180%"
      >
        <feGaussianBlur in="SourceAlpha" stdDeviation="0.8"></feGaussianBlur>
        <feOffset dx="0" dy="0" result="offsetblur"></feOffset>
        <feFlood flood-color="#000000"></feFlood>
        <feComposite in2="offsetblur" operator="in"></feComposite>
        <feMerge>
          <feMergeNode></feMergeNode>
          <feMergeNode in="SourceGraphic"></feMergeNode>
        </feMerge>
      </filter>
    </defs>
    <!-- Make a large rectangle that fills the svg space so that
  zoom events get captured on safari -->
    <rect fill="white" width="10000" height="10000"></rect>
    <g id="root"></g>
  </svg>
  <tf-graph-minimap id="minimap"></tf-graph-minimap>
  <div id="contextMenu" class="context-menu"></div>
`;var Lr=class extends Gt(_o(mt)){constructor(){super(...arguments),this._zoomed=!1,this._zoomStartCoords=null,this._zoomTransform=null,this._maxZoomDistanceForClick=20,this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this.maxMetanodeLabelLengthFontSize=9,this.minMetanodeLabelLengthFontSize=6,this.maxMetanodeLabelLengthLargeFont=11,this.maxMetanodeLabelLength=18}getNode(t){return this.renderHierarchy.getRenderNodeByName(t)}isNodeExpanded(t){return t.expanded}setNodeExpanded(t){this._build(this.renderHierarchy),this._updateLabels(!this._zoomed)}panToNode(t){Ale(t,this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)}getGraphSvgRoot(){return this.$.svg}getContextMenu(){return this.$.contextMenu}_resetState(){this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this._updateLabels(!1),Ht(this.$.svg).select("#root").selectAll("*").remove(),LH(this.$.svg)}_build(t){this.templateIndex=t.hierarchy.getTemplateIndex(),Nd("tf-graph-scene (layout):",function(){MH(t.root)}.bind(this),jr.RENDER_SCENE_LAYOUT),Nd("tf-graph-scene (build scene):",function(){ect(Ht(this.$.root),t.root,this),Ile(this.$.svg,this),this._updateInputTrace()}.bind(this),jr.RENDER_SCENE_BUILD_SCENE),setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex),this.minimap.update()}.bind(this),Tr.animation.duration)}ready(){super.ready(),this._zoom=eR().on("end",function(){if(this._zoomStartCoords){var t=Math.sqrt(Math.pow(this._zoomStartCoords.x-this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2));t<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50)}this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=qt.transform,this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click")),this._zoomed=!0,Ht(this.$.root).attr("transform",qt.transform),this.minimap.zoom(qt.transform)}.bind(this)),Ht(this.$.svg).call(this._zoom).on("dblclick.zoom",null),Ht(window).on("resize",function(){this.minimap.zoom()}.bind(this)),this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,Tr.minimap.size,Tr.subscene.meta.labelHeight)}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}_renderHierarchyChanged(){var t=this.renderHierarchy;this._hasRenderHierarchyBeenFitOnce=!1,this._resetState(),this._build(t)}_animateAndFit(){var t=this._isAttached;this._hasRenderHierarchyBeenFitOnce||!t||setTimeout(this.fit.bind(this),Tr.animation.duration)}_updateLabels(t){var r=this.$$(".title"),n=r.style,i=this.$$(".auxTitle"),o=i.style,a=this.$$(".functionLibraryTitle").style;let s=Ht(this.$.svg);var l=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.CORE).node();if(t&&l&&this.progress&&this.progress.value===100){var c=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.INEXTRACT).node()||s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.OUTEXTRACT).node(),u=l.getCTM().e,h=c?c.getCTM().e:null;n.display="inline",n.left=u+"px",h!==null&&h!==u?(o.display="inline",h=Math.max(u+r.getBoundingClientRect().width,h),o.left=h+"px"):o.display="none";let f=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY).node(),p=f?f.getCTM().e:null;p!==null&&p!==h?(a.display="inline",p=Math.max(h+i.getBoundingClientRect().width,p),a.left=p+"px"):a.display="none"}else n.display="none",o.display="none",a.display="none"}nodeColorsChanged(){this.renderHierarchy!=null&&(this.templateIndex=this.renderHierarchy.hierarchy.getTemplateIndex(),mP.each(this._nodeGroupIndex,(t,r)=>{this._updateNodeState(r)}),this.minimap.update())}fit(){this._hasRenderHierarchyBeenFitOnce=!0,Cle(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))}getImageBlob(){return this.minimap.getImageBlob()}isNodeSelected(t){return t===this.selectedNode}isNodeHighlighted(t){return t===this.highlightedNode}addAnnotationGroup(t,r,n){var i=t.node.name;this._annotationGroupIndex[i]=this._annotationGroupIndex[i]||{},this._annotationGroupIndex[i][r.node.name]=n}getAnnotationGroupsIndex(t){return this._annotationGroupIndex[t]}removeAnnotationGroup(t,r){delete this._annotationGroupIndex[t.node.name][r.node.name]}addNodeGroup(t,r){this._nodeGroupIndex[t]=r}getNodeGroup(t){return this._nodeGroupIndex[t]}removeNodeGroup(t){delete this._nodeGroupIndex[t]}addEdgeGroup(t,r){this._edgeGroupIndex[t]=r}getEdgeGroup(t){return this._edgeGroupIndex[t]}_updateHealthPills(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex;Rle(this.$.svg,t,r)}_updateNodeState(t){var r=this.getNode(t),n=this.getNodeGroup(t);if(n&&s3(n,r,this),r.node.type===jt.META&&r.node.associatedFunction&&!r.isLibraryFunction){var i=Ma+r.node.associatedFunction,o=Ht("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY+' g[data-name="'+i+'"]');s3(o,r,this)}var a=this.getAnnotationGroupsIndex(t);mP.each(a,(s,l)=>{s3(s,r,this,Hi.Annotation.NODE)})}_selectedNodeChanged(t,r){if(t!==r&&(r&&this._updateNodeState(r),!!t)){this.minimap.update();for(var n=this.renderHierarchy.hierarchy.node(t),i=[];n.parentNode!=null&&n.parentNode.name!=qc;)n=n.parentNode,i.push(n.name);var o;mP.forEachRight(i,a=>{this.renderHierarchy.buildSubhierarchy(a);var s=this.renderHierarchy.getRenderNodeByName(a);s.node.isGroupNode&&!s.expanded&&(s.expanded=!0,o||(o=s))}),o&&(this.setNodeExpanded(o),this._zoomed=!0),t&&this._updateNodeState(t),setTimeout(()=>{this.panToNode(t)},Tr.animation.duration)}}_highlightedNodeChanged(t,r){t!==r&&(t&&this._updateNodeState(t),r&&this._updateNodeState(r))}_onZoomChanged(){this._updateLabels(!this._zoomed)}_fireEnableClick(){this.fire("enable-click")}_updateInputTrace(){Yle(this.getGraphSvgRoot(),this.renderHierarchy,this.selectedNode,this.traceInputs)}};Lr.template=Kle;E([A({type:Object}),w("design:type",lo)],Lr.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"name",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"colorBy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_hasRenderHierarchyBeenFitOnce",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_isAttached",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoom",void 0);E([A({type:String,observer:"_highlightedNodeChanged"}),w("design:type",String)],Lr.prototype,"highlightedNode",void 0);E([A({type:String,observer:"_selectedNodeChanged"}),w("design:type",String)],Lr.prototype,"selectedNode",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"handleEdgeSelected",void 0);E([A({type:Boolean,observer:"_onZoomChanged"}),w("design:type",Boolean)],Lr.prototype,"_zoomed",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomStartCoords",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomTransform",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"_maxZoomDistanceForClick",void 0);E([A({type:Object}),w("design:type",Function)],Lr.prototype,"templateIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_nodeGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_annotationGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_edgeGroupIndex",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"minMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthLargeFont",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLength",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"progress",void 0);E([A({type:Array}),w("design:type",Array)],Lr.prototype,"nodeContextMenuItems",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"healthPillStepIndex",void 0);E([Bt("renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_renderHierarchyChanged",null);E([Bt("_isAttached","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_animateAndFit",null);E([Bt("colorBy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"nodeColorsChanged",null);E([Bt("nodeNamesToHealthPills","healthPillStepIndex"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateHealthPills",null);E([Bt("traceInputs","selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateInputTrace",null);Lr=E([yt("tf-graph-scene")],Lr);var Dr=class extends Gt(mt){constructor(){super(...arguments),this._renderDepth=1,this._allowGraphSelect=!0,this.edgeWidthFunction="",this.handleNodeSelected="",this.edgeLabelFunction="",this.handleEdgeSelected=""}panToNode(t){this.$$("tf-graph-scene").panToNode(t)}_autoExtractNodesChanged(){var t=this.graphHierarchy;if(!!t){for(let r of Object.values(t.getNodeMap()))r.include=ur.UNSPECIFIED;this._buildRenderHierarchy(t)}}_buildNewRenderHierarchy(){var t=this.graphHierarchy;!t||this._buildRenderHierarchy(t)}_statsChanged(){var t=this.stats,r=this.devicesForStats;this.graphHierarchy&&(t&&r&&(ale(this.basicGraph,t,r),ple(this.graphHierarchy,t)),this._buildRenderHierarchy(this.graphHierarchy))}ready(){super.ready(),this.addEventListener("graph-select",this._graphSelected.bind(this)),this.addEventListener("disable-click",this._disableClick.bind(this)),this.addEventListener("enable-click",this._enableClick.bind(this)),this.addEventListener("node-toggle-expand",this._nodeToggleExpand.bind(this)),this.addEventListener("node-select",this._nodeSelected.bind(this)),this.addEventListener("node-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("node-unhighlight",this._nodeUnhighlighted.bind(this)),this.addEventListener("node-toggle-extract",this._nodeToggleExtract.bind(this)),this.addEventListener("node-toggle-seriesgroup",this._nodeToggleSeriesGroup.bind(this)),this.addEventListener("edge-select",this._edgeSelected.bind(this)),this.addEventListener("annotation-select",this._nodeSelected.bind(this)),this.addEventListener("annotation-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("annotation-unhighlight",this._nodeUnhighlighted.bind(this))}_buildRenderHierarchy(t){if(t.root.type!==jt.META)return;let r=this,n=Nd("new tf_graph_render.Hierarchy",()=>{let i=new lo(t,!!this.stats,this.autoExtractNodes);i.edgeLabelFunction=this.edgeLabelFunction,i.edgeWidthFunction=this.edgeWidthFunction;function o(a){return{minValue:a.domain()[0],maxValue:a.domain()[1],startColor:a.range()[0],endColor:a.range()[1]}}return r._setColorByParams({compute_time:o(i.computeTimeScale),memory:o(i.memoryUsageScale),device:ict.map(i.deviceColorMap.domain(),function(a){return{device:a,color:i.deviceColorMap(a)}}),xla_cluster:ict.map(i.xlaClusterColorMap.domain(),function(a){return{xla_cluster:a,color:i.xlaClusterColorMap(a)}})}),i},jr.RENDER_BUILD_HIERARCHY);r._setRenderHierarchy(n)}_getVisible(t){return t&&this.renderHierarchy.getNearestVisibleAncestor(t)}fit(){this.$.scene.fit()}getImageBlob(){return this.$.scene.getImageBlob()}_graphChanged(){!this.graphHierarchy||(this.graphHierarchy.addListener(Od.TEMPLATES_UPDATED,()=>{this.$.scene.nodeColorsChanged()}),this.fire("graph-select"))}_graphSelected(t){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null)),this._allowGraphSelect=!0}_disableClick(t){this._allowGraphSelect=!1}_enableClick(t){this._allowGraphSelect=!0}_selectedNodeChanged(){var t=this.selectedNode;this.handleNodeSelected&&this.handleNodeSelected(t)}_selectedEdgeChanged(){var t=this.selectedEdge;this._deselectPreviousEdge(),t&&(this._lastSelectedEdgeGroup.classed(Hi.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(t)),this.handleEdgeSelected&&this.handleEdgeSelected(t)}_nodeSelected(t){this._allowGraphSelect&&this.set("selectedNode",t.detail.name),this._allowGraphSelect=!0}_edgeSelected(t){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",t.detail.edgeGroup),this.set("selectedEdge",t.detail.edgeData)),this._allowGraphSelect=!0}_nodeHighlighted(t){this.set("highlightedNode",t.detail.name)}_nodeUnhighlighted(t){this.set("highlightedNode",null)}_nodeToggleExpand(t){this._nodeSelected(t);var r=t.detail.name,n=this.renderHierarchy.getRenderNodeByName(r);n.node.type!==jt.OP&&(this.renderHierarchy.buildSubhierarchy(r),n.expanded=!n.expanded,this.async(function(){this.$.scene.setNodeExpanded(n)},75),Po({actionId:jr.NODE_EXPANSION_TOGGLED,eventLabel:n.expanded?"expanded":"collapsed"}))}_nodeToggleExtract(t){var r=t.detail.name;this.nodeToggleExtract(r)}nodeToggleExtract(t){let r=this.renderHierarchy.getRenderNodeByName(t);r.node.include==ur.INCLUDE?r.node.include=ur.EXCLUDE:r.node.include==ur.EXCLUDE?r.node.include=ur.INCLUDE:r.node.include=this.renderHierarchy.isNodeAuxiliary(r)?ur.INCLUDE:ur.EXCLUDE,this._buildRenderHierarchy(this.graphHierarchy),Po({actionId:jr.NODE_AUXILIARY_EXTRACTION_CHANGED,eventLabel:r.node.include===ur.INCLUDE?"Auxiliary to Main":"Main to Auxiliary"})}_nodeToggleSeriesGroup(t){var r=t.detail.name;this.nodeToggleSeriesGroup(r)}nodeToggleSeriesGroup(t){this.set("progress",{value:0,msg:""});var r=nP(this),n=JS(r,100,"Namespace hierarchy");let i=yh(ia({},this.hierarchyParams),{seriesMap:this.graphHierarchy.buildSeriesGroupMapToggled(t)});bH(this.basicGraph,i,n).then(function(o){this.set("graphHierarchy",o),this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))}_deselectPreviousEdge(){let t="."+Hi.Edge.SELECTED;Ht(t).classed(Hi.Edge.SELECTED,!1).each((r,n)=>{if(r.label){let i=Ht(this).selectAll("path.edgeline");r.label.startMarkerId&&i.style("marker-start",`url(#${r.label.startMarkerId})`),r.label.endMarkerId&&i.style("marker-end",`url(#${r.label.endMarkerId})`)}})}_updateMarkerOfSelectedEdge(t){var r;if(t.label){let n=t.label.startMarkerId||t.label.endMarkerId;if(n){let i=n.replace("dataflow-","selected-"),o=this.$$("#"+i);if(!o){let s=this.$.scene.querySelector("#"+n);o=s==null?void 0:s.cloneNode(!0),o.setAttribute("id",i),o.classList.add("selected-arrowhead"),(r=s==null?void 0:s.parentNode)==null||r.appendChild(o)}let a=t.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(a,`url(#${i})`)}}}not(t){return!t}};Dr.template=Q`
    <style>
      .container {
        width: 100%;
        height: 100%;
        background: white;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
      }

      .vertical {
        width: 100%;
        height: 100%;
        @apply --layout-vertical;
      }

      .auto {
        @apply --layout-flex-auto;
        @apply --layout-vertical;
      }

      h2 {
        text-align: center;
      }

      paper-button {
        text-transform: none;
      }
    </style>
    <div class="container">
      <div class="vertical">
        <template is="dom-if" if="[[title]]">
          <h2>[[title]]</h2>
        </template>
        <tf-graph-scene
          id="scene"
          class="auto"
          render-hierarchy="[[renderHierarchy]]"
          highlighted-node="[[_getVisible(highlightedNode)]]"
          selected-node="{{selectedNode}}"
          selected-edge="{{selectedEdge}}"
          color-by="[[colorBy]]"
          progress="[[progress]]"
          node-context-menu-items="[[nodeContextMenuItems]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="{{healthPillStepIndex}}"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
        ></tf-graph-scene>
      </div>
    </div>
  `;E([A({type:Object,notify:!0,observer:"_graphChanged"}),w("design:type",as)],Dr.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],Dr.prototype,"basicGraph",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"devicesForStats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"hierarchyParams",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"progress",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"title",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"selectedNode",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"selectedEdge",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"_lastSelectedEdgeGroup",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"highlightedNode",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"colorBy",void 0);E([A({type:Object,notify:!0,readOnly:!0}),w("design:type",Object)],Dr.prototype,"colorByParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",lo)],Dr.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"autoExtractNodes",void 0);E([A({type:Array}),w("design:type",Array)],Dr.prototype,"nodeContextMenuItems",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"_renderDepth",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"_allowGraphSelect",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"healthPillStepIndex",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeWidthFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleEdgeSelected",void 0);E([Bt("autoExtractNodes"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_autoExtractNodesChanged",null);E([Bt("graphHierarchy","edgeWidthFunction","handleNodeSelected","edgeLabelFunction","handleEdgeSelected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_buildNewRenderHierarchy",null);E([Bt("stats","devicesForStats"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_statsChanged",null);E([Bt("selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedNodeChanged",null);E([Bt("selectedEdge"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedEdgeChanged",null);Dr=E([yt("tf-graph")],Dr);var co=class extends Gt(mt){constructor(){super(...arguments),this.specificHealthPillStep=0,this.healthPillEntries=fP}ready(){super.ready();var t=document.getElementById("mainContainer"),r=document.querySelector("tf-dashboard-layout .scrollbar");t&&r&&(t.style.overflow="hidden",r.style.overflow="hidden")}_healthPillsAvailable(t,r){return t&&r}_computeTensorCountString(t,r){return t?t[r].toFixed(0):""}get healthPillValuesForSelectedNode(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.selectedNode,i=this.allStepsModeEnabled,o=this.areHealthPillsLoading;if(o||!n)return null;let a=t[n];if(!a)return null;let s=a[i?0:r];return s?s.value.slice(2,8):null}get _currentStepDisplayValue(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.allStepsModeEnabled,i=this.specificHealthPillStep,o=this.areHealthPillsLoading;if(n)return i.toFixed(0);if(o)return 0;for(let a in t)return t[a][r].step.toFixed(0);return 0}get _biggestStepEverSeen(){var t=this.nodeNamesToHealthPills;for(let n in t){var r=t[n];return Math.max(this._biggestStepEverSeen,r[r.length-1].step)}return this._biggestStepEverSeen||0}get _maxStepIndex(){var t=this.nodeNamesToHealthPills;for(let r in t)return t[r].length-1;return 0}_hasDebuggerNumericAlerts(t){return t&&t.length}_updateAlertsList(){var t=this.debuggerNumericAlerts,r=this.$$("#numeric-alerts-body");if(!!r){r.innerText="";for(var n=0;n<t.length;n++){var i=t[n],o=document.createElement("tr"),a=document.createElement("td");a.innerText=Qse(i.first_timestamp),a.classList.add("first-offense-td"),o.appendChild(a);var s=document.createElement("td");s.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table"),l.innerText=i.tensor_name,this._addOpExpansionListener(l,i.tensor_name),s.appendChild(l);var c=document.createElement("div");c.classList.add("device-section-within-table"),c.innerText="("+i.device_name+")",s.appendChild(c),o.appendChild(s);var u=document.createElement("div");u.classList.add("mini-health-pill");var h=document.createElement("td");if(h.classList.add("mini-health-pill-td"),h.appendChild(u),o.appendChild(h),i.neg_inf_event_count){var f=document.createElement("div");f.classList.add("negative-inf-mini-health-pill-section"),f.innerText=i.neg_inf_event_count,f.setAttribute("title",i.neg_inf_event_count+" events with -\u221E"),u.appendChild(f)}if(i.pos_inf_event_count){var p=document.createElement("div");p.classList.add("positive-inf-mini-health-pill-section"),p.innerText=i.pos_inf_event_count,p.setAttribute("title",i.pos_inf_event_count+" events with +\u221E"),u.appendChild(p)}if(i.nan_event_count){var d=document.createElement("div");d.classList.add("nan-mini-health-pill-section"),d.innerText=i.nan_event_count,d.setAttribute("title",i.nan_event_count+" events with NaN"),u.appendChild(d)}zt(r).appendChild(o)}}}_addOpExpansionListener(t,r){t.addEventListener("click",()=>{var n=xle(document.getElementById("scene"),this.renderHierarchy,r),i,o=document.querySelector("tf-graph-info#graph-info");o&&(i=o.scrollHeight-o.scrollTop);var a=this.selectedNode;this.set("selectedNode",n);var s=()=>{o.scrollTop=o.scrollHeight-i};o&&(a?s():window.setTimeout(s,20))})}};co.template=Q`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }

      .health-pill-legend {
        padding: 15px;
      }

      .health-pill-legend h2 {
        text-align: left;
      }

      .health-pill-entry {
        margin: 10px 10px 10px 0;
      }

      .health-pill-entry .color-preview {
        width: 26px;
        height: 26px;
        border-radius: 3px;
        display: inline-block;
        margin: 0 10px 0 0;
      }

      .health-pill-entry .color-label,
      .health-pill-entry .tensor-count {
        color: #777;
        display: inline-block;
        height: 26px;
        font-size: 22px;
        line-height: 26px;
        vertical-align: top;
      }

      .health-pill-entry .tensor-count {
        float: right;
      }

      #health-pill-step-slider {
        width: 100%;
        margin: 0 0 0 -15px;
        /* 31 comes from adding a padding of 15px from both sides of the paper-slider, subtracting
   * 1px so that the slider width aligns with the image (the last slider marker takes up 1px),
   * and adding 2px to account for a border of 1px on both sides of the image. 30 - 1 + 2.
   * Apparently, the paper-slider lacks a mixin for those padding values. */
        width: calc(100% + 31px);
      }

      #health-pills-loading-spinner {
        width: 20px;
        height: 20px;
        vertical-align: top;
      }

      #health-pill-step-number-input {
        text-align: center;
        vertical-align: top;
      }

      #numeric-alerts-table-container {
        max-height: 400px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      #numeric-alerts-table {
        text-align: left;
      }

      #numeric-alerts-table td {
        vertical-align: top;
      }

      #numeric-alerts-table .first-offense-td {
        display: inline-block;
      }

      .first-offense-td {
        width: 80px;
      }

      .tensor-device-td {
        max-width: 140px;
        word-wrap: break-word;
      }

      .tensor-section-within-table {
        color: #266236;
        cursor: pointer;
        opacity: 0.8;
        text-decoration: underline;
      }

      .tensor-section-within-table:hover {
        opacity: 1;
      }

      .device-section-within-table {
        color: #666;
      }

      .mini-health-pill {
        width: 130px;
      }

      .mini-health-pill > div {
        height: 100%;
        width: 60px;
        border-radius: 3px;
      }

      #event-counts-th {
        padding: 0 0 0 10px;
      }

      .negative-inf-mini-health-pill-section {
        background: rgb(255, 141, 0);
        width: 20px;
      }

      .positive-inf-mini-health-pill-section {
        background: rgb(0, 62, 212);
        width: 20px;
      }

      .nan-mini-health-pill-section {
        background: rgb(204, 47, 44);
        width: 20px;
      }

      .negative-inf-mini-health-pill-section,
      .positive-inf-mini-health-pill-section,
      .nan-mini-health-pill-section {
        color: #fff;
        display: inline-block;
        height: 100%;
        line-height: 20px;
        margin: 0 0 0 10px;
        text-align: center;
      }

      .no-numeric-alerts-notification {
        margin: 0;
      }
    </style>
    <paper-material elevation="1" class="card health-pill-legend">
      <div class="title">
        Enable all (not just sampled) steps. Requires slow disk read.
      </div>
      <paper-toggle-button
        id="enableAllStepsModeToggle"
        checked="{{allStepsModeEnabled}}"
      >
      </paper-toggle-button>
      <h2>
        Step of Health Pills:
        <template is="dom-if" if="[[allStepsModeEnabled]]">
          <input
            type="number"
            id="health-pill-step-number-input"
            min="0"
            max="[[_biggestStepEverSeen]]"
            value="{{specificHealthPillStep::input}}"
          />
        </template>
        <template is="dom-if" if="[[!allStepsModeEnabled]]">
          [[_currentStepDisplayValue]]
        </template>
        <paper-spinner-lite
          active
          hidden$="[[!areHealthPillsLoading]]"
          id="health-pills-loading-spinner"
        ></paper-spinner-lite>
      </h2>
      <template is="dom-if" if="[[allStepsModeEnabled]]">
        <paper-slider
          id="health-pill-step-slider"
          immediate-value="{{specificHealthPillStep}}"
          max="[[_biggestStepEverSeen]]"
          snaps
          step="1"
          value="{{specificHealthPillStep}}"
        ></paper-slider>
      </template>
      <template is="dom-if" if="[[!allStepsModeEnabled]]">
        <template is="dom-if" if="[[_maxStepIndex]]">
          <paper-slider
            id="health-pill-step-slider"
            immediate-value="{{healthPillStepIndex}}"
            max="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{healthPillStepIndex}}"
          ></paper-slider>
        </template>
      </template>
      <h2>
        Health Pill
        <template is="dom-if" if="[[healthPillValuesForSelectedNode]]">
          Counts for Selected Node
        </template>
        <template is="dom-if" if="[[!healthPillValuesForSelectedNode]]">
          Legend
        </template>
      </h2>
      <template is="dom-repeat" items="[[healthPillEntries]]">
        <div class="health-pill-entry">
          <div
            class="color-preview"
            style="background:[[item.background_color]]"
          ></div>
          <div class="color-label">[[item.label]]</div>
          <div class="tensor-count">
            [[_computeTensorCountString(healthPillValuesForSelectedNode,
            index)]]
          </div>
        </div>
      </template>
      <div hidden$="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]">
        <h2 id="numeric-alerts-header">Numeric Alerts</h2>
        <p>Alerts are sorted from top to bottom by increasing timestamp.</p>
        <div id="numeric-alerts-table-container">
          <table id="numeric-alerts-table">
            <thead>
              <tr>
                <th>First Offense</th>
                <th>Tensor (Device)</th>
                <th id="event-counts-th">Event Counts</th>
              </tr>
            </thead>
            <tbody id="numeric-alerts-body"></tbody>
          </table>
        </div>
      </div>
      <template
        is="dom-if"
        if="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]"
      >
        <p class="no-numeric-alerts-notification">
          No numeric alerts so far. That is likely good. Alerts indicate the
          presence of NaN or (+/-) Infinity values, which may be concerning.
        </p>
      </template>
    </paper-material>
  `;E([A({type:Object}),w("design:type",lo)],co.prototype,"renderHierarchy",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],co.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],co.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"healthPillStepIndex",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],co.prototype,"specificHealthPillStep",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Object)],co.prototype,"areHealthPillsLoading",void 0);E([A({type:Array}),w("design:type",Array)],co.prototype,"healthPillEntries",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Object)],co.prototype,"allStepsModeEnabled",void 0);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","selectedNode","allStepsModeEnabled","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"healthPillValuesForSelectedNode",null);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","allStepsModeEnabled","specificHealthPillStep","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"_currentStepDisplayValue",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_biggestStepEverSeen",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_maxStepIndex",null);E([Bt("debuggerNumericAlerts"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],co.prototype,"_updateAlertsList",null);co=E([yt("tf-graph-debugger-data-card")],co);var oct={};Zs(oct,{GraphIconType:()=>i1});var i1;(function(e){e.CONST="CONST",e.META="META",e.OP="OP",e.SERIES="SERIES",e.SUMMARY="SUMMARY"})(i1||(i1={}));var Zu=class extends Gt(_o(mt)){constructor(){super(...arguments),this.vertical=!1,this.fillOverride=null,this.strokeOverride=null,this.height=20,this.faded=!1}getSvgDefinableElement(){return this.$.svgDefs}get _fill(){var t=this.type,r=this.fillOverride;if(r!=null)return r;switch(t){case i1.META:return Ku.DEFAULT_FILL;case i1.SERIES:return Vlt.DEFAULT_FILL;default:return v0.DEFAULT_FILL}}get _stroke(){var t=this.type,r=this.strokeOverride;if(r!=null)return r;switch(t){case i1.META:return Ku.DEFAULT_STROKE;case i1.SERIES:return Vlt.DEFAULT_STROKE;default:return v0.DEFAULT_STROKE}}_isType(t,r){return t===r}_fadedClass(t,r){return t?"faded-"+r:""}};Zu.template=Q`
    <style>
      :host {
        font-size: 0;
      }

      :host(.dark-mode) svg {
        filter: invert(1);
      }

      .faded-rect {
        fill: url(#rectHatch);
      }

      .faded-ellipse {
        fill: url(#ellipseHatch);
      }

      .faded-rect,
      .faded-ellipse,
      .faded-series {
        stroke: var(--tb-graph-faded) !important;
      }
      #rectHatch line,
      #ellipseHatch line {
        color: #e0d4b3 !important;
        fill: white;
        stroke: #e0d4b3 !important;
      }
    </style>
    <!-- SVG for definitions -->
    <svg height="0" width="0" id="svgDefs">
      <defs>
        <!-- Hatch patterns for faded out nodes. -->
        <pattern
          id="rectHatch"
          patternTransform="rotate(45 0 0)"
          width="5"
          height="5"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
        </pattern>
        <pattern
          id="ellipseHatch"
          patternTransform="rotate(45 0 0)"
          width="2"
          height="2"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
        </pattern>
        <!-- Template for an Op node ellipse. -->
        <ellipse
          id="op-node-stamp"
          rx="7.5"
          ry="3"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Template for an Op node annotation ellipse (smaller). -->
        <ellipse
          id="op-node-annotation-stamp"
          rx="5"
          ry="2"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Vertically stacked series of Op nodes when unexpanded. -->
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9"></use>
          <use xlink:href="#op-node-stamp" x="8" y="6"></use>
          <use xlink:href="#op-node-stamp" x="8" y="3"></use>
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4"></use>
          <use xlink:href="#op-node-stamp" x="12" y="4"></use>
          <use xlink:href="#op-node-stamp" x="8" y="4"></use>
        </g>
        <g
          id="summary-icon"
          fill="#848484"
          height="12"
          viewBox="0 0 24 24"
          width="12"
        >
          <path
            d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
          ></path>
        </g>
      </defs>
    </svg>
    <template is="dom-if" if="[[_isType(type, 'CONST')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 10 10"
      >
        <circle
          cx="5"
          cy="5"
          r="3"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
        ></circle>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SUMMARY')]]">
      <svg
        width$="[[height]]"
        height$="[[height]]"
        viewBox="0 0 24 24"
        fill="#848484"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'OP')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 16 8"
      >
        <use
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xlink:href="#op-node-stamp"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'ellipse')}}"
          x="8"
          y="4"
        ></use>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'META')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 37 16"
      >
        <rect
          x="1"
          y="1"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'rect')}}"
          stroke-width="2px"
          height="14"
          width="35"
          rx="5"
          ry="5"
        ></rect>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SERIES')]]">
      <template is="dom-if" if="[[vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 16 15"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-vertical-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="2"
          ></use>
        </svg>
      </template>
      <template is="dom-if" if="[[!vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 24 10"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-horizontal-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="1"
          ></use>
        </svg>
      </template>
    </template>
  `;E([A({type:String}),w("design:type",String)],Zu.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"vertical",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"fillOverride",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"strokeOverride",void 0);E([A({type:Number}),w("design:type",Number)],Zu.prototype,"height",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"faded",void 0);E([Rt("type","fillOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_fill",null);E([Rt("type","strokeOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_stroke",null);Zu=E([yt("tf-graph-icon")],Zu);var Hs=class extends Gt(mt){constructor(){super(...arguments),this.node=null,this.renderInfo=null,this.colorBy=Gn.STRUCTURE,this.templateIndex=null,this.type=null,this.vertical=!1,this.const=!1,this.summary=!1,this.fill=null,this.height=20}_computeFillOverride(t,r,n,i,o){return t&&r&&i?kH(i,n,r,!1):o}_getStrokeOverride(t){return t?tct(t):null}_getType(t,r,n,i){let{GraphIconType:o}=oct;if(t)switch(t.type){case jt.OP:{let a=t.op;return typeof a!="string"?o.OP:a==="Const"||n?o.CONST:a.endsWith("Summary")||r?o.SUMMARY:o.OP}case jt.META:return o.META;case jt.SERIES:return o.SERIES}return i}_isVertical(t,r){return t?t.hasNonControlEdges:!!r}_getFaded(t){return t&&t.isFadedOut}_onFillOverrideChanged(t,r){let{node:n,renderInfo:i,colorBy:o,templateIndex:a}=this;t!==r&&LH(this.$.icon.getSvgDefinableElement()),n&&i&&a&&kH(a,o,i,!1,this.$.icon.getSvgDefinableElement())}};Hs.template=Q`
    <style>
      tf-graph-icon {
        --tb-graph-faded: var(--tb-graph-faded);
      }
    </style>
    <tf-graph-icon
      id="icon"
      type="[[_getType(node, summary, const, type)]]"
      height="[[height]]"
      fill-override="[[_fillOverride]]"
      stroke-override="[[_getStrokeOverride(_fillOverride)]]"
      faded="[[_getFaded(renderInfo)]]"
      vertical="[[_isVertical(node, vertical)]]"
    ></tf-graph-icon>
  `;E([A({type:Object}),w("design:type",Object)],Hs.prototype,"node",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"renderInfo",void 0);E([A({type:Object}),w("design:type",String)],Hs.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"templateIndex",void 0);E([A({type:String}),w("design:type",Object)],Hs.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hs.prototype,"vertical",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hs.prototype,"const",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hs.prototype,"summary",void 0);E([A({type:String}),w("design:type",Object)],Hs.prototype,"fill",void 0);E([A({type:Number}),w("design:type",Number)],Hs.prototype,"height",void 0);E([A({type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}),w("design:type",String)],Hs.prototype,"_fillOverride",void 0);Hs=E([yt("tf-node-icon")],Hs);var Gc=class extends Gt(mt){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Gc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>

    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        >
        </tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Gc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Gc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Function)],Gc.prototype,"templateIndex",void 0);Gc=E([yt("tf-graph-op-compat-list-item")],Gc);var ss=class extends Gt(_o(mt)){constructor(){super(...arguments),this._expanded=!0,this._opCompatColor=v0.COMPATIBLE,this._opIncompatColor=v0.INCOMPATIBLE,this._templateIndex=null}_getNode(t,r){return r.node(t)}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}get _incompatibleOpNodes(){let t=this.graphHierarchy;return!t||!t.root?[]:(this.async(this._resizeList.bind(this,"#incompatibleOpsList")),dle(t))}get _opCompatScore(){var t=this.graphHierarchy;if(t&&t.root){var r=t.root,n=r.compatibilityHistogram.compatible,i=r.compatibilityHistogram.incompatible;if(n==0&&i==0)return 0;var o=n+i;return Math.floor(100*n/o)/100}return 0}get _opCompatScoreLabel(){var t=this._opCompatScore;return xn(".0%")(t)}get _totalIncompatOps(){var t=this.graphHierarchy;return t&&t.root?t.root.compatibilityHistogram.incompatible:0}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Od.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};ss.template=Q`
    <style>
      :host {
        max-height: 500px;
      }

      .incompatible-ops-list {
        height: 350px;
        max-height: 400px;
        overflow-y: scroll;
        display: flex;
        flex-direction: column;
      }

      iron-list {
        flex: 1 1 auto;
      }

      paper-item {
        padding: 0;
        background: var(--secondary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
        font-weight: 500;
        font-size: 12pt;
        width: 100%;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .non-control-list-item {
        padding-left: 10px;
      }

      div.op-compat-display {
        margin-top: 10px;
        display: inline-block;
      }

      /**
       * Sadly, because the whole body is inverted in color, legends also need
       * to be inverted.
       **/
      :host(.dark-mode) div.op-compat-display {
        filter: invert(1);
      }

      svg.op-compat {
        width: 250px;
        height: 25px;
        float: left;
      }

      div.op-compat-value {
        float: right;
        height: 100%;
        font-size: 14px;
        color: black;
        margin-left: 10px;
      }
    </style>

    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name" id="nodetitle">[[nodeTitle]]</div>
        </div>
        <div secondary>
          <div class="subtitle">
            <div class="op-compat-display">
              <svg
                class="op-compat"
                preserveAspectRatio="xMinYMid meet"
                viewBox="0 0 250 25"
              >
                <defs>
                  <linearGradient id="op-compat-fill">
                    <stop offset="0" stop-color$="[[_opCompatColor]]"></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opCompatColor]]"
                    ></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opIncompatColor]]"
                    ></stop>
                    <stop offset="1" stop-color$="[[_opIncompatColor ]]"></stop>
                  </linearGradient>
                </defs>
                <rect
                  height="25"
                  width="250"
                  rx="5"
                  ry="5"
                  style="fill: url('#op-compat-fill');"
                ></rect>
              </svg>
              <div class="op-compat-value">[[_opCompatScoreLabel]]</div>
            </div>
          </div>
        </div>
      </paper-item-body>
    </paper-item>

    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          Incompatible Operations: (<span>[[_totalIncompatOps]]</span>)
          <iron-list
            class="incompatible-ops-list"
            id="incompatibleOpsList"
            items="[[_incompatibleOpNodes]]"
          >
            <template>
              <tf-graph-op-compat-list-item
                class="non-control-list-item"
                item-node="[[item]]"
                item-render-info="[[_getRenderInfo(item.name, renderHierarchy)]]"
                name="[[item.name]]"
                template-index="[[_templateIndex]]"
                color-by="[[colorBy]]"
                item-type="incompatible-ops"
              >
              </tf-graph-op-compat-list-item>
            </template>
          </iron-list>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:Object}),w("design:type",as)],ss.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",lo)],ss.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"nodeTitle",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ss.prototype,"_expanded",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"_opCompatColor",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"_opIncompatColor",void 0);E([A({type:Object}),w("design:type",Object)],ss.prototype,"_templateIndex",void 0);E([Rt("graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],ss.prototype,"_incompatibleOpNodes",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],ss.prototype,"_opCompatScore",null);E([Rt("_opCompatScore"),w("design:type",String),w("design:paramtypes",[])],ss.prototype,"_opCompatScoreLabel",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],ss.prototype,"_totalIncompatOps",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ss.prototype,"_graphHierarchyChanged",null);ss=E([yt("tf-graph-op-compat-card")],ss);var l3=Ee(Oe(),1);var Wc=class extends Gt(_o(mt)){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{cardNode:this.cardNode.name,nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Wc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      :host(.dark-mode) #list-item:hover {
        background-color: var(--paper-yellow-900);
        color: #fff;
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>
    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        ></tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Wc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Wc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"templateIndex",void 0);Wc=E([yt("tf-node-list-item")],Wc);var dn=class extends Gt(mt){constructor(){super(...arguments),this._expanded=!0,this._openedControlPred=!1,this._openedControlSucc=!1,this._templateIndex=null}expandNode(){this.fire("_node.expand",this.node)}_getNode(t,r){return r.node(t)}_getNodeStats(t,r){var n=this._getNode(t,r);return n?n.stats:null}_getTotalMicros(t){return t?t.getTotalMicros():0}get _hasDisplayableNodeStats(){var t=this._nodeStats;return gH(t)}get _nodeStatsFormattedBytes(){var t=this._nodeStats;if(!(!t||!t.totalBytes))return Dd(t.totalBytes,iP)}get _nodeStatsFormattedComputeTime(){var t=this._nodeStats;if(!(!t||!t.getTotalMicros()))return Dd(t.getTotalMicros(),oP)}get _nodeStatsFormattedOutputSizes(){var t=this._nodeStats;if(!(!t||!t.outputSize||!t.outputSize.length))return l3.map(t.outputSize,function(r){return r.length===0?"scalar":"["+r.join(", ")+"]"})}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}get _attributes(){var t=this._node;if(this.async(this._resizeList.bind(this,"#attributesList")),!t||!t.attr)return[];var r=[];return l3.each(t.attr,function(n){n.key===ile?r=r.concat(n.value.list.s.map(function(i){return{key:i,value:"Too large to show..."}})):r.push({key:n.key,value:JSON.stringify(n.value)})}),r}get _device(){var t=this._node;return t?t.device:null}get _successors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("inputsList"),t?this._convertEdgeListToEdgeInfoList(r.getSuccessors(t.name),!1,t.isGroupNode):{regular:[],control:[]}}get _predecessors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("outputsList"),t?this._convertEdgeListToEdgeInfoList(r.getPredecessors(t.name),!0,t.isGroupNode):{regular:[],control:[]}}get _functionUsages(){var t=this._node,r=this.graphHierarchy;if(this._refreshNodeItemList("functionUsagesList"),!t||t.type!==jt.META)return[];let n=r.libraryFunctions[t.associatedFunction];return n?n.usages:[]}_refreshNodeItemList(t){this.async(this._resizeList.bind(this,`#${t}`))}_convertEdgeListToEdgeInfoList(t,r,n){var i=a=>l3.map(a.baseEdgeList,s=>{var l=r?s.v:s.w;return{name:l,node:this._getNode(l,this.graphHierarchy),edgeLabel:Ylt(s,this.renderHierarchy),renderInfo:this._getRenderInfo(l,this.renderHierarchy)}}),o=function(a){var s=[];return l3.each(a,l=>{var c=r?l.v:l.w;!n||l.baseEdgeList.length==1?s=s.concat(i(l)):s.push({name:c,node:this._getNode(c,this.graphHierarchy),edgeLabel:jlt(l,this.renderHierarchy),renderInfo:this._getRenderInfo(c,this.renderHierarchy)})}),s}.bind(this);return{regular:o(t.regular),control:o(t.control)}}get _subnodes(){var t=this._node;return t&&t.metagraph?t.metagraph.nodes():null}get _totalPredecessors(){var t=this._predecessors;return t.regular.length+t.control.length}get _totalSuccessors(){var t=this._successors;return t.regular.length+t.control.length}_toggleControlPred(){this._openedControlPred=!this._openedControlPred}_toggleControlSucc(){this._openedControlSucc=!this._openedControlSucc}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resetState(){this._openedControlPred=!1,this._openedControlSucc=!1,this.set("_groupButtonText",Qlt(this._node))}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}_toggleInclude(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})}_nodeIncludeStateChanged(t,r){this.set("_auxButtonText",yH(t))}_toggleGroup(){var t=IH(this._node);this.fire("node-toggle-seriesgroup",{name:t})}_isLibraryFunction(t){return t&&t.name.startsWith(Ma)}_isInSeries(t){return Jlt(t)}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Od.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};dn.template=Q`
    <style>
      .sub-list-group {
        font-weight: 500;
        font-size: 12pt;
        padding-bottom: 8px;
        width: 100%;
      }

      .sub-list {
        max-height: 300px;
        overflow-y: scroll;
      }

      .attr-left {
        float: left;
        width: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-weight: 400;
      }

      .sub-list-table {
        display: table;
        width: 100%;
      }

      .sub-list-table-row {
        display: table-row;
      }

      .sub-list-table-row .sub-list-table-cell:last-child {
        text-align: right;
      }

      .sub-list-table-cell {
        color: var(--secondary-text-color);
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: var(--primary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
      }

      .controlDeps {
        padding: 0 0 0 8px;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .node-icon {
        float: right;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .controlLine {
        font-size: 11pt;
        font-weight: 400;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .control-toggle-button {
        float: left;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-include-group {
        padding-top: 4px;
      }

      .toggle-include {
        margin: 5px 6px;
        text-transform: none;
        padding: 4px 6px;
        font-size: 10pt;
        background-color: #fafafa;
        color: #666;
      }

      .toggle-include:hover {
        background-color: var(--google-yellow-100);
      }

      .non-control-list-item {
        padding-left: 10px;
      }
    </style>
    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name">
            <tf-wbr-string value="[[_node.name]]" delimiter-pattern="/">
            </tf-wbr-string>
          </div>
        </div>
        <div secondary>
          <tf-node-icon
            class="node-icon"
            node="[[_node]]"
            render-info="[[_getRenderInfo(graphNodeName, renderHierarchy)]]"
            color-by="[[colorBy]]"
            template-index="[[_templateIndex]]"
          ></tf-node-icon>
          <template is="dom-if" if="{{_node.op}}">
            <div class="subtitle">
              Operation:
              <span>[[_node.op]]</span>
            </div>
          </template>
          <template is="dom-if" if="{{_node.metagraph}}">
            <div class="subtitle">
              Subgraph:
              <span>[[_node.cardinality]]</span> nodes
            </div>
          </template>
        </div>
      </paper-item-body>
    </paper-item>
    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          <div class="sub-list-group attributes">
            Attributes (<span>[[_attributes.length]]</span>)
            <iron-list
              class="sub-list"
              id="attributesList"
              items="[[_attributes]]"
            >
              <template>
                <div>
                  <div class="attr-left">[[item.key]]</div>
                  <div class="attr-right">[[item.value]]</div>
                </div>
              </template>
            </iron-list>
          </div>

          <template is="dom-if" if="{{_device}}">
            <div class="sub-list-group device">
              <div class="attr-left">Device</div>
              <div class="attr-right">[[_device]]</div>
            </div>
          </template>

          <div class="sub-list-group predecessors">
            Inputs (<span>[[_totalPredecessors]]</span>)
            <iron-list
              class="sub-list"
              id="inputsList"
              items="[[_predecessors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="predecessors"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_predecessors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlPred)}}"
                    on-click="_toggleControlPred"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlPred}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlPred}}"
                    restamp="true"
                  >
                    <iron-list
                      class="sub-list"
                      items="[[_predecessors.control]]"
                    >
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="predecessors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>

          <div class="sub-list-group successors">
            Outputs (<span>[[_totalSuccessors]]</span>)
            <iron-list
              class="sub-list"
              id="outputsList"
              items="[[_successors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="successor"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_successors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlSucc)}}"
                    on-click="_toggleControlSucc"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlSucc}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlSucc}}"
                    restamp="true"
                  >
                    <iron-list class="sub-list" items="[[_successors.control]]">
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="successors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>
          <template is="dom-if" if="{{_hasDisplayableNodeStats}}">
            <div class="sub-list-group node-stats">
              Node Stats
              <div class="sub-list-table">
                <template is="dom-if" if="{{_nodeStats.totalBytes}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Memory</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedBytes]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_getTotalMicros(_nodeStats)}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Compute Time</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedComputeTime]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_nodeStats.outputSize}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Tensor Output Sizes</div>
                    <div class="sub-list-table-cell">
                      <template
                        is="dom-repeat"
                        items="{{_nodeStatsFormattedOutputSizes}}"
                      >
                        [[item]] <br />
                      </template>
                    </div>
                  </div>
                </template>
              </div>
            </div>
          </template>

          <template is="dom-if" if="[[_functionUsages.length]]">
            <div class="sub-list-group predecessors">
              Usages of the Function (<span>[[_functionUsages.length]]</span>)
              <iron-list
                class="sub-list"
                id="functionUsagesList"
                items="[[_functionUsages]]"
              >
                <template>
                  <tf-node-list-item
                    class="non-control-list-item"
                    card-node="[[_node]]"
                    item-node="[[item]]"
                    name="[[item.name]]"
                    item-type="functionUsages"
                    color-by="[[colorBy]]"
                    template-index="[[_templateIndex]]"
                  >
                  </tf-node-list-item>
                </template>
              </iron-list>
            </div>
          </template>

          <template is="dom-if" if="[[!_isLibraryFunction(_node)]]">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleInclude"
              >
                <span>[[_auxButtonText]]</span>
              </paper-button>
            </div>
          </template>

          <template is="dom-if" if="{{_isInSeries(_node)}}">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleGroup"
              >
                <span>[[_groupButtonText]]</span>
              </paper-button>
            </div>
          </template>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:String}),w("design:type",String)],dn.prototype,"graphNodeName",void 0);E([A({type:Object}),w("design:type",as)],dn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],dn.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"colorBy",void 0);E([A({type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_node",void 0);E([A({type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_nodeStats",void 0);E([A({type:Number,observer:"_nodeIncludeStateChanged"}),w("design:type",Number)],dn.prototype,"nodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlPred",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlSucc",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_auxButtonText",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_groupButtonText",void 0);E([A({type:Object}),w("design:type",Function)],dn.prototype,"_templateIndex",void 0);E([Rt("_nodeStats"),w("design:type",Boolean),w("design:paramtypes",[])],dn.prototype,"_hasDisplayableNodeStats",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedBytes",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedComputeTime",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedOutputSizes",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_attributes",null);E([Rt("_node"),w("design:type",String),w("design:paramtypes",[])],dn.prototype,"_device",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_successors",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_predecessors",null);E([Rt("_node","graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_functionUsages",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_subnodes",null);E([Rt("_predecessors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalPredecessors",null);E([Rt("_successors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalSuccessors",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dn.prototype,"_graphHierarchyChanged",null);dn=E([yt("tf-node-info")],dn);var ls=class extends Gt(mt){ready(){super.ready(),this.addEventListener("node-list-item-click",this._nodeListItemClicked.bind(this)),this.addEventListener("node-list-item-mouseover",this._nodeListItemMouseover.bind(this)),this.addEventListener("node-list-item-mouseout",this._nodeListItemMouseout.bind(this))}_nodeListItemClicked(t){this.selectedNode=t.detail.nodeName}_nodeListItemMouseover(t){this.highlightedNode=t.detail.nodeName}_nodeListItemMouseout(){this.highlightedNode=null}_healthPillsAvailable(t,r){return t&&r&&Object.keys(r).length>0}_equals(t,r){return t===r}};ls.template=Q`
    <style>
      :host {
        background: var(--secondary-background-color);
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
        max-height: 650px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }
    </style>
    <template is="dom-if" if="{{selectedNode}}">
      <paper-material elevation="1" class="card">
        <tf-node-info
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          flat-graph="[[graph]]"
          graph-node-name="[[selectedNode]]"
          node-include="[[selectedNodeInclude]]"
          highlighted-node="{{highlightedNode}}"
          color-by="[[colorBy]]"
        >
        </tf-node-info>
      </paper-material>
    </template>
    <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
      <tf-graph-op-compat-card
        graph-hierarchy="[[graphHierarchy]]"
        render-hierarchy="[[renderHierarchy]]"
        color-by="[[colorBy]]"
        node-title="[[compatNodeTitle]]"
      >
      </tf-graph-op-compat-card>
    </template>
    <template
      is="dom-if"
      if="[[_healthPillsAvailable(debuggerDataEnabled, nodeNamesToHealthPills)]]"
    >
      <tf-graph-debugger-data-card
        render-hierarchy="[[renderHierarchy]]"
        debugger-numeric-alerts="[[debuggerNumericAlerts]]"
        node-names-to-health-pills="[[nodeNamesToHealthPills]]"
        selected-node="{{selectedNode}}"
        highlighted-node="{{highlightedNode}}"
        are-health-pills-loading="[[areHealthPillsLoading]]"
        all-steps-mode-enabled="{{allStepsModeEnabled}}"
        specific-health-pill-step="{{specificHealthPillStep}}"
        health-pill-step-index="{{healthPillStepIndex}}"
      >
      </tf-graph-debugger-data-card>
    </template>
  `;E([A({type:String}),w("design:type",String)],ls.prototype,"title",void 0);E([A({type:Object}),w("design:type",as)],ls.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],ls.prototype,"graph",void 0);E([A({type:Object}),w("design:type",lo)],ls.prototype,"renderHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ls.prototype,"healthPillStepIndex",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"colorBy",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"compatNodeTitle",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ls.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ls.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ls.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"debuggerDataEnabled",void 0);ls=E([yt("tf-graph-info")],ls);var cur={MAX_NODE_COUNT:1e4,MAX_EDGE_COUNT:1e4},tn=class extends Gt(mt){constructor(){super(...arguments),this.hierarchyParams=r3,this.allStepsModeEnabled=!1,this.specificHealthPillStep=0,this.compatNodeTitle="TPU Compatibility"}fit(){this.$.graph.fit()}downloadAsImage(t){return Ri(this,null,function*(){let r=yield this.$.graph.getImageBlob(),n=document.createElement("a");n.href=URL.createObjectURL(r),n.download=t,n.click(),URL.revokeObjectURL(n.href)})}_isNotComplete(t){return t.value<100}_getContainerClass(t){var r="container";return t.error&&(r+=" error"),this._isNotComplete(t)&&(r+=" loading"),r}_onNodeInclusionToggled(t){this.$.graph.nodeToggleExtract(t.detail.name)}_onNodeSeriesGroupToggled(t){this.$.graph.nodeToggleSeriesGroup(t.detail.name)}_updateNodeInclude(){let t=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=t?t.include:ur.UNSPECIFIED}_slimGraphChanged(){if(!this.graph)return;let{MAX_NODE_COUNT:t,MAX_EDGE_COUNT:r}=cur;Object.keys(this.graph.nodes).length>t&&this.graph.edges.length>r&&this.colorBy===Gn.STRUCTURE&&(this.colorBy=Gn.NONE)}_ensureTemplates(){!this.graphHierarchy||this.colorBy!==Gn.STRUCTURE||this.graphHierarchy.getTemplateIndex()||this.graphHierarchy.updateTemplates()}};tn.template=Q`
    <style>
      ::host {
        display: block;
      }

      /deep/ .close {
        position: absolute;
        cursor: pointer;
        left: 15px;
        bottom: 15px;
      }

      .container {
        width: 100%;
        height: 100%;
        opacity: 1;
      }

      .container.loading {
        cursor: progress;
        opacity: 0.1;
      }

      .container.loading.error {
        cursor: auto;
      }

      #info {
        position: absolute;
        right: 5px;
        top: 5px;
        padding: 0px;
        max-width: 380px;
        min-width: 320px;
        background-color: rgba(255, 255, 255, 0.9);
        @apply --shadow-elevation-2dp;
      }

      #main {
        width: 100%;
        height: 100%;
      }

      #progress-bar {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100%;
        position: absolute;
        top: 40px;
        left: 0;
        font-size: 13px;
      }

      #progress-msg {
        margin-bottom: 5px;
        white-space: pre-wrap;
        width: 400px;
      }

      paper-progress {
        width: 400px;
        --paper-progress-height: 6px;
        --paper-progress-active-color: #f3913e;
      }

      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }

      /deep/ .context-menu ul {
        list-style-type: none;
        margin: 0;
        padding: 0;
        cursor: default;
      }

      /deep/ .context-menu ul li {
        padding: 4px 16px;
      }

      /deep/ .context-menu ul li:hover {
        background-color: #f3913e;
        color: white;
      }
    </style>
    <template is="dom-if" if="[[_isNotComplete(progress)]]">
      <div id="progress-bar">
        <div id="progress-msg">[[progress.msg]]</div>
        <paper-progress value="[[progress.value]]"></paper-progress>
      </div>
    </template>
    <div class$="[[_getContainerClass(progress)]]">
      <div id="main">
        <tf-graph
          id="graph"
          graph-hierarchy="{{graphHierarchy}}"
          basic-graph="[[graph]]"
          hierarchy-params="[[hierarchyParams]]"
          render-hierarchy="{{renderHierarchy}}"
          devices-for-stats="[[devicesForStats]]"
          stats="[[stats]]"
          selected-node="{{selectedNode}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="{{colorByParams}}"
          progress="{{progress}}"
          edge-label-function="[[edgeLabelFunction]]"
          edge-width-function="[[edgeWidthFunction]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="[[healthPillStepIndex]]"
          handle-node-selected="[[handleNodeSelected]]"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
          auto-extract-nodes="[[autoExtractNodes]]"
        ></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info
          id="graph-info"
          title="selected"
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          graph="[[graph]]"
          selected-node="{{selectedNode}}"
          selected-node-include="{{_selectedNodeInclude}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          debugger-data-enabled="[[debuggerDataEnabled]]"
          are-health-pills-loading="[[areHealthPillsLoading]]"
          debugger-numeric-alerts="[[debuggerNumericAlerts]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          all-steps-mode-enabled="{{allStepsModeEnabled}}"
          specific-health-pill-step="{{specificHealthPillStep}}"
          health-pill-step-index="{{healthPillStepIndex}}"
          compat-node-title="[[compatNodeTitle]]"
          on-node-toggle-inclusion="_onNodeInclusionToggled"
          on-node-toggle-seriesgroup="_onNodeSeriesGroupToggled"
        ></tf-graph-info>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",as)],tn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],tn.prototype,"graph",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"hierarchyParams",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"progress",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"autoExtractNodes",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],tn.prototype,"colorByParams",void 0);E([A({type:Object,notify:!0}),w("design:type",lo)],tn.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],tn.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],tn.prototype,"allStepsModeEnabled",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],tn.prototype,"specificHealthPillStep",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"healthPillStepIndex",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"compatNodeTitle",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeWidthFunction",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"_selectedNodeInclude",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"_highlightedNode",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleEdgeSelected",void 0);E([Bt("selectedNode","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_updateNodeInclude",null);E([Bt("graph"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_slimGraphChanged",null);E([Bt("colorBy","graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_ensureTemplates",null);tn=E([yt("tf-graph-board")],tn);var c3=Ee(Oe(),1);var Ju=class{isNotTpuOp(t){return t.toLowerCase().search("cpu:")!=-1||t.toLowerCase().search("gpu:")!=-1?!0:t.toLowerCase().search("tpu")==-1}opValid(t){return t.name.search(Ma)==0||!t.op||t.device&&this.isNotTpuOp(t.device)||t.device&&t.device.search("TPU_SYSTEM")!=-1?!0:c3.includes(Ju.WHITELIST,t.op)}};Ju.WHITELIST=["Abs","Acos","Acosh","Add","AddN","AddV2","AdjustContrastv2","AdjustHue","AdjustSaturation","All","AllToAll","Angle","Any","ApproximateEqual","ArgMax","ArgMin","Asin","Asinh","Assert","AssignAddVariableOp","AssignSubVariableOp","AssignVariableOp","Atan","Atan2","Atanh","AvgPool","AvgPool3D","AvgPool3DGrad","AvgPoolGrad","BatchMatMul","BatchMatMulV2","BatchToSpace","BatchToSpaceND","BesselI0e","BesselI1e","Betainc","BiasAdd","BiasAddGrad","BiasAddV1","Bitcast","BitwiseAnd","BitwiseOr","BitwiseXor","BroadcastArgs","BroadcastGradientArgs","BroadcastTo","Bucketize","Case","Cast","Ceil","CheckNumerics","Cholesky","ClipByValue","CollectivePermute","CollectiveReduceV2","Complex","ComplexAbs","Concat","ConcatOffset","ConcatV2","Conj","ConjugateTranspose","Const","ControlTrigger","Conv2D","Conv2DBackpropFilter","Conv2DBackpropInput","Conv3D","Conv3DBackpropFilterV2","Conv3DBackpropInputV2","Cos","Cosh","Cross","CrossReplicaSum","Cumprod","Cumsum","DataFormatDimMap","DataFormatVecPermute","DepthToSpace","DepthwiseConv2dNative","DepthwiseConv2dNativeBackpropFilter","DepthwiseConv2dNativeBackpropInput","Dequantize","DeviceIndex","Diag","DiagPart","Digamma","Div","DivNoNan","DynamicStitch","Einsum","Elu","EluGrad","Empty","EmptyTensorList","EnsureShape","Equal","Erf","Erfc","Erfinv","Exp","ExpandDims","Expm1","ExtractImagePatches","FFT","FFT2D","FFT3D","FakeParam","FakeQuantWithMinMaxArgs","FakeQuantWithMinMaxArgsGradient","FakeQuantWithMinMaxVars","FakeQuantWithMinMaxVarsGradient","Fill","Floor","FloorDiv","FloorMod","FusedBatchNorm","FusedBatchNormGrad","FusedBatchNormGradV2","FusedBatchNormGradV3","FusedBatchNormV2","FusedBatchNormV3","Gather","GatherNd","GatherV2","GetItem","Greater","GreaterEqual","HSVToRGB","IFFT","IFFT2D","IFFT3D","IRFFT","IRFFT2D","IRFFT3D","Identity","IdentityN","If","Igamma","IgammaGradA","Igammac","Imag","InTopKV2","InfeedDequeue","InfeedDequeueTuple","InplaceAdd","InplaceUpdate","Inv","Invert","InvertPermutation","IsFinite","IsInf","IsNan","KthOrderStatistic","L2Loss","LRN","LRNGrad","LeakyRelu","LeakyReluGrad","LeftShift","Less","LessEqual","Lgamma","LinSpace","ListDiff","Log","Log1p","LogSoftmax","LogicalAnd","LogicalNot","LogicalOr","LowerBound","MakeUnique","MatMul","MatrixBandPart","MatrixDiag","MatrixDiagPart","MatrixDiagPartV2","MatrixDiagPartV3","MatrixDiagV2","MatrixDiagV3","MatrixInverse","MatrixSetDiag","MatrixSetDiagV2","MatrixSetDiagV3","MatrixSolve","MatrixTriangularSolve","Max","MaxPool","MaxPool3D","MaxPool3DGrad","MaxPool3DGradGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Maximum","Mean","Min","Minimum","MirrorPad","MirrorPadGrad","Mod","Mul","MulNoNan","Multinomial","Ndtri","Neg","NextAfter","NoOp","NonMaxSuppressionV4","NotEqual","OneHot","OnesLike","OutfeedEnqueue","OutfeedEnqueueTuple","Pack","Pad","PadV2","ParallelDynamicStitch","ParameterizedTruncatedNormal","PartitionedCall","PlaceholderWithDefault","Polygamma","PopulationCount","Pow","PreventGradient","Prod","Qr","QuantizeAndDequantizeV2","QuantizeAndDequantizeV3","RFFT","RFFT2D","RFFT3D","RGBToHSV","RandomGammaGrad","RandomShuffle","RandomStandardNormal","RandomUniform","RandomUniformInt","Range","Rank","ReadVariableOp","Real","RealDiv","Reciprocal","ReciprocalGrad","Relu","Relu6","Relu6Grad","ReluGrad","Reshape","ResizeBilinear","ResizeBilinearGrad","ResizeNearestNeighbor","ResizeNearestNeighborGrad","ResourceApplyAdaMax","ResourceApplyAdadelta","ResourceApplyAdagrad","ResourceApplyAdagradDA","ResourceApplyAdagradV2","ResourceApplyAdam","ResourceApplyAddSign","ResourceApplyCenteredRMSProp","ResourceApplyFtrl","ResourceApplyFtrlV2","ResourceApplyGradientDescent","ResourceApplyKerasMomentum","ResourceApplyMomentum","ResourceApplyPowerSign","ResourceApplyProximalAdagrad","ResourceApplyProximalGradientDescent","ResourceApplyRMSProp","ResourceGather","ResourceScatterAdd","ResourceScatterDiv","ResourceScatterMax","ResourceScatterMin","ResourceScatterMul","ResourceScatterNdAdd","ResourceScatterNdSub","ResourceScatterNdUpdate","ResourceScatterSub","ResourceScatterUpdate","ResourceStridedSliceAssign","Reverse","ReverseSequence","ReverseV2","RightShift","Rint","RngReadAndSkip","RngSkip","Roll","Round","Rsqrt","RsqrtGrad","ScatterNd","Select","SelectV2","SelfAdjointEigV2","Selu","SeluGrad","Shape","ShapeN","Sigmoid","SigmoidGrad","Sign","Sin","Sinh","Size","Slice","Snapshot","Softmax","SoftmaxCrossEntropyWithLogits","Softplus","SoftplusGrad","Softsign","SoftsignGrad","SpaceToBatch","SpaceToBatchND","SpaceToDepth","SparseMatMul","SparseSoftmaxCrossEntropyWithLogits","SparseToDense","Split","SplitV","Sqrt","SqrtGrad","Square","SquaredDifference","Squeeze","StackCloseV2","StackPopV2","StackPushV2","StackV2","StatefulPartitionedCall","StatefulStandardNormalV2","StatefulTruncatedNormal","StatefulUniform","StatefulUniformFullInt","StatefulUniformInt","StatelessCase","StatelessIf","StatelessMultinomial","StatelessRandomGetAlg","StatelessRandomGetKeyCounter","StatelessRandomGetKeyCounterAlg","StatelessRandomNormal","StatelessRandomNormalV2","StatelessRandomUniform","StatelessRandomUniformFullInt","StatelessRandomUniformFullIntV2","StatelessRandomUniformInt","StatelessRandomUniformIntV2","StatelessRandomUniformV2","StatelessTruncatedNormal","StatelessTruncatedNormalV2","StatelessWhile","StopGradient","StridedSlice","StridedSliceGrad","Sub","Sum","Svd","SymbolicGradient","TPUEmbeddingActivations","Tan","Tanh","TanhGrad","TensorArrayCloseV3","TensorArrayConcatV3","TensorArrayGatherV3","TensorArrayGradV3","TensorArrayReadV3","TensorArrayScatterV3","TensorArraySizeV3","TensorArraySplitV3","TensorArrayV3","TensorArrayWriteV3","TensorListConcatV2","TensorListElementShape","TensorListFromTensor","TensorListGather","TensorListGetItem","TensorListLength","TensorListPopBack","TensorListPushBack","TensorListReserve","TensorListSetItem","TensorListSplit","TensorListStack","TensorScatterAdd","TensorScatterMax","TensorScatterMin","TensorScatterSub","TensorScatterUpdate","TensorStridedSliceUpdate","Tile","TopKUnique","TopKV2","TopKWithUnique","Transpose","TridiagonalSolve","TruncateDiv","TruncateMod","TruncatedNormal","Unique","Unpack","UnsortedSegmentMax","UnsortedSegmentMin","UnsortedSegmentProd","UnsortedSegmentSum","UpperBound","VarIsInitializedOp","VariableShape","Where","While","Xdivy","XlaBroadcastHelper","XlaConv","XlaConvV2","XlaDequantize","XlaDot","XlaDotV2","XlaDynamicSlice","XlaDynamicUpdateSlice","XlaEinsum","XlaGather","XlaHostCompute","XlaIf","XlaKeyValueSort","XlaPad","XlaRecv","XlaRecvFromHost","XlaReduce","XlaReduceWindow","XlaReplicaId","XlaScatter","XlaSelectAndScatter","XlaSelfAdjointEig","XlaSend","XlaSendToHost","XlaSetBound","XlaSetDynamicDimensionSize","XlaSharding","XlaSort","XlaSpmdFullToShardShape","XlaSpmdShardToFullShape","XlaSvd","XlaVariadicReduce","XlaVariadicSort","XlaWhile","Xlog1py","Xlogy","ZerosLike","Zeta","Enter","Exit","LoopCond","Merge","NextIteration","Switch","_Arg","_ArrayToList","_FusedBatchNormEx","_ListToArray","_ParallelConcatUpdate","_RecvTPUEmbeddingActivations","_RecvTPUEmbeddingDeduplicationData","_Retval","_SendTPUEmbeddingGradients","_TPUCompile","_TPUExecute","_UnaryOpsComposition","TPUCompilationResult","TPUReplicatedInput","TPUReplicatedOutput","TPUReplicateMetadata","MergeV2Checkpoints","RestoreV2","SaveV2","Abort","Assert","Assign","Placeholder","PlaceholderV2","ShardedFilename","StringJoin","Variable","VariableV2","VarHandleOp","AudioSummary","AudioSummaryV2","DebugNumericSummary","HistogramSummary","ImageSummary","MergeSummary","ScalarSummary","StatsAggregatorSummary"];function Zle(e,t){if(t===null)throw new Error("Compatibility provider required, but got: "+t);c3.each(e.nodes,r=>{r.compatible=t.opValid(r),c3.each(r.inEmbeddings,n=>{n.compatible=t.opValid(n)}),c3.each(r.outEmbeddings,n=>{n.compatible=t.opValid(n)})})}var gP=Ee(Oe(),1);var Jle=Ee(Oe(),1);var Ll=class extends Gt(mt){constructor(){super(...arguments),this._rawRegexInput="",this._previousRegexInput="",this._searchTimeoutDelay=150,this._maxRegexResults=42}get _regexInput(){var t=this.renderHierarchy,r=this._rawRegexInput;return r.trim()}_regexInputChanged(){var t=this._regexInput;this._requestSearch()}_clearSearchResults(){this.set("_regexMatches",[])}_requestSearch(){if(!this._searchPending){if(this._regexInput===this._previousRegexInput){this._searchPending=!1;return}this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1,this._requestSearch()},this._searchTimeoutDelay)}}_executeSearch(){if(this._previousRegexInput=this._regexInput,!this._regexInput){this._clearSearchResults();return}try{var t=new RegExp(this._regexInput)}catch(i){this._clearSearchResults();return}let r=[],n=this.renderHierarchy.hierarchy.getNodeMap();Jle.each(n,(i,o)=>{if(r.length>=this._maxRegexResults)return!1;!t.test(o)||r.push(o)}),this.set("_regexMatches",r)}_matchClicked(t){let r=t.model.item;this.set("selectedNode",r),Po({actionId:jr.NODE_SEARCH_RESULT_FOCUSED})}};Ll.template=Q`
    <div id="search-container">
      <paper-input
        id="runs-regex"
        label="Search nodes (regex)"
        value="{{_rawRegexInput}}"
      >
      </paper-input>
      <div id="search-results-anchor">
        <div id="search-results">
          <template is="dom-repeat" items="[[_regexMatches]]">
            <div id="search-match" on-click="_matchClicked">[[item]]</div>
          </template>
        </div>
      </div>
    </div>
    <style>
      #search-container {
        width: 100%;
        overflow: visible;
      }

      #runs-regex {
        width: 100%;
      }

      #search-results-anchor {
        position: relative;
      }

      #search-results {
        color: #fff;
        position: absolute;
        max-height: 200px;
        overflow-x: hidden;
        overflow-y: auto;
        text-align: right;
        max-width: 100%;
        box-sizing: border-box;
      }

      #search-match {
        background: var(--tb-orange-strong);
        padding: 3px;
        float: right;
        width: 100%;
        box-sizing: border-box;
        direction: rtl;
      }

      #search-match:hover {
        background: var(--tb-orange-weak);
        cursor: pointer;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Ll.prototype,"renderHierarchy",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Ll.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],Ll.prototype,"_rawRegexInput",void 0);E([A({type:String}),w("design:type",String)],Ll.prototype,"_previousRegexInput",void 0);E([A({type:Number}),w("design:type",Number)],Ll.prototype,"_searchTimeoutDelay",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ll.prototype,"_searchPending",void 0);E([A({type:Number}),w("design:type",Number)],Ll.prototype,"_maxRegexResults",void 0);E([A({type:Array}),w("design:type",Array)],Ll.prototype,"_regexMatches",void 0);E([Rt("renderHierarchy","_rawRegexInput"),w("design:type",String),w("design:paramtypes",[])],Ll.prototype,"_regexInput",null);E([Bt("_regexInput"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ll.prototype,"_regexInputChanged",null);Ll=E([yt("tf-graph-node-search")],Ll);var lct=/device:([^:]+:[0-9]+)$/,sct=[{regex:lct}],Qle=[],uur=new Set([Gn.COMPUTE_TIME,Gn.MEMORY]),Pn=class extends Gt(_o(mt)){constructor(){super(...arguments),this.ColorBy=Gn,this.stats=null,this.devicesForStats=null,this.colorBy=Gn.STRUCTURE,this.datasets=[],this._selectedRunIndex=0,this.traceInputs=!1,this.autoExtractNodes=!0,this._selectedTagIndex=0,this._selectedGraphType=Bs.OP_GRAPH,this.showSessionRunsDropdown=!0,this.showUploadButton=!0,this._legendOpened=!0,this._downloadFilename="graph.png"}_onGraphTypeChangedByUserGesture(){Po({actionId:jr.GRAPH_TYPE_CHANGED,eventLabel:this._selectedGraphType})}_onColorByChangedByUserGesture(){Po({actionId:jr.NODE_COLOR_MODE_CHANGED,eventLabel:this.colorBy})}_onTraceInputsChangedByUserGesture(){Po({actionId:jr.TRACE_INPUT_MODE_TOGGLED})}_xlaClustersProvided(t){return t&&t.hierarchy&&t.hierarchy.xlaClusters.length>0}_statsChanged(t){if(t!=null){var r={},n=gP.each(t.dev_stats,function(i){var o=gP.some(sct,function(s){return s.regex.test(i.device)}),a=gP.some(Qle,function(s){return s.regex.test(i.device)});o&&!a&&(r[i.device]=!0)});this.set("devicesForStats",r)}}get _currentDevices(){var t=this.devicesForStats;let r=this.stats,o=(r?r.dev_stats:[]).map(s=>s.device).filter(s=>sct.some(l=>l.regex.test(s))),a=zlt(o);if(a.length==1){let s=a[0].match(lct);s&&(a[0]=s[1])}return o.map((s,l)=>{let c=null;return Qle.forEach(u=>{u.regex.test(s)&&(c=u.msg)}),{device:s,suffix:a[l],used:t==null?void 0:t[s],ignoredMsg:c}})}_deviceCheckboxClicked(t){let r=t.target,n=Object.assign({},this.devicesForStats),i=r.value;r.checked?n[i]=!0:delete n[i],this.set("devicesForStats",n)}_numTags(t,r){return this._getTags(t,r).length}_getTags(t,r){return!t||!t[r]?[]:t[r].tags}_fit(){this.fire("fit-tap")}_isGradientColoring(t,r){return uur.has(r)&&t!=null}_equals(t,r){return t===r}get _currentDeviceParams(){var t=this.colorByParams;let r=t.device.filter(o=>sct.some(a=>a.regex.test(o.device))),n=zlt(r.map(o=>o.device));if(n.length==1){var i=n[0].match(lct);i&&(n[0]=i[1])}return r.map((o,a)=>({device:n[a],color:o.color}))}get _currentXlaClusterParams(){var t=this.colorByParams;return t.xla_cluster}get _currentGradientParams(){var t=this.colorByParams,r=this.colorBy;if(!this._isGradientColoring(this.stats,r))return null;let n=t[r],i=n.minValue,o=n.maxValue;return r===Gn.MEMORY?(i=Dd(i,iP),o=Dd(o,iP)):r===Gn.COMPUTE_TIME&&(i=Dd(i,oP),o=Dd(o,oP)),{minValue:i,maxValue:o,startColor:n.startColor,endColor:n.endColor}}download(){this.fire("download-image-requested",this._downloadFilename)}_updateFileInput(t){var a;let r=(a=t.target.files)==null?void 0:a[0];if(!r)return;let n=r.name,i=n.lastIndexOf(".");i>=0&&(n=n.substring(0,i));let o=n.lastIndexOf("/");o>=0&&(n=n.substring(o+1)),this._setDownloadFilename(n),this.set("selectedFile",t),Po({actionId:jr.UPLOADED_GRAPH_FROM_FILESYSTEM})}_datasetsChanged(t,r){var n;r!=null&&(this._selectedRunIndex=0),this._setDownloadFilename((n=this.datasets[this._selectedRunIndex])==null?void 0:n.name)}_computeSelection(t,r,n,i){return!t[r]||!t[r].tags[n]?null:{run:t[r].name,tag:t[r].tags[n].tag,type:i}}_selectedRunIndexChanged(t){var r;!this.datasets||(this.colorBy=Gn.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename((r=this.datasets[t])==null?void 0:r.name))}_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()}_getDefaultSelectionType(){let{datasets:t,_selectedRunIndex:r,_selectedTagIndex:n}=this;if(!t||!t[r]||!t[r].tags[n]||t[r].tags[n].opGraph)return Bs.OP_GRAPH;let i=t[r];return i.tags[n].profile?Bs.PROFILE:i.tags[n].conceptualGraph?Bs.CONCEPTUAL_GRAPH:Bs.OP_GRAPH}_getFile(){this.$$("#file").click()}_setDownloadFilename(t){this._downloadFilename=(t||"graph")+".png"}_statsNotNull(t){return t!==null}_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)}_getToggleLegendIcon(t){return t?"expand-more":"expand-less"}_getSelectionOpGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].opGraph}_getSelectionProfileDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].profile}_getSelectionConceptualGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].conceptualGraph}};Pn.template=Q`
    <style>
      :host {
        color: #555;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
        --tb-graph-controls-title-color: #000;
        --tb-graph-controls-legend-text-color: #000;
        --tb-graph-controls-text-color: #555;
        --tb-graph-controls-title-font-size: 14px;
        --tb-graph-controls-subtitle-font-size: 14px;
        --paper-input-container-shared-input-style_-_font-size: 14px;
        --paper-font-subhead_-_font-size: 14px;
      }

      :host(.dark-mode) {
        --tb-graph-controls-title-color: #fff;
        --tb-graph-controls-legend-text-color: #f3f3f3;
        --tb-graph-controls-text-color: #eee;
      }

      paper-dropdown-menu {
        --paper-dropdown-menu-input: {
          padding: 0;
          color: gray;
        }
        --iron-icon-width: 15px;
        --iron-icon-height: 15px;
        --primary-text-color: gray;
        --paper-item-min-height: 30px;
      }

      paper-button[raised].keyboard-focus {
        font-weight: normal;
      }

      .run-dropdown {
        --paper-input-container: {
          padding: 5px 0 5px 5px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table tr {
        height: 20px;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: var(--secondary-background-color);
        box-sizing: border-box;
        color: var(--tb-graph-controls-text-color);
        width: 100%;
      }

      .legend-toolbar {
        appearance: none;
        background-color: inherit;
        border-top: 1px solid #ccc;
        border-bottom: 1px solid #ccc;
        border-right: none;
        border-left: none;
        cursor: pointer;
        color: var(--tb-graph-controls-legend-text-color);
        font: inherit;
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
      }

      .legend-toolbar,
      .legend-content {
        padding: 8px 20px;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        font-size: var(--tb-graph-controls-subtitle-font-size);
      }

      paper-radio-button {
        display: block;
        padding: 5px;
      }
      svg.icon,
      tf-graph-icon {
        width: 60px;
        height: 18px;
      }
      .domainValues {
        margin-bottom: 10px;
        width: 165px;
      }
      .domainStart {
        float: left;
      }
      .domainEnd {
        float: right;
      }
      .colorBox {
        width: 20px;
      }

      .image-icon {
        width: 24px;
        height: 24px;
      }

      .help-icon {
        height: 15px;
        margin: 0;
        padding: 0;
      }

      .gray {
        color: #666;
      }

      .title {
        font-size: var(--tb-graph-controls-title-font-size);
        margin: 8px 5px 8px 0;
        color: var(--tb-graph-controls-title-color);
      }
      .title small {
        font-weight: normal;
      }
      .deviceList,
      .xlaClusterList {
        max-height: 200px;
        overflow-y: auto;
      }

      #file {
        padding: 8px 0;
      }

      .color-legend-row {
        align-items: center;
        clear: both;
        display: flex;
        height: 20px;
        margin-top: 5px;
      }

      .color-legend-row .label,
      .color-legend-row svg,
      .color-legend-row tf-graph-icon {
        flex: 0 0 40px;
        margin-right: 20px;
      }

      .devices-checkbox input {
        text-align: left;
        vertical-align: middle;
      }

      .control-holder .icon-button {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        margin: 0 -5px;
        padding: 5px;
        display: flex;
        justify-content: flex-start;
        color: var(--tb-graph-controls-text-color);
      }

      .button-text {
        padding-left: 20px;
        text-transform: none;
      }

      .upload-button {
        width: 165px;
        height: 25px;
        text-transform: none;
        margin-top: 4px;
      }

      .button-icon {
        width: 26px;
        height: 26px;
        color: var(--paper-orange-500);
      }

      .hidden-input {
        display: none;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder.control-options {
        padding: 0 0 15px 15px;
        flex-direction: column;
      }

      .allcontrols .control-holder paper-toggle-button {
        margin-bottom: 5px;
      }

      span.counter {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        color: gray;
        margin-left: 4px;
      }

      .runs-row .title,
      .tags-row .title {
        display: flex;
        align-items: baseline;
      }

      .runs-row paper-item,
      .tags-row paper-item {
        --paper-item: {
          white-space: nowrap;
        }
      }

      table.control-holder {
        border: 0;
        border-collapse: collapse;
      }

      table.tf-graph-controls td.input-element-table-data {
        padding: 0 0 0 20px;
      }

      .spacer {
        flex-grow: 1;
      }

      .color-text {
        overflow: hidden;
      }

      .color-text.gradient-container {
        margin: 0 5px;
      }

      /** Override inline styles that suppress pointer events for disabled buttons. Otherwise, the */
      /*  tooltips do not appear. */
      paper-radio-group paper-radio-button {
        pointer-events: auto !important;
      }

      .legend-clarifier {
        color: var(--tb-graph-controls-text-color);
        cursor: help;
        display: inline-block;
        text-decoration: underline;
      }

      .legend-clarifier paper-tooltip {
        width: 150px;
      }

      /** Otherwise, polymer UI controls appear atop node search. */
      tf-graph-node-search {
        z-index: 1;
        width: 100%;
      }

      paper-dropdown-menu {
        flex-grow: 1;
      }
    </style>

    <div class="allcontrols">
      <div class="control-holder">
        <tf-graph-node-search
          selected-node="{{selectedNode}}"
          render-hierarchy="[[renderHierarchy]]"
        ></tf-graph-node-search>
      </div>
      <div class="control-holder">
        <paper-button class="icon-button" on-tap="_fit" alt="Fit to screen">
          <iron-icon icon="aspect-ratio" class="button-icon"></iron-icon>
          <span class="button-text">Fit to screen</span>
        </paper-button>
      </div>
      <div class="control-holder">
        <paper-button
          class="icon-button"
          on-click="download"
          alt="Download PNG"
        >
          <iron-icon icon="file-download" class="button-icon"></iron-icon>
          <span class="button-text">Download PNG</span>
        </paper-button>
      </div>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <paper-button
            class="icon-button"
            on-click="_getFile"
            alt="Upload file"
            title="Upload a pbtxt file to view a graph from the local filesystem"
          >
            <iron-icon icon="file-upload" class="button-icon"></iron-icon>
            <span class="button-text">Upload file</span>
          </paper-button>

          <div class="hidden-input">
            <input
              type="file"
              id="file"
              name="file"
              on-change="_updateFileInput"
              accept=".pbtxt"
            />
          </div>
        </div>
      </template>
      <div class="control-holder runs-row">
        <div class="title">
          Run <span class="counter">([[datasets.length]])</span>
        </div>
        <paper-dropdown-menu
          no-label-float
          no-animations
          noink
          horizontal-align="left"
          class="run-dropdown"
        >
          <paper-listbox
            class="dropdown-content"
            selected="{{_selectedRunIndex}}"
            slot="dropdown-content"
          >
            <template is="dom-repeat" items="[[datasets]]">
              <paper-item>[[item.name]]</paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <template is="dom-if" if="[[showSessionRunsDropdown]]">
        <div class="control-holder tags-row">
          <div class="title">
            Tag
            <span class="counter"
              >([[_numTags(datasets, _selectedRunIndex)]])</span
            >
          </div>
          <paper-dropdown-menu
            no-label-float
            no-animations
            horizontal-align="left"
            noink
            class="run-dropdown"
          >
            <paper-listbox
              class="dropdown-content"
              selected="{{_selectedTagIndex}}"
              slot="dropdown-content"
            >
              <template
                is="dom-repeat"
                items="[[_getTags(datasets, _selectedRunIndex)]]"
              >
                <paper-item>[[item.displayName]]</paper-item>
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
        </div>
      </template>
      <div class="title">Graph type</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{_selectedGraphType}}"
          on-paper-radio-group-changed="_onGraphTypeChangedByUserGesture"
        >
          <!-- Note that the name has to match that of tf_graph_common.SelectionType. -->
          <paper-radio-button
            name="op_graph"
            disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Op graph</paper-radio-button
          >
          <paper-radio-button
            name="conceptual_graph"
            disabled="[[_getSelectionConceptualGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Conceptual graph</paper-radio-button
          >
          <paper-radio-button
            name="profile"
            disabled="[[_getSelectionProfileDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Profile</paper-radio-button
          >
        </paper-radio-group>
      </div>
      <div class="title">Node options</div>
      <div class="control-holder control-options">
        <paper-toggle-button
          checked="{{traceInputs}}"
          on-change="_onTraceInputsChangedByUserGesture"
        >
          Trace inputs
        </paper-toggle-button>
        <paper-toggle-button checked="{{autoExtractNodes}}">
          Auto-extract high-degree nodes
        </paper-toggle-button>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}"
            >Show health pills</paper-toggle-button
          >
        </div>
      </template>
      <div class="title">Color by</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{colorBy}}"
          on-paper-radio-group-changed="_onColorByChangedByUserGesture"
        >
          <paper-radio-button name="[[ColorBy.NONE]]">None</paper-radio-button>

          <paper-radio-button name="[[ColorBy.STRUCTURE]]"
            >Structure</paper-radio-button
          >

          <paper-radio-button name="[[ColorBy.DEVICE]]"
            >Device</paper-radio-button
          >

          <paper-radio-button
            id="xla-cluster-radio-button"
            name="[[ColorBy.XLA_CLUSTER]]"
            disabled="[[!_xlaClustersProvided(renderHierarchy)]]"
          >
            XLA cluster
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="xla-cluster-radio-button"
            position="right"
            offset="0"
          >
            Coloring by XLA cluster is only enabled if at least 1 op specifies
            an XLA cluster.
          </paper-tooltip>

          <paper-radio-button
            id="compute-time-radio-button"
            name="[[ColorBy.COMPUTE_TIME]]"
            disabled="[[!stats]]"
          >
            Compute time
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="compute-time-radio-button"
            position="right"
            offset="0"
          >
            Coloring by compute time is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="memory-radio-button"
            name="[[ColorBy.MEMORY]]"
            disabled="[[!stats]]"
          >
            Memory
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="memory-radio-button"
            position="right"
            offset="0"
          >
            Coloring by memory is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="tpu-compatibility-radio-button"
            name="[[ColorBy.OP_COMPATIBILITY]]"
          >
            TPU compatibility
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="tpu-compatibility-radio-button"
            position="right"
            offset="0"
          >
            Coloring by whether an operation is compatible for the TPU device.
          </paper-tooltip>
        </paper-radio-group>
        <span class="spacer"></span>
      </div>
    </div>
    <div class="legend-holder">
      <button class="legend-toolbar" on-click="_toggleLegendOpen">
        <span class="toggle-legend-text">Legend</span>
        <iron-icon
          icon="[[_getToggleLegendIcon(_legendOpened)]]"
          class="toggle-legend-button"
        >
        </iron-icon>
      </button>
      <iron-collapse opened="[[_legendOpened]]" class="legend-content">
        <!-- Color-mode-specific legend items -->
        <div>
          <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
            <svg width="140" height="20" class="color-text gradient-container">
              <defs>
                <linearGradient
                  id="linearGradient"
                  x1="0%"
                  y1="0%"
                  x2="100%"
                  y2="0%"
                >
                  <stop
                    class="start"
                    offset="0%"
                    stop-color$="[[_currentGradientParams.startColor]]"
                  ></stop>
                  <stop
                    class="end"
                    offset="100%"
                    stop-color$="[[_currentGradientParams.endColor]]"
                  ></stop>
                </linearGradient>
              </defs>
              <rect
                x="0"
                y="0"
                width="135"
                height="20"
                fill="url(#linearGradient)"
                stroke="black"
              ></rect>
            </svg>
            <div class="domainValues color-text">
              <div class="domainStart">[[_currentGradientParams.minValue]]</div>
              <div class="domainEnd">[[_currentGradientParams.maxValue]]</div>
            </div>
            <br style="clear: both" />
            <div>Devices included in stats:</div>
            <div class="deviceList">
              <template is="dom-repeat" items="[[_currentDevices]]">
                <div class="color-legend-row devices-checkbox">
                  <span
                    ><input
                      type="checkbox"
                      value$="[[item.device]]"
                      checked$="[[item.used]]"
                      on-click="_deviceCheckboxClicked"
                  /></span>
                  <span>[[item.suffix]]</span>
                  <template is="dom-if" if="[[item.ignoredMsg]]">
                    <paper-icon-button
                      icon="help"
                      class="help-icon"
                    ></paper-icon-button>
                    <paper-tooltip
                      position="right"
                      offset="0"
                      animation-delay="0"
                      >[[item.ignoredMsg]]</paper-tooltip
                    >
                  </template>
                </div>
              </template>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'structure')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <span class="label"> colors </span>
                <span class="color-legend-value">same substructure</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unique substructure</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'device')]]">
            <div>
              <template is="dom-repeat" items="[[_currentDeviceParams]]">
                <div class="color-legend-row">
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="[[item.color]]"
                    stroke-override="#a6a6a6"
                  ></tf-graph-icon>
                  <span class="color-legend-value">[[item.device]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unknown device</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'xla_cluster')]]">
            <div>
              <template is="dom-repeat" items="[[_currentXlaClusterParams]]">
                <div class="color-legend-row">
                  <svg>
                    <use
                      xmlns:xlink="http://www.w3.org/1999/xlink"
                      xlink:href="#unfilled-rect"
                      x="0"
                      y="0"
                      style="fill:[[item.color]]"
                    ></use>
                  </svg>
                  <span class="color-legend-value">[[item.xla_cluster]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <svg>
                  <use
                    xmlns:xlink="http://www.w3.org/1999/xlink"
                    xlink:href="#grey-rect"
                    x="0"
                    y="0"
                  ></use>
                </svg>
                <span class="color-legend-value">unknown XLA cluster</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#0f9d58"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Valid Op</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#db4437"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Invalid Op</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_statsNotNull(stats)]]">
            <div class="color-legend-row">
              <tf-graph-icon type="META" height="16" faded></tf-graph-icon>
              <span class="color-legend-value">unused substructure</span>
            </div>
          </template>
        </div>

        <!-- Common legend items -->
        <div>
          <table>
            <tbody>
              <tr>
                <td></td>
                <td>(* = expandable)</td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="#d9d9d9"
                    stroke-override="#ccc"
                  ></tf-graph-icon>
                </td>
                <td>
                  Namespace<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Encapsulates a set of nodes. Namespace is hierarchical and
                      based on scope.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="OP" height="16"></tf-graph-icon>
                </td>
                <td>
                  OpNode
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that performs an operation. These nodes cannot
                      expand.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SERIES" height="16"></tf-graph-icon>
                </td>
                <td>
                  Unconnected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are not connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="SERIES"
                    height="16"
                    vertical
                  ></tf-graph-icon>
                </td>
                <td>
                  Connected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg class="icon">
                    <circle
                      fill="white"
                      stroke="#848484"
                      cx="10"
                      cy="10"
                      r="5"
                    ></circle>
                  </svg>
                </td>
                <td>
                  Constant
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that outputs a constant value.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SUMMARY" height="20"></tf-graph-icon>
                </td>
                <td>
                  Summary
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that collects data for visualization within
                      TensorBoard.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="dataflow-arrowhead-legend"
                        fill="#bbb"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#dataflow-arrowhead-legend)"
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Dataflow edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the data flow between operations. Edges flow
                      upwards unless arrowheads specify otherwise.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <path
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                      stroke-dasharray="2, 2"
                    ></path>
                  </svg>
                </td>
                <td>
                  Control dependency edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the control dependency between operations.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="reference-arrowhead-legend"
                        fill="#FFB74D"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#reference-arrowhead-legend)"
                      stroke="#FFB74D"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Reference edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing that the outgoing operation node can mutate
                      the incoming tensor.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </iron-collapse>
    </div>
  `;E([A({type:Object,observer:"_statsChanged"}),w("design:type",Object)],Pn.prototype,"stats",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"devicesForStats",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"colorByParams",void 0);E([A({type:Array,observer:"_datasetsChanged"}),w("design:type",Object)],Pn.prototype,"datasets",void 0);E([A({type:Object}),w("design:type",lo)],Pn.prototype,"renderHierarchy",void 0);E([A({type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"}),w("design:type",Object)],Pn.prototype,"selection",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Pn.prototype,"selectedFile",void 0);E([A({type:Number,observer:"_selectedRunIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedRunIndex",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"traceInputs",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"autoExtractNodes",void 0);E([A({type:Number,observer:"_selectedTagIndexChanged"}),w("design:type",Number)],Pn.prototype,"_selectedTagIndex",void 0);E([A({type:String}),w("design:type",String)],Pn.prototype,"_selectedGraphType",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Pn.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showSessionRunsDropdown",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"showUploadButton",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"healthPillsFeatureEnabled",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Pn.prototype,"healthPillsToggledOn",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Pn.prototype,"_legendOpened",void 0);E([Rt("devicesForStats"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDevices",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentDeviceParams",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],Pn.prototype,"_currentXlaClusterParams",null);E([Rt("colorByParams","colorBy"),w("design:type",Object),w("design:paramtypes",[])],Pn.prototype,"_currentGradientParams",null);Pn=E([yt("tf-graph-controls")],Pn);function hur(e){if(e==="true")return!0;if(e==="false")return!1;if(e[0]==='"')return e.substring(1,e.length-1);let r=parseFloat(e);return isNaN(r)?e:r}function tce(e){return new Promise((t,r)=>{fetch(e).then(n=>{n.ok?n.arrayBuffer().then(t,r):n.text().then(r,r)})})}function ece(e,t){return Zse("Reading metadata pbtxt",40,()=>e==null?Promise.resolve(null):tce(e),t,jr.FETCH_METADATA_PBTXT_BYTES).then(r=>mH("Parsing metadata.pbtxt",60,()=>r!=null?gur(r):Promise.resolve(null),t,jr.PARSE_METADATA_PBTXT_INTO_OBJECT))}function rce(e,t,r){return mH("Reading graph pbtxt",40,()=>Ri(this,null,function*(){let n=Date.now();if(t){let o=yield new Promise(function(a,s){let l=new FileReader;l.onload=()=>a(l.result),l.onerror=()=>s(l.error),l.readAsArrayBuffer(t)});return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_FILESYSTEM,eventValue:Date.now()-n}),o}let i=yield tce(e);return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_SERVER,eventValue:Date.now()-n}),i}),r,jr.FETCH_PBTXT_BYTES).then(n=>mH("Parsing graph.pbtxt",60,()=>mur(n),r,jr.PARSE_PBTXT_INTO_OBJECT))}function fur(e,t,r=1e6,n=`
`){return new Promise(function(i,o){function a(s,l,c){let u=c>=e.byteLength,h=l.split(n);h[0]=s+h[0];let f=u?"":h.pop();for(let g of h)try{t(g)}catch(_){o(_);return}if(u){i(!0);return}let p=new Blob([e.slice(c,c+r)]),d=new FileReader;d.onload=function(g){a(f,g.target.result,c+r)},d.readAsText(p)}a("","",0)})}var pur={"library.function":!0,"library.function.node_def":!0,"library.function.node_def.input":!0,"library.function.node_def.attr":!0,"library.function.node_def.attr.value.list.b":!0,"library.function.node_def.attr.value.list.f":!0,"library.function.node_def.attr.value.list.func":!0,"library.function.node_def.attr.value.list.i":!0,"library.function.node_def.attr.value.list.s":!0,"library.function.node_def.attr.value.list.shape":!0,"library.function.node_def.attr.value.list.shape.dim":!0,"library.function.node_def.attr.value.list.tensor":!0,"library.function.node_def.attr.value.list.type":!0,"library.function.node_def.attr.value.shape.dim":!0,"library.function.node_def.attr.value.tensor.string_val":!0,"library.function.node_def.attr.value.tensor.tensor_shape.dim":!0,"library.function.signature.input_arg":!0,"library.function.signature.output_arg":!0,"library.versions":!0,node:!0,"node.input":!0,"node.attr":!0,"node.attr.value.list.b":!0,"node.attr.value.list.f":!0,"node.attr.value.list.func":!0,"node.attr.value.list.i":!0,"node.attr.value.list.s":!0,"node.attr.value.list.shape":!0,"node.attr.value.list.shape.dim":!0,"node.attr.value.list.tensor":!0,"node.attr.value.list.type":!0,"node.attr.value.shape.dim":!0,"node.attr.value.tensor.string_val":!0,"node.attr.value.tensor.tensor_shape.dim":!0},dur={"step_stats.dev_stats":!0,"step_stats.dev_stats.node_stats":!0,"step_stats.dev_stats.node_stats.output":!0,"step_stats.dev_stats.node_stats.memory":!0,"step_stats.dev_stats.node_stats.output.tensor_description.shape.dim":!0};function mur(e){return nce(e,pur)}function gur(e){return nce(e,dur).then(t=>t.step_stats)}function nce(e,t){let r={},n=[],i=[],o=r;function a(l){let c=l.indexOf(":"),u=l.substring(0,c).trim(),h=hur(l.substring(c+2).trim());return{name:u,value:h}}function s(l,c,u,h){let f=l[c];f==null?l[c]=h.join(".")in t?[u]:u:Array.isArray(f)?f.push(u):l[c]=[f,u]}return fur(e,function(l){if(l=l.trim(),!!l)switch(l[l.length-1]){case"{":let c=l.substring(0,l.length-2).trim(),u={};n.push(o),i.push(c),s(o,c,u,i),o=u;break;case"}":o=n.pop(),i.pop();break;default:let h=a(l);s(o,h.name,h.value,i.concat(h.name));break}}).then(function(){return r})}function oce(e,t,r,n=new Ju,i=r3){let o=JS(e,30,"Data"),a=JS(e,20,"Graph"),s=JS(e,50,"Namespace hierarchy"),l=Date.now();return rce(t,r,o).then(function(c){if(!c.node)throw new Error("The graph is empty. This can happen when TensorFlow could not trace any graph. Please refer to https://github.com/tensorflow/tensorboard/issues/1961 for more information.");return lle(c,sle,a)},()=>{throw new Error("Malformed GraphDef. This can sometimes be caused by a bad network connection or difficulty reconciling multiple GraphDefs; for the latter case, please refer to https://github.com/tensorflow/tensorboard/issues/1929.")}).then(c=>Ri(this,null,function*(){Zle(c,n);let u=yield bH(c,i,s);return Po({timingId:jr.GRAPH_LOAD_SUCCEEDED,eventValue:Date.now()-l}),{graph:c,graphHierarchy:u}})).catch(c=>{let u=`Graph visualization failed.

${c}`;throw e.reportError(u,c),Po({timingId:jr.GRAPH_LOAD_FAILED,eventValue:Date.now()-l}),c})}var Vs=class extends Gt(mt){constructor(){super(...arguments),this.compatibilityProvider=new Ju,this.hierarchyParams=r3,this._template=null}_selectionChanged(){!this.selection||this.debounce("selectionchange",()=>{this._load(this.selection)})}_load(t){let{run:r,tag:n,type:i}=t;switch(i){case Bs.OP_GRAPH:case Bs.CONCEPTUAL_GRAPH:{(function(){this._setOutStats(null)}).bind(this)();let o=new URLSearchParams;o.set("run",r),o.set("conceptual",String(i===Bs.CONCEPTUAL_GRAPH)),n&&o.set("tag",n);let a=_e().pluginRouteForSrc("graphs","/graph",o);return this._fetchAndConstructHierarchicalGraph(a).then(()=>{this._graphRunTag={run:r,tag:n}})}case Bs.PROFILE:{let{tags:o}=this.datasets.find(({name:f})=>f===r),s=o.find(f=>f.tag===n).opGraph?n:null;console.assert(o.find(f=>f.tag===s),`Required tag (${s}) is missing.`);let c=!this._graphRunTag||this._graphRunTag.run!==r||this._graphRunTag.tag!==s?this._load({run:r,tag:s,type:Bs.OP_GRAPH}):Promise.resolve(),u=new URLSearchParams;u.set("tag",n),u.set("run",r);let h=_e().pluginRouteForSrc("graphs","/run_metadata",u);return c.then(()=>this._readAndParseMetadata(h))}default:return Promise.reject(new Error(`Unknown selection type: ${i}`))}}_readAndParseMetadata(t){this.set("progress",{value:0,msg:""});var r=nP(this);ece(t,r).then(function(n){this._setOutStats(n)}.bind(this))}_fetchAndConstructHierarchicalGraph(t,r){this.set("progress",{value:0,msg:""});let n=nP(this);return oce(n,t,r!==void 0?r:null,this.compatibilityProvider,this.hierarchyParams).then(function({graph:i,graphHierarchy:o}){this._setOutGraph(i),this._setOutGraphHierarchy(o)}.bind(this))}_selectedFileChanged(){var i;var t=this.selectedFile;if(!t)return;let r=t.target,n=(i=r.files)==null?void 0:i[0];!n||(r.value="",this._fetchAndConstructHierarchicalGraph(null,n))}};E([A({type:Array}),w("design:type",Array)],Vs.prototype,"datasets",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Vs.prototype,"progress",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"selection",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"selectedFile",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"compatibilityProvider",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"hierarchyParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",as)],Vs.prototype,"outGraphHierarchy",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Xu)],Vs.prototype,"outGraph",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Object)],Vs.prototype,"outStats",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_graphRunTag",void 0);E([Bt("selection","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vs.prototype,"_selectionChanged",null);E([Bt("selectedFile","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vs.prototype,"_selectedFileChanged",null);Vs=E([yt("tf-graph-dashboard-loader")],Vs);var ace="run";var Or=class extends Gt(mt){constructor(){super(...arguments),this._datasets=[],this._datasetsFetched=!1,this._selectedDataset=0,this._requestManager=new Ae,this._canceller=new an,this.specificHealthPillStep=0,this.healthPillsToggledOn=!1,this._debuggerNumericAlerts=[],this._nodeNamesToHealthPills={},this._healthPillRequestId=1,this._healthPillStepRequestTimerDelay=500,this.run=v_(ace,{defaultValue:"",useLocalStorage:!1}).call(this),this._runObserver=x_(ace,{defaultValue:"",polymerProperty:"run",useLocalStorage:!1})}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}ready(){super.ready(),this.addEventListener("node-toggle-expand",this._handleNodeToggleExpand.bind(this))}reload(){this._debuggerDataEnabled||this._requestManager.request(_e().pluginsListing()).then(this._canceller.cancellable(t=>{t.cancelled||t.value.debugger&&this.set("_debuggerDataEnabled",!0)})),this._maybeFetchHealthPills()}_fit(){this.$$("#graphboard").fit()}_onDownloadImageRequested(t){this.$$("#graphboard").downloadAsImage(t.detail)}_getGraphDisplayClassName(t,r){return t||r.length?"":"no-graph"}_fetchDataset(){return this._requestManager.request(_e().pluginRoute("graphs","/info"))}_fetchHealthPills(t,r){let n={node_names:JSON.stringify(t),run:"__debugger_data__"};r!==void 0&&(n.step=r);let i=_e().pluginRoute("debugger","/health_pills");return this._requestManager.request(i,n)}_fetchDebuggerNumericsAlerts(){return this._requestManager.request(_e().pluginRoute("debugger","/numerics_alert_report"))}_graphUrl(t,r,n){return _e().pluginRouteForSrc("graphs","/graph",new URLSearchParams({run:t,limit_attr_size:r,large_attrs_key:n}))}_shouldRequestHealthPills(){return this._debuggerDataEnabled&&this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")}_maybeInitializeDashboard(){var t=this._isAttached;this._initialized||!t||(this.set("_compatibilityProvider",new Ju),this._initialized=!0,this._fetchDataset().then(r=>{let n=Object.keys(r);this._datasets=n.sort(bh).map(i=>{let o=r[i],s=Object.keys(o.tags).sort(bh).map(c=>o.tags[c]).map(({tag:c,conceptual_graph:u,op_graph:h,profile:f})=>({tag:c,displayName:c,conceptualGraph:u,opGraph:h,profile:f})),l=o.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...s]:s;return{name:i,tags:l}}),this._datasetsFetched=!0}))}_determineSelectedDataset(){var t=this._datasetsFetched,r=this._datasets,n=this.run;if(!n){this.set("_selectedDataset",0);return}let i=r.findIndex(o=>o.name===n);if(i===-1){if(t){let o=this.$$("#error-dialog");o.textContent=`No dataset named "${n}" could be found.`,o.open()}return}this.set("_selectedDataset",i)}_updateSelectedDatasetName(){var t=this._datasetsFetched,r=this._datasets,n=this._selectedDataset;!t||r.length<=n||this.set("run",r[n].name)}_requestHealthPills(){this.set("_areHealthPillsLoading",!0);var t=++this._healthPillRequestId;this._healthPillStepRequestTimerId!==null&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null),this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null,this._initiateNetworkRequestForHealthPills(t)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(t)}_initiateNetworkRequestForHealthPills(t){if(this._healthPillRequestId!==t)return;let r=this.allStepsModeEnabled?this.specificHealthPillStep:void 0,n=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),r),i=this._fetchDebuggerNumericsAlerts();Promise.all([n,i]).then(function(o){var a=o[0],s=o[1];if(!!this.healthPillsToggledOn&&t===this._healthPillRequestId){for(var l in a){this.set("_healthPillStepIndex",a[l].length-1);break}this.set("_debuggerNumericAlerts",s),this.set("_nodeNamesToHealthPills",a),this.set("_areHealthPillsLoading",!1),this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}_datasetsState(t,r,n){return t?!r||!r.length?n==="EMPTY":n==="PRESENT":n==="NOT_LOADED"}_renderHierarchyChanged(t){this.reload()}_handleNodeToggleExpand(){this._maybeFetchHealthPills()}_healthPillsToggledOnChanged(t){t?this.reload():this.set("_nodeNamesToHealthPills",{})}_maybeFetchHealthPills(){!this._shouldRequestHealthPills()||this._requestHealthPills()}};Or.template=Q`
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <tf-dashboard-layout>
      <tf-graph-controls
        id="controls"
        class="sidebar"
        slot="sidebar"
        devices-for-stats="{{_devicesForStats}}"
        color-by-params="[[_colorByParams]]"
        stats="[[_stats]]"
        color-by="{{_colorBy}}"
        datasets="[[_datasets]]"
        render-hierarchy="[[_renderHierarchy]]"
        selection="{{_selection}}"
        selected-file="{{_selectedFile}}"
        selected-node="{{_selectedNode}}"
        health-pills-feature-enabled="[[_debuggerDataEnabled]]"
        health-pills-toggled-on="{{healthPillsToggledOn}}"
        on-fit-tap="_fit"
        trace-inputs="{{_traceInputs}}"
        auto-extract-nodes="{{_autoExtractNodes}}"
        on-download-image-requested="_onDownloadImageRequested"
      ></tf-graph-controls>
      <div
        class$="center [[_getGraphDisplayClassName(_selectedFile, _datasets)]]"
        slot="center"
      >
        <tf-graph-dashboard-loader
          id="loader"
          datasets="[[_datasets]]"
          selection="[[_selection]]"
          selected-file="[[_selectedFile]]"
          out-graph-hierarchy="{{_graphHierarchy}}"
          out-graph="{{_graph}}"
          out-stats="{{_stats}}"
          progress="{{_progress}}"
          hierarchy-params="[[_hierarchyParams]]"
          compatibility-provider="[[_compatibilityProvider]]"
        ></tf-graph-dashboard-loader>
        <div class="no-data-message">
          <h3>No graph definition files were found.</h3>
          <p>
            To store a graph, create a
            <code>tf.summary.FileWriter</code>
            and pass the graph either via the constructor, or by calling its
            <code>add_graph()</code> method. You may want to check out the
            <a href="https://www.tensorflow.org/tensorboard/graphs"
              >examining the TensorFlow graph tutorial</a
            >.
          </p>

          <p>
            If you’re new to using TensorBoard, and want to find out how to add
            data and set up your event files, check out the
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
              >README</a
            >
            and perhaps the
            <a
              href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
              >TensorBoard tutorial</a
            >.
          </p>

          <p>
            If you think TensorBoard is configured properly, please see
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
              >the section of the README devoted to missing data problems</a
            >
            and consider filing an issue on GitHub.
          </p>
        </div>
        <div class="graphboard">
          <tf-graph-board
            id="graphboard"
            devices-for-stats="[[_devicesForStats]]"
            color-by="{{_colorBy}}"
            color-by-params="{{_colorByParams}}"
            graph-hierarchy="[[_graphHierarchy]]"
            graph="[[_graph]]"
            hierarchy-params="[[_hierarchyParams]]"
            progress="[[_progress]]"
            debugger-data-enabled="[[_debuggerDataEnabled]]"
            are-health-pills-loading="[[_areHealthPillsLoading]]"
            debugger-numeric-alerts="[[_debuggerNumericAlerts]]"
            node-names-to-health-pills="[[_nodeNamesToHealthPills]]"
            all-steps-mode-enabled="{{allStepsModeEnabled}}"
            specific-health-pill-step="{{specificHealthPillStep}}"
            health-pill-step-index="[[_healthPillStepIndex]]"
            render-hierarchy="{{_renderHierarchy}}"
            selected-node="{{_selectedNode}}"
            stats="[[_stats]]"
            trace-inputs="[[_traceInputs]]"
            auto-extract-nodes="[[_autoExtractNodes]]"
          ></tf-graph-board>
        </div>
      </div>
    </tf-dashboard-layout>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }

      .no-data-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      .graphboard {
        height: 100%;
      }

      .no-graph .graphboard {
        display: none;
      }

      .center:not(.no-graph) .no-data-message {
        display: none;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Or.prototype,"_datasets",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_datasetsFetched",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_selectedDataset",void 0);E([A({type:Object,observer:"_renderHierarchyChanged"}),w("design:type",lo)],Or.prototype,"_renderHierarchy",void 0);E([A({type:Object}),w("design:type",Ae)],Or.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],Or.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"allStepsModeEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"specificHealthPillStep",void 0);E([A({type:Boolean,observer:"_healthPillsToggledOnChanged"}),w("design:type",Boolean)],Or.prototype,"healthPillsToggledOn",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Or.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_isAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_initialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Or.prototype,"_debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepIndex",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillRequestId",void 0);E([A({type:Number}),w("design:type",Object)],Or.prototype,"_healthPillStepRequestTimerId",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepRequestTimerDelay",void 0);E([A({type:Array}),w("design:type",Array)],Or.prototype,"runs",void 0);E([A({type:String,notify:!0,observer:"_runObserver"}),w("design:type",String)],Or.prototype,"run",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selection",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_compatibilityProvider",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_autoExtractNodes",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selectedFile",void 0);E([Bt("_isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_maybeInitializeDashboard",null);E([Bt("_datasetsFetched","_datasets","run"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_determineSelectedDataset",null);E([Bt("_datasetsFetched","_datasets","_selectedDataset"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_updateSelectedDatasetName",null);Or=E([yt("tf-graph-dashboard")],Or);var NH=Ee(Oe(),1);var kr=Vr,Ea=class extends Gt(_o(mt)){constructor(){super(...arguments),this.mode="offset",this.timeProperty="step",this.bins="bins",this.x="x",this.dx="dx",this.y="y",this.colorScale=kr.scaleOrdinal(kr.schemeCategory10),this.modeTransitionDuration=500,this._name=null,this._data=null}ready(){super.ready(),this.scopeSubtree(this.$.svg,!0)}attached(){this._attached=!0}detached(){this._attached=!1}setSeriesData(t,r){this._name=t,this._data=r,this.redraw()}_redrawOnChange(){this.redraw()}redraw(){this._draw(0)}_modeRedraw(){this._draw(this.modeTransitionDuration)}_draw(t){if(!this._attached||!this._data)return;if(t===void 0)throw new Error("vz-histogram-timeseries _draw needs duration");if(this._data.length<=0)throw new Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw new Error("No bins property of '"+this.bins+"' in data");if(this._data[0][this.bins].length<=0)throw new Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw new Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw new Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw new Error("No y property '"+this.y+"' on bins data");var r=this.timeProperty,n=this.x,i=this.bins,o=this.dx,a=this.y,s=this._data,l=this._name,c=this.mode,u=kr.hcl(this.colorScale(l)),h=kr.select(this.$.tooltip),f=function(Nt){return Nt[n]},p=function(Nt){return Nt[a]},d=function(Nt){return Nt[o]},g=function(Nt){return Nt[n]+Nt[o]},_=function(Nt){return Nt[r]};r==="relative"&&(_=function(Nt){return Nt.wall_time-s[0].wall_time});var y=this.$.svg.getBoundingClientRect(),x=y.width,b=y.height,S,C={top:5,right:60,bottom:20,left:24};c==="offset"?(S=b/2.5,C.top=S+5):S=b-C.top-C.bottom;var P=x-C.left-C.right,k=b-C.top-C.bottom,O=kr.min(s,f),D=kr.max(s,g),B=kr.format(".3n"),I=kr.format(".0f");r==="wall_time"?I=kr.timeFormat("%m/%d %X"):r==="relative"&&(I=function(Nt){return kr.format(".1r")(Nt/36e5)+"h"});var L=s.map(function(Nt,ze){return[kr.min(Nt[i],f),kr.max(Nt[i],g)]}),R=s.map(function(Nt){return kr.extent(Nt[i],p)}),F=500,z=kr.extent(s,_),U=(r==="wall_time"?kr.scaleTime():kr.scaleLinear()).domain(z).range([0,c==="offset"?k:0]),W=kr.scaleLinear().domain([0,kr.max(s,function(Nt,ze){return R[ze][1]})]).range([S,0]),Z=kr.scaleLinear().domain(W.domain()).range([F,0]),rt=kr.scaleLinear().domain([kr.min(s,function(Nt,ze){return L[ze][0]}),kr.max(s,function(Nt,ze){return L[ze][1]})]).nice().range([0,P]),ot=kr.scaleLinear().domain(rt.domain()).range([0,F]);let st=kr.scaleLinear().domain(kr.extent(s,_)).range([u.brighter(),u.darker()]).interpolate(kr.interpolateHcl);var St=kr.axisBottom(rt).ticks(Math.max(2,P/20)),bt=kr.axisRight(U).ticks(Math.max(2,k/15)).tickFormat(I),Mt=kr.axisRight(W).ticks(Math.max(2,k/15)).tickSize(P+5).tickFormat(B),lt=function(Nt){return Nt[n]+Nt[o]/2},Kt=kr.line().x(function(Nt){return ot(lt(Nt))}).y(function(Nt){return Z(Nt[a])}),_t=function(Nt){return"M"+ot(lt(Nt[0]))+","+Z(0)+"L"+Kt(Nt).slice(1)+"L"+ot(lt(Nt[Nt.length-1]))+","+Z(0)},ct=this.$.svg,X=kr.select(ct),et=X.transition().duration(t),dt=X.select("g").classed("small",function(){return P>0&&P<=150}).classed("medium",function(){return P>150&&P<=300}).classed("large",function(){return P>300}),q=et.select("g").attr("transform","translate("+C.left+","+C.top+")"),pt=kr.bisector(g).left,ht=dt.select(".stage").on("mouseover",function(){Tt.style("opacity",1),Ct.style("opacity",1),at.style("opacity",1),Ce.style("opacity",1),h.style("opacity",1)}).on("mouseout",function(){Tt.style("opacity",0),Ct.style("opacity",0),at.style("opacity",0),Ce.style("opacity",0),Tt.classed("hover-closest",!1),It.classed("outline-hover",!1),h.style("opacity",0)}).on("mousemove",Pt),wt=ht.select(".background").attr("transform","translate("+-C.left+","+-C.top+")").attr("width",x).attr("height",b),kt=ht.selectAll(".histogram").data(s),ie=kt.exit().remove(),ee=kt.enter().append("g").attr("class","histogram"),Le=ee.merge(kt).sort(function(Nt,ze){return _(Nt)-_(ze)}),ar=q.selectAll(".histogram").attr("transform",function(Nt){return"translate(0, "+(c==="offset"?U(_(Nt))-S:0)+")"}),fr=ee.append("line").attr("class","baseline"),tt=ar.select(".baseline").style("stroke-opacity",function(Nt){return c==="offset"?.1:0}).attr("y1",S).attr("y2",S).attr("x2",P),$=ee.append("path").attr("class","outline"),It=Le.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(Nt){return _t(Nt[i])}).style("stroke-width",1),$t=ar.select(".outline").attr("transform","scale("+P/F+", "+S/F+")").style("stroke",function(Nt){return c==="offset"?"":st(_(Nt))}).style("fill-opacity",function(Nt){return c==="offset"?1:0}).style("fill",function(Nt){return st(_(Nt))}),he=ee.append("g").attr("class","hover"),Tt=Le.select(".hover").style("fill",function(Nt){return st(_(Nt))});he.append("circle").attr("r",2),he.append("text").style("display","none").attr("dx",4);var be=dt.select(".x-axis-hover").selectAll(".label").data(["x"]),nt=be.enter().append("g").attr("class","label"),Ct=be.merge(nt);nt.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14),nt.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6),nt.append("text").attr("dy",18);var Wt=dt.select(".y-axis-hover").selectAll(".label").data(["y"]),fe=Wt.enter().append("g").attr("class","label"),at=Wt.merge(fe);fe.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),fe.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),fe.append("text").attr("dx",8).attr("dy",4);var se=dt.select(".y-slice-axis-hover").selectAll(".label").data(["y"]),Qt=se.enter().append("g").attr("class","label"),Ce=se.merge(Qt);Qt.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),Qt.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),Qt.append("text").attr("dx",8).attr("dy",4),q.select(".y.axis.slice").style("opacity",c==="offset"?0:1).attr("transform","translate(0, "+(c==="offset"?-S:0)+")").call(Mt),q.select(".x.axis").attr("transform","translate(0, "+k+")").call(St),q.select(".y.axis").style("opacity",c==="offset"?1:0).attr("transform","translate("+P+", "+(c==="offset"?0:k)+")").call(bt),q.selectAll(".tick text").attr("fill","#aaa"),q.selectAll(".axis path.domain").attr("stroke","none");function Pt(){var Nt=kr.mouse(this),ze=rt.invert(Nt[0]),yn=U.invert(Nt[1]);function Wi(cn){return Math.min(cn[i].length-1,pt(cn[i],ze))}var Ar,Ia=1/0,ho;Tt.attr("transform",function(cn,ux){var np=Wi(cn);ho=cn;var K=rt(cn[i][np][n]+cn[i][np][o]/2),gt=W(cn[i][np][a]),Et=c==="offset"?U(_(cn))-(S-gt):gt,xt=Math.abs(Nt[1]-Et);return xt<Ia&&(Ia=xt,Ar=cn),"translate("+K+","+gt+")"}),Tt.select("text").text(function(cn){var ux=Wi(cn);return cn[i][ux][a]}),Tt.classed("hover-closest",function(cn){return cn===Ar}),It.classed("outline-hover",function(cn){return cn===Ar});var La=Wi(ho);Ct.attr("transform",function(cn){return"translate("+rt(ho[i][La][n]+ho[i][La][o]/2)+", "+k+")"}).select("text").text(function(cn){return B(ho[i][La][n]+ho[i][La][o]/2)});var cx=bt.tickFormat();at.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?U(_(Ar)):0)+")"}).style("display",c==="offset"?"":"none").select("text").text(function(cn){return cx(_(Ar))});var um=Mt.tickFormat();Ce.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?0:W(Ar[i][La][a]))+")"}).style("display",c==="offset"?"none":"").select("text").text(function(cn){return um(Ar[i][La][a])});var Q0=kr.mouse(ct);h.style("transform","translate("+(Q0[0]+15)+"px,"+(Q0[1]-15)+"px)").select("span").text(c==="offset"?um(Ar[i][La][a]):(r==="step"?"step ":"")+cx(_(Ar)))}}};Ea.template=Q`
    <div id="tooltip"><span></span></div>
    <svg id="svg">
      <g>
        <g class="axis x"></g>
        <g class="axis y"></g>
        <g class="axis y slice"></g>
        <g class="stage">
          <rect class="background"></rect>
        </g>
        <g class="x-axis-hover"></g>
        <g class="y-axis-hover"></g>
        <g class="y-slice-axis-hover"></g>
      </g>
    </svg>

    <style>
      :host {
        color: #aaa;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
        --vz-histogram-timeseries-hover-bg-color: #fff;
        --vz-histogram-timeseries-outline-color: #fff;
        --vz-histogram-timeseries-hover-outline-color: #000;
      }

      :host(.dark-mode) {
        --vz-histogram-timeseries-hover-bg-color: var(
          --primary-background-color
        );
        --vz-histogram-timeseries-outline-color: var(--paper-grey-600);
        --vz-histogram-timeseries-hover-outline-color: #fff;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      text {
        fill: currentColor;
      }

      #tooltip {
        position: absolute;
        display: block;
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
      }

      .background {
        fill-opacity: 0;
        fill: red;
      }

      .histogram {
        pointer-events: none;
      }

      .hover {
        font-size: 9px;
        dominant-baseline: middle;
        opacity: 0;
      }

      .hover circle {
        stroke: white;
        stroke-opacity: 0.5;
        stroke-width: 1px;
      }

      .hover text {
        fill: black;
        opacity: 0;
      }

      .hover.hover-closest circle {
        fill: var(--vz-histogram-timeseries-hover-outline-color) !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: var(--vz-histogram-timeseries-outline-color);
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: var(--vz-histogram-timeseries-hover-outline-color) !important;
        stroke-opacity: 1;
      }

      .x-axis-hover,
      .y-axis-hover,
      .y-slice-axis-hover {
        pointer-events: none;
      }

      .x-axis-hover .label,
      .y-axis-hover .label,
      .y-slice-axis-hover .label {
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
        text-anchor: end;
      }

      .x-axis-hover text {
        text-anchor: middle;
      }

      .y-axis-hover text,
      .y-slice-axis-hover text {
        text-anchor: start;
      }

      .x-axis-hover line,
      .y-axis-hover line,
      .y-slice-axis-hover line {
        stroke: currentColor;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: var(--vz-histogram-timeseries-hover-bg-color);
      }

      #tooltip,
      .x-axis-hover text,
      .y-axis-hover text,
      .y-slice-axis-hover text {
        color: var(--vz-histogram-timeseries-hover-outline-color);
      }

      .axis {
        font-size: 11px;
      }

      .axis path.domain {
        fill: none;
      }

      .axis .tick line {
        stroke: #ddd;
      }

      .axis.slice {
        opacity: 0;
      }

      .axis.slice .tick line {
        stroke-dasharray: 2;
      }

      .small .axis text {
        display: none;
      }
      .small .axis .tick:first-of-type text {
        display: block;
      }
      .small .axis .tick:last-of-type text {
        display: block;
      }
      .medium .axis text {
        display: none;
      }
      .medium .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
      .large .axis text {
        display: none;
      }
      .large .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ea.prototype,"mode",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"bins",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"x",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"dx",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"y",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"colorScale",void 0);E([A({type:Number}),w("design:type",Number)],Ea.prototype,"modeTransitionDuration",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ea.prototype,"_attached",void 0);E([A({type:String}),w("design:type",Object)],Ea.prototype,"_name",void 0);E([A({type:Array}),w("design:type",Object)],Ea.prototype,"_data",void 0);E([Bt("timeProperty","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_redrawOnChange",null);E([Bt("mode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_modeRedraw",null);Ea=E([yt("vz-histogram-timeseries")],Ea);function yur(e){let[t,r,n]=e;return{wall_time:t,step:r,min:km(n.map(([i,,])=>i)),max:lu(n.map(([,i])=>i)),buckets:n.map(([i,o,a])=>({left:i,right:o,count:a}))}}function vur(e,t,r,n=30){(t===void 0||r==null)&&(t=0,r=0),r===t&&(r=t*1.1+1,t=t/1.1-1);let i=(r-t)/n,o=0,a=[];for(let s=0;s<n;s++){let l=t+s*i,c=l+i,u=0;for(;o<e.buckets.length;){let h=Math.min(r,e.buckets[o].right),f=Math.max(t,e.buckets[o].left);if(h-f>0){let d=Math.min(h,c)-Math.max(f,l),g=d/(h-f)*e.buckets[o].count;u+=d>0?g:0}else{let d=c>=r;u+=l<=f&&(d?h<=c:h<c)?e.buckets[o].count:0}if(h>c)break;o++}a.push({x:l,dx:i,y:u})}return a}function sce(e){let t=e.map(yur),r=km(t,i=>i.min),n=lu(t,i=>i.max);return t.map(i=>({wall_time:i.wall_time,step:i.step,bins:vur(i,r,n)}))}var Ta=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=_e().pluginRoute("histograms","/histograms");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=sce(n),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i)},this._colorScaleFunction=fn,this._expanded=!1}_reloadOnRunTagRequestManagerChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};Ta.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main histogram that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-histogram-timeseries
      id="chart"
      time-property="[[timeProperty]]"
      mode="[[histogramMode]]"
      color-scale="[[_colorScaleFunction]]"
    ></vz-histogram-timeseries>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
        will-change: transform;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
        width: 90%;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ta.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ta.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],Ta.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Ae)],Ta.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],Ta.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],Ta.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Ta.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ta.prototype,"histogramMode",void 0);E([A({type:Object}),w("design:type",Function)],Ta.prototype,"_colorScaleFunction",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Ta.prototype,"_expanded",void 0);E([Bt("run","tag","requestManager"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ta.prototype,"_reloadOnRunTagRequestManagerChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ta.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ta.prototype,"_runColor",null);Ta=E([yt("tf-histogram-loader")],Ta);var cs=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._histogramMode="offset",this._timeProperty="step",this._restamp=!1,this._requestManager=new Ae}_redrawCategoryPane(t,r){!r||t.target.querySelectorAll("tf-histogram-loader").forEach(n=>n.redraw())}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadHistograms()})}_fetchTags(){let t=_e().pluginRoute("histograms","/tags");return this._requestManager.request(t).then(r=>{if(NH.isEqual(r,this._runToTagInfo))return;let n=NH.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadHistograms(){var t;(t=this.root)==null||t.querySelectorAll("tf-histogram-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};cs.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="histogramModeSelector"
              name="Histogram mode"
              selected-id="{{_histogramMode}}"
            >
              <paper-button id="overlay">overlay</paper-button>
              <paper-button id="offset">offset</paper-button>
            </tf-option-selector>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="timePropertySelector"
              name="Offset time axis"
              selected-id="{{_timeProperty}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No histogram data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-histogram-loader
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  active="[[active]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  time-property="[[_timeProperty]]"
                  histogram-mode="[[_histogramMode]]"
                  request-manager="[[_requestManager]]"
                ></tf-histogram-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],cs.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],cs.prototype,"_histogramMode",void 0);E([A({type:String}),w("design:type",String)],cs.prototype,"_timeProperty",void 0);E([A({type:Array}),w("design:type",Array)],cs.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],cs.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],cs.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],cs.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],cs.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],cs.prototype,"_restamp",void 0);E([A({type:Boolean}),w("design:type",Boolean)],cs.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],cs.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],cs.prototype,"_categories",null);cs=E([yt("tf-histogram-dashboard")],cs);var u3=class{constructor(t,r=!0){this._requestManager=t,this._useHttpGet=r}getExperiment(t){return this._sendRequest("/experiment",t)}getDownloadUrl(t,r,n){return _e().pluginRouteForSrc("hparams","/download_data",new URLSearchParams({format:t,columnsVisibility:JSON.stringify(n),request:JSON.stringify(r)}))}listSessionGroups(t){return this._sendRequest("/session_groups",t)}listMetricEvals(t){return this._sendRequest("/metric_evals",t)}_sendRequest(t,r){if(this._useHttpGet){let o=_e().pluginRoute("hparams",t,new URLSearchParams({request:JSON.stringify(r)}));return this._requestManager.request(o)}let n=new Ux;n.withCredentials=!0,n.methodType=Pm.POST,n.contentType="text/plain",n.body=JSON.stringify(r);let i=_e().pluginRoute("hparams",t);return this._requestManager.requestWithOptions(i,n)}};var _ce=Ee(Oe(),1);var DH=class extends mt{constructor(){super(...arguments),this.orientation="horizontal"}};DH.template=Q`
    <slot name="content"></slot>

    <style>
      :host {
        display: block;
      }

      :host slot {
        display: flex;
        height: 100%;
        width: 100%;
      }

      :host ::slotted(*) {
        flex: 0 0 auto;
      }

      :host([orientation='horizontal']) slot {
        flex-direction: row;
        overflow-x: auto;
      }

      :host([orientation='vertical']) slot {
        flex-direction: column;
        overflow-y: auto;
      }

      :host ::slotted(*:not(:last-child)) {
        border: 0 solid var(--divider-color, #ccc);
      }

      :host([orientation='vertical']) ::slotted(*:not(:last-child)) {
        border-bottom-width: 5px;
      }

      :host([orientation='horizontal']) ::slotted(*:not(:last-child)) {
        border-right-width: 5px;
      }
    </style>
  `;E([A({type:String,reflectToAttribute:!0}),w("design:type",String)],DH.prototype,"orientation",void 0);DH=E([yt("hparams-split-layout")],DH);var us={};Zs(us,{columnValueByIndex:()=>b0,columnValueByVisibleIndex:()=>BH,euclideanDist:()=>h3,filterSet:()=>Pur,getAbsoluteColumnIndex:()=>zH,hashOfString:()=>dct,hparamName:()=>Bd,hparamValueByIndex:()=>hce,hparamValueByName:()=>uce,hparamValueByVisibleIndex:()=>mce,isNullOrUndefined:()=>Tur,l2NormSquared:()=>p3,metricName:()=>Qu,metricValueByIndex:()=>fce,metricValueByName:()=>f3,metricValueByVisibleIndex:()=>FH,numColumns:()=>uct,numHParams:()=>lce,numMetrics:()=>cce,numVisibleColumns:()=>wur,numVisibleHParams:()=>pce,numVisibleMetrics:()=>dce,numericColumnExtent:()=>hct,pointToRectangleDist:()=>gce,prettyPrint:()=>w0,prettyPrintHParamValueByName:()=>Sur,prettyPrintMetricValueByName:()=>Mur,quadTreeVisitPointsInDisk:()=>Aur,quadTreeVisitPointsInRect:()=>Cur,rotateStr:()=>Eur,schemaColumnName:()=>cct,schemaVisibleColumnName:()=>bur,sessionGroupWithName:()=>fct,setArrayObservably:()=>pct,translateStr:()=>yP,visibleNumericColumnExtent:()=>_P});var OH=Ee(Oe(),1);function Bd(e){return e.displayName!==""&&e.displayName!==void 0?e.displayName:e.name}function Qu(e){if(e.displayName!==""&&e.displayName!==void 0)return e.displayName;let t=e.name.group,r=e.name.tag;return t===void 0&&(t=""),r===void 0&&(r=""),t===""||t==="."?r:t+"."+r}function cct(e,t){if(t<e.hparamColumns.length)return Bd(e.hparamColumns[t].hparamInfo);let r=t-e.hparamColumns.length;return Qu(e.metricColumns[r].metricInfo)}function lce(e){return e.hparamColumns.length}function cce(e){return e.metricColumns.length}function uct(e){return lce(e)+cce(e)}function uce(e,t){return e[t]}function f3(e,t){return e.find(r=>OH.isEqual(r.name,t))}function hce(e,t,r){return t.hparams[e.hparamColumns[r].hparamInfo.name]}function fce(e,t,r){let n=e.metricColumns[r].metricInfo.name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function b0(e,t,r){return r<e.hparamColumns.length?hce(e,t,r):fce(e,t,r-e.hparamColumns.length)}function hct(e,t,r){return sa(t,n=>b0(e,n,r))}function zH(e,t,r){let n;if(r<t.hparamInfos.length)n=e.hparamColumns.findIndex(i=>i.hparamInfo.name===t.hparamInfos[r].name);else{let i=r-t.hparamInfos.length,o=t.metricInfos[i].name;n=e.hparamColumns.length+e.metricColumns.findIndex(a=>a.metricInfo.name===o)}return console.assert(n!==-1),n}function bur(e,t){if(t<e.hparamInfos.length)return Bd(e.hparamInfos[t]);let r=t-e.hparamInfos.length;return Qu(e.metricInfos[r])}function pce(e){return e.hparamInfos.length}function dce(e){return e.metricInfos.length}function wur(e){return pce(e)+dce(e)}function _P(e,t,r){return sa(t,n=>BH(e,n,r))}function Sur(e,t){return w0(uce(e,t))}function Mur(e,t){return w0(f3(e,t))}function fct(e,t){return e.find(r=>r.name===t)}function mce(e,t,r){return t.hparams[e.hparamInfos[r].name]}function FH(e,t,r){let n=e.metricInfos[r].name,i=f3(t.metricValues,n);return i===void 0||i.value==="NaN"?void 0:i.value}function BH(e,t,r){return r<e.hparamInfos.length?mce(e,t,r):FH(e,t,r-e.hparamInfos.length)}function w0(e){return OH.isNumber(e)?e.toPrecision(5):e==null?"":e.toString()}function p3(e,t){return e*e+t*t}function h3(e,t,r,n){return Math.sqrt(p3(e-r,t-n))}function gce(e,t,r,n,i,o){if(e<r&&t<n)return h3(e,t,r,n);if(r<=e&&e<i&&t<n)return n-t;if(i<=e&&t<n)return h3(e,t,i,n);if(e<r&&n<=t&&t<o)return r-e;if(r<=e&&e<i&&n<=t&&t<o)return 0;if(i<=e&&n<=t&&t<o)return e-i;if(e<r&&o<=t)return h3(e,t,r,o);if(r<=e&&e<i&&o<=t)return t-o;if(i<=e&&o<=t)return h3(e,t,i,o);throw"Point (x,y) must be in one of the regions defined above."}function yP(e,t){return t===void 0?"translate("+e+")":"translate("+e+","+t+")"}function Eur(e,t,r){let n="rotate("+e;return t!==void 0&&r!==void 0&&(n=n+","+t+","+r),n=n+")",n}function Tur(e){return e==null}function Cur(e,t,r,n,i,o){e.visit((a,s,l,c,u)=>{if(a.length===void 0){do{let h=e.x()(a.data),f=e.y()(a.data);t<=h&&h<n&&r<=f&&f<i&&o(a.data)}while(a=a.next);return!0}return s>=n||c<=t||l>=i||u<=r})}function Aur(e,t,r,n,i){e.visit((o,a,s,l,c)=>{if(o.length===void 0){do{let u=e.x()(o.data),h=e.y()(o.data),f=h3(t,r,u,h);f<=n&&i(o.data,f)}while(o=o.next);return!0}return gce(t,r,a,s,l,c)>n})}function Pur(e,t){let r=new Set;return e.forEach(n=>{t(n)&&r.add(n)}),r}function pct(e,t,r){let n=e.get(t,e);if(!Array.isArray(n)){e.set(t,r);return}e.splice.apply(e,[t,0,n.length].concat(r))}function dct(e){let t=0;for(let r=0;r<e.length;++r)t=t*31+e.charCodeAt(r)&4294967295;return t+TI(2,31)}var Iur=10,In=class extends Gt(mt){constructor(){super(...arguments),this.configuration={schema:{hparamColumns:Array(),metricColumns:Array()},columnsVisibility:Array(),visibleSchema:{hparamInfos:Array(),metricInfos:Array()}},this.sessionGroups=[],this.dataLoadedWithNonEmptyHparams=!1,this.dataLoadedWithEmptyHparams=!1,this._maxNumHparamsToLoad=1e3,this._tooManyHparams=!1,this._statuses=[{value:"STATUS_UNKNOWN",displayName:"Unknown",allowed:!0},{value:"STATUS_SUCCESS",displayName:"Success",allowed:!0},{value:"STATUS_FAILURE",displayName:"Failure",allowed:!0},{value:"STATUS_RUNNING",displayName:"Running",allowed:!0}],this._getExperimentResolved=new Promise(t=>{this._resolveGetExperiment=t}),this._listSessionGroupsCanceller=new an,this._pageSizeInput={value:"100",invalid:!1},this._pageNumberInput={value:"1",invalid:!1},this._pageCountStr="?",this._hparamName=Bd,this._metricName=Qu,this._prettyPrint=w0}reload(){this._queryServer()}_csvUrl(t,r){return this._downloadDataUrl(t,r,"csv")}_jsonUrl(t,r){return this._downloadDataUrl(t,r,"json")}_latexUrl(t,r){return this._downloadDataUrl(t,r,"latex")}_downloadDataUrl(t,r,n){let i=r.columnsVisibility;return this.backend.getDownloadUrl(n,t,i)}_computeExperimentAndRelatedProps(){let t=us;if(t.isNullOrUndefined(this.backend)||t.isNullOrUndefined(this.experimentName))return;let r={experimentName:this.experimentName,hparamsLimit:this._maxNumHparamsToLoad};this.backend.getExperiment(r).then(n=>{_ce.isEqual(n,this._experiment)||(this.set("_experiment",n),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())}).finally(()=>{this._computeDataFound()})}_computeDataFound(){let t=Boolean(this._experiment&&this._experiment.hparamInfos&&this._experiment.hparamInfos.length>0);this.set("dataLoadedWithNonEmptyHparams",t),this.set("dataLoadedWithEmptyHparams",!t)}_computeHParams(){let t=[];this._experiment.hparamInfos.forEach(i=>{let o={info:i,displayed:!1,filter:{}};o.info.hasOwnProperty("domainDiscrete")?o.info.domainDiscrete.length<Iur?(o.filter.domainDiscrete=[],o.info.domainDiscrete.forEach(a=>{o.filter.domainDiscrete.push({value:a,checked:!0})})):o.filter.regexp="":o.info.type==="DATA_TYPE_FLOAT64"?o.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:console.warn("cannot process domain type %s without discrete domain values",o.info.type),t.push(o)}),t.sort((i,o)=>i.info.differs===o.info.differs?0:i.info.differs?-1:1);let n=Math.min(5,t.length);for(let i=0;i<n;i++)t[i].displayed=!0;this.set("_hparams",t),this.set("_TooManyHparams",t.length>=this._maxNumHparamsToLoad)}_computeMetrics(){let t=[];this._experiment.metricInfos.forEach((n,i)=>{let o={info:n,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:i<5};t.push(o)}),this.set("_metrics",t)}_computeSchema(){return!this._hparams||!this._metrics?{hparamColumns:[],metricColumns:[]}:{hparamColumns:this._hparams.map(t=>({hparamInfo:t.info})),metricColumns:this._metrics.map(t=>({metricInfo:t.info}))}}_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this.configuration={schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),visibleSchema:this._computeVisibleSchema()}})}_computeColumnsVisibility(){return!this._hparams||!this._metrics?[]:this._hparams.map(t=>t.displayed).concat(this._metrics.map(t=>t.displayed))}_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};let t=this._hparams.filter(n=>n.displayed).map(n=>n.info),r=this._metrics.filter(n=>n.displayed).map(n=>n.info);return{hparamInfos:t,metricInfos:r}}_hasRegexpFilter(t){return t.filter.regexp!==void 0}_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),100)}_queryServerNoDebounce(){if(!(!this._hparams||!this._metrics))return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:t,cancelled:r})=>{if(!r){if(t.totalSize>=0){let n=+this._pageSizeInput.value;this.set("_pageCountStr",String(Math.ceil(t.totalSize/n))),this.set("_totalSessionGroupsCountStr",t.totalSize)}else this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown");pct(this,"sessionGroups",t.sessionGroups)}}))}_sendListSessionGroupsRequest(){let t=this._buildListSessionGroupsRequest();if(t!==null)return this.set("_sessionGroupsRequest",t),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(t)}_buildListSessionGroupsRequest(){let t=this,r=!0;function n(h){return h.min.value!==""||h.max.value!==""}function i(h){let f=t.get(h+".min.value");console.assert(f!==void 0);let p=f===""?"-Infinity":+f,d=isNaN(p);t.set(h+".min.invalid",d),r=r&&!d;let g=t.get(h+".max.value");console.assert(g!==void 0);let _=g===""?"Infinity":+g,y=isNaN(_);return t.set(h+".max.invalid",y),r=r&&!y,d||y?null:{minValue:p,maxValue:_}}function o(h){let f=t.get(h+".value");console.assert(f!==void 0);let p=+f,d=Number.isInteger(p)&&p>0;return t.set(h+".invalid",!d),r=r&&d,d?p:null}let a=this._statuses.filter(h=>h.allowed).map(h=>h.value),s=[];if(this._hparams.forEach((h,f)=>{let p={hparam:h.info.name,includeInResult:!0};h.filter.domainDiscrete?h.filter.domainDiscrete.every(g=>g.checked)||(p.filterDiscrete=[],h.filter.domainDiscrete.forEach(g=>{g.checked&&p.filterDiscrete.push(g.value)})):h.filter.interval?n(h.filter.interval)&&(p.filterInterval=i("_hparams."+f+".filter.interval")):h.filter.regexp&&(p.filterRegexp=h.filter.regexp),s.push(p)}),this._metrics.forEach((h,f)=>{let p={metric:h.info.name,includeInResult:!0};n(h.filter.interval)&&(p.filterInterval=i("_metrics."+f+".filter.interval")),s.push(p)}),this._sortByIndex!==void 0&&this._sortDirection!==void 0){if(!(this._sortByIndex in s))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;s[this._sortByIndex].order=this._sortDirection===0?"ORDER_ASC":"ORDER_DESC"}let l=o("_pageNumberInput")||0,c=o("_pageSizeInput")||0;if(!r)return null;let u=c*(l-1);return{experimentName:this.experimentName,allowedStatuses:a,colParams:s,startIndex:u,sliceSize:c}}_metricSortByIndex(t){return t+this._hparams.length}};In.template=Q`
    <hparams-split-layout orientation="vertical">
      <div slot="content" class="section hyperparameters">
        <div class="section-title">Hyperparameters</div>
        <template is="dom-if" if="[[_TooManyHparams]]">
          <div class="too-many-hparams">
            Warning: There were too many hparams to load all of them
            efficiently. Only [[_maxNumHparamsToLoad]] were loaded.
          </div>
        </template>
        <template is="dom-repeat" items="{{_hparams}}" as="hparam">
          <div class="hparam">
            <paper-checkbox
              checked="{{hparam.displayed}}"
              class="hparam-checkbox"
            >
              [[_hparamName(hparam.info)]]
            </paper-checkbox>
            <!-- Precisely one of the templates below will be stamped.-->
            <!-- 1. A list of checkboxes -->
            <template is="dom-if" if="[[hparam.filter.domainDiscrete]]">
              <template
                is="dom-repeat"
                items="[[hparam.filter.domainDiscrete]]"
              >
                <paper-checkbox
                  checked="{{item.checked}}"
                  class="discrete-value-checkbox"
                  on-change="_queryServer"
                >
                  [[_prettyPrint(item.value)]]
                </paper-checkbox>
              </template>
            </template>
            <!-- 2. A numeric interval -->
            <template is="dom-if" if="[[hparam.filter.interval]]">
              <paper-input
                label="Min"
                value="{{hparam.filter.interval.min.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.min.invalid]]"
                placeholder="-infinity"
              >
              </paper-input>
              <paper-input
                label="Max"
                value="{{hparam.filter.interval.max.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.max.invalid]]"
                placeholder="+infinity"
              >
              </paper-input>
            </template>
            <!-- 3. A regexp -->
            <template is="dom-if" if="[[_hasRegexpFilter(hparam)]]">
              <paper-input
                label="Regular expression"
                value="{{hparam.filter.regexp}}"
                on-value-changed="_queryServer"
              >
              </paper-input>
            </template>
          </div>
        </template>
      </div>
      <div slot="content" class="section metrics">
        <div class="section-title">Metrics</div>
        <template is="dom-repeat" items="{{_metrics}}" as="metric">
          <div class="metric">
            <!-- TODO(erez): Make it easier to handle a large number of
                  metrics:
                  1. Add an 'isolator' radio-button to select just one
                  metric and
                  hide all the rest
                  2. Add a 'toggle-all' button that will hide/unhide
                    all the
                  metrics.
                  Use similar logic/appearance to the run-selector of
                  scalars.-->
            <paper-checkbox
              checked="{{metric.displayed}}"
              class="metric-checkbox"
            >
              [[_metricName(metric.info)]]
            </paper-checkbox>
            <div class="inline-element">
              <paper-input
                label="Min"
                value="{{metric.filter.interval.min.value}}"
                allowed-pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.min.invalid}}"
                placeholder="-infinity"
              >
              </paper-input>
            </div>
            <div class="inline-element">
              <paper-input
                label="Max"
                allowed-pattern="[0-9.e\\-]"
                value="{{metric.filter.interval.max.value}}"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.max.invalid}}"
                placeholder="+infinity"
              >
              </paper-input>
            </div>
          </div>
        </template>
      </div>
      <div slot="content" class="section status">
        <div class="section-title">Status</div>
        <template is="dom-repeat" items="[[_statuses]]" as="status">
          <paper-checkbox checked="{{status.allowed}}" on-change="_queryServer">
            [[status.displayName]]
          </paper-checkbox>
        </template>
      </div>
      <div slot="content" class="section sorting">
        <div class="section-title">Sorting</div>
        <paper-dropdown-menu
          label="Sort by"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortByIndex}}"
            on-selected-item-changed="_queryServer"
          >
            <template is="dom-repeat" items="[[_hparams]]" as="hparam">
              <paper-item> [[_hparamName(hparam.info)]] </paper-item>
            </template>
            <template is="dom-repeat" items="[[_metrics]]" as="metric">
              <paper-item> [[_metricName(metric.info)]] </paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-dropdown-menu
          label="Direction"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortDirection}}"
          >
            <paper-item>Ascending</paper-item>
            <paper-item>Descending</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <div slot="content" class="section paging">
        <div class="section-title">Paging</div>
        <div>
          Number of matching session groups: [[_totalSessionGroupsCountStr]]
        </div>
        <div class="inline-element page-number-input">
          <paper-input
            label="Page #"
            value="{{_pageNumberInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageNumberInput.invalid]]"
            on-value-changed="_queryServer"
          >
            <div slot="suffix" class="page-suffix">/ [[_pageCountStr]]</div>
          </paper-input>
        </div>
        <div class="inline-element page-size-input">
          <paper-input
            label="Max # of session groups per page:"
            value="{{_pageSizeInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageSizeInput.invalid]]"
            on-value-changed="_queryServer"
          >
          </paper-input>
        </div>
      </div>
      <div slot="content" class="section download">
        <template is="dom-if" if="[[_sessionGroupsRequest]]">
          Download data as
          <span>
            <a
              id="csvLink"
              download="hparams_table.csv"
              href="[[_csvUrl(_sessionGroupsRequest, configuration)]]"
              >CSV</a
            >
            <a
              id="jsonLink"
              download="hparams_table.json"
              href="[[_jsonUrl(_sessionGroupsRequest, configuration)]]"
              >JSON</a
            >
            <a
              id="latexLink"
              download="hparams_table.tex"
              href="[[_latexUrl(_sessionGroupsRequest, configuration)]]"
              >LaTeX</a
            >
          </span>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      .too-many-hparams {
        color: var(--tb-orange-dark);
        font-size: 13px;
        font-style: italic;
        margin: 12px 0;
      }
      .discrete-value-checkbox,
      .metric-checkbox,
      .hparam-checkbox {
        display: block;
      }
      .discrete-value-checkbox {
        margin-left: 20px;
      }
      .hparam,
      .metric {
        display: block;
      }
      .inline-element {
        display: inline-block;
        width: 40%;
        margin-left: 10px;
      }
      .page-number-input {
        width: 20%;
      }
      .page-size-input {
        width: 60%;
      }
      vaadin-split-layout {
        height: 100%;
      }
      paper-listbox {
        max-height: 15em;
      }
      .page-suffix {
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],In.prototype,"experimentName",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],In.prototype,"configuration",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],In.prototype,"sessionGroups",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],In.prototype,"dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],In.prototype,"dataLoadedWithEmptyHparams",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_experiment",void 0);E([A({type:Array}),w("design:type",Array)],In.prototype,"_hparams",void 0);E([A({type:Number}),w("design:type",Number)],In.prototype,"_maxNumHparamsToLoad",void 0);E([A({type:Boolean}),w("design:type",Boolean)],In.prototype,"_tooManyHparams",void 0);E([A({type:Array}),w("design:type",Array)],In.prototype,"_metrics",void 0);E([A({type:Array}),w("design:type",Object)],In.prototype,"_statuses",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_getExperimentResolved",void 0);E([A({type:Object}),w("design:type",Function)],In.prototype,"_resolveGetExperiment",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_listSessionGroupsCanceller",void 0);E([A({type:Number}),w("design:type",Number)],In.prototype,"_sortByIndex",void 0);E([A({type:Number}),w("design:type",Number)],In.prototype,"_sortDirection",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_pageSizeInput",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_pageNumberInput",void 0);E([A({type:String}),w("design:type",String)],In.prototype,"_pageCountStr",void 0);E([A({type:String}),w("design:type",String)],In.prototype,"_totalSessionGroupsCountStr",void 0);E([A({type:Object}),w("design:type",Object)],In.prototype,"_sessionGroupsRequest",void 0);E([Bt("backend","experimentName"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],In.prototype,"_computeExperimentAndRelatedProps",null);E([Bt("_hparams.*","_metrics.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],In.prototype,"_updateConfiguration",null);In=E([yt("tf-hparams-query-pane")],In);var Uct=Ee(Oe(),1);var mct=typeof window!="undefined"&&window.customElements!=null&&window.customElements.polyfillWrapFlushCallback!==void 0;var o1=(e,t,r=null)=>{for(;t!==r;){let n=t.nextSibling;e.removeChild(t),t=n}};var Yc=`{{lit-${String(Math.random()).slice(2)}}}`,gct=`<!--${Yc}-->`,yce=new RegExp(`${Yc}|${gct}`),d3="$lit$",a1=class{constructor(t,r){this.parts=[],this.element=r;let n=[],i=[],o=document.createTreeWalker(r.content,133,null,!1),a=0,s=-1,l=0,{strings:c,values:{length:u}}=t;for(;l<u;){let h=o.nextNode();if(h===null){o.currentNode=i.pop();continue}if(s++,h.nodeType===1){if(h.hasAttributes()){let f=h.attributes,{length:p}=f,d=0;for(let g=0;g<p;g++)vce(f[g].name,d3)&&d++;for(;d-- >0;){let g=c[l],_=HH.exec(g)[2],y=_.toLowerCase()+d3,x=h.getAttribute(y);h.removeAttribute(y);let b=x.split(yce);this.parts.push({type:"attribute",index:s,name:_,strings:b}),l+=b.length-1}}h.tagName==="TEMPLATE"&&(i.push(h),o.currentNode=h.content)}else if(h.nodeType===3){let f=h.data;if(f.indexOf(Yc)>=0){let p=h.parentNode,d=f.split(yce),g=d.length-1;for(let _=0;_<g;_++){let y,x=d[_];if(x==="")y=jf();else{let b=HH.exec(x);b!==null&&vce(b[2],d3)&&(x=x.slice(0,b.index)+b[1]+b[2].slice(0,-d3.length)+b[3]),y=document.createTextNode(x)}p.insertBefore(y,h),this.parts.push({type:"node",index:++s})}d[g]===""?(p.insertBefore(jf(),h),n.push(h)):h.data=d[g],l+=g}}else if(h.nodeType===8)if(h.data===Yc){let f=h.parentNode;(h.previousSibling===null||s===a)&&(s++,f.insertBefore(jf(),h)),a=s,this.parts.push({type:"node",index:s}),h.nextSibling===null?h.data="":(n.push(h),s--),l++}else{let f=-1;for(;(f=h.data.indexOf(Yc,f+1))!==-1;)this.parts.push({type:"node",index:-1}),l++}}for(let h of n)h.parentNode.removeChild(h)}},vce=(e,t)=>{let r=e.length-t.length;return r>=0&&e.slice(r)===t},vP=e=>e.index!==-1,jf=()=>document.createComment(""),HH=/([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;var _ct=133;function yct(e,t){let{element:{content:r},parts:n}=e,i=document.createTreeWalker(r,_ct,null,!1),o=xP(n),a=n[o],s=-1,l=0,c=[],u=null;for(;i.nextNode();){s++;let h=i.currentNode;for(h.previousSibling===u&&(u=null),t.has(h)&&(c.push(h),u===null&&(u=h)),u!==null&&l++;a!==void 0&&a.index===s;)a.index=u!==null?-1:a.index-l,o=xP(n,o),a=n[o]}c.forEach(h=>h.parentNode.removeChild(h))}var Lur=e=>{let t=e.nodeType===11?0:1,r=document.createTreeWalker(e,_ct,null,!1);for(;r.nextNode();)t++;return t},xP=(e,t=-1)=>{for(let r=t+1;r<e.length;r++){let n=e[r];if(vP(n))return r}return-1};function xce(e,t,r=null){let{element:{content:n},parts:i}=e;if(r==null){n.appendChild(t);return}let o=document.createTreeWalker(n,_ct,null,!1),a=xP(i),s=0,l=-1;for(;o.nextNode();)for(l++,o.currentNode===r&&(s=Lur(t),r.parentNode.insertBefore(t,r));a!==-1&&i[a].index===l;){if(s>0){for(;a!==-1;)i[a].index+=s,a=xP(i,a);return}a=xP(i,a)}}var kur=new WeakMap;var s1=e=>typeof e=="function"&&kur.has(e);var kl={},VH={};var S0=class{constructor(t,r,n){this.__parts=[],this.template=t,this.processor=r,this.options=n}update(t){let r=0;for(let n of this.__parts)n!==void 0&&n.setValue(t[r]),r++;for(let n of this.__parts)n!==void 0&&n.commit()}_clone(){let t=mct?this.template.element.content.cloneNode(!0):document.importNode(this.template.element.content,!0),r=[],n=this.template.parts,i=document.createTreeWalker(t,133,null,!1),o=0,a=0,s,l=i.nextNode();for(;o<n.length;){if(s=n[o],!vP(s)){this.__parts.push(void 0),o++;continue}for(;a<s.index;)a++,l.nodeName==="TEMPLATE"&&(r.push(l),i.currentNode=l.content),(l=i.nextNode())===null&&(i.currentNode=r.pop(),l=i.nextNode());if(s.type==="node"){let c=this.processor.handleTextExpression(this.options);c.insertAfterNode(l.previousSibling),this.__parts.push(c)}else this.__parts.push(...this.processor.handleAttributeExpressions(l,s.name,s.strings,this.options));o++}return mct&&(document.adoptNode(t),customElements.upgrade(t)),t}};var bce=window.trustedTypes&&trustedTypes.createPolicy("lit-html",{createHTML:e=>e}),Nur=` ${Yc} `,M0=class{constructor(t,r,n,i){this.strings=t,this.values=r,this.type=n,this.processor=i}getHTML(){let t=this.strings.length-1,r="",n=!1;for(let i=0;i<t;i++){let o=this.strings[i],a=o.lastIndexOf("<!--");n=(a>-1||n)&&o.indexOf("-->",a+1)===-1;let s=HH.exec(o);s===null?r+=o+(n?Nur:gct):r+=o.substr(0,s.index)+s[1]+s[2]+d3+s[3]+Yc}return r+=this.strings[t],r}getTemplateElement(){let t=document.createElement("template"),r=this.getHTML();return bce!==void 0&&(r=bce.createHTML(r)),t.innerHTML=r,t}};var GH=e=>e===null||!(typeof e=="object"||typeof e=="function"),UH=e=>Array.isArray(e)||!!(e&&e[Symbol.iterator]),m3=class{constructor(t,r,n){this.dirty=!0,this.element=t,this.name=r,this.strings=n,this.parts=[];for(let i=0;i<n.length-1;i++)this.parts[i]=this._createPart()}_createPart(){return new bP(this)}_getValue(){let t=this.strings,r=t.length-1,n=this.parts;if(r===1&&t[0]===""&&t[1]===""){let o=n[0].value;if(typeof o=="symbol")return String(o);if(typeof o=="string"||!UH(o))return o}let i="";for(let o=0;o<r;o++){i+=t[o];let a=n[o];if(a!==void 0){let s=a.value;if(GH(s)||!UH(s))i+=typeof s=="string"?s:String(s);else for(let l of s)i+=typeof l=="string"?l:String(l)}}return i+=t[r],i}commit(){this.dirty&&(this.dirty=!1,this.element.setAttribute(this.name,this._getValue()))}},bP=class{constructor(t){this.value=void 0,this.committer=t}setValue(t){t!==kl&&(!GH(t)||t!==this.value)&&(this.value=t,s1(t)||(this.committer.dirty=!0))}commit(){for(;s1(this.value);){let t=this.value;this.value=kl,t(this)}this.value!==kl&&this.committer.commit()}},Hd=class{constructor(t){this.value=void 0,this.__pendingValue=void 0,this.options=t}appendInto(t){this.startNode=t.appendChild(jf()),this.endNode=t.appendChild(jf())}insertAfterNode(t){this.startNode=t,this.endNode=t.nextSibling}appendIntoPart(t){t.__insert(this.startNode=jf()),t.__insert(this.endNode=jf())}insertAfterPart(t){t.__insert(this.startNode=jf()),this.endNode=t.endNode,t.endNode=this.startNode}setValue(t){this.__pendingValue=t}commit(){if(this.startNode.parentNode===null)return;for(;s1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=kl,r(this)}let t=this.__pendingValue;t!==kl&&(GH(t)?t!==this.value&&this.__commitText(t):t instanceof M0?this.__commitTemplateResult(t):t instanceof Node?this.__commitNode(t):UH(t)?this.__commitIterable(t):t===VH?(this.value=VH,this.clear()):this.__commitText(t))}__insert(t){this.endNode.parentNode.insertBefore(t,this.endNode)}__commitNode(t){this.value!==t&&(this.clear(),this.__insert(t),this.value=t)}__commitText(t){let r=this.startNode.nextSibling;t=t==null?"":t;let n=typeof t=="string"?t:String(t);r===this.endNode.previousSibling&&r.nodeType===3?r.data=n:this.__commitNode(document.createTextNode(n)),this.value=t}__commitTemplateResult(t){let r=this.options.templateFactory(t);if(this.value instanceof S0&&this.value.template===r)this.value.update(t.values);else{let n=new S0(r,t.processor,this.options),i=n._clone();n.update(t.values),this.__commitNode(i),this.value=n}}__commitIterable(t){Array.isArray(this.value)||(this.value=[],this.clear());let r=this.value,n=0,i;for(let o of t)i=r[n],i===void 0&&(i=new Hd(this.options),r.push(i),n===0?i.appendIntoPart(this):i.insertAfterPart(r[n-1])),i.setValue(o),i.commit(),n++;n<r.length&&(r.length=n,this.clear(i&&i.endNode))}clear(t=this.startNode){o1(this.startNode.parentNode,t.nextSibling,this.endNode)}},wP=class{constructor(t,r,n){if(this.value=void 0,this.__pendingValue=void 0,n.length!==2||n[0]!==""||n[1]!=="")throw new Error("Boolean attributes can only contain a single expression");this.element=t,this.name=r,this.strings=n}setValue(t){this.__pendingValue=t}commit(){for(;s1(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=kl,r(this)}if(this.__pendingValue===kl)return;let t=!!this.__pendingValue;this.value!==t&&(t?this.element.setAttribute(this.name,""):this.element.removeAttribute(this.name),this.value=t),this.__pendingValue=kl}},SP=class extends m3{constructor(t,r,n){super(t,r,n),this.single=n.length===2&&n[0]===""&&n[1]===""}_createPart(){return new qH(this)}_getValue(){return this.single?this.parts[0].value:super._getValue()}commit(){this.dirty&&(this.dirty=!1,this.element[this.name]=this._getValue())}},qH=class extends bP{},wce=!1;(()=>{try{let e={get capture(){return wce=!0,!1}};window.addEventListener("test",e,e),window.removeEventListener("test",e,e)}catch(e){}})();var MP=class{constructor(t,r,n){this.value=void 0,this.__pendingValue=void 0,this.element=t,this.eventName=r,this.eventContext=n,this.__boundHandleEvent=i=>this.handleEvent(i)}setValue(t){this.__pendingValue=t}commit(){for(;s1(this.__pendingValue);){let o=this.__pendingValue;this.__pendingValue=kl,o(this)}if(this.__pendingValue===kl)return;let t=this.__pendingValue,r=this.value,n=t==null||r!=null&&(t.capture!==r.capture||t.once!==r.once||t.passive!==r.passive),i=t!=null&&(r==null||n);n&&this.element.removeEventListener(this.eventName,this.__boundHandleEvent,this.__options),i&&(this.__options=Dur(t),this.element.addEventListener(this.eventName,this.__boundHandleEvent,this.__options)),this.value=t,this.__pendingValue=kl}handleEvent(t){typeof this.value=="function"?this.value.call(this.eventContext||this.element,t):this.value.handleEvent(t)}},Dur=e=>e&&(wce?{capture:e.capture,passive:e.passive,once:e.once}:e.capture);function vct(e){let t=l1.get(e.type);t===void 0&&(t={stringsArray:new WeakMap,keyString:new Map},l1.set(e.type,t));let r=t.stringsArray.get(e.strings);if(r!==void 0)return r;let n=e.strings.join(Yc);return r=t.keyString.get(n),r===void 0&&(r=new a1(e,e.getTemplateElement()),t.keyString.set(n,r)),t.stringsArray.set(e.strings,r),r}var l1=new Map;var E0=new WeakMap,xct=(e,t,r)=>{let n=E0.get(t);n===void 0&&(o1(t,t.firstChild),E0.set(t,n=new Hd(Object.assign({templateFactory:vct},r))),n.appendInto(t)),n.setValue(e),n.commit()};var WH=class{handleAttributeExpressions(t,r,n,i){let o=r[0];return o==="."?new SP(t,r.slice(1),n).parts:o==="@"?[new MP(t,r.slice(1),i.eventContext)]:o==="?"?[new wP(t,r.slice(1),n)]:new m3(t,r,n).parts}handleTextExpression(t){return new Hd(t)}},Sce=new WH;typeof window!="undefined"&&(window.litHtmlVersions||(window.litHtmlVersions=[])).push("1.4.1");var Ece=(e,t)=>`${e}--${t}`,YH=!0;typeof window.ShadyCSS=="undefined"?YH=!1:typeof window.ShadyCSS.prepareTemplateDom=="undefined"&&(console.warn("Incompatible ShadyCSS version detected. Please update to at least @webcomponents/webcomponentsjs@2.0.2 and @webcomponents/shadycss@1.3.1."),YH=!1);var Fur=e=>t=>{let r=Ece(t.type,e),n=l1.get(r);n===void 0&&(n={stringsArray:new WeakMap,keyString:new Map},l1.set(r,n));let i=n.stringsArray.get(t.strings);if(i!==void 0)return i;let o=t.strings.join(Yc);if(i=n.keyString.get(o),i===void 0){let a=t.getTemplateElement();YH&&window.ShadyCSS.prepareTemplateDom(a,e),i=new a1(t,a),n.keyString.set(o,i)}return n.stringsArray.set(t.strings,i),i},Bur=["html","svg"],Hur=e=>{Bur.forEach(t=>{let r=l1.get(Ece(t,e));r!==void 0&&r.keyString.forEach(n=>{let{element:{content:i}}=n,o=new Set;Array.from(i.querySelectorAll("style")).forEach(a=>{o.add(a)}),yct(n,o)})})},Tce=new Set,Vur=(e,t,r)=>{Tce.add(e);let n=r?r.element:document.createElement("template"),i=t.querySelectorAll("style"),{length:o}=i;if(o===0){window.ShadyCSS.prepareTemplateStyles(n,e);return}let a=document.createElement("style");for(let c=0;c<o;c++){let u=i[c];u.parentNode.removeChild(u),a.textContent+=u.textContent}Hur(e);let s=n.content;r?xce(r,a,s.firstChild):s.insertBefore(a,s.firstChild),window.ShadyCSS.prepareTemplateStyles(n,e);let l=s.querySelector("style");if(window.ShadyCSS.nativeShadow&&l!==null)t.insertBefore(l.cloneNode(!0),t.firstChild);else if(r){s.insertBefore(a,s.firstChild);let c=new Set;c.add(a),yct(r,c)}},Cce=(e,t,r)=>{if(!r||typeof r!="object"||!r.scopeName)throw new Error("The `scopeName` option is required.");let n=r.scopeName,i=E0.has(t),o=YH&&t.nodeType===11&&!!t.host,a=o&&!Tce.has(n),s=a?document.createDocumentFragment():t;if(xct(e,s,Object.assign({templateFactory:Fur(n)},r)),a){let l=E0.get(s);E0.delete(s);let c=l.value instanceof S0?l.value.template:void 0;Vur(n,s,c),o1(t,t.firstChild),t.appendChild(s),E0.set(t,l)}!i&&o&&window.ShadyCSS.styleElement(t.host)};var Ace;window.JSCompiler_renameProperty=(e,t)=>e;var Tct={toAttribute(e,t){switch(t){case Boolean:return e?"":null;case Object:case Array:return e==null?e:JSON.stringify(e)}return e},fromAttribute(e,t){switch(t){case Boolean:return e!==null;case Number:return e===null?null:Number(e);case Object:case Array:return JSON.parse(e)}return e}},Pce=(e,t)=>t!==e&&(t===t||e===e),bct={attribute:!0,type:String,converter:Tct,reflect:!1,hasChanged:Pce},wct=1,Sct=1<<2,Mct=1<<3,Ect=1<<4,Cct="finalized",g3=class extends HTMLElement{constructor(){super(),this.initialize()}static get observedAttributes(){this.finalize();let t=[];return this._classProperties.forEach((r,n)=>{let i=this._attributeNameForProperty(n,r);i!==void 0&&(this._attributeToPropertyMap.set(i,n),t.push(i))}),t}static _ensureClassProperties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_classProperties",this))){this._classProperties=new Map;let t=Object.getPrototypeOf(this)._classProperties;t!==void 0&&t.forEach((r,n)=>this._classProperties.set(n,r))}}static createProperty(t,r=bct){if(this._ensureClassProperties(),this._classProperties.set(t,r),r.noAccessor||this.prototype.hasOwnProperty(t))return;let n=typeof t=="symbol"?Symbol():`__${t}`,i=this.getPropertyDescriptor(t,n,r);i!==void 0&&Object.defineProperty(this.prototype,t,i)}static getPropertyDescriptor(t,r,n){return{get(){return this[r]},set(i){let o=this[t];this[r]=i,this.requestUpdateInternal(t,o,n)},configurable:!0,enumerable:!0}}static getPropertyOptions(t){return this._classProperties&&this._classProperties.get(t)||bct}static finalize(){let t=Object.getPrototypeOf(this);if(t.hasOwnProperty(Cct)||t.finalize(),this[Cct]=!0,this._ensureClassProperties(),this._attributeToPropertyMap=new Map,this.hasOwnProperty(JSCompiler_renameProperty("properties",this))){let r=this.properties,n=[...Object.getOwnPropertyNames(r),...typeof Object.getOwnPropertySymbols=="function"?Object.getOwnPropertySymbols(r):[]];for(let i of n)this.createProperty(i,r[i])}}static _attributeNameForProperty(t,r){let n=r.attribute;return n===!1?void 0:typeof n=="string"?n:typeof t=="string"?t.toLowerCase():void 0}static _valueHasChanged(t,r,n=Pce){return n(t,r)}static _propertyValueFromAttribute(t,r){let n=r.type,i=r.converter||Tct,o=typeof i=="function"?i:i.fromAttribute;return o?o(t,n):t}static _propertyValueToAttribute(t,r){if(r.reflect===void 0)return;let n=r.type,i=r.converter;return(i&&i.toAttribute||Tct.toAttribute)(t,n)}initialize(){this._updateState=0,this._updatePromise=new Promise(t=>this._enableUpdatingResolver=t),this._changedProperties=new Map,this._saveInstanceProperties(),this.requestUpdateInternal()}_saveInstanceProperties(){this.constructor._classProperties.forEach((t,r)=>{if(this.hasOwnProperty(r)){let n=this[r];delete this[r],this._instanceProperties||(this._instanceProperties=new Map),this._instanceProperties.set(r,n)}})}_applyInstanceProperties(){this._instanceProperties.forEach((t,r)=>this[r]=t),this._instanceProperties=void 0}connectedCallback(){this.enableUpdating()}enableUpdating(){this._enableUpdatingResolver!==void 0&&(this._enableUpdatingResolver(),this._enableUpdatingResolver=void 0)}disconnectedCallback(){}attributeChangedCallback(t,r,n){r!==n&&this._attributeToProperty(t,n)}_propertyToAttribute(t,r,n=bct){let i=this.constructor,o=i._attributeNameForProperty(t,n);if(o!==void 0){let a=i._propertyValueToAttribute(r,n);if(a===void 0)return;this._updateState=this._updateState|Mct,a==null?this.removeAttribute(o):this.setAttribute(o,a),this._updateState=this._updateState&~Mct}}_attributeToProperty(t,r){if(this._updateState&Mct)return;let n=this.constructor,i=n._attributeToPropertyMap.get(t);if(i!==void 0){let o=n.getPropertyOptions(i);this._updateState=this._updateState|Ect,this[i]=n._propertyValueFromAttribute(r,o),this._updateState=this._updateState&~Ect}}requestUpdateInternal(t,r,n){let i=!0;if(t!==void 0){let o=this.constructor;n=n||o.getPropertyOptions(t),o._valueHasChanged(this[t],r,n.hasChanged)?(this._changedProperties.has(t)||this._changedProperties.set(t,r),n.reflect===!0&&!(this._updateState&Ect)&&(this._reflectingProperties===void 0&&(this._reflectingProperties=new Map),this._reflectingProperties.set(t,n))):i=!1}!this._hasRequestedUpdate&&i&&(this._updatePromise=this._enqueueUpdate())}requestUpdate(t,r){return this.requestUpdateInternal(t,r),this.updateComplete}_enqueueUpdate(){return Ri(this,null,function*(){this._updateState=this._updateState|Sct;try{yield this._updatePromise}catch(r){}let t=this.performUpdate();return t!=null&&(yield t),!this._hasRequestedUpdate})}get _hasRequestedUpdate(){return this._updateState&Sct}get hasUpdated(){return this._updateState&wct}performUpdate(){if(!this._hasRequestedUpdate)return;this._instanceProperties&&this._applyInstanceProperties();let t=!1,r=this._changedProperties;try{t=this.shouldUpdate(r),t?this.update(r):this._markUpdated()}catch(n){throw t=!1,this._markUpdated(),n}t&&(this._updateState&wct||(this._updateState=this._updateState|wct,this.firstUpdated(r)),this.updated(r))}_markUpdated(){this._changedProperties=new Map,this._updateState=this._updateState&~Sct}get updateComplete(){return this._getUpdateComplete()}_getUpdateComplete(){return this.getUpdateComplete()}getUpdateComplete(){return this._updatePromise}shouldUpdate(t){return!0}update(t){this._reflectingProperties!==void 0&&this._reflectingProperties.size>0&&(this._reflectingProperties.forEach((r,n)=>this._propertyToAttribute(n,this[n],r)),this._reflectingProperties=void 0),this._markUpdated()}updated(t){}firstUpdated(t){}};Ace=Cct;g3[Ace]=!0;var Ice=Element.prototype,Iii=Ice.msMatchesSelector||Ice.webkitMatchesSelector;var jH=window.ShadowRoot&&(window.ShadyCSS===void 0||window.ShadyCSS.nativeShadow)&&"adoptedStyleSheets"in Document.prototype&&"replace"in CSSStyleSheet.prototype,Act=Symbol(),c1=class{constructor(t,r){if(r!==Act)throw new Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");this.cssText=t}get styleSheet(){return this._styleSheet===void 0&&(jH?(this._styleSheet=new CSSStyleSheet,this._styleSheet.replaceSync(this.cssText)):this._styleSheet=null),this._styleSheet}toString(){return this.cssText}},Pct=e=>new c1(String(e),Act),Uur=e=>{if(e instanceof c1)return e.cssText;if(typeof e=="number")return e;throw new Error(`Value passed to 'css' function must be a 'css' function result: ${e}. Use 'unsafeCSS' to pass non-literal values, but
            take care to ensure page security.`)},Ci=(e,...t)=>{let r=t.reduce((n,i,o)=>n+Uur(i)+e[o+1],e[0]);return new c1(r,Act)};(window.litElementVersions||(window.litElementVersions=[])).push("2.5.1");var Lce={},EP=class extends g3{static getStyles(){return this.styles}static _getUniqueStyles(){if(this.hasOwnProperty(JSCompiler_renameProperty("_styles",this)))return;let t=this.getStyles();if(Array.isArray(t)){let r=(o,a)=>o.reduceRight((s,l)=>Array.isArray(l)?r(l,s):(s.add(l),s),a),n=r(t,new Set),i=[];n.forEach(o=>i.unshift(o)),this._styles=i}else this._styles=t===void 0?[]:[t];this._styles=this._styles.map(r=>{if(r instanceof CSSStyleSheet&&!jH){let n=Array.prototype.slice.call(r.cssRules).reduce((i,o)=>i+o.cssText,"");return Pct(n)}return r})}initialize(){super.initialize(),this.constructor._getUniqueStyles(),this.renderRoot=this.createRenderRoot(),window.ShadowRoot&&this.renderRoot instanceof window.ShadowRoot&&this.adoptStyles()}createRenderRoot(){return this.attachShadow(this.constructor.shadowRootOptions)}adoptStyles(){let t=this.constructor._styles;t.length!==0&&(window.ShadyCSS!==void 0&&!window.ShadyCSS.nativeShadow?window.ShadyCSS.ScopingShim.prepareAdoptedCssText(t.map(r=>r.cssText),this.localName):jH?this.renderRoot.adoptedStyleSheets=t.map(r=>r instanceof CSSStyleSheet?r:r.styleSheet):this._needsShimAdoptedStyleSheets=!0)}connectedCallback(){super.connectedCallback(),this.hasUpdated&&window.ShadyCSS!==void 0&&window.ShadyCSS.styleElement(this)}update(t){let r=this.render();super.update(t),r!==Lce&&this.constructor.render(r,this.renderRoot,{scopeName:this.localName,eventContext:this}),this._needsShimAdoptedStyleSheets&&(this._needsShimAdoptedStyleSheets=!1,this.constructor._styles.forEach(n=>{let i=document.createElement("style");i.textContent=n.cssText,this.renderRoot.appendChild(i)}))}render(){return Lce}};EP.finalized=!0;EP.render=Cce;EP.shadowRootOptions={mode:"open"};var kce=0,Ict={},jc=(e,t,r)=>{let n=r&&r.moduleId||`custom-style-module-${kce++}`;Array.isArray(t)||(t=t?[t]:[]),t.forEach(a=>{if(!(a instanceof c1))throw new Error("An item in styles is not of type CSSResult. Use `unsafeCSS` or `css`.");if(!Ict[a]){let s=document.createElement("dom-module");s.innerHTML=`
        <template>
          <style>${a.toString()}</style>
        </template>
      `;let l=`custom-style-module-${kce++}`;s.register(l),Ict[a]=l}});let i=document.createElement("dom-module");if(e){let a=customElements.get(e);a&&Object.prototype.hasOwnProperty.call(a,"__finalized")&&console.warn(`The custom element definition for "${e}"
      was finalized before a style module was registered.
      Make sure to add component specific style modules before
      importing the corresponding custom element.`),i.setAttribute("theme-for",e)}let o=r&&r.include||[];i.innerHTML=`
    <template>
      ${o.map(a=>`<style include=${a}></style>`)}
      ${t.map(a=>`<style include=${Ict[a]}></style>`)}
    </template>
  `,i.register(n)};var Lct=class extends HTMLElement{static get version(){return"20.0.2"}};customElements.define("vaadin-lumo-styles",Lct);var qur=Ci`
  :host {
    /* Base (background) */
    --lumo-base-color: #fff;

    /* Tint */
    --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);
    --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);
    --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);
    --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);
    --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);
    --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);
    --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);
    --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);
    --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);
    --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);
    --lumo-tint: #fff;

    /* Shade */
    --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);
    --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);
    --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);
    --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);
    --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);
    --lumo-shade-50pct: hsla(214, 45%, 20%, 0.5);
    --lumo-shade-60pct: hsla(214, 43%, 19%, 0.61);
    --lumo-shade-70pct: hsla(214, 42%, 18%, 0.72);
    --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);
    --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);
    --lumo-shade: hsl(214, 35%, 15%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-shade-5pct);
    --lumo-contrast-10pct: var(--lumo-shade-10pct);
    --lumo-contrast-20pct: var(--lumo-shade-20pct);
    --lumo-contrast-30pct: var(--lumo-shade-30pct);
    --lumo-contrast-40pct: var(--lumo-shade-40pct);
    --lumo-contrast-50pct: var(--lumo-shade-50pct);
    --lumo-contrast-60pct: var(--lumo-shade-60pct);
    --lumo-contrast-70pct: var(--lumo-shade-70pct);
    --lumo-contrast-80pct: var(--lumo-shade-80pct);
    --lumo-contrast-90pct: var(--lumo-shade-90pct);
    --lumo-contrast: var(--lumo-shade);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 90%, 52%);
    --lumo-primary-color-50pct: hsla(214, 90%, 52%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 52%, 0.1);
    --lumo-primary-text-color: var(--lumo-primary-color);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 100%, 61%);
    --lumo-error-color-50pct: hsla(3, 100%, 60%, 0.5);
    --lumo-error-color-10pct: hsla(3, 100%, 60%, 0.1);
    --lumo-error-text-color: hsl(3, 92%, 53%);
    --lumo-error-contrast-color: #fff;

    /* Success */
    --lumo-success-color: hsl(145, 80%, 42%); /* hsl(144,82%,37%); */
    --lumo-success-color-50pct: hsla(145, 76%, 44%, 0.55);
    --lumo-success-color-10pct: hsla(145, 76%, 44%, 0.12);
    --lumo-success-text-color: hsl(145, 100%, 32%);
    --lumo-success-contrast-color: #fff;
  }
`,Rce=document.createElement("template");Rce.innerHTML=`<style>${qur.toString().replace(":host","html")}</style>`;document.head.appendChild(Rce.content);var Gur=Ci`
  [theme~='dark'] {
    /* Base (background) */
    --lumo-base-color: hsl(214, 35%, 21%);

    /* Tint */
    --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);
    --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);
    --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);
    --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);
    --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);
    --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);
    --lumo-tint-60pct: hsla(214, 82%, 90%, 0.6);
    --lumo-tint-70pct: hsla(214, 87%, 92%, 0.7);
    --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);
    --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);
    --lumo-tint: hsl(214, 100%, 98%);

    /* Shade */
    --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);
    --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);
    --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);
    --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);
    --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);
    --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);
    --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);
    --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);
    --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);
    --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);
    --lumo-shade: hsl(214, 33%, 13%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-tint-5pct);
    --lumo-contrast-10pct: var(--lumo-tint-10pct);
    --lumo-contrast-20pct: var(--lumo-tint-20pct);
    --lumo-contrast-30pct: var(--lumo-tint-30pct);
    --lumo-contrast-40pct: var(--lumo-tint-40pct);
    --lumo-contrast-50pct: var(--lumo-tint-50pct);
    --lumo-contrast-60pct: var(--lumo-tint-60pct);
    --lumo-contrast-70pct: var(--lumo-tint-70pct);
    --lumo-contrast-80pct: var(--lumo-tint-80pct);
    --lumo-contrast-90pct: var(--lumo-tint-90pct);
    --lumo-contrast: var(--lumo-tint);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 86%, 55%);
    --lumo-primary-color-50pct: hsla(214, 86%, 55%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 63%, 0.1);
    --lumo-primary-text-color: hsl(214, 100%, 70%);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 90%, 63%);
    --lumo-error-color-50pct: hsla(3, 90%, 63%, 0.5);
    --lumo-error-color-10pct: hsla(3, 90%, 63%, 0.1);
    --lumo-error-text-color: hsl(3, 100%, 67%);

    /* Success */
    --lumo-success-color: hsl(145, 65%, 42%);
    --lumo-success-color-50pct: hsla(145, 65%, 42%, 0.5);
    --lumo-success-color-10pct: hsla(145, 65%, 42%, 0.1);
    --lumo-success-text-color: hsl(145, 85%, 47%);
  }

  html {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  [theme~='dark'] {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    color: var(--lumo-header-text-color);
  }

  a {
    color: var(--lumo-primary-text-color);
  }

  blockquote {
    color: var(--lumo-secondary-text-color);
  }

  code,
  pre {
    background-color: var(--lumo-contrast-10pct);
    border-radius: var(--lumo-border-radius-m);
  }
`;jc("",Gur,{moduleId:"lumo-color"});var Wur=Ci`
  :host {
    color: var(--lumo-body-text-color) !important;
    background-color: var(--lumo-base-color) !important;
  }
`;jc("",Wur,{moduleId:"lumo-color-legacy",include:["lumo-color"]});var Nce=document.createElement("template");Nce.innerHTML=`
  <style>
    @font-face {
      font-family: 'lumo-icons';
      src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff');
      font-weight: normal;
      font-style: normal;
    }

    html {
      --lumo-icons-align-center: "\\ea01";
      --lumo-icons-align-left: "\\ea02";
      --lumo-icons-align-right: "\\ea03";
      --lumo-icons-angle-down: "\\ea04";
      --lumo-icons-angle-left: "\\ea05";
      --lumo-icons-angle-right: "\\ea06";
      --lumo-icons-angle-up: "\\ea07";
      --lumo-icons-arrow-down: "\\ea08";
      --lumo-icons-arrow-left: "\\ea09";
      --lumo-icons-arrow-right: "\\ea0a";
      --lumo-icons-arrow-up: "\\ea0b";
      --lumo-icons-bar-chart: "\\ea0c";
      --lumo-icons-bell: "\\ea0d";
      --lumo-icons-calendar: "\\ea0e";
      --lumo-icons-checkmark: "\\ea0f";
      --lumo-icons-chevron-down: "\\ea10";
      --lumo-icons-chevron-left: "\\ea11";
      --lumo-icons-chevron-right: "\\ea12";
      --lumo-icons-chevron-up: "\\ea13";
      --lumo-icons-clock: "\\ea14";
      --lumo-icons-cog: "\\ea15";
      --lumo-icons-cross: "\\ea16";
      --lumo-icons-download: "\\ea17";
      --lumo-icons-dropdown: "\\ea18";
      --lumo-icons-edit: "\\ea19";
      --lumo-icons-error: "\\ea1a";
      --lumo-icons-eye: "\\ea1b";
      --lumo-icons-eye-disabled: "\\ea1c";
      --lumo-icons-menu: "\\ea1d";
      --lumo-icons-minus: "\\ea1e";
      --lumo-icons-ordered-list: "\\ea1f";
      --lumo-icons-phone: "\\ea20";
      --lumo-icons-photo: "\\ea21";
      --lumo-icons-play: "\\ea22";
      --lumo-icons-plus: "\\ea23";
      --lumo-icons-redo: "\\ea24";
      --lumo-icons-reload: "\\ea25";
      --lumo-icons-search: "\\ea26";
      --lumo-icons-undo: "\\ea27";
      --lumo-icons-unordered-list: "\\ea28";
      --lumo-icons-upload: "\\ea29";
      --lumo-icons-user: "\\ea2a";
    }
  </style>
`;document.head.appendChild(Nce.content);var Yur=Ci`
  :host {
    --lumo-size-xs: 1.625rem;
    --lumo-size-s: 1.875rem;
    --lumo-size-m: 2.25rem;
    --lumo-size-l: 2.75rem;
    --lumo-size-xl: 3.5rem;

    /* Icons */
    --lumo-icon-size-s: 1.25em;
    --lumo-icon-size-m: 1.5em;
    --lumo-icon-size-l: 2.25em;
    /* For backwards compatibility */
    --lumo-icon-size: var(--lumo-icon-size-m);
  }
`,Dce=document.createElement("template");Dce.innerHTML=`<style>${Yur.toString().replace(":host","html")}</style>`;document.head.appendChild(Dce.content);var jur=Ci`
  :host {
    /* Square */
    --lumo-space-xs: 0.25rem;
    --lumo-space-s: 0.5rem;
    --lumo-space-m: 1rem;
    --lumo-space-l: 1.5rem;
    --lumo-space-xl: 2.5rem;

    /* Wide */
    --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);
    --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);
    --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);
    --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);
    --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);

    /* Tall */
    --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);
    --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);
    --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);
    --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);
    --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);
  }
`,Oce=document.createElement("template");Oce.innerHTML=`<style>${jur.toString().replace(":host","html")}</style>`;document.head.appendChild(Oce.content);var Xur=Ci`
  :host {
    /* Border radius */
    --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */
    --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */
    --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */
    --lumo-border-radius: 0.25em; /* Deprecated */

    /* Shadow */
    --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);
    --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);
    --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);
    --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);
    --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);

    /* Clickable element cursor */
    --lumo-clickable-cursor: default;
  }
`,zce=document.createElement("template");zce.innerHTML=`<style>${Xur.toString().replace(":host","html")}</style>`;document.head.appendChild(zce.content);var $ur=Ci`
  :host {
    /* prettier-ignore */
    --lumo-font-family: -apple-system, BlinkMacSystemFont, 'Roboto', 'Segoe UI', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';

    /* Font sizes */
    --lumo-font-size-xxs: 0.75rem;
    --lumo-font-size-xs: 0.8125rem;
    --lumo-font-size-s: 0.875rem;
    --lumo-font-size-m: 1rem;
    --lumo-font-size-l: 1.125rem;
    --lumo-font-size-xl: 1.375rem;
    --lumo-font-size-xxl: 1.75rem;
    --lumo-font-size-xxxl: 2.5rem;

    /* Line heights */
    --lumo-line-height-xs: 1.25;
    --lumo-line-height-s: 1.375;
    --lumo-line-height-m: 1.625;
  }
`,Fce=document.createElement("template");Fce.innerHTML=`<style>${$ur.toString().replace(":host","html")}</style>`;document.head.appendChild(Fce.content);var Kur=Ci`
  html {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  /* Can’t combine with the above selector because that doesn’t work in browsers without native shadow dom */
  :host {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  small,
  [theme~='font-size-s'] {
    font-size: var(--lumo-font-size-s);
    line-height: var(--lumo-line-height-s);
  }

  [theme~='font-size-xs'] {
    font-size: var(--lumo-font-size-xs);
    line-height: var(--lumo-line-height-xs);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    font-weight: 600;
    line-height: var(--lumo-line-height-xs);
    margin-top: 1.25em;
  }

  h1 {
    font-size: var(--lumo-font-size-xxxl);
    margin-bottom: 0.75em;
  }

  h2 {
    font-size: var(--lumo-font-size-xxl);
    margin-bottom: 0.5em;
  }

  h3 {
    font-size: var(--lumo-font-size-xl);
    margin-bottom: 0.5em;
  }

  h4 {
    font-size: var(--lumo-font-size-l);
    margin-bottom: 0.5em;
  }

  h5 {
    font-size: var(--lumo-font-size-m);
    margin-bottom: 0.25em;
  }

  h6 {
    font-size: var(--lumo-font-size-xs);
    margin-bottom: 0;
    text-transform: uppercase;
    letter-spacing: 0.03em;
  }

  p,
  blockquote {
    margin-top: 0.5em;
    margin-bottom: 0.75em;
  }

  a {
    text-decoration: none;
  }

  a:hover {
    text-decoration: underline;
  }

  hr {
    display: block;
    align-self: stretch;
    height: 1px;
    border: 0;
    padding: 0;
    margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);
    background-color: var(--lumo-contrast-10pct);
  }

  blockquote {
    border-left: 2px solid var(--lumo-contrast-30pct);
  }

  b,
  strong {
    font-weight: 600;
  }

  /* RTL specific styles */

  blockquote[dir='rtl'] {
    border-left: none;
    border-right: 2px solid var(--lumo-contrast-30pct);
  }
`;jc("",Kur,{moduleId:"lumo-typography"});jc("vaadin-checkbox",Ci`
    :host {
      -webkit-tap-highlight-color: transparent;
      -webkit-user-select: none;
      -moz-user-select: none;
      user-select: none;
      cursor: default;
      outline: none;
    }

    [part='label']:not([empty]) {
      margin: 0.1875em 0.875em 0.1875em 0.375em;
    }

    [part='checkbox'] {
      width: calc(1em + 2px);
      height: calc(1em + 2px);
      margin: 0.1875em;
      position: relative;
      border-radius: var(--lumo-border-radius-s);
      background-color: var(--lumo-contrast-20pct);
      transition: transform 0.2s cubic-bezier(0.12, 0.32, 0.54, 2), background-color 0.15s;
      pointer-events: none;
      line-height: 1.2;
    }

    :host([indeterminate]) [part='checkbox'],
    :host([checked]) [part='checkbox'] {
      background-color: var(--lumo-primary-color);
    }

    /* Needed to align the checkbox nicely on the baseline */
    [part='checkbox']::before {
      content: '\\2003';
    }

    /* Checkmark */
    [part='checkbox']::after {
      content: '';
      display: inline-block;
      width: 0;
      height: 0;
      border: 0 solid var(--lumo-primary-contrast-color);
      border-width: 0.1875em 0 0 0.1875em;
      box-sizing: border-box;
      transform-origin: 0 0;
      position: absolute;
      top: 0.8125em;
      left: 0.5em;
      transform: scale(0.55) rotate(-135deg);
      opacity: 0;
    }

    :host([checked]) [part='checkbox']::after {
      opacity: 1;
      width: 0.625em;
      height: 1.0625em;
    }

    /* Indeterminate checkmark */
    :host([indeterminate]) [part='checkbox']::after {
      transform: none;
      opacity: 1;
      top: 45%;
      height: 10%;
      left: 22%;
      right: 22%;
      width: auto;
      border: 0;
      background-color: var(--lumo-primary-contrast-color);
      transition: opacity 0.25s;
    }

    /* Focus ring */
    :host([focus-ring]) [part='checkbox'] {
      box-shadow: 0 0 0 3px var(--lumo-primary-color-50pct);
    }

    /* Disabled */
    :host([disabled]) {
      pointer-events: none;
      color: var(--lumo-disabled-text-color);
    }

    :host([disabled]) [part='label'] ::slotted(*) {
      color: inherit;
    }

    :host([disabled]) [part='checkbox'] {
      background-color: var(--lumo-contrast-10pct);
    }

    :host([disabled]) [part='checkbox']::after {
      border-color: var(--lumo-contrast-30pct);
    }

    :host([indeterminate][disabled]) [part='checkbox']::after {
      background-color: var(--lumo-contrast-30pct);
    }

    /* RTL specific styles */
    :host([dir='rtl']) [part='label']:not([empty]) {
      margin: 0.1875em 0.375em 0.1875em 0.875em;
    }

    /* Transition the checkmark if activated with the mouse (disabled for grid select-all this way) */
    :host(:hover) [part='checkbox']::after {
      transition: width 0.1s, height 0.25s;
    }

    /* Used for activation "halo" */
    [part='checkbox']::before {
      color: transparent;
      display: inline-block;
      width: 100%;
      height: 100%;
      border-radius: inherit;
      background-color: inherit;
      transform: scale(1.4);
      opacity: 0;
      transition: transform 0.1s, opacity 0.8s;
    }

    /* Hover */
    :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
      background-color: var(--lumo-contrast-30pct);
    }

    /* Disable hover for touch devices */
    @media (pointer: coarse) {
      :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
        background-color: var(--lumo-contrast-20pct);
      }
    }

    /* Active */
    :host([active]) [part='checkbox'] {
      transform: scale(0.9);
      transition-duration: 0.05s;
    }

    :host([active][checked]) [part='checkbox'] {
      transform: scale(1.1);
    }

    :host([active]:not([checked])) [part='checkbox']::before {
      transition-duration: 0.01s, 0.01s;
      transform: scale(0);
      opacity: 0.4;
    }
  `,{moduleId:"lumo-checkbox"});var Bce=e=>class extends e{static get properties(){return{theme:{type:String,readOnly:!0}}}attributeChangedCallback(r,n,i){super.attributeChangedCallback(r,n,i),r==="theme"&&this._setTheme(i)}};var XH=e=>class extends Bce(e){static finalize(){super.finalize();let r=this.prototype._template,n=Object.getPrototypeOf(this.prototype)._template;n&&Array.from(n.content.querySelectorAll("style[include]")).forEach(i=>{this._includeStyle(i.getAttribute("include"),r)}),this._includeMatchingThemes(r)}static _includeMatchingThemes(r){let i=ou.prototype.modules,o=!1,a=this.is+"-default-theme";Object.keys(i).sort((s,l)=>{let c=s.indexOf("vaadin-")===0,u=l.indexOf("vaadin-")===0,h=["lumo-","material-"],f=h.filter(d=>s.indexOf(d)===0).length>0,p=h.filter(d=>l.indexOf(d)===0).length>0;return c!==u?c?-1:1:f!==p?f?-1:1:0}).forEach(s=>{if(s!==a){let l=i[s].getAttribute("theme-for");l&&l.split(" ").forEach(c=>{new RegExp("^"+c.split("*").join(".*")+"$").test(this.is)&&(o=!0,this._includeStyle(s,r))})}}),!o&&i[a]&&this._includeStyle(a,r)}static _includeStyle(r,n){if(n&&!n.content.querySelector(`style[include="${r}"]`)){let i=document.createElement("style");i.setAttribute("include",r),n.content.appendChild(i)}}};var kct=!1;window.addEventListener("keydown",()=>{kct=!0},{capture:!0});window.addEventListener("mousedown",()=>{kct=!1},{capture:!0});var Zur=e=>class extends e{static get properties(){return{tabindex:{type:Number,value:0,reflectToAttribute:!0,observer:"_tabindexChanged"}}}},Hce=e=>class extends Zur(e){static get properties(){return{autofocus:{type:Boolean},_previousTabIndex:{type:Number},disabled:{type:Boolean,observer:"_disabledChanged",reflectToAttribute:!0},_isShiftTabbing:{type:Boolean}}}ready(){this.addEventListener("focusin",r=>{r.composedPath()[0]===this?this.contains(r.relatedTarget)||this._focus():r.composedPath().indexOf(this.focusElement)!==-1&&!this.disabled&&this._setFocused(!0)}),this.addEventListener("focusout",()=>this._setFocused(!1)),super.ready(),this.addEventListener("keydown",r=>{!r.defaultPrevented&&r.keyCode===9&&r.shiftKey&&(this._isShiftTabbing=!0,HTMLElement.prototype.focus.apply(this),this._setFocused(!1),setTimeout(()=>this._isShiftTabbing=!1,0))}),this.autofocus&&!this.disabled&&window.requestAnimationFrame(()=>{this._focus(),this._setFocused(!0),this.setAttribute("focus-ring","")})}disconnectedCallback(){super.disconnectedCallback(),this.hasAttribute("focused")&&this._setFocused(!1)}_setFocused(r){r?this.setAttribute("focused",""):this.removeAttribute("focused"),r&&kct?this.setAttribute("focus-ring",""):this.removeAttribute("focus-ring")}get focusElement(){return window.console.warn(`Please implement the 'focusElement' property in <${this.localName}>`),this}_focus(){!this.focusElement||this._isShiftTabbing||(this.focusElement.focus(),this._setFocused(!0))}focus(){!this.focusElement||this.disabled||(this.focusElement.focus(),this._setFocused(!0))}blur(){!this.focusElement||(this.focusElement.blur(),this._setFocused(!1))}_disabledChanged(r){this.focusElement.disabled=r,r?(this.blur(),this._previousTabIndex=this.tabindex,this.tabindex=-1,this.setAttribute("aria-disabled","true")):(typeof this._previousTabIndex!="undefined"&&(this.tabindex=this._previousTabIndex),this.removeAttribute("aria-disabled"))}_tabindexChanged(r){r!==void 0&&(this.focusElement.tabIndex=r),this.disabled&&this.tabindex&&(this.tabindex!==-1&&(this._previousTabIndex=this.tabindex),this.tabindex=r=void 0)}click(){this.disabled||super.click()}};var Jur=/\/\*\*\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i,$H=window.Vaadin&&window.Vaadin.Flow&&window.Vaadin.Flow.clients;function Qur(){function e(){return!0}return Vce(e)}function thr(){try{return ehr()?!0:rhr()?$H?!nhr():!Qur():!1}catch(e){return!1}}function ehr(){return localStorage.getItem("vaadin.developmentmode.force")}function rhr(){return["localhost","127.0.0.1"].indexOf(window.location.hostname)>=0}function nhr(){return!!($H&&Object.keys($H).map(t=>$H[t]).filter(t=>t.productionMode).length>0)}function Vce(e,t){if(typeof e!="function")return;let r=Jur.exec(e.toString());if(r)try{e=new Function(r[1])}catch(n){console.log("vaadin-development-mode-detector: uncommentAndRun() failed",n)}return e(t)}window.Vaadin=window.Vaadin||{};var Rct=function(e,t){if(window.Vaadin.developmentMode)return Vce(e,t)};window.Vaadin.developmentMode===void 0&&(window.Vaadin.developmentMode=thr());function ihr(){}var Uce=function(){if(typeof Rct=="function")return Rct(ihr)};var _3=class{static detectScrollType(){let t=document.createElement("div");t.textContent="ABCD",t.dir="rtl",t.style.fontSize="14px",t.style.width="4px",t.style.height="1px",t.style.position="absolute",t.style.top="-1000px",t.style.overflow="scroll",document.body.appendChild(t);let r="reverse";return t.scrollLeft>0?r="default":(t.scrollLeft=2,t.scrollLeft<2&&(r="negative")),document.body.removeChild(t),r}static getNormalizedScrollLeft(t,r,n){let{scrollLeft:i}=n;if(r!=="rtl"||!t)return i;switch(t){case"negative":return n.scrollWidth-n.clientWidth+i;case"reverse":return n.scrollWidth-n.clientWidth-i}return i}static setNormalizedScrollLeft(t,r,n,i){if(r!=="rtl"||!t){n.scrollLeft=i;return}switch(t){case"negative":n.scrollLeft=n.clientWidth-n.scrollWidth+i;break;case"reverse":n.scrollLeft=n.scrollWidth-n.clientWidth-i;break;default:n.scrollLeft=i;break}}};var T0=[],ohr=function(){let e=Dct();T0.forEach(t=>{Nct(t,e)})},KH,ahr=new MutationObserver(ohr);ahr.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]});var Nct=function(e,t,r=e.getAttribute("dir")){t?e.setAttribute("dir",t):r!=null&&e.removeAttribute("dir")},Dct=function(){return document.documentElement.getAttribute("dir")},ZH=e=>class extends e{static get properties(){return{dir:{type:String,value:"",reflectToAttribute:!0}}}static finalize(){super.finalize(),KH||(KH=_3.detectScrollType())}connectedCallback(){super.connectedCallback(),this.hasAttribute("dir")||(this.__subscribe(),Nct(this,Dct(),null))}attributeChangedCallback(r,n,i){if(super.attributeChangedCallback(r,n,i),r!=="dir")return;let o=Dct(),a=i===o&&T0.indexOf(this)===-1,s=!i&&n&&T0.indexOf(this)===-1;a||s?(this.__subscribe(),Nct(this,o,i)):i!==o&&n===o&&this.__subscribe(!1)}disconnectedCallback(){super.disconnectedCallback(),this.__subscribe(!1),this.removeAttribute("dir")}_valueToNodeAttribute(r,n,i){i==="dir"&&n===""&&!r.hasAttribute("dir")||super._valueToNodeAttribute(r,n,i)}_attributeToProperty(r,n,i){r==="dir"&&!n?this.dir="":super._attributeToProperty(r,n,i)}__subscribe(r=!0){r?T0.indexOf(this)===-1&&T0.push(this):T0.indexOf(this)>-1&&T0.splice(T0.indexOf(this),1)}__getNormalizedScrollLeft(r){return _3.getNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r)}__setNormalizedScrollLeft(r,n){return _3.setNormalizedScrollLeft(KH,this.getAttribute("dir")||"ltr",r,n)}};window.Vaadin=window.Vaadin||{};window.Vaadin.registrations=window.Vaadin.registrations||[];window.Vaadin.developmentModeCallback=window.Vaadin.developmentModeCallback||{};window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]=function(){Uce()};var Oct,qce=new Set,JH=e=>class extends ZH(e){static finalize(){super.finalize();let{is:r}=this;r&&!qce.has(r)&&(window.Vaadin.registrations.push(this),qce.add(r),window.Vaadin.developmentModeCallback&&(Oct=sr.debounce(Oct,kx,()=>{window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]()}),Jl(Oct)))}constructor(){super(),document.doctype===null&&console.warn('Vaadin components require the "standards mode" declaration. Please add <!DOCTYPE html> to the HTML document.')}};var QH=class extends JH(Hce(XH(vh(mt)))){static get template(){return Q`
      <style>
        :host {
          display: inline-block;
        }

        :host([hidden]) {
          display: none !important;
        }

        label {
          display: inline-flex;
          align-items: baseline;
          outline: none;
        }

        [part='checkbox'] {
          position: relative;
          display: inline-block;
          flex: none;
        }

        input[type='checkbox'] {
          position: absolute;
          top: 0;
          left: 0;
          right: 0;
          width: 100%;
          height: 100%;
          opacity: 0;
          cursor: inherit;
          margin: 0;
        }

        :host([disabled]) {
          -webkit-tap-highlight-color: transparent;
        }
      </style>

      <label>
        <span part="checkbox">
          <input
            type="checkbox"
            checked="{{checked::change}}"
            disabled$="[[disabled]]"
            indeterminate="{{indeterminate::change}}"
            role="presentation"
            tabindex="-1"
          />
        </span>

        <span part="label">
          <slot></slot>
        </span>
      </label>
    `}static get is(){return"vaadin-checkbox"}static get version(){return"20.0.2"}static get properties(){return{checked:{type:Boolean,value:!1,notify:!0,observer:"_checkedChanged",reflectToAttribute:!0},indeterminate:{type:Boolean,notify:!0,observer:"_indeterminateChanged",reflectToAttribute:!0,value:!1},value:{type:String,value:"on"},_nativeCheckbox:{type:Object}}}constructor(){super(),this.name}get name(){return this.checked?this._storedName:""}set name(t){this._storedName=t}ready(){super.ready(),this.setAttribute("role","checkbox"),this._nativeCheckbox=this.shadowRoot.querySelector('input[type="checkbox"]'),this.addEventListener("click",this._handleClick.bind(this)),this._addActiveListeners();let t=this.getAttribute("name");t&&(this.name=t),this.shadowRoot.querySelector('[part~="label"]').querySelector("slot").addEventListener("slotchange",this._updateLabelAttribute.bind(this)),this._updateLabelAttribute()}_updateLabelAttribute(){let t=this.shadowRoot.querySelector('[part~="label"]'),r=t.firstElementChild.assignedNodes();this._isAssignedNodesEmpty(r)?t.setAttribute("empty",""):t.removeAttribute("empty")}_isAssignedNodesEmpty(t){return t.length===0||t.length==1&&t[0].nodeType==Node.TEXT_NODE&&t[0].textContent.trim()===""}_checkedChanged(t){this.indeterminate?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",Boolean(t))}_indeterminateChanged(t){t?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",this.checked)}_addActiveListeners(){this._addEventListenerToNode(this,"down",t=>{this.__interactionsAllowed(t)&&this.setAttribute("active","")}),this._addEventListenerToNode(this,"up",()=>this.removeAttribute("active")),this.addEventListener("keydown",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this.setAttribute("active",""))}),this.addEventListener("keyup",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this._toggleChecked(),this.removeAttribute("active"),this.indeterminate&&(this.indeterminate=!1))})}get focusElement(){return this.shadowRoot.querySelector("input")}__interactionsAllowed(t){return!(this.disabled||t.target.localName==="a")}_handleClick(t){this.__interactionsAllowed(t)&&(this.indeterminate?(this.indeterminate=!1,t.preventDefault(),this._toggleChecked()):t.composedPath()[0]!==this._nativeCheckbox&&(t.preventDefault(),this._toggleChecked()))}_toggleChecked(){this.checked=!this.checked,this.dispatchEvent(new CustomEvent("change",{composed:!1,bubbles:!0}))}};customElements.define(QH.is,QH);jc("vaadin-grid",Ci`
    :host {
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-m);
      line-height: var(--lumo-line-height-s);
      color: var(--lumo-body-text-color);
      background-color: var(--lumo-base-color);
      box-sizing: border-box;
      -webkit-text-size-adjust: 100%;
      -webkit-tap-highlight-color: transparent;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;

      /* For internal use only */
      --_lumo-grid-border-color: var(--lumo-contrast-20pct);
      --_lumo-grid-secondary-border-color: var(--lumo-contrast-10pct);
      --_lumo-grid-border-width: 1px;
      --_lumo-grid-selected-row-color: var(--lumo-primary-color-10pct);
    }

    /* No (outer) border */

    :host(:not([theme~='no-border'])) {
      border: var(--_lumo-grid-border-width) solid var(--_lumo-grid-border-color);
    }

    /* Cell styles */

    [part~='cell'] {
      min-height: var(--lumo-size-m);
      background-color: var(--lumo-base-color);
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      cursor: default;
      padding: var(--lumo-space-xs) var(--lumo-space-m);
    }

    /* Apply row borders by default and introduce the "no-row-borders" variant */
    :host(:not([theme~='no-row-borders'])) [part~='cell']:not([part~='details-cell']) {
      border-top: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Hide first body row top border */
    :host(:not([theme~='no-row-borders'])) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      border-top: 0;
      min-height: calc(var(--lumo-size-m) - var(--_lumo-grid-border-width));
    }

    /* Focus-ring */

    [part~='cell']:focus {
      outline: none;
    }

    :host([navigating]) [part~='cell']:focus::before {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    /* Drag and Drop styles */
    :host([dragover])::after {
      content: '';
      position: absolute;
      z-index: 100;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    [part~='row'][dragover] {
      z-index: 100 !important;
    }

    [part~='row'][dragover] [part~='cell'] {
      overflow: visible;
    }

    [part~='row'][dragover] [part~='cell']::after {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      height: calc(var(--_lumo-grid-border-width) + 2px);
      pointer-events: none;
      background: var(--lumo-primary-color-50pct);
    }

    :host([theme~='no-row-borders']) [dragover] [part~='cell']::after {
      height: 2px;
    }

    [part~='row'][dragover='below'] [part~='cell']::after {
      top: 100%;
      bottom: auto;
      margin-top: -1px;
    }

    [part~='row'][dragover='above'] [part~='cell']::after {
      top: auto;
      bottom: 100%;
      margin-bottom: -1px;
    }

    [part~='row'][details-opened][dragover='below'] [part~='cell']:not([part~='details-cell'])::after,
    [part~='row'][details-opened][dragover='above'] [part~='details-cell']::after {
      display: none;
    }

    [part~='row'][dragover][dragover='on-top'] [part~='cell']::after {
      height: 100%;
    }

    [part~='row'][dragstart] {
      /* Add bottom-space to the row so the drag number doesn't get clipped. Needed for IE/Edge */
      border-bottom: 100px solid transparent;
      z-index: 100 !important;
      opacity: 0.9;
    }

    [part~='row'][dragstart] [part~='cell'] {
      border: none !important;
      box-shadow: none !important;
    }

    [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    [ios] [part~='row'][dragstart] [part~='cell'] {
      background: var(--lumo-primary-color-50pct);
    }

    #scroller:not([ios]) [part~='row'][dragstart]:not([dragstart=''])::after {
      display: block;
      position: absolute;
      left: var(--_grid-drag-start-x);
      top: var(--_grid-drag-start-y);
      z-index: 100;
      content: attr(dragstart);
      align-items: center;
      justify-content: center;
      box-sizing: border-box;
      padding: calc(var(--lumo-space-xs) * 0.8);
      color: var(--lumo-error-contrast-color);
      background-color: var(--lumo-error-color);
      border-radius: var(--lumo-border-radius-m);
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-xxs);
      line-height: 1;
      font-weight: 500;
      text-transform: initial;
      letter-spacing: initial;
      min-width: calc(var(--lumo-size-s) * 0.7);
      text-align: center;
    }

    /* Headers and footers */

    [part~='header-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='reorder-ghost'] {
      font-size: var(--lumo-font-size-s);
      font-weight: 500;
    }

    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content) {
      font-weight: 400;
    }

    [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-xl);
    }

    /* Header borders */

    /* Hide first header row top border */
    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='header-cell'] {
      border-top: 0;
    }

    [part='row']:last-child [part~='header-cell'] {
      border-bottom: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='top']) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-border-color);
    }

    /* Footer borders */

    [part='row']:first-child [part~='footer-cell'] {
      border-top: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='bottom']) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-border-color);
    }

    /* Column reordering */

    :host([reordering]) [part~='cell'] {
      background: linear-gradient(var(--lumo-shade-20pct), var(--lumo-shade-20pct)) var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='allowed'] {
      background: var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='dragging'] {
      background: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct)) var(--lumo-base-color);
    }

    [part~='reorder-ghost'] {
      opacity: 0.85;
      box-shadow: var(--lumo-box-shadow-s);
      /* TODO Use the same styles as for the cell element (reorder-ghost copies styles from the cell element) */
      padding: var(--lumo-space-s) var(--lumo-space-m) !important;
    }

    /* Column resizing */

    [part='resize-handle'] {
      width: 3px;
      background-color: var(--lumo-primary-color-50pct);
      opacity: 0;
      transition: opacity 0.2s;
    }

    :host(:not([reordering])) *:not([column-resizing]) [part~='cell']:hover [part='resize-handle'],
    [part='resize-handle']:active {
      opacity: 1;
      transition-delay: 0.15s;
    }

    /* Column borders */

    :host([theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Frozen columns */

    [last-frozen] {
      border-right: var(--_lumo-grid-border-width) solid transparent;
      overflow: hidden;
    }

    :host([overflow~='left']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-right-color: var(--_lumo-grid-border-color);
    }

    /* Row stripes */

    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='body-cell'],
    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='details-cell'] {
      background-image: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct));
      background-repeat: repeat-x;
    }

    /* Selected row */

    /* Raise the selected rows above unselected rows (so that box-shadow can cover unselected rows) */
    :host(:not([reordering])) [part~='row'][selected] {
      z-index: 1;
    }

    :host(:not([reordering])) [part~='row'][selected] [part~='body-cell']:not([part~='details-cell']) {
      background-image: linear-gradient(var(--_lumo-grid-selected-row-color), var(--_lumo-grid-selected-row-color));
      background-repeat: repeat;
    }

    /* Cover the border of an unselected row */
    :host(:not([theme~='no-row-borders'])) [part~='row'][selected] [part~='cell']:not([part~='details-cell']) {
      box-shadow: 0 var(--_lumo-grid-border-width) 0 0 var(--_lumo-grid-selected-row-color);
    }

    /* Compact */

    :host([theme~='compact']) [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-m);
    }

    :host([theme~='compact']) [part~='cell'] {
      min-height: var(--lumo-size-s);
    }

    :host([theme~='compact']) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      min-height: calc(var(--lumo-size-s) - var(--_lumo-grid-border-width));
    }

    :host([theme~='compact']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      padding: var(--lumo-space-xs) var(--lumo-space-s);
    }

    /* Wrap cell contents */

    :host([theme~='wrap-cell-content']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      white-space: normal;
    }

    /* RTL specific styles */

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    :host([dir='rtl'][theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    :host([dir='rtl']) [last-frozen] {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid transparent;
    }

    :host([dir='rtl'][overflow~='right']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-left-color: var(--_lumo-grid-border-color);
    }
  `,{moduleId:"lumo-grid"});jc("vaadin-checkbox",Ci`
    :host(.vaadin-grid-select-all-checkbox) {
      font-size: var(--lumo-font-size-m);
    }
  `,{moduleId:"vaadin-grid-select-all-checkbox-lumo"});var Gce=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),shr=Gce&&Gce[1]>=8,Wce=3,Yce=h9({behaviors:[Qs,v9],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedVirtualIndex:-1,_templateCost:0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return this._physicalSize-this._viewportHeight},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){let e=this._firstVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._physicalSizes[r],t>this._scrollPosition)return n})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){let e=this._lastVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._physicalSizes[r]}),this._lastVisibleIndexVal=e}return e},get _scrollOffset(){return this._scrollerPaddingTop},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){let e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight},_scrollHandler:function(){let e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;let n=Math.round(t/this._physicalAverage);this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage,this._update()}else if(this._physicalCount>0){let{physicalTop:n,indexes:i}=this._getReusables(r);r?(this._physicalTop=n,this._virtualStart=this._virtualStart+i.length,this._physicalStart=this._physicalStart+i.length):(this._virtualStart=this._virtualStart-i.length,this._physicalStart=this._physicalStart-i.length),this._update(i,r?null:i),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),li)}},_getReusables:function(e){let t,r,n,i=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._physicalBottom+this._scrollOffset,h=this._scrollTop,f=this._scrollBottom;for(e?(t=this._physicalStart,r=h-c):(t=this._physicalEnd,r=u-f);n=this._physicalSizes[t],r=r-n,!(i.length>=l||r<=o);)if(e){if(s+i.length+1>=this._virtualCount||c+n>=h-this._scrollOffset)break;i.push(t),c=c+n,t=(t+1)%l}else{if(a-i.length<=0||c+this._physicalSize-n<=f)break;i.push(t),c=c-n,t=t===0?l-1:t-1}return{indexes:i,physicalTop:c-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){let r=t.pop();this._physicalTop-=this._physicalSizes[r]}this._positionItems(),this._updateScrollerSize()}},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){let r=this._clamp(this._physicalCount+e,Wce,this._virtualCount-this._virtualStart)-this._physicalCount,n=Math.round(this._physicalCount*.5);if(!(r<0)){if(r>0){let i=window.performance.now();[].push.apply(this._physicalItems,this._createPool(r));for(let o=0;o<r;o++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+r,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+r),this._update(),this._templateCost=(window.performance.now()-i)/r,n=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||n===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,n)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,n),li))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){let{physicalTop:e,indexes:t}=this._getReusables(!0);this._physicalTop=e,this._virtualStart=this._virtualStart+t.length,this._physicalStart=this._physicalStart+t.length,this._update(t),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(Wce))},_itemsChanged:function(e){e.path==="items"&&(this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._debounce("_render",this._render,Ni))},_iterateItems:function(e,t){let r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_updateMetrics:function(e){if(!this._isVisible)return;ci();let t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this._physicalSize=this._physicalSize+t-r,this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();let e=this._physicalTop;this._iterateItems(function(t){this.translate3d(0,e+"px",0,this._physicalItems[t]),e+=this._physicalSizes[t]})},_adjustScrollPosition:function(){let e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;let t=this._scrollTop;!shr&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToIndex:function(e){if(typeof e!="number"||e<0||e>this.items.length-1||(ci(),this._physicalCount===0))return;e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=e-1),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage;let t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;for(;r<e&&n<=i;)n=n+this._physicalSizes[t],t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this.updateViewportBoundaries(),this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])}});var tV=class extends Yce{static get properties(){return{size:{type:Number,notify:!0},_vidxOffset:{type:Number,value:0}}}static get observers(){return["_effectiveSizeChanged(_effectiveSize)"]}connectedCallback(){super.connectedCallback(),this._scrollHandler()}_updateScrollerItem(){}_afterScroll(){}_getRowTarget(){}_createScrollerRows(){}_canPopulate(){}scrollToIndex(t){this._warnPrivateAPIAccess("scrollToIndex"),this._scrollingToIndex=!0,t=Math.min(Math.max(t,0),this._effectiveSize-1),this.$.table.scrollTop=t/this._effectiveSize*(this.$.table.scrollHeight-this.$.table.offsetHeight),this._scrollHandler(),this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize&&this._adjustVirtualIndexOffset(1e6),this._accessIronListAPI(()=>super.scrollToIndex(t-this._vidxOffset)),this._scrollHandler();let r=Array.from(this.$.items.children).filter(n=>n.index===t)[0];if(r){let n=r.getBoundingClientRect().top-this.$.header.getBoundingClientRect().bottom;Math.abs(n)>1&&(this.$.table.scrollTop+=n,this._scrollHandler())}this._scrollingToIndex=!1}_effectiveSizeChanged(t){let r,n=0;this._iterateItems((i,o)=>{if(o===this._firstVisibleIndex){let a=this._physicalItems[i];r=a.index,n=a.getBoundingClientRect().top}}),this.items&&t<this.items.length&&(this._scrollTop=0),Array.isArray(this.items)||(this.items={length:Math.min(t,1e5)}),this._accessIronListAPI(()=>super._itemsChanged({path:"items"})),this._virtualCount=Math.min(this.items.length,t)||0,this._scrollTop===0&&(this._accessIronListAPI(()=>this._scrollToIndex(Math.min(t-1,r))),this._iterateItems(i=>{let o=this._physicalItems[i];if(o.index===r&&(this.$.table.scrollTop+=Math.round(o.getBoundingClientRect().top-n)),o.index===this._focusedItemIndex&&this._itemsFocusable&&this.$.items.contains(this.shadowRoot.activeElement)){let a=Array.from(this._itemsFocusable.parentElement.children).indexOf(this._itemsFocusable);o.children[a].focus()}})),this._assignModels(),requestAnimationFrame(()=>this._update()),this.__updateFooterPositioning()}_positionItems(){this._adjustScrollPosition();let t;isNaN(this._physicalTop)&&(t=!0,this._physicalTop=0);let r=this._physicalTop;this._iterateItems(n=>{this._physicalItems[n].style.transform=`translateY(${r}px)`,r+=this._physicalSizes[n]}),t&&this._scrollToIndex(0)}_increasePoolIfNeeded(t){t===0&&this._scrollingToIndex||!this._canPopulate()||!this._effectiveSize||(this._initialPoolCreated?this._optPhysicalSize!==1/0&&(this._debounceIncreasePool=sr.debounce(this._debounceIncreasePool,Ni,()=>{this._updateMetrics();let r=this._optPhysicalSize-this._physicalSize,n=Math.ceil(r/this._physicalAverage);this._physicalCount+n>this._effectiveSize&&(n=Math.max(0,this._effectiveSize-this._physicalCount)),this._physicalSize&&n>0&&this._optPhysicalSize!==1/0&&(super._increasePoolIfNeeded(n),this.__reorderChildNodes())})):(this._initialPoolCreated=!0,super._increasePoolIfNeeded(25)))}__reorderChildNodes(){let t=Array.from(this.$.items.childNodes);!!t.reduce((n,i,o,a)=>{if(o===0||a[o-1].index===i.index-1)return n},!0)||t.sort((n,i)=>n.index-i.index).forEach(n=>this.$.items.appendChild(n))}_createPool(t){let r=document.createDocumentFragment(),n=this._createScrollerRows(t);n.forEach(o=>r.appendChild(o)),this._getRowTarget().appendChild(r);let i=this.querySelector("[slot]");if(i){let o=i.getAttribute("slot");i.setAttribute("slot","foo-bar"),i.setAttribute("slot",o)}return Cm(this,()=>this.notifyResize()),n}_assignModels(t){this._iterateItems((r,n)=>{let i=this._physicalItems[r];this._toggleAttribute("hidden",n>=this._effectiveSize,i),this._updateScrollerItem(i,n+(this._vidxOffset||0))},t)}_scrollHandler(){let t=this.$.table.scrollTop-this._scrollPosition;this._accessIronListAPI(super._scrollHandler);let r=this._vidxOffset;this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize?this._adjustVirtualIndexOffset(t):this._vidxOffset=0,this._vidxOffset!==r&&this._update(),this._afterScroll()}_adjustVirtualIndexOffset(t){if(Math.abs(t)>1e4){if(this._noScale){this._noScale=!1;return}let r=this.$.table.scrollTop/(this.$.table.scrollHeight-this.$.table.offsetHeight),n=r*this._effectiveSize;this._vidxOffset=Math.round(n-r*this._virtualCount)}else{let r=this._vidxOffset||0,n=1e3,i=100;this._scrollTop===0?(this._vidxOffset=0,r!==this._vidxOffset&&super.scrollToIndex(0)):this.firstVisibleIndex<n&&this._vidxOffset>0&&(this._vidxOffset-=Math.min(this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex+(r-this._vidxOffset)),this._noScale=!0);let o=this._effectiveSize-this._virtualCount;this._scrollTop>=this._maxScrollTop&&this._maxScrollTop>0?(this._vidxOffset=o,r!==this._vidxOffset&&super.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-n&&this._vidxOffset<o&&(this._vidxOffset+=Math.min(o-this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-r)),this._noScale=!0)}}_accessIronListAPI(t){this._warnPrivateAPIAccessAsyncEnabled=!1;let r=t.apply(this);return this._debouncerWarnPrivateAPIAccess=sr.debounce(this._debouncerWarnPrivateAPIAccess,Ni,()=>this._warnPrivateAPIAccessAsyncEnabled=!0),r}_debounceRender(t,r){super._debounceRender(()=>this._accessIronListAPI(t),r)}_warnPrivateAPIAccess(t){this._warnPrivateAPIAccessAsyncEnabled&&console.warn(`Accessing private API (${t})!`)}_render(){this._accessIronListAPI(super._render)}_itemsChanged(){}get _firstVisibleIndex(){return this._accessIronListAPI(()=>super.firstVisibleIndex)}get _lastVisibleIndex(){return this._accessIronListAPI(()=>super.lastVisibleIndex)}_scrollToIndex(t){this._accessIronListAPI(()=>this.scrollToIndex(t))}get firstVisibleIndex(){return this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex}set firstVisibleIndex(t){this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex=t}get lastVisibleIndex(){return this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex}set lastVisibleIndex(t){this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex=t}updateViewportBoundaries(){this._warnPrivateAPIAccess("updateViewportBoundaries"),super.updateViewportBoundaries.apply(this,arguments)}_resizeHandler(){super._resizeHandler(),ci()}};var jce=e=>class extends e{static get observers(){return["_a11yUpdateGridSize(size, _columnTree, _columnTree.*)"]}_a11yGetHeaderRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer||i.path||i.header)).length}_a11yGetFooterRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer)).length}_a11yUpdateGridSize(r,n){if(r===void 0||n===void 0)return;let i=n[n.length-1];this.$.table.setAttribute("aria-rowcount",r+this._a11yGetHeaderRowCount(n)+this._a11yGetFooterRowCount(n)),this.$.table.setAttribute("aria-colcount",i&&i.length||0),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows()}_a11yUpdateHeaderRows(){Array.from(this.$.header.children).forEach((r,n)=>r.setAttribute("aria-rowindex",n+1))}_a11yUpdateFooterRows(){Array.from(this.$.footer.children).forEach((r,n)=>r.setAttribute("aria-rowindex",this._a11yGetHeaderRowCount(this._columnTree)+this.size+n+1))}_a11yUpdateRowRowindex(r,n){r.setAttribute("aria-rowindex",n+this._a11yGetHeaderRowCount(this._columnTree)+1)}_a11yUpdateRowSelected(r,n){r.setAttribute("aria-selected",Boolean(n)),Array.from(r.children).forEach(i=>i.setAttribute("aria-selected",Boolean(n)))}_a11yUpdateRowLevel(r,n){r.setAttribute("aria-level",n+1)}_a11yUpdateRowDetailsOpened(r,n){Array.from(r.children).forEach(i=>{typeof n=="boolean"?i.setAttribute("aria-expanded",n):i.hasAttribute("aria-expanded")&&i.removeAttribute("aria-expanded")})}_a11ySetRowDetailsCell(r,n){Array.from(r.children).forEach(i=>{i!==n&&i.setAttribute("aria-controls",n.id)})}_a11yUpdateCellColspan(r,n){r.setAttribute("aria-colspan",Number(n))}_a11yUpdateSorters(){Array.from(this.querySelectorAll("vaadin-grid-sorter")).forEach(r=>{let n=r.parentNode;for(;n&&n.localName!=="vaadin-grid-cell-content";)n=n.parentNode;n&&n.assignedSlot&&n.assignedSlot.parentNode.setAttribute("aria-sort",{asc:"ascending",desc:"descending"}[String(r.direction)]||"none")})}};var Xce=e=>class extends e{static get properties(){return{activeItem:{type:Object,notify:!0,value:null}}}ready(){super.ready(),this.$.scroller.addEventListener("click",this._onClick.bind(this)),this.addEventListener("cell-activate",this._activateItem.bind(this))}_activateItem(r){let n=r.detail.model,i=n?n.item:null;i&&(this.activeItem=this._itemsEqual(this.activeItem,i)?null:i)}_onClick(r){if(r.defaultPrevented)return;let n=r.composedPath(),i=n[n.indexOf(this.$.table)-3];if(!i||i.getAttribute("part").indexOf("details-cell")>-1)return;let o=i._content,a=this.getRootNode().activeElement;!o.contains(a)&&!this._isFocusable(r.target)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(i.parentElement)}}))}_isFocusable(r){return lhr(r)}},lhr=e=>{if(!e.parentNode)return!1;let r=Array.from(e.parentNode.querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]")).filter(n=>n.getAttribute("part")!=="cell body-cell").indexOf(e)!==-1;return!e.disabled&&r};var $ce=e=>class extends e{static get properties(){return{items:Array}}static get observers(){return["_itemsChanged(items, items.*, isAttached)"]}_itemsChanged(r,n,i){if(!!i){if(!Array.isArray(r)){r==null&&(this.size=0),this.dataProvider===this._arrayDataProvider&&(this.dataProvider=void 0);return}this.size=r.length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache(),this._ensureFirstPageLoaded()}}_arrayDataProvider(r,n){let i=(Array.isArray(this.items)?this.items:[]).slice(0);this._filters&&this._checkPaths(this._filters,"filtering",i)&&(i=this._filter(i)),this.size=i.length,r.sortOrders.length&&this._checkPaths(this._sorters,"sorting",i)&&(i=i.sort(this._multiSort.bind(this)));let o=r.page*r.pageSize,a=o+r.pageSize,s=i.slice(o,a);n(s,i.length)}_checkPaths(r,n,i){if(!i.length)return!1;let o=!0;for(let a in r){let s=r[a].path;if(!s||s.indexOf(".")===-1)continue;let l=s.replace(/\.[^.]*$/,"");Oa.get(l,i[0])===void 0&&(console.warn(`Path "${s}" used for ${n} does not exist in all of the items, ${n} is disabled.`),o=!1)}return o}_multiSort(r,n){return this._sorters.map(i=>i.direction==="asc"?this._compare(Oa.get(i.path,r),Oa.get(i.path,n)):i.direction==="desc"?this._compare(Oa.get(i.path,n),Oa.get(i.path,r)):0).reduce((i,o)=>i||o,0)}_normalizeEmptyValue(r){return[void 0,null].indexOf(r)>=0?"":isNaN(r)?r.toString():r}_compare(r,n){return r=this._normalizeEmptyValue(r),n=this._normalizeEmptyValue(n),r<n?-1:r>n?1:0}_filter(r){return r.filter(n=>this._filters.filter(i=>{let o=this._normalizeEmptyValue(Oa.get(i.path,n)),a=this._normalizeEmptyValue(i.value).toString().toLowerCase();return o.toString().toLowerCase().indexOf(a)===-1}).length===0)}};var Kce=e=>class extends vh(e){ready(){super.ready();let r=this.$.scroller;Tm(r,"track",this._onHeaderTrack.bind(this)),r.addEventListener("touchmove",n=>r.hasAttribute("column-resizing")&&n.preventDefault()),r.addEventListener("contextmenu",n=>n.target.getAttribute("part")=="resize-handle"&&n.preventDefault()),r.addEventListener("mousedown",n=>n.target.getAttribute("part")==="resize-handle"&&n.preventDefault())}_onHeaderTrack(r){let n=r.target;if(n.getAttribute("part")==="resize-handle"){let o=n.parentElement._column;for(this._toggleAttribute("column-resizing",!0,this.$.scroller);o.localName==="vaadin-grid-column-group";)o=Array.prototype.slice.call(o._childColumns,0).sort(function(l,c){return l._order-c._order}).filter(function(l){return!l.hidden}).pop();let a=Array.from(this.$.header.querySelectorAll('[part~="row"]:last-child [part~="cell"]')),s=a.filter(l=>l._column===o)[0];if(s.offsetWidth){let l=window.getComputedStyle(s),c=10+parseInt(l.paddingLeft)+parseInt(l.paddingRight)+parseInt(l.borderLeftWidth)+parseInt(l.borderRightWidth)+parseInt(l.marginLeft)+parseInt(l.marginRight),u=s.offsetWidth+(this.__isRTL?s.getBoundingClientRect().left-r.detail.x:r.detail.x-s.getBoundingClientRect().right);o.width=Math.max(c,u)+"px",o.flexGrow=0}a.sort(function(l,c){return l._column._order-c._column._order}).forEach(function(l,c,u){c<u.indexOf(s)&&(l._column.width=l.offsetWidth+"px",l._column.flexGrow=0)}),r.detail.state==="end"&&(this._toggleAttribute("column-resizing",!1,this.$.scroller),this.dispatchEvent(new CustomEvent("column-resize",{detail:{resizedColumn:o}}))),this._resizeHandler()}}};var Zce=class Jce{constructor(t,r,n){this.grid=t,this.parentCache=r,this.parentItem=n,this.itemCaches={},this.items={},this.effectiveSize=0,this.size=0,this.pendingRequests={}}isLoading(){return Boolean(Object.keys(this.pendingRequests).length||Object.keys(this.itemCaches).filter(t=>this.itemCaches[t].isLoading())[0])}getItemForIndex(t){let{cache:r,scaledIndex:n}=this.getCacheAndIndex(t);return r.items[n]}updateSize(){this.effectiveSize=!this.parentItem||this.grid._isExpanded(this.parentItem)?this.size+Object.keys(this.itemCaches).reduce((t,r)=>{let n=this.itemCaches[r];return n.updateSize(),t+n.effectiveSize},0):0}ensureSubCacheForScaledIndex(t){if(!this.itemCaches[t]){let r=new Jce(this.grid,this,this.items[t]);this.itemCaches[t]=r,this.grid._loadPage(0,r)}}getCacheAndIndex(t){let r=t,n=Object.keys(this.itemCaches);for(let i=0;i<n.length;i++){let o=Number(n[i]),a=this.itemCaches[o];if(r<=o)return{cache:this,scaledIndex:r};if(r<=o+a.effectiveSize)return a.getCacheAndIndex(r-o-1);r-=a.effectiveSize}return{cache:this,scaledIndex:r}}},Qce=e=>class extends e{static get properties(){return{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},loading:{type:Boolean,notify:!0,readOnly:!0,reflectToAttribute:!0},_cache:{type:Object,value:function(){return new Zce(this)}},itemIdPath:{type:String,value:null},expandedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_sizeChanged(size)","_itemIdPathChanged(itemIdPath)","_expandedItemsChanged(expandedItems.*)"]}_sizeChanged(r){let n=r-this._cache.size;this._cache.size+=n,this._cache.effectiveSize+=n,this._effectiveSize=this._cache.effectiveSize,this._increasePoolIfNeeded(0),this._debounceIncreasePool&&this._debounceIncreasePool.flush()}_getItem(r,n){if(r>=this._effectiveSize)return;n.index=r;let{cache:i,scaledIndex:o}=this._cache.getCacheAndIndex(r),a=i.items[o];a?(this._toggleAttribute("loading",!1,n),this._updateItem(n,a),this._isExpanded(a)&&i.ensureSubCacheForScaledIndex(o)):(this._toggleAttribute("loading",!0,n),this._loadPage(this._getPageForIndex(o),i))}_expandedInstanceChangedCallback(r,n){r.item!==void 0&&(n?this.expandItem(r.item):this.collapseItem(r.item))}getItemId(r){return this.itemIdPath?this.get(this.itemIdPath,r):r}_isExpanded(r){return this.__expandedKeys.has(this.getItemId(r))}_expandedItemsChanged(){this.__cacheExpandedKeys(),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,this._assignModels()}_itemIdPathChanged(){this.__cacheExpandedKeys()}__cacheExpandedKeys(){this.expandedItems&&(this.__expandedKeys=new Set,this.expandedItems.forEach(r=>{this.__expandedKeys.add(this.getItemId(r))}))}expandItem(r){this._isExpanded(r)||(this.expandedItems=[...this.expandedItems,r])}collapseItem(r){this._isExpanded(r)&&(this.expandedItems=this.expandedItems.filter(n=>!this._itemsEqual(n,r)))}_getIndexLevel(r){let{cache:n}=this._cache.getCacheAndIndex(r),i=0;for(;n.parentCache;)n=n.parentCache,i++;return i}_canPopulate(){return Boolean(this._hasData&&this._columnTree)}_loadPage(r,n){if(!n.pendingRequests[r]&&this.dataProvider){this._setLoading(!0),n.pendingRequests[r]=!0;let i={page:r,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters(),parentItem:n.parentItem};this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.dataProvider(i,(o,a)=>{a!==void 0?n.size=a:i.parentItem&&(n.size=o.length);let s=Array.from(this.$.items.children).map(l=>l._item);o.forEach((l,c)=>{let u=r*this.pageSize+c;n.items[u]=l,this._isExpanded(l)&&s.indexOf(l)>-1&&n.ensureSubCacheForScaledIndex(u)}),this._hasData=!0,delete n.pendingRequests[r],this._debouncerApplyCachedData=sr.debounce(this._debouncerApplyCachedData,mo.after(0),()=>{this._setLoading(!1),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,Array.from(this.$.items.children).filter(l=>!l.hidden).forEach(l=>{this._cache.getItemForIndex(l.index)&&this._getItem(l.index,l)}),this._increasePoolIfNeeded(0),this.__scrollToPendingIndex()}),this._cache.isLoading()||this._debouncerApplyCachedData.flush(),this.__itemsReceived()})}}_getPageForIndex(r){return Math.floor(r/this.pageSize)}clearCache(){this._cache=new Zce(this),Array.from(this.$.items.children).forEach(r=>{Array.from(r.children).forEach(n=>{n._instance&&n._instance._setPendingProperty("item",{},!1)})}),this._cache.size=this.size||0,this._cache.updateSize(),this._hasData=!1,this._assignModels(),(!this._effectiveSize||!this._initialPoolCreated)&&this._loadPage(0,this._cache)}_pageSizeChanged(r,n){n!==void 0&&r!==n&&this.clearCache()}_checkSize(){this.size===void 0&&this._effectiveSize===0&&console.warn("The <vaadin-grid> needs the total number of items in order to display rows. Set the total number of items to the `size` property, or provide the total number of items in the second argument of the `dataProvider`\u2019s `callback` call.")}_dataProviderChanged(r,n){n!==void 0&&this.clearCache(),r&&this.items&&this.items.length&&this._scrollToIndex(this._firstVisibleIndex),this._ensureFirstPageLoaded(),this._debouncerCheckSize=sr.debounce(this._debouncerCheckSize,mo.after(2e3),this._checkSize.bind(this)),this._scrollHandler()}_ensureFirstPageLoaded(){this._hasData||this._loadPage(0,this._cache)}_itemsEqual(r,n){return this.getItemId(r)===this.getItemId(n)}_getItemIndexInArray(r,n){let i=-1;return n.forEach((o,a)=>{this._itemsEqual(o,r)&&(i=a)}),i}scrollToIndex(r){super.scrollToIndex(r),!isNaN(r)&&(this._cache.isLoading()||!this.clientHeight)&&(this.__pendingScrollToIndex=r)}__scrollToPendingIndex(){if(this.__pendingScrollToIndex&&this.$.items.children.length){let r=this.__pendingScrollToIndex;delete this.__pendingScrollToIndex,this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.scrollToIndex(r)}}};var tue=e=>class extends e{ready(){super.ready(),this._addNodeObserver()}_hasColumnGroups(r){for(let n=0;n<r.length;n++)if(r[n].localName==="vaadin-grid-column-group")return!0;return!1}_getChildColumns(r){return xh.getFlattenedNodes(r).filter(this._isColumnElement)}_flattenColumnGroups(r){return r.map(n=>n.localName==="vaadin-grid-column-group"?this._getChildColumns(n):[n]).reduce((n,i)=>n.concat(i),[])}_getColumnTree(){let r=xh.getFlattenedNodes(this).filter(this._isColumnElement),n=[];for(let i=r;n.push(i),!!this._hasColumnGroups(i);)i=this._flattenColumnGroups(i);return n}_updateColumnTree(){let r=this._getColumnTree();this._arrayEquals(r,this._columnTree)||(this._columnTree=r)}_addNodeObserver(){this._observer=new xh(this,r=>{let n=r.addedNodes.filter(o=>o.localName==="template"&&o.classList.contains("row-details"))[0];n&&this._rowDetailsTemplate!==n&&(this._rowDetailsTemplate=n);let i=o=>o.filter(this._isColumnElement).length>0;if(i(r.addedNodes)||i(r.removedNodes)){let o=r.removedNodes.flatMap(s=>s._allCells),a=s=>o.filter(l=>l._content.contains(s)).length;this.__removeSorters(this._sorters.filter(a)),this.__removeFilters(this._filters.filter(a)),this._updateColumnTree()}this._debouncerCheckImports=sr.debounce(this._debouncerCheckImports,mo.after(2e3),this._checkImports.bind(this)),this._ensureFirstPageLoaded()})}_arrayEquals(r,n){if(!r||!n||r.length!=n.length)return!1;for(let i=0,o=r.length;i<o;i++)if(r[i]instanceof Array&&n[i]instanceof Array){if(!this._arrayEquals(r[i],n[i]))return!1}else if(r[i]!=n[i])return!1;return!0}_checkImports(){["vaadin-grid-column-group","vaadin-grid-filter","vaadin-grid-filter-column","vaadin-grid-tree-toggle","vaadin-grid-selection-column","vaadin-grid-sort-column","vaadin-grid-sorter"].forEach(r=>{let n=this.querySelector(r);n&&!(n instanceof mt)&&console.warn(`Make sure you have imported the required module for <${r}> element.`)})}_updateFirstAndLastColumn(){Array.from(this.shadowRoot.querySelectorAll("tr")).forEach(r=>this._updateFirstAndLastColumnForRow(r))}_updateFirstAndLastColumnForRow(r){Array.from(r.querySelectorAll('[part~="cell"]:not([part~="details-cell"])')).sort((n,i)=>n._column._order-i._column._order).forEach((n,i,o)=>{this._toggleAttribute("first-column",i===0,n),this._toggleAttribute("last-column",i===o.length-1,n)})}_isColumnElement(r){return r.nodeType===Node.ELEMENT_NODE&&/\bcolumn\b/.test(r.localName)}};var eue=e=>class extends e{getEventContext(r){let n={},i=r.composedPath(),o=i[i.indexOf(this.$.table)-3];return o&&(n.section=["body","header","footer","details"].filter(a=>o.getAttribute("part").indexOf(a)>-1)[0],o._column&&(n.column=o._column),(n.section==="body"||n.section==="details")&&Object.assign(n,this.__getRowModel(o.parentElement))),n}};var rue=e=>class extends e{static get properties(){return{_filters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("filter-changed",this._filterChanged.bind(this))}_filterChanged(r){r.stopPropagation(),this.__addFilter(r.target),this.__applyFilters()}__removeFilters(r){r.length!=0&&(this._filters=this._filters.filter(n=>r.indexOf(n)<0),this.__applyFilters())}__addFilter(r){this._filters.indexOf(r)===-1&&this._filters.push(r)}__applyFilters(){this.dataProvider&&this.isAttached&&this.clearCache()}_mapFilters(){return this._filters.map(r=>({path:r.path,value:r.value}))}};var C0=class extends mt{static get is(){return"vaadin-grid-templatizer"}static get properties(){return{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}},_grid:Object}}static get observers(){return["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"]}constructor(){super(),this._instanceProps={detailsOpened:!0,index:!0,item:!0,selected:!0,expanded:!0,level:!0}}createInstance(){this._ensureTemplatized();let t=new this._TemplateClass({});return this.addInstance(t),t}addInstance(t){this._templateInstances.indexOf(t)===-1&&(this._templateInstances.push(t),requestAnimationFrame(()=>this.notifyPath("_templateInstances.*",this._templateInstances)))}removeInstance(t){let r=this._templateInstances.indexOf(t);this.splice("_templateInstances",r,1)}_ensureTemplatized(){this._TemplateClass||(this._TemplateClass=tc(this.template,this,{instanceProps:this._instanceProps,parentModel:!0,forwardHostProp:function(t,r){this._forwardParentProp(t,r),this._templateInstances&&this._templateInstances.forEach(n=>n.notifyPath(t,r))},notifyInstanceProp:function(t,r,n){if(r==="index"||r==="item")return;let i=`__${r}__`;if(t[i]===n)return;t[i]=n;let o=Array.from(this._grid.$.items.children).filter(l=>this._grid._itemsEqual(l._item,t.item))[0];o&&Array.from(o.children).forEach(l=>{l._instance&&(l._instance[i]=n,l._instance.notifyPath(r,n))});let a="item.";if(Array.isArray(this._grid.items)&&r.indexOf(a)===0){let l=this._grid.items.indexOf(t.item),c=r.slice(a.length);this._grid.notifyPath(`items.${l}.${c}`,n)}let s=`_${r}InstanceChangedCallback`;this._grid&&this._grid[s]&&this._grid[s](t,n)}}))}_forwardParentProp(t,r){this._parentPathValues[t]=r,this._templateInstances.forEach(n=>n.notifyPath(t,r))}_templateInstancesChanged(t){let r,n;if(t.path==="_templateInstances")r=0,n=this._templateInstances.length;else if(t.path==="_templateInstances.splices")r=t.value.index,n=t.value.addedCount;else return;Object.keys(this._parentPathValues||{}).forEach(i=>{for(let o=r;o<r+n;o++)this._templateInstances[o].set(i,this._parentPathValues[i])})}};customElements.define(C0.is,C0);var nue=e=>class extends e{static get properties(){return{detailsOpenedItems:{type:Array,value:function(){return[]}},_rowDetailsTemplate:Object,rowDetailsRenderer:Function,_detailsCells:{type:Array}}}static get observers(){return["_detailsOpenedItemsChanged(detailsOpenedItems.*, _rowDetailsTemplate, rowDetailsRenderer)","_rowDetailsTemplateOrRendererChanged(_rowDetailsTemplate, rowDetailsRenderer)"]}_rowDetailsTemplateOrRendererChanged(r,n){if(r&&n)throw new Error("You should only use either a renderer or a template for row details");if(r||n){if(r&&!r.templatizer){let i=new C0;i._grid=this,i.dataHost=this.dataHost,i.template=r,r.templatizer=i}this._columnTree&&Array.from(this.$.items.children).forEach(i=>{i.querySelector("[part~=details-cell]")||(this._updateRow(i,this._columnTree[this._columnTree.length-1]),this._a11yUpdateRowDetailsOpened(i,!1)),delete i.querySelector("[part~=details-cell]")._instance}),this.detailsOpenedItems.length&&(Array.from(this.$.items.children).forEach(this._toggleDetailsCell,this),this._update())}}_detailsOpenedItemsChanged(r){r.path==="detailsOpenedItems.length"||!r.value||Array.from(this.$.items.children).forEach(n=>{this._toggleDetailsCell(n,n._item),this._a11yUpdateRowDetailsOpened(n,this._isDetailsOpened(n._item)),this._toggleAttribute("details-opened",this._isDetailsOpened(n._item),n)})}_configureDetailsCell(r){r.setAttribute("part","cell details-cell"),this._toggleAttribute("frozen",!0,r)}_toggleDetailsCell(r,n){let i=r.querySelector('[part~="details-cell"]');if(!i)return;let o=!this._isDetailsOpened(n),a=!!i.hidden!==o;(!i._instance&&!i._renderer||i.hidden!==o)&&(i.hidden=o,o?r.style.removeProperty("padding-bottom"):(this.rowDetailsRenderer?(i._renderer=this.rowDetailsRenderer,i._renderer.call(this,i._content,this,{index:r.index,item:n})):this._rowDetailsTemplate&&!i._instance&&(i._instance=this._rowDetailsTemplate.templatizer.createInstance(),i._content.innerHTML="",i._content.appendChild(i._instance.root),this._updateItem(r,n)),ci(),r.style.setProperty("padding-bottom",`${i.offsetHeight}px`),requestAnimationFrame(()=>this.notifyResize()))),a&&(this._updateMetrics(),this._positionItems())}_updateDetailsCellHeights(){Array.from(this.$.items.querySelectorAll('[part~="details-cell"]:not([hidden])')).forEach(r=>{r.parentElement.style.setProperty("padding-bottom",`${r.offsetHeight}px`)})}_isDetailsOpened(r){return this.detailsOpenedItems&&this._getItemIndexInArray(r,this.detailsOpenedItems)!==-1}openItemDetails(r){this._isDetailsOpened(r)||(this.detailsOpenedItems=[...this.detailsOpenedItems,r])}closeItemDetails(r){this._isDetailsOpened(r)&&(this.detailsOpenedItems=this.detailsOpenedItems.filter(n=>!this._itemsEqual(n,r)))}_detailsOpenedInstanceChangedCallback(r,n){n?this.openItemDetails(r.item):this.closeItemDetails(r.item)}};var zct={SCROLLING:500,IGNORE_WHEEL:500},iue=e=>class extends e{static get properties(){return{_frozenCells:{type:Array,value:()=>[]},_rowWithFocusedElement:Element,_deltaYAcc:{type:Number,value:0},_useSticky:{type:Boolean,value:window.CSS&&window.CSS.supports&&(window.CSS.supports("position","sticky")||window.CSS.supports("position","-webkit-sticky"))}}}static get observers(){return["_scrollViewportHeightUpdated(_viewportHeight)"]}set _scrollTop(r){this.$.table.scrollTop=r}get _scrollTop(){return this.$.table.scrollTop}constructor(){super(),this._scrollLineHeight=this._getScrollLineHeight()}_getScrollLineHeight(){let r=document.createElement("div");r.style.fontSize="initial",r.style.display="none",document.body.appendChild(r);let n=window.getComputedStyle(r).fontSize;return document.body.removeChild(r),n?window.parseInt(n):void 0}_scrollViewportHeightUpdated(r){this._scrollPageHeight=r-this.$.header.clientHeight-this.$.footer.clientHeight-this._scrollLineHeight}ready(){super.ready(),this.$.outerscroller=document.createElement("div"),this.scrollTarget=this.$.table,this.addEventListener("wheel",this._onWheel),this.$.items.addEventListener("focusin",r=>{let n=r.composedPath().indexOf(this.$.items);this._rowWithFocusedElement=r.composedPath()[n-1]}),this.$.items.addEventListener("focusout",()=>this._rowWithFocusedElement=void 0),this.scrollTarget.addEventListener("mousedown",()=>this.__mouseDown=!0),this.scrollTarget.addEventListener("mouseup",()=>{this.__mouseDown=!1,this.__pendingReorder&&(this.__pendingReorder=!1,setTimeout(()=>this._reorderRows(),zct.SCROLLING))})}scrollToIndex(r){this._accessIronListAPI(()=>super.scrollToIndex(r))}_onWheel(r){if(r.ctrlKey||this._hasScrolledAncestor(r.target,r.deltaX,r.deltaY))return;let n=this.$.table,i=r.deltaY;if(r.deltaMode===WheelEvent.DOM_DELTA_LINE?i*=this._scrollLineHeight:r.deltaMode===WheelEvent.DOM_DELTA_PAGE&&(i*=this._scrollPageHeight),this._wheelAnimationFrame){this._deltaYAcc+=i,r.preventDefault();return}i+=this._deltaYAcc,this._deltaYAcc=0,this._wheelAnimationFrame=!0,this._debouncerWheelAnimationFrame=sr.debounce(this._debouncerWheelAnimationFrame,Ni,()=>this._wheelAnimationFrame=!1);let o=Math.abs(r.deltaX)+Math.abs(i);this._canScroll(n,r.deltaX,i)?(r.preventDefault(),n.scrollTop+=i,n.scrollLeft+=r.deltaX,this._scrollHandler(),this._hasResidualMomentum=!0,this._ignoreNewWheel=!0,this._debouncerIgnoreNewWheel=sr.debounce(this._debouncerIgnoreNewWheel,mo.after(zct.IGNORE_WHEEL),()=>this._ignoreNewWheel=!1)):this._hasResidualMomentum&&o<=this._previousMomentum||this._ignoreNewWheel?r.preventDefault():o>this._previousMomentum&&(this._hasResidualMomentum=!1),this._previousMomentum=o}_hasScrolledAncestor(r,n,i){if(r.localName==="vaadin-grid-cell-content")return!1;if(this._canScroll(r,n,i)&&["auto","scroll"].indexOf(getComputedStyle(r).overflow)!==-1)return!0;if(r!==this&&r.parentElement)return this._hasScrolledAncestor(r.parentElement,n,i)}_canScroll(r,n,i){return i>0&&r.scrollTop<r.scrollHeight-r.offsetHeight||i<0&&r.scrollTop>0||n>0&&r.scrollLeft<r.scrollWidth-r.offsetWidth||n<0&&r.scrollLeft>0}_scheduleScrolling(){this._scrollingFrame||(this._scrollingFrame=requestAnimationFrame(()=>this._toggleAttribute("scrolling",!0,this.$.scroller))),this._debounceScrolling=sr.debounce(this._debounceScrolling,mo.after(zct.SCROLLING),()=>{cancelAnimationFrame(this._scrollingFrame),delete this._scrollingFrame,this._toggleAttribute("scrolling",!1,this.$.scroller),this._reorderRows()})}_afterScroll(){this._translateStationaryElements(),this.hasAttribute("reordering")||this._scheduleScrolling(),this._updateOverflow()}_updateOverflow(){let r="",n=this.$.table;n.scrollTop<n.scrollHeight-n.clientHeight&&(r+=" bottom"),n.scrollTop>0&&(r+=" top"),n.scrollLeft<n.scrollWidth-n.clientWidth&&(r+=" right"),n.scrollLeft>0&&(r+=" left"),this._debounceOverflow=sr.debounce(this._debounceOverflow,Ni,()=>{let i=r.trim();i.length>0&&this.getAttribute("overflow")!==i?this.setAttribute("overflow",i):i.length==0&&this.hasAttribute("overflow")&&this.removeAttribute("overflow")})}_reorderRows(){if(this.__mouseDown){this.__pendingReorder=!0;return}let r=this.$.items,n=r.querySelectorAll("tr");if(!n.length)return;let i=this._virtualStart+this._vidxOffset,o=this._rowWithFocusedElement||Array.from(n).filter(l=>!l.hidden)[0];if(!o)return;let a=o.index-i,s=Array.from(n).indexOf(o)-a;if(s>0)for(let l=0;l<s;l++)r.appendChild(n[l]);else if(s<0)for(let l=n.length+s;l<n.length;l++)r.insertBefore(n[l],n[0]);if(this._safari){let{transform:l}=this.$.header.style;this.$.header.style.transform="",setTimeout(()=>this.$.header.style.transform=l)}}_frozenCellsChanged(){this._debouncerCacheElements=sr.debounce(this._debouncerCacheElements,li,()=>{Array.from(this.shadowRoot.querySelectorAll('[part~="cell"]')).forEach(function(r){r.style.transform=""}),this._frozenCells=Array.prototype.slice.call(this.$.table.querySelectorAll("[frozen]")),this._updateScrollerMeasurements(),this._translateStationaryElements()}),this._updateLastFrozen()}_updateScrollerMeasurements(){this._frozenCells.length>0&&this.__isRTL&&(this.__scrollerMetrics={scrollWidth:this.$.table.scrollWidth,clientWidth:this.$.table.clientWidth})}_updateLastFrozen(){if(!this._columnTree)return;let r=this._columnTree[this._columnTree.length-1].slice(0);r.sort((i,o)=>i._order-o._order);let n=r.reduce((i,o,a)=>(o._lastFrozen=!1,o.frozen&&!o.hidden?a:i),void 0);n!==void 0&&(r[n]._lastFrozen=!0)}_translateStationaryElements(){let r=Math.max(0,this._scrollLeft),n=Math.max(0,this._scrollTop),i=0,o=0,a=0;if(this._useSticky||(i=r,o=n,a=this.$.table.clientHeight-this.$.footer.offsetHeight-this.$.footer.offsetTop),this.$.header.style.transform=this._getTranslate(-r+i,o),this.$.footer.style.transform=this._getTranslate(-r+i,o+a),this.$.items.style.transform=this._getTranslate(-r+i,0),this._frozenCells.length>0){let s=this.__isRTL?this.__getNormalizedScrollLeft(this.$.table)+this.__scrollerMetrics.clientWidth-this.__scrollerMetrics.scrollWidth:this._scrollLeft,l=this._getTranslate(s,0);for(let c=0;c<this._frozenCells.length;c++)this._frozenCells[c].style.transform=l}}_getTranslate(r,n){return`translate(${r}px, ${n}px)`}};var oue=e=>class extends e{static get properties(){return{selectedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_selectedItemsChanged(selectedItems.*)"]}_isSelected(r){return this.selectedItems&&this._getItemIndexInArray(r,this.selectedItems)>-1}selectItem(r){this._isSelected(r)||(this.selectedItems=[...this.selectedItems,r])}deselectItem(r){this._isSelected(r)&&(this.selectedItems=this.selectedItems.filter(n=>!this._itemsEqual(n,r)))}_toggleItem(r){this._getItemIndexInArray(r,this.selectedItems)===-1?this.selectItem(r):this.deselectItem(r)}_selectedItemsChanged(r){this.$.items.children.length&&(r.path==="selectedItems"||r.path==="selectedItems.splices")&&Array.from(this.$.items.children).forEach(n=>{this._updateItem(n,n._item)})}_selectedInstanceChangedCallback(r,n){n?this.selectItem(r.item):this.deselectItem(r.item)}};var aue=e=>class extends e{static get properties(){return{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("sorter-changed",this._onSorterChanged)}_onSorterChanged(r){let n=r.target;r.stopPropagation(),this.__updateSorter(n),this.__applySorters()}__removeSorters(r){r.length!=0&&(this._sorters=this._sorters.filter(n=>r.indexOf(n)<0),this.multiSort&&this.__updateSortOrders(),this.__applySorters())}__updateSortOrders(){this._sorters.forEach((r,n)=>r._order=this._sorters.length>1?n:null,this)}__updateSorter(r){if(!(!r.direction&&this._sorters.indexOf(r)===-1)){if(r._order=null,this.multiSort)this._removeArrayItem(this._sorters,r),r.direction&&this._sorters.unshift(r),this.__updateSortOrders();else if(r.direction){let n=this._sorters.filter(i=>i!=r);this._sorters=[r],n.forEach(i=>{i._order=null,i.direction=null})}}}__applySorters(){this.dataProvider&&this.isAttached&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache(),this._a11yUpdateSorters(),this._previousSorters=this._mapSorters()}_mapSorters(){return this._sorters.map(r=>({path:r.path,direction:r.direction}))}_removeArrayItem(r,n){let i=r.indexOf(n);i>-1&&r.splice(i,1)}};var sue=e=>class extends e{static get properties(){return{cellClassNameGenerator:Function}}static get observers(){return["__cellClassNameGeneratorChanged(cellClassNameGenerator)"]}__cellClassNameGeneratorChanged(){this.generateCellClassNames()}generateCellClassNames(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>this._generateCellClassNames(r,this.__getRowModel(r)))}_generateCellClassNames(r,n){Array.from(r.children).forEach(i=>{if(i.__generatedClasses&&i.__generatedClasses.forEach(o=>i.classList.remove(o)),this.cellClassNameGenerator){let o=this.cellClassNameGenerator(i._column,n);i.__generatedClasses=o&&o.split(" ").filter(a=>a.length>0),i.__generatedClasses&&i.__generatedClasses.forEach(a=>i.classList.add(a))}})}};var TP={BETWEEN:"between",ON_TOP:"on-top",ON_TOP_OR_BETWEEN:"on-top-or-between",ON_GRID:"on-grid"},A0={ON_TOP:"on-top",ABOVE:"above",BELOW:"below",EMPTY:"empty"},lue=e=>class extends e{static get properties(){return{dropMode:String,rowsDraggable:Boolean,dragFilter:Function,dropFilter:Function,__dndAutoScrollThreshold:{value:50}}}static get observers(){return["_dragDropAccessChanged(rowsDraggable, dropMode, dragFilter, dropFilter)"]}ready(){super.ready(),this.$.table.addEventListener("dragstart",this._onDragStart.bind(this)),this.$.table.addEventListener("dragend",this._onDragEnd.bind(this)),this.$.table.addEventListener("dragover",this._onDragOver.bind(this)),this.$.table.addEventListener("dragleave",this._onDragLeave.bind(this)),this.$.table.addEventListener("drop",this._onDrop.bind(this)),this.$.table.addEventListener("dragenter",r=>{this.dropMode&&(r.preventDefault(),r.stopPropagation())})}_onDragStart(r){if(this.rowsDraggable){let n=r.target;if(n.localName==="vaadin-grid-cell-content"&&(n=n.assignedSlot.parentNode.parentNode),n.parentNode!==this.$.items)return;if(r.stopPropagation(),this._toggleAttribute("dragging-rows",!0,this),this._safari){let s=n.style.transform;n.style.top=/translateY\((.*)\)/.exec(s)[1],n.style.transform="none",requestAnimationFrame(()=>{n.style.top="",n.style.transform=s})}let i=n.getBoundingClientRect();this._ios?r.dataTransfer.setDragImage(n):r.dataTransfer.setDragImage(n,r.clientX-i.left,r.clientY-i.top);let o=[n];this._isSelected(n._item)&&(o=this.__getViewportRows().filter(s=>this._isSelected(s._item)).filter(s=>!this.dragFilter||this.dragFilter(this.__getRowModel(s)))),r.dataTransfer.setData("text",this.__formatDefaultTransferData(o)),n.setAttribute("dragstart",o.length>1?o.length:""),this.updateStyles({"--_grid-drag-start-x":`${r.clientX-i.left+20}px`,"--_grid-drag-start-y":`${r.clientY-i.top+10}px`}),requestAnimationFrame(()=>{n.removeAttribute("dragstart"),this.updateStyles({"--_grid-drag-start-x":"","--_grid-drag-start-y":""})});let a=new CustomEvent("grid-dragstart",{detail:{draggedItems:o.map(s=>s._item),setDragData:(s,l)=>r.dataTransfer.setData(s,l),setDraggedItemsCount:s=>n.setAttribute("dragstart",s)}});a.originalEvent=r,this.dispatchEvent(a)}}_onDragEnd(r){this._toggleAttribute("dragging-rows",!1,this),r.stopPropagation();let n=new CustomEvent("grid-dragend");n.originalEvent=r,this.dispatchEvent(n)}_onDragLeave(r){r.stopPropagation(),this._clearDragStyles()}_onDragOver(r){if(this.dropMode){if(this._dropLocation=void 0,this._dragOverItem=void 0,this.__dndAutoScroll(r.clientY)){this._clearDragStyles();return}let n=r.composedPath().filter(i=>i.localName==="tr")[0];if(!this._effectiveSize||this.dropMode===TP.ON_GRID)this._dropLocation=A0.EMPTY;else if(!n||n.parentNode!==this.$.items){if(n)return;if(this.dropMode===TP.BETWEEN||this.dropMode===TP.ON_TOP_OR_BETWEEN)n=Array.from(this.$.items.children).filter(i=>!i.hidden).pop(),this._dropLocation=A0.BELOW;else return}else{let i=n.getBoundingClientRect();if(this._dropLocation=A0.ON_TOP,this.dropMode===TP.BETWEEN){let o=r.clientY-i.top<i.bottom-r.clientY;this._dropLocation=o?A0.ABOVE:A0.BELOW}else this.dropMode===TP.ON_TOP_OR_BETWEEN&&(r.clientY-i.top<i.height/3?this._dropLocation=A0.ABOVE:r.clientY-i.top>i.height/3*2&&(this._dropLocation=A0.BELOW))}if(n&&n.hasAttribute("drop-disabled")){this._dropLocation=void 0;return}r.stopPropagation(),r.preventDefault(),this._dropLocation===A0.EMPTY?this._toggleAttribute("dragover",!0,this):n?(this._dragOverItem=n._item,n.getAttribute("dragover")!==this._dropLocation&&n.setAttribute("dragover",this._dropLocation)):this._clearDragStyles()}}__dndAutoScroll(r){if(this.__dndAutoScrolling)return!0;let n=this.$.header.getBoundingClientRect().bottom,i=this.$.footer.getBoundingClientRect().top,o=n-r+this.__dndAutoScrollThreshold,a=r-i+this.__dndAutoScrollThreshold,s=0;if(a>0?s=a*2:o>0&&(s=-o*2),s){let l=this.$.table.scrollTop;if(this.$.table.scrollTop+=s,l!==this.$.table.scrollTop)return this.__dndAutoScrolling=!0,setTimeout(()=>this.__dndAutoScrolling=!1,20),this._scrollHandler(),!0}}__getViewportRows(){let r=this.$.header.getBoundingClientRect().bottom,n=this.$.footer.getBoundingClientRect().top;return Array.from(this.$.items.children).filter(i=>{let o=i.getBoundingClientRect();return o.bottom>r&&o.top<n})}_clearDragStyles(){this.removeAttribute("dragover"),Array.from(this.$.items.children).forEach(r=>r.removeAttribute("dragover"))}_onDrop(r){if(this.dropMode){r.stopPropagation(),r.preventDefault();let n=r.dataTransfer.types&&Array.from(r.dataTransfer.types).map(o=>({type:o,data:r.dataTransfer.getData(o)}));this._clearDragStyles();let i=new CustomEvent("grid-drop",{bubbles:r.bubbles,cancelable:r.cancelable,detail:{dropTargetItem:this._dragOverItem,dropLocation:this._dropLocation,dragData:n}});i.originalEvent=r,this.dispatchEvent(i)}}__formatDefaultTransferData(r){return r.map(n=>Array.from(n.children).filter(i=>!i.hidden&&i.getAttribute("part").indexOf("details-cell")===-1).sort((i,o)=>i._column._order>o._column._order?1:-1).map(i=>i._content.textContent.trim()).filter(i=>i).join("	")).join(`
`)}_dragDropAccessChanged(){this.filterDragAndDrop()}filterDragAndDrop(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>{this._filterDragAndDrop(r,this.__getRowModel(r))})}_filterDragAndDrop(r,n){let i=!this.rowsDraggable||this.dragFilter&&!this.dragFilter(n),o=!this.dropMode||this.dropFilter&&!this.dropFilter(n);Array.from(r.children).map(s=>s._content).forEach(s=>{i?s.removeAttribute("draggable"):s.setAttribute("draggable",!0)}),this._toggleAttribute("drag-disabled",i,r),this._toggleAttribute("drop-disabled",o,r)}};var cue=e=>class extends e{static get properties(){return{_headerFocusable:{type:Object,observer:"_focusableChanged"},_itemsFocusable:{type:Object,observer:"_focusableChanged"},_footerFocusable:{type:Object,observer:"_focusableChanged"},_navigatingIsHidden:Boolean,_focusedItemIndex:{type:Number,value:0},_focusedColumnOrder:Number,interacting:{type:Boolean,value:!1,reflectToAttribute:!0,readOnly:!0,observer:"_interactingChanged"}}}ready(){super.ready(),!(this._ios||this._android)&&(this.addEventListener("keydown",this._onKeyDown),this.addEventListener("keyup",this._onKeyUp),this.addEventListener("focusin",this._onFocusIn),this.addEventListener("focusout",this._onFocusOut),this.$.table.addEventListener("focusin",this._onCellFocusIn.bind(this)),this.$.table.addEventListener("focusout",this._onCellFocusOut.bind(this)),this.addEventListener("mousedown",()=>{this._toggleAttribute("navigating",!1,this),this._isMousedown=!0}),this.addEventListener("mouseup",()=>this._isMousedown=!1))}_focusableChanged(r,n){n&&n.setAttribute("tabindex","-1"),r&&this._updateGridSectionFocusTarget(r)}_interactingChanged(){this._updateGridSectionFocusTarget(this._headerFocusable),this._updateGridSectionFocusTarget(this._itemsFocusable),this._updateGridSectionFocusTarget(this._footerFocusable)}_onKeyDown(r){let n=r.key,i;switch(n){case"ArrowUp":case"ArrowDown":case"ArrowLeft":case"ArrowRight":case"PageUp":case"PageDown":case"Home":case"End":i="Navigation";break;case"Enter":case"Escape":case"F2":i="Interaction";break;case"Tab":i="Tab";break;case" ":i="Space";break}this._detectInteracting(r),this.interacting&&i!=="Interaction"&&(i=void 0),i&&this[`_on${i}KeyDown`](r,n)}_ensureScrolledToIndex(r){Array.from(this.$.items.children).filter(i=>i.index===r)[0]||this._scrollToIndex(r)}_onNavigationKeyDown(r,n){this._scrollHandler(),r.preventDefault();function i(B){return Array.prototype.indexOf.call(B.parentNode.children,B)}let o=this._lastVisibleIndex-this._firstVisibleIndex-1,a=0,s=0;switch(n){case"ArrowRight":a=this.__isRTL?-1:1;break;case"ArrowLeft":a=this.__isRTL?1:-1;break;case"Home":a=-1/0,r.ctrlKey&&(s=-1/0);break;case"End":a=1/0,r.ctrlKey&&(s=1/0);break;case"ArrowDown":s=1;break;case"ArrowUp":s=-1;break;case"PageDown":s=o;break;case"PageUp":s=-o;break}let l=r.composedPath()[0],c=i(l),u=this._elementMatches(l,'[part~="details-cell"]'),h=l.parentNode,f=h.parentNode,p=(f===this.$.items?this._effectiveSize:f.children.length)-1,d=f===this.$.items?this._focusedItemIndex!==void 0?this._focusedItemIndex:h.index:i(h),g=Math.max(0,Math.min(d+s,p)),_=!1;if(f===this.$.items){let B=h._item,I=this._cache.getItemForIndex(g);u?_=s===0:_=s===1&&this._isDetailsOpened(B)||s===-1&&g!==d&&this._isDetailsOpened(I),_!==u&&(s===1&&_||s===-1&&!_)&&(g=d)}if(f!==this.$.items){if(g>d)for(;g<p&&f.children[g].hidden;)g++;else if(g<d)for(;g>0&&f.children[g].hidden;)g--}this._focusedColumnOrder===void 0&&(u?this._focusedColumnOrder=0:this._focusedColumnOrder=this._getColumns(f,d).filter(B=>!B.hidden)[c]._order);let y=this._getColumns(f,g).filter(B=>!B.hidden),x=y.map(B=>B._order).sort((B,I)=>B-I),b=x.length-1,S=x.indexOf(x.slice(0).sort((B,I)=>Math.abs(B-this._focusedColumnOrder)-Math.abs(I-this._focusedColumnOrder))[0]),C=s===0&&u?S:Math.max(0,Math.min(S+a,b));C!==S&&(this._focusedColumnOrder=void 0),f===this.$.items&&this._ensureScrolledToIndex(g),this._toggleAttribute("navigating",!0,this);let k=y.reduce((B,I,L)=>(B[I._order]=L,B),{})[x[C]],O=f===this.$.items?Array.from(f.children).filter(B=>B.index===g)[0]:f.children[g];if(!O)return;let D=_?Array.from(O.children).filter(B=>this._elementMatches(B,'[part~="details-cell"]'))[0]:O.children[k];if(this._scrollHorizontallyToCell(D),f===this.$.items&&(this._focusedItemIndex=g),f===this.$.items){let B=D.getBoundingClientRect(),I=this.$.footer.getBoundingClientRect().top,L=this.$.header.getBoundingClientRect().bottom;B.bottom>I?(this.$.table.scrollTop+=B.bottom-I,this._scrollHandler()):B.top<L&&(this.$.table.scrollTop-=L-B.top,this._scrollHandler())}D.focus()}_onInteractionKeyDown(r,n){let i=r.composedPath()[0],o=i.localName==="input"&&!/^(button|checkbox|color|file|image|radio|range|reset|submit)$/i.test(i.type),a;switch(n){case"Enter":a=this.interacting?!o:!0;break;case"Escape":a=!1;break;case"F2":a=!this.interacting;break}let{cell:s}=this._getGridEventLocation(r);if(this.interacting!==a&&s!==null)if(a){let l=s._content.querySelector("[focus-target]")||s._content.firstElementChild;l&&(r.preventDefault(),l.focus(),this._setInteracting(!0),this._toggleAttribute("navigating",!1,this))}else r.preventDefault(),this._focusedColumnOrder=void 0,s.focus(),this._setInteracting(!1),this._toggleAttribute("navigating",!0,this)}_predictFocusStepTarget(r,n){let i=[this.$.table,this._headerFocusable,this._itemsFocusable,this._footerFocusable,this.$.focusexit],o=i.indexOf(r);for(o+=n;o>=0&&o<=i.length-1&&(!i[o]||i[o].parentNode.hidden);)o+=n;return i[o]}_onTabKeyDown(r){let n=this._predictFocusStepTarget(r.composedPath()[0],r.shiftKey?-1:1);if(n===this.$.table)this.$.table.focus();else if(n===this.$.focusexit)this.$.focusexit.focus();else if(n===this._itemsFocusable){let i=n,o=this._itemsFocusable.parentNode;if(this._ensureScrolledToIndex(this._focusedItemIndex),o.index!==this._focusedItemIndex){let a=Array.from(o.children).indexOf(this._itemsFocusable),s=Array.from(this.$.items.children).filter(l=>l.index===this._focusedItemIndex)[0];s&&(i=s.children[a])}r.preventDefault(),i.focus()}else r.preventDefault(),n.focus();this._toggleAttribute("navigating",!0,this)}_onSpaceKeyDown(r){r.preventDefault();let n=r.composedPath()[0];(!n._content||!n._content.firstElementChild)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(n.parentElement)}}))}_onKeyUp(r){if(!/^( |SpaceBar)$/.test(r.key))return;r.preventDefault();let n=r.composedPath()[0];if(n._content&&n._content.firstElementChild){let i=this.hasAttribute("navigating");n._content.firstElementChild.click(),this._toggleAttribute("navigating",i,this)}}_onFocusIn(r){this._isMousedown||this._toggleAttribute("navigating",!0,this);let n=r.composedPath()[0];n===this.$.table||n===this.$.focusexit?(this._predictFocusStepTarget(n,n===this.$.table?1:-1).focus(),this._setInteracting(!1)):this._detectInteracting(r)}_onFocusOut(r){this._toggleAttribute("navigating",!1,this),this._detectInteracting(r)}_onCellFocusIn(r){let{section:n,cell:i}=this._getGridEventLocation(r);this._detectInteracting(r),n&&i&&(this._activeRowGroup=n,this.$.header===n?this._headerFocusable=i:this.$.items===n?this._itemsFocusable=i:this.$.footer===n&&(this._footerFocusable=i),i._content.dispatchEvent(new CustomEvent("cell-focusin",{bubbles:!1})),i.dispatchEvent(new CustomEvent("cell-focus",{bubbles:!0,composed:!0}))),this._detectFocusedItemIndex(r)}_onCellFocusOut(r){r.composedPath().indexOf(this.$.table)===3&&r.composedPath()[0]._content.dispatchEvent(new CustomEvent("cell-focusout",{bubbles:!1}))}_detectInteracting(r){let n=r.composedPath().some(i=>i.localName==="vaadin-grid-cell-content");this._setInteracting(n)}_detectFocusedItemIndex(r){let{section:n,row:i}=this._getGridEventLocation(r);n===this.$.items&&(this._focusedItemIndex=i.index)}_updateGridSectionFocusTarget(r){if(!r)return;let n=this._getGridSectionFromFocusTarget(r),i=this.interacting&&n===this._activeRowGroup;r.tabIndex=i?-1:0}_preventScrollerRotatingCellFocus(r,n){r.index===this._focusedItemIndex&&this.hasAttribute("navigating")&&this._activeRowGroup===this.$.items&&(this._navigatingIsHidden=!0,this._toggleAttribute("navigating",!1,this)),n===this._focusedItemIndex&&this._navigatingIsHidden&&(this._navigatingIsHidden=!1,this._toggleAttribute("navigating",!0,this))}_getColumns(r,n){let i=this._columnTree.length-1;return r===this.$.header?i=n:r===this.$.footer&&(i=this._columnTree.length-1-n),this._columnTree[i]}_resetKeyboardNavigation(){if(this.$.header.firstElementChild&&(this._headerFocusable=Array.from(this.$.header.firstElementChild.children).filter(r=>!r.hidden)[0]),this.$.items.firstElementChild){let r=this._iterateItems((n,i)=>{if(this._firstVisibleIndex===i)return this.$.items.children[n]});r&&(this._itemsFocusable=Array.from(r.children).filter(n=>!n.hidden)[0])}this.$.footer.firstElementChild&&(this._footerFocusable=Array.from(this.$.footer.firstElementChild.children).filter(r=>!r.hidden)[0])}_scrollHorizontallyToCell(r){if(r.hasAttribute("frozen")||this._elementMatches(r,'[part~="details-cell"]'))return;let n=r.getBoundingClientRect(),i=r.parentNode,o=Array.from(i.children).indexOf(r),a=this.$.table.getBoundingClientRect(),s=a.left,l=a.right;for(let c=o-1;c>=0;c--){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){s=u.getBoundingClientRect().right;break}}for(let c=o+1;c<i.children.length;c++){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){l=u.getBoundingClientRect().left;break}}n.left<s&&(this.$.table.scrollLeft+=Math.round(n.left-s)),n.right>l&&(this.$.table.scrollLeft+=Math.round(n.right-l))}_elementMatches(r,n){return r.matches?r.matches(n):Array.from(r.parentNode.querySelectorAll(n)).indexOf(r)!==-1}_getGridEventLocation(r){let n=r.composedPath(),i=n.indexOf(this.$.table),o=i>=1?n[i-1]:null,a=i>=2?n[i-2]:null,s=i>=3?n[i-3]:null;return{section:o,row:a,cell:s}}_getGridSectionFromFocusTarget(r){return r===this._headerFocusable?this.$.header:r===this._itemsFocusable?this.$.items:r===this._footerFocusable?this.$.footer:null}};function uue(e,t,r){let n=1;e.forEach(i=>{n%10===0&&n++,i._order=r+n*t,n++})}var hue=e=>class extends vh(e){static get properties(){return{columnReorderingAllowed:{type:Boolean,value:!1},_orderBaseScope:{type:Number,value:1e7}}}static get observers(){return["_updateOrders(_columnTree, _columnTree.*)"]}ready(){super.ready(),Tm(this,"track",this._onTrackEvent),this._reorderGhost=this.shadowRoot.querySelector('[part="reorder-ghost"]'),this.addEventListener("touchstart",this._onTouchStart.bind(this)),this.addEventListener("touchmove",this._onTouchMove.bind(this)),this.addEventListener("touchend",this._onTouchEnd.bind(this)),this.addEventListener("contextmenu",this._onContextMenu.bind(this))}_onContextMenu(r){this.hasAttribute("reordering")&&r.preventDefault()}_onTouchStart(r){this._startTouchReorderTimeout=setTimeout(()=>{this._onTrackStart({detail:{x:r.touches[0].clientX,y:r.touches[0].clientY}})},100)}_onTouchMove(r){this._draggedColumn&&r.preventDefault(),clearTimeout(this._startTouchReorderTimeout)}_onTouchEnd(){clearTimeout(this._startTouchReorderTimeout),this._onTrackEnd()}_onTrackEvent(r){if(r.detail.state==="start"){let n=r.composedPath(),i=n[n.indexOf(this.$.header)-2];if(!i||!i._content||i._content.contains(this.getRootNode().activeElement)||this.$.scroller.hasAttribute("column-resizing"))return;this._touchDevice||this._onTrackStart(r)}else r.detail.state==="track"?this._onTrack(r):r.detail.state==="end"&&this._onTrackEnd(r)}_onTrackStart(r){if(!this.columnReorderingAllowed)return;let n=r.composedPath&&r.composedPath();if(n&&n.filter(o=>o.hasAttribute&&o.hasAttribute("draggable"))[0])return;let i=this._cellFromPoint(r.detail.x,r.detail.y);if(!(!i||i.getAttribute("part").indexOf("header-cell")===-1)){for(this._toggleAttribute("reordering",!0,this),this._draggedColumn=i._column;this._draggedColumn.parentElement.childElementCount===1;)this._draggedColumn=this._draggedColumn.parentElement;this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",this._updateGhost(i),this._reorderGhost.style.visibility="visible",this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._autoScroller()}}_onTrack(r){if(!this._draggedColumn)return;let n=this._cellFromPoint(r.detail.x,r.detail.y);if(!n)return;let i=this._getTargetColumn(n,this._draggedColumn);this._isSwapAllowed(this._draggedColumn,i)&&this._isSwappableByPosition(i,r.detail.x)&&this._swapColumnOrders(this._draggedColumn,i),this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._lastDragClientX=r.detail.x}_onTrackEnd(){!this._draggedColumn||(this._toggleAttribute("reordering",!1,this),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._draggedColumn=null,this._lastDragClientX=null,this._reorderGhost.style.visibility="hidden",this.dispatchEvent(new CustomEvent("column-reorder",{detail:{columns:this._getColumnsInOrder()}})))}_getColumnsInOrder(){return this._columnTree.slice(0).pop().filter(r=>!r.hidden).sort((r,n)=>r._order-n._order)}_cellFromPoint(r,n){r=r||0,n=n||0,this._draggedColumn||this._toggleAttribute("no-content-pointer-events",!0,this.$.scroller);let i=this.shadowRoot.elementFromPoint(r,n);if(this._toggleAttribute("no-content-pointer-events",!1,this.$.scroller),i&&i._column)return i}_updateGhostPosition(r,n){let i=this._reorderGhost.getBoundingClientRect(),o=r-i.width/2,a=n-i.height/2,s=parseInt(this._reorderGhost._left||0),l=parseInt(this._reorderGhost._top||0);this._reorderGhost._left=s-(i.left-o),this._reorderGhost._top=l-(i.top-a),this._reorderGhost.style.transform=`translate(${this._reorderGhost._left}px, ${this._reorderGhost._top}px)`}_updateGhost(r){let n=this._reorderGhost;n.textContent=r._content.innerText;let i=window.getComputedStyle(r);return["boxSizing","display","width","height","background","alignItems","padding","border","flex-direction","overflow"].forEach(o=>n.style[o]=i[o]),n}_updateOrders(r,n){r===void 0||n===void 0||(r[0].forEach(i=>i._order=0),uue(r[0],this._orderBaseScope,0))}_setSiblingsReorderStatus(r,n){Array.from(r.parentNode.children).filter(i=>/column/.test(i.localName)&&this._isSwapAllowed(i,r)).forEach(i=>i._reorderStatus=n)}_autoScroller(){if(this._lastDragClientX){let r=this._lastDragClientX-this.getBoundingClientRect().right+50,n=this.getBoundingClientRect().left-this._lastDragClientX+50;r>0?this.$.table.scrollLeft+=r/10:n>0&&(this.$.table.scrollLeft-=n/10),this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)}_isSwapAllowed(r,n){if(r&&n){let i=r!==n,o=r.parentElement===n.parentElement,a=r.frozen===n.frozen;return i&&o&&a}}_isSwappableByPosition(r,n){let i=Array.from(this.$.header.querySelectorAll('tr:not([hidden]) [part~="cell"]')).filter(s=>r.contains(s._column))[0],o=this.$.header.querySelector("tr:not([hidden]) [reorder-status=dragging]").getBoundingClientRect(),a=i.getBoundingClientRect();return a.left>o.left?n>a.right-o.width:n<a.left+o.width}_swapColumnOrders(r,n){let i=r._order;r._order=n._order,n._order=i,this._updateLastFrozen(),this._updateFirstAndLastColumn()}_getTargetColumn(r,n){if(r&&n){let i=r._column;for(;i.parentElement!==n.parentElement&&i!==this;)i=i.parentElement;return i.parentElement===n.parentElement?i:r._column}}};var chr=e=>class extends e{static get properties(){return{resizable:{type:Boolean,value:function(){if(this.localName==="vaadin-grid-column-group")return;let r=this.parentNode;return r&&r.localName==="vaadin-grid-column-group"&&r.resizable||!1}},_headerTemplate:{type:Object},_footerTemplate:{type:Object},frozen:{type:Boolean,value:!1},hidden:{type:Boolean},header:{type:String},textAlign:{type:String},_lastFrozen:{type:Boolean,value:!1},_order:Number,_reorderStatus:Boolean,_emptyCells:Array,_headerCell:Object,_footerCell:Object,_grid:Object,headerRenderer:Function,footerRenderer:Function}}static get observers(){return["_widthChanged(width, _headerCell, _footerCell, _cells.*)","_frozenChanged(frozen, _headerCell, _footerCell, _cells.*)","_flexGrowChanged(flexGrow, _headerCell, _footerCell, _cells.*)","_pathOrHeaderChanged(path, header, _headerCell, _footerCell, _cells.*, renderer, headerRenderer, _bodyTemplate, _headerTemplate)","_textAlignChanged(textAlign, _cells.*, _headerCell, _footerCell)","_orderChanged(_order, _headerCell, _footerCell, _cells.*)","_lastFrozenChanged(_lastFrozen)","_setBodyTemplateOrRenderer(_bodyTemplate, renderer, _cells, _cells.*)","_setHeaderTemplateOrRenderer(_headerTemplate, headerRenderer, _headerCell)","_setFooterTemplateOrRenderer(_footerTemplate, footerRenderer, _footerCell)","_resizableChanged(resizable, _headerCell)","_reorderStatusChanged(_reorderStatus, _headerCell, _footerCell, _cells.*)","_hiddenChanged(hidden, _headerCell, _footerCell, _cells.*)"]}connectedCallback(){super.connectedCallback(),this._bodyTemplate&&(this._bodyTemplate.templatizer._grid=this._grid),this._headerTemplate&&(this._headerTemplate.templatizer._grid=this._grid),this._footerTemplate&&(this._footerTemplate.templatizer._grid=this._grid),this._templateObserver.flush(),this._bodyTemplate||this._templateObserver.callback(),requestAnimationFrame(()=>{this._allCells.forEach(r=>{r._content.parentNode||this._grid&&this._grid.appendChild(r._content)})})}disconnectedCallback(){super.disconnectedCallback(),requestAnimationFrame(()=>{this._findHostGrid()||this._allCells.forEach(r=>{r._content.parentNode&&r._content.parentNode.removeChild(r._content)})}),this._gridValue=void 0}_findHostGrid(){let r=this;for(;r&&!/^vaadin.*grid(-pro)?$/.test(r.localName);)r=r.assignedSlot?r.assignedSlot.parentNode:r.parentNode;return r||void 0}get _grid(){return this._gridValue||(this._gridValue=this._findHostGrid()),this._gridValue}get _allCells(){return[].concat(this._cells||[]).concat(this._emptyCells||[]).concat(this._headerCell).concat(this._footerCell).filter(r=>r)}constructor(){super(),this._templateObserver=new xh(this,()=>{this._headerTemplate=this._prepareHeaderTemplate(),this._footerTemplate=this._prepareFooterTemplate(),this._bodyTemplate=this._prepareBodyTemplate()})}_prepareHeaderTemplate(){return this._prepareTemplatizer(this._findTemplate(!0)||null,{})}_prepareFooterTemplate(){return this._prepareTemplatizer(this._findTemplate(!1,!0)||null,{})}_prepareBodyTemplate(){return this._prepareTemplatizer(this._findTemplate()||null)}_prepareTemplatizer(r,n){if(r&&!r.templatizer){let i=new C0;i._grid=this._grid,i.dataHost=this.dataHost,i._instanceProps=n||i._instanceProps,i.template=r,r.templatizer=i}return r}_renderHeaderAndFooter(){this.headerRenderer&&this._headerCell&&this.__runRenderer(this.headerRenderer,this._headerCell),this.footerRenderer&&this._footerCell&&this.__runRenderer(this.footerRenderer,this._footerCell)}__runRenderer(r,n,i){let o=[n._content,this];i&&i.item&&o.push(i),r.apply(this,o)}__setColumnTemplateOrRenderer(r,n,i){if(!this.hidden){if(r&&n)throw new Error("You should only use either a renderer or a template");i.forEach(o=>{let a=this._grid.__getRowModel(o.parentElement);if(n)o._renderer=n,(a.item||n===this.headerRenderer||n===this.footerRenderer)&&this.__runRenderer(n,o,a);else if(o._template!==r){o._template=r,o._content.innerHTML="",r.templatizer._grid=r.templatizer._grid||this._grid;let s=r.templatizer.createInstance();o._content.appendChild(s.root),o._instance=s,a.item&&o._instance.setProperties(a)}})}}_setBodyTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,i)}_setHeaderTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,[i])}_setFooterTemplateOrRenderer(r,n,i){(r||n)&&i&&(this.__setColumnTemplateOrRenderer(r,n,[i]),this._grid.__updateHeaderFooterRowVisibility(i.parentElement))}_selectFirstTemplate(r=!1,n=!1){return xh.getFlattenedNodes(this).filter(i=>i.localName==="template"&&i.classList.contains("header")===r&&i.classList.contains("footer")===n)[0]}_findTemplate(r,n){let i=this._selectFirstTemplate(r,n);return i&&this.dataHost&&(i._rootDataHost=this.dataHost._rootDataHost||this.dataHost),i}_flexGrowChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("flexGrow"),this._allCells.forEach(n=>n.style.flexGrow=r)}_orderChanged(r){this._allCells.forEach(n=>n.style.order=r)}_widthChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("width"),this._allCells.forEach(n=>n.style.width=r),this._grid&&this._grid.__forceReflow&&this._grid.__forceReflow()}_frozenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("frozen",r),this._allCells.forEach(n=>this._toggleAttribute("frozen",r,n)),this._grid&&this._grid._frozenCellsChanged&&this._grid._frozenCellsChanged()}_lastFrozenChanged(r){this._allCells.forEach(n=>this._toggleAttribute("last-frozen",r,n)),this.parentElement&&this.parentElement._columnPropChanged&&(this.parentElement._lastFrozen=r)}_pathOrHeaderChanged(r,n,i,o,a,s,l,c,u){let h=n!==void 0;if(!l&&!u&&h&&i&&this.__setTextContent(i._content,n),r&&a.value){if(!s&&!c){let f=(p,d,{item:g})=>this.__setTextContent(p,this.get(r,g));this.__setColumnTemplateOrRenderer(void 0,f,a.value)}!l&&!u&&!h&&i&&n!==null&&this.__setTextContent(i._content,this._generateHeader(r))}i&&this._grid.__updateHeaderFooterRowVisibility(i.parentElement)}__setTextContent(r,n){r.textContent!==n&&(r.textContent=n)}_generateHeader(r){return r.substr(r.lastIndexOf(".")+1).replace(/([A-Z])/g,"-$1").toLowerCase().replace(/-/g," ").replace(/^./,n=>n.toUpperCase())}_toggleAttribute(r,n,i){i.hasAttribute(r)===!n&&(n?i.setAttribute(r,""):i.removeAttribute(r))}_reorderStatusChanged(r){this._allCells.forEach(n=>n.setAttribute("reorder-status",r))}_resizableChanged(r,n){r===void 0||n===void 0||n&&[n].concat(this._emptyCells).forEach(i=>{if(i){let o=i.querySelector('[part~="resize-handle"]');if(o&&i.removeChild(o),r){let a=document.createElement("div");a.setAttribute("part","resize-handle"),i.appendChild(a)}}})}_textAlignChanged(r){if(r===void 0)return;if(["start","end","center"].indexOf(r)===-1){console.warn('textAlign can only be set as "start", "end" or "center"');return}let n;getComputedStyle(this._grid).direction==="ltr"?r==="start"?n="left":r==="end"&&(n="right"):r==="start"?n="right":r==="end"&&(n="left"),this._allCells.forEach(i=>{i._content.style.textAlign=r,getComputedStyle(i._content).textAlign!==r&&(i._content.style.textAlign=n)})}_hiddenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("hidden",r),!!r!=!!this._previousHidden&&this._grid&&(r===!0&&this._allCells.forEach(n=>{n._content.parentNode&&n._content.parentNode.removeChild(n._content)}),this._grid._debouncerHiddenChanged=sr.debounce(this._grid._debouncerHiddenChanged,Ni,()=>{this._grid&&this._grid._renderColumnTree&&this._grid._renderColumnTree(this._grid._columnTree)}),this._grid._updateLastFrozen&&this._grid._updateLastFrozen(),this._grid.notifyResize&&this._grid.notifyResize(),this._grid._resetKeyboardNavigation&&this._grid._resetKeyboardNavigation()),this._previousHidden=r}},eV=class extends chr(ZH(mt)){static get is(){return"vaadin-grid-column"}static get properties(){return{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},renderer:Function,path:{type:String},autoWidth:{type:Boolean,value:!1},_bodyTemplate:{type:Object},_cells:Array}}};customElements.define(eV.is,eV);jc("vaadin-grid",Ci`
    @keyframes vaadin-grid-appear {
      to {
        opacity: 1;
      }
    }

    :host {
      display: block;
      animation: 1ms vaadin-grid-appear;
      height: 400px;
      flex: 1 1 auto;
      align-self: stretch;
      position: relative;
    }

    :host([hidden]) {
      display: none !important;
    }

    #scroller {
      display: block;
      transform: translateY(0);
      width: auto;
      height: auto;
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }

    :host([height-by-rows]) {
      height: auto;
      align-self: flex-start;
      flex-grow: 0;
      width: 100%;
    }

    :host([height-by-rows]) #scroller {
      width: 100%;
      height: 100%;
      position: relative;
    }

    #table {
      display: flex;
      flex-direction: column;
      width: 100%;
      height: 100%;
      overflow: auto;
      position: relative;
      outline: none;
      /* Workaround for a Desktop Safari bug: new stacking context here prevents the scrollbar from getting hidden */
      z-index: 0;
    }

    #header,
    #footer {
      display: block;
      position: -webkit-sticky;
      position: sticky;
      left: 0;
      overflow: visible;
      width: 100%;
      z-index: 1;
    }

    #header {
      top: 0;
    }

    th {
      text-align: inherit;
    }

    /* Safari doesn't work with "inherit" */
    [safari] th {
      text-align: initial;
    }

    #footer {
      bottom: 0;
    }

    #items {
      flex-grow: 1;
      flex-shrink: 0;
      display: block;
      position: -webkit-sticky;
      position: sticky;
      width: 100%;
      left: 0;
      overflow: visible;
    }

    [part~='row'] {
      display: flex;
      width: 100%;
      box-sizing: border-box;
      margin: 0;
    }

    [part~='row'][loading] [part~='body-cell'] ::slotted(vaadin-grid-cell-content) {
      opacity: 0;
    }

    #items [part~='row'] {
      position: absolute;
    }

    #items [part~='row']:empty {
      height: 1em;
    }

    [part~='cell']:not([part~='details-cell']) {
      flex-shrink: 0;
      flex-grow: 1;
      box-sizing: border-box;
      display: flex;
      width: 100%;
      position: relative;
      align-items: center;
      padding: 0;
      white-space: nowrap;
    }

    [part~='details-cell'] {
      position: absolute;
      bottom: 0;
      width: 100%;
      box-sizing: border-box;
      padding: 0;
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: block;
      width: 100%;
      box-sizing: border-box;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    [hidden] {
      display: none !important;
    }

    [frozen] {
      z-index: 2;
      will-change: transform;
    }

    [no-scrollbars][safari] #table,
    [no-scrollbars][firefox] #table {
      overflow: hidden;
    }

    /* Reordering styles */
    :host([reordering]) [part~='cell'] ::slotted(vaadin-grid-cell-content),
    :host([reordering]) [part~='resize-handle'],
    #scroller[no-content-pointer-events] [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      pointer-events: none;
    }

    [part~='reorder-ghost'] {
      visibility: hidden;
      position: fixed;
      pointer-events: none;
      opacity: 0.5;

      /* Prevent overflowing the grid in Firefox */
      top: 0;
      left: 0;
    }

    :host([reordering]) {
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Resizing styles */
    [part~='resize-handle'] {
      position: absolute;
      top: 0;
      right: 0;
      height: 100%;
      cursor: col-resize;
      z-index: 1;
    }

    [part~='resize-handle']::before {
      position: absolute;
      content: '';
      height: 100%;
      width: 35px;
      transform: translateX(-50%);
    }

    [last-column] [part~='resize-handle']::before,
    [last-frozen] [part~='resize-handle']::before {
      width: 18px;
      transform: none;
      right: 0;
    }

    #scroller[column-resizing] {
      -ms-user-select: none;
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Sizer styles */
    #sizer {
      display: flex;
      position: absolute;
      visibility: hidden;
    }

    #sizer [part~='details-cell'] {
      display: none !important;
    }

    #sizer [part~='cell'][hidden] {
      display: none !important;
    }

    #sizer [part~='cell'] {
      display: block;
      flex-shrink: 0;
      line-height: 0;
      height: 0 !important;
      min-height: 0 !important;
      max-height: 0 !important;
      padding: 0 !important;
      border: none !important;
    }

    #sizer [part~='cell']::before {
      content: '-';
    }

    #sizer [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: none !important;
    }

    /* RTL specific styles */

    :host([dir='rtl']) #items,
    :host([dir='rtl']) #header,
    :host([dir='rtl']) #footer {
      left: auto;
    }

    :host([dir='rtl']) [part~='reorder-ghost'] {
      left: auto;
      right: 0;
    }

    :host([dir='rtl']) [part~='resize-handle'] {
      left: 0;
      right: auto;
    }

    :host([dir='rtl']) [part~='resize-handle']::before {
      transform: translateX(50%);
    }

    :host([dir='rtl']) [last-column] [part~='resize-handle']::before,
    :host([dir='rtl']) [last-frozen] [part~='resize-handle']::before {
      left: 0;
      right: auto;
    }
  `,{moduleId:"vaadin-grid-styles"});var uhr=(()=>{try{return document.createEvent("TouchEvent"),!0}catch(e){return!1}})(),rV=class extends JH(XH(Qce($ce(tue(Xce(iue(oue(aue(nue(cue(jce(rue(hue(Kce(eue(lue(sue(tV)))))))))))))))))){static get template(){return Q`
      <div
        id="scroller"
        safari$="[[_safari]]"
        ios$="[[_ios]]"
        loading$="[[loading]]"
        column-reordering-allowed$="[[columnReorderingAllowed]]"
      >
        <table id="table" role="grid" aria-multiselectable="true" tabindex="0">
          <caption id="sizer" part="row"></caption>
          <thead id="header" role="rowgroup"></thead>
          <tbody id="items" role="rowgroup"></tbody>
          <tfoot id="footer" role="rowgroup"></tfoot>
        </table>

        <div part="reorder-ghost"></div>
      </div>

      <div id="focusexit" tabindex="0"></div>
    `}static get is(){return"vaadin-grid"}static get version(){return"20.0.2"}static get observers(){return["_columnTreeChanged(_columnTree, _columnTree.*)"]}static get properties(){return{_safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},_ios:{type:Boolean,value:/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||navigator.platform==="MacIntel"&&navigator.maxTouchPoints>1},_firefox:{type:Boolean,value:navigator.userAgent.toLowerCase().indexOf("firefox")>-1},_android:{type:Boolean,value:/android/i.test(navigator.userAgent)},_touchDevice:{type:Boolean,value:uhr},heightByRows:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_heightByRowsChanged"},_recalculateColumnWidthOnceLoadingFinished:{type:Boolean,value:!0}}}constructor(){super(),this.addEventListener("animationend",this._onAnimationEnd)}connectedCallback(){super.connectedCallback(),this.recalculateColumnWidths()}attributeChangedCallback(t,r,n){super.attributeChangedCallback(t,r,n),t==="dir"&&(this.__isRTL=n==="rtl",this._updateScrollerMeasurements())}__hasRowsWithClientHeight(){return!!Array.from(this.$.items.children).filter(t=>t.clientHeight).length}__itemsReceived(){this._recalculateColumnWidthOnceLoadingFinished&&!this._cache.isLoading()&&this.__hasRowsWithClientHeight()&&(this._recalculateColumnWidthOnceLoadingFinished=!1,this.recalculateColumnWidths())}_recalculateColumnWidths(t){t.forEach(r=>{r.width="auto",r._origFlexGrow=r.flexGrow,r.flexGrow=0}),t.forEach(r=>{r._currentWidth=0,r._allCells.forEach(n=>{let i=n.offsetWidth+1;r._currentWidth=Math.max(r._currentWidth,i)})}),t.forEach(r=>{r.width=`${r._currentWidth}px`,r.flexGrow=r._origFlexGrow,r._currentWidth=void 0,r._origFlexGrow=void 0})}recalculateColumnWidths(){if(!!this._columnTree)if(this._cache.isLoading())this._recalculateColumnWidthOnceLoadingFinished=!0;else{let t=this._getColumns().filter(r=>!r.hidden&&r.autoWidth);this._recalculateColumnWidths(t)}}_createScrollerRows(t){let r=[];for(let n=0;n<t;n++){let i=document.createElement("tr");i.setAttribute("part","row"),i.setAttribute("role","row"),this._columnTree&&this._updateRow(i,this._columnTree[this._columnTree.length-1],"body",!1,!0),r.push(i)}return this._columnTree&&this._columnTree[this._columnTree.length-1].forEach(n=>n.isConnected&&n.notifyPath&&n.notifyPath("_cells.*",n._cells)),vgt(this,()=>{this._updateFirstAndLastColumn(),this._resetKeyboardNavigation()}),r}_getRowTarget(){return this.$.items}_createCell(t){let r=this._contentIndex=this._contentIndex+1||0,n="vaadin-grid-cell-content-"+r,i=document.createElement("vaadin-grid-cell-content");i.setAttribute("slot",n);let o=document.createElement(t);o.id=n.replace("-content-","-"),o.setAttribute("tabindex","-1"),o.setAttribute("role",t==="td"?"gridcell":"columnheader");let a=document.createElement("slot");return a.setAttribute("name",n),o.appendChild(a),o._content=i,i.addEventListener("mousedown",()=>{if(window.chrome){let s=()=>{i.contains(this.getRootNode().activeElement)||o.focus(),document.removeEventListener("mouseup",s,!0)};document.addEventListener("mouseup",s,!0)}else setTimeout(()=>{i.contains(this.getRootNode().activeElement)||o.focus()})}),o}_updateRow(t,r,n,i,o){n=n||"body";let a=document.createDocumentFragment();Array.from(t.children).forEach(s=>s._vacant=!0),t.innerHTML="",t.id!=="sizer"&&(t.hidden=!0),r.filter(s=>!s.hidden).forEach((s,l,c)=>{let u;if(n==="body"){if(s._cells=s._cells||[],u=s._cells.filter(h=>h._vacant)[0],u||(u=this._createCell("td"),s._cells.push(u)),u.setAttribute("part","cell body-cell"),t.appendChild(u),l===c.length-1&&(this._rowDetailsTemplate||this.rowDetailsRenderer)){this._detailsCells=this._detailsCells||[];let h=this._detailsCells.filter(f=>f._vacant)[0]||this._createCell("td");this._detailsCells.indexOf(h)===-1&&this._detailsCells.push(h),h._content.parentElement||a.appendChild(h._content),this._configureDetailsCell(h),t.appendChild(h),this._a11ySetRowDetailsCell(t,h),h._vacant=!1}s.notifyPath&&!o&&s.notifyPath("_cells.*",s._cells)}else{let h=n==="header"?"th":"td";i||s.localName==="vaadin-grid-column-group"?(u=s[`_${n}Cell`]||this._createCell(h),u._column=s,t.appendChild(u),s[`_${n}Cell`]=u):(s._emptyCells=s._emptyCells||[],u=s._emptyCells.filter(f=>f._vacant)[0]||this._createCell(h),u._column=s,t.appendChild(u),s._emptyCells.indexOf(u)===-1&&s._emptyCells.push(u)),u.setAttribute("part",`cell ${n}-cell`),this.__updateHeaderFooterRowVisibility(t)}u._content.parentElement||a.appendChild(u._content),u._vacant=!1,u._column=s}),this.appendChild(a),this._frozenCellsChanged(),this._updateFirstAndLastColumnForRow(t)}__updateHeaderFooterRowVisibility(t){if(!t)return;let r=Array.from(t.children).filter(n=>{let i=n._column;if(i._emptyCells&&i._emptyCells.indexOf(n)>-1)return!1;if(t.parentElement===this.$.header){if(i.headerRenderer||i._headerTemplate)return!0;if(i.header===null)return!1;if(i.path||i.header!==void 0)return!0}else if(i.footerRenderer||i._footerTemplate)return!0});t.hidden!==!r.length&&(t.hidden=!r.length,this.notifyResize())}_updateScrollerItem(t,r){this._preventScrollerRotatingCellFocus(t,r),this._columnTree&&(this._toggleAttribute("first",r===0,t),this._toggleAttribute("odd",r%2,t),this._a11yUpdateRowRowindex(t,r),this._getItem(r,t))}_columnTreeChanged(t){this._renderColumnTree(t),this.recalculateColumnWidths()}_renderColumnTree(t){for(Array.from(this.$.items.children).forEach(r=>this._updateRow(r,t[t.length-1],null,!1,!0));this.$.header.children.length<t.length;){let r=document.createElement("tr");r.setAttribute("part","row"),r.setAttribute("role","row"),this.$.header.appendChild(r);let n=document.createElement("tr");n.setAttribute("part","row"),n.setAttribute("role","row"),this.$.footer.appendChild(n)}for(;this.$.header.children.length>t.length;)this.$.header.removeChild(this.$.header.firstElementChild),this.$.footer.removeChild(this.$.footer.firstElementChild);Array.from(this.$.header.children).forEach((r,n)=>this._updateRow(r,t[n],"header",n===t.length-1)),Array.from(this.$.footer.children).forEach((r,n)=>this._updateRow(r,t[t.length-1-n],"footer",n===0)),this._updateRow(this.$.sizer,t[t.length-1]),this._resizeHandler(),this._frozenCellsChanged(),this._updateFirstAndLastColumn(),this._resetKeyboardNavigation(),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows(),this.__updateFooterPositioning()}__updateFooterPositioning(){this._firefox&&(this.$.items.style.paddingBottom=0,this.heightByRows||(this.$.items.style.paddingBottom=`${this.$.footer.offsetHeight}px`)),this._ios&&!window.CSS.supports("position","sticky")&&(this.$.table.style.height="",this.$.table.style.minHeight="100%",this.$.table.style.maxHeight="100%",setTimeout(()=>this.$.table.style.height=`${this.$.scroller.offsetHeight}px`))}_updateItem(t,r){t._item=r;let n=this.__getRowModel(t);this._toggleAttribute("selected",n.selected,t),this._a11yUpdateRowSelected(t,n.selected),this._a11yUpdateRowLevel(t,n.level),this._toggleAttribute("expanded",n.expanded,t),this._toggleAttribute("details-opened",this._isDetailsOpened(r),t),(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._toggleDetailsCell(t,r),this._generateCellClassNames(t,n),this._filterDragAndDrop(t,n),Array.from(t.children).forEach(i=>{if(i._renderer){let o=i._column||this;i._renderer.call(o,i._content,o,n)}else i._instance&&(i._instance.__detailsOpened__=n.detailsOpened,i._instance.__selected__=n.selected,i._instance.__level__=n.level,i._instance.__expanded__=n.expanded,i._instance.setProperties(n))}),this._debouncerUpdateHeights=sr.debounce(this._debouncerUpdateHeights,mo.after(1),()=>{this._updateMetrics(),this._positionItems(),this._updateScrollerSize()})}_resizeHandler(){this._updateDetailsCellHeights(),this._accessIronListAPI(super._resizeHandler,!0),this._updateScrollerMeasurements(),this.__updateFooterPositioning()}_onAnimationEnd(t){t.animationName.indexOf("vaadin-grid-appear")===0&&(this._render(),t.stopPropagation(),this.notifyResize(),this.__itemsReceived(),requestAnimationFrame(()=>{this.__scrollToPendingIndex(),this.$.table.style.webkitOverflowScrolling="touch"}))}_toggleAttribute(t,r,n){n.hasAttribute(t)===!r&&(r?n.setAttribute(t,""):n.removeAttribute(t))}__getRowModel(t){return{index:t.index,item:t._item,level:this._getIndexLevel(t.index),expanded:this._isExpanded(t._item),selected:this._isSelected(t._item),detailsOpened:!!(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._isDetailsOpened(t._item)}}render(){this._columnTree&&(this._columnTree.forEach(t=>{t.forEach(r=>r._renderHeaderAndFooter())}),this._update())}notifyResize(){super.notifyResize()}_heightByRowsChanged(t,r){(t||r)&&this.notifyResize()}__forceReflow(){this._debouncerForceReflow=sr.debounce(this._debouncerForceReflow,Ni,()=>{this.$.scroller.style.overflow="hidden",setTimeout(()=>this.$.scroller.style.overflow="")})}};customElements.define(rV.is,rV);function fue(e,t){return Bgt(e,t)}var u1=class extends mt{constructor(){super(...arguments),this._run=""}_csvUrl(t,r,n){return r?Mi(n(t,r),{format:"csv"}):""}_jsonUrl(t,r,n){return r?n(t,r):""}_csvName(t,r){return r?`run-${r}-tag-${t}.csv`:""}_jsonName(t,r){return r?`run-${r}-tag-${t}.json`:""}};u1.template=Q`
    <paper-dropdown-menu
      no-label-float="true"
      label="run to download"
      selected-item-label="{{_run}}"
    >
      <paper-listbox slot="dropdown-content">
        <template is="dom-repeat" items="[[runs]]">
          <paper-item no-label-float="true">[[item]]</paper-item>
        </template>
      </paper-listbox>
    </paper-dropdown-menu>
    <template is="dom-if" if="[[_run]]">
      <a download="[[_csvName(tag, _run)]]" href="[[_csvUrl(tag, _run, urlFn)]]"
        >CSV</a
      ><!--
      --><a
        download="[[_jsonName(tag, _run)]]"
        href="[[_jsonUrl(tag, _run, urlFn)]]"
        >JSON</a
      >
    </template>
    <style>
      :host {
        display: flex;
        align-items: center;
        height: 32px;
      }
      paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }
      a {
        font-size: 10px;
        margin: 0 0.2em;
      }
      paper-input {
        font-size: 22px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],u1.prototype,"_run",void 0);E([A({type:Array}),w("design:type",Array)],u1.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],u1.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],u1.prototype,"urlFn",void 0);u1=E([yt("tf-downloader")],u1);var hhr=64,Eli=new URLSearchParams(window.location.search),Wn=class extends mt{constructor(){super(...arguments),this.colorScale=null,this._loadDataCallback=(t,r,n)=>{if(n==null){console.error("Failed to load data for:",r);return}let i=n.map(a=>({wall_time:new Date(a[0]*1e3),step:a[1],scalar:a[2]})),o=this._getSeriesNameFromDatum(r);t.setSeriesMetadata(o,r),t.setSeriesData(o,i)},this.getDataLoadUrl=({tag:t,run:r})=>_e().pluginRouteForSrc("scalars","/scalars",new URLSearchParams({tag:t,run:r})),this._downloadUrlFn=(t,r)=>this.getDataLoadUrl({tag:t,run:r}),this.requestData=(t,r,n)=>this.inColab?this._requestDataGet(t,r,n):this._requestDataPost(t,r,n),this._requestDataGet=(t,r,n)=>{let o=_e().pluginRoute("scalars","/scalars");Promise.all(t.map(a=>{let s=Mi(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this._requestDataPost=(t,r,n)=>{var c;let o=_e().pluginRoute("scalars","/scalars_multirun"),a=new Map;for(let{tag:u,run:h}of t){let f=a.get(u);f==null&&a.set(u,f=[]),f.push(h)}let s=(c=this.batchSize)!=null?c:hhr,l=[];for(let[u,h]of a)for(let f=0;f<h.length;f+=s)l.push({tag:u,runs:h.slice(f,f+s)});Promise.all(l.map(({tag:u,runs:h})=>this.requestManager.request(o,{tag:u,runs:h}).then(f=>{for(let p of h){let d={tag:u,run:p};Object.prototype.hasOwnProperty.call(f,p)?r({item:d,data:f[p]}):r({item:d,data:null})}}))).finally(()=>void n())},this._getDataLoadName=t=>this._getSeriesNameFromDatum(t),this._expanded=!1,this._tooltipColumns=(()=>{let t=ist.slice(),r=t.findIndex(n=>n.title=="Name");return t.splice(r,1,{title:"Name",evaluate:n=>{let i=n.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(i)}}),t})()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){this._getChartDataLoader().reload()}redraw(){this._getChartDataLoader().redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this._getChartDataLoader();t&&t.resetDomain()}_updateDownloadLink(){var n;let t=this._getChartDataLoader().exportAsSvgString(),r=(n=this.shadowRoot)==null?void 0:n.querySelector("#svgLink");r.href=`data:image/svg+xml;base64,${btoa(t)}`}_runsFromData(t){return t.map(r=>r.run)}_getDataSeries(){return this.dataToLoad.map(t=>this._getSeriesNameFromDatum(t))}_getSeriesNameFromDatum({run:t,experiment:r={name:"_default"}}){return JSON.stringify([r.name,t])}_getSeriesDisplayNameFromDatum(t){return t.run}_getColorScale(){return this.colorScale!==null?this.colorScale:{scale:t=>{let[,r]=JSON.parse(t);return fn(r)}}}};Wn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        active="[[active]]"
        color-scale="[[_getColorScale(colorScale)]]"
        data-series="[[_getDataSeries(dataToLoad.*)]]"
        data-to-load="[[dataToLoad]]"
        get-data-load-name="[[_getDataLoadName]]"
        get-data-load-url="[[getDataLoadUrl]]"
        request-data="[[requestData]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-data-callback="[[_loadDataCallback]]"
        load-key="[[tag]]"
        log-scale-active="[[_logScaleActive]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        tag-metadata="[[tagMetadata]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-position="auto"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <paper-menu-button on-paper-dropdown-open="_updateDownloadLink">
          <paper-icon-button
            class="dropdown-trigger"
            slot="dropdown-trigger"
            icon="file-download"
          ></paper-icon-button>
          <paper-listbox class="dropdown-content" slot="dropdown-content">
            <paper-item>
              <a id="svgLink" download="[[tag]].svg">
                Download Current Chart as SVG
              </a>
            </paper-item>
          </paper-listbox>
        </paper-menu-button>
      </template>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <tf-downloader
            runs="[[_runsFromData(dataToLoad)]]"
            tag="[[tag]]"
            url-fn="[[_downloadUrlFn]]"
          ></tf-downloader>
        </div>
      </template>
    </div>
    <style>
      :host {
        margin: 5px;
        display: block;
        width: 330px;
      }

      :host([_expanded]) {
        width: 100%;
      }

      :host([_expanded]) #tf-line-chart-data-loader-container {
        height: 400px;
      }

      #tf-line-chart-data-loader-container {
        height: 200px;
        width: 100%;
      }

      tf-card-heading {
        display: block;
        margin-bottom: 10px;
      }

      #buttons {
        display: flex;
        flex-direction: row;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      .download-links {
        display: flex;
        height: 32px;
      }

      .download-links a {
        align-self: center;
        font-size: 10px;
        margin: 2px;
      }

      .download-links paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }

      paper-menu-button {
        padding: 0;
      }
      paper-item a {
        color: inherit;
        text-decoration: none;
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Wn.prototype,"tag",void 0);E([A({type:Array}),w("design:type",Array)],Wn.prototype,"dataToLoad",void 0);E([A({type:String}),w("design:type",String)],Wn.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Wn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"showDownLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Wn.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Wn.prototype,"tooltipSortingMethod",void 0);E([A({type:Number}),w("design:type",Number)],Wn.prototype,"batchSize",void 0);E([A({type:Boolean}),w("design:type",Number)],Wn.prototype,"inColab",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_loadDataCallback",void 0);E([A({type:Object}),w("design:type",Function)],Wn.prototype,"getDataLoadUrl",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_downloadUrlFn",void 0);E([A({type:Object}),w("design:type",Function)],Wn.prototype,"requestData",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_getDataLoadName",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Wn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"_logScaleActive",void 0);E([A({type:Array}),w("design:type",Array)],Wn.prototype,"_tooltipColumns",void 0);Wn=E([yt("tf-scalar-card")],Wn);var Us=class extends fue([cW],mt){constructor(){super(...arguments),this.sessionGroup=null,this._xType=Td.STEP,this._noMultiExperiments=!1,this._requestData=(t,r,n)=>{Promise.all(t.map(i=>{let o={experimentName:this.experimentName,sessionName:i.run,metricName:i.tag};return this.backend.listMetricEvals(o).then(a=>void r({item:i,data:a}))})).finally(()=>void n())},this._colorScale={scale:t=>{let r=JSON.parse(t)[1],n=this._indexOfSession.get(r),i=iR;return i[(this._sessionGroupNameHash+n)%i.length]}}}connectedCallback(){super.connectedCallback(),this.addEventListener("iron-resize",this.redraw.bind(this))}redraw(){var t;(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.redraw()})}_sessionGroupChanged(){var t;!this.sessionGroup||Object.keys(this.sessionGroup).length==0?(this._indexOfSession=new Map,this._sessionGroupNameHash=0):(this._indexOfSession=new Map(this.sessionGroup.sessions.map((r,n)=>[r.name,n])),this._sessionGroupNameHash=dct(this.sessionGroup.name)),(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{let n=r,i=n.get("tag");n.set("tag",""),n.set("tag",i)})}_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&this.visibleSchema.metricInfos.length>0}_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()}_computeSeriesForSessionGroupMetric(t,r){return t===null||Object.keys(t).length==0||r===null?[]:t.sessions.filter(n=>f3(n.metricValues,r.name)!==void 0).map(n=>({tag:r.name,run:n.name}))}_computeTagMetadata(t){return{displayName:Qu(t),description:t.description||""}}};Us.template=Q`
    <template is="dom-if" if="[[!sessionGroup]]">
      <div>
        <h3>No session group selected</h3>
        <p>Please select a session group to see its metric-graphs here.</p>
      </div>
    </template>
    <template is="dom-if" if="[[!_haveMetrics(visibleSchema.*)]]">
      <div>
        <h3>No metrics are enabled</h3>
        <p>Please enable some metrics to see content here.</p>
      </div>
    </template>
    <div class="layout horizontal wrap session-group-details">
      <template
        is="dom-if"
        if="[[_haveMetricsAndSessionGroup(visibleSchema.*, sessionGroup)]]"
      >
        <template
          is="dom-repeat"
          items="[[visibleSchema.metricInfos]]"
          as="metricInfo"
        >
          <!-- Note that we do not provide a request-manager attribute since
               we provide a function in request-data for calling the backend
               to get the metrics data.
            -->
          <tf-scalar-card
            class="scalar-card"
            color-scale="[[_colorScale]]"
            data-to-load="[[_computeSeriesForSessionGroupMetric(sessionGroup, metricInfo)]]"
            tag="[[metricInfo.name.tag]]"
            tag-metadata="[[_computeTagMetadata(metricInfo)]]"
            x-type="[[_xType]]"
            multi-experiments="[[_noMultiExperiments]]"
            request-data="[[_requestData]]"
            active
          >
          </tf-scalar-card>
        </template>
      </template>
    </div>
    <!-- "iron-flex" is needed to use the layout classes in the div above -->
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Us.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Us.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Us.prototype,"visibleSchema",void 0);E([A({type:Object}),w("design:type",Object)],Us.prototype,"sessionGroup",void 0);E([A({type:String}),w("design:type",String)],Us.prototype,"_xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Us.prototype,"_noMultiExperiments",void 0);E([A({type:Object}),w("design:type",Object)],Us.prototype,"_indexOfSession",void 0);E([A({type:Number}),w("design:type",Number)],Us.prototype,"_sessionGroupNameHash",void 0);E([A({type:Object}),w("design:type",Function)],Us.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Us.prototype,"_colorScale",void 0);E([Bt("sessionGroup.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Us.prototype,"_sessionGroupChanged",null);Us=E([yt("tf-hparams-session-group-details")],Us);var Vd=class extends Gt(_o(mt)){constructor(){super(...arguments),this._hparamName=Bd,this._metricName=Qu}_visibleSchemaOrSessionGroupsChanged(){let t=this.$.sessionGroupsTable.get("detailsOpenedItems");this.$.sessionGroupsTable.set("detailsOpenedItems",[]),ci();let r=new Map;this.sessionGroups.forEach(n=>{r.set(n.name,n)}),this.$.sessionGroupsTable.set("detailsOpenedItems",t.map(n=>r.get(n.name)).filter(Boolean))}_sessionGroupHParam(t,r){return t==null||Object.keys(t).length==0||!Object.prototype.hasOwnProperty.call(t.hparams,r)?"":w0(t.hparams[r])}_sessionGroupMetric(t,r){if(t==null||Object.keys(t).length==0)return"";for(let n=0;n<t.metricValues.length;++n){let i=t.metricValues[n];if(i.name.group===r.group&&i.name.tag==r.tag)return w0(i.value)}return""}_rowNumber(t){return t+1}};Vd.template=Q`
    <vaadin-grid
      class="session-group-table"
      id="sessionGroupsTable"
      column-reordering-allowed=""
      items="[[sessionGroups]]"
    >
      <vaadin-grid-column flex-grow="0" width="10em" resizable="">
        <template class="header">
          <div class="table-header table-cell">Trial ID</div>
        </template>
        <template>
          <div class="table-cell">[[item.name]]</div>
        </template>
      </vaadin-grid-column>
      <template is="dom-if" if="[[enableShowMetrics]]">
        <vaadin-grid-column flex-grow="0" autoWidth="" resizable="">
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{detailsOpened}}">
            </paper-checkbox>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="[[visibleSchema.hparamInfos]]"
        as="hparamInfo"
        index-as="hparamIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_hparamName(hparamInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupHParam(item, hparamInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="{{visibleSchema.metricInfos}}"
        as="metricInfo"
        index-as="metricIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_metricName(metricInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupMetric(item, metricInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template class="row-details">
        <tf-hparams-session-group-details
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          session-group="[[item]]"
          visible-schema="[[visibleSchema]]"
          class="session-group-details"
        >
        </tf-hparams-session-group-details>
      </template>
    </vaadin-grid>

    <style>
      :host {
        display: inline;
      }

      :host(.dark-mode) {
        --lumo-base-color: #303030;
        --lumo-body-text-color: #fff;
      }

      :host(.dark-mode) vaadin-grid {
        --_lumo-grid-secondary-border-color: #505050;
      }

      .table-cell {
        white-space: nowrap;
        text-overflow: ellipsis;
        overflow: hidden;
      }
      .table-header {
        /* line-break overflowing column headers */
        white-space: normal;
        overflow-wrap: break-word;
      }
      .session-group-table {
        height: 100%;
      }
      .session-group-details {
        height: 360px;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Vd.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],Vd.prototype,"sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vd.prototype,"enableShowMetrics",void 0);E([A({type:Object}),w("design:type",Object)],Vd.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Vd.prototype,"experimentName",void 0);E([Bt("visibleSchema.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vd.prototype,"_visibleSchemaOrSessionGroupsChanged",null);Vd=E([yt("tf-hparams-table-view")],Vd);var CP=class extends mt{constructor(){super(...arguments),this.sessionGroup=null,this.visibleSchema=null}_propertiesArePopulated(t,r){return t!=null&&r!==void 0&&r!==null}_singletonSessionGroups(t){return t==null?[]:[t]}};CP.template=Q`
    <!-- If sessionGroup or visibleSchema are not populated, do not display
         anything.
      -->
    <template
      is="dom-if"
      if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <!-- Display one row without a "show-metrics" column -->
      <tf-hparams-table-view
        visible-schema="[[visibleSchema]]"
        session-groups="[[_singletonSessionGroups(sessionGroup)]]"
      >
      </tf-hparams-table-view>
    </template>
    <template
      is="dom-if"
      if="[[!_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <div>Click or hover over a session group to display its values here.</div>
    </template>

    <style>
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],CP.prototype,"sessionGroup",void 0);E([A({type:Object}),w("design:type",Object)],CP.prototype,"visibleSchema",void 0);CP=E([yt("tf-hparams-session-group-values")],CP);var AP=Ee(Oe(),1);function pue(e,t,r,n){if(t.length<2)return console.error("Less than two axes in parallel coordinates plot."),null;let i=r[0],o=r[1];if(i<=t[0]||i>=t[t.length-1])return null;let a=AP.sortedIndex(t,i);console.assert(a>0),console.assert(a<t.length);let s=a-1;function l(h,f,p,d){let g=h-p,_=f-d,y=i-p,x=o-d,b=(g*y+_*x)/(g*g+_*_);if(b<=0)return p3(y,x);if(b>=1){let S=h-i,C=f-o;return p3(S,C)}return p3(y-b*g,x-b*_)}let c=null,u=null;return e.forEach(h=>{let f=l(h.controlPoints[s][0],h.controlPoints[s][1],h.controlPoints[a][0],h.controlPoints[a][1]);f>n||(c===null||f<c)&&(c=f,u=h)}),u}function due(e,t,r){return e.domain().filter(n=>{let i=e(n);return t<=i&&i<=r})}function mue(e,t,r){let n=e.range(),i=n.filter(o=>t<=o&&o<=r).map(o=>{let a=e.invertExtent(o);return o===n[n.length-1]?[a[0],a[1]+1]:a});return i.length==0?[0,0]:sa(Lm(i))}function gue(e,t,r){return[e.invert(t),e.invert(r)].sort((n,i)=>n-i)}function Fct(e,t,r){function n(){if(e.length===0)return[1,2];let[i,o]=sa(e);return i!==o?[i,o]:i>0?[i*.5,i*1.5]:i<0?[i*1.5,i*.5]:[-1,1]}if(r==="LINEAR")return zn().domain(n()).range([t,0]);if(r==="LOG"){let i=n();return i[0]<=0&&i[1]>=0?Fct(e,t,"LINEAR"):cc().domain(i).range([t,0])}else if(r==="QUANTILE"){let o=Ir(20).map(a=>t-a*t/19);return e.length===0&&(e=[1]),rg().domain(AP.uniq(e)).range(o)}else{if(r==="NON_NUMERIC")return eg().domain(AP.uniq(e.sort())).range([t,0]).padding(.1);throw RangeError("Unknown scale: "+r)}}var h1;(function(e){e.LINEAR="LINEAR",e.LOG="LOG",e.QUANTILE="QUANTILE",e.NON_NUMERIC="NON_NUMERIC"})(h1||(h1={}));var PP=class{isPassing(t){return!0}},nV=class{constructor(t,r,n,i){this._lower=t,this._upper=r,this._lowerOpen=n,this._upperOpen=i}isPassing(t){let r=t;return this._before(this._lower,r,!this._lowerOpen)&&this._before(r,this._upper,!this._upperOpen)}_before(t,r,n){return n?t<=r:t<r}},Hct=class{constructor(t){this._domainSet=t}isPassing(t){return this._domainSet.findIndex(r=>r===t)!==-1}},Vct=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._interactionManager=n,this._colIndex=i,this._isDisplayed=!1,this._yScale=null,this._scaleType=null,this.setBrushSelection(null)}colIndex(){return this._colIndex}yScale(){return this._yScale}scaleType(){return this._scaleType}brushSelection(){return this._brushSelection}isDisplayed(){return this._isDisplayed}setBrushSelection(t){this._brushSelection=t,this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}setDomainAndScale(t,r){this._scaleType=r,this._yScale=Fct(t.slice(),this._svgProps.height,this.scaleType()),this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(t){let r=lb(this.yScale());this.scaleType()===h1.QUANTILE&&(r=r.tickValues(this.yScale().quantiles()).tickFormat(xn("-.6g")));let n=Ht(t);n.selectAll("g").remove(),n.append("g").classed("axis",!0).call(r).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(a=>cct(this._schema,a)),n.call(pb().on("start",()=>{t.setAttribute("is-dragging",""),this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(qt.x)).on("end",()=>{this._interactionManager.onDragEnd(),t.removeAttribute("is-dragging")}));let i=qL().extent([[-8,0],[8,this._svgProps.height+1]]).on("start",()=>{!Bct(qt)||(t.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex(),qt.selection))}).on("brush",()=>{!Bct(qt)||this._interactionManager.onBrushChanged(this.colIndex(),qt.selection)}).on("end",()=>{!Bct(qt)||(this._interactionManager.onBrushChanged(this.colIndex(),qt.selection),t.removeAttribute("is-brushing"))}),o=Ht(t).append("g").classed("brush",!0);o.call(i),i.move(o,this.brushSelection())}setDisplayed(t){this._isDisplayed=t}_buildBrushFilter(t,r,n){if(t===null)return new PP;if(r===null)return console.error("Scale type is null, but brushSelection isn't: ",t),new PP;switch(r){case h1.LINEAR:case h1.LOG:{let[i,o]=gue(n,t[0],t[1]);return new nV(i,o,!1,!1)}case h1.QUANTILE:{let[i,o]=mue(n,t[0],t[1]);return new nV(i,o,!1,!0)}case h1.NON_NUMERIC:return new Hct(due(n,t[0],t[1]))}return console.error("Unknown scale type: ",r),new PP}},iV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axes=this._createAxes(n),this._stationaryAxesPositions=eg().range([1,this._svgProps.width-1]).padding(.5),this._draggedAxis=null,this._svgProps.svgG.selectAll("g.axis-parent").remove(),this._parentsSel=this._svgProps.svgG.selectAll(".axis-parent")}updateAxes(t,r){console.assert(!this.isAxisDragging());let n=new Set;t.columns.forEach(o=>{let a=o.absoluteIndex,s=this._axes[a];s.setDisplayed(!0);let l=r.map(c=>b0(this._schema,c,a));s.setDomainAndScale(l,o.scale),n.add(a)}),this._axes.forEach(o=>{n.has(o.colIndex())||o.setDisplayed(!1)}),this._updateStationaryAxesPositions(n),this._parentsSel=this._parentsSel.data(Array.from(n),o=>o),this._parentsSel.exit().remove(),this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);let i=this;this._parentsSel.call(o=>this._updateAxesPositionsInDOM(o)).each(function(o){i._axes[o].updateDOM(this)})}mapVisibleAxes(t){return this._stationaryAxesPositions.domain().map(r=>t(this.getAxisPosition(r),this._axes[r]))}allVisibleAxesSatisfy(t){return this._stationaryAxesPositions.domain().every(r=>t(this.getAxisPosition(r),this._axes[r]))}getAxisForColIndex(t){return this._axes[t]}dragStart(t){console.assert(!this.isAxisDragging()),console.assert(this._axes[t].isDisplayed()),this._draggedAxis=this._axes[t],this._draggedAxisPosition=this._stationaryAxesPositions(t)}drag(t){t=Math.min(Math.max(t,0),this._svgProps.width),this._draggedAxisPosition=t;let r=this._stationaryAxesPositions.domain();r.sort((n,i)=>this.getAxisPosition(n)-this.getAxisPosition(i)),this._stationaryAxesPositions.domain(r),this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(t){console.assert(this.isAxisDragging()),this._draggedAxisPosition=null,this._draggedAxis=null,this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(t))}isAxisDragging(){return this._draggedAxis!==null}getAxisPosition(t){return this._draggedAxis!==null&&this._draggedAxis.colIndex()===t?this._draggedAxisPosition:this._stationaryAxesPositions(t)}_updateStationaryAxesPositions(t){let r=this._stationaryAxesPositions.domain().filter(i=>t.has(i)),n=Array.from(new Set([...r,...Array.from(t)]));this._stationaryAxesPositions.domain(n)}_updateAxesPositionsInDOM(t){t.attr("transform",r=>yP(this.getAxisPosition(r)))}_createAxes(t){return Ir(uct(this._schema)).map(r=>new Vct(this._svgProps,this._schema,t,r))}};function Bct(e){return e.sourceEvent!==null}var Xf;(function(e){e[e.FOREGROUND=0]="FOREGROUND",e[e.BACKGROUND=1]="BACKGROUND"})(Xf||(Xf={}));var th=class{constructor(t){t===void 0&&(t=Tp(null)),console.assert(t.size()<=1),this._sessionGroupSel=t}sessionGroup(){return this._sessionGroupSel.size()===1?this._sessionGroupSel.datum():null}isNull(){return this.sessionGroup()===null}selection(){return this._sessionGroupSel}equalsTo(t){var r,n;return this.isNull()?t.isNull():t.isNull()?!1:((r=t.sessionGroup())==null?void 0:r.name)==((n=this.sessionGroup())==null?void 0:n.name)}},oV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axesCollection=n,this._sessionGroups=[],this._svgProps.svgG.selectAll("g.background").remove(),this._svgProps.svgG.selectAll("g.foreground").remove(),this._bgPathsSel=this._svgProps.svgG.append("g").classed("background",!0).selectAll("path"),this._fgPathsSel=this._svgProps.svgG.append("g").classed("foreground",!0).selectAll("path"),this._updateVisibleFgPathsSel(),this._peakedSessionGroupHandle=new th,this._selectedSessionGroupHandle=new th,this._d3line=vu().curve(jh)}getSessionGroupHandle(t){return t==null?new th:new th(this._fgPathsSel.filter(r=>r.name===t.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(t,r=0){(t===Xf.FOREGROUND?this._fgPathsSel:this._bgPathsSel).transition().duration(r).attr("d",i=>this._pathDAttribute(i)),t===Xf.FOREGROUND&&window.setTimeout(()=>{let i=this;this._fgPathsSel.each(function(o){i._setControlPointsProperty(this,o)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",t=>!this._axesCollection.allVisibleAxesSatisfy((r,n)=>n.brushFilter().isPassing(b0(this._schema,t,n.colIndex())))),this._updateVisibleFgPathsSel()}setForegroundLinesColor(t,r,n){let i=this._createLineColorFunction(t,r,n);this._fgPathsSel.attr("stroke",i)}redraw(t,r,n,i){let o=this._peakedSessionGroupHandle.sessionGroup(),a=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=t,this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel),this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel),this._peakedSessionGroupHandle=this.getSessionGroupHandle(o),this._selectedSessionGroupHandle=this.getSessionGroupHandle(a),this.recomputeControlPoints(Xf.FOREGROUND),this.recomputeControlPoints(Xf.BACKGROUND),this.recomputeForegroundLinesVisibility(),this.setForegroundLinesColor(r,n,i)}updatePeakedSessionGroup(t){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1),this._peakedSessionGroupHandle=t,this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new th)}updateSelectedSessionGroup(t){this._selectedSessionGroupHandle.selection().classed("selected-path",!1),this._selectedSessionGroupHandle=t,this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(t,r){let n=this._axesCollection.mapVisibleAxes((o,a)=>o),i=pue(this._visibleFgPathsSel.nodes(),n,[t,r],100);return i===null?new th:new th(Ht(i))}_createLineColorFunction(t,r,n){if(t===null)return()=>"red";let i=zn().domain(hct(this._schema,this._sessionGroups,t)).range([r,n]).interpolate(E_);return o=>i(b0(this._schema,o,t))}_recomputePathSelection(t){return t=t.data(this._sessionGroups,r=>r.name),t.exit().remove(),t.enter().append("path").merge(t)}_setControlPointsProperty(t,r){t.controlPoints=this._computeControlPoints(r)}_computeControlPoints(t){return this._axesCollection.mapVisibleAxes((r,n)=>[r,n.yScale()(b0(this._schema,t,n.colIndex()))])}_pathDAttribute(t){return this._d3line(this._computeControlPoints(t))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=this._fgPathsSel.filter(":not(.invisible-path)")}};var aV=class{constructor(t,r){this.svg=Ht(t);let n={top:30,right:10,bottom:10,left:10},i=100,o=200,a=r*i+n.left+n.right,s=o+n.top+n.bottom;this.svg.attr("viewBox",`0 0 ${a} ${s}`),this.svg.attr("preserveAspectRatio","xMidYMid"),this.svg.style("min-width",a+"px"),this.svg.style("min-height",s+"px"),this.width=a-n.left-n.right,this.height=s-n.top-n.bottom,this.svgG=this.svg.append("g").attr("transform",yP(n.left,n.top))}},sV=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._peakedSessionGroupChangedCB=n,this._selectedSessionGroupChangedCB=i,this._axesCollection=new iV(t,r,this),this._linesCollection=new oV(t,r,this._axesCollection),this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{let[o,a]=zo(this._svgProps.svgG.node());this.onMouseMoved(o,a)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t),this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t),this._linesCollection.recomputeControlPoints(Xf.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd(500),this._linesCollection.recomputeControlPoints(Xf.FOREGROUND,500),window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(Xf.BACKGROUND),this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t,r){this._axesCollection.getAxisForColIndex(t).setBrushSelection(r),this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,r){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,r)),this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup())}onMouseLeave(){this._linesCollection.peakedSessionGroupHandle().isNull()||(this._linesCollection.clearPeakedSessionGroup(),this._peakedSessionGroupChangedCB(null))}onClick(){this._linesCollection.peakedSessionGroupHandle().sessionGroup()===this._linesCollection.selectedSessionGroupHandle().sessionGroup()?this._linesCollection.updateSelectedSessionGroup(new th):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle()),this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,r){this._axesCollection.updateAxes(t,r);let n=this._linesCollection.peakedSessionGroupHandle(),i=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(r,t.colorByColumnIndex!==void 0?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor),n.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup()),i.equalsTo(this._linesCollection.selectedSessionGroupHandle())||this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}};var eh=class extends Gt(_o(mt)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this.redrawCount=0}_optionsOrSessionGroupsChanged(){var n;if(!this.options)return;let{configuration:t}=(n=this._prevOptions)!=null?n:{},{configuration:r}=this.options;if(this._interactionManager===void 0||!Uct.isEqual(t==null?void 0:t.schema,r.schema)||!Uct.isEqual(t==null?void 0:t.columnsVisibility,r.columnsVisibility)){Ht(this.$.svg).selectAll("*").remove();let i=new aV(this.$.svg,r.columnsVisibility.filter(Boolean).length);this.scopeSubtree(this.$.svg,!0),this._interactionManager=new sV(i,r.schema,o=>this.closestSessionGroupChanged(o),o=>this.selectedSessionGroupChanged(o))}this._computeValidSessionGroups(),this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,this._validSessionGroups),this.redrawCount++,this._prevOptions=this.options}closestSessionGroupChanged(t){this.closestSessionGroup=t}selectedSessionGroupChanged(t){this.selectedSessionGroup=t}_computeValidSessionGroups(){let t=us;if(this.sessionGroups===void 0){this._validSessionGroups=void 0;return}let r=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(n=>{for(let i=0;i<t.numColumns(r);++i){if(!this.options.configuration.columnsVisibility[i])continue;let o=t.columnValueByIndex(r,n,i);if(o===void 0||o==="NaN")return!1}return!0})}};eh.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #fff,
          1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
      }
      :host(.dark-mode) {
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #000,
          1px 0 0 #000, 0 -1px 0 #000, -1px 0 0 #000;
      }
      svg {
        font: 10px sans-serif;
      }

      .background path {
        fill: none;
        stroke: #ddd;
        shape-rendering: crispEdges;
      }

      .foreground path {
        fill: none;
        stroke-opacity: 0.7;
        stroke-width: 1;
      }

      /* Will be set on foreground paths that are not "contained" in the current
         axes brushes. If no brushes are set, no path will have this class. */
      .foreground .invisible-path {
        display: none;
      }

      /* Style for the path closest to the mouse pointer (typically will become
      the selected path when the user clicks). */
      .foreground .peaked-path {
        stroke-width: 3;
      }

      /* The currently selected path class. We use !important to override the
         inline style that sets the regular color of a path. */
      .foreground .selected-path {
        stroke-width: 3 !important;
        stroke: #0f0 !important;
      }

      #container {
        height: 100%;
        width: 100%;
      }

      svg {
        width: 100%;
        height: 100%;
      }

      .axis text {
        text-shadow: var(--tf-hparams-parallel-coords-plot-axis-shadow);
        fill: currentColor;
        cursor: move;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],eh.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"closestSessionGroup",void 0);E([A({type:Number}),w("design:type",Number)],eh.prototype,"redrawCount",void 0);E([A({type:Array}),w("design:type",Object)],eh.prototype,"_validSessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"_interactionManager",void 0);E([Bt("options.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],eh.prototype,"_optionsOrSessionGroupsChanged",null);eh=E([yt("tf-hparams-parallel-coords-plot")],eh);var P0=class extends mt{constructor(){super(...arguments),this.options=null}_configurationChanged(){let t=this.configuration.visibleSchema,r=this.configuration.schema,n=(a,s)=>({name:Bd(a),index:s,absoluteIndex:zH(r,t,s),scale:this._isNumericColumn(s)?"LINEAR":"NON_NUMERIC"}),i=(a,s)=>{let l=s+t.hparamInfos.length;return{scale:"LINEAR",name:Qu(a),index:l,absoluteIndex:zH(r,t,l)}},o={columns:t.hparamInfos.map(n).concat(t.metricInfos.map(i)),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",o),ci(),this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())}_unselectDisabledLogScales(){this.options!==null&&this.options.columns.forEach(t=>{let r="options.columns."+t.index;!this._allowLogScale(t)&&t.scale==="LOG"&&this.set(r+".scale","LINEAR")})}_allowLogScale(t){if(!this._isNumericColumn(t.index)||!this.sessionGroups)return!1;let[r,n]=_P(this.configuration.visibleSchema,this.sessionGroups,t.index);return r>0||n<0}_isNumericColumn(t){return t>=this.configuration.visibleSchema.hparamInfos.length||this.configuration.visibleSchema.hparamInfos[t].type==="DATA_TYPE_FLOAT64"}_defaultColorByColumnIndex(){if(this.configuration.visibleSchema.metricInfos.length>0)return this.configuration.visibleSchema.hparamInfos.length;let t=this.configuration.visibleSchema.hparamInfos.findIndex(r=>r.type==="DATA_TYPE_FLOAT64");if(t!==-1)return t}};P0.template=Q`
    <div class="control-panel">
      <!-- 'Color by' drop down menu -->
      <paper-dropdown-menu
        label="Color by"
        id="colorByDropDownMenu"
        horizontal-align="left"
      >
        <paper-listbox
          class="dropdown-content"
          slot="dropdown-content"
          selected="{{options.colorByColumnIndex}}"
          id="colorByListBox"
        >
          <template
            is="dom-repeat"
            items="[[options.columns]]"
            as="column"
            id="colorByColumnTemplate"
          >
            <paper-item disabled="[[!_isNumericColumn(column.index)]]">
              [[column.name]]
            </paper-item>
          </template>
        </paper-listbox>
      </paper-dropdown-menu>

      <!-- Columns scales -->
      <div class="columns-container">
        <!-- Scale options for each numeric feature -->
        <template is="dom-repeat" items="{{options.columns}}" as="column">
          <template is="dom-if" if="[[_isNumericColumn(column.index)]]">
            <div class="column">
              <div class="column-title">[[column.name]]</div>
              <div>
                <paper-radio-group
                  class="scale-radio-group"
                  selected="{{column.scale}}"
                >
                  <paper-radio-button name="LINEAR">
                    Linear
                  </paper-radio-button>
                  <!-- The id here is used to access this button in unit
                       tests.-->
                  <paper-radio-button
                    id="logScaleButton_[[column.name]]"
                    name="LOG"
                    disabled="[[!_allowLogScale(column, sessionGroups.*)]]"
                  >
                    Logarithmic
                  </paper-radio-button>
                  <paper-radio-button name="QUANTILE">
                    Quantile
                  </paper-radio-button>
                </paper-radio-group>
              </div>
            </div>
          </template>
        </template>
      </div>
    </div>

    <style>
      :host {
        display: block;
      }
      .control-panel {
        overflow: auto;
      }
      .column {
        flex-grow: 1;
        flex-shrink: 1;
        margin-right: 5px;
        border: solid 1px darkgray;
        padding: 3px;
      }
      .column-title {
        /* Fit every title in one line so the radio boxes align vertically. */
        white-space: nowrap;
        text-decoration: underline;
      }
      .columns-container {
        display: flex;
        flex-direction: row;
      }
      .scale-radio-group paper-radio-button {
        padding: 2px;
        display: block;
      }
      paper-listbox {
        max-height: 15em;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],P0.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],P0.prototype,"sessionGroups",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],P0.prototype,"options",void 0);E([Bt("configuration.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],P0.prototype,"_configurationChanged",null);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],P0.prototype,"_unselectDisabledLogScales",null);P0=E([yt("tf-hparams-scale-and-color-controls")],P0);var f1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};f1.template=Q`
    <!-- Controls behavior of parallel coordinates plot
         outputs set options to the _options property.
      -->
    <hparams-split-layout orientation="vertical">
      <!-- The scale and color controls. -->
      <tf-hparams-scale-and-color-controls
        id="controls"
        slot="content"
        class="section"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual parallel coordinates plot -->
      <tf-hparams-parallel-coords-plot
        id="plot"
        slot="content"
        class="section"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-parallel-coords-plot>
      <tf-hparams-session-group-values
        id="values"
        slot="content"
        class="section"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <tf-hparams-session-group-details
        id="details"
        slot="content"
        class="section"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>

    <style>
      .section {
        padding: 10px;
      }
      #values {
        height: 115px;
      }
      #details {
        flex-grow: 1;
        max-height: fit-content;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],f1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],f1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],f1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],f1.prototype,"sessionGroups",void 0);f1=E([yt("tf-hparams-parallel-coords-view")],f1);var y3=Ee(Oe(),1);var $o=class extends Gt(mt){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this._container=null,this._svg=null,this.width=0,this.height=0,this._brushedCellIndex=null,this._brushSelection=null}ready(){super.ready(),this._container=this.$.container,this._svg=Ht(this.$.svg),this._redraw()}_sessionGroupsChanged(){this.selectedSessionGroup!==null&&(this.selectedSessionGroup=fct(this.sessionGroups,this.selectedSessionGroup.name)||null),this._redraw()}_visibleSchemaChanged(){this._brushedCellIndex=null,this._brushSelection=null,this._redraw()}_redraw(){this.debounce("_redraw",()=>{let t=us,r=1200,n=.4*r,i=150,o=.75*i;this.width=Math.max(i*t.numVisibleColumns(this.visibleSchema),r),this.height=Math.max(o*t.numVisibleMetrics(this.visibleSchema),n),this._container.style.width=this.width+"px",this._container.style.height=this.height+"px",this._svg.attr("width",this.width).attr("height",this.height),this._svg.selectAll("g").remove(),this._draw()},100)}_draw(){let t=us,r=this;if(!this.sessionGroups||this.sessionGroups.length==0||!this.visibleSchema||this.visibleSchema.metricInfos.length==0)return;let n=Ir(t.numVisibleColumns(r.visibleSchema)),i=Ir(t.numVisibleMetrics(r.visibleSchema)),o=80,a=50,s=5,l=tg().domain(n).range([o+s,this.width-1-s]).paddingInner(.1),c=tg().domain(i).range([this.height-1-s-a,s]).paddingInner(.1),u=l.bandwidth(),h=c.bandwidth(),f=n.map(ct=>r._cellScale(ct,[0,u-1])),p=i.map(ct=>r._cellScale(ct+t.numVisibleHParams(r.visibleSchema),[h-1,0])),d=this._svg.selectAll(".x-axis").data(n).enter().append("g").classed("x-axis",!0).attr("transform",ct=>t.translateStr(l(ct),0));function g(ct){return"x-axis-clip-path-"+ct}function _(ct){return"x-label-clip-path-"+ct}d.append("clipPath").attr("id",g).append("rect").attr("x",-s).attr("y",0).attr("width",u+2*s).attr("height",r.height-a/2),d.append("clipPath").attr("id",_).append("rect").attr("x",0).attr("y",r.height-a/2).attr("width",u).attr("height",a/2),d.append("g").attr("clip-path",ct=>"url(#"+g(ct)+")").each(function(ct){Ht(this).call(S,Z9(f[ct]).tickSize(r.height-a),u,40,r.options.columns[ct].scale)}),d.append("g").classed("x-axis-label",!0).attr("clip-path",ct=>"url(#"+_(ct)+")").append("text").attr("text-anchor","middle").attr("x",u/2).attr("y",r.height-1-a/4).text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct)).append("title").text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct));let y=this._svg.selectAll(".y-axis").data(i).enter().append("g").classed("y-axis",!0).attr("transform",ct=>t.translateStr(r.width-1,c(ct)));function x(ct){return"y-axis-clip-path-"+ct}function b(ct){return"y-label-clip-path-"+ct}y.append("clipPath").attr("id",x).append("rect").attr("x",-(r.width-o/2-1)).attr("y",-s).attr("width",r.width-o/2).attr("height",h+2*s),y.append("clipPath").attr("id",b).append("rect").attr("x",-(r.width-1)).attr("y",0).attr("width",o/2).attr("height",h),y.append("g").attr("clip-path",ct=>"url(#"+x(ct)+")").each(function(ct){Ht(this).call(S,lb(p[ct]).tickSize(r.width-o),h,20,r.options.columns[ct+t.numVisibleHParams(r.visibleSchema)].scale)}),y.append("g").classed("y-axis-label",!0).attr("clip-path",ct=>"url(#"+b(ct)+")").append("text").attr("text-anchor","middle").attr("x",-(r.width-o/4-1)).attr("y",h/2).attr("transform",t.rotateStr(90,-(r.width-o/4-1),h/2)).text(ct=>t.metricName(r.visibleSchema.metricInfos[ct])).append("title").text(ct=>t.metricName(r.visibleSchema.metricInfos[ct]));function S(ct,X,et,dt,q){let pt=Math.floor(et/dt),ht=X.scale();if(q==="QUANTILE"){let wt=ht.quantiles(),kt=Math.ceil(wt.length/pt);wt=Ir(0,wt.length,kt).map(ie=>wt[ie]),X.tickValues(wt).tickFormat(xn("-.2g"))}(q==="LINEAR"||q==="LOG")&&X.ticks(pt),ct.call(X),ct.selectAll(".domain").remove(),ct.selectAll(".tick line").attr("stroke","#ddd")}let C=this._svg.selectAll(".cell").data(q9(n,i)).enter().append("g").classed("cell",!0).attr("transform",([ct,X])=>t.translateStr(l(ct),c(X))),P=C.append("g").classed("frame",!0).append("rect").attr("x",-s).attr("y",-s).attr("width",u+2*s).attr("height",h+2*s).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges"),k=null;r.options.colorByColumnIndex!==void 0&&(k=zn().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(E_));let O=r.options.colorByColumnIndex===void 0?()=>"red":({sessionGroup:ct})=>k(this._colValue(ct,r.options.colorByColumnIndex));function D(ct,X){return f[X](r._colValue(ct,X))}function B(ct,X){return p[X](r._metricValue(ct,X))}function I(ct,X){let et=ct.selectAll(".data-marker").data(([pt,ht])=>r.sessionGroups.filter(wt=>r._colValue(wt,pt)!==void 0&&r._metricValue(wt,ht)!==void 0).map(wt=>({col:pt,metric:ht,sessionGroup:wt,x:D(wt,pt),y:B(wt,ht),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:pt})=>pt).attr("cy",({y:pt})=>pt).attr("r",2).attr("fill",X),dt=new Map;r.sessionGroups.forEach(pt=>{dt.set(pt,[])}),et.each(function(pt){var ht;(ht=dt.get(pt.sessionGroup))==null||ht.push(this)}),et.each(pt=>{let ht=dt.get(pt.sessionGroup);pt.sessionGroupMarkers=new Set(ht)});let q=n.map(pt=>i.map(ht=>et.filter(wt=>wt.col==pt&&wt.metric==ht)));return[et,q,dt]}let[L,R,F]=I(C.append("g"),O);function z(ct,X){let et=[];return R[ct][X].each(function(){et.push(this)}),Fh().x(dt=>Ht(dt).datum().x).y(dt=>Ht(dt).datum().y).addAll(et)}let U=n.map(ct=>i.map(X=>z(ct,X))),W=null;bt()&&(W=C.filter(ct=>y3.isEqual(ct,r._brushedCellIndex)),console.assert(W.size()==1,W));let Z=new Set(L.nodes());rt();function rt(){let ct=new Set(L.nodes());Mt()||(ct=ot(r._brushedCellIndex,r._brushSelection)),Tp(Array.from(t.filterSet(ct,X=>!Z.has(X)))).attr("fill",O),Tp(Array.from(t.filterSet(Z,X=>!ct.has(X)))).attr("fill","#ddd"),Z=ct}function ot(ct,X){console.assert(ct!==null),console.assert(X!==null);let[et,dt]=ct,q=new Set;return t.quadTreeVisitPointsInRect(U[et][dt],X[0][0],X[0][1],X[1][0],X[1][1],pt=>{Ht(pt).datum().sessionGroupMarkers.forEach(wt=>{q.add(wt)})}),q}let st=GL().extent([[-s+1,-s+1],[u-1+s-1,h-1+s-1]]).on("start",function(){bt()&&W.node()!=this&&st.move(W,null),St(this)}).on("brush",function(){St(this)}).on("end",function(){St(this)});function St(ct){let X=UL(ct);!bt()&&X===null||bt()&&ct===W.node()&&y3.isEqual(X,r._brushSelection)||(r._brushSelection=X,X!==null?(W=Ht(ct),r._brushedCellIndex=W.datum()):(W=null,r._brushedCellIndex=null),rt())}function bt(){return r._brushedCellIndex!==null&&r._brushSelection!==null}function Mt(){return!bt()||r._brushSelection[0][0]===r._brushSelection[1][0]||r._brushSelection[0][1]===r._brushSelection[1][1]}C.call(st),bt()&&st.move(W,r._brushSelection);let lt=null,Kt=null;this.selectedSessionGroup!==null&&(Kt=Tp(F.get(this.selectedSessionGroup)).classed("selected-marker",!0)),C.on("click",function(){let ct=lt===Kt?null:lt;if(ct===Kt)return;Kt!==null&&Kt.classed("selected-marker",!1),Kt=ct,Kt!==null&&Kt.classed("selected-marker",!0);let X=Kt===null?null:Kt.datum().sessionGroup;r.selectedSessionGroup=X}).on("mousemove mouseenter",function([ct,X]){let[et,dt]=zo(this),q=_t(ct,X,et,dt,20);lt!==q&&(lt!==null&&lt.classed("closest-marker",!1),lt=q,lt!==null?(lt.classed("closest-marker",!0),r.closestSessionGroup=lt.datum().sessionGroup):r.closestSessionGroup=null)}).on("mouseleave",function([ct,X]){lt!==null&&(lt.classed("closest-marker",!1),lt=null,r.closestSessionGroup=null)});function _t(ct,X,et,dt,q){let pt=1/0,ht=null;return t.quadTreeVisitPointsInDisk(U[ct][X],et,dt,q,(wt,kt)=>{if(Z.has(wt)&&kt<pt){let ie=Ht(wt).datum();pt=kt,ht=ie.sessionGroup}}),ht===null?null:Tp(F.get(ht))}this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}_cellScale(t,r){let n=this._colExtent(t),i=zn().domain(n).range(r);if(this.options.columns[t].scale==="LINEAR")return i;if(this.options.columns[t].scale==="LOG")return n[0]<=0&&n[1]>=0?i:cc().domain(n).range(r);if(this.options.columns[t].scale==="QUANTILE"){let o=(r[1]-r[0])/19,a=Ir(20).map(s=>r[0]+o*s);return rg().domain(y3.uniq(this.sessionGroups.map(s=>this._colValue(s,t)))).range(a)}else{if(this.options.columns[t].scale==="NON_NUMERIC")return eg().domain(y3.uniq(this.sessionGroups.map(o=>this._colValue(o,t)).sort())).range(r).padding(.1);throw"Unknown scale for column: "+t+". options: "+this.options}}_colValue(t,r){return BH(this.visibleSchema,t,r)}_metricValue(t,r){return FH(this.visibleSchema,t,r)}_colExtent(t){return _P(this.visibleSchema,this.sessionGroups,t)}};$o.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      text {
        fill: currentColor;
      }

      .frame rect {
        stroke: currentColor;
      }

      /* The closest data point marker to the mouse pointer. We use !important
         to override the inline style that sets the regular style of a marker.
      */
      .closest-marker {
        r: 6 !important;
      }

      /* The currently selected data point marker. We use !important to
         override the inline style that sets the regular style of a marker. */
      .selected-marker {
        r: 6 !important;
        fill: #0f0 !important;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],$o.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],$o.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"closestSessionGroup",void 0);E([A({type:Object}),w("design:type",HTMLElement)],$o.prototype,"_container",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_svg",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"width",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"height",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushedCellIndex",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushSelection",void 0);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_sessionGroupsChanged",null);E([Bt("visibleSchema.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_visibleSchemaChanged",null);E([Bt("options.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_redraw",null);$o=E([yt("tf-hparams-scatter-plot-matrix-plot")],$o);var p1=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};p1.template=Q`
    <hparams-split-layout orientation="vertical">
      <!-- Controls behavior of the scatter plot matrix
             outputs the configured options to the _options property. -->
      <tf-hparams-scale-and-color-controls
        slot="content"
        class="section"
        id="controls"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual scatter plot matrix -->
      <tf-hparams-scatter-plot-matrix-plot
        slot="content"
        class="section"
        id="plot"
        visible-schema="[[configuration.visibleSchema]]"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-scatter-plot-matrix-plot>
      <tf-hparams-session-group-values
        slot="content"
        class="section"
        id="values"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <!-- Shows session group details for the clicked marker. -->
      <tf-hparams-session-group-details
        slot="content"
        class="section"
        id="details"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      #controls {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #plot {
        flex-grow: 1;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 115px;
        overflow-y: auto;
        max-height: fit-content;
      }
      #details {
        flex-grow: 0;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      vaadin-split-layout {
        height: 100%;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],p1.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],p1.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],p1.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],p1.prototype,"sessionGroups",void 0);p1=E([yt("tf-hparams-scatter-plot-matrix-view")],p1);var $f=class extends mt{constructor(){super(),this._selectedTab=0,this._tableTabClicked=()=>{this.logAction("Tab Clicked","Table")},this._parallelCoordsTabClicked=()=>{this.logAction("Tab Clicked","Parallel Coords")},this._scatterPlotMatrixTabClicked=()=>{this.logAction("Tab Clicked","Scatter Plot Matrix")},this.logAction=(t,r)=>{let n=window.dataLayer||[];function i(){n.push(arguments)}i("event",t,{event_category:"HParams",event_label:r})},this.logAction("Plugin Load")}};$f.template=Q`
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          <!-- view-id can be used by integration tests to locate a tab.
               It should be the name of the root element implementing the view
               without the 'tf-hparams-' prefix. -->
          <paper-tab on-click="_tableTabClicked" view-id="table-view">
            TABLE VIEW
          </paper-tab>
          <paper-tab
            on-click="_parallelCoordsTabClicked"
            view-id="parallel-coords-view"
          >
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab
            on-click="_scatterPlotMatrixTabClicked"
            view-id="scatter-plot-matrix-view"
          >
            SCATTER PLOT MATRIX VIEW
          </paper-tab>
          <div class="help-and-feedback">
            <template is="dom-if" if="[[bugReportUrl]]">
              <a
                href$="[[bugReportUrl]]"
                target="_blank"
                rel="noopener noreferrer"
              >
                <paper-button
                  id="bug-report"
                  raised
                  title="Send a bug report or feature request"
                >
                  Bug Report / Feature Request
                </paper-button>
              </a>
            </template>
            <template is="dom-if" if="[[helpUrl]]">
              <a href$="[[helpUrl]]" target="_blank" rel="noopener noreferrer">
                <paper-icon-button
                  icon="help-outline"
                  title="View documentation"
                >
                </paper-icon-button>
              </a>
            </template>
          </div>
        </paper-tabs>
      </paper-toolbar>
      <iron-pages selected="[[_selectedTab]]" class="fit tab-view">
        <div id="0" class="tab">
          <tf-hparams-table-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            visible-schema="[[configuration.visibleSchema]]"
            session-groups="[[sessionGroups]]"
            enable-show-metrics
          >
          </tf-hparams-table-view>
        </div>
        <div id="1" class="tab">
          <tf-hparams-parallel-coords-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-parallel-coords-view>
        </div>
        <div id="2" class="tab">
          <tf-hparams-scatter-plot-matrix-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-scatter-plot-matrix-view>
        </div>
      </iron-pages>
    </paper-header-panel>

    <style>
      .tab-view {
        height: 100%;
      }
      .tab-bar {
        overflow-y: auto;
        color: white;
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
      }
      .tab {
        height: 100%;
      }
      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
        }
      }
      tf-hparams-table-view {
        width: 100%;
        height: 100%;
      }
      .help-and-feedback {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }
      #bug-report {
        border: solid black;
        background: red;
        white-space: normal;
        word-break: break-words;
        font-size: 12px;
        max-width: 150px;
        text-align: left;
      }
      .help-and-feedback a {
        color: white;
        text-decoration: none;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],$f.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],$f.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],$f.prototype,"bugReportUrl",void 0);E([A({type:String}),w("design:type",String)],$f.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],$f.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],$f.prototype,"sessionGroups",void 0);E([A({type:Number}),w("design:type",Number)],$f.prototype,"_selectedTab",void 0);$f=E([yt("tf-hparams-sessions-pane"),w("design:paramtypes",[])],$f);var rh=class extends Gt(mt){reload(){this.$["query-pane"].reload()}};rh.template=Q`
    <hparams-split-layout>
      <div slot="content" class="sidebar">
        <tf-hparams-query-pane
          id="query-pane"
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          configuration="{{_configuration}}"
          session-groups="{{_sessionGroups}}"
          data-loaded-with-non-empty-hparams="{{_dataLoadedWithNonEmptyHparams}}"
          data-loaded-with-empty-hparams="{{_dataLoadedWithEmptyHparams}}"
        >
        </tf-hparams-query-pane>
      </div>
      <div slot="content" class="center">
        <template is="dom-if" if="[[_dataLoadedWithEmptyHparams]]">
          <div class="no-data-warning">
            <h3>No hparams data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any hparams data to your event files.</li>
              <li>
                Event files are still being loaded (try reloading this page).
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>

        <template is="dom-if" if="[[_dataLoadedWithNonEmptyHparams]]">
          <tf-hparams-sessions-pane
            id="sessions-pane"
            backend="[[backend]]"
            help-url="[[helpUrl]]"
            bug-report-url="[[bugReportUrl]]"
            experiment-name="[[experimentName]]"
            configuration="[[_configuration]]"
            session-groups="[[_sessionGroups]]"
          >
          </tf-hparams-sessions-pane>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      hparams-split-layout {
        width: 100%;
      }

      .sidebar {
        width: 20%;
        height: 100%;
        overflow: auto;
        flex-grow: 0;
        flex-shrink: 0;
        min-width: 10%;
      }

      .center {
        height: 100%;
        overflow-y: auto;
        flex-grow: 1;
        flex-shrink: 1;
        width: 80%;
      }

      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
        width: 100%;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Object}),w("design:type",u3)],rh.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"experimentName",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"bugReportUrl",void 0);E([A({type:Object}),w("design:type",Object)],rh.prototype,"_configuration",void 0);E([A({type:Array}),w("design:type",Array)],rh.prototype,"_sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithEmptyHparams",void 0);rh=E([yt("tf-hparams-main")],rh);var phr=new URLSearchParams(window.location.search).get("tensorboardColab")==="true",lV=class extends Gt(mt){constructor(){super(...arguments),this._backend=new u3(new Ae,phr)}reload(){this.$["hparams-main"].reload()}};lV.template=Q`
    <!-- TensorBoard does not specify an experimentName. Currently it only
         supports one experiment per invocation. -->
    <tf-hparams-main
      id="hparams-main"
      backend="[[_backend]]"
      experiment-name=""
    >
    </tf-hparams-main>
  `;E([A({type:Object}),w("design:type",Object)],lV.prototype,"_backend",void 0);lV=E([yt("tf-hparams-dashboard")],lV);var d1=Ee(Oe(),1);var _n=class extends Gt(mt){constructor(){super(...arguments),this.actualSize=!1,this.brightnessAdjustment=.5,this.contrastPercentage=0,this._metadataCanceller=new an,this._imageCanceller=new an,this._steps=[],this._isImageLoading=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){var t=this._currentStep;return t?t.step:0}get _currentWallTime(){var t=this._currentStep;return t?s2(t.wall_time):""}get _maxStepIndex(){var t=this._steps;return t.length-1}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.ofSamples;return t>1}_getAriaExpanded(){return this.actualSize?"true":"false"}attached(){this.reload()}reload(){if(!this.isAttached)return;this._metadataCanceller.cancelAll();let t=new URLSearchParams({tag:this.tag,run:this.run,sample:this.sample}),r=_e().pluginRoute("images","/images",t),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",t.wall_time);let n=_e().pluginRouteForSrc("images","/individualImage",r);return{wall_time:new Date(t.wall_time*1e3),step:t.step,url:n}}_updateImageUrl(){var t=this._currentStep,r=this.brightnessAdjustment,n=this.contrastPercentage;if(!t)return;let i=new Image;this._imageCanceller.cancelAll(),i.onload=i.onerror=this._imageCanceller.cancellable(o=>{if(o.cancelled)return;let a=this.$$("#main-image-container");a&&(a.textContent="",zt(a).appendChild(i)),this.set("_isImageLoading",!1)}).bind(this),i.style.filter=`contrast(${n}%) `,i.style.filter+=`brightness(${r})`,this.set("_isImageLoading",!0),i.src=t.url}_handleTap(t){this.set("actualSize",!this.actualSize)}_toLocaleString(t){return t.toLocaleString()}};_n.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div>sample: [[_sampleText]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[_toLocaleString(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right datetime">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isImageLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>

    <!-- Semantically a button but <img> inside a <button> disallows user to do
    an interesting operation like "Copy Image" in non-Chromium browsers. -->
    <a
      id="main-image-container"
      role="button"
      aria-label="Toggle actual size"
      aria-expanded$="[[_getAriaExpanded(actualSize)]]"
      on-tap="_handleTap"
    ></a>

    <style include="tf-card-heading-style">
      /** Make button a div. */
      button {
        width: 100%;
        display: block;
        background: none;
        border: 0;
        padding: 0;
      }

      /** Firefox: Get rid of dotted line inside button. */
      button::-moz-focus-inner {
        border: 0;
        padding: 0;
      }

      /** Firefox: Simulate Chrome's outer glow on button when focused. */
      button:-moz-focusring {
        outline: none;
        box-shadow: 0px 0px 1px 2px Highlight;
      }

      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        margin: 0 15px 40px 0;
        overflow-x: auto;
      }

      /** When actual size shown is on, use the actual image width. */
      :host([actual-size]) {
        max-width: 100%;
        width: auto;
      }

      :host([actual-size]) #main-image-container {
        max-height: none;
        width: auto;
      }

      :host([actual-size]) #main-image-container img {
        width: auto;
      }

      paper-spinner-lite {
        width: 14px;
        height: 14px;
        vertical-align: text-bottom;
        --paper-spinner-color: var(--tb-orange-strong);
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        /*
         * 31 comes from adding a padding of 15px from both sides of the
         * paper-slider, subtracting 1px so that the slider width aligns
         * with the image (the last slider marker takes up 1px), and
         * adding 2px to account for a border of 1px on both sides of
         * the image. 30 - 1 + 2.
         */
        width: calc(100% + 31px);
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }

      #main-image-container {
        max-height: 1024px;
        overflow: auto;
      }

      #main-image-container img {
        cursor: pointer;
        display: block;
        image-rendering: -moz-crisp-edges;
        image-rendering: pixelated;
        width: 100%;
        height: auto;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],_n.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],_n.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"ofSamples",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"tagMetadata",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],_n.prototype,"actualSize",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"contrastPercentage",void 0);E([A({type:Object}),w("design:type",Ae)],_n.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_metadataCanceller",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_imageCanceller",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],_n.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],_n.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],_n.prototype,"_isImageLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSteps",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],_n.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_currentWallTime",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_maxStepIndex",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_sampleText",null);E([Rt("ofSamples"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"reload",null);E([Bt("_currentStep","brightnessAdjustment","contrastPercentage"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"_updateImageUrl",null);_n=E([yt("tf-image-loader")],_n);var Io=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._defaultBrightnessAdjustment=1,this._defaultContrastPercentage=100,this._brightnessAdjustment=1,this._contrastPercentage=100,this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadImages()})}_fetchTags(){let t=_e().pluginRoute("images","/tags");return this._requestManager.request(t).then(r=>{if(d1.isEqual(r,this._runToTagInfo))return;let n=d1.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadImages(){var t;(t=this.root)==null||t.querySelectorAll("tf-image-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment}_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage}get _brightnessIsDefault(){var t=this._brightnessAdjustment;return t===this._defaultBrightnessAdjustment}get _contrastIsDefault(){var t=this._contrastPercentage;return t===this._defaultContrastPercentage}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;let o=d1.mapValues(t,c=>Object.keys(c)),a=Ql(o,r,n);function s(c){let u=t[c.run][c.tag].samples;return d1.range(u).map(h=>Object.assign({},c,{sample:h,ofSamples:u}))}return a.map(c=>Object.assign({},c,{items:[].concat.apply([],c.items.map(s))}))}_tagMetadata(t,r,n){return t[r][n]}};Io.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_actualSize}}"
                >Show actual image size</paper-checkbox
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Brightness adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="2"
                snaps
                pin
                step="0.01"
                value="{{_brightnessAdjustment}}"
                immediate-value="{{_brightnessAdjustment}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetBrightness"
                disabled="[[_brightnessIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Contrast adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="500"
                snaps
                pin
                step="1"
                value="{{_contrastPercentage}}"
                immediate-value="{{_contrastPercentage}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetContrast"
                disabled="[[_contrastIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No image data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any image data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-image-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  actual-size="[[_actualSize]]"
                  brightness-adjustment="[[_brightnessAdjustment]]"
                  contrast-percentage="[[_contrastPercentage]]"
                ></tf-image-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .resettable-slider-container {
        display: flex;
      }
      .resettable-slider-container paper-slider {
        flex-grow: 1;
      }
      .resettable-slider-container paper-button {
        flex-grow: 0;
      }
      .resettable-slider-container paper-button[disabled] {
        background-color: unset;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],Io.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_dataNotFound",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_actualSize",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultBrightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultContrastPercentage",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_contrastPercentage",void 0);E([A({type:String}),w("design:type",String)],Io.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_requestManager",void 0);E([Rt("_brightnessAdjustment"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_brightnessIsDefault",null);E([Rt("_contrastPercentage"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_contrastIsDefault",null);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Io.prototype,"_categories",null);Io=E([yt("tf-image-dashboard")],Io);var lx=Ee(Oe(),1);var m1;(function(e){e[e.CANCELLED=1]="CANCELLED"})(m1||(m1={}));var cV;(function(e){e[e.VERTEX=1]="VERTEX",e[e.FACE=2]="FACE",e[e.COLOR=3]="COLOR"})(cV||(cV={}));var qct;(function(e){e.VERTEX="float32",e.FACE="int32",e.COLOR="uint8"})(qct||(qct={}));var IP=class{constructor(t){this._canceller=new an,this._requestManager=t}reload(t,r,n){return this._canceller.cancelAll(),this._fetchMetadata(t,r,n)}_fetchDataByStep(t,r,n,i,o,a){let s=_e().pluginRoute("mesh","/data",new URLSearchParams({tag:r,run:t,content_type:n,sample:String(i),step:String(o)})),l=function(u){let f=[];for(let p=0;p<u.length/3;p++){let d=[];for(let g=0;g<3;g++)d.push(u[p*3+g]);f.push(d)}return f},c=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:m1.CANCELLED,message:"Response was invalidated."});let h=u.value;switch(n){case"VERTEX":a.vertices=l(new Float32Array(h));break;case"FACE":a.faces=l(new Int32Array(h));break;case"COLOR":a.colors=l(new Uint8Array(h));break}return a});return this._requestManager.fetch(s,{method:"GET",headers:{responseType:"arraybuffer",contentType:qct[n]}}).then(u=>u.arrayBuffer()).then(c)}fetchData(t,r,n,i){let o=[],a=new Map;return Object.keys(cV).forEach(s=>{let l=1<<cV[s];t.components&l&&o.push(this._fetchDataByStep(r,n,s,i,t.step,a))}),Promise.all(o)}_fetchMetadata(t,r,n){this._canceller.cancelAll();let i=_e().pluginRoute("mesh","/meshes",new URLSearchParams({tag:r,run:t,sample:n})),o=this._canceller.cancellable(a=>a.cancelled?Promise.reject({code:m1.CANCELLED,message:"Response was invalidated."}):a.value);return this._requestManager.fetch(i).then(a=>a.json()).then(o).then(this._processMetadata.bind(this))}_processMetadata(t){if(!t)return;let r=new Map;for(let i=0;i<t.length;i++){let o=t[i];r.has(o.step)||r.set(o.step,[]),r.get(o.step).push(o)}let n=[];return r.forEach(i=>{let o=this._createStepDatum(i[0]);n.push(o)}),n}_createStepDatum(t){return{wall_time:new Date(t.wall_time*1e3),step:t.step,config:t.config,content_type:t.content_type,components:t.components}}};var wM={};Zs(wM,{ACESFilmicToneMapping:()=>pfe,AddEquation:()=>E1,AddOperation:()=>cfe,AdditiveAnimationBlendMode:()=>kht,AdditiveBlending:()=>Mut,AlphaFormat:()=>xfe,AlwaysDepth:()=>rfe,AlwaysStencilFunc:()=>Ofe,AmbientLight:()=>L6,AmbientLightProbe:()=>zU,AnimationClip:()=>tx,AnimationLoader:()=>oht,AnimationMixer:()=>VU,AnimationObjectGroup:()=>HU,AnimationUtils:()=>jn,ArcCurve:()=>l6,ArrayCamera:()=>n6,ArrowHelper:()=>Mht,Audio:()=>D6,AudioAnalyser:()=>FU,AudioContext:()=>zht,AudioListener:()=>cht,AudioLoader:()=>DU,AxesHelper:()=>vM,AxisHelper:()=>K0r,BackSide:()=>Ii,BasicDepthPacking:()=>Rfe,BasicShadowMap:()=>mhr,BinaryTextureLoader:()=>e_r,Bone:()=>sM,BooleanKeyframeTrack:()=>sm,BoundingBoxHelper:()=>Z0r,Box2:()=>K0,Box3:()=>ta,Box3Helper:()=>wht,BoxBufferGeometry:()=>tp,BoxGeometry:()=>tp,BoxHelper:()=>yM,BufferAttribute:()=>Je,BufferGeometry:()=>Pe,BufferGeometryLoader:()=>RU,ByteType:()=>mfe,Cache:()=>ex,Camera:()=>N1,CameraHelper:()=>bht,CanvasRenderer:()=>n_r,CanvasTexture:()=>xU,CatmullRomCurve3:()=>c6,CineonToneMapping:()=>ffe,CircleBufferGeometry:()=>B1,CircleGeometry:()=>B1,ClampToEdgeWrapping:()=>Jo,Clock:()=>mM,Color:()=>ne,ColorKeyframeTrack:()=>M6,CompressedTexture:()=>a6,CompressedTextureLoader:()=>aht,ConeBufferGeometry:()=>H1,ConeGeometry:()=>H1,CubeCamera:()=>J3,CubeReflectionMapping:()=>ix,CubeRefractionMapping:()=>ox,CubeTexture:()=>V0,CubeTextureLoader:()=>TU,CubeUVReflectionMapping:()=>xM,CubeUVRefractionMapping:()=>z6,CubicBezierCurve:()=>cM,CubicBezierCurve3:()=>u6,CubicInterpolant:()=>SU,CullFaceBack:()=>Sut,CullFaceFront:()=>Vhe,CullFaceFrontBack:()=>dhr,CullFaceNone:()=>Hhe,Curve:()=>ps,CurvePath:()=>wU,CustomBlending:()=>qhe,CustomToneMapping:()=>dfe,CylinderBufferGeometry:()=>am,CylinderGeometry:()=>am,Cylindrical:()=>mht,DataTexture:()=>Qd,DataTexture2DArray:()=>tM,DataTexture3D:()=>r6,DataTextureLoader:()=>CU,DataUtils:()=>Tht,DecrementStencilOp:()=>Thr,DecrementWrapStencilOp:()=>Ahr,DefaultLoadingManager:()=>ipe,DepthFormat:()=>F0,DepthStencilFormat:()=>R1,DepthTexture:()=>nM,DirectionalLight:()=>I6,DirectionalLightHelper:()=>xht,DiscreteInterpolant:()=>MU,DodecahedronBufferGeometry:()=>V1,DodecahedronGeometry:()=>V1,DoubleSide:()=>k1,DstAlphaFactor:()=>Khe,DstColorFactor:()=>Jhe,DynamicBufferAttribute:()=>H0r,DynamicCopyUsage:()=>Uhr,DynamicDrawUsage:()=>Y3,DynamicReadUsage:()=>Bhr,EdgesGeometry:()=>s6,EdgesHelper:()=>J0r,EllipseCurve:()=>U1,EqualDepth:()=>ife,EqualStencilFunc:()=>khr,EquirectangularReflectionMapping:()=>YP,EquirectangularRefractionMapping:()=>jP,Euler:()=>em,EventDispatcher:()=>qs,ExtrudeBufferGeometry:()=>hh,ExtrudeGeometry:()=>hh,FaceColors:()=>P0r,FileLoader:()=>Jc,FlatShading:()=>Aht,Float16BufferAttribute:()=>dU,Float32Attribute:()=>X0r,Float32BufferAttribute:()=>xe,Float64Attribute:()=>$0r,Float64BufferAttribute:()=>mU,FloatType:()=>Xd,Fog:()=>F1,FogExp2:()=>z1,Font:()=>u_r,FontLoader:()=>c_r,FramebufferTexture:()=>vU,FrontSide:()=>L1,Frustum:()=>D1,GLBufferAttribute:()=>qU,GLSL1:()=>Ghr,GLSL3:()=>Kut,GreaterDepth:()=>afe,GreaterEqualDepth:()=>ofe,GreaterEqualStencilFunc:()=>Ohr,GreaterStencilFunc:()=>Nhr,GridHelper:()=>YU,Group:()=>$d,HalfFloatType:()=>A1,HemisphereLight:()=>T6,HemisphereLightHelper:()=>yht,HemisphereLightProbe:()=>OU,IcosahedronBufferGeometry:()=>W1,IcosahedronGeometry:()=>W1,ImageBitmapLoader:()=>NU,ImageLoader:()=>rx,ImageUtils:()=>Zf,ImmediateRenderObject:()=>h_r,IncrementStencilOp:()=>Ehr,IncrementWrapStencilOp:()=>Chr,InstancedBufferAttribute:()=>nm,InstancedBufferGeometry:()=>N6,InstancedInterleavedBuffer:()=>UU,InstancedMesh:()=>i6,Int16Attribute:()=>G0r,Int16BufferAttribute:()=>fU,Int32Attribute:()=>Y0r,Int32BufferAttribute:()=>pU,Int8Attribute:()=>V0r,Int8BufferAttribute:()=>cU,IntType:()=>_fe,InterleavedBuffer:()=>rm,InterleavedBufferAttribute:()=>ep,Interpolant:()=>fh,InterpolateDiscrete:()=>KP,InterpolateLinear:()=>ZP,InterpolateSmooth:()=>rU,InvertStencilOp:()=>Phr,JSONLoader:()=>i_r,KeepStencilOp:()=>nU,KeyframeTrack:()=>Ol,LOD:()=>_U,LatheBufferGeometry:()=>Y1,LatheGeometry:()=>Y1,Layers:()=>X3,LensFlare:()=>a_r,LessDepth:()=>nfe,LessEqualDepth:()=>iU,LessEqualStencilFunc:()=>Rhr,LessStencilFunc:()=>Lhr,Light:()=>zl,LightProbe:()=>nx,Line:()=>ch,Line3:()=>GU,LineBasicMaterial:()=>Gi,LineCurve:()=>q1,LineCurve3:()=>bU,LineDashedMaterial:()=>w6,LineLoop:()=>o6,LinePieces:()=>C0r,LineSegments:()=>Pa,LineStrip:()=>T0r,LinearEncoding:()=>tm,LinearFilter:()=>ii,LinearInterpolant:()=>S6,LinearMipMapLinearFilter:()=>xhr,LinearMipMapNearestFilter:()=>vhr,LinearMipmapLinearFilter:()=>ax,LinearMipmapNearestFilter:()=>Lht,LinearToneMapping:()=>ufe,Loader:()=>ea,LoaderUtils:()=>dM,LoadingManager:()=>E6,LoopOnce:()=>Pfe,LoopPingPong:()=>Lfe,LoopRepeat:()=>Ife,LuminanceAlphaFormat:()=>wfe,LuminanceFormat:()=>bfe,MOUSE:()=>Z0,Material:()=>qi,MaterialLoader:()=>kU,Math:()=>ifr,MathUtils:()=>ifr,Matrix3:()=>ki,Matrix4:()=>Me,MaxEquation:()=>Aut,Mesh:()=>ti,MeshBasicMaterial:()=>sh,MeshDepthMaterial:()=>eM,MeshDistanceMaterial:()=>rM,MeshFaceMaterial:()=>L0r,MeshLambertMaterial:()=>x6,MeshMatcapMaterial:()=>b6,MeshNormalMaterial:()=>v6,MeshPhongMaterial:()=>_6,MeshPhysicalMaterial:()=>g6,MeshStandardMaterial:()=>pM,MeshToonMaterial:()=>y6,MinEquation:()=>Cut,MirroredRepeatWrapping:()=>$P,MixOperation:()=>lfe,MultiMaterial:()=>k0r,MultiplyBlending:()=>Tut,MultiplyOperation:()=>O6,NearestFilter:()=>Li,NearestMipMapLinearFilter:()=>yhr,NearestMipMapNearestFilter:()=>_hr,NearestMipmapLinearFilter:()=>aU,NearestMipmapNearestFilter:()=>oU,NeverDepth:()=>efe,NeverStencilFunc:()=>Ihr,NoBlending:()=>Kd,NoColors:()=>A0r,NoToneMapping:()=>Zd,NormalAnimationBlendMode:()=>$U,NormalBlending:()=>V3,NotEqualDepth:()=>sfe,NotEqualStencilFunc:()=>Dhr,NumberKeyframeTrack:()=>J1,Object3D:()=>or,ObjectLoader:()=>sht,ObjectSpaceNormalMap:()=>Dfe,OctahedronBufferGeometry:()=>Y0,OctahedronGeometry:()=>Y0,OneFactor:()=>jhe,OneMinusDstAlphaFactor:()=>Zhe,OneMinusDstColorFactor:()=>Qhe,OneMinusSrcAlphaFactor:()=>Iht,OneMinusSrcColorFactor:()=>$he,OrthographicCamera:()=>O1,PCFShadowMap:()=>Cht,PCFSoftShadowMap:()=>Uhe,PMREMGenerator:()=>e6,ParametricGeometry:()=>s_r,Particle:()=>N0r,ParticleBasicMaterial:()=>z0r,ParticleSystem:()=>D0r,ParticleSystemMaterial:()=>F0r,Path:()=>G1,PerspectiveCamera:()=>Ui,Plane:()=>$c,PlaneBufferGeometry:()=>U0,PlaneGeometry:()=>U0,PlaneHelper:()=>Sht,PointCloud:()=>R0r,PointCloudMaterial:()=>O0r,PointLight:()=>P6,PointLightHelper:()=>_ht,Points:()=>om,PointsMaterial:()=>im,PolarGridHelper:()=>vht,PolyhedronBufferGeometry:()=>uh,PolyhedronGeometry:()=>uh,PositionalAudio:()=>uht,PropertyBinding:()=>Cr,PropertyMixer:()=>BU,QuadraticBezierCurve:()=>uM,QuadraticBezierCurve3:()=>hM,Quaternion:()=>yi,QuaternionKeyframeTrack:()=>$0,QuaternionLinearInterpolant:()=>EU,REVISION:()=>jU,RGBADepthPacking:()=>Nfe,RGBAFormat:()=>Qo,RGBAIntegerFormat:()=>Cfe,RGBA_ASTC_10x10_Format:()=>Yut,RGBA_ASTC_10x5_Format:()=>qut,RGBA_ASTC_10x6_Format:()=>Gut,RGBA_ASTC_10x8_Format:()=>Wut,RGBA_ASTC_12x10_Format:()=>jut,RGBA_ASTC_12x12_Format:()=>Xut,RGBA_ASTC_4x4_Format:()=>Dut,RGBA_ASTC_5x4_Format:()=>Out,RGBA_ASTC_5x5_Format:()=>zut,RGBA_ASTC_6x5_Format:()=>Fut,RGBA_ASTC_6x6_Format:()=>But,RGBA_ASTC_8x5_Format:()=>Hut,RGBA_ASTC_8x6_Format:()=>Vut,RGBA_ASTC_8x8_Format:()=>Uut,RGBA_BPTC_Format:()=>$ut,RGBA_ETC2_EAC_Format:()=>Nut,RGBA_PVRTC_2BPPV1_Format:()=>kut,RGBA_PVRTC_4BPPV1_Format:()=>Lut,RGBA_S3TC_DXT1_Format:()=>QV,RGBA_S3TC_DXT3_Format:()=>tU,RGBA_S3TC_DXT5_Format:()=>eU,RGB_ETC1_Format:()=>Afe,RGB_ETC2_Format:()=>Rut,RGB_PVRTC_2BPPV1_Format:()=>Iut,RGB_PVRTC_4BPPV1_Format:()=>Put,RGB_S3TC_DXT1_Format:()=>JV,RGFormat:()=>Efe,RGIntegerFormat:()=>Tfe,RawShaderMaterial:()=>q0,Ray:()=>Qf,Raycaster:()=>pht,RectAreaLight:()=>k6,RedFormat:()=>Sfe,RedIntegerFormat:()=>Mfe,ReinhardToneMapping:()=>hfe,RepeatWrapping:()=>XP,ReplaceStencilOp:()=>Mhr,ReverseSubtractEquation:()=>Whe,RingBufferGeometry:()=>j1,RingGeometry:()=>j1,Scene:()=>G0,SceneUtils:()=>o_r,ShaderChunk:()=>hr,ShaderLib:()=>ah,ShaderMaterial:()=>lh,ShadowMaterial:()=>m6,Shape:()=>Kc,ShapeBufferGeometry:()=>j0,ShapeGeometry:()=>j0,ShapePath:()=>Eht,ShapeUtils:()=>Zc,ShortType:()=>gfe,Skeleton:()=>lM,SkeletonHelper:()=>WU,SkinnedMesh:()=>aM,SmoothShading:()=>ghr,Sphere:()=>Jf,SphereBufferGeometry:()=>X0,SphereGeometry:()=>X0,Spherical:()=>_M,SphericalHarmonics3:()=>R6,SplineCurve:()=>fM,SpotLight:()=>A6,SpotLightHelper:()=>ght,Sprite:()=>oM,SpriteMaterial:()=>iM,SrcAlphaFactor:()=>Pht,SrcAlphaSaturateFactor:()=>tfe,SrcColorFactor:()=>Xhe,StaticCopyUsage:()=>Vhr,StaticDrawUsage:()=>W3,StaticReadUsage:()=>Fhr,StereoCamera:()=>lht,StreamCopyUsage:()=>qhr,StreamDrawUsage:()=>zhr,StreamReadUsage:()=>Hhr,StringKeyframeTrack:()=>lm,SubtractEquation:()=>Ghe,SubtractiveBlending:()=>Eut,TOUCH:()=>J0,TangentSpaceNormalMap:()=>sx,TetrahedronBufferGeometry:()=>X1,TetrahedronGeometry:()=>X1,TextGeometry:()=>l_r,Texture:()=>vi,TextureLoader:()=>AU,TorusBufferGeometry:()=>$1,TorusGeometry:()=>$1,TorusKnotBufferGeometry:()=>K1,TorusKnotGeometry:()=>K1,Triangle:()=>oi,TriangleFanDrawMode:()=>whr,TriangleStripDrawMode:()=>bhr,TrianglesDrawMode:()=>kfe,TubeBufferGeometry:()=>Z1,TubeGeometry:()=>Z1,UVMapping:()=>XU,Uint16Attribute:()=>W0r,Uint16BufferAttribute:()=>$3,Uint32Attribute:()=>j0r,Uint32BufferAttribute:()=>K3,Uint8Attribute:()=>U0r,Uint8BufferAttribute:()=>uU,Uint8ClampedAttribute:()=>q0r,Uint8ClampedBufferAttribute:()=>hU,Uniform:()=>gM,UniformsLib:()=>re,UniformsUtils:()=>Vfe,UnsignedByteType:()=>Jd,UnsignedInt248Type:()=>P1,UnsignedIntType:()=>VP,UnsignedShort4444Type:()=>yfe,UnsignedShort5551Type:()=>vfe,UnsignedShortType:()=>G3,VSMShadowMap:()=>F3,Vector2:()=>Lt,Vector3:()=>j,Vector4:()=>en,VectorKeyframeTrack:()=>Q1,Vertex:()=>B0r,VertexColors:()=>I0r,VideoTexture:()=>yU,WebGL1Renderer:()=>gU,WebGLCubeRenderTarget:()=>Q3,WebGLMultipleRenderTargets:()=>lU,WebGLMultisampleRenderTarget:()=>j3,WebGLRenderTarget:()=>hs,WebGLRenderTargetCube:()=>r_r,WebGLRenderer:()=>rn,WebGLUtils:()=>Qfe,WireframeGeometry:()=>d6,WireframeHelper:()=>Q0r,WrapAroundEnding:()=>JP,XHRLoader:()=>t_r,ZeroCurvatureEnding:()=>T1,ZeroFactor:()=>Yhe,ZeroSlopeEnding:()=>C1,ZeroStencilOp:()=>Shr,_SRGBAFormat:()=>sU,sRGBEncoding:()=>Yn});var jU="137",Z0={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},J0={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},Hhe=0,Sut=1,Vhe=2,dhr=3,mhr=0,Cht=1,Uhe=2,F3=3,L1=0,Ii=1,k1=2,Aht=1,ghr=2,Kd=0,V3=1,Mut=2,Eut=3,Tut=4,qhe=5,E1=100,Ghe=101,Whe=102,Cut=103,Aut=104,Yhe=200,jhe=201,Xhe=202,$he=203,Pht=204,Iht=205,Khe=206,Zhe=207,Jhe=208,Qhe=209,tfe=210,efe=0,rfe=1,nfe=2,iU=3,ife=4,ofe=5,afe=6,sfe=7,O6=0,lfe=1,cfe=2,Zd=0,ufe=1,hfe=2,ffe=3,pfe=4,dfe=5,XU=300,ix=301,ox=302,YP=303,jP=304,xM=306,z6=307,XP=1e3,Jo=1001,$P=1002,Li=1003,oU=1004,_hr=1004,aU=1005,yhr=1005,ii=1006,Lht=1007,vhr=1007,ax=1008,xhr=1008,Jd=1009,mfe=1010,gfe=1011,G3=1012,_fe=1013,VP=1014,Xd=1015,A1=1016,yfe=1017,vfe=1018,P1=1020,xfe=1021,Qo=1023,bfe=1024,wfe=1025,F0=1026,R1=1027,Sfe=1028,Mfe=1029,Efe=1030,Tfe=1031,Cfe=1033,JV=33776,QV=33777,tU=33778,eU=33779,Put=35840,Iut=35841,Lut=35842,kut=35843,Afe=36196,Rut=37492,Nut=37496,Dut=37808,Out=37809,zut=37810,Fut=37811,But=37812,Hut=37813,Vut=37814,Uut=37815,qut=37816,Gut=37817,Wut=37818,Yut=37819,jut=37820,Xut=37821,$ut=36492,Pfe=2200,Ife=2201,Lfe=2202,KP=2300,ZP=2301,rU=2302,T1=2400,C1=2401,JP=2402,$U=2500,kht=2501,kfe=0,bhr=1,whr=2,tm=3e3,Yn=3001,Rfe=3200,Nfe=3201,sx=0,Dfe=1,Shr=0,nU=7680,Mhr=7681,Ehr=7682,Thr=7683,Chr=34055,Ahr=34056,Phr=5386,Ihr=512,Lhr=513,khr=514,Rhr=515,Nhr=516,Dhr=517,Ohr=518,Ofe=519,W3=35044,Y3=35048,zhr=35040,Fhr=35045,Bhr=35049,Hhr=35041,Vhr=35046,Uhr=35050,qhr=35042,Ghr="100",Kut="300 es",sU=1035,qs=class{addEventListener(t,r){this._listeners===void 0&&(this._listeners={});let n=this._listeners;n[t]===void 0&&(n[t]=[]),n[t].indexOf(r)===-1&&n[t].push(r)}hasEventListener(t,r){if(this._listeners===void 0)return!1;let n=this._listeners;return n[t]!==void 0&&n[t].indexOf(r)!==-1}removeEventListener(t,r){if(this._listeners===void 0)return;let i=this._listeners[t];if(i!==void 0){let o=i.indexOf(r);o!==-1&&i.splice(o,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let n=this._listeners[t.type];if(n!==void 0){t.target=this;let i=n.slice(0);for(let o=0,a=i.length;o<a;o++)i[o].call(this,t);t.target=null}}},Ko=[];for(let e=0;e<256;e++)Ko[e]=(e<16?"0":"")+e.toString(16);var uV=1234567,I1=Math.PI/180,QP=180/Math.PI;function Dl(){let e=Math.random()*4294967295|0,t=Math.random()*4294967295|0,r=Math.random()*4294967295|0,n=Math.random()*4294967295|0;return(Ko[e&255]+Ko[e>>8&255]+Ko[e>>16&255]+Ko[e>>24&255]+"-"+Ko[t&255]+Ko[t>>8&255]+"-"+Ko[t>>16&15|64]+Ko[t>>24&255]+"-"+Ko[r&63|128]+Ko[r>>8&255]+"-"+Ko[r>>16&255]+Ko[r>>24&255]+Ko[n&255]+Ko[n>>8&255]+Ko[n>>16&255]+Ko[n>>24&255]).toUpperCase()}function Zo(e,t,r){return Math.max(t,Math.min(r,e))}function Rht(e,t){return(e%t+t)%t}function Whr(e,t,r,n,i){return n+(e-t)*(i-n)/(r-t)}function Yhr(e,t,r){return e!==t?(r-e)/(t-e):0}function UP(e,t,r){return(1-r)*e+r*t}function jhr(e,t,r,n){return UP(e,t,1-Math.exp(-r*n))}function Xhr(e,t=1){return t-Math.abs(Rht(e,t*2)-t)}function $hr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*(3-2*e))}function Khr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*e*(e*(e*6-15)+10))}function Zhr(e,t){return e+Math.floor(Math.random()*(t-e+1))}function Jhr(e,t){return e+Math.random()*(t-e)}function Qhr(e){return e*(.5-Math.random())}function tfr(e){return e!==void 0&&(uV=e%2147483647),uV=uV*16807%2147483647,(uV-1)/2147483646}function efr(e){return e*I1}function rfr(e){return e*QP}function Zut(e){return(e&e-1)===0&&e!==0}function zfe(e){return Math.pow(2,Math.ceil(Math.log(e)/Math.LN2))}function Ffe(e){return Math.pow(2,Math.floor(Math.log(e)/Math.LN2))}function nfr(e,t,r,n,i){let o=Math.cos,a=Math.sin,s=o(r/2),l=a(r/2),c=o((t+n)/2),u=a((t+n)/2),h=o((t-n)/2),f=a((t-n)/2),p=o((n-t)/2),d=a((n-t)/2);switch(i){case"XYX":e.set(s*u,l*h,l*f,s*c);break;case"YZY":e.set(l*f,s*u,l*h,s*c);break;case"ZXZ":e.set(l*h,l*f,s*u,s*c);break;case"XZX":e.set(s*u,l*d,l*p,s*c);break;case"YXY":e.set(l*p,s*u,l*d,s*c);break;case"ZYZ":e.set(l*d,l*p,s*u,s*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+i)}}var ifr=Object.freeze({__proto__:null,DEG2RAD:I1,RAD2DEG:QP,generateUUID:Dl,clamp:Zo,euclideanModulo:Rht,mapLinear:Whr,inverseLerp:Yhr,lerp:UP,damp:jhr,pingpong:Xhr,smoothstep:$hr,smootherstep:Khr,randInt:Zhr,randFloat:Jhr,randFloatSpread:Qhr,seededRandom:tfr,degToRad:efr,radToDeg:rfr,isPowerOfTwo:Zut,ceilPowerOfTwo:zfe,floorPowerOfTwo:Ffe,setQuaternionFromProperEuler:nfr}),Lt=class{constructor(t=0,r=0){this.x=t,this.y=r}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,r){return this.x=t,this.y=r,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let r=this.x,n=this.y,i=t.elements;return this.x=i[0]*r+i[3]*n+i[6],this.y=i[1]*r+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y;return r*r+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this}rotateAround(t,r){let n=Math.cos(r),i=Math.sin(r),o=this.x-t.x,a=this.y-t.y;return this.x=o*n-a*i+t.x,this.y=o*i+a*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};Lt.prototype.isVector2=!0;var ki=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c){let u=this.elements;return u[0]=t,u[1]=i,u[2]=s,u[3]=r,u[4]=o,u[5]=l,u[6]=n,u[7]=a,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],this}extractBasis(t,r,n){return t.setFromMatrix3Column(this,0),r.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let r=t.elements;return this.set(r[0],r[4],r[8],r[1],r[5],r[9],r[2],r[6],r[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[3],l=n[6],c=n[1],u=n[4],h=n[7],f=n[2],p=n[5],d=n[8],g=i[0],_=i[3],y=i[6],x=i[1],b=i[4],S=i[7],C=i[2],P=i[5],k=i[8];return o[0]=a*g+s*x+l*C,o[3]=a*_+s*b+l*P,o[6]=a*y+s*S+l*k,o[1]=c*g+u*x+h*C,o[4]=c*_+u*b+h*P,o[7]=c*y+u*S+h*k,o[2]=f*g+p*x+d*C,o[5]=f*_+p*b+d*P,o[8]=f*y+p*S+d*k,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[3]*=t,r[6]*=t,r[1]*=t,r[4]*=t,r[7]*=t,r[2]*=t,r[5]*=t,r[8]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return r*a*u-r*s*c-n*o*u+n*s*l+i*o*c-i*a*l}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=u*a-s*c,f=s*l-u*o,p=c*o-a*l,d=r*h+n*f+i*p;if(d===0)return this.set(0,0,0,0,0,0,0,0,0);let g=1/d;return t[0]=h*g,t[1]=(i*c-u*n)*g,t[2]=(s*n-i*a)*g,t[3]=f*g,t[4]=(u*r-i*l)*g,t[5]=(i*o-s*r)*g,t[6]=p*g,t[7]=(n*l-c*r)*g,t[8]=(a*r-n*o)*g,this}transpose(){let t,r=this.elements;return t=r[1],r[1]=r[3],r[3]=t,t=r[2],r[2]=r[6],r[6]=t,t=r[5],r[5]=r[7],r[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let r=this.elements;return t[0]=r[0],t[1]=r[3],t[2]=r[6],t[3]=r[1],t[4]=r[4],t[5]=r[7],t[6]=r[2],t[7]=r[5],t[8]=r[8],this}setUvTransform(t,r,n,i,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(n*l,n*c,-n*(l*a+c*s)+a+t,-i*c,i*l,-i*(-c*a+l*s)+s+r,0,0,1),this}scale(t,r){let n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=r,n[4]*=r,n[7]*=r,this}rotate(t){let r=Math.cos(t),n=Math.sin(t),i=this.elements,o=i[0],a=i[3],s=i[6],l=i[1],c=i[4],u=i[7];return i[0]=r*o+n*l,i[3]=r*a+n*c,i[6]=r*s+n*u,i[1]=-n*o+r*l,i[4]=-n*a+r*c,i[7]=-n*s+r*u,this}translate(t,r){let n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=r*n[2],n[4]+=r*n[5],n[7]+=r*n[8],this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<9;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<9;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t}clone(){return new this.constructor().fromArray(this.elements)}};ki.prototype.isMatrix3=!0;function Bfe(e){for(let t=e.length-1;t>=0;--t)if(e[t]>65535)return!0;return!1}var ofr={Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};function B3(e,t){return new ofr[e](t)}function t6(e){return document.createElementNS("http://www.w3.org/1999/xhtml",e)}var Hfe={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},nh={h:0,s:0,l:0},hV={h:0,s:0,l:0};function Gct(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*6*(2/3-r):e}function U3(e){return e<.04045?e*.0773993808:Math.pow(e*.9478672986+.0521327014,2.4)}function Wct(e){return e<.0031308?e*12.92:1.055*Math.pow(e,.41666)-.055}var ne=class{constructor(t,r,n){return r===void 0&&n===void 0?this.set(t):this.setRGB(t,r,n)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,r,n){return this.r=t,this.g=r,this.b=n,this}setHSL(t,r,n){if(t=Rht(t,1),r=Zo(r,0,1),n=Zo(n,0,1),r===0)this.r=this.g=this.b=n;else{let i=n<=.5?n*(1+r):n+r-n*r,o=2*n-i;this.r=Gct(o,i,t+1/3),this.g=Gct(o,i,t),this.b=Gct(o,i,t-1/3)}return this}setStyle(t){function r(i){i!==void 0&&parseFloat(i)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let i,o=n[1],a=n[2];switch(o){case"rgb":case"rgba":if(i=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(i[1],10))/255,this.g=Math.min(255,parseInt(i[2],10))/255,this.b=Math.min(255,parseInt(i[3],10))/255,r(i[4]),this;if(i=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(i[1],10))/100,this.g=Math.min(100,parseInt(i[2],10))/100,this.b=Math.min(100,parseInt(i[3],10))/100,r(i[4]),this;break;case"hsl":case"hsla":if(i=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let s=parseFloat(i[1])/360,l=parseInt(i[2],10)/100,c=parseInt(i[3],10)/100;return r(i[4]),this.setHSL(s,l,c)}break}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){let i=n[1],o=i.length;if(o===3)return this.r=parseInt(i.charAt(0)+i.charAt(0),16)/255,this.g=parseInt(i.charAt(1)+i.charAt(1),16)/255,this.b=parseInt(i.charAt(2)+i.charAt(2),16)/255,this;if(o===6)return this.r=parseInt(i.charAt(0)+i.charAt(1),16)/255,this.g=parseInt(i.charAt(2)+i.charAt(3),16)/255,this.b=parseInt(i.charAt(4)+i.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let r=Hfe[t.toLowerCase()];return r!==void 0?this.setHex(r):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=U3(t.r),this.g=U3(t.g),this.b=U3(t.b),this}copyLinearToSRGB(t){return this.r=Wct(t.r),this.g=Wct(t.g),this.b=Wct(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let r=this.r,n=this.g,i=this.b,o=Math.max(r,n,i),a=Math.min(r,n,i),s,l,c=(a+o)/2;if(a===o)s=0,l=0;else{let u=o-a;switch(l=c<=.5?u/(o+a):u/(2-o-a),o){case r:s=(n-i)/u+(n<i?6:0);break;case n:s=(i-r)/u+2;break;case i:s=(r-n)/u+4;break}s/=6}return t.h=s,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,r,n){return this.getHSL(nh),nh.h+=t,nh.s+=r,nh.l+=n,this.setHSL(nh.h,nh.s,nh.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,r){return this.r=t.r+r.r,this.g=t.g+r.g,this.b=t.b+r.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,r){return this.r+=(t.r-this.r)*r,this.g+=(t.g-this.g)*r,this.b+=(t.b-this.b)*r,this}lerpColors(t,r,n){return this.r=t.r+(r.r-t.r)*n,this.g=t.g+(r.g-t.g)*n,this.b=t.b+(r.b-t.b)*n,this}lerpHSL(t,r){this.getHSL(nh),t.getHSL(hV);let n=UP(nh.h,hV.h,r),i=UP(nh.s,hV.s,r),o=UP(nh.l,hV.l,r);return this.setHSL(n,i,o),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,r=0){return this.r=t[r],this.g=t[r+1],this.b=t[r+2],this}toArray(t=[],r=0){return t[r]=this.r,t[r+1]=this.g,t[r+2]=this.b,t}fromBufferAttribute(t,r){return this.r=t.getX(r),this.g=t.getY(r),this.b=t.getZ(r),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ne.NAMES=Hfe;ne.prototype.isColor=!0;ne.prototype.r=1;ne.prototype.g=1;ne.prototype.b=1;var v3,Zf=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let r;if(t instanceof HTMLCanvasElement)r=t;else{v3===void 0&&(v3=t6("canvas")),v3.width=t.width,v3.height=t.height;let n=v3.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),r=v3}return r.width>2048||r.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),r.toDataURL("image/jpeg",.6)):r.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let r=t6("canvas");r.width=t.width,r.height=t.height;let n=r.getContext("2d");n.drawImage(t,0,0,t.width,t.height);let i=n.getImageData(0,0,t.width,t.height),o=i.data;for(let a=0;a<o.length;a++)o[a]=U3(o[a]/255)*255;return n.putImageData(i,0,0),r}else if(t.data){let r=t.data.slice(0);for(let n=0;n<r.length;n++)r instanceof Uint8Array||r instanceof Uint8ClampedArray?r[n]=Math.floor(U3(r[n]/255)*255):r[n]=U3(r[n]);return{data:r,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},afr=0,vi=class extends qs{constructor(t=vi.DEFAULT_IMAGE,r=vi.DEFAULT_MAPPING,n=Jo,i=Jo,o=ii,a=ax,s=Qo,l=Jd,c=1,u=tm){super(),Object.defineProperty(this,"id",{value:afr++}),this.uuid=Dl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=r,this.wrapS=n,this.wrapT=i,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new Lt(0,0),this.repeat=new Lt(1,1),this.center=new Lt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new ki,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let r=t===void 0||typeof t=="string";if(!r&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let i=this.image;if(i.uuid===void 0&&(i.uuid=Dl()),!r&&t.images[i.uuid]===void 0){let o;if(Array.isArray(i)){o=[];for(let a=0,s=i.length;a<s;a++)i[a].isDataTexture?o.push(Yct(i[a].image)):o.push(Yct(i[a]))}else o=Yct(i);t.images[i.uuid]={uuid:i.uuid,url:o}}n.image=i.uuid}return JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData),r||(t.textures[this.uuid]=n),n}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==XU)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case XP:t.x=t.x-Math.floor(t.x);break;case Jo:t.x=t.x<0?0:1;break;case $P:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case XP:t.y=t.y-Math.floor(t.y);break;case Jo:t.y=t.y<0?0:1;break;case $P:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};vi.DEFAULT_IMAGE=void 0;vi.DEFAULT_MAPPING=XU;vi.prototype.isTexture=!0;function Yct(e){return typeof HTMLImageElement!="undefined"&&e instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&e instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&e instanceof ImageBitmap?Zf.getDataURL(e):e.data?{data:Array.prototype.slice.call(e.data),width:e.width,height:e.height,type:e.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var en=class{constructor(t=0,r=0,n=0,i=1){this.x=t,this.y=r,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,r,n,i){return this.x=t,this.y=r,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;case 3:this.w=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this.w=t.w+r.w,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this.w+=t.w*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this.w=t.w-r.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=this.w,a=t.elements;return this.x=a[0]*r+a[4]*n+a[8]*i+a[12]*o,this.y=a[1]*r+a[5]*n+a[9]*i+a[13]*o,this.z=a[2]*r+a[6]*n+a[10]*i+a[14]*o,this.w=a[3]*r+a[7]*n+a[11]*i+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let r=Math.sqrt(1-t.w*t.w);return r<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/r,this.y=t.y/r,this.z=t.z/r),this}setAxisAngleFromRotationMatrix(t){let r,n,i,o,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],p=l[5],d=l[9],g=l[2],_=l[6],y=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-g)<.01&&Math.abs(d-_)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+g)<.1&&Math.abs(d+_)<.1&&Math.abs(c+p+y-3)<.1)return this.set(1,0,0,0),this;r=Math.PI;let b=(c+1)/2,S=(p+1)/2,C=(y+1)/2,P=(u+f)/4,k=(h+g)/4,O=(d+_)/4;return b>S&&b>C?b<.01?(n=0,i=.707106781,o=.707106781):(n=Math.sqrt(b),i=P/n,o=k/n):S>C?S<.01?(n=.707106781,i=0,o=.707106781):(i=Math.sqrt(S),n=P/i,o=O/i):C<.01?(n=.707106781,i=.707106781,o=0):(o=Math.sqrt(C),n=k/o,i=O/o),this.set(n,i,o,r),this}let x=Math.sqrt((_-d)*(_-d)+(h-g)*(h-g)+(f-u)*(f-u));return Math.abs(x)<.001&&(x=1),this.x=(_-d)/x,this.y=(h-g)/x,this.z=(f-u)/x,this.w=Math.acos((c+p+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this.w=Math.max(t.w,Math.min(r.w,this.w)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this.w=Math.max(t,Math.min(r,this.w)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this.w+=(t.w-this.w)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this.w=t.w+(r.w-t.w)*n,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this.w=t[r+3],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t[r+3]=this.w,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this.w=t.getW(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};en.prototype.isVector4=!0;var hs=class extends qs{constructor(t,r,n={}){super(),this.width=t,this.height=r,this.depth=1,this.scissor=new en(0,0,t,r),this.scissorTest=!1,this.viewport=new en(0,0,t,r),this.texture=new vi(void 0,n.mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:r,depth:1},this.texture.generateMipmaps=n.generateMipmaps!==void 0?n.generateMipmaps:!1,this.texture.internalFormat=n.internalFormat!==void 0?n.internalFormat:null,this.texture.minFilter=n.minFilter!==void 0?n.minFilter:ii,this.depthBuffer=n.depthBuffer!==void 0?n.depthBuffer:!0,this.stencilBuffer=n.stencilBuffer!==void 0?n.stencilBuffer:!1,this.depthTexture=n.depthTexture!==void 0?n.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,r,n=1){(this.width!==t||this.height!==r||this.depth!==n)&&(this.width=t,this.height=r,this.depth=n,this.texture.image.width=t,this.texture.image.height=r,this.texture.image.depth=n,this.dispose()),this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};hs.prototype.isWebGLRenderTarget=!0;var lU=class extends hs{constructor(t,r,n){super(t,r);let i=this.texture;this.texture=[];for(let o=0;o<n;o++)this.texture[o]=i.clone()}setSize(t,r,n=1){if(this.width!==t||this.height!==r||this.depth!==n){this.width=t,this.height=r,this.depth=n;for(let i=0,o=this.texture.length;i<o;i++)this.texture[i].image.width=t,this.texture[i].image.height=r,this.texture[i].image.depth=n;this.dispose()}return this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let r=0,n=t.texture.length;r<n;r++)this.texture[r]=t.texture[r].clone();return this}};lU.prototype.isWebGLMultipleRenderTargets=!0;var j3=class extends hs{constructor(t,r,n={}){super(t,r,n),this.samples=4,this.ignoreDepthForMultisampleCopy=n.ignoreDepth!==void 0?n.ignoreDepth:!0,this.useRenderToTexture=n.useRenderToTexture!==void 0?n.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};j3.prototype.isWebGLMultisampleRenderTarget=!0;var yi=class{constructor(t=0,r=0,n=0,i=1){this._x=t,this._y=r,this._z=n,this._w=i}static slerp(t,r,n,i){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),n.slerpQuaternions(t,r,i)}static slerpFlat(t,r,n,i,o,a,s){let l=n[i+0],c=n[i+1],u=n[i+2],h=n[i+3],f=o[a+0],p=o[a+1],d=o[a+2],g=o[a+3];if(s===0){t[r+0]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h;return}if(s===1){t[r+0]=f,t[r+1]=p,t[r+2]=d,t[r+3]=g;return}if(h!==g||l!==f||c!==p||u!==d){let _=1-s,y=l*f+c*p+u*d+h*g,x=y>=0?1:-1,b=1-y*y;if(b>Number.EPSILON){let C=Math.sqrt(b),P=Math.atan2(C,y*x);_=Math.sin(_*P)/C,s=Math.sin(s*P)/C}let S=s*x;if(l=l*_+f*S,c=c*_+p*S,u=u*_+d*S,h=h*_+g*S,_===1-s){let C=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=C,c*=C,u*=C,h*=C}}t[r]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h}static multiplyQuaternionsFlat(t,r,n,i,o,a){let s=n[i],l=n[i+1],c=n[i+2],u=n[i+3],h=o[a],f=o[a+1],p=o[a+2],d=o[a+3];return t[r]=s*d+u*h+l*p-c*f,t[r+1]=l*d+u*f+c*h-s*p,t[r+2]=c*d+u*p+s*f-l*h,t[r+3]=u*d-s*h-l*f-c*p,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,r,n,i){return this._x=t,this._y=r,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,r){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let n=t._x,i=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(n/2),u=s(i/2),h=s(o/2),f=l(n/2),p=l(i/2),d=l(o/2);switch(a){case"XYZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"YXZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"ZXY":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"ZYX":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"YZX":this._x=f*u*h+c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h-f*p*d;break;case"XZY":this._x=f*u*h-c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h+f*p*d;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return r!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,r){let n=r/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){let r=t.elements,n=r[0],i=r[4],o=r[8],a=r[1],s=r[5],l=r[9],c=r[2],u=r[6],h=r[10],f=n+s+h;if(f>0){let p=.5/Math.sqrt(f+1);this._w=.25/p,this._x=(u-l)*p,this._y=(o-c)*p,this._z=(a-i)*p}else if(n>s&&n>h){let p=2*Math.sqrt(1+n-s-h);this._w=(u-l)/p,this._x=.25*p,this._y=(i+a)/p,this._z=(o+c)/p}else if(s>h){let p=2*Math.sqrt(1+s-n-h);this._w=(o-c)/p,this._x=(i+a)/p,this._y=.25*p,this._z=(l+u)/p}else{let p=2*Math.sqrt(1+h-n-s);this._w=(a-i)/p,this._x=(o+c)/p,this._y=(l+u)/p,this._z=.25*p}return this._onChangeCallback(),this}setFromUnitVectors(t,r){let n=t.dot(r)+1;return n<Number.EPSILON?(n=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*r.z-t.z*r.y,this._y=t.z*r.x-t.x*r.z,this._z=t.x*r.y-t.y*r.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Zo(this.dot(t),-1,1)))}rotateTowards(t,r){let n=this.angleTo(t);if(n===0)return this;let i=Math.min(1,r/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,r){return r!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,r)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,r){let n=t._x,i=t._y,o=t._z,a=t._w,s=r._x,l=r._y,c=r._z,u=r._w;return this._x=n*u+a*s+i*c-o*l,this._y=i*u+a*l+o*s-n*c,this._z=o*u+a*c+n*l-i*s,this._w=a*u-n*s-i*l-o*c,this._onChangeCallback(),this}slerp(t,r){if(r===0)return this;if(r===1)return this.copy(t);let n=this._x,i=this._y,o=this._z,a=this._w,s=a*t._w+n*t._x+i*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=n,this._y=i,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let p=1-r;return this._w=p*a+r*this._w,this._x=p*n+r*this._x,this._y=p*i+r*this._y,this._z=p*o+r*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,s),h=Math.sin((1-r)*u)/c,f=Math.sin(r*u)/c;return this._w=a*h+this._w*f,this._x=n*h+this._x*f,this._y=i*h+this._y*f,this._z=o*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,r,n){return this.copy(t).slerp(r,n)}random(){let t=Math.random(),r=Math.sqrt(1-t),n=Math.sqrt(t),i=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(r*Math.cos(i),n*Math.sin(o),n*Math.cos(o),r*Math.sin(i))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,r=0){return this._x=t[r],this._y=t[r+1],this._z=t[r+2],this._w=t[r+3],this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._w,t}fromBufferAttribute(t,r){return this._x=t.getX(r),this._y=t.getY(r),this._z=t.getZ(r),this._w=t.getW(r),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};yi.prototype.isQuaternion=!0;var j=class{constructor(t=0,r=0,n=0){this.x=t,this.y=r,this.z=n}set(t,r,n){return n===void 0&&(n=this.z),this.x=t,this.y=r,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,r)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,r){return this.x=t.x*r.x,this.y=t.y*r.y,this.z=t.z*r.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(yue.setFromEuler(t))}applyAxisAngle(t,r){return this.applyQuaternion(yue.setFromAxisAngle(t,r))}applyMatrix3(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[3]*n+o[6]*i,this.y=o[1]*r+o[4]*n+o[7]*i,this.z=o[2]*r+o[5]*n+o[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=t.elements,a=1/(o[3]*r+o[7]*n+o[11]*i+o[15]);return this.x=(o[0]*r+o[4]*n+o[8]*i+o[12])*a,this.y=(o[1]*r+o[5]*n+o[9]*i+o[13])*a,this.z=(o[2]*r+o[6]*n+o[10]*i+o[14])*a,this}applyQuaternion(t){let r=this.x,n=this.y,i=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*r+a*i-s*n,u=l*n+s*r-o*i,h=l*i+o*n-a*r,f=-o*r-a*n-s*i;return this.x=c*l+f*-o+u*-s-h*-a,this.y=u*l+f*-a+h*-o-c*-s,this.z=h*l+f*-s+c*-a-u*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[4]*n+o[8]*i,this.y=o[1]*r+o[5]*n+o[9]*i,this.z=o[2]*r+o[6]*n+o[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this}cross(t,r){return r!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,r)):this.crossVectors(this,t)}crossVectors(t,r){let n=t.x,i=t.y,o=t.z,a=r.x,s=r.y,l=r.z;return this.x=i*l-o*s,this.y=o*a-n*l,this.z=n*s-i*a,this}projectOnVector(t){let r=t.lengthSq();if(r===0)return this.set(0,0,0);let n=t.dot(this)/r;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return jct.copy(this).projectOnVector(t),this.sub(jct)}reflect(t){return this.sub(jct.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let r=Math.sqrt(this.lengthSq()*t.lengthSq());if(r===0)return Math.PI/2;let n=this.dot(t)/r;return Math.acos(Zo(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return r*r+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,r,n){let i=Math.sin(r)*t;return this.x=i*Math.sin(n),this.y=Math.cos(r)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,r,n){return this.x=t*Math.sin(r),this.y=n,this.z=t*Math.cos(r),this}setFromMatrixPosition(t){let r=t.elements;return this.x=r[12],this.y=r[13],this.z=r[14],this}setFromMatrixScale(t){let r=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=r,this.y=n,this.z=i,this}setFromMatrixColumn(t,r){return this.fromArray(t.elements,r*4)}setFromMatrix3Column(t,r){return this.fromArray(t.elements,r*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,r=Math.random()*Math.PI*2,n=Math.sqrt(1-TI(t,2));return this.x=n*Math.cos(r),this.y=n*Math.sin(r),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};j.prototype.isVector3=!0;var jct=new j,yue=new yi,ta=class{constructor(t=new j(1/0,1/0,1/0),r=new j(-1/0,-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromArray(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromBufferAttribute(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=g1.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}setFromObject(t,r=!1){return this.makeEmpty(),this.expandByObject(t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,r=!1){t.updateWorldMatrix(!1,!1);let n=t.geometry;if(n!==void 0)if(r&&n.attributes!=null&&n.attributes.position!==void 0){let o=n.attributes.position;for(let a=0,s=o.count;a<s;a++)g1.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(g1)}else n.boundingBox===null&&n.computeBoundingBox(),Xct.copy(n.boundingBox),Xct.applyMatrix4(t.matrixWorld),this.union(Xct);let i=t.children;for(let o=0,a=i.length;o<a;o++)this.expandByObject(i[o],r);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,g1),g1.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let r,n;return t.normal.x>0?(r=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(r=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(r+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(r+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(r+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(r+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),r<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(LP),fV.subVectors(this.max,LP),x3.subVectors(t.a,LP),b3.subVectors(t.b,LP),w3.subVectors(t.c,LP),I0.subVectors(b3,x3),L0.subVectors(w3,b3),_1.subVectors(x3,w3);let r=[0,-I0.z,I0.y,0,-L0.z,L0.y,0,-_1.z,_1.y,I0.z,0,-I0.x,L0.z,0,-L0.x,_1.z,0,-_1.x,-I0.y,I0.x,0,-L0.y,L0.x,0,-_1.y,_1.x,0];return!$ct(r,x3,b3,w3,fV)||(r=[1,0,0,0,1,0,0,0,1],!$ct(r,x3,b3,w3,fV))?!1:(pV.crossVectors(I0,L0),r=[pV.x,pV.y,pV.z],$ct(r,x3,b3,w3,fV))}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return g1.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(g1).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(Ud[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Ud[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Ud[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Ud[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Ud[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Ud[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Ud[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Ud[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Ud),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};ta.prototype.isBox3=!0;var Ud=[new j,new j,new j,new j,new j,new j,new j,new j],g1=new j,Xct=new ta,x3=new j,b3=new j,w3=new j,I0=new j,L0=new j,_1=new j,LP=new j,fV=new j,pV=new j,y1=new j;function $ct(e,t,r,n,i){for(let o=0,a=e.length-3;o<=a;o+=3){y1.fromArray(e,o);let s=i.x*Math.abs(y1.x)+i.y*Math.abs(y1.y)+i.z*Math.abs(y1.z),l=t.dot(y1),c=r.dot(y1),u=n.dot(y1);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>s)return!1}return!0}var sfr=new ta,vue=new j,dV=new j,Kct=new j,Jf=class{constructor(t=new j,r=-1){this.center=t,this.radius=r}set(t,r){return this.center.copy(t),this.radius=r,this}setFromPoints(t,r){let n=this.center;r!==void 0?n.copy(r):sfr.setFromPoints(t).getCenter(n);let i=0;for(let o=0,a=t.length;o<a;o++)i=Math.max(i,n.distanceToSquared(t[o]));return this.radius=Math.sqrt(i),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let r=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=r*r}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,r){let n=this.center.distanceToSquared(t);return r.copy(t),n>this.radius*this.radius&&(r.sub(this.center).normalize(),r.multiplyScalar(this.radius).add(this.center)),r}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Kct.subVectors(t,this.center);let r=Kct.lengthSq();if(r>this.radius*this.radius){let n=Math.sqrt(r),i=(n-this.radius)*.5;this.center.add(Kct.multiplyScalar(i/n)),this.radius+=i}return this}union(t){return this.center.equals(t.center)===!0?dV.set(0,0,1).multiplyScalar(t.radius):dV.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(vue.copy(t.center).add(dV)),this.expandByPoint(vue.copy(t.center).sub(dV)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},qd=new j,Zct=new j,mV=new j,k0=new j,Jct=new j,gV=new j,Qct=new j,Qf=class{constructor(t=new j,r=new j(0,0,-1)){this.origin=t,this.direction=r}set(t,r){return this.origin.copy(t),this.direction.copy(r),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,r){return r.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,qd)),this}closestPointToPoint(t,r){r.subVectors(t,this.origin);let n=r.dot(this.direction);return n<0?r.copy(this.origin):r.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let r=qd.subVectors(t,this.origin).dot(this.direction);return r<0?this.origin.distanceToSquared(t):(qd.copy(this.direction).multiplyScalar(r).add(this.origin),qd.distanceToSquared(t))}distanceSqToSegment(t,r,n,i){Zct.copy(t).add(r).multiplyScalar(.5),mV.copy(r).sub(t).normalize(),k0.copy(this.origin).sub(Zct);let o=t.distanceTo(r)*.5,a=-this.direction.dot(mV),s=k0.dot(this.direction),l=-k0.dot(mV),c=k0.lengthSq(),u=Math.abs(1-a*a),h,f,p,d;if(u>0)if(h=a*l-s,f=a*s-l,d=o*u,h>=0)if(f>=-d)if(f<=d){let g=1/u;h*=g,f*=g,p=h*(h+a*f+2*s)+f*(a*h+f+2*l)+c}else f=o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f=-o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f<=-d?(h=Math.max(0,-(-a*o+s)),f=h>0?-o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c):f<=d?(h=0,f=Math.min(Math.max(-o,-l),o),p=f*(f+2*l)+c):(h=Math.max(0,-(a*o+s)),f=h>0?o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c);else f=a>0?-o:o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;return n&&n.copy(this.direction).multiplyScalar(h).add(this.origin),i&&i.copy(mV).multiplyScalar(f).add(Zct),p}intersectSphere(t,r){qd.subVectors(t.center,this.origin);let n=qd.dot(this.direction),i=qd.dot(qd)-n*n,o=t.radius*t.radius;if(i>o)return null;let a=Math.sqrt(o-i),s=n-a,l=n+a;return s<0&&l<0?null:s<0?this.at(l,r):this.at(s,r)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let r=t.normal.dot(this.direction);if(r===0)return t.distanceToPoint(this.origin)===0?0:null;let n=-(this.origin.dot(t.normal)+t.constant)/r;return n>=0?n:null}intersectPlane(t,r){let n=this.distanceToPlane(t);return n===null?null:this.at(n,r)}intersectsPlane(t){let r=t.distanceToPoint(this.origin);return r===0||t.normal.dot(this.direction)*r<0}intersectBox(t,r){let n,i,o,a,s,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(n=(t.min.x-f.x)*c,i=(t.max.x-f.x)*c):(n=(t.max.x-f.x)*c,i=(t.min.x-f.x)*c),u>=0?(o=(t.min.y-f.y)*u,a=(t.max.y-f.y)*u):(o=(t.max.y-f.y)*u,a=(t.min.y-f.y)*u),n>a||o>i||((o>n||n!==n)&&(n=o),(a<i||i!==i)&&(i=a),h>=0?(s=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(s=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),n>l||s>i)||((s>n||n!==n)&&(n=s),(l<i||i!==i)&&(i=l),i<0)?null:this.at(n>=0?n:i,r)}intersectsBox(t){return this.intersectBox(t,qd)!==null}intersectTriangle(t,r,n,i,o){Jct.subVectors(r,t),gV.subVectors(n,t),Qct.crossVectors(Jct,gV);let a=this.direction.dot(Qct),s;if(a>0){if(i)return null;s=1}else if(a<0)s=-1,a=-a;else return null;k0.subVectors(this.origin,t);let l=s*this.direction.dot(gV.crossVectors(k0,gV));if(l<0)return null;let c=s*this.direction.dot(Jct.cross(k0));if(c<0||l+c>a)return null;let u=-s*k0.dot(Qct);return u<0?null:this.at(u/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},Me=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c,u,h,f,p,d,g,_){let y=this.elements;return y[0]=t,y[4]=r,y[8]=n,y[12]=i,y[1]=o,y[5]=a,y[9]=s,y[13]=l,y[2]=c,y[6]=u,y[10]=h,y[14]=f,y[3]=p,y[7]=d,y[11]=g,y[15]=_,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new Me().fromArray(this.elements)}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],r[9]=n[9],r[10]=n[10],r[11]=n[11],r[12]=n[12],r[13]=n[13],r[14]=n[14],r[15]=n[15],this}copyPosition(t){let r=this.elements,n=t.elements;return r[12]=n[12],r[13]=n[13],r[14]=n[14],this}setFromMatrix3(t){let r=t.elements;return this.set(r[0],r[3],r[6],0,r[1],r[4],r[7],0,r[2],r[5],r[8],0,0,0,0,1),this}extractBasis(t,r,n){return t.setFromMatrixColumn(this,0),r.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,r,n){return this.set(t.x,r.x,n.x,0,t.y,r.y,n.y,0,t.z,r.z,n.z,0,0,0,0,1),this}extractRotation(t){let r=this.elements,n=t.elements,i=1/S3.setFromMatrixColumn(t,0).length(),o=1/S3.setFromMatrixColumn(t,1).length(),a=1/S3.setFromMatrixColumn(t,2).length();return r[0]=n[0]*i,r[1]=n[1]*i,r[2]=n[2]*i,r[3]=0,r[4]=n[4]*o,r[5]=n[5]*o,r[6]=n[6]*o,r[7]=0,r[8]=n[8]*a,r[9]=n[9]*a,r[10]=n[10]*a,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let r=this.elements,n=t.x,i=t.y,o=t.z,a=Math.cos(n),s=Math.sin(n),l=Math.cos(i),c=Math.sin(i),u=Math.cos(o),h=Math.sin(o);if(t.order==="XYZ"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=-l*h,r[8]=c,r[1]=p+d*c,r[5]=f-g*c,r[9]=-s*l,r[2]=g-f*c,r[6]=d+p*c,r[10]=a*l}else if(t.order==="YXZ"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f+g*s,r[4]=d*s-p,r[8]=a*c,r[1]=a*h,r[5]=a*u,r[9]=-s,r[2]=p*s-d,r[6]=g+f*s,r[10]=a*l}else if(t.order==="ZXY"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f-g*s,r[4]=-a*h,r[8]=d+p*s,r[1]=p+d*s,r[5]=a*u,r[9]=g-f*s,r[2]=-a*c,r[6]=s,r[10]=a*l}else if(t.order==="ZYX"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=d*c-p,r[8]=f*c+g,r[1]=l*h,r[5]=g*c+f,r[9]=p*c-d,r[2]=-c,r[6]=s*l,r[10]=a*l}else if(t.order==="YZX"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=g-f*h,r[8]=d*h+p,r[1]=h,r[5]=a*u,r[9]=-s*u,r[2]=-c*u,r[6]=p*h+d,r[10]=f-g*h}else if(t.order==="XZY"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=-h,r[8]=c*u,r[1]=f*h+g,r[5]=a*u,r[9]=p*h-d,r[2]=d*h-p,r[6]=s*u,r[10]=g*h+f}return r[3]=0,r[7]=0,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromQuaternion(t){return this.compose(lfr,t,cfr)}lookAt(t,r,n){let i=this.elements;return Rl.subVectors(t,r),Rl.lengthSq()===0&&(Rl.z=1),Rl.normalize(),R0.crossVectors(n,Rl),R0.lengthSq()===0&&(Math.abs(n.z)===1?Rl.x+=1e-4:Rl.z+=1e-4,Rl.normalize(),R0.crossVectors(n,Rl)),R0.normalize(),_V.crossVectors(Rl,R0),i[0]=R0.x,i[4]=_V.x,i[8]=Rl.x,i[1]=R0.y,i[5]=_V.y,i[9]=Rl.y,i[2]=R0.z,i[6]=_V.z,i[10]=Rl.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,r)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[4],l=n[8],c=n[12],u=n[1],h=n[5],f=n[9],p=n[13],d=n[2],g=n[6],_=n[10],y=n[14],x=n[3],b=n[7],S=n[11],C=n[15],P=i[0],k=i[4],O=i[8],D=i[12],B=i[1],I=i[5],L=i[9],R=i[13],F=i[2],z=i[6],U=i[10],W=i[14],Z=i[3],rt=i[7],ot=i[11],st=i[15];return o[0]=a*P+s*B+l*F+c*Z,o[4]=a*k+s*I+l*z+c*rt,o[8]=a*O+s*L+l*U+c*ot,o[12]=a*D+s*R+l*W+c*st,o[1]=u*P+h*B+f*F+p*Z,o[5]=u*k+h*I+f*z+p*rt,o[9]=u*O+h*L+f*U+p*ot,o[13]=u*D+h*R+f*W+p*st,o[2]=d*P+g*B+_*F+y*Z,o[6]=d*k+g*I+_*z+y*rt,o[10]=d*O+g*L+_*U+y*ot,o[14]=d*D+g*R+_*W+y*st,o[3]=x*P+b*B+S*F+C*Z,o[7]=x*k+b*I+S*z+C*rt,o[11]=x*O+b*L+S*U+C*ot,o[15]=x*D+b*R+S*W+C*st,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[4]*=t,r[8]*=t,r[12]*=t,r[1]*=t,r[5]*=t,r[9]*=t,r[13]*=t,r[2]*=t,r[6]*=t,r[10]*=t,r[14]*=t,r[3]*=t,r[7]*=t,r[11]*=t,r[15]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[4],i=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],p=t[14],d=t[3],g=t[7],_=t[11],y=t[15];return d*(+o*l*h-i*c*h-o*s*f+n*c*f+i*s*p-n*l*p)+g*(+r*l*p-r*c*f+o*a*f-i*a*p+i*c*u-o*l*u)+_*(+r*c*h-r*s*p-o*a*h+n*a*p+o*s*u-n*c*u)+y*(-i*s*u-r*l*h+r*s*f+i*a*h-n*a*f+n*l*u)}transpose(){let t=this.elements,r;return r=t[1],t[1]=t[4],t[4]=r,r=t[2],t[2]=t[8],t[8]=r,r=t[6],t[6]=t[9],t[9]=r,r=t[3],t[3]=t[12],t[12]=r,r=t[7],t[7]=t[13],t[13]=r,r=t[11],t[11]=t[14],t[14]=r,this}setPosition(t,r,n){let i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=r,i[14]=n),this}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],p=t[11],d=t[12],g=t[13],_=t[14],y=t[15],x=h*_*c-g*f*c+g*l*p-s*_*p-h*l*y+s*f*y,b=d*f*c-u*_*c-d*l*p+a*_*p+u*l*y-a*f*y,S=u*g*c-d*h*c+d*s*p-a*g*p-u*s*y+a*h*y,C=d*h*l-u*g*l-d*s*f+a*g*f+u*s*_-a*h*_,P=r*x+n*b+i*S+o*C;if(P===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let k=1/P;return t[0]=x*k,t[1]=(g*f*o-h*_*o-g*i*p+n*_*p+h*i*y-n*f*y)*k,t[2]=(s*_*o-g*l*o+g*i*c-n*_*c-s*i*y+n*l*y)*k,t[3]=(h*l*o-s*f*o-h*i*c+n*f*c+s*i*p-n*l*p)*k,t[4]=b*k,t[5]=(u*_*o-d*f*o+d*i*p-r*_*p-u*i*y+r*f*y)*k,t[6]=(d*l*o-a*_*o-d*i*c+r*_*c+a*i*y-r*l*y)*k,t[7]=(a*f*o-u*l*o+u*i*c-r*f*c-a*i*p+r*l*p)*k,t[8]=S*k,t[9]=(d*h*o-u*g*o-d*n*p+r*g*p+u*n*y-r*h*y)*k,t[10]=(a*g*o-d*s*o+d*n*c-r*g*c-a*n*y+r*s*y)*k,t[11]=(u*s*o-a*h*o-u*n*c+r*h*c+a*n*p-r*s*p)*k,t[12]=C*k,t[13]=(u*g*i-d*h*i+d*n*f-r*g*f-u*n*_+r*h*_)*k,t[14]=(d*s*i-a*g*i-d*n*l+r*g*l+a*n*_-r*s*_)*k,t[15]=(a*h*i-u*s*i+u*n*l-r*h*l-a*n*f+r*s*f)*k,this}scale(t){let r=this.elements,n=t.x,i=t.y,o=t.z;return r[0]*=n,r[4]*=i,r[8]*=o,r[1]*=n,r[5]*=i,r[9]*=o,r[2]*=n,r[6]*=i,r[10]*=o,r[3]*=n,r[7]*=i,r[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements,r=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(r,n,i))}makeTranslation(t,r,n){return this.set(1,0,0,t,0,1,0,r,0,0,1,n,0,0,0,1),this}makeRotationX(t){let r=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,r,-n,0,0,n,r,0,0,0,0,1),this}makeRotationY(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,0,n,0,0,1,0,0,-n,0,r,0,0,0,0,1),this}makeRotationZ(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,-n,0,0,n,r,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,r){let n=Math.cos(r),i=Math.sin(r),o=1-n,a=t.x,s=t.y,l=t.z,c=o*a,u=o*s;return this.set(c*a+n,c*s-i*l,c*l+i*s,0,c*s+i*l,u*s+n,u*l-i*a,0,c*l-i*s,u*l+i*a,o*l*l+n,0,0,0,0,1),this}makeScale(t,r,n){return this.set(t,0,0,0,0,r,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,r,n,i,o,a){return this.set(1,n,o,0,t,1,a,0,r,i,1,0,0,0,0,1),this}compose(t,r,n){let i=this.elements,o=r._x,a=r._y,s=r._z,l=r._w,c=o+o,u=a+a,h=s+s,f=o*c,p=o*u,d=o*h,g=a*u,_=a*h,y=s*h,x=l*c,b=l*u,S=l*h,C=n.x,P=n.y,k=n.z;return i[0]=(1-(g+y))*C,i[1]=(p+S)*C,i[2]=(d-b)*C,i[3]=0,i[4]=(p-S)*P,i[5]=(1-(f+y))*P,i[6]=(_+x)*P,i[7]=0,i[8]=(d+b)*k,i[9]=(_-x)*k,i[10]=(1-(f+g))*k,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,r,n){let i=this.elements,o=S3.set(i[0],i[1],i[2]).length(),a=S3.set(i[4],i[5],i[6]).length(),s=S3.set(i[8],i[9],i[10]).length();this.determinant()<0&&(o=-o),t.x=i[12],t.y=i[13],t.z=i[14],ih.copy(this);let c=1/o,u=1/a,h=1/s;return ih.elements[0]*=c,ih.elements[1]*=c,ih.elements[2]*=c,ih.elements[4]*=u,ih.elements[5]*=u,ih.elements[6]*=u,ih.elements[8]*=h,ih.elements[9]*=h,ih.elements[10]*=h,r.setFromRotationMatrix(ih),n.x=o,n.y=a,n.z=s,this}makePerspective(t,r,n,i,o,a){a===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,l=2*o/(r-t),c=2*o/(n-i),u=(r+t)/(r-t),h=(n+i)/(n-i),f=-(a+o)/(a-o),p=-2*a*o/(a-o);return s[0]=l,s[4]=0,s[8]=u,s[12]=0,s[1]=0,s[5]=c,s[9]=h,s[13]=0,s[2]=0,s[6]=0,s[10]=f,s[14]=p,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,r,n,i,o,a){let s=this.elements,l=1/(r-t),c=1/(n-i),u=1/(a-o),h=(r+t)*l,f=(n+i)*c,p=(a+o)*u;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-h,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-f,s[2]=0,s[6]=0,s[10]=-2*u,s[14]=-p,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<16;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<16;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t[r+9]=n[9],t[r+10]=n[10],t[r+11]=n[11],t[r+12]=n[12],t[r+13]=n[13],t[r+14]=n[14],t[r+15]=n[15],t}};Me.prototype.isMatrix4=!0;var S3=new j,ih=new Me,lfr=new j(0,0,0),cfr=new j(1,1,1),R0=new j,_V=new j,Rl=new j,xue=new Me,bue=new yi,em=class{constructor(t=0,r=0,n=0,i=em.DefaultOrder){this._x=t,this._y=r,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,r,n,i=this._order){return this._x=t,this._y=r,this._z=n,this._order=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,r=this._order,n=!0){let i=t.elements,o=i[0],a=i[4],s=i[8],l=i[1],c=i[5],u=i[9],h=i[2],f=i[6],p=i[10];switch(r){case"XYZ":this._y=Math.asin(Zo(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-u,p),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Zo(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(s,p),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,o),this._z=0);break;case"ZXY":this._x=Math.asin(Zo(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,p),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Zo(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,p),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(Zo(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,o)):(this._x=0,this._y=Math.atan2(s,p));break;case"XZY":this._z=Math.asin(-Zo(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-u,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+r)}return this._order=r,n===!0&&this._onChangeCallback(),this}setFromQuaternion(t,r,n){return xue.makeRotationFromQuaternion(t),this.setFromRotationMatrix(xue,r,n)}setFromVector3(t,r=this._order){return this.set(t.x,t.y,t.z,r)}reorder(t){return bue.setFromEuler(this),this.setFromQuaternion(bue,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new j(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};em.prototype.isEuler=!0;em.DefaultOrder="XYZ";em.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var X3=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},ufr=0,wue=new j,M3=new yi,Gd=new Me,yV=new j,kP=new j,hfr=new j,ffr=new yi,Sue=new j(1,0,0),Mue=new j(0,1,0),Eue=new j(0,0,1),pfr={type:"added"},Tue={type:"removed"},or=class extends qs{constructor(){super(),Object.defineProperty(this,"id",{value:ufr++}),this.uuid=Dl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=or.DefaultUp.clone();let t=new j,r=new em,n=new yi,i=new j(1,1,1);function o(){n.setFromEuler(r,!1)}function a(){r.setFromQuaternion(n,void 0,!1)}r._onChange(o),n._onChange(a),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:r},quaternion:{configurable:!0,enumerable:!0,value:n},scale:{configurable:!0,enumerable:!0,value:i},modelViewMatrix:{value:new Me},normalMatrix:{value:new ki}}),this.matrix=new Me,this.matrixWorld=new Me,this.matrixAutoUpdate=or.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new X3,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,r){this.quaternion.setFromAxisAngle(t,r)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.multiply(M3),this}rotateOnWorldAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.premultiply(M3),this}rotateX(t){return this.rotateOnAxis(Sue,t)}rotateY(t){return this.rotateOnAxis(Mue,t)}rotateZ(t){return this.rotateOnAxis(Eue,t)}translateOnAxis(t,r){return wue.copy(t).applyQuaternion(this.quaternion),this.position.add(wue.multiplyScalar(r)),this}translateX(t){return this.translateOnAxis(Sue,t)}translateY(t){return this.translateOnAxis(Mue,t)}translateZ(t){return this.translateOnAxis(Eue,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Gd.copy(this.matrixWorld).invert())}lookAt(t,r,n){t.isVector3?yV.copy(t):yV.set(t,r,n);let i=this.parent;this.updateWorldMatrix(!0,!1),kP.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Gd.lookAt(kP,yV,this.up):Gd.lookAt(yV,kP,this.up),this.quaternion.setFromRotationMatrix(Gd),i&&(Gd.extractRotation(i.matrixWorld),M3.setFromRotationMatrix(Gd),this.quaternion.premultiply(M3.invert()))}add(t){if(arguments.length>1){for(let r=0;r<arguments.length;r++)this.add(arguments[r]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(pfr)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let n=0;n<arguments.length;n++)this.remove(arguments[n]);return this}let r=this.children.indexOf(t);return r!==-1&&(t.parent=null,this.children.splice(r,1),t.dispatchEvent(Tue)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let r=this.children[t];r.parent=null,r.dispatchEvent(Tue)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Gd.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),Gd.multiply(t.parent.matrixWorld)),t.applyMatrix4(Gd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,r){if(this[t]===r)return this;for(let n=0,i=this.children.length;n<i;n++){let a=this.children[n].getObjectByProperty(t,r);if(a!==void 0)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,t,hfr),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(kP,ffr,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(r[8],r[9],r[10]).normalize()}raycast(){}traverse(t){t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverseVisible(t)}traverseAncestors(t){let r=this.parent;r!==null&&(t(r),r.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].updateMatrixWorld(t)}updateWorldMatrix(t,r){let n=this.parent;if(t===!0&&n!==null&&n.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),r===!0){let i=this.children;for(let o=0,a=i.length;o<a;o++)i[o].updateWorldMatrix(!1,!0)}}toJSON(t){let r=t===void 0||typeof t=="string",n={};r&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},n.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let i={};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.castShadow===!0&&(i.castShadow=!0),this.receiveShadow===!0&&(i.receiveShadow=!0),this.visible===!1&&(i.visible=!1),this.frustumCulled===!1&&(i.frustumCulled=!1),this.renderOrder!==0&&(i.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(i.instanceColor=this.instanceColor.toJSON()));function o(s,l){return s[l.uuid]===void 0&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?i.background=this.background.toJSON():this.background.isTexture&&(i.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(i.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){i.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(s!==void 0&&s.shapes!==void 0){let l=s.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];o(t.shapes,h)}else o(t.shapes,l)}}if(this.isSkinnedMesh&&(i.bindMode=this.bindMode,i.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(o(t.skeletons,this.skeleton),i.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));i.material=s}else i.material=o(t.materials,this.material);if(this.children.length>0){i.children=[];for(let s=0;s<this.children.length;s++)i.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){i.animations=[];for(let s=0;s<this.animations.length;s++){let l=this.animations[s];i.animations.push(o(t.animations,l))}}if(r){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),u=a(t.images),h=a(t.shapes),f=a(t.skeletons),p=a(t.animations);s.length>0&&(n.geometries=s),l.length>0&&(n.materials=l),c.length>0&&(n.textures=c),u.length>0&&(n.images=u),h.length>0&&(n.shapes=h),f.length>0&&(n.skeletons=f),p.length>0&&(n.animations=p)}return n.object=i,n;function a(s){let l=[];for(let c in s){let u=s[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,r=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),r===!0)for(let n=0;n<t.children.length;n++){let i=t.children[n];this.add(i.clone())}return this}};or.DefaultUp=new j(0,1,0);or.DefaultMatrixAutoUpdate=!0;or.prototype.isObject3D=!0;var oh=new j,Wd=new j,tut=new j,Yd=new j,E3=new j,T3=new j,Cue=new j,eut=new j,rut=new j,nut=new j,oi=class{constructor(t=new j,r=new j,n=new j){this.a=t,this.b=r,this.c=n}static getNormal(t,r,n,i){i.subVectors(n,r),oh.subVectors(t,r),i.cross(oh);let o=i.lengthSq();return o>0?i.multiplyScalar(1/Math.sqrt(o)):i.set(0,0,0)}static getBarycoord(t,r,n,i,o){oh.subVectors(i,r),Wd.subVectors(n,r),tut.subVectors(t,r);let a=oh.dot(oh),s=oh.dot(Wd),l=oh.dot(tut),c=Wd.dot(Wd),u=Wd.dot(tut),h=a*c-s*s;if(h===0)return o.set(-2,-1,-1);let f=1/h,p=(c*l-s*u)*f,d=(a*u-s*l)*f;return o.set(1-p-d,d,p)}static containsPoint(t,r,n,i){return this.getBarycoord(t,r,n,i,Yd),Yd.x>=0&&Yd.y>=0&&Yd.x+Yd.y<=1}static getUV(t,r,n,i,o,a,s,l){return this.getBarycoord(t,r,n,i,Yd),l.set(0,0),l.addScaledVector(o,Yd.x),l.addScaledVector(a,Yd.y),l.addScaledVector(s,Yd.z),l}static isFrontFacing(t,r,n,i){return oh.subVectors(n,r),Wd.subVectors(t,r),oh.cross(Wd).dot(i)<0}set(t,r,n){return this.a.copy(t),this.b.copy(r),this.c.copy(n),this}setFromPointsAndIndices(t,r,n,i){return this.a.copy(t[r]),this.b.copy(t[n]),this.c.copy(t[i]),this}setFromAttributeAndIndices(t,r,n,i){return this.a.fromBufferAttribute(t,r),this.b.fromBufferAttribute(t,n),this.c.fromBufferAttribute(t,i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return oh.subVectors(this.c,this.b),Wd.subVectors(this.a,this.b),oh.cross(Wd).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return oi.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,r){return oi.getBarycoord(t,this.a,this.b,this.c,r)}getUV(t,r,n,i,o){return oi.getUV(t,this.a,this.b,this.c,r,n,i,o)}containsPoint(t){return oi.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return oi.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,r){let n=this.a,i=this.b,o=this.c,a,s;E3.subVectors(i,n),T3.subVectors(o,n),eut.subVectors(t,n);let l=E3.dot(eut),c=T3.dot(eut);if(l<=0&&c<=0)return r.copy(n);rut.subVectors(t,i);let u=E3.dot(rut),h=T3.dot(rut);if(u>=0&&h<=u)return r.copy(i);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return a=l/(l-u),r.copy(n).addScaledVector(E3,a);nut.subVectors(t,o);let p=E3.dot(nut),d=T3.dot(nut);if(d>=0&&p<=d)return r.copy(o);let g=p*c-l*d;if(g<=0&&c>=0&&d<=0)return s=c/(c-d),r.copy(n).addScaledVector(T3,s);let _=u*d-p*h;if(_<=0&&h-u>=0&&p-d>=0)return Cue.subVectors(o,i),s=(h-u)/(h-u+(p-d)),r.copy(i).addScaledVector(Cue,s);let y=1/(_+g+f);return a=g*y,s=f*y,r.copy(n).addScaledVector(E3,a).addScaledVector(T3,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},dfr=0,qi=class extends qs{constructor(){super(),Object.defineProperty(this,"id",{value:dfr++}),this.uuid=Dl(),this.name="",this.type="Material",this.fog=!0,this.blending=V3,this.side=L1,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=Pht,this.blendDst=Iht,this.blendEquation=E1,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=iU,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=Ofe,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nU,this.stencilZFail=nU,this.stencilZPass=nU,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let r in t){let n=t[r];if(n===void 0){console.warn("THREE.Material: '"+r+"' parameter is undefined.");continue}if(r==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===Aht;continue}let i=this[r];if(i===void 0){console.warn("THREE."+this.type+": '"+r+"' is not a property of this material.");continue}i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[r]=n}}toJSON(t){let r=t===void 0||typeof t=="string";r&&(t={textures:{},images:{}});let n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};n.uuid=this.uuid,n.type=this.type,this.name!==""&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),this.roughness!==void 0&&(n.roughness=this.roughness),this.metalness!==void 0&&(n.metalness=this.metalness),this.sheen!==void 0&&(n.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(n.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(n.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(n.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(n.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(n.shininess=this.shininess),this.clearcoat!==void 0&&(n.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(n.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(n.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(n.combine=this.combine)),this.envMapIntensity!==void 0&&(n.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(n.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(n.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(n.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(n.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(n.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(n.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(n.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(n.size=this.size),this.shadowSide!==null&&(n.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(n.sizeAttenuation=this.sizeAttenuation),this.blending!==V3&&(n.blending=this.blending),this.side!==L1&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),this.transparent===!0&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.colorWrite=this.colorWrite,n.alphaWrite=this.alphaWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(n.rotation=this.rotation),this.polygonOffset===!0&&(n.polygonOffset=!0),this.polygonOffsetFactor!==0&&(n.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(n.linewidth=this.linewidth),this.dashSize!==void 0&&(n.dashSize=this.dashSize),this.gapSize!==void 0&&(n.gapSize=this.gapSize),this.scale!==void 0&&(n.scale=this.scale),this.dithering===!0&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(n.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(n.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(n.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(n.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(n.flatShading=this.flatShading),this.visible===!1&&(n.visible=!1),this.toneMapped===!1&&(n.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData);function i(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(r){let o=i(t.textures),a=i(t.images);o.length>0&&(n.textures=o),a.length>0&&(n.images=a)}return n}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let r=t.clippingPlanes,n=null;if(r!==null){let i=r.length;n=new Array(i);for(let o=0;o!==i;++o)n[o]=r[o].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};qi.prototype.isMaterial=!0;var sh=class extends qi{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};sh.prototype.isMeshBasicMaterial=!0;var Ln=new j,vV=new Lt,Je=class{constructor(t,r,n){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=r,this.count=t!==void 0?t.length/r:0,this.normalized=n===!0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,r,n){t*=this.itemSize,n*=r.itemSize;for(let i=0,o=this.itemSize;i<o;i++)this.array[t+i]=r.array[n+i];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",i),a=new ne),r[n++]=a.r,r[n++]=a.g,r[n++]=a.b}return this}copyVector2sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",i),a=new Lt),r[n++]=a.x,r[n++]=a.y}return this}copyVector3sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",i),a=new j),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z}return this}copyVector4sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",i),a=new en),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z,r[n++]=a.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let r=0,n=this.count;r<n;r++)vV.fromBufferAttribute(this,r),vV.applyMatrix3(t),this.setXY(r,vV.x,vV.y);else if(this.itemSize===3)for(let r=0,n=this.count;r<n;r++)Ln.fromBufferAttribute(this,r),Ln.applyMatrix3(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}applyMatrix4(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.applyMatrix4(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.applyNormalMatrix(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.transformDirection(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}set(t,r=0){return this.array.set(t,r),this}getX(t){return this.array[t*this.itemSize]}setX(t,r){return this.array[t*this.itemSize]=r,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,r){return this.array[t*this.itemSize+1]=r,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,r){return this.array[t*this.itemSize+2]=r,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,r){return this.array[t*this.itemSize+3]=r,this}setXY(t,r,n){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this}setXYZ(t,r,n,i){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==W3&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Je.prototype.isBufferAttribute=!0;var cU=class extends Je{constructor(t,r,n){super(new Int8Array(t),r,n)}},uU=class extends Je{constructor(t,r,n){super(new Uint8Array(t),r,n)}},hU=class extends Je{constructor(t,r,n){super(new Uint8ClampedArray(t),r,n)}},fU=class extends Je{constructor(t,r,n){super(new Int16Array(t),r,n)}},$3=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}},pU=class extends Je{constructor(t,r,n){super(new Int32Array(t),r,n)}},K3=class extends Je{constructor(t,r,n){super(new Uint32Array(t),r,n)}},dU=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}};dU.prototype.isFloat16BufferAttribute=!0;var xe=class extends Je{constructor(t,r,n){super(new Float32Array(t),r,n)}},mU=class extends Je{constructor(t,r,n){super(new Float64Array(t),r,n)}},mfr=0,Xc=new Me,iut=new or,C3=new j,Nl=new ta,RP=new ta,Lo=new j,Pe=class extends qs{constructor(){super(),Object.defineProperty(this,"id",{value:mfr++}),this.uuid=Dl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(Bfe(t)?K3:$3)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,r){return this.attributes[t]=r,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,r,n=0){this.groups.push({start:t,count:r,materialIndex:n})}clearGroups(){this.groups=[]}setDrawRange(t,r){this.drawRange.start=t,this.drawRange.count=r}applyMatrix4(t){let r=this.attributes.position;r!==void 0&&(r.applyMatrix4(t),r.needsUpdate=!0);let n=this.attributes.normal;if(n!==void 0){let o=new ki().getNormalMatrix(t);n.applyNormalMatrix(o),n.needsUpdate=!0}let i=this.attributes.tangent;return i!==void 0&&(i.transformDirection(t),i.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return Xc.makeRotationFromQuaternion(t),this.applyMatrix4(Xc),this}rotateX(t){return Xc.makeRotationX(t),this.applyMatrix4(Xc),this}rotateY(t){return Xc.makeRotationY(t),this.applyMatrix4(Xc),this}rotateZ(t){return Xc.makeRotationZ(t),this.applyMatrix4(Xc),this}translate(t,r,n){return Xc.makeTranslation(t,r,n),this.applyMatrix4(Xc),this}scale(t,r,n){return Xc.makeScale(t,r,n),this.applyMatrix4(Xc),this}lookAt(t){return iut.lookAt(t),iut.updateMatrix(),this.applyMatrix4(iut.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(C3).negate(),this.translate(C3.x,C3.y,C3.z),this}setFromPoints(t){let r=[];for(let n=0,i=t.length;n<i;n++){let o=t[n];r.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new xe(r,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new ta);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new j(-1/0,-1/0,-1/0),new j(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),r)for(let n=0,i=r.length;n<i;n++){let o=r[n];Nl.setFromBufferAttribute(o),this.morphTargetsRelative?(Lo.addVectors(this.boundingBox.min,Nl.min),this.boundingBox.expandByPoint(Lo),Lo.addVectors(this.boundingBox.max,Nl.max),this.boundingBox.expandByPoint(Lo)):(this.boundingBox.expandByPoint(Nl.min),this.boundingBox.expandByPoint(Nl.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new Jf);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new j,1/0);return}if(t){let n=this.boundingSphere.center;if(Nl.setFromBufferAttribute(t),r)for(let o=0,a=r.length;o<a;o++){let s=r[o];RP.setFromBufferAttribute(s),this.morphTargetsRelative?(Lo.addVectors(Nl.min,RP.min),Nl.expandByPoint(Lo),Lo.addVectors(Nl.max,RP.max),Nl.expandByPoint(Lo)):(Nl.expandByPoint(RP.min),Nl.expandByPoint(RP.max))}Nl.getCenter(n);let i=0;for(let o=0,a=t.count;o<a;o++)Lo.fromBufferAttribute(t,o),i=Math.max(i,n.distanceToSquared(Lo));if(r)for(let o=0,a=r.length;o<a;o++){let s=r[o],l=this.morphTargetsRelative;for(let c=0,u=s.count;c<u;c++)Lo.fromBufferAttribute(s,c),l&&(C3.fromBufferAttribute(t,c),Lo.add(C3)),i=Math.max(i,n.distanceToSquared(Lo))}this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,r=this.attributes;if(t===null||r.position===void 0||r.normal===void 0||r.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let n=t.array,i=r.position.array,o=r.normal.array,a=r.uv.array,s=i.length/3;r.tangent===void 0&&this.setAttribute("tangent",new Je(new Float32Array(4*s),4));let l=r.tangent.array,c=[],u=[];for(let B=0;B<s;B++)c[B]=new j,u[B]=new j;let h=new j,f=new j,p=new j,d=new Lt,g=new Lt,_=new Lt,y=new j,x=new j;function b(B,I,L){h.fromArray(i,B*3),f.fromArray(i,I*3),p.fromArray(i,L*3),d.fromArray(a,B*2),g.fromArray(a,I*2),_.fromArray(a,L*2),f.sub(h),p.sub(h),g.sub(d),_.sub(d);let R=1/(g.x*_.y-_.x*g.y);!isFinite(R)||(y.copy(f).multiplyScalar(_.y).addScaledVector(p,-g.y).multiplyScalar(R),x.copy(p).multiplyScalar(g.x).addScaledVector(f,-_.x).multiplyScalar(R),c[B].add(y),c[I].add(y),c[L].add(y),u[B].add(x),u[I].add(x),u[L].add(x))}let S=this.groups;S.length===0&&(S=[{start:0,count:n.length}]);for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)b(n[z+0],n[z+1],n[z+2])}let C=new j,P=new j,k=new j,O=new j;function D(B){k.fromArray(o,B*3),O.copy(k);let I=c[B];C.copy(I),C.sub(k.multiplyScalar(k.dot(I))).normalize(),P.crossVectors(O,I);let R=P.dot(u[B])<0?-1:1;l[B*4]=C.x,l[B*4+1]=C.y,l[B*4+2]=C.z,l[B*4+3]=R}for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)D(n[z+0]),D(n[z+1]),D(n[z+2])}}computeVertexNormals(){let t=this.index,r=this.getAttribute("position");if(r!==void 0){let n=this.getAttribute("normal");if(n===void 0)n=new Je(new Float32Array(r.count*3),3),this.setAttribute("normal",n);else for(let f=0,p=n.count;f<p;f++)n.setXYZ(f,0,0,0);let i=new j,o=new j,a=new j,s=new j,l=new j,c=new j,u=new j,h=new j;if(t)for(let f=0,p=t.count;f<p;f+=3){let d=t.getX(f+0),g=t.getX(f+1),_=t.getX(f+2);i.fromBufferAttribute(r,d),o.fromBufferAttribute(r,g),a.fromBufferAttribute(r,_),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),s.fromBufferAttribute(n,d),l.fromBufferAttribute(n,g),c.fromBufferAttribute(n,_),s.add(u),l.add(u),c.add(u),n.setXYZ(d,s.x,s.y,s.z),n.setXYZ(g,l.x,l.y,l.z),n.setXYZ(_,c.x,c.y,c.z)}else for(let f=0,p=r.count;f<p;f+=3)i.fromBufferAttribute(r,f+0),o.fromBufferAttribute(r,f+1),a.fromBufferAttribute(r,f+2),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),n.setXYZ(f+0,u.x,u.y,u.z),n.setXYZ(f+1,u.x,u.y,u.z),n.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),n.needsUpdate=!0}}merge(t,r){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}r===void 0&&(r=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let n=this.attributes;for(let i in n){if(t.attributes[i]===void 0)continue;let a=n[i].array,s=t.attributes[i],l=s.array,c=s.itemSize*r,u=Math.min(l.length,a.length-c);for(let h=0,f=c;h<u;h++,f++)a[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let r=0,n=t.count;r<n;r++)Lo.fromBufferAttribute(t,r),Lo.normalize(),t.setXYZ(r,Lo.x,Lo.y,Lo.z)}toNonIndexed(){function t(s,l){let c=s.array,u=s.itemSize,h=s.normalized,f=new c.constructor(l.length*u),p=0,d=0;for(let g=0,_=l.length;g<_;g++){s.isInterleavedBufferAttribute?p=l[g]*s.data.stride+s.offset:p=l[g]*u;for(let y=0;y<u;y++)f[d++]=c[p++]}return new Je(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let r=new Pe,n=this.index.array,i=this.attributes;for(let s in i){let l=i[s],c=t(l,n);r.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=t(f,n);l.push(p)}r.morphAttributes[s]=l}r.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];r.addGroup(c.start,c.count,c.materialIndex)}return r}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let r=this.index;r!==null&&(t.data.index={type:r.array.constructor.name,array:Array.prototype.slice.call(r.array)});let n=this.attributes;for(let l in n){let c=n[l];t.data.attributes[l]=c.toJSON(t.data)}let i={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let p=c[h];u.push(p.toJSON(t.data))}u.length>0&&(i[l]=u,o=!0)}o&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return s!==null&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let r={};this.name=t.name;let n=t.index;n!==null&&this.setIndex(n.clone(r));let i=t.attributes;for(let c in i){let u=i[c];this.setAttribute(c,u.clone(r))}let o=t.morphAttributes;for(let c in o){let u=[],h=o[c];for(let f=0,p=h.length;f<p;f++)u.push(h[f].clone(r));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,u=a.length;c<u;c++){let h=a[c];this.addGroup(h.start,h.count,h.materialIndex)}let s=t.boundingBox;s!==null&&(this.boundingBox=s.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Pe.prototype.isBufferGeometry=!0;var Aue=new Me,A3=new Qf,out=new Jf,N0=new j,D0=new j,O0=new j,aut=new j,sut=new j,lut=new j,xV=new j,bV=new j,wV=new j,SV=new Lt,MV=new Lt,EV=new Lt,cut=new j,TV=new j,ti=class extends or{constructor(t=new Pe,r=new sh){super(),this.type="Mesh",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,r){let n=this.geometry,i=this.material,o=this.matrixWorld;if(i===void 0||(n.boundingSphere===null&&n.computeBoundingSphere(),out.copy(n.boundingSphere),out.applyMatrix4(o),t.ray.intersectsSphere(out)===!1)||(Aue.copy(o).invert(),A3.copy(t.ray).applyMatrix4(Aue),n.boundingBox!==null&&A3.intersectsBox(n.boundingBox)===!1))return;let a;if(n.isBufferGeometry){let s=n.index,l=n.attributes.position,c=n.morphAttributes.position,u=n.morphTargetsRelative,h=n.attributes.uv,f=n.attributes.uv2,p=n.groups,d=n.drawRange;if(s!==null)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(s.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=s.getX(C),O=s.getX(C+1),D=s.getX(C+2);a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(s.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=s.getX(y),S=s.getX(y+1),C=s.getX(y+2);a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}else if(l!==void 0)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(l.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=C,O=C+1,D=C+2;a=CV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(l.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=y,S=y+1,C=y+2;a=CV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}}else n.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};ti.prototype.isMesh=!0;function gfr(e,t,r,n,i,o,a,s){let l;if(t.side===Ii?l=n.intersectTriangle(a,o,i,!0,s):l=n.intersectTriangle(i,o,a,t.side!==k1,s),l===null)return null;TV.copy(s),TV.applyMatrix4(e.matrixWorld);let c=r.ray.origin.distanceTo(TV);return c<r.near||c>r.far?null:{distance:c,point:TV.clone(),object:e}}function CV(e,t,r,n,i,o,a,s,l,c,u,h){N0.fromBufferAttribute(i,c),D0.fromBufferAttribute(i,u),O0.fromBufferAttribute(i,h);let f=e.morphTargetInfluences;if(o&&f){xV.set(0,0,0),bV.set(0,0,0),wV.set(0,0,0);for(let d=0,g=o.length;d<g;d++){let _=f[d],y=o[d];_!==0&&(aut.fromBufferAttribute(y,c),sut.fromBufferAttribute(y,u),lut.fromBufferAttribute(y,h),a?(xV.addScaledVector(aut,_),bV.addScaledVector(sut,_),wV.addScaledVector(lut,_)):(xV.addScaledVector(aut.sub(N0),_),bV.addScaledVector(sut.sub(D0),_),wV.addScaledVector(lut.sub(O0),_)))}N0.add(xV),D0.add(bV),O0.add(wV)}e.isSkinnedMesh&&(e.boneTransform(c,N0),e.boneTransform(u,D0),e.boneTransform(h,O0));let p=gfr(e,t,r,n,N0,D0,O0,cut);if(p){s&&(SV.fromBufferAttribute(s,c),MV.fromBufferAttribute(s,u),EV.fromBufferAttribute(s,h),p.uv=oi.getUV(cut,N0,D0,O0,SV,MV,EV,new Lt)),l&&(SV.fromBufferAttribute(l,c),MV.fromBufferAttribute(l,u),EV.fromBufferAttribute(l,h),p.uv2=oi.getUV(cut,N0,D0,O0,SV,MV,EV,new Lt));let d={a:c,b:u,c:h,normal:new j,materialIndex:0};oi.getNormal(N0,D0,O0,d.normal),p.face=d}return p}var tp=class extends Pe{constructor(t=1,r=1,n=1,i=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:r,depth:n,widthSegments:i,heightSegments:o,depthSegments:a};let s=this;i=Math.floor(i),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],u=[],h=[],f=0,p=0;d("z","y","x",-1,-1,n,r,t,a,o,0),d("z","y","x",1,-1,n,r,-t,a,o,1),d("x","z","y",1,1,t,n,r,i,a,2),d("x","z","y",1,-1,t,n,-r,i,a,3),d("x","y","z",1,-1,t,r,n,i,o,4),d("x","y","z",-1,-1,t,r,-n,i,o,5),this.setIndex(l),this.setAttribute("position",new xe(c,3)),this.setAttribute("normal",new xe(u,3)),this.setAttribute("uv",new xe(h,2));function d(g,_,y,x,b,S,C,P,k,O,D){let B=S/k,I=C/O,L=S/2,R=C/2,F=P/2,z=k+1,U=O+1,W=0,Z=0,rt=new j;for(let ot=0;ot<U;ot++){let st=ot*I-R;for(let St=0;St<z;St++){let bt=St*B-L;rt[g]=bt*x,rt[_]=st*b,rt[y]=F,c.push(rt.x,rt.y,rt.z),rt[g]=0,rt[_]=0,rt[y]=P>0?1:-1,u.push(rt.x,rt.y,rt.z),h.push(St/k),h.push(1-ot/O),W+=1}}for(let ot=0;ot<O;ot++)for(let st=0;st<k;st++){let St=f+st+z*ot,bt=f+st+z*(ot+1),Mt=f+(st+1)+z*(ot+1),lt=f+(st+1)+z*ot;l.push(St,bt,lt),l.push(bt,Mt,lt),Z+=6}s.addGroup(p,Z,D),p+=Z,f+=W}}static fromJSON(t){return new tp(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Z3(e){let t={};for(let r in e){t[r]={};for(let n in e[r]){let i=e[r][n];i&&(i.isColor||i.isMatrix3||i.isMatrix4||i.isVector2||i.isVector3||i.isVector4||i.isTexture||i.isQuaternion)?t[r][n]=i.clone():Array.isArray(i)?t[r][n]=i.slice():t[r][n]=i}}return t}function Ca(e){let t={};for(let r=0;r<e.length;r++){let n=Z3(e[r]);for(let i in n)t[i]=n[i]}return t}var Vfe={clone:Z3,merge:Ca},_fr=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,yfr=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,lh=class extends qi{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=_fr,this.fragmentShader=yfr,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Z3(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let r=super.toJSON(t);r.glslVersion=this.glslVersion,r.uniforms={};for(let i in this.uniforms){let a=this.uniforms[i].value;a&&a.isTexture?r.uniforms[i]={type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?r.uniforms[i]={type:"c",value:a.getHex()}:a&&a.isVector2?r.uniforms[i]={type:"v2",value:a.toArray()}:a&&a.isVector3?r.uniforms[i]={type:"v3",value:a.toArray()}:a&&a.isVector4?r.uniforms[i]={type:"v4",value:a.toArray()}:a&&a.isMatrix3?r.uniforms[i]={type:"m3",value:a.toArray()}:a&&a.isMatrix4?r.uniforms[i]={type:"m4",value:a.toArray()}:r.uniforms[i]={value:a}}Object.keys(this.defines).length>0&&(r.defines=this.defines),r.vertexShader=this.vertexShader,r.fragmentShader=this.fragmentShader;let n={};for(let i in this.extensions)this.extensions[i]===!0&&(n[i]=!0);return Object.keys(n).length>0&&(r.extensions=n),r}};lh.prototype.isShaderMaterial=!0;var N1=class extends or{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Me,this.projectionMatrix=new Me,this.projectionMatrixInverse=new Me}copy(t,r){return super.copy(t,r),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(-r[8],-r[9],-r[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,r){super.updateWorldMatrix(t,r),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};N1.prototype.isCamera=!0;var Ui=class extends N1{constructor(t=50,r=1,n=.1,i=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=r,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let r=.5*this.getFilmHeight()/t;this.fov=QP*2*Math.atan(r),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(I1*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return QP*2*Math.atan(Math.tan(I1*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,r,n,i,o,a){this.aspect=t/r,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,r=t*Math.tan(I1*.5*this.fov)/this.zoom,n=2*r,i=this.aspect*n,o=-.5*i,a=this.view;if(this.view!==null&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*i/l,r-=a.offsetY*n/c,i*=a.width/l,n*=a.height/c}let s=this.filmOffset;s!==0&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+i,r,r-n,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.fov=this.fov,r.object.zoom=this.zoom,r.object.near=this.near,r.object.far=this.far,r.object.focus=this.focus,r.object.aspect=this.aspect,this.view!==null&&(r.object.view=Object.assign({},this.view)),r.object.filmGauge=this.filmGauge,r.object.filmOffset=this.filmOffset,r}};Ui.prototype.isPerspectiveCamera=!0;var P3=90,I3=1,J3=class extends or{constructor(t,r,n){if(super(),this.type="CubeCamera",n.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=n;let i=new Ui(P3,I3,t,r);i.layers=this.layers,i.up.set(0,-1,0),i.lookAt(new j(1,0,0)),this.add(i);let o=new Ui(P3,I3,t,r);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new j(-1,0,0)),this.add(o);let a=new Ui(P3,I3,t,r);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new j(0,1,0)),this.add(a);let s=new Ui(P3,I3,t,r);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new j(0,-1,0)),this.add(s);let l=new Ui(P3,I3,t,r);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new j(0,0,1)),this.add(l);let c=new Ui(P3,I3,t,r);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new j(0,0,-1)),this.add(c)}update(t,r){this.parent===null&&this.updateMatrixWorld();let n=this.renderTarget,[i,o,a,s,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0),t.render(r,i),t.setRenderTarget(n,1),t.render(r,o),t.setRenderTarget(n,2),t.render(r,a),t.setRenderTarget(n,3),t.render(r,s),t.setRenderTarget(n,4),t.render(r,l),n.texture.generateMipmaps=f,t.setRenderTarget(n,5),t.render(r,c),t.setRenderTarget(h),t.xr.enabled=u,n.texture.needsPMREMUpdate=!0}},V0=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){t=t!==void 0?t:[],r=r!==void 0?r:ix,super(t,r,n,i,o,a,s,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};V0.prototype.isCubeTexture=!0;var Q3=class extends hs{constructor(t,r,n){Number.isInteger(r)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),r=n),super(t,t,r),r=r||{},this.texture=new V0(void 0,r.mapping,r.wrapS,r.wrapT,r.magFilter,r.minFilter,r.format,r.type,r.anisotropy,r.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=r.generateMipmaps!==void 0?r.generateMipmaps:!1,this.texture.minFilter=r.minFilter!==void 0?r.minFilter:ii}fromEquirectangularTexture(t,r){this.texture.type=r.type,this.texture.format=Qo,this.texture.encoding=r.encoding,this.texture.generateMipmaps=r.generateMipmaps,this.texture.minFilter=r.minFilter,this.texture.magFilter=r.magFilter;let n={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},i=new tp(5,5,5),o=new lh({name:"CubemapFromEquirect",uniforms:Z3(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:Ii,blending:Kd});o.uniforms.tEquirect.value=r;let a=new ti(i,o),s=r.minFilter;return r.minFilter===ax&&(r.minFilter=ii),new J3(1,10,this).update(t,a),r.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,r,n,i){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(r,n,i);t.setRenderTarget(o)}};Q3.prototype.isWebGLCubeRenderTarget=!0;var uut=new j,vfr=new j,xfr=new ki,$c=class{constructor(t=new j(1,0,0),r=0){this.normal=t,this.constant=r}set(t,r){return this.normal.copy(t),this.constant=r,this}setComponents(t,r,n,i){return this.normal.set(t,r,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,r){return this.normal.copy(t),this.constant=-r.dot(this.normal),this}setFromCoplanarPoints(t,r,n){let i=uut.subVectors(n,r).cross(vfr.subVectors(t,r)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,r){return r.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,r){let n=t.delta(uut),i=this.normal.dot(n);if(i===0)return this.distanceToPoint(t.start)===0?r.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/i;return o<0||o>1?null:r.copy(n).multiplyScalar(o).add(t.start)}intersectsLine(t){let r=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return r<0&&n>0||n<0&&r>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,r){let n=r||xfr.getNormalMatrix(t),i=this.coplanarPoint(uut).applyMatrix4(t),o=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};$c.prototype.isPlane=!0;var L3=new Jf,AV=new j,D1=class{constructor(t=new $c,r=new $c,n=new $c,i=new $c,o=new $c,a=new $c){this.planes=[t,r,n,i,o,a]}set(t,r,n,i,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(r),s[2].copy(n),s[3].copy(i),s[4].copy(o),s[5].copy(a),this}copy(t){let r=this.planes;for(let n=0;n<6;n++)r[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t){let r=this.planes,n=t.elements,i=n[0],o=n[1],a=n[2],s=n[3],l=n[4],c=n[5],u=n[6],h=n[7],f=n[8],p=n[9],d=n[10],g=n[11],_=n[12],y=n[13],x=n[14],b=n[15];return r[0].setComponents(s-i,h-l,g-f,b-_).normalize(),r[1].setComponents(s+i,h+l,g+f,b+_).normalize(),r[2].setComponents(s+o,h+c,g+p,b+y).normalize(),r[3].setComponents(s-o,h-c,g-p,b-y).normalize(),r[4].setComponents(s-a,h-u,g-d,b-x).normalize(),r[5].setComponents(s+a,h+u,g+d,b+x).normalize(),this}intersectsObject(t){let r=t.geometry;return r.boundingSphere===null&&r.computeBoundingSphere(),L3.copy(r.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSprite(t){return L3.center.set(0,0,0),L3.radius=.7071067811865476,L3.applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSphere(t){let r=this.planes,n=t.center,i=-t.radius;for(let o=0;o<6;o++)if(r[o].distanceToPoint(n)<i)return!1;return!0}intersectsBox(t){let r=this.planes;for(let n=0;n<6;n++){let i=r[n];if(AV.x=i.normal.x>0?t.max.x:t.min.x,AV.y=i.normal.y>0?t.max.y:t.min.y,AV.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(AV)<0)return!1}return!0}containsPoint(t){let r=this.planes;for(let n=0;n<6;n++)if(r[n].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function Ufe(){let e=null,t=!1,r=null,n=null;function i(o,a){r(o,a),n=e.requestAnimationFrame(i)}return{start:function(){t!==!0&&r!==null&&(n=e.requestAnimationFrame(i),t=!0)},stop:function(){e.cancelAnimationFrame(n),t=!1},setAnimationLoop:function(o){r=o},setContext:function(o){e=o}}}function bfr(e,t){let r=t.isWebGL2,n=new WeakMap;function i(c,u){let h=c.array,f=c.usage,p=e.createBuffer();e.bindBuffer(u,p),e.bufferData(u,h,f),c.onUploadCallback();let d=5126;return h instanceof Float32Array?d=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?r?d=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):d=5123:h instanceof Int16Array?d=5122:h instanceof Uint32Array?d=5125:h instanceof Int32Array?d=5124:h instanceof Int8Array?d=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(d=5121),{buffer:p,type:d,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function o(c,u,h){let f=u.array,p=u.updateRange;e.bindBuffer(h,c),p.count===-1?e.bufferSubData(h,0,f):(r?e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f,p.offset,p.count):e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f.subarray(p.offset,p.offset+p.count)),p.count=-1)}function a(c){return c.isInterleavedBufferAttribute&&(c=c.data),n.get(c)}function s(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=n.get(c);u&&(e.deleteBuffer(u.buffer),n.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=n.get(c);(!f||f.version<c.version)&&n.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=n.get(c);h===void 0?n.set(c,i(c,u)):h.version<c.version&&(o(h.buffer,c,u),h.version=c.version)}return{get:a,remove:s,update:l}}var U0=class extends Pe{constructor(t=1,r=1,n=1,i=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:r,widthSegments:n,heightSegments:i};let o=t/2,a=r/2,s=Math.floor(n),l=Math.floor(i),c=s+1,u=l+1,h=t/s,f=r/l,p=[],d=[],g=[],_=[];for(let y=0;y<u;y++){let x=y*f-a;for(let b=0;b<c;b++){let S=b*h-o;d.push(S,-x,0),g.push(0,0,1),_.push(b/s),_.push(1-y/l)}}for(let y=0;y<l;y++)for(let x=0;x<s;x++){let b=x+c*y,S=x+c*(y+1),C=x+1+c*(y+1),P=x+1+c*y;p.push(b,S,P),p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new U0(t.width,t.height,t.widthSegments,t.heightSegments)}},wfr=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,Sfr=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Mfr=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,Efr=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,Tfr=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,Cfr=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,Afr="vec3 transformed = vec3( position );",Pfr=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,Ifr=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,Lfr=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,kfr=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,Rfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,Nfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,Dfr=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,Ofr=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,zfr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,Ffr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,Bfr=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,Hfr=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,Vfr=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,Ufr=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,qfr=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,Gfr=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,Wfr=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,Yfr=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,jfr="gl_FragColor = linearToOutputTexel( gl_FragColor );",Xfr=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,$fr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,Kfr=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,Zfr=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,Jfr=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,Qfr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,tpr=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,epr=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,rpr=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,npr=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,ipr=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,opr=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,apr=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,spr=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,lpr=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,cpr=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,upr=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,hpr=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,fpr=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,ppr=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,dpr=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,mpr=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,gpr=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,_pr=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,ypr=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,vpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,xpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,bpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,wpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,Spr=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mpr=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,Epr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Tpr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Cpr=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Apr=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ppr=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Ipr=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Lpr=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,kpr=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Rpr=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Npr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Dpr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Opr=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,zpr=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,Fpr=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Bpr=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Hpr=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Vpr=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,Upr=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,qpr=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Gpr=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Wpr=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Ypr=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,jpr=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xpr=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,$pr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Kpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Zpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,Jpr=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Qpr=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,tdr=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,edr=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,rdr=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,ndr=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,idr=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,odr=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,adr=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,sdr=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,ldr=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,cdr=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,udr=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,hdr=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,fdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,pdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,ddr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,mdr=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,gdr=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,_dr=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,ydr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,vdr=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,xdr=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,bdr=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,wdr=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,Sdr=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,Mdr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,Edr=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,Tdr=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,Cdr=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Adr=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,Pdr=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Idr=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Ldr=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,kdr=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,Rdr=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Ndr=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,Ddr=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,Odr=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,zdr=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Fdr=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,Bdr=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Hdr=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Vdr=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Udr=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,qdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Gdr=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Wdr=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Ydr=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,jdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,hr={alphamap_fragment:wfr,alphamap_pars_fragment:Sfr,alphatest_fragment:Mfr,alphatest_pars_fragment:Efr,aomap_fragment:Tfr,aomap_pars_fragment:Cfr,begin_vertex:Afr,beginnormal_vertex:Pfr,bsdfs:Ifr,bumpmap_pars_fragment:Lfr,clipping_planes_fragment:kfr,clipping_planes_pars_fragment:Rfr,clipping_planes_pars_vertex:Nfr,clipping_planes_vertex:Dfr,color_fragment:Ofr,color_pars_fragment:zfr,color_pars_vertex:Ffr,color_vertex:Bfr,common:Hfr,cube_uv_reflection_fragment:Vfr,defaultnormal_vertex:Ufr,displacementmap_pars_vertex:qfr,displacementmap_vertex:Gfr,emissivemap_fragment:Wfr,emissivemap_pars_fragment:Yfr,encodings_fragment:jfr,encodings_pars_fragment:Xfr,envmap_fragment:$fr,envmap_common_pars_fragment:Kfr,envmap_pars_fragment:Zfr,envmap_pars_vertex:Jfr,envmap_physical_pars_fragment:cpr,envmap_vertex:Qfr,fog_vertex:tpr,fog_pars_vertex:epr,fog_fragment:rpr,fog_pars_fragment:npr,gradientmap_pars_fragment:ipr,lightmap_fragment:opr,lightmap_pars_fragment:apr,lights_lambert_vertex:spr,lights_pars_begin:lpr,lights_toon_fragment:upr,lights_toon_pars_fragment:hpr,lights_phong_fragment:fpr,lights_phong_pars_fragment:ppr,lights_physical_fragment:dpr,lights_physical_pars_fragment:mpr,lights_fragment_begin:gpr,lights_fragment_maps:_pr,lights_fragment_end:ypr,logdepthbuf_fragment:vpr,logdepthbuf_pars_fragment:xpr,logdepthbuf_pars_vertex:bpr,logdepthbuf_vertex:wpr,map_fragment:Spr,map_pars_fragment:Mpr,map_particle_fragment:Epr,map_particle_pars_fragment:Tpr,metalnessmap_fragment:Cpr,metalnessmap_pars_fragment:Apr,morphnormal_vertex:Ppr,morphtarget_pars_vertex:Ipr,morphtarget_vertex:Lpr,normal_fragment_begin:kpr,normal_fragment_maps:Rpr,normal_pars_fragment:Npr,normal_pars_vertex:Dpr,normal_vertex:Opr,normalmap_pars_fragment:zpr,clearcoat_normal_fragment_begin:Fpr,clearcoat_normal_fragment_maps:Bpr,clearcoat_pars_fragment:Hpr,output_fragment:Vpr,packing:Upr,premultiplied_alpha_fragment:qpr,project_vertex:Gpr,dithering_fragment:Wpr,dithering_pars_fragment:Ypr,roughnessmap_fragment:jpr,roughnessmap_pars_fragment:Xpr,shadowmap_pars_fragment:$pr,shadowmap_pars_vertex:Kpr,shadowmap_vertex:Zpr,shadowmask_pars_fragment:Jpr,skinbase_vertex:Qpr,skinning_pars_vertex:tdr,skinning_vertex:edr,skinnormal_vertex:rdr,specularmap_fragment:ndr,specularmap_pars_fragment:idr,tonemapping_fragment:odr,tonemapping_pars_fragment:adr,transmission_fragment:sdr,transmission_pars_fragment:ldr,uv_pars_fragment:cdr,uv_pars_vertex:udr,uv_vertex:hdr,uv2_pars_fragment:fdr,uv2_pars_vertex:pdr,uv2_vertex:ddr,worldpos_vertex:mdr,background_vert:gdr,background_frag:_dr,cube_vert:ydr,cube_frag:vdr,depth_vert:xdr,depth_frag:bdr,distanceRGBA_vert:wdr,distanceRGBA_frag:Sdr,equirect_vert:Mdr,equirect_frag:Edr,linedashed_vert:Tdr,linedashed_frag:Cdr,meshbasic_vert:Adr,meshbasic_frag:Pdr,meshlambert_vert:Idr,meshlambert_frag:Ldr,meshmatcap_vert:kdr,meshmatcap_frag:Rdr,meshnormal_vert:Ndr,meshnormal_frag:Ddr,meshphong_vert:Odr,meshphong_frag:zdr,meshphysical_vert:Fdr,meshphysical_frag:Bdr,meshtoon_vert:Hdr,meshtoon_frag:Vdr,points_vert:Udr,points_frag:qdr,shadow_vert:Gdr,shadow_frag:Wdr,sprite_vert:Ydr,sprite_frag:jdr},re={common:{diffuse:{value:new ne(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new ki},uv2Transform:{value:new ki},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new Lt(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ne(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ne(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}},sprite:{diffuse:{value:new ne(16777215)},opacity:{value:1},center:{value:new Lt(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}}},ah={basic:{uniforms:Ca([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.fog]),vertexShader:hr.meshbasic_vert,fragmentShader:hr.meshbasic_frag},lambert:{uniforms:Ca([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshlambert_vert,fragmentShader:hr.meshlambert_frag},phong:{uniforms:Ca([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.fog,re.lights,{emissive:{value:new ne(0)},specular:{value:new ne(1118481)},shininess:{value:30}}]),vertexShader:hr.meshphong_vert,fragmentShader:hr.meshphong_frag},standard:{uniforms:Ca([re.common,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.roughnessmap,re.metalnessmap,re.fog,re.lights,{emissive:{value:new ne(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag},toon:{uniforms:Ca([re.common,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.gradientmap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshtoon_vert,fragmentShader:hr.meshtoon_frag},matcap:{uniforms:Ca([re.common,re.bumpmap,re.normalmap,re.displacementmap,re.fog,{matcap:{value:null}}]),vertexShader:hr.meshmatcap_vert,fragmentShader:hr.meshmatcap_frag},points:{uniforms:Ca([re.points,re.fog]),vertexShader:hr.points_vert,fragmentShader:hr.points_frag},dashed:{uniforms:Ca([re.common,re.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:hr.linedashed_vert,fragmentShader:hr.linedashed_frag},depth:{uniforms:Ca([re.common,re.displacementmap]),vertexShader:hr.depth_vert,fragmentShader:hr.depth_frag},normal:{uniforms:Ca([re.common,re.bumpmap,re.normalmap,re.displacementmap,{opacity:{value:1}}]),vertexShader:hr.meshnormal_vert,fragmentShader:hr.meshnormal_frag},sprite:{uniforms:Ca([re.sprite,re.fog]),vertexShader:hr.sprite_vert,fragmentShader:hr.sprite_frag},background:{uniforms:{uvTransform:{value:new ki},t2D:{value:null}},vertexShader:hr.background_vert,fragmentShader:hr.background_frag},cube:{uniforms:Ca([re.envmap,{opacity:{value:1}}]),vertexShader:hr.cube_vert,fragmentShader:hr.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:hr.equirect_vert,fragmentShader:hr.equirect_frag},distanceRGBA:{uniforms:Ca([re.common,re.displacementmap,{referencePosition:{value:new j},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:hr.distanceRGBA_vert,fragmentShader:hr.distanceRGBA_frag},shadow:{uniforms:Ca([re.lights,re.fog,{color:{value:new ne(0)},opacity:{value:1}}]),vertexShader:hr.shadow_vert,fragmentShader:hr.shadow_frag}};ah.physical={uniforms:Ca([ah.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new Lt(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ne(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new Lt},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ne(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ne(1,1,1)},specularColorMap:{value:null}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag};function Xdr(e,t,r,n,i,o){let a=new ne(0),s=i===!0?0:1,l,c,u=null,h=0,f=null;function p(g,_){let y=!1,x=_.isScene===!0?_.background:null;x&&x.isTexture&&(x=t.get(x));let b=e.xr,S=b.getSession&&b.getSession();S&&S.environmentBlendMode==="additive"&&(x=null),x===null?d(a,s):x&&x.isColor&&(d(x,1),y=!0),(e.autoClear||y)&&e.clear(e.autoClearColor,e.autoClearDepth,e.autoClearStencil),x&&(x.isCubeTexture||x.mapping===xM)?(c===void 0&&(c=new ti(new tp(1,1,1),new lh({name:"BackgroundCubeMaterial",uniforms:Z3(ah.cube.uniforms),vertexShader:ah.cube.vertexShader,fragmentShader:ah.cube.fragmentShader,side:Ii,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(C,P,k){this.matrixWorld.copyPosition(k.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),n.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&x.isRenderTargetTexture===!1?-1:1,(u!==x||h!==x.version||f!==e.toneMapping)&&(c.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(l===void 0&&(l=new ti(new U0(2,2),new lh({name:"BackgroundMaterial",uniforms:Z3(ah.background.uniforms),vertexShader:ah.background.vertexShader,fragmentShader:ah.background.fragmentShader,side:L1,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),n.update(l)),l.material.uniforms.t2D.value=x,x.matrixAutoUpdate===!0&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(u!==x||h!==x.version||f!==e.toneMapping)&&(l.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(l,l.geometry,l.material,0,0,null))}function d(g,_){r.buffers.color.setClear(g.r,g.g,g.b,_,o)}return{getClearColor:function(){return a},setClearColor:function(g,_=1){a.set(g),s=_,d(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(g){s=g,d(a,s)},render:p}}function $dr(e,t,r,n){let i=e.getParameter(34921),o=n.isWebGL2?null:t.get("OES_vertex_array_object"),a=n.isWebGL2||o!==null,s={},l=g(null),c=l;function u(R,F,z,U,W){let Z=!1;if(a){let rt=d(U,z,F);c!==rt&&(c=rt,f(c.object)),Z=_(U,W),Z&&y(U,W)}else{let rt=F.wireframe===!0;(c.geometry!==U.id||c.program!==z.id||c.wireframe!==rt)&&(c.geometry=U.id,c.program=z.id,c.wireframe=rt,Z=!0)}R.isInstancedMesh===!0&&(Z=!0),W!==null&&r.update(W,34963),Z&&(k(R,F,z,U),W!==null&&e.bindBuffer(34963,r.get(W).buffer))}function h(){return n.isWebGL2?e.createVertexArray():o.createVertexArrayOES()}function f(R){return n.isWebGL2?e.bindVertexArray(R):o.bindVertexArrayOES(R)}function p(R){return n.isWebGL2?e.deleteVertexArray(R):o.deleteVertexArrayOES(R)}function d(R,F,z){let U=z.wireframe===!0,W=s[R.id];W===void 0&&(W={},s[R.id]=W);let Z=W[F.id];Z===void 0&&(Z={},W[F.id]=Z);let rt=Z[U];return rt===void 0&&(rt=g(h()),Z[U]=rt),rt}function g(R){let F=[],z=[],U=[];for(let W=0;W<i;W++)F[W]=0,z[W]=0,U[W]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:U,object:R,attributes:{},index:null}}function _(R,F){let z=c.attributes,U=R.attributes,W=0;for(let Z in U){let rt=z[Z],ot=U[Z];if(rt===void 0||rt.attribute!==ot||rt.data!==ot.data)return!0;W++}return c.attributesNum!==W||c.index!==F}function y(R,F){let z={},U=R.attributes,W=0;for(let Z in U){let rt=U[Z],ot={};ot.attribute=rt,rt.data&&(ot.data=rt.data),z[Z]=ot,W++}c.attributes=z,c.attributesNum=W,c.index=F}function x(){let R=c.newAttributes;for(let F=0,z=R.length;F<z;F++)R[F]=0}function b(R){S(R,0)}function S(R,F){let z=c.newAttributes,U=c.enabledAttributes,W=c.attributeDivisors;z[R]=1,U[R]===0&&(e.enableVertexAttribArray(R),U[R]=1),W[R]!==F&&((n.isWebGL2?e:t.get("ANGLE_instanced_arrays"))[n.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](R,F),W[R]=F)}function C(){let R=c.newAttributes,F=c.enabledAttributes;for(let z=0,U=F.length;z<U;z++)F[z]!==R[z]&&(e.disableVertexAttribArray(z),F[z]=0)}function P(R,F,z,U,W,Z){n.isWebGL2===!0&&(z===5124||z===5125)?e.vertexAttribIPointer(R,F,z,W,Z):e.vertexAttribPointer(R,F,z,U,W,Z)}function k(R,F,z,U){if(n.isWebGL2===!1&&(R.isInstancedMesh||U.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;x();let W=U.attributes,Z=z.getAttributes(),rt=F.defaultAttributeValues;for(let ot in Z){let st=Z[ot];if(st.location>=0){let St=W[ot];if(St===void 0&&(ot==="instanceMatrix"&&R.instanceMatrix&&(St=R.instanceMatrix),ot==="instanceColor"&&R.instanceColor&&(St=R.instanceColor)),St!==void 0){let bt=St.normalized,Mt=St.itemSize,lt=r.get(St);if(lt===void 0)continue;let Kt=lt.buffer,_t=lt.type,ct=lt.bytesPerElement;if(St.isInterleavedBufferAttribute){let X=St.data,et=X.stride,dt=St.offset;if(X&&X.isInstancedInterleavedBuffer){for(let q=0;q<st.locationSize;q++)S(st.location+q,X.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=X.meshPerAttribute*X.count)}else for(let q=0;q<st.locationSize;q++)b(st.location+q);e.bindBuffer(34962,Kt);for(let q=0;q<st.locationSize;q++)P(st.location+q,Mt/st.locationSize,_t,bt,et*ct,(dt+Mt/st.locationSize*q)*ct)}else{if(St.isInstancedBufferAttribute){for(let X=0;X<st.locationSize;X++)S(st.location+X,St.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=St.meshPerAttribute*St.count)}else for(let X=0;X<st.locationSize;X++)b(st.location+X);e.bindBuffer(34962,Kt);for(let X=0;X<st.locationSize;X++)P(st.location+X,Mt/st.locationSize,_t,bt,Mt*ct,Mt/st.locationSize*X*ct)}}else if(rt!==void 0){let bt=rt[ot];if(bt!==void 0)switch(bt.length){case 2:e.vertexAttrib2fv(st.location,bt);break;case 3:e.vertexAttrib3fv(st.location,bt);break;case 4:e.vertexAttrib4fv(st.location,bt);break;default:e.vertexAttrib1fv(st.location,bt)}}}}C()}function O(){I();for(let R in s){let F=s[R];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R]}}function D(R){if(s[R.id]===void 0)return;let F=s[R.id];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R.id]}function B(R){for(let F in s){let z=s[F];if(z[R.id]===void 0)continue;let U=z[R.id];for(let W in U)p(U[W].object),delete U[W];delete z[R.id]}}function I(){L(),c!==l&&(c=l,f(c.object))}function L(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:I,resetDefaultState:L,dispose:O,releaseStatesOfGeometry:D,releaseStatesOfProgram:B,initAttributes:x,enableAttribute:b,disableUnusedAttributes:C}}function Kdr(e,t,r,n){let i=n.isWebGL2,o;function a(c){o=c}function s(c,u){e.drawArrays(o,c,u),r.update(u,o,1)}function l(c,u,h){if(h===0)return;let f,p;if(i)f=e,p="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),p="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[p](o,c,u,h),r.update(u,o,h)}this.setMode=a,this.render=s,this.renderInstances=l}function Zdr(e,t,r){let n;function i(){if(n!==void 0)return n;if(t.has("EXT_texture_filter_anisotropic")===!0){let k=t.get("EXT_texture_filter_anisotropic");n=e.getParameter(k.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else n=0;return n}function o(k){if(k==="highp"){if(e.getShaderPrecisionFormat(35633,36338).precision>0&&e.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";k="mediump"}return k==="mediump"&&e.getShaderPrecisionFormat(35633,36337).precision>0&&e.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext!="undefined"&&e instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&e instanceof WebGL2ComputeRenderingContext,s=r.precision!==void 0?r.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),u=r.logarithmicDepthBuffer===!0,h=e.getParameter(34930),f=e.getParameter(35660),p=e.getParameter(3379),d=e.getParameter(34076),g=e.getParameter(34921),_=e.getParameter(36347),y=e.getParameter(36348),x=e.getParameter(36349),b=f>0,S=a||t.has("OES_texture_float"),C=b&&S,P=a?e.getParameter(36183):0;return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:i,getMaxPrecision:o,precision:s,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:p,maxCubemapSize:d,maxAttributes:g,maxVertexUniforms:_,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:b,floatFragmentTextures:S,floatVertexTextures:C,maxSamples:P}}function Jdr(e){let t=this,r=null,n=0,i=!1,o=!1,a=new $c,s=new ki,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,p){let d=h.length!==0||f||n!==0||i;return i=f,r=u(h,p,0),n=h.length,d},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(h,f,p){let d=h.clippingPlanes,g=h.clipIntersection,_=h.clipShadows,y=e.get(h);if(!i||d===null||d.length===0||o&&!_)o?u(null):c();else{let x=o?0:n,b=x*4,S=y.clippingState||null;l.value=S,S=u(d,f,b,p);for(let C=0;C!==b;++C)S[C]=r[C];y.clippingState=S,this.numIntersection=g?this.numPlanes:0,this.numPlanes+=x}};function c(){l.value!==r&&(l.value=r,l.needsUpdate=n>0),t.numPlanes=n,t.numIntersection=0}function u(h,f,p,d){let g=h!==null?h.length:0,_=null;if(g!==0){if(_=l.value,d!==!0||_===null){let y=p+g*4,x=f.matrixWorldInverse;s.getNormalMatrix(x),(_===null||_.length<y)&&(_=new Float32Array(y));for(let b=0,S=p;b!==g;++b,S+=4)a.copy(h[b]).applyMatrix4(x,s),a.normal.toArray(_,S),_[S+3]=a.constant}l.value=_,l.needsUpdate=!0}return t.numPlanes=g,t.numIntersection=0,_}}function Qdr(e){let t=new WeakMap;function r(a,s){return s===YP?a.mapping=ix:s===jP&&(a.mapping=ox),a}function n(a){if(a&&a.isTexture&&a.isRenderTargetTexture===!1){let s=a.mapping;if(s===YP||s===jP)if(t.has(a)){let l=t.get(a).texture;return r(l,a.mapping)}else{let l=a.image;if(l&&l.height>0){let c=new Q3(l.height/2);return c.fromEquirectangularTexture(e,a),t.set(a,c),a.addEventListener("dispose",i),r(c.texture,a.mapping)}else return null}}return a}function i(a){let s=a.target;s.removeEventListener("dispose",i);let l=t.get(s);l!==void 0&&(t.delete(s),l.dispose())}function o(){t=new WeakMap}return{get:n,dispose:o}}var O1=class extends N1{constructor(t=-1,r=1,n=1,i=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=r,this.top=n,this.bottom=i,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,r,n,i,o,a){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),r=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2,o=n-t,a=n+t,s=i+r,l=i-r;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=u*this.view.offsetY,l=s-u*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.zoom=this.zoom,r.object.left=this.left,r.object.right=this.right,r.object.top=this.top,r.object.bottom=this.bottom,r.object.near=this.near,r.object.far=this.far,this.view!==null&&(r.object.view=Object.assign({},this.view)),r}};O1.prototype.isOrthographicCamera=!0;var q0=class extends lh{constructor(t){super(t),this.type="RawShaderMaterial"}};q0.prototype.isRawShaderMaterial=!0;var q3=4,B0=8,Kf=Math.pow(2,B0),qfe=[.125,.215,.35,.446,.526,.582],Gfe=B0-q3+1+qfe.length,k3=20,hut=new O1,{_lodPlanes:NP,_sizeLods:Pue,_sigmas:PV}=tmr(),Iue=new ne,fut=null,M1=(1+Math.sqrt(5))/2,R3=1/M1,Lue=[new j(1,1,1),new j(-1,1,1),new j(1,1,-1),new j(-1,1,-1),new j(0,M1,R3),new j(0,M1,-R3),new j(R3,0,M1),new j(-R3,0,M1),new j(M1,R3,0),new j(-M1,R3,0)],e6=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=emr(k3),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,r=0,n=.1,i=100){fut=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,n,i,o),r>0&&this._blur(o,0,0,r),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,r=null){return this._fromTexture(t,r)}fromCubemap(t,r=null){return this._fromTexture(t,r)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=Nue(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=Rue(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<NP.length;t++)NP[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(fut),t.scissorTest=!1,IV(t,0,0,t.width,t.height)}_fromTexture(t,r){fut=this._renderer.getRenderTarget();let n=r||this._allocateTargets(t);return this._textureToCubeUV(t,n),this._applyPMREM(n),this._cleanup(n),n}_allocateTargets(t){let r={magFilter:ii,minFilter:ii,generateMipmaps:!1,type:A1,format:Qo,encoding:tm,depthBuffer:!1},n=kue(r);return n.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=kue(r)),n}_compileMaterial(t){let r=new ti(NP[0],t);this._renderer.compile(r,hut)}_sceneToCubeUV(t,r,n,i){let s=new Ui(90,1,r,n),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(Iue),u.toneMapping=Zd,u.autoClear=!1;let p=new sh({name:"PMREM.Background",side:Ii,depthWrite:!1,depthTest:!1}),d=new ti(new tp,p),g=!1,_=t.background;_?_.isColor&&(p.color.copy(_),t.background=null,g=!0):(p.color.copy(Iue),g=!0);for(let y=0;y<6;y++){let x=y%3;x===0?(s.up.set(0,l[y],0),s.lookAt(c[y],0,0)):x===1?(s.up.set(0,0,l[y]),s.lookAt(0,c[y],0)):(s.up.set(0,l[y],0),s.lookAt(0,0,c[y])),IV(i,x*Kf,y>2?Kf:0,Kf,Kf),u.setRenderTarget(i),g&&u.render(d,s),u.render(t,s)}d.geometry.dispose(),d.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=_}_textureToCubeUV(t,r){let n=this._renderer,i=t.mapping===ix||t.mapping===ox;i?(this._cubemapShader===null&&(this._cubemapShader=Nue()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=Rue());let o=i?this._cubemapShader:this._equirectShader,a=new ti(NP[0],o),s=o.uniforms;s.envMap.value=t,i||s.texelSize.value.set(1/t.image.width,1/t.image.height),IV(r,0,0,3*Kf,2*Kf),n.setRenderTarget(r),n.render(a,hut)}_applyPMREM(t){let r=this._renderer,n=r.autoClear;r.autoClear=!1;for(let i=1;i<Gfe;i++){let o=Math.sqrt(PV[i]*PV[i]-PV[i-1]*PV[i-1]),a=Lue[(i-1)%Lue.length];this._blur(t,i-1,i,o,a)}r.autoClear=n}_blur(t,r,n,i,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,r,n,i,"latitudinal",o),this._halfBlur(a,t,n,n,i,"longitudinal",o)}_halfBlur(t,r,n,i,o,a,s){let l=this._renderer,c=this._blurMaterial;a!=="latitudinal"&&a!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new ti(NP[i],c),f=c.uniforms,p=Pue[n]-1,d=isFinite(o)?Math.PI/(2*p):2*Math.PI/(2*k3-1),g=o/d,_=isFinite(o)?1+Math.floor(u*g):k3;_>k3&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${_} samples when the maximum is set to ${k3}`);let y=[],x=0;for(let P=0;P<k3;++P){let k=P/g,O=Math.exp(-k*k/2);y.push(O),P===0?x+=O:P<_&&(x+=2*O)}for(let P=0;P<y.length;P++)y[P]=y[P]/x;f.envMap.value=t.texture,f.samples.value=_,f.weights.value=y,f.latitudinal.value=a==="latitudinal",s&&(f.poleAxis.value=s),f.dTheta.value=d,f.mipInt.value=B0-n;let b=Pue[i],S=3*Math.max(0,Kf-2*b),C=(i===0?0:2*Kf)+2*b*(i>B0-q3?i-B0+q3:0);IV(r,S,C,3*b,2*b),l.setRenderTarget(r),l.render(h,hut)}};function tmr(){let e=[],t=[],r=[],n=B0;for(let i=0;i<Gfe;i++){let o=Math.pow(2,n);t.push(o);let a=1/o;i>B0-q3?a=qfe[i-B0+q3-1]:i===0&&(a=0),r.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,p=3,d=2,g=1,_=new Float32Array(p*f*h),y=new Float32Array(d*f*h),x=new Float32Array(g*f*h);for(let S=0;S<h;S++){let C=S%3*2/3-1,P=S>2?0:-1,k=[C,P,0,C+2/3,P,0,C+2/3,P+1,0,C,P,0,C+2/3,P+1,0,C,P+1,0];_.set(k,p*f*S),y.set(u,d*f*S);let O=[S,S,S,S,S,S];x.set(O,g*f*S)}let b=new Pe;b.setAttribute("position",new Je(_,p)),b.setAttribute("uv",new Je(y,d)),b.setAttribute("faceIndex",new Je(x,g)),e.push(b),n>q3&&n--}return{_lodPlanes:e,_sizeLods:t,_sigmas:r}}function kue(e){let t=new hs(3*Kf,3*Kf,e);return t.texture.mapping=xM,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function IV(e,t,r,n,i){e.viewport.set(t,r,n,i),e.scissor.set(t,r,n,i)}function emr(e){let t=new Float32Array(e),r=new j(0,1,0);return new q0({name:"SphericalGaussianBlur",defines:{n:e},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:r}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:Kd,depthTest:!1,depthWrite:!1})}function Rue(){let e=new Lt(1,1);return new q0({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:e}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:Kd,depthTest:!1,depthWrite:!1})}function Nue(){return new q0({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:Nht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:Kd,depthTest:!1,depthWrite:!1})}function Nht(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function rmr(e){let t=new WeakMap,r=null;function n(s){if(s&&s.isTexture){let l=s.mapping,c=l===YP||l===jP,u=l===ix||l===ox;if(c||u)if(s.isRenderTargetTexture&&s.needsPMREMUpdate===!0){s.needsPMREMUpdate=!1;let h=t.get(s);return r===null&&(r=new e6(e)),h=c?r.fromEquirectangular(s,h):r.fromCubemap(s,h),t.set(s,h),h.texture}else{if(t.has(s))return t.get(s).texture;{let h=s.image;if(c&&h&&h.height>0||u&&h&&i(h)){r===null&&(r=new e6(e));let f=c?r.fromEquirectangular(s):r.fromCubemap(s);return t.set(s,f),s.addEventListener("dispose",o),f.texture}else return null}}}return s}function i(s){let l=0,c=6;for(let u=0;u<c;u++)s[u]!==void 0&&l++;return l===c}function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function a(){t=new WeakMap,r!==null&&(r.dispose(),r=null)}return{get:n,dispose:a}}function nmr(e){let t={};function r(n){if(t[n]!==void 0)return t[n];let i;switch(n){case"WEBGL_depth_texture":i=e.getExtension("WEBGL_depth_texture")||e.getExtension("MOZ_WEBGL_depth_texture")||e.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=e.getExtension("EXT_texture_filter_anisotropic")||e.getExtension("MOZ_EXT_texture_filter_anisotropic")||e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=e.getExtension("WEBGL_compressed_texture_s3tc")||e.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=e.getExtension("WEBGL_compressed_texture_pvrtc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=e.getExtension(n)}return t[n]=i,i}return{has:function(n){return r(n)!==null},init:function(n){n.isWebGL2?r("EXT_color_buffer_float"):(r("WEBGL_depth_texture"),r("OES_texture_float"),r("OES_texture_half_float"),r("OES_texture_half_float_linear"),r("OES_standard_derivatives"),r("OES_element_index_uint"),r("OES_vertex_array_object"),r("ANGLE_instanced_arrays")),r("OES_texture_float_linear"),r("EXT_color_buffer_half_float"),r("WEBGL_multisampled_render_to_texture")},get:function(n){let i=r(n);return i===null&&console.warn("THREE.WebGLRenderer: "+n+" extension not supported."),i}}}function imr(e,t,r,n){let i={},o=new WeakMap;function a(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let d in f.attributes)t.remove(f.attributes[d]);f.removeEventListener("dispose",a),delete i[f.id];let p=o.get(f);p&&(t.remove(p),o.delete(f)),n.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,r.memory.geometries--}function s(h,f){return i[f.id]===!0||(f.addEventListener("dispose",a),i[f.id]=!0,r.memory.geometries++),f}function l(h){let f=h.attributes;for(let d in f)t.update(f[d],34962);let p=h.morphAttributes;for(let d in p){let g=p[d];for(let _=0,y=g.length;_<y;_++)t.update(g[_],34962)}}function c(h){let f=[],p=h.index,d=h.attributes.position,g=0;if(p!==null){let x=p.array;g=p.version;for(let b=0,S=x.length;b<S;b+=3){let C=x[b+0],P=x[b+1],k=x[b+2];f.push(C,P,P,k,k,C)}}else{let x=d.array;g=d.version;for(let b=0,S=x.length/3-1;b<S;b+=3){let C=b+0,P=b+1,k=b+2;f.push(C,P,P,k,k,C)}}let _=new(Bfe(f)?K3:$3)(f,1);_.version=g;let y=o.get(h);y&&t.remove(y),o.set(h,_)}function u(h){let f=o.get(h);if(f){let p=h.index;p!==null&&f.version<p.version&&c(h)}else c(h);return o.get(h)}return{get:s,update:l,getWireframeAttribute:u}}function omr(e,t,r,n){let i=n.isWebGL2,o;function a(f){o=f}let s,l;function c(f){s=f.type,l=f.bytesPerElement}function u(f,p){e.drawElements(o,p,s,f*l),r.update(p,o,1)}function h(f,p,d){if(d===0)return;let g,_;if(i)g=e,_="drawElementsInstanced";else if(g=t.get("ANGLE_instanced_arrays"),_="drawElementsInstancedANGLE",g===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}g[_](o,p,s,f*l,d),r.update(p,o,d)}this.setMode=a,this.setIndex=c,this.render=u,this.renderInstances=h}function amr(e){let t={geometries:0,textures:0},r={frame:0,calls:0,triangles:0,points:0,lines:0};function n(o,a,s){switch(r.calls++,a){case 4:r.triangles+=s*(o/3);break;case 1:r.lines+=s*(o/2);break;case 3:r.lines+=s*(o-1);break;case 2:r.lines+=s*o;break;case 0:r.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a);break}}function i(){r.frame++,r.calls=0,r.triangles=0,r.points=0,r.lines=0}return{memory:t,render:r,programs:null,autoReset:!0,reset:i,update:n}}var tM=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};tM.prototype.isDataTexture2DArray=!0;function smr(e,t){return e[0]-t[0]}function lmr(e,t){return Math.abs(t[1])-Math.abs(e[1])}function Due(e,t){let r=1,n=t.isInterleavedBufferAttribute?t.data.array:t.array;n instanceof Int8Array?r=127:n instanceof Int16Array?r=32767:n instanceof Int32Array?r=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",n),e.divideScalar(r)}function cmr(e,t,r){let n={},i=new Float32Array(8),o=new WeakMap,a=new j,s=[];for(let c=0;c<8;c++)s[c]=[c,0];function l(c,u,h,f){let p=c.morphTargetInfluences;if(t.isWebGL2===!0){let d=u.morphAttributes.position.length,g=o.get(u);if(g===void 0||g.count!==d){let L=function(){B.dispose(),o.delete(u),u.removeEventListener("dispose",L)};g!==void 0&&g.texture.dispose();let x=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,S=u.morphAttributes.normal||[],C=u.attributes.position.count,P=x===!0?2:1,k=C*P,O=1;k>t.maxTextureSize&&(O=Math.ceil(k/t.maxTextureSize),k=t.maxTextureSize);let D=new Float32Array(k*O*4*d),B=new tM(D,k,O,d);B.format=Qo,B.type=Xd,B.needsUpdate=!0;let I=P*4;for(let R=0;R<d;R++){let F=b[R],z=S[R],U=k*O*4*R;for(let W=0;W<F.count;W++){a.fromBufferAttribute(F,W),F.normalized===!0&&Due(a,F);let Z=W*I;D[U+Z+0]=a.x,D[U+Z+1]=a.y,D[U+Z+2]=a.z,D[U+Z+3]=0,x===!0&&(a.fromBufferAttribute(z,W),z.normalized===!0&&Due(a,z),D[U+Z+4]=a.x,D[U+Z+5]=a.y,D[U+Z+6]=a.z,D[U+Z+7]=0)}}g={count:d,texture:B,size:new Lt(k,O)},o.set(u,g),u.addEventListener("dispose",L)}let _=0;for(let x=0;x<p.length;x++)_+=p[x];let y=u.morphTargetsRelative?1:1-_;f.getUniforms().setValue(e,"morphTargetBaseInfluence",y),f.getUniforms().setValue(e,"morphTargetInfluences",p),f.getUniforms().setValue(e,"morphTargetsTexture",g.texture,r),f.getUniforms().setValue(e,"morphTargetsTextureSize",g.size)}else{let d=p===void 0?0:p.length,g=n[u.id];if(g===void 0||g.length!==d){g=[];for(let S=0;S<d;S++)g[S]=[S,0];n[u.id]=g}for(let S=0;S<d;S++){let C=g[S];C[0]=S,C[1]=p[S]}g.sort(lmr);for(let S=0;S<8;S++)S<d&&g[S][1]?(s[S][0]=g[S][0],s[S][1]=g[S][1]):(s[S][0]=Number.MAX_SAFE_INTEGER,s[S][1]=0);s.sort(smr);let _=u.morphAttributes.position,y=u.morphAttributes.normal,x=0;for(let S=0;S<8;S++){let C=s[S],P=C[0],k=C[1];P!==Number.MAX_SAFE_INTEGER&&k?(_&&u.getAttribute("morphTarget"+S)!==_[P]&&u.setAttribute("morphTarget"+S,_[P]),y&&u.getAttribute("morphNormal"+S)!==y[P]&&u.setAttribute("morphNormal"+S,y[P]),i[S]=k,x+=k):(_&&u.hasAttribute("morphTarget"+S)===!0&&u.deleteAttribute("morphTarget"+S),y&&u.hasAttribute("morphNormal"+S)===!0&&u.deleteAttribute("morphNormal"+S),i[S]=0)}let b=u.morphTargetsRelative?1:1-x;f.getUniforms().setValue(e,"morphTargetBaseInfluence",b),f.getUniforms().setValue(e,"morphTargetInfluences",i)}}return{update:l}}function umr(e,t,r,n){let i=new WeakMap;function o(l){let c=n.render.frame,u=l.geometry,h=t.get(l,u);return i.get(h)!==c&&(t.update(h),i.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",s)===!1&&l.addEventListener("dispose",s),r.update(l.instanceMatrix,34962),l.instanceColor!==null&&r.update(l.instanceColor,34962)),h}function a(){i=new WeakMap}function s(l){let c=l.target;c.removeEventListener("dispose",s),r.remove(c.instanceMatrix),c.instanceColor!==null&&r.remove(c.instanceColor)}return{update:o,dispose:a}}var r6=class extends vi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};r6.prototype.isDataTexture3D=!0;var Wfe=new vi,Yfe=new tM,jfe=new r6,Xfe=new V0,Oue=[],zue=[],Fue=new Float32Array(16),Bue=new Float32Array(9),Hue=new Float32Array(4);function bM(e,t,r){let n=e[0];if(n<=0||n>0)return e;let i=t*r,o=Oue[i];if(o===void 0&&(o=new Float32Array(i),Oue[i]=o),t!==0){n.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=r,e[a].toArray(o,s)}return o}function fs(e,t){if(e.length!==t.length)return!1;for(let r=0,n=e.length;r<n;r++)if(e[r]!==t[r])return!1;return!0}function Aa(e,t){for(let r=0,n=t.length;r<n;r++)e[r]=t[r]}function KU(e,t){let r=zue[t];r===void 0&&(r=new Int32Array(t),zue[t]=r);for(let n=0;n!==t;++n)r[n]=e.allocateTextureUnit();return r}function hmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1f(this.addr,t),r[0]=t)}function fmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y)&&(e.uniform2f(this.addr,t.x,t.y),r[0]=t.x,r[1]=t.y);else{if(fs(r,t))return;e.uniform2fv(this.addr,t),Aa(r,t)}}function pmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z)&&(e.uniform3f(this.addr,t.x,t.y,t.z),r[0]=t.x,r[1]=t.y,r[2]=t.z);else if(t.r!==void 0)(r[0]!==t.r||r[1]!==t.g||r[2]!==t.b)&&(e.uniform3f(this.addr,t.r,t.g,t.b),r[0]=t.r,r[1]=t.g,r[2]=t.b);else{if(fs(r,t))return;e.uniform3fv(this.addr,t),Aa(r,t)}}function dmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z||r[3]!==t.w)&&(e.uniform4f(this.addr,t.x,t.y,t.z,t.w),r[0]=t.x,r[1]=t.y,r[2]=t.z,r[3]=t.w);else{if(fs(r,t))return;e.uniform4fv(this.addr,t),Aa(r,t)}}function mmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(fs(r,t))return;e.uniformMatrix2fv(this.addr,!1,t),Aa(r,t)}else{if(fs(r,n))return;Hue.set(n),e.uniformMatrix2fv(this.addr,!1,Hue),Aa(r,n)}}function gmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(fs(r,t))return;e.uniformMatrix3fv(this.addr,!1,t),Aa(r,t)}else{if(fs(r,n))return;Bue.set(n),e.uniformMatrix3fv(this.addr,!1,Bue),Aa(r,n)}}function _mr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(fs(r,t))return;e.uniformMatrix4fv(this.addr,!1,t),Aa(r,t)}else{if(fs(r,n))return;Fue.set(n),e.uniformMatrix4fv(this.addr,!1,Fue),Aa(r,n)}}function ymr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1i(this.addr,t),r[0]=t)}function vmr(e,t){let r=this.cache;fs(r,t)||(e.uniform2iv(this.addr,t),Aa(r,t))}function xmr(e,t){let r=this.cache;fs(r,t)||(e.uniform3iv(this.addr,t),Aa(r,t))}function bmr(e,t){let r=this.cache;fs(r,t)||(e.uniform4iv(this.addr,t),Aa(r,t))}function wmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1ui(this.addr,t),r[0]=t)}function Smr(e,t){let r=this.cache;fs(r,t)||(e.uniform2uiv(this.addr,t),Aa(r,t))}function Mmr(e,t){let r=this.cache;fs(r,t)||(e.uniform3uiv(this.addr,t),Aa(r,t))}function Emr(e,t){let r=this.cache;fs(r,t)||(e.uniform4uiv(this.addr,t),Aa(r,t))}function Tmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTexture2D(t||Wfe,i)}function Cmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture3D(t||jfe,i)}function Amr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTextureCube(t||Xfe,i)}function Pmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture2DArray(t||Yfe,i)}function Imr(e){switch(e){case 5126:return hmr;case 35664:return fmr;case 35665:return pmr;case 35666:return dmr;case 35674:return mmr;case 35675:return gmr;case 35676:return _mr;case 5124:case 35670:return ymr;case 35667:case 35671:return vmr;case 35668:case 35672:return xmr;case 35669:case 35673:return bmr;case 5125:return wmr;case 36294:return Smr;case 36295:return Mmr;case 36296:return Emr;case 35678:case 36198:case 36298:case 36306:case 35682:return Tmr;case 35679:case 36299:case 36307:return Cmr;case 35680:case 36300:case 36308:case 36293:return Amr;case 36289:case 36303:case 36311:case 36292:return Pmr}}function Lmr(e,t){e.uniform1fv(this.addr,t)}function kmr(e,t){let r=bM(t,this.size,2);e.uniform2fv(this.addr,r)}function Rmr(e,t){let r=bM(t,this.size,3);e.uniform3fv(this.addr,r)}function Nmr(e,t){let r=bM(t,this.size,4);e.uniform4fv(this.addr,r)}function Dmr(e,t){let r=bM(t,this.size,4);e.uniformMatrix2fv(this.addr,!1,r)}function Omr(e,t){let r=bM(t,this.size,9);e.uniformMatrix3fv(this.addr,!1,r)}function zmr(e,t){let r=bM(t,this.size,16);e.uniformMatrix4fv(this.addr,!1,r)}function Fmr(e,t){e.uniform1iv(this.addr,t)}function Bmr(e,t){e.uniform2iv(this.addr,t)}function Hmr(e,t){e.uniform3iv(this.addr,t)}function Vmr(e,t){e.uniform4iv(this.addr,t)}function Umr(e,t){e.uniform1uiv(this.addr,t)}function qmr(e,t){e.uniform2uiv(this.addr,t)}function Gmr(e,t){e.uniform3uiv(this.addr,t)}function Wmr(e,t){e.uniform4uiv(this.addr,t)}function Ymr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTexture2D(t[o]||Wfe,i[o])}function jmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture3D(t[o]||jfe,i[o])}function Xmr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTextureCube(t[o]||Xfe,i[o])}function $mr(e,t,r){let n=t.length,i=KU(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture2DArray(t[o]||Yfe,i[o])}function Kmr(e){switch(e){case 5126:return Lmr;case 35664:return kmr;case 35665:return Rmr;case 35666:return Nmr;case 35674:return Dmr;case 35675:return Omr;case 35676:return zmr;case 5124:case 35670:return Fmr;case 35667:case 35671:return Bmr;case 35668:case 35672:return Hmr;case 35669:case 35673:return Vmr;case 5125:return Umr;case 36294:return qmr;case 36295:return Gmr;case 36296:return Wmr;case 35678:case 36198:case 36298:case 36306:case 35682:return Ymr;case 35679:case 36299:case 36307:return jmr;case 35680:case 36300:case 36308:case 36293:return Xmr;case 36289:case 36303:case 36311:case 36292:return $mr}}function Zmr(e,t,r){this.id=e,this.addr=r,this.cache=[],this.setValue=Imr(t.type)}function $fe(e,t,r){this.id=e,this.addr=r,this.cache=[],this.size=t.size,this.setValue=Kmr(t.type)}$fe.prototype.updateCache=function(e){let t=this.cache;e instanceof Float32Array&&t.length!==e.length&&(this.cache=new Float32Array(e.length)),Aa(t,e)};function Kfe(e){this.id=e,this.seq=[],this.map={}}Kfe.prototype.setValue=function(e,t,r){let n=this.seq;for(let i=0,o=n.length;i!==o;++i){let a=n[i];a.setValue(e,t[a.id],r)}};var put=/(\w+)(\])?(\[|\.)?/g;function Vue(e,t){e.seq.push(t),e.map[t.id]=t}function Jmr(e,t,r){let n=e.name,i=n.length;for(put.lastIndex=0;;){let o=put.exec(n),a=put.lastIndex,s=o[1],l=o[2]==="]",c=o[3];if(l&&(s=s|0),c===void 0||c==="["&&a+2===i){Vue(r,c===void 0?new Zmr(s,e,t):new $fe(s,e,t));break}else{let h=r.map[s];h===void 0&&(h=new Kfe(s),Vue(r,h)),r=h}}}function H0(e,t){this.seq=[],this.map={};let r=e.getProgramParameter(t,35718);for(let n=0;n<r;++n){let i=e.getActiveUniform(t,n),o=e.getUniformLocation(t,i.name);Jmr(i,o,this)}}H0.prototype.setValue=function(e,t,r,n){let i=this.map[t];i!==void 0&&i.setValue(e,r,n)};H0.prototype.setOptional=function(e,t,r){let n=t[r];n!==void 0&&this.setValue(e,r,n)};H0.upload=function(e,t,r,n){for(let i=0,o=t.length;i!==o;++i){let a=t[i],s=r[a.id];s.needsUpdate!==!1&&a.setValue(e,s.value,n)}};H0.seqWithValue=function(e,t){let r=[];for(let n=0,i=e.length;n!==i;++n){let o=e[n];o.id in t&&r.push(o)}return r};function Uue(e,t,r){let n=e.createShader(t);return e.shaderSource(n,r),e.compileShader(n),n}var Qmr=0;function tgr(e){let t=e.split(`
`);for(let r=0;r<t.length;r++)t[r]=r+1+": "+t[r];return t.join(`
`)}function egr(e){switch(e){case tm:return["Linear","( value )"];case Yn:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",e),["Linear","( value )"]}}function que(e,t,r){let n=e.getShaderParameter(t,35713),i=e.getShaderInfoLog(t).trim();return n&&i===""?"":r.toUpperCase()+`

`+i+`

`+tgr(e.getShaderSource(t))}function rgr(e,t){let r=egr(t);return"vec4 "+e+"( vec4 value ) { return LinearTo"+r[0]+r[1]+"; }"}function ngr(e,t){let r;switch(t){case ufe:r="Linear";break;case hfe:r="Reinhard";break;case ffe:r="OptimizedCineon";break;case pfe:r="ACESFilmic";break;case dfe:r="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),r="Linear"}return"vec3 "+e+"( vec3 color ) { return "+r+"ToneMapping( color ); }"}function igr(e){return[e.extensionDerivatives||e.envMapCubeUV||e.bumpMap||e.tangentSpaceNormalMap||e.clearcoatNormalMap||e.flatShading||e.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(e.extensionFragDepth||e.logarithmicDepthBuffer)&&e.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",e.extensionDrawBuffers&&e.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(e.extensionShaderTextureLOD||e.envMap||e.transmission)&&e.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(HP).join(`
`)}function ogr(e){let t=[];for(let r in e){let n=e[r];n!==!1&&t.push("#define "+r+" "+n)}return t.join(`
`)}function agr(e,t){let r={},n=e.getProgramParameter(t,35721);for(let i=0;i<n;i++){let o=e.getActiveAttrib(t,i),a=o.name,s=1;o.type===35674&&(s=2),o.type===35675&&(s=3),o.type===35676&&(s=4),r[a]={type:o.type,location:e.getAttribLocation(t,a),locationSize:s}}return r}function HP(e){return e!==""}function Gue(e,t){return e.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Wue(e,t){return e.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sgr=/^[ \t]*#include +<([\w\d./]+)>/gm;function Jut(e){return e.replace(sgr,lgr)}function lgr(e,t){let r=hr[t];if(r===void 0)throw new Error("Can not resolve #include <"+t+">");return Jut(r)}var cgr=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,ugr=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Yue(e){return e.replace(ugr,Zfe).replace(cgr,hgr)}function hgr(e,t,r,n){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),Zfe(e,t,r,n)}function Zfe(e,t,r,n){let i="";for(let o=parseInt(t);o<parseInt(r);o++)i+=n.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return i}function jue(e){let t="precision "+e.precision+` float;
precision `+e.precision+" int;";return e.precision==="highp"?t+=`
#define HIGH_PRECISION`:e.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:e.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function fgr(e){let t="SHADOWMAP_TYPE_BASIC";return e.shadowMapType===Cht?t="SHADOWMAP_TYPE_PCF":e.shadowMapType===Uhe?t="SHADOWMAP_TYPE_PCF_SOFT":e.shadowMapType===F3&&(t="SHADOWMAP_TYPE_VSM"),t}function pgr(e){let t="ENVMAP_TYPE_CUBE";if(e.envMap)switch(e.envMapMode){case ix:case ox:t="ENVMAP_TYPE_CUBE";break;case xM:case z6:t="ENVMAP_TYPE_CUBE_UV";break}return t}function dgr(e){let t="ENVMAP_MODE_REFLECTION";if(e.envMap)switch(e.envMapMode){case ox:case z6:t="ENVMAP_MODE_REFRACTION";break}return t}function mgr(e){let t="ENVMAP_BLENDING_NONE";if(e.envMap)switch(e.combine){case O6:t="ENVMAP_BLENDING_MULTIPLY";break;case lfe:t="ENVMAP_BLENDING_MIX";break;case cfe:t="ENVMAP_BLENDING_ADD";break}return t}function ggr(e,t,r,n){let i=e.getContext(),o=r.defines,a=r.vertexShader,s=r.fragmentShader,l=fgr(r),c=pgr(r),u=dgr(r),h=mgr(r),f=r.isWebGL2?"":igr(r),p=ogr(o),d=i.createProgram(),g,_,y=r.glslVersion?"#version "+r.glslVersion+`
`:"";r.isRawShaderMaterial?(g=[p].filter(HP).join(`
`),g.length>0&&(g+=`
`),_=[f,p].filter(HP).join(`
`),_.length>0&&(_+=`
`)):(g=[jue(r),"#define SHADER_NAME "+r.shaderName,p,r.instancing?"#define USE_INSTANCING":"",r.instancingColor?"#define USE_INSTANCING_COLOR":"",r.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+r.maxBones,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+u:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.displacementMap&&r.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.flatShading?"#define FLAT_SHADED":"",r.skinning?"#define USE_SKINNING":"",r.useVertexTexture?"#define BONE_TEXTURE":"",r.morphTargets?"#define USE_MORPHTARGETS":"",r.morphNormals&&r.flatShading===!1?"#define USE_MORPHNORMALS":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_COUNT "+r.morphTargetsCount:"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.sizeAttenuation?"#define USE_SIZEATTENUATION":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter(HP).join(`
`),_=[f,jue(r),"#define SHADER_NAME "+r.shaderName,p,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.matcap?"#define USE_MATCAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+c:"",r.envMap?"#define "+u:"",r.envMap?"#define "+h:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoat?"#define USE_CLEARCOAT":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.alphaTest?"#define USE_ALPHATEST":"",r.sheen?"#define USE_SHEEN":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors||r.instancingColor?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.gradientMap?"#define USE_GRADIENTMAP":"",r.flatShading?"#define FLAT_SHADED":"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",r.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(r.extensionShaderTextureLOD||r.envMap)&&r.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",r.toneMapping!==Zd?"#define TONE_MAPPING":"",r.toneMapping!==Zd?hr.tonemapping_pars_fragment:"",r.toneMapping!==Zd?ngr("toneMapping",r.toneMapping):"",r.dithering?"#define DITHERING":"",r.alphaWrite?"":"#define OPAQUE",hr.encodings_pars_fragment,rgr("linearToOutputTexel",r.outputEncoding),r.depthPacking?"#define DEPTH_PACKING "+r.depthPacking:"",`
`].filter(HP).join(`
`)),a=Jut(a),a=Gue(a,r),a=Wue(a,r),s=Jut(s),s=Gue(s,r),s=Wue(s,r),a=Yue(a),s=Yue(s),r.isWebGL2&&r.isRawShaderMaterial!==!0&&(y=`#version 300 es
`,g=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+g,_=["#define varying in",r.glslVersion===Kut?"":"layout(location = 0) out highp vec4 pc_fragColor;",r.glslVersion===Kut?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+_);let x=y+g+a,b=y+_+s,S=Uue(i,35633,x),C=Uue(i,35632,b);if(i.attachShader(d,S),i.attachShader(d,C),r.index0AttributeName!==void 0?i.bindAttribLocation(d,0,r.index0AttributeName):r.morphTargets===!0&&i.bindAttribLocation(d,0,"position"),i.linkProgram(d),e.debug.checkShaderErrors){let O=i.getProgramInfoLog(d).trim(),D=i.getShaderInfoLog(S).trim(),B=i.getShaderInfoLog(C).trim(),I=!0,L=!0;if(i.getProgramParameter(d,35714)===!1){I=!1;let R=que(i,S,"vertex"),F=que(i,C,"fragment");console.error("THREE.WebGLProgram: Shader Error "+i.getError()+" - VALIDATE_STATUS "+i.getProgramParameter(d,35715)+`

Program Info Log: `+O+`
`+R+`
`+F)}else O!==""?console.warn("THREE.WebGLProgram: Program Info Log:",O):(D===""||B==="")&&(L=!1);L&&(this.diagnostics={runnable:I,programLog:O,vertexShader:{log:D,prefix:g},fragmentShader:{log:B,prefix:_}})}i.deleteShader(S),i.deleteShader(C);let P;this.getUniforms=function(){return P===void 0&&(P=new H0(i,d)),P};let k;return this.getAttributes=function(){return k===void 0&&(k=agr(i,d)),k},this.destroy=function(){n.releaseStatesOfProgram(this),i.deleteProgram(d),this.program=void 0},this.name=r.shaderName,this.id=Qmr++,this.cacheKey=t,this.usedTimes=1,this.program=d,this.vertexShader=S,this.fragmentShader=C,this}var _gr=0,Qut=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let r=t.vertexShader,n=t.fragmentShader,i=this._getShaderStage(r),o=this._getShaderStage(n),a=this._getShaderCacheForMaterial(t);return a.has(i)===!1&&(a.add(i),i.usedTimes++),a.has(o)===!1&&(a.add(o),o.usedTimes++),this}remove(t){let r=this.materialCache.get(t);for(let n of r)n.usedTimes--,n.usedTimes===0&&this.shaderCache.delete(n);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let r=this.materialCache;return r.has(t)===!1&&r.set(t,new Set),r.get(t)}_getShaderStage(t){let r=this.shaderCache;if(r.has(t)===!1){let n=new tht;r.set(t,n)}return r.get(t)}},tht=class{constructor(){this.id=_gr++,this.usedTimes=0}};function ygr(e,t,r,n,i,o,a){let s=new X3,l=new Qut,c=[],u=i.isWebGL2,h=i.logarithmicDepthBuffer,f=i.floatVertexTextures,p=i.maxVertexUniforms,d=i.vertexTextures,g=i.precision,_={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function y(I){let R=I.skeleton.bones;if(f)return 1024;{let z=Math.floor((p-20)/4),U=Math.min(z,R.length);return U<R.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+R.length+" bones. This GPU supports "+U+"."),0):U}}function x(I,L,R,F,z){let U=F.fog,W=I.isMeshStandardMaterial?F.environment:null,Z=(I.isMeshStandardMaterial?r:t).get(I.envMap||W),rt=_[I.type],ot=z.isSkinnedMesh?y(z):0;I.precision!==null&&(g=i.getMaxPrecision(I.precision),g!==I.precision&&console.warn("THREE.WebGLProgram.getParameters:",I.precision,"not supported, using",g,"instead."));let st,St,bt,Mt;if(rt){let X=ah[rt];st=X.vertexShader,St=X.fragmentShader}else st=I.vertexShader,St=I.fragmentShader,l.update(I),bt=l.getVertexShaderID(I),Mt=l.getFragmentShaderID(I);let lt=e.getRenderTarget(),Kt=I.alphaTest>0,_t=I.clearcoat>0;return{isWebGL2:u,shaderID:rt,shaderName:I.type,vertexShader:st,fragmentShader:St,defines:I.defines,customVertexShaderID:bt,customFragmentShaderID:Mt,isRawShaderMaterial:I.isRawShaderMaterial===!0,glslVersion:I.glslVersion,precision:g,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:d,outputEncoding:lt===null?e.outputEncoding:lt.isXRRenderTarget===!0?lt.texture.encoding:tm,map:!!I.map,matcap:!!I.matcap,envMap:!!Z,envMapMode:Z&&Z.mapping,envMapCubeUV:!!Z&&(Z.mapping===xM||Z.mapping===z6),lightMap:!!I.lightMap,aoMap:!!I.aoMap,emissiveMap:!!I.emissiveMap,bumpMap:!!I.bumpMap,normalMap:!!I.normalMap,objectSpaceNormalMap:I.normalMapType===Dfe,tangentSpaceNormalMap:I.normalMapType===sx,decodeVideoTexture:!!I.map&&I.map.isVideoTexture===!0&&I.map.encoding===Yn,clearcoat:_t,clearcoatMap:_t&&!!I.clearcoatMap,clearcoatRoughnessMap:_t&&!!I.clearcoatRoughnessMap,clearcoatNormalMap:_t&&!!I.clearcoatNormalMap,displacementMap:!!I.displacementMap,roughnessMap:!!I.roughnessMap,metalnessMap:!!I.metalnessMap,specularMap:!!I.specularMap,specularIntensityMap:!!I.specularIntensityMap,specularColorMap:!!I.specularColorMap,alphaMap:!!I.alphaMap,alphaTest:Kt,alphaWrite:I.alphaWrite||I.transparent,gradientMap:!!I.gradientMap,sheen:I.sheen>0,sheenColorMap:!!I.sheenColorMap,sheenRoughnessMap:!!I.sheenRoughnessMap,transmission:I.transmission>0,transmissionMap:!!I.transmissionMap,thicknessMap:!!I.thicknessMap,combine:I.combine,vertexTangents:!!I.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:I.vertexColors,vertexAlphas:I.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatMap||!!I.clearcoatRoughnessMap||!!I.clearcoatNormalMap||!!I.displacementMap||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||!!I.sheenColorMap||!!I.sheenRoughnessMap,uvsVertexOnly:!(!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatNormalMap||I.transmission>0||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||I.sheen>0||!!I.sheenColorMap||!!I.sheenRoughnessMap)&&!!I.displacementMap,fog:!!U,useFog:I.fog,fogExp2:U&&U.isFogExp2,flatShading:!!I.flatShading,sizeAttenuation:I.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&ot>0,maxBones:ot,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:L.directional.length,numPointLights:L.point.length,numSpotLights:L.spot.length,numRectAreaLights:L.rectArea.length,numHemiLights:L.hemi.length,numDirLightShadows:L.directionalShadowMap.length,numPointLightShadows:L.pointShadowMap.length,numSpotLightShadows:L.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:I.dithering,shadowMapEnabled:e.shadowMap.enabled&&R.length>0,shadowMapType:e.shadowMap.type,toneMapping:I.toneMapped?e.toneMapping:Zd,physicallyCorrectLights:e.physicallyCorrectLights,premultipliedAlpha:I.premultipliedAlpha,doubleSided:I.side===k1,flipSided:I.side===Ii,depthPacking:I.depthPacking!==void 0?I.depthPacking:!1,index0AttributeName:I.index0AttributeName,extensionDerivatives:I.extensions&&I.extensions.derivatives,extensionFragDepth:I.extensions&&I.extensions.fragDepth,extensionDrawBuffers:I.extensions&&I.extensions.drawBuffers,extensionShaderTextureLOD:I.extensions&&I.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||n.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||n.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||n.has("EXT_shader_texture_lod"),customProgramCacheKey:I.customProgramCacheKey()}}function b(I){let L=[];if(I.shaderID?L.push(I.shaderID):(L.push(I.customVertexShaderID),L.push(I.customFragmentShaderID)),I.defines!==void 0)for(let R in I.defines)L.push(R),L.push(I.defines[R]);return I.isRawShaderMaterial===!1&&(S(L,I),C(L,I),L.push(e.outputEncoding)),L.push(I.customProgramCacheKey),L.join()}function S(I,L){I.push(L.precision),I.push(L.outputEncoding),I.push(L.envMapMode),I.push(L.combine),I.push(L.vertexUvs),I.push(L.fogExp2),I.push(L.sizeAttenuation),I.push(L.maxBones),I.push(L.morphTargetsCount),I.push(L.numDirLights),I.push(L.numPointLights),I.push(L.numSpotLights),I.push(L.numHemiLights),I.push(L.numRectAreaLights),I.push(L.numDirLightShadows),I.push(L.numPointLightShadows),I.push(L.numSpotLightShadows),I.push(L.shadowMapType),I.push(L.toneMapping),I.push(L.numClippingPlanes),I.push(L.numClipIntersection),I.push(L.alphaWrite)}function C(I,L){s.disableAll(),L.isWebGL2&&s.enable(0),L.supportsVertexTextures&&s.enable(1),L.instancing&&s.enable(2),L.instancingColor&&s.enable(3),L.map&&s.enable(4),L.matcap&&s.enable(5),L.envMap&&s.enable(6),L.envMapCubeUV&&s.enable(7),L.lightMap&&s.enable(8),L.aoMap&&s.enable(9),L.emissiveMap&&s.enable(10),L.bumpMap&&s.enable(11),L.normalMap&&s.enable(12),L.objectSpaceNormalMap&&s.enable(13),L.tangentSpaceNormalMap&&s.enable(14),L.clearcoat&&s.enable(15),L.clearcoatMap&&s.enable(16),L.clearcoatRoughnessMap&&s.enable(17),L.clearcoatNormalMap&&s.enable(18),L.displacementMap&&s.enable(19),L.specularMap&&s.enable(20),L.roughnessMap&&s.enable(21),L.metalnessMap&&s.enable(22),L.gradientMap&&s.enable(23),L.alphaMap&&s.enable(24),L.alphaTest&&s.enable(25),L.vertexColors&&s.enable(26),L.vertexAlphas&&s.enable(27),L.vertexUvs&&s.enable(28),L.vertexTangents&&s.enable(29),L.uvsVertexOnly&&s.enable(30),L.fog&&s.enable(31),I.push(s.mask),s.disableAll(),L.useFog&&s.enable(0),L.flatShading&&s.enable(1),L.logarithmicDepthBuffer&&s.enable(2),L.skinning&&s.enable(3),L.useVertexTexture&&s.enable(4),L.morphTargets&&s.enable(5),L.morphNormals&&s.enable(6),L.premultipliedAlpha&&s.enable(7),L.shadowMapEnabled&&s.enable(8),L.physicallyCorrectLights&&s.enable(9),L.doubleSided&&s.enable(10),L.flipSided&&s.enable(11),L.depthPacking&&s.enable(12),L.dithering&&s.enable(13),L.specularIntensityMap&&s.enable(14),L.specularColorMap&&s.enable(15),L.transmission&&s.enable(16),L.transmissionMap&&s.enable(17),L.thicknessMap&&s.enable(18),L.sheen&&s.enable(19),L.sheenColorMap&&s.enable(20),L.sheenRoughnessMap&&s.enable(21),L.decodeVideoTexture&&s.enable(22),I.push(s.mask)}function P(I){let L=_[I.type],R;if(L){let F=ah[L];R=Vfe.clone(F.uniforms)}else R=I.uniforms;return R}function k(I,L){let R;for(let F=0,z=c.length;F<z;F++){let U=c[F];if(U.cacheKey===L){R=U,++R.usedTimes;break}}return R===void 0&&(R=new ggr(e,L,I,o),c.push(R)),R}function O(I){if(--I.usedTimes===0){let L=c.indexOf(I);c[L]=c[c.length-1],c.pop(),I.destroy()}}function D(I){l.remove(I)}function B(){l.dispose()}return{getParameters:x,getProgramCacheKey:b,getUniforms:P,acquireProgram:k,releaseProgram:O,releaseShaderCache:D,programs:c,dispose:B}}function vgr(){let e=new WeakMap;function t(o){let a=e.get(o);return a===void 0&&(a={},e.set(o,a)),a}function r(o){e.delete(o)}function n(o,a,s){e.get(o)[a]=s}function i(){e=new WeakMap}return{get:t,remove:r,update:n,dispose:i}}function xgr(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.material.id!==t.material.id?e.material.id-t.material.id:e.z!==t.z?e.z-t.z:e.id-t.id}function Xue(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.z!==t.z?t.z-e.z:e.id-t.id}function $ue(){let e=[],t=0,r=[],n=[],i=[];function o(){t=0,r.length=0,n.length=0,i.length=0}function a(h,f,p,d,g,_){let y=e[t];return y===void 0?(y={id:h.id,object:h,geometry:f,material:p,groupOrder:d,renderOrder:h.renderOrder,z:g,group:_},e[t]=y):(y.id=h.id,y.object=h,y.geometry=f,y.material=p,y.groupOrder=d,y.renderOrder=h.renderOrder,y.z=g,y.group=_),t++,y}function s(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.push(y):p.transparent===!0?i.push(y):r.push(y)}function l(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.unshift(y):p.transparent===!0?i.unshift(y):r.unshift(y)}function c(h,f){r.length>1&&r.sort(h||xgr),n.length>1&&n.sort(f||Xue),i.length>1&&i.sort(f||Xue)}function u(){for(let h=t,f=e.length;h<f;h++){let p=e[h];if(p.id===null)break;p.id=null,p.object=null,p.geometry=null,p.material=null,p.group=null}}return{opaque:r,transmissive:n,transparent:i,init:o,push:s,unshift:l,finish:u,sort:c}}function bgr(){let e=new WeakMap;function t(n,i){let o;return e.has(n)===!1?(o=new $ue,e.set(n,[o])):i>=e.get(n).length?(o=new $ue,e.get(n).push(o)):o=e.get(n)[i],o}function r(){e=new WeakMap}return{get:t,dispose:r}}function wgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={direction:new j,color:new ne};break;case"SpotLight":r={position:new j,direction:new j,color:new ne,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":r={position:new j,color:new ne,distance:0,decay:0};break;case"HemisphereLight":r={direction:new j,skyColor:new ne,groundColor:new ne};break;case"RectAreaLight":r={color:new ne,position:new j,halfWidth:new j,halfHeight:new j};break}return e[t.id]=r,r}}}function Sgr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"SpotLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"PointLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt,shadowCameraNear:1,shadowCameraFar:1e3};break}return e[t.id]=r,r}}}var Mgr=0;function Egr(e,t){return(t.castShadow?1:0)-(e.castShadow?1:0)}function Tgr(e,t){let r=new wgr,n=Sgr(),i={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)i.probe.push(new j);let o=new j,a=new Me,s=new Me;function l(u,h){let f=0,p=0,d=0;for(let D=0;D<9;D++)i.probe[D].set(0,0,0);let g=0,_=0,y=0,x=0,b=0,S=0,C=0,P=0;u.sort(Egr);let k=h!==!0?Math.PI:1;for(let D=0,B=u.length;D<B;D++){let I=u[D],L=I.color,R=I.intensity,F=I.distance,z=I.shadow&&I.shadow.map?I.shadow.map.texture:null;if(I.isAmbientLight)f+=L.r*R*k,p+=L.g*R*k,d+=L.b*R*k;else if(I.isLightProbe)for(let U=0;U<9;U++)i.probe[U].addScaledVector(I.sh.coefficients[U],R);else if(I.isDirectionalLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.directionalShadow[g]=Z,i.directionalShadowMap[g]=z,i.directionalShadowMatrix[g]=I.shadow.matrix,S++}i.directional[g]=U,g++}else if(I.isSpotLight){let U=r.get(I);if(U.position.setFromMatrixPosition(I.matrixWorld),U.color.copy(L).multiplyScalar(R*k),U.distance=F,U.coneCos=Math.cos(I.angle),U.penumbraCos=Math.cos(I.angle*(1-I.penumbra)),U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.spotShadow[y]=Z,i.spotShadowMap[y]=z,i.spotShadowMatrix[y]=I.shadow.matrix,P++}i.spot[y]=U,y++}else if(I.isRectAreaLight){let U=r.get(I);U.color.copy(L).multiplyScalar(R),U.halfWidth.set(I.width*.5,0,0),U.halfHeight.set(0,I.height*.5,0),i.rectArea[x]=U,x++}else if(I.isPointLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),U.distance=I.distance,U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,Z.shadowCameraNear=W.camera.near,Z.shadowCameraFar=W.camera.far,i.pointShadow[_]=Z,i.pointShadowMap[_]=z,i.pointShadowMatrix[_]=I.shadow.matrix,C++}i.point[_]=U,_++}else if(I.isHemisphereLight){let U=r.get(I);U.skyColor.copy(I.color).multiplyScalar(R*k),U.groundColor.copy(I.groundColor).multiplyScalar(R*k),i.hemi[b]=U,b++}}x>0&&(t.isWebGL2||e.has("OES_texture_float_linear")===!0?(i.rectAreaLTC1=re.LTC_FLOAT_1,i.rectAreaLTC2=re.LTC_FLOAT_2):e.has("OES_texture_half_float_linear")===!0?(i.rectAreaLTC1=re.LTC_HALF_1,i.rectAreaLTC2=re.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),i.ambient[0]=f,i.ambient[1]=p,i.ambient[2]=d;let O=i.hash;(O.directionalLength!==g||O.pointLength!==_||O.spotLength!==y||O.rectAreaLength!==x||O.hemiLength!==b||O.numDirectionalShadows!==S||O.numPointShadows!==C||O.numSpotShadows!==P)&&(i.directional.length=g,i.spot.length=y,i.rectArea.length=x,i.point.length=_,i.hemi.length=b,i.directionalShadow.length=S,i.directionalShadowMap.length=S,i.pointShadow.length=C,i.pointShadowMap.length=C,i.spotShadow.length=P,i.spotShadowMap.length=P,i.directionalShadowMatrix.length=S,i.pointShadowMatrix.length=C,i.spotShadowMatrix.length=P,O.directionalLength=g,O.pointLength=_,O.spotLength=y,O.rectAreaLength=x,O.hemiLength=b,O.numDirectionalShadows=S,O.numPointShadows=C,O.numSpotShadows=P,i.version=Mgr++)}function c(u,h){let f=0,p=0,d=0,g=0,_=0,y=h.matrixWorldInverse;for(let x=0,b=u.length;x<b;x++){let S=u[x];if(S.isDirectionalLight){let C=i.directional[f];C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),f++}else if(S.isSpotLight){let C=i.spot[d];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),d++}else if(S.isRectAreaLight){let C=i.rectArea[g];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),s.identity(),a.copy(S.matrixWorld),a.premultiply(y),s.extractRotation(a),C.halfWidth.set(S.width*.5,0,0),C.halfHeight.set(0,S.height*.5,0),C.halfWidth.applyMatrix4(s),C.halfHeight.applyMatrix4(s),g++}else if(S.isPointLight){let C=i.point[p];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),p++}else if(S.isHemisphereLight){let C=i.hemi[_];C.direction.setFromMatrixPosition(S.matrixWorld),C.direction.transformDirection(y),C.direction.normalize(),_++}}}return{setup:l,setupView:c,state:i}}function Kue(e,t){let r=new Tgr(e,t),n=[],i=[];function o(){n.length=0,i.length=0}function a(h){n.push(h)}function s(h){i.push(h)}function l(h){r.setup(n,h)}function c(h){r.setupView(n,h)}return{init:o,state:{lightsArray:n,shadowsArray:i,lights:r},setupLights:l,setupLightsView:c,pushLight:a,pushShadow:s}}function Cgr(e,t){let r=new WeakMap;function n(o,a=0){let s;return r.has(o)===!1?(s=new Kue(e,t),r.set(o,[s])):a>=r.get(o).length?(s=new Kue(e,t),r.get(o).push(s)):s=r.get(o)[a],s}function i(){r=new WeakMap}return{get:n,dispose:i}}var eM=class extends qi{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Rfe,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};eM.prototype.isMeshDepthMaterial=!0;var rM=class extends qi{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new j,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};rM.prototype.isMeshDistanceMaterial=!0;var Agr=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,Pgr=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function Jfe(e,t,r){let n=new D1,i=new Lt,o=new Lt,a=new en,s=new eM({depthPacking:Nfe}),l=new rM,c={},u=r.maxTextureSize,h={0:Ii,1:L1,2:k1},f=new lh({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new Lt},radius:{value:4}},vertexShader:Agr,fragmentShader:Pgr}),p=f.clone();p.defines.HORIZONTAL_PASS=1;let d=new Pe;d.setAttribute("position",new Je(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let g=new ti(d,f),_=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=Cht,this.render=function(S,C,P){if(_.enabled===!1||_.autoUpdate===!1&&_.needsUpdate===!1||S.length===0)return;let k=e.getRenderTarget(),O=e.getActiveCubeFace(),D=e.getActiveMipmapLevel(),B=e.state;B.setBlending(Kd),B.buffers.color.setClear(1,1,1,1),B.buffers.depth.setTest(!0),B.setScissorTest(!1);for(let I=0,L=S.length;I<L;I++){let R=S[I],F=R.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",R,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;i.copy(F.mapSize);let z=F.getFrameExtents();if(i.multiply(z),o.copy(F.mapSize),(i.x>u||i.y>u)&&(i.x>u&&(o.x=Math.floor(u/z.x),i.x=o.x*z.x,F.mapSize.x=o.x),i.y>u&&(o.y=Math.floor(u/z.y),i.y=o.y*z.y,F.mapSize.y=o.y)),F.map===null&&!F.isPointLightShadow&&this.type===F3){let W={minFilter:ii,magFilter:ii,format:Qo};F.map=new hs(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.mapPass=new hs(i.x,i.y,W),F.camera.updateProjectionMatrix()}if(F.map===null){let W={minFilter:Li,magFilter:Li,format:Qo};F.map=new hs(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.camera.updateProjectionMatrix()}e.setRenderTarget(F.map),e.clear();let U=F.getViewportCount();for(let W=0;W<U;W++){let Z=F.getViewport(W);a.set(o.x*Z.x,o.y*Z.y,o.x*Z.z,o.y*Z.w),B.viewport(a),F.updateMatrices(R,W),n=F.getFrustum(),b(C,P,F.camera,R,this.type)}!F.isPointLightShadow&&this.type===F3&&y(F,P),F.needsUpdate=!1}_.needsUpdate=!1,e.setRenderTarget(k,O,D)};function y(S,C){let P=t.update(g);f.defines.VSM_SAMPLES!==S.blurSamples&&(f.defines.VSM_SAMPLES=S.blurSamples,p.defines.VSM_SAMPLES=S.blurSamples,f.needsUpdate=!0,p.needsUpdate=!0),f.uniforms.shadow_pass.value=S.map.texture,f.uniforms.resolution.value=S.mapSize,f.uniforms.radius.value=S.radius,e.setRenderTarget(S.mapPass),e.clear(),e.renderBufferDirect(C,null,P,f,g,null),p.uniforms.shadow_pass.value=S.mapPass.texture,p.uniforms.resolution.value=S.mapSize,p.uniforms.radius.value=S.radius,e.setRenderTarget(S.map),e.clear(),e.renderBufferDirect(C,null,P,p,g,null)}function x(S,C,P,k,O,D,B){let I=null,L=k.isPointLight===!0?S.customDistanceMaterial:S.customDepthMaterial;if(L!==void 0?I=L:I=k.isPointLight===!0?l:s,e.localClippingEnabled&&P.clipShadows===!0&&P.clippingPlanes.length!==0||P.displacementMap&&P.displacementScale!==0||P.alphaMap&&P.alphaTest>0){let R=I.uuid,F=P.uuid,z=c[R];z===void 0&&(z={},c[R]=z);let U=z[F];U===void 0&&(U=I.clone(),z[F]=U),I=U}return I.visible=P.visible,I.wireframe=P.wireframe,B===F3?I.side=P.shadowSide!==null?P.shadowSide:P.side:I.side=P.shadowSide!==null?P.shadowSide:h[P.side],I.alphaMap=P.alphaMap,I.alphaTest=P.alphaTest,I.clipShadows=P.clipShadows,I.clippingPlanes=P.clippingPlanes,I.clipIntersection=P.clipIntersection,I.displacementMap=P.displacementMap,I.displacementScale=P.displacementScale,I.displacementBias=P.displacementBias,I.wireframeLinewidth=P.wireframeLinewidth,I.linewidth=P.linewidth,k.isPointLight===!0&&I.isMeshDistanceMaterial===!0&&(I.referencePosition.setFromMatrixPosition(k.matrixWorld),I.nearDistance=O,I.farDistance=D),I}function b(S,C,P,k,O){if(S.visible===!1)return;if(S.layers.test(C.layers)&&(S.isMesh||S.isLine||S.isPoints)&&(S.castShadow||S.receiveShadow&&O===F3)&&(!S.frustumCulled||n.intersectsObject(S))){S.modelViewMatrix.multiplyMatrices(P.matrixWorldInverse,S.matrixWorld);let I=t.update(S),L=S.material;if(Array.isArray(L)){let R=I.groups;for(let F=0,z=R.length;F<z;F++){let U=R[F],W=L[U.materialIndex];if(W&&W.visible){let Z=x(S,I,W,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,Z,S,U)}}}else if(L.visible){let R=x(S,I,L,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,R,S,null)}}let B=S.children;for(let I=0,L=B.length;I<L;I++)b(B[I],C,P,k,O)}}function Igr(e,t,r){let n=r.isWebGL2;function i(){let at=!1,se=new en,Qt=null,Ce=new en(0,0,0,0);return{setMask:function(Pt){Qt!==Pt&&!at&&(e.colorMask(Pt,Pt,Pt,Pt),Qt=Pt)},setLocked:function(Pt){at=Pt},setClear:function(Pt,Nt,ze,yn,Wi){Wi===!0&&(Pt*=yn,Nt*=yn,ze*=yn),se.set(Pt,Nt,ze,yn),Ce.equals(se)===!1&&(e.clearColor(Pt,Nt,ze,yn),Ce.copy(se))},reset:function(){at=!1,Qt=null,Ce.set(-1,0,0,0)}}}function o(){let at=!1,se=null,Qt=null,Ce=null;return{setTest:function(Pt){Pt?lt(2929):Kt(2929)},setMask:function(Pt){se!==Pt&&!at&&(e.depthMask(Pt),se=Pt)},setFunc:function(Pt){if(Qt!==Pt){if(Pt)switch(Pt){case efe:e.depthFunc(512);break;case rfe:e.depthFunc(519);break;case nfe:e.depthFunc(513);break;case iU:e.depthFunc(515);break;case ife:e.depthFunc(514);break;case ofe:e.depthFunc(518);break;case afe:e.depthFunc(516);break;case sfe:e.depthFunc(517);break;default:e.depthFunc(515)}else e.depthFunc(515);Qt=Pt}},setLocked:function(Pt){at=Pt},setClear:function(Pt){Ce!==Pt&&(e.clearDepth(Pt),Ce=Pt)},reset:function(){at=!1,se=null,Qt=null,Ce=null}}}function a(){let at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null;return{setTest:function(Ar){at||(Ar?lt(2960):Kt(2960))},setMask:function(Ar){se!==Ar&&!at&&(e.stencilMask(Ar),se=Ar)},setFunc:function(Ar,Ia,ho){(Qt!==Ar||Ce!==Ia||Pt!==ho)&&(e.stencilFunc(Ar,Ia,ho),Qt=Ar,Ce=Ia,Pt=ho)},setOp:function(Ar,Ia,ho){(Nt!==Ar||ze!==Ia||yn!==ho)&&(e.stencilOp(Ar,Ia,ho),Nt=Ar,ze=Ia,yn=ho)},setLocked:function(Ar){at=Ar},setClear:function(Ar){Wi!==Ar&&(e.clearStencil(Ar),Wi=Ar)},reset:function(){at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null}}}let s=new i,l=new o,c=new a,u={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,R=e.getParameter(35661),F=!1,z=0,U=e.getParameter(7938);U.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(U)[1]),F=z>=1):U.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(U)[1]),F=z>=2);let W=null,Z={},rt=e.getParameter(3088),ot=e.getParameter(2978),st=new en().fromArray(rt),St=new en().fromArray(ot);function bt(at,se,Qt){let Ce=new Uint8Array(4),Pt=e.createTexture();e.bindTexture(at,Pt),e.texParameteri(at,10241,9728),e.texParameteri(at,10240,9728);for(let Nt=0;Nt<Qt;Nt++)e.texImage2D(se+Nt,0,6408,1,1,0,6408,5121,Ce);return Pt}let Mt={};Mt[3553]=bt(3553,3553,1),Mt[34067]=bt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),lt(2929),l.setFunc(iU),ht(!1),wt(Sut),lt(2884),q(Kd);function lt(at){u[at]!==!0&&(e.enable(at),u[at]=!0)}function Kt(at){u[at]!==!1&&(e.disable(at),u[at]=!1)}function _t(at,se){return h[at]!==se?(e.bindFramebuffer(at,se),h[at]=se,n&&(at===36009&&(h[36160]=se),at===36160&&(h[36009]=se)),!0):!1}function ct(at,se){let Qt=p,Ce=!1;if(at)if(Qt=f.get(se),Qt===void 0&&(Qt=[],f.set(se,Qt)),at.isWebGLMultipleRenderTargets){let Pt=at.texture;if(Qt.length!==Pt.length||Qt[0]!==36064){for(let Nt=0,ze=Pt.length;Nt<ze;Nt++)Qt[Nt]=36064+Nt;Qt.length=Pt.length,Ce=!0}}else Qt[0]!==36064&&(Qt[0]=36064,Ce=!0);else Qt[0]!==1029&&(Qt[0]=1029,Ce=!0);Ce&&(r.isWebGL2?e.drawBuffers(Qt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Qt))}function X(at){return d!==at?(e.useProgram(at),d=at,!0):!1}let et={[E1]:32774,[Ghe]:32778,[Whe]:32779};if(n)et[Cut]=32775,et[Aut]=32776;else{let at=t.get("EXT_blend_minmax");at!==null&&(et[Cut]=at.MIN_EXT,et[Aut]=at.MAX_EXT)}let dt={[Yhe]:0,[jhe]:1,[Xhe]:768,[Pht]:770,[tfe]:776,[Jhe]:774,[Khe]:772,[$he]:769,[Iht]:771,[Qhe]:775,[Zhe]:773};function q(at,se,Qt,Ce,Pt,Nt,ze,yn){if(at===Kd){g===!0&&(Kt(3042),g=!1);return}if(g===!1&&(lt(3042),g=!0),at!==qhe){if(at!==_||yn!==k){if((y!==E1||S!==E1)&&(e.blendEquation(32774),y=E1,S=E1),yn)switch(at){case V3:e.blendFuncSeparate(1,771,1,771);break;case Mut:e.blendFunc(1,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}else switch(at){case V3:e.blendFuncSeparate(770,771,1,771);break;case Mut:e.blendFunc(770,1);break;case Eut:e.blendFuncSeparate(0,769,0,1);break;case Tut:e.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}x=null,b=null,C=null,P=null,_=at,k=yn}return}Pt=Pt||se,Nt=Nt||Qt,ze=ze||Ce,(se!==y||Pt!==S)&&(e.blendEquationSeparate(et[se],et[Pt]),y=se,S=Pt),(Qt!==x||Ce!==b||Nt!==C||ze!==P)&&(e.blendFuncSeparate(dt[Qt],dt[Ce],dt[Nt],dt[ze]),x=Qt,b=Ce,C=Nt,P=ze),_=at,k=null}function pt(at,se){at.side===k1?Kt(2884):lt(2884);let Qt=at.side===Ii;se&&(Qt=!Qt),ht(Qt),at.blending===V3&&at.transparent===!1?q(Kd):q(at.blending,at.blendEquation,at.blendSrc,at.blendDst,at.blendEquationAlpha,at.blendSrcAlpha,at.blendDstAlpha,at.premultipliedAlpha),l.setFunc(at.depthFunc),l.setTest(at.depthTest),l.setMask(at.depthWrite),s.setMask(at.colorWrite);let Ce=at.stencilWrite;c.setTest(Ce),Ce&&(c.setMask(at.stencilWriteMask),c.setFunc(at.stencilFunc,at.stencilRef,at.stencilFuncMask),c.setOp(at.stencilFail,at.stencilZFail,at.stencilZPass)),ie(at.polygonOffset,at.polygonOffsetFactor,at.polygonOffsetUnits),at.alphaToCoverage===!0?lt(32926):Kt(32926)}function ht(at){O!==at&&(at?e.frontFace(2304):e.frontFace(2305),O=at)}function wt(at){at!==Hhe?(lt(2884),at!==D&&(at===Sut?e.cullFace(1029):at===Vhe?e.cullFace(1028):e.cullFace(1032))):Kt(2884),D=at}function kt(at){at!==B&&(F&&e.lineWidth(at),B=at)}function ie(at,se,Qt){at?(lt(32823),(I!==se||L!==Qt)&&(e.polygonOffset(se,Qt),I=se,L=Qt)):Kt(32823)}function ee(at){at?lt(3089):Kt(3089)}function Le(at){at===void 0&&(at=33984+R-1),W!==at&&(e.activeTexture(at),W=at)}function ar(at,se){W===null&&Le();let Qt=Z[W];Qt===void 0&&(Qt={type:void 0,texture:void 0},Z[W]=Qt),(Qt.type!==at||Qt.texture!==se)&&(e.bindTexture(at,se||Mt[at]),Qt.type=at,Qt.texture=se)}function fr(){let at=Z[W];at!==void 0&&at.type!==void 0&&(e.bindTexture(at.type,null),at.type=void 0,at.texture=void 0)}function tt(){try{e.compressedTexImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $(){try{e.texSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function It(){try{e.texSubImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $t(){try{e.compressedTexSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function he(){try{e.texStorage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Tt(){try{e.texStorage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function be(){try{e.texImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function nt(){try{e.texImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Ct(at){st.equals(at)===!1&&(e.scissor(at.x,at.y,at.z,at.w),st.copy(at))}function Wt(at){St.equals(at)===!1&&(e.viewport(at.x,at.y,at.z,at.w),St.copy(at))}function fe(){e.disable(3042),e.disable(2884),e.disable(2929),e.disable(32823),e.disable(3089),e.disable(2960),e.disable(32926),e.blendEquation(32774),e.blendFunc(1,0),e.blendFuncSeparate(1,0,1,0),e.colorMask(!0,!0,!0,!0),e.clearColor(0,0,0,0),e.depthMask(!0),e.depthFunc(513),e.clearDepth(1),e.stencilMask(4294967295),e.stencilFunc(519,0,4294967295),e.stencilOp(7680,7680,7680),e.clearStencil(0),e.cullFace(1029),e.frontFace(2305),e.polygonOffset(0,0),e.activeTexture(33984),e.bindFramebuffer(36160,null),n===!0&&(e.bindFramebuffer(36009,null),e.bindFramebuffer(36008,null)),e.useProgram(null),e.lineWidth(1),e.scissor(0,0,e.canvas.width,e.canvas.height),e.viewport(0,0,e.canvas.width,e.canvas.height),u={},W=null,Z={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,st.set(0,0,e.canvas.width,e.canvas.height),St.set(0,0,e.canvas.width,e.canvas.height),s.reset(),l.reset(),c.reset()}return{buffers:{color:s,depth:l,stencil:c},enable:lt,disable:Kt,bindFramebuffer:_t,drawBuffers:ct,useProgram:X,setBlending:q,setMaterial:pt,setFlipSided:ht,setCullFace:wt,setLineWidth:kt,setPolygonOffset:ie,setScissorTest:ee,activeTexture:Le,bindTexture:ar,unbindTexture:fr,compressedTexImage2D:tt,texImage2D:be,texImage3D:nt,texStorage2D:he,texStorage3D:Tt,texSubImage2D:$,texSubImage3D:It,compressedTexSubImage2D:$t,scissor:Ct,viewport:Wt,reset:fe}}function Lgr(e,t,r,n,i,o,a){let s=i.isWebGL2,l=i.maxTextures,c=i.maxCubemapSize,u=i.maxTextureSize,h=i.maxSamples,p=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,d=new WeakMap,g,_=!1;try{_=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(tt){}function y(tt,$){return _?new OffscreenCanvas(tt,$):t6("canvas")}function x(tt,$,It,$t){let he=1;if((tt.width>$t||tt.height>$t)&&(he=$t/Math.max(tt.width,tt.height)),he<1||$===!0)if(typeof HTMLImageElement!="undefined"&&tt instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&tt instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&tt instanceof ImageBitmap){let Tt=$?Ffe:Math.floor,be=Tt(he*tt.width),nt=Tt(he*tt.height);g===void 0&&(g=y(be,nt));let Ct=It?y(be,nt):g;return Ct.width=be,Ct.height=nt,Ct.getContext("2d").drawImage(tt,0,0,be,nt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+tt.width+"x"+tt.height+") to ("+be+"x"+nt+")."),Ct}else return"data"in tt&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+tt.width+"x"+tt.height+")."),tt;return tt}function b(tt){return Zut(tt.width)&&Zut(tt.height)}function S(tt){return s?!1:tt.wrapS!==Jo||tt.wrapT!==Jo||tt.minFilter!==Li&&tt.minFilter!==ii}function C(tt,$){return tt.generateMipmaps&&$&&tt.minFilter!==Li&&tt.minFilter!==ii}function P(tt){e.generateMipmap(tt)}function k(tt,$,It,$t,he=!1){if(s===!1)return $;if(tt!==null){if(e[tt]!==void 0)return e[tt];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+tt+"'")}let Tt=$;return $===6403&&(It===5126&&(Tt=33326),It===5131&&(Tt=33325),It===5121&&(Tt=33321)),$===33319&&(It===5126&&(Tt=33328),It===5131&&(Tt=33327),It===5121&&(Tt=33323)),$===6408&&(It===5126&&(Tt=34836),It===5131&&(Tt=34842),It===5121&&(Tt=$t===Yn&&he===!1?35907:32856),It===32819&&(Tt=32854),It===32820&&(Tt=32855)),(Tt===33325||Tt===33326||Tt===33327||Tt===33328||Tt===34842||Tt===34836)&&t.get("EXT_color_buffer_float"),Tt}function O(tt,$,It){return C(tt,It)===!0||tt.isFramebufferTexture&&tt.minFilter!==Li&&tt.minFilter!==ii?Math.log2(Math.max($.width,$.height))+1:tt.mipmaps!==void 0&&tt.mipmaps.length>0?tt.mipmaps.length:tt.isCompressedTexture&&Array.isArray(tt.image)?$.mipmaps.length:1}function D(tt){return tt===Li||tt===oU||tt===aU?9728:9729}function B(tt){let $=tt.target;$.removeEventListener("dispose",B),L($),$.isVideoTexture&&d.delete($),a.memory.textures--}function I(tt){let $=tt.target;$.removeEventListener("dispose",I),R($)}function L(tt){let $=n.get(tt);$.__webglInit!==void 0&&(e.deleteTexture($.__webglTexture),n.remove(tt))}function R(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);if(!!tt){if($t.__webglTexture!==void 0&&(e.deleteTexture($t.__webglTexture),a.memory.textures--),tt.depthTexture&&tt.depthTexture.dispose(),tt.isWebGLCubeRenderTarget)for(let he=0;he<6;he++)e.deleteFramebuffer(It.__webglFramebuffer[he]),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer[he]);else e.deleteFramebuffer(It.__webglFramebuffer),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer),It.__webglMultisampledFramebuffer&&e.deleteFramebuffer(It.__webglMultisampledFramebuffer),It.__webglColorRenderbuffer&&e.deleteRenderbuffer(It.__webglColorRenderbuffer),It.__webglDepthRenderbuffer&&e.deleteRenderbuffer(It.__webglDepthRenderbuffer);if(tt.isWebGLMultipleRenderTargets)for(let he=0,Tt=$.length;he<Tt;he++){let be=n.get($[he]);be.__webglTexture&&(e.deleteTexture(be.__webglTexture),a.memory.textures--),n.remove($[he])}n.remove($),n.remove(tt)}}let F=0;function z(){F=0}function U(){let tt=F;return tt>=l&&console.warn("THREE.WebGLTextures: Trying to use "+tt+" texture units while this GPU supports only "+l),F+=1,tt}function W(tt,$){let It=n.get(tt);if(tt.isVideoTexture&&kt(tt),tt.version>0&&It.__version!==tt.version){let $t=tt.image;if($t===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if($t.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{lt(It,tt,$);return}}r.activeTexture(33984+$),r.bindTexture(3553,It.__webglTexture)}function Z(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(35866,It.__webglTexture)}function rt(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(32879,It.__webglTexture)}function ot(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){Kt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(34067,It.__webglTexture)}let st={[XP]:10497,[Jo]:33071,[$P]:33648},St={[Li]:9728,[oU]:9984,[aU]:9986,[ii]:9729,[Lht]:9985,[ax]:9987};function bt(tt,$,It){if(It?(e.texParameteri(tt,10242,st[$.wrapS]),e.texParameteri(tt,10243,st[$.wrapT]),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,st[$.wrapR]),e.texParameteri(tt,10240,St[$.magFilter]),e.texParameteri(tt,10241,St[$.minFilter])):(e.texParameteri(tt,10242,33071),e.texParameteri(tt,10243,33071),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,33071),($.wrapS!==Jo||$.wrapT!==Jo)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),e.texParameteri(tt,10240,D($.magFilter)),e.texParameteri(tt,10241,D($.minFilter)),$.minFilter!==Li&&$.minFilter!==ii&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let $t=t.get("EXT_texture_filter_anisotropic");if($.type===Xd&&t.has("OES_texture_float_linear")===!1||s===!1&&$.type===A1&&t.has("OES_texture_half_float_linear")===!1)return;($.anisotropy>1||n.get($).__currentAnisotropy)&&(e.texParameterf(tt,$t.TEXTURE_MAX_ANISOTROPY_EXT,Math.min($.anisotropy,i.getMaxAnisotropy())),n.get($).__currentAnisotropy=$.anisotropy)}}function Mt(tt,$){tt.__webglInit===void 0&&(tt.__webglInit=!0,$.addEventListener("dispose",B),tt.__webglTexture=e.createTexture(),a.memory.textures++)}function lt(tt,$,It){let $t=3553;$.isDataTexture2DArray&&($t=35866),$.isDataTexture3D&&($t=32879),Mt(tt,$),r.activeTexture(33984+It),r.bindTexture($t,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let he=S($)&&b($.image)===!1,Tt=x($.image,he,!1,u);Tt=ie($,Tt);let be=b(Tt)||s,nt=o.convert($.format,$.encoding),Ct=o.convert($.type),Wt=k($.internalFormat,nt,Ct,$.encoding,$.isVideoTexture);bt($t,$,be);let fe,at=$.mipmaps,se=s&&$.isVideoTexture!==!0,Qt=tt.__version===void 0,Ce=O($,Tt,be);if($.isDepthTexture)Wt=6402,s?$.type===Xd?Wt=36012:$.type===VP?Wt=33190:$.type===P1?Wt=35056:Wt=33189:$.type===Xd&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),$.format===F0&&Wt===6402&&$.type!==G3&&$.type!==VP&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),$.type=G3,Ct=o.convert($.type)),$.format===R1&&Wt===6402&&(Wt=34041,$.type!==P1&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),$.type=P1,Ct=o.convert($.type))),se&&Qt?r.texStorage2D(3553,1,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if($.isDataTexture)if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,0,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,Tt.width,Tt.height,nt,Ct,Tt.data)):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,Tt.data);else if($.isCompressedTexture){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],$.format!==Qo?nt!==null?se?r.compressedTexSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,fe.data):r.compressedTexImage2D(3553,Pt,Wt,fe.width,fe.height,0,fe.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):se?r.texSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data)}else if($.isDataTexture2DArray)se?(Qt&&r.texStorage3D(35866,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(35866,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(35866,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isDataTexture3D)se?(Qt&&r.texStorage3D(32879,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(32879,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(32879,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isFramebufferTexture)se&&Qt?r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,Pt,0,0,nt,Ct,fe):r.texImage2D(3553,Pt,Wt,nt,Ct,fe);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,nt,Ct,Tt)):r.texImage2D(3553,0,Wt,nt,Ct,Tt);C($,be)&&P($t),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function Kt(tt,$,It){if($.image.length!==6)return;Mt(tt,$),r.activeTexture(33984+It),r.bindTexture(34067,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let $t=$&&($.isCompressedTexture||$.image[0].isCompressedTexture),he=$.image[0]&&$.image[0].isDataTexture,Tt=[];for(let Pt=0;Pt<6;Pt++)!$t&&!he?Tt[Pt]=x($.image[Pt],!1,!0,c):Tt[Pt]=he?$.image[Pt].image:$.image[Pt],Tt[Pt]=ie($,Tt[Pt]);let be=Tt[0],nt=b(be)||s,Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=s&&$.isVideoTexture!==!0,se=tt.__version===void 0,Qt=O($,be,nt);bt(34067,$,nt);let Ce;if($t){at&&se&&r.texStorage2D(34067,Qt,fe,be.width,be.height);for(let Pt=0;Pt<6;Pt++){Ce=Tt[Pt].mipmaps;for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];$.format!==Qo?Ct!==null?at?r.compressedTexSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,ze.data):r.compressedTexImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,ze.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):at?r.texSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,Wt,ze.data):r.texImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,Ct,Wt,ze.data)}}}else{Ce=$.mipmaps,at&&se&&(Ce.length>0&&Qt++,r.texStorage2D(34067,Qt,fe,Tt[0].width,Tt[0].height));for(let Pt=0;Pt<6;Pt++)if(he){at?r.texSubImage2D(34069+Pt,0,0,0,Tt[Pt].width,Tt[Pt].height,Ct,Wt,Tt[Pt].data):r.texImage2D(34069+Pt,0,fe,Tt[Pt].width,Tt[Pt].height,0,Ct,Wt,Tt[Pt].data);for(let Nt=0;Nt<Ce.length;Nt++){let yn=Ce[Nt].image[Pt].image;at?r.texSubImage2D(34069+Pt,Nt+1,0,0,yn.width,yn.height,Ct,Wt,yn.data):r.texImage2D(34069+Pt,Nt+1,fe,yn.width,yn.height,0,Ct,Wt,yn.data)}}else{at?r.texSubImage2D(34069+Pt,0,0,0,Ct,Wt,Tt[Pt]):r.texImage2D(34069+Pt,0,fe,Ct,Wt,Tt[Pt]);for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];at?r.texSubImage2D(34069+Pt,Nt+1,0,0,Ct,Wt,ze.image[Pt]):r.texImage2D(34069+Pt,Nt+1,fe,Ct,Wt,ze.image[Pt])}}}C($,nt)&&P(34067),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function _t(tt,$,It,$t,he){let Tt=o.convert(It.format,It.encoding),be=o.convert(It.type),nt=k(It.internalFormat,Tt,be,It.encoding);n.get($).__hasExternalTextures||(he===32879||he===35866?r.texImage3D(he,0,nt,$.width,$.height,$.depth,0,Tt,be,null):r.texImage2D(he,0,nt,$.width,$.height,0,Tt,be,null)),r.bindFramebuffer(36160,tt),$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,$t,he,n.get(It).__webglTexture,0,wt($)):e.framebufferTexture2D(36160,$t,he,n.get(It).__webglTexture,0),r.bindFramebuffer(36160,null)}function ct(tt,$,It){if(e.bindRenderbuffer(36161,tt),$.depthBuffer&&!$.stencilBuffer){let $t=33189;if(It||$.useRenderToTexture){let he=$.depthTexture;he&&he.isDepthTexture&&(he.type===Xd?$t=36012:he.type===VP&&($t=33190));let Tt=wt($);$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,Tt,$t,$.width,$.height):e.renderbufferStorageMultisample(36161,Tt,$t,$.width,$.height)}else e.renderbufferStorage(36161,$t,$.width,$.height);e.framebufferRenderbuffer(36160,36096,36161,tt)}else if($.depthBuffer&&$.stencilBuffer){let $t=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,$t,35056,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,$t,35056,$.width,$.height):e.renderbufferStorage(36161,34041,$.width,$.height),e.framebufferRenderbuffer(36160,33306,36161,tt)}else{let $t=$.isWebGLMultipleRenderTargets===!0?$.texture[0]:$.texture,he=o.convert($t.format,$t.encoding),Tt=o.convert($t.type),be=k($t.internalFormat,he,Tt,$t.encoding),nt=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,nt,be,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,nt,be,$.width,$.height):e.renderbufferStorage(36161,be,$.width,$.height)}e.bindRenderbuffer(36161,null)}function X(tt,$){if($&&$.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(r.bindFramebuffer(36160,tt),!($.depthTexture&&$.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!n.get($.depthTexture).__webglTexture||$.depthTexture.image.width!==$.width||$.depthTexture.image.height!==$.height)&&($.depthTexture.image.width=$.width,$.depthTexture.image.height=$.height,$.depthTexture.needsUpdate=!0),W($.depthTexture,0);let $t=n.get($.depthTexture).__webglTexture,he=wt($);if($.depthTexture.format===F0)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,36096,3553,$t,0,he):e.framebufferTexture2D(36160,36096,3553,$t,0);else if($.depthTexture.format===R1)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,33306,3553,$t,0,he):e.framebufferTexture2D(36160,33306,3553,$t,0);else throw new Error("Unknown depthTexture format")}function et(tt){let $=n.get(tt),It=tt.isWebGLCubeRenderTarget===!0;if(tt.depthTexture&&!$.__autoAllocateDepthBuffer){if(It)throw new Error("target.depthTexture not supported in Cube render targets");X($.__webglFramebuffer,tt)}else if(It){$.__webglDepthbuffer=[];for(let $t=0;$t<6;$t++)r.bindFramebuffer(36160,$.__webglFramebuffer[$t]),$.__webglDepthbuffer[$t]=e.createRenderbuffer(),ct($.__webglDepthbuffer[$t],tt,!1)}else r.bindFramebuffer(36160,$.__webglFramebuffer),$.__webglDepthbuffer=e.createRenderbuffer(),ct($.__webglDepthbuffer,tt,!1);r.bindFramebuffer(36160,null)}function dt(tt,$,It){let $t=n.get(tt);$!==void 0&&_t($t.__webglFramebuffer,tt,tt.texture,36064,3553),It!==void 0&&et(tt)}function q(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);tt.addEventListener("dispose",I),tt.isWebGLMultipleRenderTargets!==!0&&($t.__webglTexture===void 0&&($t.__webglTexture=e.createTexture()),$t.__version=$.version,a.memory.textures++);let he=tt.isWebGLCubeRenderTarget===!0,Tt=tt.isWebGLMultipleRenderTargets===!0,be=$.isDataTexture3D||$.isDataTexture2DArray,nt=b(tt)||s;if(he){It.__webglFramebuffer=[];for(let Ct=0;Ct<6;Ct++)It.__webglFramebuffer[Ct]=e.createFramebuffer()}else if(It.__webglFramebuffer=e.createFramebuffer(),Tt)if(i.drawBuffers){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=n.get(Ct[Wt]);at.__webglTexture===void 0&&(at.__webglTexture=e.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(tt.useRenderbuffer)if(s){It.__webglMultisampledFramebuffer=e.createFramebuffer(),It.__webglColorRenderbuffer=e.createRenderbuffer(),e.bindRenderbuffer(36161,It.__webglColorRenderbuffer);let Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=wt(tt);e.renderbufferStorageMultisample(36161,at,fe,tt.width,tt.height),r.bindFramebuffer(36160,It.__webglMultisampledFramebuffer),e.framebufferRenderbuffer(36160,36064,36161,It.__webglColorRenderbuffer),e.bindRenderbuffer(36161,null),tt.depthBuffer&&(It.__webglDepthRenderbuffer=e.createRenderbuffer(),ct(It.__webglDepthRenderbuffer,tt,!0)),r.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(he){r.bindTexture(34067,$t.__webglTexture),bt(34067,$,nt);for(let Ct=0;Ct<6;Ct++)_t(It.__webglFramebuffer[Ct],tt,$,36064,34069+Ct);C($,nt)&&P(34067),r.unbindTexture()}else if(Tt){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=Ct[Wt],se=n.get(at);r.bindTexture(3553,se.__webglTexture),bt(3553,at,nt),_t(It.__webglFramebuffer,tt,at,36064+Wt,3553),C(at,nt)&&P(3553)}r.unbindTexture()}else{let Ct=3553;be&&(s?Ct=$.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),r.bindTexture(Ct,$t.__webglTexture),bt(Ct,$,nt),_t(It.__webglFramebuffer,tt,$,36064,Ct),C($,nt)&&P(Ct),r.unbindTexture()}tt.depthBuffer&&et(tt)}function pt(tt){let $=b(tt)||s,It=tt.isWebGLMultipleRenderTargets===!0?tt.texture:[tt.texture];for(let $t=0,he=It.length;$t<he;$t++){let Tt=It[$t];if(C(Tt,$)){let be=tt.isWebGLCubeRenderTarget?34067:3553,nt=n.get(Tt).__webglTexture;r.bindTexture(be,nt),P(be),r.unbindTexture()}}}function ht(tt){if(tt.useRenderbuffer)if(s){let $=tt.width,It=tt.height,$t=16384,he=[36064],Tt=tt.stencilBuffer?33306:36096;tt.depthBuffer&&he.push(Tt),tt.ignoreDepthForMultisampleCopy||(tt.depthBuffer&&($t|=256),tt.stencilBuffer&&($t|=1024));let be=n.get(tt);r.bindFramebuffer(36008,be.__webglMultisampledFramebuffer),r.bindFramebuffer(36009,be.__webglFramebuffer),tt.ignoreDepthForMultisampleCopy&&(e.invalidateFramebuffer(36008,[Tt]),e.invalidateFramebuffer(36009,[Tt])),e.blitFramebuffer(0,0,$,It,0,0,$,It,$t,9728),e.invalidateFramebuffer(36008,he),r.bindFramebuffer(36008,null),r.bindFramebuffer(36009,be.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function wt(tt){return s&&(tt.useRenderbuffer||tt.useRenderToTexture)?Math.min(h,tt.samples):0}function kt(tt){let $=a.render.frame;d.get(tt)!==$&&(d.set(tt,$),tt.update())}function ie(tt,$){let It=tt.encoding,$t=tt.format,he=tt.type;return tt.isCompressedTexture===!0||tt.isVideoTexture===!0||tt.format===sU||It!==tm&&(It===Yn?s===!1?t.has("EXT_sRGB")===!0&&$t===Qo?(tt.format=sU,tt.minFilter=ii,tt.generateMipmaps=!1):$=Zf.sRGBToLinear($):($t!==Qo||he!==Jd)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",It)),$}let ee=!1,Le=!1;function ar(tt,$){tt&&tt.isWebGLRenderTarget&&(ee===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),ee=!0),tt=tt.texture),W(tt,$)}function fr(tt,$){tt&&tt.isWebGLCubeRenderTarget&&(Le===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),Le=!0),tt=tt.texture),ot(tt,$)}this.allocateTextureUnit=U,this.resetTextureUnits=z,this.setTexture2D=W,this.setTexture2DArray=Z,this.setTexture3D=rt,this.setTextureCube=ot,this.rebindTextures=dt,this.setupRenderTarget=q,this.updateRenderTargetMipmap=pt,this.updateMultisampleRenderTarget=ht,this.setupDepthRenderbuffer=et,this.setupFrameBufferTexture=_t,this.safeSetTexture2D=ar,this.safeSetTextureCube=fr}function Qfe(e,t,r){let n=r.isWebGL2;function i(o,a=null){let s;if(o===Jd)return 5121;if(o===yfe)return 32819;if(o===vfe)return 32820;if(o===mfe)return 5120;if(o===gfe)return 5122;if(o===G3)return 5123;if(o===_fe)return 5124;if(o===VP)return 5125;if(o===Xd)return 5126;if(o===A1)return n?5131:(s=t.get("OES_texture_half_float"),s!==null?s.HALF_FLOAT_OES:null);if(o===xfe)return 6406;if(o===Qo)return 6408;if(o===bfe)return 6409;if(o===wfe)return 6410;if(o===F0)return 6402;if(o===R1)return 34041;if(o===Sfe)return 6403;if(o===sU)return s=t.get("EXT_sRGB"),s!==null?s.SRGB_ALPHA_EXT:null;if(o===Mfe)return 36244;if(o===Efe)return 33319;if(o===Tfe)return 33320;if(o===Cfe)return 36249;if(o===JV||o===QV||o===tU||o===eU)if(a===Yn)if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),s!==null){if(o===JV)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(s=t.get("WEBGL_compressed_texture_s3tc"),s!==null){if(o===JV)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===tU)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===eU)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(o===Put||o===Iut||o===Lut||o===kut)if(s=t.get("WEBGL_compressed_texture_pvrtc"),s!==null){if(o===Put)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===Iut)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===Lut)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===kut)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(o===Afe)return s=t.get("WEBGL_compressed_texture_etc1"),s!==null?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===Rut||o===Nut)if(s=t.get("WEBGL_compressed_texture_etc"),s!==null){if(o===Rut)return a===Yn?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===Nut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(o===Dut||o===Out||o===zut||o===Fut||o===But||o===Hut||o===Vut||o===Uut||o===qut||o===Gut||o===Wut||o===Yut||o===jut||o===Xut)if(s=t.get("WEBGL_compressed_texture_astc"),s!==null){if(o===Dut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===Out)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===zut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===Fut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===But)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===Hut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===Vut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===Uut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===qut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Gut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Wut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===Yut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===jut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===Xut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(o===$ut)if(s=t.get("EXT_texture_compression_bptc"),s!==null){if(o===$ut)return a===Yn?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(o===P1)return n?34042:(s=t.get("WEBGL_depth_texture"),s!==null?s.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:i}}var n6=class extends Ui{constructor(t=[]){super(),this.cameras=t}};n6.prototype.isArrayCamera=!0;var $d=class extends or{constructor(){super(),this.type="Group"}};$d.prototype.isGroup=!0;var kgr={type:"move"},qP=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new $d,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new $d,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new j,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new j),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new $d,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new j,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new j),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,r,n){let i=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&r.session.visibilityState!=="visible-blurred")if(s!==null&&(i=r.getPose(t.targetRaySpace,n),i!==null&&(s.matrix.fromArray(i.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),i.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(i.linearVelocity)):s.hasLinearVelocity=!1,i.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(i.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(kgr))),c&&t.hand){a=!0;for(let g of t.hand.values()){let _=r.getJointPose(g,n);if(c.joints[g.jointName]===void 0){let x=new $d;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[g.jointName]=x,c.add(x)}let y=c.joints[g.jointName];_!==null&&(y.matrix.fromArray(_.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=_.radius),y.visible=_!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),p=.02,d=.005;c.inputState.pinching&&f>p+d?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=p-d&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(o=r.getPose(t.gripSpace,n),o!==null&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return s!==null&&(s.visible=i!==null),l!==null&&(l.visible=o!==null),c!==null&&(c.visible=a!==null),this}},nM=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u){if(u=u!==void 0?u:F0,u!==F0&&u!==R1)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");n===void 0&&u===F0&&(n=G3),n===void 0&&u===R1&&(n=P1),super(null,i,o,a,s,l,u,n,c),this.image={width:t,height:r},this.magFilter=s!==void 0?s:Li,this.minFilter=l!==void 0?l:Li,this.flipY=!1,this.generateMipmaps=!1}};nM.prototype.isDepthTexture=!0;var eht=class extends qs{constructor(t,r){super();let n=this,i=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,p=!1,d=null,g=r.getContextAttributes(),_=null,y=null,x=[],b=new Map,S=new Ui;S.layers.enable(1),S.viewport=new en;let C=new Ui;C.layers.enable(2),C.viewport=new en;let P=[S,C],k=new n6;k.layers.enable(1),k.layers.enable(2);let O=null,D=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getTargetRaySpace()},this.getControllerGrip=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getGripSpace()},this.getHand=function(ot){let st=x[ot];return st===void 0&&(st=new qP,x[ot]=st),st.getHandSpace()};function B(ot){let st=b.get(ot.inputSource);st&&st.dispatchEvent({type:ot.type,data:ot.inputSource})}function I(){b.forEach(function(ot,st){ot.disconnect(st)}),b.clear(),O=null,D=null,t.setRenderTarget(_),f=null,h=null,u=null,i=null,y=null,rt.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(ot){o=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(ot){s=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return d},this.getSession=function(){return i},this.setSession=function(ot){return Ri(this,null,function*(){if(i=ot,i!==null){if(_=t.getRenderTarget(),i.addEventListener("select",B),i.addEventListener("selectstart",B),i.addEventListener("selectend",B),i.addEventListener("squeeze",B),i.addEventListener("squeezestart",B),i.addEventListener("squeezeend",B),i.addEventListener("end",I),i.addEventListener("inputsourceschange",L),g.xrCompatible!==!0&&(yield r.makeXRCompatible()),i.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let st={antialias:i.renderState.layers===void 0?g.antialias:!0,alpha:g.alpha,depth:g.depth,stencil:g.stencil,framebufferScaleFactor:o};f=new XRWebGLLayer(i,r,st),i.updateRenderState({baseLayer:f}),y=new hs(f.framebufferWidth,f.framebufferHeight,{format:Qo,type:Jd,encoding:t.outputEncoding})}else{p=g.antialias;let st=null,St=null,bt=null;g.depth&&(bt=g.stencil?35056:33190,st=g.stencil?R1:F0,St=g.stencil?P1:G3);let Mt={colorFormat:t.outputEncoding===Yn?35907:32856,depthFormat:bt,scaleFactor:o};u=new XRWebGLBinding(i,r),h=u.createProjectionLayer(Mt),i.updateRenderState({layers:[h]}),p?y=new j3(h.textureWidth,h.textureHeight,{format:Qo,type:Jd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):y=new hs(h.textureWidth,h.textureHeight,{format:Qo,type:Jd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),a=yield i.requestReferenceSpace(s),rt.setContext(i),rt.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}})};function L(ot){let st=i.inputSources;for(let St=0;St<x.length;St++)b.set(st[St],x[St]);for(let St=0;St<ot.removed.length;St++){let bt=ot.removed[St],Mt=b.get(bt);Mt&&(Mt.dispatchEvent({type:"disconnected",data:bt}),b.delete(bt))}for(let St=0;St<ot.added.length;St++){let bt=ot.added[St],Mt=b.get(bt);Mt&&Mt.dispatchEvent({type:"connected",data:bt})}}let R=new j,F=new j;function z(ot,st,St){R.setFromMatrixPosition(st.matrixWorld),F.setFromMatrixPosition(St.matrixWorld);let bt=R.distanceTo(F),Mt=st.projectionMatrix.elements,lt=St.projectionMatrix.elements,Kt=Mt[14]/(Mt[10]-1),_t=Mt[14]/(Mt[10]+1),ct=(Mt[9]+1)/Mt[5],X=(Mt[9]-1)/Mt[5],et=(Mt[8]-1)/Mt[0],dt=(lt[8]+1)/lt[0],q=Kt*et,pt=Kt*dt,ht=bt/(-et+dt),wt=ht*-et;st.matrixWorld.decompose(ot.position,ot.quaternion,ot.scale),ot.translateX(wt),ot.translateZ(ht),ot.matrixWorld.compose(ot.position,ot.quaternion,ot.scale),ot.matrixWorldInverse.copy(ot.matrixWorld).invert();let kt=Kt+ht,ie=_t+ht,ee=q-wt,Le=pt+(bt-wt),ar=ct*_t/ie*kt,fr=X*_t/ie*kt;ot.projectionMatrix.makePerspective(ee,Le,ar,fr,kt,ie)}function U(ot,st){st===null?ot.matrixWorld.copy(ot.matrix):ot.matrixWorld.multiplyMatrices(st.matrixWorld,ot.matrix),ot.matrixWorldInverse.copy(ot.matrixWorld).invert()}this.updateCamera=function(ot){if(i===null)return;k.near=C.near=S.near=ot.near,k.far=C.far=S.far=ot.far,(O!==k.near||D!==k.far)&&(i.updateRenderState({depthNear:k.near,depthFar:k.far}),O=k.near,D=k.far);let st=ot.parent,St=k.cameras;U(k,st);for(let Mt=0;Mt<St.length;Mt++)U(St[Mt],st);k.matrixWorld.decompose(k.position,k.quaternion,k.scale),ot.position.copy(k.position),ot.quaternion.copy(k.quaternion),ot.scale.copy(k.scale),ot.matrix.copy(k.matrix),ot.matrixWorld.copy(k.matrixWorld);let bt=ot.children;for(let Mt=0,lt=bt.length;Mt<lt;Mt++)bt[Mt].updateMatrixWorld(!0);St.length===2?z(k,S,C):k.projectionMatrix.copy(S.projectionMatrix)},this.getCamera=function(){return k},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(ot){h!==null&&(h.fixedFoveation=ot),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=ot)};let W=null;function Z(ot,st){if(c=st.getViewerPose(a),d=st,c!==null){let bt=c.views;f!==null&&(t.setRenderTargetFramebuffer(y,f.framebuffer),t.setRenderTarget(y));let Mt=!1;bt.length!==k.cameras.length&&(k.cameras.length=0,Mt=!0);for(let lt=0;lt<bt.length;lt++){let Kt=bt[lt],_t=null;if(f!==null)_t=f.getViewport(Kt);else{let X=u.getViewSubImage(h,Kt);_t=X.viewport,lt===0&&(t.setRenderTargetTextures(y,X.colorTexture,h.ignoreDepthValues?void 0:X.depthStencilTexture),t.setRenderTarget(y))}let ct=P[lt];ct.matrix.fromArray(Kt.transform.matrix),ct.projectionMatrix.fromArray(Kt.projectionMatrix),ct.viewport.set(_t.x,_t.y,_t.width,_t.height),lt===0&&k.matrix.copy(ct.matrix),Mt===!0&&k.cameras.push(ct)}}let St=i.inputSources;for(let bt=0;bt<x.length;bt++){let Mt=x[bt],lt=St[bt];Mt.update(lt,st,a)}W&&W(ot,st),d=null}let rt=new Ufe;rt.setAnimationLoop(Z),this.setAnimationLoop=function(ot){W=ot},this.dispose=function(){}}};function Rgr(e){function t(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)}function r(y,x,b,S,C){x.isMeshBasicMaterial?n(y,x):x.isMeshLambertMaterial?(n(y,x),l(y,x)):x.isMeshToonMaterial?(n(y,x),u(y,x)):x.isMeshPhongMaterial?(n(y,x),c(y,x)):x.isMeshStandardMaterial?(n(y,x),x.isMeshPhysicalMaterial?f(y,x,C):h(y,x)):x.isMeshMatcapMaterial?(n(y,x),p(y,x)):x.isMeshDepthMaterial?(n(y,x),d(y,x)):x.isMeshDistanceMaterial?(n(y,x),g(y,x)):x.isMeshNormalMaterial?(n(y,x),_(y,x)):x.isLineBasicMaterial?(i(y,x),x.isLineDashedMaterial&&o(y,x)):x.isPointsMaterial?a(y,x,b,S):x.isSpriteMaterial?s(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}function n(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b=e.get(x).envMap;b&&(y.envMap.value=b,y.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity);let S;x.map?S=x.map:x.specularMap?S=x.specularMap:x.displacementMap?S=x.displacementMap:x.normalMap?S=x.normalMap:x.bumpMap?S=x.bumpMap:x.roughnessMap?S=x.roughnessMap:x.metalnessMap?S=x.metalnessMap:x.alphaMap?S=x.alphaMap:x.emissiveMap?S=x.emissiveMap:x.clearcoatMap?S=x.clearcoatMap:x.clearcoatNormalMap?S=x.clearcoatNormalMap:x.clearcoatRoughnessMap?S=x.clearcoatRoughnessMap:x.specularIntensityMap?S=x.specularIntensityMap:x.specularColorMap?S=x.specularColorMap:x.transmissionMap?S=x.transmissionMap:x.thicknessMap?S=x.thicknessMap:x.sheenColorMap?S=x.sheenColorMap:x.sheenRoughnessMap&&(S=x.sheenRoughnessMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),y.uvTransform.value.copy(S.matrix));let C;x.aoMap?C=x.aoMap:x.lightMap&&(C=x.lightMap),C!==void 0&&(C.isWebGLRenderTarget&&(C=C.texture),C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uv2Transform.value.copy(C.matrix))}function i(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}function o(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}function a(y,x,b,S){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*b,y.scale.value=S*.5,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let C;x.map?C=x.map:x.alphaMap&&(C=x.alphaMap),C!==void 0&&(C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uvTransform.value.copy(C.matrix))}function s(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b;x.map?b=x.map:x.alphaMap&&(b=x.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),y.uvTransform.value.copy(b.matrix))}function l(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}function c(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function u(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function h(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),e.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}function f(y,x,b){h(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===Ii&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=b.texture,y.transmissionSamplerSize.value.set(b.width,b.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}function p(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function d(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function g(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}function _(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:r}}function Ngr(){let e=t6("canvas");return e.style.display="block",e}function rn(e={}){let t=e.canvas!==void 0?e.canvas:Ngr(),r=e.context!==void 0?e.context:null,n=e.alpha!==void 0?e.alpha:!1,i=e.depth!==void 0?e.depth:!0,o=e.stencil!==void 0?e.stencil:!0,a=e.antialias!==void 0?e.antialias:!1,s=e.premultipliedAlpha!==void 0?e.premultipliedAlpha:!0,l=e.preserveDrawingBuffer!==void 0?e.preserveDrawingBuffer:!1,c=e.powerPreference!==void 0?e.powerPreference:"default",u=e.failIfMajorPerformanceCaveat!==void 0?e.failIfMajorPerformanceCaveat:!1,h=null,f=null,p=[],d=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=tm,this.physicallyCorrectLights=!1,this.toneMapping=Zd,this.toneMappingExposure=1;let g=this,_=!1,y=0,x=0,b=null,S=-1,C=null,P=new en,k=new en,O=null,D=t.width,B=t.height,I=1,L=null,R=null,F=new en(0,0,D,B),z=new en(0,0,D,B),U=!1,W=new D1,Z=!1,rt=!1,ot=null,st=new Me,St=new j,bt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function Mt(){return b===null?I:1}let lt=r;function Kt(K,gt){for(let Et=0;Et<K.length;Et++){let xt=K[Et],Ft=t.getContext(xt,gt);if(Ft!==null)return Ft}return null}try{let K={alpha:!0,depth:i,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${jU}`),t.addEventListener("webglcontextlost",fe,!1),t.addEventListener("webglcontextrestored",at,!1),lt===null){let gt=["webgl2","webgl","experimental-webgl"];if(g.isWebGL1Renderer===!0&&gt.shift(),lt=Kt(gt,K),lt===null)throw Kt(gt)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}lt.getShaderPrecisionFormat===void 0&&(lt.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(K){throw console.error("THREE.WebGLRenderer: "+K.message),K}let _t,ct,X,et,dt,q,pt,ht,wt,kt,ie,ee,Le,ar,fr,tt,$,It,$t,he,Tt,be,nt;function Ct(){_t=new nmr(lt),ct=new Zdr(lt,_t,e),_t.init(ct),be=new Qfe(lt,_t,ct),X=new Igr(lt,_t,ct),et=new amr(lt),dt=new vgr,q=new Lgr(lt,_t,X,dt,ct,be,et),pt=new Qdr(g),ht=new rmr(g),wt=new bfr(lt,ct),nt=new $dr(lt,_t,wt,ct),kt=new imr(lt,wt,et,nt),ie=new umr(lt,kt,wt,et),$t=new cmr(lt,ct,q),tt=new Jdr(dt),ee=new ygr(g,pt,ht,_t,ct,nt,tt),Le=new Rgr(dt),ar=new bgr,fr=new Cgr(_t,ct),It=new Xdr(g,pt,X,ie,n,s),$=new Jfe(g,ie,ct),he=new Kdr(lt,_t,et,ct),Tt=new omr(lt,_t,et,ct),et.programs=ee.programs,g.capabilities=ct,g.extensions=_t,g.properties=dt,g.renderLists=ar,g.shadowMap=$,g.state=X,g.info=et}Ct();let Wt=new eht(g,lt);this.xr=Wt,this.getContext=function(){return lt},this.getContextAttributes=function(){return lt.getContextAttributes()},this.forceContextLoss=function(){let K=_t.get("WEBGL_lose_context");K&&K.loseContext()},this.forceContextRestore=function(){let K=_t.get("WEBGL_lose_context");K&&K.restoreContext()},this.getPixelRatio=function(){return I},this.setPixelRatio=function(K){K!==void 0&&(I=K,this.setSize(D,B,!1))},this.getSize=function(K){return K.set(D,B)},this.setSize=function(K,gt,Et){if(Wt.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}D=K,B=gt,t.width=Math.floor(K*I),t.height=Math.floor(gt*I),Et!==!1&&(t.style.width=K+"px",t.style.height=gt+"px"),this.setViewport(0,0,K,gt)},this.getDrawingBufferSize=function(K){return K.set(D*I,B*I).floor()},this.setDrawingBufferSize=function(K,gt,Et){D=K,B=gt,I=Et,t.width=Math.floor(K*Et),t.height=Math.floor(gt*Et),this.setViewport(0,0,K,gt)},this.getCurrentViewport=function(K){return K.copy(P)},this.getViewport=function(K){return K.copy(F)},this.setViewport=function(K,gt,Et,xt){K.isVector4?F.set(K.x,K.y,K.z,K.w):F.set(K,gt,Et,xt),X.viewport(P.copy(F).multiplyScalar(I).floor())},this.getScissor=function(K){return K.copy(z)},this.setScissor=function(K,gt,Et,xt){K.isVector4?z.set(K.x,K.y,K.z,K.w):z.set(K,gt,Et,xt),X.scissor(k.copy(z).multiplyScalar(I).floor())},this.getScissorTest=function(){return U},this.setScissorTest=function(K){X.setScissorTest(U=K)},this.setOpaqueSort=function(K){L=K},this.setTransparentSort=function(K){R=K},this.getClearColor=function(K){return K.copy(It.getClearColor())},this.setClearColor=function(){It.setClearColor.apply(It,arguments)},this.getClearAlpha=function(){return It.getClearAlpha()},this.setClearAlpha=function(){It.setClearAlpha.apply(It,arguments)},this.clear=function(K,gt,Et){let xt=0;(K===void 0||K)&&(xt|=16384),(gt===void 0||gt)&&(xt|=256),(Et===void 0||Et)&&(xt|=1024),lt.clear(xt)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",fe,!1),t.removeEventListener("webglcontextrestored",at,!1),ar.dispose(),fr.dispose(),dt.dispose(),pt.dispose(),ht.dispose(),ie.dispose(),nt.dispose(),ee.dispose(),Wt.dispose(),Wt.removeEventListener("sessionstart",ze),Wt.removeEventListener("sessionend",yn),ot&&(ot.dispose(),ot=null),Wi.stop()};function fe(K){K.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),_=!0}function at(){console.log("THREE.WebGLRenderer: Context Restored."),_=!1;let K=et.autoReset,gt=$.enabled,Et=$.autoUpdate,xt=$.needsUpdate,Ft=$.type;Ct(),et.autoReset=K,$.enabled=gt,$.autoUpdate=Et,$.needsUpdate=xt,$.type=Ft}function se(K){let gt=K.target;gt.removeEventListener("dispose",se),Qt(gt)}function Qt(K){Ce(K),dt.remove(K)}function Ce(K){let gt=dt.get(K).programs;gt!==void 0&&(gt.forEach(function(Et){ee.releaseProgram(Et)}),K.isShaderMaterial&&ee.releaseShaderCache(K))}this.renderBufferDirect=function(K,gt,Et,xt,Ft,Ve){gt===null&&(gt=bt);let Ue=Ft.isMesh&&Ft.matrixWorld.determinant()<0,tr=cn(K,gt,Et,xt,Ft);X.setMaterial(xt,Ue);let Ke=Et.index,Xr=Et.attributes.position;if(Ke===null){if(Xr===void 0||Xr.count===0)return}else if(Ke.count===0)return;let _r=1;xt.wireframe===!0&&(Ke=kt.getWireframeAttribute(Et),_r=2),nt.setup(Ft,xt,tr,Et,Ke);let Pr,Xn=he;Ke!==null&&(Pr=wt.get(Ke),Xn=Tt,Xn.setIndex(Pr));let ip=Ke!==null?Ke.count:Xr.count,hm=Et.drawRange.start*_r,mr=Et.drawRange.count*_r,Bl=Ve!==null?Ve.start*_r:0,$n=Ve!==null?Ve.count*_r:1/0,Hl=Math.max(hm,Bl),hx=Math.min(ip,hm+mr,Bl+$n)-1,Vl=Math.max(0,hx-Hl+1);if(Vl!==0){if(Ft.isMesh)xt.wireframe===!0?(X.setLineWidth(xt.wireframeLinewidth*Mt()),Xn.setMode(1)):Xn.setMode(4);else if(Ft.isLine){let Ul=xt.linewidth;Ul===void 0&&(Ul=1),X.setLineWidth(Ul*Mt()),Ft.isLineSegments?Xn.setMode(1):Ft.isLineLoop?Xn.setMode(2):Xn.setMode(3)}else Ft.isPoints?Xn.setMode(0):Ft.isSprite&&Xn.setMode(4);if(Ft.isInstancedMesh)Xn.renderInstances(Hl,Vl,Ft.count);else if(Et.isInstancedBufferGeometry){let Ul=Math.min(Et.instanceCount,Et._maxInstanceCount);Xn.renderInstances(Hl,Vl,Ul)}else Xn.render(Hl,Vl)}},this.compile=function(K,gt){f=fr.get(K),f.init(),d.push(f),K.traverseVisible(function(Et){Et.isLight&&Et.layers.test(gt.layers)&&(f.pushLight(Et),Et.castShadow&&f.pushShadow(Et))}),f.setupLights(g.physicallyCorrectLights),K.traverse(function(Et){let xt=Et.material;if(xt)if(Array.isArray(xt))for(let Ft=0;Ft<xt.length;Ft++){let Ve=xt[Ft];um(Ve,K,Et)}else um(xt,K,Et)}),d.pop(),f=null};let Pt=null;function Nt(K){Pt&&Pt(K)}function ze(){Wi.stop()}function yn(){Wi.start()}let Wi=new Ufe;Wi.setAnimationLoop(Nt),typeof window!="undefined"&&Wi.setContext(window),this.setAnimationLoop=function(K){Pt=K,Wt.setAnimationLoop(K),K===null?Wi.stop():Wi.start()},Wt.addEventListener("sessionstart",ze),Wt.addEventListener("sessionend",yn),this.render=function(K,gt){if(gt!==void 0&&gt.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(_===!0)return;K.autoUpdate===!0&&K.updateMatrixWorld(),gt.parent===null&&gt.updateMatrixWorld(),Wt.enabled===!0&&Wt.isPresenting===!0&&(Wt.cameraAutoUpdate===!0&&Wt.updateCamera(gt),gt=Wt.getCamera()),K.isScene===!0&&K.onBeforeRender(g,K,gt,b),f=fr.get(K,d.length),f.init(),d.push(f),st.multiplyMatrices(gt.projectionMatrix,gt.matrixWorldInverse),W.setFromProjectionMatrix(st),rt=this.localClippingEnabled,Z=tt.init(this.clippingPlanes,rt,gt),h=ar.get(K,p.length),h.init(),p.push(h),Ar(K,gt,0,g.sortObjects),h.finish(),g.sortObjects===!0&&h.sort(L,R),Z===!0&&tt.beginShadows();let Et=f.state.shadowsArray;if($.render(Et,K,gt),Z===!0&&tt.endShadows(),this.info.autoReset===!0&&this.info.reset(),It.render(h,K),f.setupLights(g.physicallyCorrectLights),gt.isArrayCamera){let xt=gt.cameras;for(let Ft=0,Ve=xt.length;Ft<Ve;Ft++){let Ue=xt[Ft];Ia(h,K,Ue,Ue.viewport)}}else Ia(h,K,gt);b!==null&&(q.updateMultisampleRenderTarget(b),q.updateRenderTargetMipmap(b)),K.isScene===!0&&K.onAfterRender(g,K,gt),X.buffers.depth.setTest(!0),X.buffers.depth.setMask(!0),X.buffers.color.setMask(!0),X.setPolygonOffset(!1),nt.resetDefaultState(),S=-1,C=null,d.pop(),d.length>0?f=d[d.length-1]:f=null,p.pop(),p.length>0?h=p[p.length-1]:h=null};function Ar(K,gt,Et,xt){if(K.visible===!1)return;if(K.layers.test(gt.layers)){if(K.isGroup)Et=K.renderOrder;else if(K.isLOD)K.autoUpdate===!0&&K.update(gt);else if(K.isLight)f.pushLight(K),K.castShadow&&f.pushShadow(K);else if(K.isSprite){if(!K.frustumCulled||W.intersectsSprite(K)){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}else if((K.isMesh||K.isLine||K.isPoints)&&(K.isSkinnedMesh&&K.skeleton.frame!==et.render.frame&&(K.skeleton.update(),K.skeleton.frame=et.render.frame),!K.frustumCulled||W.intersectsObject(K))){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;if(Array.isArray(tr)){let Ke=Ue.groups;for(let Xr=0,_r=Ke.length;Xr<_r;Xr++){let Pr=Ke[Xr],Xn=tr[Pr.materialIndex];Xn&&Xn.visible&&h.push(K,Ue,Xn,Et,St.z,Pr)}}else tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}let Ve=K.children;for(let Ue=0,tr=Ve.length;Ue<tr;Ue++)Ar(Ve[Ue],gt,Et,xt)}function Ia(K,gt,Et,xt){let Ft=K.opaque,Ve=K.transmissive,Ue=K.transparent;f.setupLightsView(Et),Ve.length>0&&ho(Ft,gt,Et),xt&&X.viewport(P.copy(xt)),Ft.length>0&&La(Ft,gt,Et),Ve.length>0&&La(Ve,gt,Et),Ue.length>0&&La(Ue,gt,Et)}function ho(K,gt,Et){if(ot===null){let Ue=a===!0&&ct.isWebGL2===!0?j3:hs;ot=new Ue(1024,1024,{generateMipmaps:!0,type:be.convert(A1)!==null?A1:Jd,minFilter:ax,magFilter:Li,wrapS:Jo,wrapT:Jo,useRenderToTexture:_t.has("WEBGL_multisampled_render_to_texture")})}let xt=g.getRenderTarget();g.setRenderTarget(ot),g.clear();let Ft=g.toneMapping;g.toneMapping=Zd,La(K,gt,Et),g.toneMapping=Ft,q.updateMultisampleRenderTarget(ot),q.updateRenderTargetMipmap(ot),g.setRenderTarget(xt)}function La(K,gt,Et){let xt=gt.isScene===!0?gt.overrideMaterial:null;for(let Ft=0,Ve=K.length;Ft<Ve;Ft++){let Ue=K[Ft],tr=Ue.object,Ke=Ue.geometry,Xr=xt===null?Ue.material:xt,_r=Ue.group;tr.layers.test(Et.layers)&&cx(tr,gt,Et,Ke,Xr,_r)}}function cx(K,gt,Et,xt,Ft,Ve){K.onBeforeRender(g,gt,Et,xt,Ft,Ve),K.modelViewMatrix.multiplyMatrices(Et.matrixWorldInverse,K.matrixWorld),K.normalMatrix.getNormalMatrix(K.modelViewMatrix),Ft.onBeforeRender(g,gt,Et,xt,K,Ve),Ft.transparent===!0&&Ft.side===k1?(Ft.side=Ii,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=L1,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=k1):g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),K.onAfterRender(g,gt,Et,xt,Ft,Ve)}function um(K,gt,Et){gt.isScene!==!0&&(gt=bt);let xt=dt.get(K),Ft=f.state.lights,Ve=f.state.shadowsArray,Ue=Ft.state.version,tr=ee.getParameters(K,Ft.state,Ve,gt,Et),Ke=ee.getProgramCacheKey(tr),Xr=xt.programs;xt.environment=K.isMeshStandardMaterial?gt.environment:null,xt.fog=gt.fog,xt.envMap=(K.isMeshStandardMaterial?ht:pt).get(K.envMap||xt.environment),Xr===void 0&&(K.addEventListener("dispose",se),Xr=new Map,xt.programs=Xr);let _r=Xr.get(Ke);if(_r!==void 0){if(xt.currentProgram===_r&&xt.lightsStateVersion===Ue)return Q0(K,tr),_r}else tr.uniforms=ee.getUniforms(K),K.onBuild(Et,tr,g),K.onBeforeCompile(tr,g),_r=ee.acquireProgram(tr,Ke),Xr.set(Ke,_r),xt.uniforms=tr.uniforms;let Pr=xt.uniforms;(!K.isShaderMaterial&&!K.isRawShaderMaterial||K.clipping===!0)&&(Pr.clippingPlanes=tt.uniform),Q0(K,tr),xt.needsLights=np(K),xt.lightsStateVersion=Ue,xt.needsLights&&(Pr.ambientLightColor.value=Ft.state.ambient,Pr.lightProbe.value=Ft.state.probe,Pr.directionalLights.value=Ft.state.directional,Pr.directionalLightShadows.value=Ft.state.directionalShadow,Pr.spotLights.value=Ft.state.spot,Pr.spotLightShadows.value=Ft.state.spotShadow,Pr.rectAreaLights.value=Ft.state.rectArea,Pr.ltc_1.value=Ft.state.rectAreaLTC1,Pr.ltc_2.value=Ft.state.rectAreaLTC2,Pr.pointLights.value=Ft.state.point,Pr.pointLightShadows.value=Ft.state.pointShadow,Pr.hemisphereLights.value=Ft.state.hemi,Pr.directionalShadowMap.value=Ft.state.directionalShadowMap,Pr.directionalShadowMatrix.value=Ft.state.directionalShadowMatrix,Pr.spotShadowMap.value=Ft.state.spotShadowMap,Pr.spotShadowMatrix.value=Ft.state.spotShadowMatrix,Pr.pointShadowMap.value=Ft.state.pointShadowMap,Pr.pointShadowMatrix.value=Ft.state.pointShadowMatrix);let Xn=_r.getUniforms(),ip=H0.seqWithValue(Xn.seq,Pr);return xt.currentProgram=_r,xt.uniformsList=ip,_r}function Q0(K,gt){let Et=dt.get(K);Et.outputEncoding=gt.outputEncoding,Et.instancing=gt.instancing,Et.skinning=gt.skinning,Et.morphTargets=gt.morphTargets,Et.morphNormals=gt.morphNormals,Et.morphTargetsCount=gt.morphTargetsCount,Et.numClippingPlanes=gt.numClippingPlanes,Et.numIntersection=gt.numClipIntersection,Et.vertexAlphas=gt.vertexAlphas,Et.vertexTangents=gt.vertexTangents,Et.toneMapping=gt.toneMapping}function cn(K,gt,Et,xt,Ft){gt.isScene!==!0&&(gt=bt),q.resetTextureUnits();let Ve=gt.fog,Ue=xt.isMeshStandardMaterial?gt.environment:null,tr=b===null?g.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:tm,Ke=(xt.isMeshStandardMaterial?ht:pt).get(xt.envMap||Ue),Xr=xt.vertexColors===!0&&!!Et.attributes.color&&Et.attributes.color.itemSize===4,_r=!!xt.normalMap&&!!Et.attributes.tangent,Pr=!!Et.morphAttributes.position,Xn=!!Et.morphAttributes.normal,ip=Et.morphAttributes.position?Et.morphAttributes.position.length:0,hm=xt.toneMapped?g.toneMapping:Zd,mr=dt.get(xt),Bl=f.state.lights;if(Z===!0&&(rt===!0||K!==C)){let Gs=K===C&&xt.id===S;tt.setState(xt,K,Gs)}let $n=!1;xt.version===mr.__version?(mr.needsLights&&mr.lightsStateVersion!==Bl.state.version||mr.outputEncoding!==tr||Ft.isInstancedMesh&&mr.instancing===!1||!Ft.isInstancedMesh&&mr.instancing===!0||Ft.isSkinnedMesh&&mr.skinning===!1||!Ft.isSkinnedMesh&&mr.skinning===!0||mr.envMap!==Ke||xt.fog&&mr.fog!==Ve||mr.numClippingPlanes!==void 0&&(mr.numClippingPlanes!==tt.numPlanes||mr.numIntersection!==tt.numIntersection)||mr.vertexAlphas!==Xr||mr.vertexTangents!==_r||mr.morphTargets!==Pr||mr.morphNormals!==Xn||mr.toneMapping!==hm||ct.isWebGL2===!0&&mr.morphTargetsCount!==ip)&&($n=!0):($n=!0,mr.__version=xt.version);let Hl=mr.currentProgram;$n===!0&&(Hl=um(xt,gt,Ft));let hx=!1,Vl=!1,Ul=!1,Yi=Hl.getUniforms(),fm=mr.uniforms;if(X.useProgram(Hl.program)&&(hx=!0,Vl=!0,Ul=!0),xt.id!==S&&(S=xt.id,Vl=!0),hx||C!==K){if(Yi.setValue(lt,"projectionMatrix",K.projectionMatrix),ct.logarithmicDepthBuffer&&Yi.setValue(lt,"logDepthBufFC",2/(Math.log(K.far+1)/Math.LN2)),C!==K&&(C=K,Vl=!0,Ul=!0),xt.isShaderMaterial||xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshStandardMaterial||xt.envMap){let Gs=Yi.map.cameraPosition;Gs!==void 0&&Gs.setValue(lt,St.setFromMatrixPosition(K.matrixWorld))}(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial)&&Yi.setValue(lt,"isOrthographic",K.isOrthographicCamera===!0),(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial||xt.isShadowMaterial||Ft.isSkinnedMesh)&&Yi.setValue(lt,"viewMatrix",K.matrixWorldInverse)}if(Ft.isSkinnedMesh){Yi.setOptional(lt,Ft,"bindMatrix"),Yi.setOptional(lt,Ft,"bindMatrixInverse");let Gs=Ft.skeleton;Gs&&(ct.floatVertexTextures?(Gs.boneTexture===null&&Gs.computeBoneTexture(),Yi.setValue(lt,"boneTexture",Gs.boneTexture,q),Yi.setValue(lt,"boneTextureSize",Gs.boneTextureSize)):Yi.setOptional(lt,Gs,"boneMatrices"))}return!!Et&&(Et.morphAttributes.position!==void 0||Et.morphAttributes.normal!==void 0)&&$t.update(Ft,Et,xt,Hl),(Vl||mr.receiveShadow!==Ft.receiveShadow)&&(mr.receiveShadow=Ft.receiveShadow,Yi.setValue(lt,"receiveShadow",Ft.receiveShadow)),Vl&&(Yi.setValue(lt,"toneMappingExposure",g.toneMappingExposure),mr.needsLights&&ux(fm,Ul),Ve&&xt.fog&&Le.refreshFogUniforms(fm,Ve),Le.refreshMaterialUniforms(fm,xt,I,B,ot),H0.upload(lt,mr.uniformsList,fm,q)),xt.isShaderMaterial&&xt.uniformsNeedUpdate===!0&&(H0.upload(lt,mr.uniformsList,fm,q),xt.uniformsNeedUpdate=!1),xt.isSpriteMaterial&&Yi.setValue(lt,"center",Ft.center),Yi.setValue(lt,"modelViewMatrix",Ft.modelViewMatrix),Yi.setValue(lt,"normalMatrix",Ft.normalMatrix),Yi.setValue(lt,"modelMatrix",Ft.matrixWorld),Hl}function ux(K,gt){K.ambientLightColor.needsUpdate=gt,K.lightProbe.needsUpdate=gt,K.directionalLights.needsUpdate=gt,K.directionalLightShadows.needsUpdate=gt,K.pointLights.needsUpdate=gt,K.pointLightShadows.needsUpdate=gt,K.spotLights.needsUpdate=gt,K.spotLightShadows.needsUpdate=gt,K.rectAreaLights.needsUpdate=gt,K.hemisphereLights.needsUpdate=gt}function np(K){return K.isMeshLambertMaterial||K.isMeshToonMaterial||K.isMeshPhongMaterial||K.isMeshStandardMaterial||K.isShadowMaterial||K.isShaderMaterial&&K.lights===!0}this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(K,gt,Et){dt.get(K.texture).__webglTexture=gt,dt.get(K.depthTexture).__webglTexture=Et;let xt=dt.get(K);xt.__hasExternalTextures=!0,xt.__hasExternalTextures&&(xt.__autoAllocateDepthBuffer=Et===void 0,xt.__autoAllocateDepthBuffer||K.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),K.useRenderToTexture=!1,K.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(K,gt){let Et=dt.get(K);Et.__webglFramebuffer=gt,Et.__useDefaultFramebuffer=gt===void 0},this.setRenderTarget=function(K,gt=0,Et=0){b=K,y=gt,x=Et;let xt=!0;if(K){let Ke=dt.get(K);Ke.__useDefaultFramebuffer!==void 0?(X.bindFramebuffer(36160,null),xt=!1):Ke.__webglFramebuffer===void 0?q.setupRenderTarget(K):Ke.__hasExternalTextures&&q.rebindTextures(K,dt.get(K.texture).__webglTexture,dt.get(K.depthTexture).__webglTexture)}let Ft=null,Ve=!1,Ue=!1;if(K){let Ke=K.texture;(Ke.isDataTexture3D||Ke.isDataTexture2DArray)&&(Ue=!0);let Xr=dt.get(K).__webglFramebuffer;K.isWebGLCubeRenderTarget?(Ft=Xr[gt],Ve=!0):K.useRenderbuffer?Ft=dt.get(K).__webglMultisampledFramebuffer:Ft=Xr,P.copy(K.viewport),k.copy(K.scissor),O=K.scissorTest}else P.copy(F).multiplyScalar(I).floor(),k.copy(z).multiplyScalar(I).floor(),O=U;if(X.bindFramebuffer(36160,Ft)&&ct.drawBuffers&&xt&&X.drawBuffers(K,Ft),X.viewport(P),X.scissor(k),X.setScissorTest(O),Ve){let Ke=dt.get(K.texture);lt.framebufferTexture2D(36160,36064,34069+gt,Ke.__webglTexture,Et)}else if(Ue){let Ke=dt.get(K.texture),Xr=gt||0;lt.framebufferTextureLayer(36160,36064,Ke.__webglTexture,Et||0,Xr)}S=-1},this.readRenderTargetPixels=function(K,gt,Et,xt,Ft,Ve,Ue){if(!(K&&K.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let tr=dt.get(K).__webglFramebuffer;if(K.isWebGLCubeRenderTarget&&Ue!==void 0&&(tr=tr[Ue]),tr){X.bindFramebuffer(36160,tr);try{let Ke=K.texture,Xr=Ke.format,_r=Ke.type;if(Xr!==Qo&&be.convert(Xr)!==lt.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Pr=_r===A1&&(_t.has("EXT_color_buffer_half_float")||ct.isWebGL2&&_t.has("EXT_color_buffer_float"));if(_r!==Jd&&be.convert(_r)!==lt.getParameter(35738)&&!(_r===Xd&&(ct.isWebGL2||_t.has("OES_texture_float")||_t.has("WEBGL_color_buffer_float")))&&!Pr){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}lt.checkFramebufferStatus(36160)===36053?gt>=0&&gt<=K.width-xt&&Et>=0&&Et<=K.height-Ft&&lt.readPixels(gt,Et,xt,Ft,be.convert(Xr),be.convert(_r),Ve):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Ke=b!==null?dt.get(b).__webglFramebuffer:null;X.bindFramebuffer(36160,Ke)}}},this.copyFramebufferToTexture=function(K,gt,Et=0){if(gt.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let xt=Math.pow(2,-Et),Ft=Math.floor(gt.image.width*xt),Ve=Math.floor(gt.image.height*xt);q.setTexture2D(gt,0),lt.copyTexSubImage2D(3553,Et,0,0,K.x,K.y,Ft,Ve),X.unbindTexture()},this.copyTextureToTexture=function(K,gt,Et,xt=0){let Ft=gt.image.width,Ve=gt.image.height,Ue=be.convert(Et.format),tr=be.convert(Et.type);q.setTexture2D(Et,0),lt.pixelStorei(37440,Et.flipY),lt.pixelStorei(37441,Et.premultiplyAlpha),lt.pixelStorei(3317,Et.unpackAlignment),gt.isDataTexture?lt.texSubImage2D(3553,xt,K.x,K.y,Ft,Ve,Ue,tr,gt.image.data):gt.isCompressedTexture?lt.compressedTexSubImage2D(3553,xt,K.x,K.y,gt.mipmaps[0].width,gt.mipmaps[0].height,Ue,gt.mipmaps[0].data):lt.texSubImage2D(3553,xt,K.x,K.y,Ue,tr,gt.image),xt===0&&Et.generateMipmaps&&lt.generateMipmap(3553),X.unbindTexture()},this.copyTextureToTexture3D=function(K,gt,Et,xt,Ft=0){if(g.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Ve=K.max.x-K.min.x+1,Ue=K.max.y-K.min.y+1,tr=K.max.z-K.min.z+1,Ke=be.convert(xt.format),Xr=be.convert(xt.type),_r;if(xt.isDataTexture3D)q.setTexture3D(xt,0),_r=32879;else if(xt.isDataTexture2DArray)q.setTexture2DArray(xt,0),_r=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}lt.pixelStorei(37440,xt.flipY),lt.pixelStorei(37441,xt.premultiplyAlpha),lt.pixelStorei(3317,xt.unpackAlignment);let Pr=lt.getParameter(3314),Xn=lt.getParameter(32878),ip=lt.getParameter(3316),hm=lt.getParameter(3315),mr=lt.getParameter(32877),Bl=Et.isCompressedTexture?Et.mipmaps[0]:Et.image;lt.pixelStorei(3314,Bl.width),lt.pixelStorei(32878,Bl.height),lt.pixelStorei(3316,K.min.x),lt.pixelStorei(3315,K.min.y),lt.pixelStorei(32877,K.min.z),Et.isDataTexture||Et.isDataTexture3D?lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Bl.data):Et.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),lt.compressedTexSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Bl.data)):lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Bl),lt.pixelStorei(3314,Pr),lt.pixelStorei(32878,Xn),lt.pixelStorei(3316,ip),lt.pixelStorei(3315,hm),lt.pixelStorei(32877,mr),Ft===0&&xt.generateMipmaps&&lt.generateMipmap(_r),X.unbindTexture()},this.initTexture=function(K){q.setTexture2D(K,0),X.unbindTexture()},this.resetState=function(){y=0,x=0,b=null,X.reset(),nt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}rn.prototype.isWebGLRenderer=!0;var gU=class extends rn{};gU.prototype.isWebGL1Renderer=!0;var z1=class{constructor(t,r=25e-5){this.name="",this.color=new ne(t),this.density=r}clone(){return new z1(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};z1.prototype.isFogExp2=!0;var F1=class{constructor(t,r=1,n=1e3){this.name="",this.color=new ne(t),this.near=r,this.far=n}clone(){return new F1(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};F1.prototype.isFog=!0;var G0=class extends or{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,r){return super.copy(t,r),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let r=super.toJSON(t);return this.fog!==null&&(r.object.fog=this.fog.toJSON()),r}};G0.prototype.isScene=!0;var rm=class{constructor(t,r){this.array=t,this.stride=r,this.count=t!==void 0?t.length/r:0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Dl()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,r,n){t*=this.stride,n*=r.stride;for(let i=0,o=this.stride;i<o;i++)this.array[t+i]=r.array[n+i];return this}set(t,r=0){return this.array.set(t,r),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Dl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let r=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),n=new this.constructor(r,this.stride);return n.setUsage(this.usage),n}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Dl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};rm.prototype.isInterleavedBuffer=!0;var Ai=new j,ep=class{constructor(t,r,n,i=!1){this.name="",this.data=t,this.itemSize=r,this.offset=n,this.normalized=i===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let r=0,n=this.data.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyMatrix4(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyNormalMatrix(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.transformDirection(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}setX(t,r){return this.data.array[t*this.data.stride+this.offset]=r,this}setY(t,r){return this.data.array[t*this.data.stride+this.offset+1]=r,this}setZ(t,r){return this.data.array[t*this.data.stride+this.offset+2]=r,this}setW(t,r){return this.data.array[t*this.data.stride+this.offset+3]=r,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,r,n){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this}setXYZ(t,r,n,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this.data.array[t+3]=o,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return new Je(new this.array.constructor(r),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new ep(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:r,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};ep.prototype.isInterleavedBufferAttribute=!0;var iM=class extends qi{constructor(t){super(),this.type="SpriteMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};iM.prototype.isSpriteMaterial=!0;var N3,DP=new j,D3=new j,O3=new j,z3=new Lt,OP=new Lt,tpe=new Me,LV=new j,zP=new j,kV=new j,Zue=new Lt,dut=new Lt,Jue=new Lt,oM=class extends or{constructor(t){if(super(),this.type="Sprite",N3===void 0){N3=new Pe;let r=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),n=new rm(r,5);N3.setIndex([0,1,2,0,2,3]),N3.setAttribute("position",new ep(n,3,0,!1)),N3.setAttribute("uv",new ep(n,2,3,!1))}this.geometry=N3,this.material=t!==void 0?t:new iM,this.center=new Lt(.5,.5)}raycast(t,r){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),D3.setFromMatrixScale(this.matrixWorld),tpe.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),O3.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&D3.multiplyScalar(-O3.z);let n=this.material.rotation,i,o;n!==0&&(o=Math.cos(n),i=Math.sin(n));let a=this.center;RV(LV.set(-.5,-.5,0),O3,a,D3,i,o),RV(zP.set(.5,-.5,0),O3,a,D3,i,o),RV(kV.set(.5,.5,0),O3,a,D3,i,o),Zue.set(0,0),dut.set(1,0),Jue.set(1,1);let s=t.ray.intersectTriangle(LV,zP,kV,!1,DP);if(s===null&&(RV(zP.set(-.5,.5,0),O3,a,D3,i,o),dut.set(0,1),s=t.ray.intersectTriangle(LV,kV,zP,!1,DP),s===null))return;let l=t.ray.origin.distanceTo(DP);l<t.near||l>t.far||r.push({distance:l,point:DP.clone(),uv:oi.getUV(DP,LV,zP,kV,Zue,dut,Jue,new Lt),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};oM.prototype.isSprite=!0;function RV(e,t,r,n,i,o){z3.subVectors(e,r).addScalar(.5).multiply(n),i!==void 0?(OP.x=o*z3.x-i*z3.y,OP.y=i*z3.x+o*z3.y):OP.copy(z3),e.copy(t),e.x+=OP.x,e.y+=OP.y,e.applyMatrix4(tpe)}var NV=new j,Que=new j,_U=class extends or{constructor(){super(),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]},isLOD:{value:!0}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);let r=t.levels;for(let n=0,i=r.length;n<i;n++){let o=r[n];this.addLevel(o.object.clone(),o.distance)}return this.autoUpdate=t.autoUpdate,this}addLevel(t,r=0){r=Math.abs(r);let n=this.levels,i;for(i=0;i<n.length&&!(r<n[i].distance);i++);return n.splice(i,0,{distance:r,object:t}),this.add(t),this}getCurrentLevel(){return this._currentLevel}getObjectForDistance(t){let r=this.levels;if(r.length>0){let n,i;for(n=1,i=r.length;n<i&&!(t<r[n].distance);n++);return r[n-1].object}return null}raycast(t,r){if(this.levels.length>0){NV.setFromMatrixPosition(this.matrixWorld);let i=t.ray.origin.distanceTo(NV);this.getObjectForDistance(i).raycast(t,r)}}update(t){let r=this.levels;if(r.length>1){NV.setFromMatrixPosition(t.matrixWorld),Que.setFromMatrixPosition(this.matrixWorld);let n=NV.distanceTo(Que)/t.zoom;r[0].object.visible=!0;let i,o;for(i=1,o=r.length;i<o&&n>=r[i].distance;i++)r[i-1].object.visible=!1,r[i].object.visible=!0;for(this._currentLevel=i-1;i<o;i++)r[i].object.visible=!1}}toJSON(t){let r=super.toJSON(t);this.autoUpdate===!1&&(r.object.autoUpdate=!1),r.object.levels=[];let n=this.levels;for(let i=0,o=n.length;i<o;i++){let a=n[i];r.object.levels.push({object:a.object.uuid,distance:a.distance})}return r}},the=new j,ehe=new en,rhe=new en,Dgr=new j,nhe=new Me,aM=class extends ti{constructor(t,r){super(t,r),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Me,this.bindMatrixInverse=new Me}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,r){this.skeleton=t,r===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),r=this.matrixWorld),this.bindMatrix.copy(r),this.bindMatrixInverse.copy(r).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new en,r=this.geometry.attributes.skinWeight;for(let n=0,i=r.count;n<i;n++){t.x=r.getX(n),t.y=r.getY(n),t.z=r.getZ(n),t.w=r.getW(n);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),r.setXYZW(n,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,r){let n=this.skeleton,i=this.geometry;ehe.fromBufferAttribute(i.attributes.skinIndex,t),rhe.fromBufferAttribute(i.attributes.skinWeight,t),the.copy(r).applyMatrix4(this.bindMatrix),r.set(0,0,0);for(let o=0;o<4;o++){let a=rhe.getComponent(o);if(a!==0){let s=ehe.getComponent(o);nhe.multiplyMatrices(n.bones[s].matrixWorld,n.boneInverses[s]),r.addScaledVector(Dgr.copy(the).applyMatrix4(nhe),a)}}return r.applyMatrix4(this.bindMatrixInverse)}};aM.prototype.isSkinnedMesh=!0;var sM=class extends or{constructor(){super(),this.type="Bone"}};sM.prototype.isBone=!0;var Qd=class extends vi{constructor(t=null,r=1,n=1,i,o,a,s,l,c=Li,u=Li,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={data:t,width:r,height:n},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Qd.prototype.isDataTexture=!0;var ihe=new Me,Ogr=new Me,lM=class{constructor(t=[],r=[]){this.uuid=Dl(),this.bones=t.slice(0),this.boneInverses=r,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}init(){let t=this.bones,r=this.boneInverses;if(this.boneMatrices=new Float32Array(t.length*16),r.length===0)this.calculateInverses();else if(t.length!==r.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let n=0,i=this.bones.length;n<i;n++)this.boneInverses.push(new Me)}}calculateInverses(){this.boneInverses.length=0;for(let t=0,r=this.bones.length;t<r;t++){let n=new Me;this.bones[t]&&n.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(n)}}pose(){for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&n.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&(n.parent&&n.parent.isBone?(n.matrix.copy(n.parent.matrixWorld).invert(),n.matrix.multiply(n.matrixWorld)):n.matrix.copy(n.matrixWorld),n.matrix.decompose(n.position,n.quaternion,n.scale))}}update(){let t=this.bones,r=this.boneInverses,n=this.boneMatrices,i=this.boneTexture;for(let o=0,a=t.length;o<a;o++){let s=t[o]?t[o].matrixWorld:Ogr;ihe.multiplyMatrices(s,r[o]),ihe.toArray(n,o*16)}i!==null&&(i.needsUpdate=!0)}clone(){return new lM(this.bones,this.boneInverses)}computeBoneTexture(){let t=Math.sqrt(this.bones.length*4);t=zfe(t),t=Math.max(t,4);let r=new Float32Array(t*t*4);r.set(this.boneMatrices);let n=new Qd(r,t,t,Qo,Xd);return n.needsUpdate=!0,this.boneMatrices=r,this.boneTexture=n,this.boneTextureSize=t,this}getBoneByName(t){for(let r=0,n=this.bones.length;r<n;r++){let i=this.bones[r];if(i.name===t)return i}}dispose(){this.boneTexture!==null&&(this.boneTexture.dispose(),this.boneTexture=null)}fromJSON(t,r){this.uuid=t.uuid;for(let n=0,i=t.bones.length;n<i;n++){let o=t.bones[n],a=r[o];a===void 0&&(console.warn("THREE.Skeleton: No bone found with UUID:",o),a=new sM),this.bones.push(a),this.boneInverses.push(new Me().fromArray(t.boneInverses[n]))}return this.init(),this}toJSON(){let t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;let r=this.bones,n=this.boneInverses;for(let i=0,o=r.length;i<o;i++){let a=r[i];t.bones.push(a.uuid);let s=n[i];t.boneInverses.push(s.toArray())}return t}},nm=class extends Je{constructor(t,r,n,i=1){typeof n=="number"&&(i=n,n=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,r,n),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};nm.prototype.isInstancedBufferAttribute=!0;var ohe=new Me,ahe=new Me,DV=[],FP=new ti,i6=class extends ti{constructor(t,r,n){super(t,r),this.instanceMatrix=new nm(new Float32Array(n*16),16),this.instanceColor=null,this.count=n,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,r){r.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,r){r.fromArray(this.instanceMatrix.array,t*16)}raycast(t,r){let n=this.matrixWorld,i=this.count;if(FP.geometry=this.geometry,FP.material=this.material,FP.material!==void 0)for(let o=0;o<i;o++){this.getMatrixAt(o,ohe),ahe.multiplyMatrices(n,ohe),FP.matrixWorld=ahe,FP.raycast(t,DV);for(let a=0,s=DV.length;a<s;a++){let l=DV[a];l.instanceId=o,l.object=this,r.push(l)}DV.length=0}}setColorAt(t,r){this.instanceColor===null&&(this.instanceColor=new nm(new Float32Array(this.instanceMatrix.count*3),3)),r.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,r){r.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};i6.prototype.isInstancedMesh=!0;var Gi=class extends qi{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ne(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Gi.prototype.isLineBasicMaterial=!0;var she=new j,lhe=new j,che=new Me,mut=new Qf,OV=new Jf,ch=class extends or{constructor(t=new Pe,r=new Gi){super(),this.type="Line",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[0];for(let i=1,o=r.count;i<o;i++)she.fromBufferAttribute(r,i-1),lhe.fromBufferAttribute(r,i),n[i]=n[i-1],n[i]+=she.distanceTo(lhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Line.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),OV.copy(n.boundingSphere),OV.applyMatrix4(i),OV.radius+=o,t.ray.intersectsSphere(OV)===!1)return;che.copy(i).invert(),mut.copy(t.ray).applyMatrix4(che);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new j,u=new j,h=new j,f=new j,p=this.isLineSegments?2:1;if(n.isBufferGeometry){let d=n.index,_=n.attributes.position;if(d!==null){let y=Math.max(0,a.start),x=Math.min(d.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){let C=d.getX(b),P=d.getX(b+1);if(c.fromBufferAttribute(_,C),u.fromBufferAttribute(_,P),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let O=t.ray.origin.distanceTo(f);O<t.near||O>t.far||r.push({distance:O,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let y=Math.max(0,a.start),x=Math.min(_.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){if(c.fromBufferAttribute(_,b),u.fromBufferAttribute(_,b+1),mut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let P=t.ray.origin.distanceTo(f);P<t.near||P>t.far||r.push({distance:P,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else n.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};ch.prototype.isLine=!0;var uhe=new j,hhe=new j,Pa=class extends ch{constructor(t,r){super(t,r),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[];for(let i=0,o=r.count;i<o;i+=2)uhe.fromBufferAttribute(r,i),hhe.fromBufferAttribute(r,i+1),n[i]=i===0?0:n[i-1],n[i+1]=n[i]+uhe.distanceTo(hhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Pa.prototype.isLineSegments=!0;var o6=class extends ch{constructor(t,r){super(t,r),this.type="LineLoop"}};o6.prototype.isLineLoop=!0;var im=class extends qi{constructor(t){super(),this.type="PointsMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};im.prototype.isPointsMaterial=!0;var fhe=new Me,rht=new Qf,zV=new Jf,FV=new j,om=class extends or{constructor(t=new Pe,r=new im){super(),this.type="Points",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Points.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),zV.copy(n.boundingSphere),zV.applyMatrix4(i),zV.radius+=o,t.ray.intersectsSphere(zV)===!1)return;fhe.copy(i).invert(),rht.copy(t.ray).applyMatrix4(fhe);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(n.isBufferGeometry){let c=n.index,h=n.attributes.position;if(c!==null){let f=Math.max(0,a.start),p=Math.min(c.count,a.start+a.count);for(let d=f,g=p;d<g;d++){let _=c.getX(d);FV.fromBufferAttribute(h,_),phe(FV,_,l,i,t,r,this)}}else{let f=Math.max(0,a.start),p=Math.min(h.count,a.start+a.count);for(let d=f,g=p;d<g;d++)FV.fromBufferAttribute(h,d),phe(FV,d,l,i,t,r,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};om.prototype.isPoints=!0;function phe(e,t,r,n,i,o,a){let s=rht.distanceSqToPoint(e);if(s<r){let l=new j;rht.closestPointToPoint(e,l),l.applyMatrix4(n);let c=i.ray.origin.distanceTo(l);if(c<i.near||c>i.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}var yU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.minFilter=a!==void 0?a:ii,this.magFilter=o!==void 0?o:ii,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};yU.prototype.isVideoTexture=!0;var vU=class extends vi{constructor(t,r,n){super({width:t,height:r}),this.format=n,this.magFilter=Li,this.minFilter=Li,this.generateMipmaps=!1,this.needsUpdate=!0}};vU.prototype.isFramebufferTexture=!0;var a6=class extends vi{constructor(t,r,n,i,o,a,s,l,c,u,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={width:r,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};a6.prototype.isCompressedTexture=!0;var xU=class extends vi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.needsUpdate=!0}};xU.prototype.isCanvasTexture=!0;var B1=class extends Pe{constructor(t=1,r=8,n=0,i=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:r,thetaStart:n,thetaLength:i},r=Math.max(3,r);let o=[],a=[],s=[],l=[],c=new j,u=new Lt;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=r;h++,f+=3){let p=n+h/r*i;c.x=t*Math.cos(p),c.y=t*Math.sin(p),a.push(c.x,c.y,c.z),s.push(0,0,1),u.x=(a[f]/t+1)/2,u.y=(a[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=r;h++)o.push(h,h+1,0);this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("normal",new xe(s,3)),this.setAttribute("uv",new xe(l,2))}static fromJSON(t){return new B1(t.radius,t.segments,t.thetaStart,t.thetaLength)}},am=class extends Pe{constructor(t=1,r=1,n=1,i=8,o=1,a=!1,s=0,l=Math.PI*2){super(),this.type="CylinderGeometry",this.parameters={radiusTop:t,radiusBottom:r,height:n,radialSegments:i,heightSegments:o,openEnded:a,thetaStart:s,thetaLength:l};let c=this;i=Math.floor(i),o=Math.floor(o);let u=[],h=[],f=[],p=[],d=0,g=[],_=n/2,y=0;x(),a===!1&&(t>0&&b(!0),r>0&&b(!1)),this.setIndex(u),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function x(){let S=new j,C=new j,P=0,k=(r-t)/n;for(let O=0;O<=o;O++){let D=[],B=O/o,I=B*(r-t)+t;for(let L=0;L<=i;L++){let R=L/i,F=R*l+s,z=Math.sin(F),U=Math.cos(F);C.x=I*z,C.y=-B*n+_,C.z=I*U,h.push(C.x,C.y,C.z),S.set(z,k,U).normalize(),f.push(S.x,S.y,S.z),p.push(R,1-B),D.push(d++)}g.push(D)}for(let O=0;O<i;O++)for(let D=0;D<o;D++){let B=g[D][O],I=g[D+1][O],L=g[D+1][O+1],R=g[D][O+1];u.push(B,I,R),u.push(I,L,R),P+=6}c.addGroup(y,P,0),y+=P}function b(S){let C=d,P=new Lt,k=new j,O=0,D=S===!0?t:r,B=S===!0?1:-1;for(let L=1;L<=i;L++)h.push(0,_*B,0),f.push(0,B,0),p.push(.5,.5),d++;let I=d;for(let L=0;L<=i;L++){let F=L/i*l+s,z=Math.cos(F),U=Math.sin(F);k.x=D*U,k.y=_*B,k.z=D*z,h.push(k.x,k.y,k.z),f.push(0,B,0),P.x=z*.5+.5,P.y=U*.5*B+.5,p.push(P.x,P.y),d++}for(let L=0;L<i;L++){let R=C+L,F=I+L;S===!0?u.push(F,F+1,R):u.push(F+1,F,R),O+=3}c.addGroup(y,O,S===!0?1:2),y+=O}}static fromJSON(t){return new am(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},H1=class extends am{constructor(t=1,r=1,n=8,i=1,o=!1,a=0,s=Math.PI*2){super(0,t,r,n,i,o,a,s),this.type="ConeGeometry",this.parameters={radius:t,height:r,radialSegments:n,heightSegments:i,openEnded:o,thetaStart:a,thetaLength:s}}static fromJSON(t){return new H1(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},uh=class extends Pe{constructor(t=[],r=[],n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:r,radius:n,detail:i};let o=[],a=[];s(i),c(n),u(),this.setAttribute("position",new xe(o,3)),this.setAttribute("normal",new xe(o.slice(),3)),this.setAttribute("uv",new xe(a,2)),i===0?this.computeVertexNormals():this.normalizeNormals();function s(x){let b=new j,S=new j,C=new j;for(let P=0;P<r.length;P+=3)p(r[P+0],b),p(r[P+1],S),p(r[P+2],C),l(b,S,C,x)}function l(x,b,S,C){let P=C+1,k=[];for(let O=0;O<=P;O++){k[O]=[];let D=x.clone().lerp(S,O/P),B=b.clone().lerp(S,O/P),I=P-O;for(let L=0;L<=I;L++)L===0&&O===P?k[O][L]=D:k[O][L]=D.clone().lerp(B,L/I)}for(let O=0;O<P;O++)for(let D=0;D<2*(P-O)-1;D++){let B=Math.floor(D/2);D%2===0?(f(k[O][B+1]),f(k[O+1][B]),f(k[O][B])):(f(k[O][B+1]),f(k[O+1][B+1]),f(k[O+1][B]))}}function c(x){let b=new j;for(let S=0;S<o.length;S+=3)b.x=o[S+0],b.y=o[S+1],b.z=o[S+2],b.normalize().multiplyScalar(x),o[S+0]=b.x,o[S+1]=b.y,o[S+2]=b.z}function u(){let x=new j;for(let b=0;b<o.length;b+=3){x.x=o[b+0],x.y=o[b+1],x.z=o[b+2];let S=_(x)/2/Math.PI+.5,C=y(x)/Math.PI+.5;a.push(S,1-C)}d(),h()}function h(){for(let x=0;x<a.length;x+=6){let b=a[x+0],S=a[x+2],C=a[x+4],P=Math.max(b,S,C),k=Math.min(b,S,C);P>.9&&k<.1&&(b<.2&&(a[x+0]+=1),S<.2&&(a[x+2]+=1),C<.2&&(a[x+4]+=1))}}function f(x){o.push(x.x,x.y,x.z)}function p(x,b){let S=x*3;b.x=t[S+0],b.y=t[S+1],b.z=t[S+2]}function d(){let x=new j,b=new j,S=new j,C=new j,P=new Lt,k=new Lt,O=new Lt;for(let D=0,B=0;D<o.length;D+=9,B+=6){x.set(o[D+0],o[D+1],o[D+2]),b.set(o[D+3],o[D+4],o[D+5]),S.set(o[D+6],o[D+7],o[D+8]),P.set(a[B+0],a[B+1]),k.set(a[B+2],a[B+3]),O.set(a[B+4],a[B+5]),C.copy(x).add(b).add(S).divideScalar(3);let I=_(C);g(P,B+0,x,I),g(k,B+2,b,I),g(O,B+4,S,I)}}function g(x,b,S,C){C<0&&x.x===1&&(a[b]=x.x-1),S.x===0&&S.z===0&&(a[b]=C/2/Math.PI+.5)}function _(x){return Math.atan2(x.z,-x.x)}function y(x){return Math.atan2(-x.y,Math.sqrt(x.x*x.x+x.z*x.z))}}static fromJSON(t){return new uh(t.vertices,t.indices,t.radius,t.details)}},V1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=1/n,o=[-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],a=[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9];super(o,a,t,r),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new V1(t.radius,t.detail)}},BV=new j,HV=new j,gut=new j,VV=new oi,s6=class extends Pe{constructor(t=null,r=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:r},t!==null){let i=Math.pow(10,4),o=Math.cos(I1*r),a=t.getIndex(),s=t.getAttribute("position"),l=a?a.count:s.count,c=[0,0,0],u=["a","b","c"],h=new Array(3),f={},p=[];for(let d=0;d<l;d+=3){a?(c[0]=a.getX(d),c[1]=a.getX(d+1),c[2]=a.getX(d+2)):(c[0]=d,c[1]=d+1,c[2]=d+2);let{a:g,b:_,c:y}=VV;if(g.fromBufferAttribute(s,c[0]),_.fromBufferAttribute(s,c[1]),y.fromBufferAttribute(s,c[2]),VV.getNormal(gut),h[0]=`${Math.round(g.x*i)},${Math.round(g.y*i)},${Math.round(g.z*i)}`,h[1]=`${Math.round(_.x*i)},${Math.round(_.y*i)},${Math.round(_.z*i)}`,h[2]=`${Math.round(y.x*i)},${Math.round(y.y*i)},${Math.round(y.z*i)}`,!(h[0]===h[1]||h[1]===h[2]||h[2]===h[0]))for(let x=0;x<3;x++){let b=(x+1)%3,S=h[x],C=h[b],P=VV[u[x]],k=VV[u[b]],O=`${S}_${C}`,D=`${C}_${S}`;D in f&&f[D]?(gut.dot(f[D].normal)<=o&&(p.push(P.x,P.y,P.z),p.push(k.x,k.y,k.z)),f[D]=null):O in f||(f[O]={index0:c[x],index1:c[b],normal:gut.clone()})}}for(let d in f)if(f[d]){let{index0:g,index1:_}=f[d];BV.fromBufferAttribute(s,g),HV.fromBufferAttribute(s,_),p.push(BV.x,BV.y,BV.z),p.push(HV.x,HV.y,HV.z)}this.setAttribute("position",new xe(p,3))}}},ps=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,r){let n=this.getUtoTmapping(t);return this.getPoint(n,r)}getPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return r}getSpacedPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPointAt(n/t));return r}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let r=[],n,i=this.getPoint(0),o=0;r.push(0);for(let a=1;a<=t;a++)n=this.getPoint(a/t),o+=n.distanceTo(i),r.push(o),i=n;return this.cacheArcLengths=r,r}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,r){let n=this.getLengths(),i=0,o=n.length,a;r?a=r:a=t*n[o-1];let s=0,l=o-1,c;for(;s<=l;)if(i=Math.floor(s+(l-s)/2),c=n[i]-a,c<0)s=i+1;else if(c>0)l=i-1;else{l=i;break}if(i=l,n[i]===a)return i/(o-1);let u=n[i],f=n[i+1]-u,p=(a-u)/f;return(i+p)/(o-1)}getTangent(t,r){let i=t-1e-4,o=t+1e-4;i<0&&(i=0),o>1&&(o=1);let a=this.getPoint(i),s=this.getPoint(o),l=r||(a.isVector2?new Lt:new j);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,r){let n=this.getUtoTmapping(t);return this.getTangent(n,r)}computeFrenetFrames(t,r){let n=new j,i=[],o=[],a=[],s=new j,l=new Me;for(let p=0;p<=t;p++){let d=p/t;i[p]=this.getTangentAt(d,new j)}o[0]=new j,a[0]=new j;let c=Number.MAX_VALUE,u=Math.abs(i[0].x),h=Math.abs(i[0].y),f=Math.abs(i[0].z);u<=c&&(c=u,n.set(1,0,0)),h<=c&&(c=h,n.set(0,1,0)),f<=c&&n.set(0,0,1),s.crossVectors(i[0],n).normalize(),o[0].crossVectors(i[0],s),a[0].crossVectors(i[0],o[0]);for(let p=1;p<=t;p++){if(o[p]=o[p-1].clone(),a[p]=a[p-1].clone(),s.crossVectors(i[p-1],i[p]),s.length()>Number.EPSILON){s.normalize();let d=Math.acos(Zo(i[p-1].dot(i[p]),-1,1));o[p].applyMatrix4(l.makeRotationAxis(s,d))}a[p].crossVectors(i[p],o[p])}if(r===!0){let p=Math.acos(Zo(o[0].dot(o[t]),-1,1));p/=t,i[0].dot(s.crossVectors(o[0],o[t]))>0&&(p=-p);for(let d=1;d<=t;d++)o[d].applyMatrix4(l.makeRotationAxis(i[d],p*d)),a[d].crossVectors(i[d],o[d])}return{tangents:i,normals:o,binormals:a}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},U1=class extends ps{constructor(t=0,r=0,n=1,i=1,o=0,a=Math.PI*2,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=r,this.xRadius=n,this.yRadius=i,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,r){let n=r||new Lt,i=Math.PI*2,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=i;for(;o>i;)o-=i;o<Number.EPSILON&&(a?o=0:o=i),this.aClockwise===!0&&!a&&(o===i?o=-i:o=o-i);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,p=c-this.aY;l=f*u-p*h+this.aX,c=f*h+p*u+this.aY}return n.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};U1.prototype.isEllipseCurve=!0;var l6=class extends U1{constructor(t,r,n,i,o,a){super(t,r,n,n,i,o,a),this.type="ArcCurve"}};l6.prototype.isArcCurve=!0;function Dht(){let e=0,t=0,r=0,n=0;function i(o,a,s,l){e=o,t=s,r=-3*o+3*a-2*s-l,n=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){i(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,u,h){let f=(a-o)/c-(s-o)/(c+u)+(s-a)/u,p=(s-a)/u-(l-a)/(u+h)+(l-s)/h;f*=u,p*=u,i(a,s,f,p)},calc:function(o){let a=o*o,s=a*o;return e+t*o+r*a+n*s}}}var UV=new j,_ut=new Dht,yut=new Dht,vut=new Dht,c6=class extends ps{constructor(t=[],r=!1,n="centripetal",i=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=r,this.curveType=n,this.tension=i}getPoint(t,r=new j){let n=r,i=this.points,o=i.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:l===0&&s===o-1&&(s=o-2,l=1);let c,u;this.closed||s>0?c=i[(s-1)%o]:(UV.subVectors(i[0],i[1]).add(i[0]),c=UV);let h=i[s%o],f=i[(s+1)%o];if(this.closed||s+2<o?u=i[(s+2)%o]:(UV.subVectors(i[o-1],i[o-2]).add(i[o-1]),u=UV),this.curveType==="centripetal"||this.curveType==="chordal"){let p=this.curveType==="chordal"?.5:.25,d=Math.pow(c.distanceToSquared(h),p),g=Math.pow(h.distanceToSquared(f),p),_=Math.pow(f.distanceToSquared(u),p);g<1e-4&&(g=1),d<1e-4&&(d=g),_<1e-4&&(_=g),_ut.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,d,g,_),yut.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,d,g,_),vut.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,d,g,_)}else this.curveType==="catmullrom"&&(_ut.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),yut.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),vut.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return n.set(_ut.calc(l),yut.calc(l),vut.calc(l)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new j().fromArray(i))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};c6.prototype.isCatmullRomCurve3=!0;function dhe(e,t,r,n,i){let o=(n-t)*.5,a=(i-r)*.5,s=e*e,l=e*s;return(2*r-2*n+o+a)*l+(-3*r+3*n-2*o-a)*s+o*e+r}function zgr(e,t){let r=1-e;return r*r*t}function Fgr(e,t){return 2*(1-e)*e*t}function Bgr(e,t){return e*e*t}function GP(e,t,r,n){return zgr(e,t)+Fgr(e,r)+Bgr(e,n)}function Hgr(e,t){let r=1-e;return r*r*r*t}function Vgr(e,t){let r=1-e;return 3*r*r*e*t}function Ugr(e,t){return 3*(1-e)*e*e*t}function qgr(e,t){return e*e*e*t}function WP(e,t,r,n,i){return Hgr(e,t)+Vgr(e,r)+Ugr(e,n)+qgr(e,i)}var cM=class extends ps{constructor(t=new Lt,r=new Lt,n=new Lt,i=new Lt){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};cM.prototype.isCubicBezierCurve=!0;var u6=class extends ps{constructor(t=new j,r=new j,n=new j,i=new j){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(WP(t,i.x,o.x,a.x,s.x),WP(t,i.y,o.y,a.y,s.y),WP(t,i.z,o.z,a.z,s.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};u6.prototype.isCubicBezierCurve3=!0;var q1=class extends ps{constructor(t=new Lt,r=new Lt){super(),this.type="LineCurve",this.v1=t,this.v2=r}getPoint(t,r=new Lt){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}getTangent(t,r){let n=r||new Lt;return n.copy(this.v2).sub(this.v1).normalize(),n}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};q1.prototype.isLineCurve=!0;var bU=class extends ps{constructor(t=new j,r=new j){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=r}getPoint(t,r=new j){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},uM=class extends ps{constructor(t=new Lt,r=new Lt,n=new Lt){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};uM.prototype.isQuadraticBezierCurve=!0;var hM=class extends ps{constructor(t=new j,r=new j,n=new j){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(GP(t,i.x,o.x,a.x),GP(t,i.y,o.y,a.y),GP(t,i.z,o.z,a.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};hM.prototype.isQuadraticBezierCurve3=!0;var fM=class extends ps{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,r=new Lt){let n=r,i=this.points,o=(i.length-1)*t,a=Math.floor(o),s=o-a,l=i[a===0?a:a-1],c=i[a],u=i[a>i.length-2?i.length-1:a+1],h=i[a>i.length-3?i.length-1:a+2];return n.set(dhe(s,l.x,c.x,u.x,h.x),dhe(s,l.y,c.y,u.y,h.y)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new Lt().fromArray(i))}return this}};fM.prototype.isSplineCurve=!0;var Oht=Object.freeze({__proto__:null,ArcCurve:l6,CatmullRomCurve3:c6,CubicBezierCurve:cM,CubicBezierCurve3:u6,EllipseCurve:U1,LineCurve:q1,LineCurve3:bU,QuadraticBezierCurve:uM,QuadraticBezierCurve3:hM,SplineCurve:fM}),wU=class extends ps{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),r=this.curves[this.curves.length-1].getPoint(1);t.equals(r)||this.curves.push(new q1(r,t))}getPoint(t,r){let n=t*this.getLength(),i=this.getCurveLengths(),o=0;for(;o<i.length;){if(i[o]>=n){let a=i[o]-n,s=this.curves[o],l=s.getLength(),c=l===0?0:1-a/l;return s.getPointAt(c,r)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],r=0;for(let n=0,i=this.curves.length;n<i;n++)r+=this.curves[n].getLength(),t.push(r);return this.cacheLengths=t,t}getSpacedPoints(t=40){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return this.autoClose&&r.push(r[0]),r}getPoints(t=12){let r=[],n;for(let i=0,o=this.curves;i<o.length;i++){let a=o[i],s=a&&a.isEllipseCurve?t*2:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t,l=a.getPoints(s);for(let c=0;c<l.length;c++){let u=l[c];n&&n.equals(u)||(r.push(u),n=u)}}return this.autoClose&&r.length>1&&!r[r.length-1].equals(r[0])&&r.push(r[0]),r}copy(t){super.copy(t),this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(i.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let r=0,n=this.curves.length;r<n;r++){let i=this.curves[r];t.curves.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(new Oht[i.type]().fromJSON(i))}return this}},G1=class extends wU{constructor(t){super(),this.type="Path",this.currentPoint=new Lt,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let r=1,n=t.length;r<n;r++)this.lineTo(t[r].x,t[r].y);return this}moveTo(t,r){return this.currentPoint.set(t,r),this}lineTo(t,r){let n=new q1(this.currentPoint.clone(),new Lt(t,r));return this.curves.push(n),this.currentPoint.set(t,r),this}quadraticCurveTo(t,r,n,i){let o=new uM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i));return this.curves.push(o),this.currentPoint.set(n,i),this}bezierCurveTo(t,r,n,i,o,a){let s=new cM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i),new Lt(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let r=[this.currentPoint.clone()].concat(t),n=new fM(r);return this.curves.push(n),this.currentPoint.copy(t[t.length-1]),this}arc(t,r,n,i,o,a){let s=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+s,r+l,n,i,o,a),this}absarc(t,r,n,i,o,a){return this.absellipse(t,r,n,n,i,o,a),this}ellipse(t,r,n,i,o,a,s,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,r+u,n,i,o,a,s,l),this}absellipse(t,r,n,i,o,a,s,l){let c=new U1(t,r,n,i,o,a,s,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Kc=class extends G1{constructor(t){super(t),this.uuid=Dl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let r=[];for(let n=0,i=this.holes.length;n<i;n++)r[n]=this.holes[n].getPoints(t);return r}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let r=0,n=this.holes.length;r<n;r++){let i=this.holes[r];t.holes.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(new G1().fromJSON(i))}return this}},Ggr={triangulate:function(e,t,r=2){let n=t&&t.length,i=n?t[0]*r:e.length,o=epe(e,0,i,r,!0),a=[];if(!o||o.next===o.prev)return a;let s,l,c,u,h,f,p;if(n&&(o=$gr(e,t,o,r)),e.length>80*r){s=c=e[0],l=u=e[1];for(let d=r;d<i;d+=r)h=e[d],f=e[d+1],h<s&&(s=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);p=Math.max(c-s,u-l),p=p!==0?1/p:0}return h6(o,a,r,s,l,p),a}};function epe(e,t,r,n,i){let o,a;if(i===a0r(e,t,r,n)>0)for(o=t;o<r;o+=n)a=mhe(o,e[o],e[o+1],a);else for(o=r-n;o>=t;o-=n)a=mhe(o,e[o],e[o+1],a);return a&&ZU(a,a.next)&&(p6(a),a=a.next),a}function W0(e,t){if(!e)return e;t||(t=e);let r=e,n;do if(n=!1,!r.steiner&&(ZU(r,r.next)||ai(r.prev,r,r.next)===0)){if(p6(r),r=t=r.prev,r===r.next)break;n=!0}else r=r.next;while(n||r!==t);return t}function h6(e,t,r,n,i,o,a){if(!e)return;!a&&o&&t0r(e,n,i,o);let s=e,l,c;for(;e.prev!==e.next;){if(l=e.prev,c=e.next,o?Ygr(e,n,i,o):Wgr(e)){t.push(l.i/r),t.push(e.i/r),t.push(c.i/r),p6(e),e=c.next,s=c.next;continue}if(e=c,e===s){a?a===1?(e=jgr(W0(e),t,r),h6(e,t,r,n,i,o,2)):a===2&&Xgr(e,t,r,n,i,o):h6(W0(e),t,r,n,i,o,1);break}}}function Wgr(e){let t=e.prev,r=e,n=e.next;if(ai(t,r,n)>=0)return!1;let i=e.next.next;for(;i!==e.prev;){if(H3(t.x,t.y,r.x,r.y,n.x,n.y,i.x,i.y)&&ai(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function Ygr(e,t,r,n){let i=e.prev,o=e,a=e.next;if(ai(i,o,a)>=0)return!1;let s=i.x<o.x?i.x<a.x?i.x:a.x:o.x<a.x?o.x:a.x,l=i.y<o.y?i.y<a.y?i.y:a.y:o.y<a.y?o.y:a.y,c=i.x>o.x?i.x>a.x?i.x:a.x:o.x>a.x?o.x:a.x,u=i.y>o.y?i.y>a.y?i.y:a.y:o.y>a.y?o.y:a.y,h=nht(s,l,t,r,n),f=nht(c,u,t,r,n),p=e.prevZ,d=e.nextZ;for(;p&&p.z>=h&&d&&d.z<=f;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0||(p=p.prevZ,d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0))return!1;d=d.nextZ}for(;p&&p.z>=h;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&ai(p.prev,p,p.next)>=0)return!1;p=p.prevZ}for(;d&&d.z<=f;){if(d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&ai(d.prev,d,d.next)>=0)return!1;d=d.nextZ}return!0}function jgr(e,t,r){let n=e;do{let i=n.prev,o=n.next.next;!ZU(i,o)&&rpe(i,n,n.next,o)&&f6(i,o)&&f6(o,i)&&(t.push(i.i/r),t.push(n.i/r),t.push(o.i/r),p6(n),p6(n.next),n=e=o),n=n.next}while(n!==e);return W0(n)}function Xgr(e,t,r,n,i,o){let a=e;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&n0r(a,s)){let l=npe(a,s);a=W0(a,a.next),l=W0(l,l.next),h6(a,t,r,n,i,o),h6(l,t,r,n,i,o);return}s=s.next}a=a.next}while(a!==e)}function $gr(e,t,r,n){let i=[],o,a,s,l,c;for(o=0,a=t.length;o<a;o++)s=t[o]*n,l=o<a-1?t[o+1]*n:e.length,c=epe(e,s,l,n,!1),c===c.next&&(c.steiner=!0),i.push(r0r(c));for(i.sort(Kgr),o=0;o<i.length;o++)Zgr(i[o],r),r=W0(r,r.next);return r}function Kgr(e,t){return e.x-t.x}function Zgr(e,t){if(t=Jgr(e,t),t){let r=npe(t,e);W0(t,t.next),W0(r,r.next)}}function Jgr(e,t){let r=t,n=e.x,i=e.y,o=-1/0,a;do{if(i<=r.y&&i>=r.next.y&&r.next.y!==r.y){let f=r.x+(i-r.y)*(r.next.x-r.x)/(r.next.y-r.y);if(f<=n&&f>o){if(o=f,f===n){if(i===r.y)return r;if(i===r.next.y)return r.next}a=r.x<r.next.x?r:r.next}}r=r.next}while(r!==t);if(!a)return null;if(n===o)return a;let s=a,l=a.x,c=a.y,u=1/0,h;r=a;do n>=r.x&&r.x>=l&&n!==r.x&&H3(i<c?n:o,i,l,c,i<c?o:n,i,r.x,r.y)&&(h=Math.abs(i-r.y)/(n-r.x),f6(r,e)&&(h<u||h===u&&(r.x>a.x||r.x===a.x&&Qgr(a,r)))&&(a=r,u=h)),r=r.next;while(r!==s);return a}function Qgr(e,t){return ai(e.prev,e,t.prev)<0&&ai(t.next,e,e.next)<0}function t0r(e,t,r,n){let i=e;do i.z===null&&(i.z=nht(i.x,i.y,t,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next;while(i!==e);i.prevZ.nextZ=null,i.prevZ=null,e0r(i)}function e0r(e){let t,r,n,i,o,a,s,l,c=1;do{for(r=e,e=null,o=null,a=0;r;){for(a++,n=r,s=0,t=0;t<c&&(s++,n=n.nextZ,!!n);t++);for(l=c;s>0||l>0&&n;)s!==0&&(l===0||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),o?o.nextZ=i:e=i,i.prevZ=o,o=i;r=n}o.nextZ=null,c*=2}while(a>1);return e}function nht(e,t,r,n,i){return e=32767*(e-r)*i,t=32767*(t-n)*i,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,e|t<<1}function r0r(e){let t=e,r=e;do(t.x<r.x||t.x===r.x&&t.y<r.y)&&(r=t),t=t.next;while(t!==e);return r}function H3(e,t,r,n,i,o,a,s){return(i-a)*(t-s)-(e-a)*(o-s)>=0&&(e-a)*(n-s)-(r-a)*(t-s)>=0&&(r-a)*(o-s)-(i-a)*(n-s)>=0}function n0r(e,t){return e.next.i!==t.i&&e.prev.i!==t.i&&!i0r(e,t)&&(f6(e,t)&&f6(t,e)&&o0r(e,t)&&(ai(e.prev,e,t.prev)||ai(e,t.prev,t))||ZU(e,t)&&ai(e.prev,e,e.next)>0&&ai(t.prev,t,t.next)>0)}function ai(e,t,r){return(t.y-e.y)*(r.x-t.x)-(t.x-e.x)*(r.y-t.y)}function ZU(e,t){return e.x===t.x&&e.y===t.y}function rpe(e,t,r,n){let i=GV(ai(e,t,r)),o=GV(ai(e,t,n)),a=GV(ai(r,n,e)),s=GV(ai(r,n,t));return!!(i!==o&&a!==s||i===0&&qV(e,r,t)||o===0&&qV(e,n,t)||a===0&&qV(r,e,n)||s===0&&qV(r,t,n))}function qV(e,t,r){return t.x<=Math.max(e.x,r.x)&&t.x>=Math.min(e.x,r.x)&&t.y<=Math.max(e.y,r.y)&&t.y>=Math.min(e.y,r.y)}function GV(e){return e>0?1:e<0?-1:0}function i0r(e,t){let r=e;do{if(r.i!==e.i&&r.next.i!==e.i&&r.i!==t.i&&r.next.i!==t.i&&rpe(r,r.next,e,t))return!0;r=r.next}while(r!==e);return!1}function f6(e,t){return ai(e.prev,e,e.next)<0?ai(e,t,e.next)>=0&&ai(e,e.prev,t)>=0:ai(e,t,e.prev)<0||ai(e,e.next,t)<0}function o0r(e,t){let r=e,n=!1,i=(e.x+t.x)/2,o=(e.y+t.y)/2;do r.y>o!=r.next.y>o&&r.next.y!==r.y&&i<(r.next.x-r.x)*(o-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next;while(r!==e);return n}function npe(e,t){let r=new iht(e.i,e.x,e.y),n=new iht(t.i,t.x,t.y),i=e.next,o=t.prev;return e.next=t,t.prev=e,r.next=i,i.prev=r,n.next=r,r.prev=n,o.next=n,n.prev=o,n}function mhe(e,t,r,n){let i=new iht(e,t,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function p6(e){e.next.prev=e.prev,e.prev.next=e.next,e.prevZ&&(e.prevZ.nextZ=e.nextZ),e.nextZ&&(e.nextZ.prevZ=e.prevZ)}function iht(e,t,r){this.i=e,this.x=t,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function a0r(e,t,r,n){let i=0;for(let o=t,a=r-n;o<r;o+=n)i+=(e[a]-e[o])*(e[o+1]+e[a+1]),a=o;return i}var Zc=class{static area(t){let r=t.length,n=0;for(let i=r-1,o=0;o<r;i=o++)n+=t[i].x*t[o].y-t[o].x*t[i].y;return n*.5}static isClockWise(t){return Zc.area(t)<0}static triangulateShape(t,r){let n=[],i=[],o=[];ghe(t),_he(n,t);let a=t.length;r.forEach(ghe);for(let l=0;l<r.length;l++)i.push(a),a+=r[l].length,_he(n,r[l]);let s=Ggr.triangulate(n,i);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function ghe(e){let t=e.length;t>2&&e[t-1].equals(e[0])&&e.pop()}function _he(e,t){for(let r=0;r<t.length;r++)e.push(t[r].x),e.push(t[r].y)}var hh=class extends Pe{constructor(t=new Kc([new Lt(.5,.5),new Lt(-.5,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:r},t=Array.isArray(t)?t:[t];let n=this,i=[],o=[];for(let s=0,l=t.length;s<l;s++){let c=t[s];a(c)}this.setAttribute("position",new xe(i,3)),this.setAttribute("uv",new xe(o,2)),this.computeVertexNormals();function a(s){let l=[],c=r.curveSegments!==void 0?r.curveSegments:12,u=r.steps!==void 0?r.steps:1,h=r.depth!==void 0?r.depth:1,f=r.bevelEnabled!==void 0?r.bevelEnabled:!0,p=r.bevelThickness!==void 0?r.bevelThickness:.2,d=r.bevelSize!==void 0?r.bevelSize:p-.1,g=r.bevelOffset!==void 0?r.bevelOffset:0,_=r.bevelSegments!==void 0?r.bevelSegments:3,y=r.extrudePath,x=r.UVGenerator!==void 0?r.UVGenerator:s0r;r.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=r.amount);let b,S=!1,C,P,k,O;y&&(b=y.getSpacedPoints(u),S=!0,f=!1,C=y.computeFrenetFrames(u,!1),P=new j,k=new j,O=new j),f||(_=0,p=0,d=0,g=0);let D=s.extractPoints(c),B=D.shape,I=D.holes;if(!Zc.isClockWise(B)){B=B.reverse();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];Zc.isClockWise(ht)&&(I[q]=ht.reverse())}}let R=Zc.triangulateShape(B,I),F=B;for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];B=B.concat(ht)}function z(q,pt,ht){return pt||console.error("THREE.ExtrudeGeometry: vec does not exist"),pt.clone().multiplyScalar(ht).add(q)}let U=B.length,W=R.length;function Z(q,pt,ht){let wt,kt,ie,ee=q.x-pt.x,Le=q.y-pt.y,ar=ht.x-q.x,fr=ht.y-q.y,tt=ee*ee+Le*Le,$=ee*fr-Le*ar;if(Math.abs($)>Number.EPSILON){let It=Math.sqrt(tt),$t=Math.sqrt(ar*ar+fr*fr),he=pt.x-Le/It,Tt=pt.y+ee/It,be=ht.x-fr/$t,nt=ht.y+ar/$t,Ct=((be-he)*fr-(nt-Tt)*ar)/(ee*fr-Le*ar);wt=he+ee*Ct-q.x,kt=Tt+Le*Ct-q.y;let Wt=wt*wt+kt*kt;if(Wt<=2)return new Lt(wt,kt);ie=Math.sqrt(Wt/2)}else{let It=!1;ee>Number.EPSILON?ar>Number.EPSILON&&(It=!0):ee<-Number.EPSILON?ar<-Number.EPSILON&&(It=!0):Math.sign(Le)===Math.sign(fr)&&(It=!0),It?(wt=-Le,kt=ee,ie=Math.sqrt(tt)):(wt=ee,kt=Le,ie=Math.sqrt(tt/2))}return new Lt(wt/ie,kt/ie)}let rt=[];for(let q=0,pt=F.length,ht=pt-1,wt=q+1;q<pt;q++,ht++,wt++)ht===pt&&(ht=0),wt===pt&&(wt=0),rt[q]=Z(F[q],F[ht],F[wt]);let ot=[],st,St=rt.concat();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];st=[];for(let wt=0,kt=ht.length,ie=kt-1,ee=wt+1;wt<kt;wt++,ie++,ee++)ie===kt&&(ie=0),ee===kt&&(ee=0),st[wt]=Z(ht[wt],ht[ie],ht[ee]);ot.push(st),St=St.concat(st)}for(let q=0;q<_;q++){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,-ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);_t(fr.x,fr.y,-ht)}}}let bt=d+g;for(let q=0;q<U;q++){let pt=f?z(B[q],St[q],bt):B[q];S?(k.copy(C.normals[0]).multiplyScalar(pt.x),P.copy(C.binormals[0]).multiplyScalar(pt.y),O.copy(b[0]).add(k).add(P),_t(O.x,O.y,O.z)):_t(pt.x,pt.y,0)}for(let q=1;q<=u;q++)for(let pt=0;pt<U;pt++){let ht=f?z(B[pt],St[pt],bt):B[pt];S?(k.copy(C.normals[q]).multiplyScalar(ht.x),P.copy(C.binormals[q]).multiplyScalar(ht.y),O.copy(b[q]).add(k).add(P),_t(O.x,O.y,O.z)):_t(ht.x,ht.y,h/u*q)}for(let q=_-1;q>=0;q--){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,h+ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);S?_t(fr.x,fr.y+b[u-1].y,b[u-1].x+ht):_t(fr.x,fr.y,h+ht)}}}Mt(),lt();function Mt(){let q=i.length/3;if(f){let pt=0,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[2]+ht,kt[1]+ht,kt[0]+ht)}pt=u+_*2,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[0]+ht,kt[1]+ht,kt[2]+ht)}}else{for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[2],ht[1],ht[0])}for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[0]+U*u,ht[1]+U*u,ht[2]+U*u)}}n.addGroup(q,i.length/3-q,0)}function lt(){let q=i.length/3,pt=0;Kt(F,pt),pt+=F.length;for(let ht=0,wt=I.length;ht<wt;ht++){let kt=I[ht];Kt(kt,pt),pt+=kt.length}n.addGroup(q,i.length/3-q,1)}function Kt(q,pt){let ht=q.length;for(;--ht>=0;){let wt=ht,kt=ht-1;kt<0&&(kt=q.length-1);for(let ie=0,ee=u+_*2;ie<ee;ie++){let Le=U*ie,ar=U*(ie+1),fr=pt+wt+Le,tt=pt+kt+Le,$=pt+kt+ar,It=pt+wt+ar;X(fr,tt,$,It)}}}function _t(q,pt,ht){l.push(q),l.push(pt),l.push(ht)}function ct(q,pt,ht){et(q),et(pt),et(ht);let wt=i.length/3,kt=x.generateTopUV(n,i,wt-3,wt-2,wt-1);dt(kt[0]),dt(kt[1]),dt(kt[2])}function X(q,pt,ht,wt){et(q),et(pt),et(wt),et(pt),et(ht),et(wt);let kt=i.length/3,ie=x.generateSideWallUV(n,i,kt-6,kt-3,kt-2,kt-1);dt(ie[0]),dt(ie[1]),dt(ie[3]),dt(ie[1]),dt(ie[2]),dt(ie[3])}function et(q){i.push(l[q*3+0]),i.push(l[q*3+1]),i.push(l[q*3+2])}function dt(q){o.push(q.x),o.push(q.y)}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes,n=this.parameters.options;return l0r(r,n,t)}static fromJSON(t,r){let n=[];for(let o=0,a=t.shapes.length;o<a;o++){let s=r[t.shapes[o]];n.push(s)}let i=t.options.extrudePath;return i!==void 0&&(t.options.extrudePath=new Oht[i.type]().fromJSON(i)),new hh(n,t.options)}},s0r={generateTopUV:function(e,t,r,n,i){let o=t[r*3],a=t[r*3+1],s=t[n*3],l=t[n*3+1],c=t[i*3],u=t[i*3+1];return[new Lt(o,a),new Lt(s,l),new Lt(c,u)]},generateSideWallUV:function(e,t,r,n,i,o){let a=t[r*3],s=t[r*3+1],l=t[r*3+2],c=t[n*3],u=t[n*3+1],h=t[n*3+2],f=t[i*3],p=t[i*3+1],d=t[i*3+2],g=t[o*3],_=t[o*3+1],y=t[o*3+2];return Math.abs(s-u)<Math.abs(a-c)?[new Lt(a,1-l),new Lt(c,1-h),new Lt(f,1-d),new Lt(g,1-y)]:[new Lt(s,1-l),new Lt(u,1-h),new Lt(p,1-d),new Lt(_,1-y)]}};function l0r(e,t,r){if(r.shapes=[],Array.isArray(e))for(let n=0,i=e.length;n<i;n++){let o=e[n];r.shapes.push(o.uuid)}else r.shapes.push(e.uuid);return t.extrudePath!==void 0&&(r.options.extrudePath=t.extrudePath.toJSON()),r}var W1=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=[-1,n,0,1,n,0,-1,-n,0,1,-n,0,0,-1,n,0,1,n,0,-1,-n,0,1,-n,n,0,-1,n,0,1,-n,0,-1,-n,0,1],o=[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1];super(i,o,t,r),this.type="IcosahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new W1(t.radius,t.detail)}},Y1=class extends Pe{constructor(t=[new Lt(0,.5),new Lt(.5,0),new Lt(0,-.5)],r=12,n=0,i=Math.PI*2){super(),this.type="LatheGeometry",this.parameters={points:t,segments:r,phiStart:n,phiLength:i},r=Math.floor(r),i=Zo(i,0,Math.PI*2);let o=[],a=[],s=[],l=[],c=[],u=1/r,h=new j,f=new Lt,p=new j,d=new j,g=new j,_=0,y=0;for(let x=0;x<=t.length-1;x++)switch(x){case 0:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,g.copy(p),p.normalize(),l.push(p.x,p.y,p.z);break;case t.length-1:l.push(g.x,g.y,g.z);break;default:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,d.copy(p),p.x+=g.x,p.y+=g.y,p.z+=g.z,p.normalize(),l.push(p.x,p.y,p.z),g.copy(d)}for(let x=0;x<=r;x++){let b=n+x*u*i,S=Math.sin(b),C=Math.cos(b);for(let P=0;P<=t.length-1;P++){h.x=t[P].x*S,h.y=t[P].y,h.z=t[P].x*C,a.push(h.x,h.y,h.z),f.x=x/r,f.y=P/(t.length-1),s.push(f.x,f.y);let k=l[3*P+0]*S,O=l[3*P+1],D=l[3*P+0]*C;c.push(k,O,D)}}for(let x=0;x<r;x++)for(let b=0;b<t.length-1;b++){let S=b+x*t.length,C=S,P=S+t.length,k=S+t.length+1,O=S+1;o.push(C,P,O),o.push(k,O,P)}this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("uv",new xe(s,2)),this.setAttribute("normal",new xe(c,3))}static fromJSON(t){return new Y1(t.points,t.segments,t.phiStart,t.phiLength)}},Y0=class extends uh{constructor(t=1,r=0){let n=[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],i=[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2];super(n,i,t,r),this.type="OctahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new Y0(t.radius,t.detail)}},j1=class extends Pe{constructor(t=.5,r=1,n=8,i=1,o=0,a=Math.PI*2){super(),this.type="RingGeometry",this.parameters={innerRadius:t,outerRadius:r,thetaSegments:n,phiSegments:i,thetaStart:o,thetaLength:a},n=Math.max(3,n),i=Math.max(1,i);let s=[],l=[],c=[],u=[],h=t,f=(r-t)/i,p=new j,d=new Lt;for(let g=0;g<=i;g++){for(let _=0;_<=n;_++){let y=o+_/n*a;p.x=h*Math.cos(y),p.y=h*Math.sin(y),l.push(p.x,p.y,p.z),c.push(0,0,1),d.x=(p.x/r+1)/2,d.y=(p.y/r+1)/2,u.push(d.x,d.y)}h+=f}for(let g=0;g<i;g++){let _=g*(n+1);for(let y=0;y<n;y++){let x=y+_,b=x,S=x+n+1,C=x+n+2,P=x+1;s.push(b,S,P),s.push(S,C,P)}}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2))}static fromJSON(t){return new j1(t.innerRadius,t.outerRadius,t.thetaSegments,t.phiSegments,t.thetaStart,t.thetaLength)}},j0=class extends Pe{constructor(t=new Kc([new Lt(0,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:r};let n=[],i=[],o=[],a=[],s=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(s,l,u),s+=l,l=0;this.setIndex(n),this.setAttribute("position",new xe(i,3)),this.setAttribute("normal",new xe(o,3)),this.setAttribute("uv",new xe(a,2));function c(u){let h=i.length/3,f=u.extractPoints(r),p=f.shape,d=f.holes;Zc.isClockWise(p)===!1&&(p=p.reverse());for(let _=0,y=d.length;_<y;_++){let x=d[_];Zc.isClockWise(x)===!0&&(d[_]=x.reverse())}let g=Zc.triangulateShape(p,d);for(let _=0,y=d.length;_<y;_++){let x=d[_];p=p.concat(x)}for(let _=0,y=p.length;_<y;_++){let x=p[_];i.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let _=0,y=g.length;_<y;_++){let x=g[_],b=x[0]+h,S=x[1]+h,C=x[2]+h;n.push(b,S,C),l+=3}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes;return c0r(r,t)}static fromJSON(t,r){let n=[];for(let i=0,o=t.shapes.length;i<o;i++){let a=r[t.shapes[i]];n.push(a)}return new j0(n,t.curveSegments)}};function c0r(e,t){if(t.shapes=[],Array.isArray(e))for(let r=0,n=e.length;r<n;r++){let i=e[r];t.shapes.push(i.uuid)}else t.shapes.push(e.uuid);return t}var X0=class extends Pe{constructor(t=1,r=32,n=16,i=0,o=Math.PI*2,a=0,s=Math.PI){super(),this.type="SphereGeometry",this.parameters={radius:t,widthSegments:r,heightSegments:n,phiStart:i,phiLength:o,thetaStart:a,thetaLength:s},r=Math.max(3,Math.floor(r)),n=Math.max(2,Math.floor(n));let l=Math.min(a+s,Math.PI),c=0,u=[],h=new j,f=new j,p=[],d=[],g=[],_=[];for(let y=0;y<=n;y++){let x=[],b=y/n,S=0;y==0&&a==0?S=.5/r:y==n&&l==Math.PI&&(S=-.5/r);for(let C=0;C<=r;C++){let P=C/r;h.x=-t*Math.cos(i+P*o)*Math.sin(a+b*s),h.y=t*Math.cos(a+b*s),h.z=t*Math.sin(i+P*o)*Math.sin(a+b*s),d.push(h.x,h.y,h.z),f.copy(h).normalize(),g.push(f.x,f.y,f.z),_.push(P+S,1-b),x.push(c++)}u.push(x)}for(let y=0;y<n;y++)for(let x=0;x<r;x++){let b=u[y][x+1],S=u[y][x],C=u[y+1][x],P=u[y+1][x+1];(y!==0||a>0)&&p.push(b,S,P),(y!==n-1||l<Math.PI)&&p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new X0(t.radius,t.widthSegments,t.heightSegments,t.phiStart,t.phiLength,t.thetaStart,t.thetaLength)}},X1=class extends uh{constructor(t=1,r=0){let n=[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],i=[2,1,0,0,3,2,1,3,0,2,3,1];super(n,i,t,r),this.type="TetrahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new X1(t.radius,t.detail)}},$1=class extends Pe{constructor(t=1,r=.4,n=8,i=6,o=Math.PI*2){super(),this.type="TorusGeometry",this.parameters={radius:t,tube:r,radialSegments:n,tubularSegments:i,arc:o},n=Math.floor(n),i=Math.floor(i);let a=[],s=[],l=[],c=[],u=new j,h=new j,f=new j;for(let p=0;p<=n;p++)for(let d=0;d<=i;d++){let g=d/i*o,_=p/n*Math.PI*2;h.x=(t+r*Math.cos(_))*Math.cos(g),h.y=(t+r*Math.cos(_))*Math.sin(g),h.z=r*Math.sin(_),s.push(h.x,h.y,h.z),u.x=t*Math.cos(g),u.y=t*Math.sin(g),f.subVectors(h,u).normalize(),l.push(f.x,f.y,f.z),c.push(d/i),c.push(p/n)}for(let p=1;p<=n;p++)for(let d=1;d<=i;d++){let g=(i+1)*p+d-1,_=(i+1)*(p-1)+d-1,y=(i+1)*(p-1)+d,x=(i+1)*p+d;a.push(g,_,x),a.push(_,y,x)}this.setIndex(a),this.setAttribute("position",new xe(s,3)),this.setAttribute("normal",new xe(l,3)),this.setAttribute("uv",new xe(c,2))}static fromJSON(t){return new $1(t.radius,t.tube,t.radialSegments,t.tubularSegments,t.arc)}},K1=class extends Pe{constructor(t=1,r=.4,n=64,i=8,o=2,a=3){super(),this.type="TorusKnotGeometry",this.parameters={radius:t,tube:r,tubularSegments:n,radialSegments:i,p:o,q:a},n=Math.floor(n),i=Math.floor(i);let s=[],l=[],c=[],u=[],h=new j,f=new j,p=new j,d=new j,g=new j,_=new j,y=new j;for(let b=0;b<=n;++b){let S=b/n*o*Math.PI*2;x(S,o,a,t,p),x(S+.01,o,a,t,d),_.subVectors(d,p),y.addVectors(d,p),g.crossVectors(_,y),y.crossVectors(g,_),g.normalize(),y.normalize();for(let C=0;C<=i;++C){let P=C/i*Math.PI*2,k=-r*Math.cos(P),O=r*Math.sin(P);h.x=p.x+(k*y.x+O*g.x),h.y=p.y+(k*y.y+O*g.y),h.z=p.z+(k*y.z+O*g.z),l.push(h.x,h.y,h.z),f.subVectors(h,p).normalize(),c.push(f.x,f.y,f.z),u.push(b/n),u.push(C/i)}}for(let b=1;b<=n;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;s.push(C,P,O),s.push(P,k,O)}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2));function x(b,S,C,P,k){let O=Math.cos(b),D=Math.sin(b),B=C/S*b,I=Math.cos(B);k.x=P*(2+I)*.5*O,k.y=P*(2+I)*D*.5,k.z=P*Math.sin(B)*.5}}static fromJSON(t){return new K1(t.radius,t.tube,t.tubularSegments,t.radialSegments,t.p,t.q)}},Z1=class extends Pe{constructor(t=new hM(new j(-1,-1,0),new j(-1,1,0),new j(1,1,0)),r=64,n=1,i=8,o=!1){super(),this.type="TubeGeometry",this.parameters={path:t,tubularSegments:r,radius:n,radialSegments:i,closed:o};let a=t.computeFrenetFrames(r,o);this.tangents=a.tangents,this.normals=a.normals,this.binormals=a.binormals;let s=new j,l=new j,c=new Lt,u=new j,h=[],f=[],p=[],d=[];g(),this.setIndex(d),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function g(){for(let b=0;b<r;b++)_(b);_(o===!1?r:0),x(),y()}function _(b){u=t.getPointAt(b/r,u);let S=a.normals[b],C=a.binormals[b];for(let P=0;P<=i;P++){let k=P/i*Math.PI*2,O=Math.sin(k),D=-Math.cos(k);l.x=D*S.x+O*C.x,l.y=D*S.y+O*C.y,l.z=D*S.z+O*C.z,l.normalize(),f.push(l.x,l.y,l.z),s.x=u.x+n*l.x,s.y=u.y+n*l.y,s.z=u.z+n*l.z,h.push(s.x,s.y,s.z)}}function y(){for(let b=1;b<=r;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;d.push(C,P,O),d.push(P,k,O)}}function x(){for(let b=0;b<=r;b++)for(let S=0;S<=i;S++)c.x=b/r,c.y=S/i,p.push(c.x,c.y)}}toJSON(){let t=super.toJSON();return t.path=this.parameters.path.toJSON(),t}static fromJSON(t){return new Z1(new Oht[t.path.type]().fromJSON(t.path),t.tubularSegments,t.radius,t.radialSegments,t.closed)}},d6=class extends Pe{constructor(t=null){if(super(),this.type="WireframeGeometry",this.parameters={geometry:t},t!==null){let r=[],n=new Set,i=new j,o=new j;if(t.index!==null){let a=t.attributes.position,s=t.index,l=t.groups;l.length===0&&(l=[{start:0,count:s.count,materialIndex:0}]);for(let c=0,u=l.length;c<u;++c){let h=l[c],f=h.start,p=h.count;for(let d=f,g=f+p;d<g;d+=3)for(let _=0;_<3;_++){let y=s.getX(d+_),x=s.getX(d+(_+1)%3);i.fromBufferAttribute(a,y),o.fromBufferAttribute(a,x),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}}else{let a=t.attributes.position;for(let s=0,l=a.count/3;s<l;s++)for(let c=0;c<3;c++){let u=3*s+c,h=3*s+(c+1)%3;i.fromBufferAttribute(a,u),o.fromBufferAttribute(a,h),yhe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}this.setAttribute("position",new xe(r,3))}}};function yhe(e,t,r){let n=`${e.x},${e.y},${e.z}-${t.x},${t.y},${t.z}`,i=`${t.x},${t.y},${t.z}-${e.x},${e.y},${e.z}`;return r.has(n)===!0||r.has(i)===!0?!1:(r.add(n,i),!0)}var vhe=Object.freeze({__proto__:null,BoxGeometry:tp,BoxBufferGeometry:tp,CircleGeometry:B1,CircleBufferGeometry:B1,ConeGeometry:H1,ConeBufferGeometry:H1,CylinderGeometry:am,CylinderBufferGeometry:am,DodecahedronGeometry:V1,DodecahedronBufferGeometry:V1,EdgesGeometry:s6,ExtrudeGeometry:hh,ExtrudeBufferGeometry:hh,IcosahedronGeometry:W1,IcosahedronBufferGeometry:W1,LatheGeometry:Y1,LatheBufferGeometry:Y1,OctahedronGeometry:Y0,OctahedronBufferGeometry:Y0,PlaneGeometry:U0,PlaneBufferGeometry:U0,PolyhedronGeometry:uh,PolyhedronBufferGeometry:uh,RingGeometry:j1,RingBufferGeometry:j1,ShapeGeometry:j0,ShapeBufferGeometry:j0,SphereGeometry:X0,SphereBufferGeometry:X0,TetrahedronGeometry:X1,TetrahedronBufferGeometry:X1,TorusGeometry:$1,TorusBufferGeometry:$1,TorusKnotGeometry:K1,TorusKnotBufferGeometry:K1,TubeGeometry:Z1,TubeBufferGeometry:Z1,WireframeGeometry:d6}),m6=class extends qi{constructor(t){super(),this.type="ShadowMaterial",this.color=new ne(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};m6.prototype.isShadowMaterial=!0;var pM=class extends qi{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ne(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=sx,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};pM.prototype.isMeshStandardMaterial=!0;var g6=class extends pM{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new Lt(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Zo(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(r){this.ior=(1+.4*r)/(1-.4*r)}}),this.sheenColor=new ne(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ne(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ne(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};g6.prototype.isMeshPhysicalMaterial=!0;var _6=class extends qi{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ne(16777215),this.specular=new ne(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=sx,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};_6.prototype.isMeshPhongMaterial=!0;var y6=class extends qi{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ne(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=sx,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};y6.prototype.isMeshToonMaterial=!0;var v6=class extends qi{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=sx,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};v6.prototype.isMeshNormalMaterial=!0;var x6=class extends qi{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=O6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};x6.prototype.isMeshLambertMaterial=!0;var b6=class extends qi{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ne(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=sx,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};b6.prototype.isMeshMatcapMaterial=!0;var w6=class extends Gi{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};w6.prototype.isLineDashedMaterial=!0;var u0r=Object.freeze({__proto__:null,ShadowMaterial:m6,SpriteMaterial:iM,RawShaderMaterial:q0,ShaderMaterial:lh,PointsMaterial:im,MeshPhysicalMaterial:g6,MeshStandardMaterial:pM,MeshPhongMaterial:_6,MeshToonMaterial:y6,MeshNormalMaterial:v6,MeshLambertMaterial:x6,MeshDepthMaterial:eM,MeshDistanceMaterial:rM,MeshBasicMaterial:sh,MeshMatcapMaterial:b6,LineDashedMaterial:w6,LineBasicMaterial:Gi,Material:qi}),jn={arraySlice:function(e,t,r){return jn.isTypedArray(e)?new e.constructor(e.subarray(t,r!==void 0?r:e.length)):e.slice(t,r)},convertArray:function(e,t,r){return!e||!r&&e.constructor===t?e:typeof t.BYTES_PER_ELEMENT=="number"?new t(e):Array.prototype.slice.call(e)},isTypedArray:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)},getKeyframeOrder:function(e){function t(i,o){return e[i]-e[o]}let r=e.length,n=new Array(r);for(let i=0;i!==r;++i)n[i]=i;return n.sort(t),n},sortedArray:function(e,t,r){let n=e.length,i=new e.constructor(n);for(let o=0,a=0;a!==n;++o){let s=r[o]*t;for(let l=0;l!==t;++l)i[a++]=e[s+l]}return i},flattenJSON:function(e,t,r,n){let i=1,o=e[0];for(;o!==void 0&&o[n]===void 0;)o=e[i++];if(o===void 0)return;let a=o[n];if(a!==void 0)if(Array.isArray(a))do a=o[n],a!==void 0&&(t.push(o.time),r.push.apply(r,a)),o=e[i++];while(o!==void 0);else if(a.toArray!==void 0)do a=o[n],a!==void 0&&(t.push(o.time),a.toArray(r,r.length)),o=e[i++];while(o!==void 0);else do a=o[n],a!==void 0&&(t.push(o.time),r.push(a)),o=e[i++];while(o!==void 0)},subclip:function(e,t,r,n,i=30){let o=e.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],u=c.getValueSize(),h=[],f=[];for(let p=0;p<c.times.length;++p){let d=c.times[p]*i;if(!(d<r||d>=n)){h.push(c.times[p]);for(let g=0;g<u;++g)f.push(c.values[p*u+g])}}h.length!==0&&(c.times=jn.convertArray(h,c.times.constructor),c.values=jn.convertArray(f,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(e,t=0,r=e,n=30){n<=0&&(n=30);let i=r.tracks.length,o=t/n;for(let a=0;a<i;++a){let s=r.tracks[a],l=s.ValueTypeName;if(l==="bool"||l==="string")continue;let c=e.tracks.find(function(y){return y.name===s.name&&y.ValueTypeName===l});if(c===void 0)continue;let u=0,h=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,p=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=p/3);let d=s.times.length-1,g;if(o<=s.times[0]){let y=u,x=h-u;g=jn.arraySlice(s.values,y,x)}else if(o>=s.times[d]){let y=d*h+u,x=y+h-u;g=jn.arraySlice(s.values,y,x)}else{let y=s.createInterpolant(),x=u,b=h-u;y.evaluate(o),g=jn.arraySlice(y.resultBuffer,x,b)}l==="quaternion"&&new yi().fromArray(g).normalize().conjugate().toArray(g);let _=c.times.length;for(let y=0;y<_;++y){let x=y*p+f;if(l==="quaternion")yi.multiplyQuaternionsFlat(c.values,x,g,0,c.values,x);else{let b=p-f*2;for(let S=0;S<b;++S)c.values[x+S]-=g[S]}}}return e.blendMode=kht,e}},fh=class{constructor(t,r,n,i){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=i!==void 0?i:new r.constructor(n),this.sampleValues=r,this.valueSize=n,this.settings=null,this.DefaultSettings_={}}evaluate(t){let r=this.parameterPositions,n=this._cachedIndex,i=r[n],o=r[n-1];t:{e:{let a;r:{n:if(!(t<i)){for(let s=n+2;;){if(i===void 0){if(t<o)break n;return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,t,o)}if(n===s)break;if(o=i,i=r[++n],t<i)break e}a=r.length;break r}if(!(t>=o)){let s=r[1];t<s&&(n=2,o=s);for(let l=n-2;;){if(o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(n===l)break;if(i=o,o=r[--n-1],t>=o)break e}a=n,n=0;break r}break t}for(;n<a;){let s=n+a>>>1;t<r[s]?a=s:n=s+1}if(i=r[n],o=r[n-1],o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(i===void 0)return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,o,t)}this._cachedIndex=n,this.intervalChanged_(n,o,i)}return this.interpolate_(n,o,t,i)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let r=this.resultBuffer,n=this.sampleValues,i=this.valueSize,o=t*i;for(let a=0;a!==i;++a)r[a]=n[o+a];return r}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};fh.prototype.beforeStart_=fh.prototype.copySampleValue_;fh.prototype.afterEnd_=fh.prototype.copySampleValue_;var SU=class extends fh{constructor(t,r,n,i){super(t,r,n,i),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:T1,endingEnd:T1}}intervalChanged_(t,r,n){let i=this.parameterPositions,o=t-2,a=t+1,s=i[o],l=i[a];if(s===void 0)switch(this.getSettings_().endingStart){case C1:o=t,s=2*r-n;break;case JP:o=i.length-2,s=r+i[o]-i[o+1];break;default:o=t,s=n}if(l===void 0)switch(this.getSettings_().endingEnd){case C1:a=t,l=2*n-r;break;case JP:a=1,l=n+i[1]-i[0];break;default:a=t-1,l=r}let c=(n-r)*.5,u=this.valueSize;this._weightPrev=c/(r-s),this._weightNext=c/(l-n),this._offsetPrev=o*u,this._offsetNext=a*u}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,p=this._weightNext,d=(n-r)/(i-r),g=d*d,_=g*d,y=-f*_+2*f*g-f*d,x=(1+f)*_+(-1.5-2*f)*g+(-.5+f)*d+1,b=(-1-p)*_+(1.5+p)*g+.5*d,S=p*_-p*g;for(let C=0;C!==s;++C)o[C]=y*a[u+C]+x*a[c+C]+b*a[l+C]+S*a[h+C];return o}},S6=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=(n-r)/(i-r),h=1-u;for(let f=0;f!==s;++f)o[f]=a[c+f]*h+a[l+f]*u;return o}},MU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t){return this.copySampleValue_(t-1)}},Ol=class{constructor(t,r,n,i){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(r===void 0||r.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=jn.convertArray(r,this.TimeBufferType),this.values=jn.convertArray(n,this.ValueBufferType),this.setInterpolation(i||this.DefaultInterpolation)}static toJSON(t){let r=t.constructor,n;if(r.toJSON!==this.toJSON)n=r.toJSON(t);else{n={name:t.name,times:jn.convertArray(t.times,Array),values:jn.convertArray(t.values,Array)};let i=t.getInterpolation();i!==t.DefaultInterpolation&&(n.interpolation=i)}return n.type=t.ValueTypeName,n}InterpolantFactoryMethodDiscrete(t){return new MU(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new S6(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new SU(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let r;switch(t){case KP:r=this.InterpolantFactoryMethodDiscrete;break;case ZP:r=this.InterpolantFactoryMethodLinear;break;case rU:r=this.InterpolantFactoryMethodSmooth;break}if(r===void 0){let n="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(n);return console.warn("THREE.KeyframeTrack:",n),this}return this.createInterpolant=r,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return KP;case this.InterpolantFactoryMethodLinear:return ZP;case this.InterpolantFactoryMethodSmooth:return rU}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]+=t}return this}scale(t){if(t!==1){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]*=t}return this}trim(t,r){let n=this.times,i=n.length,o=0,a=i-1;for(;o!==i&&n[o]<t;)++o;for(;a!==-1&&n[a]>r;)--a;if(++a,o!==0||a!==i){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=jn.arraySlice(n,o,a),this.values=jn.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,r=this.getValueSize();r-Math.floor(r)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let n=this.times,i=this.values,o=n.length;o===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=n[s];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(a!==null&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(i!==void 0&&jn.isTypedArray(i))for(let s=0,l=i.length;s!==l;++s){let c=i[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=jn.arraySlice(this.times),r=jn.arraySlice(this.values),n=this.getValueSize(),i=this.getInterpolation()===rU,o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s],u=t[s+1];if(c!==u&&(s!==1||c!==t[0]))if(i)l=!0;else{let h=s*n,f=h-n,p=h+n;for(let d=0;d!==n;++d){let g=r[h+d];if(g!==r[f+d]||g!==r[p+d]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let h=s*n,f=a*n;for(let p=0;p!==n;++p)r[f+p]=r[h+p]}++a}}if(o>0){t[a]=t[o];for(let s=o*n,l=a*n,c=0;c!==n;++c)r[l+c]=r[s+c];++a}return a!==t.length?(this.times=jn.arraySlice(t,0,a),this.values=jn.arraySlice(r,0,a*n)):(this.times=t,this.values=r),this}clone(){let t=jn.arraySlice(this.times,0),r=jn.arraySlice(this.values,0),n=this.constructor,i=new n(this.name,t,r);return i.createInterpolant=this.createInterpolant,i}};Ol.prototype.TimeBufferType=Float32Array;Ol.prototype.ValueBufferType=Float32Array;Ol.prototype.DefaultInterpolation=ZP;var sm=class extends Ol{};sm.prototype.ValueTypeName="bool";sm.prototype.ValueBufferType=Array;sm.prototype.DefaultInterpolation=KP;sm.prototype.InterpolantFactoryMethodLinear=void 0;sm.prototype.InterpolantFactoryMethodSmooth=void 0;var M6=class extends Ol{};M6.prototype.ValueTypeName="color";var J1=class extends Ol{};J1.prototype.ValueTypeName="number";var EU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(n-r)/(i-r),c=t*s;for(let u=c+s;c!==u;c+=4)yi.slerpFlat(o,0,a,c-s,a,c,l);return o}},$0=class extends Ol{InterpolantFactoryMethodLinear(t){return new EU(this.times,this.values,this.getValueSize(),t)}};$0.prototype.ValueTypeName="quaternion";$0.prototype.DefaultInterpolation=ZP;$0.prototype.InterpolantFactoryMethodSmooth=void 0;var lm=class extends Ol{};lm.prototype.ValueTypeName="string";lm.prototype.ValueBufferType=Array;lm.prototype.DefaultInterpolation=KP;lm.prototype.InterpolantFactoryMethodLinear=void 0;lm.prototype.InterpolantFactoryMethodSmooth=void 0;var Q1=class extends Ol{};Q1.prototype.ValueTypeName="vector";var tx=class{constructor(t,r=-1,n,i=$U){this.name=t,this.tracks=n,this.duration=r,this.blendMode=i,this.uuid=Dl(),this.duration<0&&this.resetDuration()}static parse(t){let r=[],n=t.tracks,i=1/(t.fps||1);for(let a=0,s=n.length;a!==s;++a)r.push(f0r(n[a]).scale(i));let o=new this(t.name,t.duration,r,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let r=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:r,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=n.length;o!==a;++o)r.push(Ol.toJSON(n[o]));return i}static CreateFromMorphTargetSequence(t,r,n,i){let o=r.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let u=jn.getKeyframeOrder(l);l=jn.sortedArray(l,1,u),c=jn.sortedArray(c,1,u),!i&&l[0]===0&&(l.push(o),c.push(c[0])),a.push(new J1(".morphTargetInfluences["+r[s].name+"]",l,c).scale(1/n))}return new this(t,-1,a)}static findByName(t,r){let n=t;if(!Array.isArray(t)){let i=t;n=i.geometry&&i.geometry.animations||i.animations}for(let i=0;i<n.length;i++)if(n[i].name===r)return n[i];return null}static CreateClipsFromMorphTargetSequences(t,r,n){let i={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],u=c.name.match(o);if(u&&u.length>1){let h=u[1],f=i[h];f||(i[h]=f=[]),f.push(c)}}let a=[];for(let s in i)a.push(this.CreateFromMorphTargetSequence(s,i[s],r,n));return a}static parseAnimation(t,r){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let n=function(h,f,p,d,g){if(p.length!==0){let _=[],y=[];jn.flattenJSON(p,_,y,d),_.length!==0&&g.push(new h(f,_,y))}},i=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let p={},d;for(d=0;d<f.length;d++)if(f[d].morphTargets)for(let g=0;g<f[d].morphTargets.length;g++)p[f[d].morphTargets[g]]=-1;for(let g in p){let _=[],y=[];for(let x=0;x!==f[d].morphTargets.length;++x){let b=f[d];_.push(b.time),y.push(b.morphTarget===g?1:0)}i.push(new J1(".morphTargetInfluence["+g+"]",_,y))}l=p.length*(a||1)}else{let p=".bones["+r[h].name+"]";n(Q1,p+".position",f,"pos",i),n($0,p+".quaternion",f,"rot",i),n(Q1,p+".scale",f,"scl",i)}}return i.length===0?null:new this(o,l,i,s)}resetDuration(){let t=this.tracks,r=0;for(let n=0,i=t.length;n!==i;++n){let o=this.tracks[n];r=Math.max(r,o.times[o.times.length-1])}return this.duration=r,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let r=0;r<this.tracks.length;r++)t=t&&this.tracks[r].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let r=0;r<this.tracks.length;r++)t.push(this.tracks[r].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function h0r(e){switch(e.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return J1;case"vector":case"vector2":case"vector3":case"vector4":return Q1;case"color":return M6;case"quaternion":return $0;case"bool":case"boolean":return sm;case"string":return lm}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+e)}function f0r(e){if(e.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=h0r(e.type);if(e.times===void 0){let r=[],n=[];jn.flattenJSON(e.keys,r,n,"value"),e.times=r,e.values=n}return t.parse!==void 0?t.parse(e):new t(e.name,e.times,e.values,e.interpolation)}var ex={enabled:!1,files:{},add:function(e,t){this.enabled!==!1&&(this.files[e]=t)},get:function(e){if(this.enabled!==!1)return this.files[e]},remove:function(e){delete this.files[e]},clear:function(){this.files={}}},E6=class{constructor(t,r,n){let i=this,o=!1,a=0,s=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=r,this.onError=n,this.itemStart=function(u){s++,o===!1&&i.onStart!==void 0&&i.onStart(u,a,s),o=!0},this.itemEnd=function(u){a++,i.onProgress!==void 0&&i.onProgress(u,a,s),a===s&&(o=!1,i.onLoad!==void 0&&i.onLoad())},this.itemError=function(u){i.onError!==void 0&&i.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let p=c[h],d=c[h+1];if(p.global&&(p.lastIndex=0),p.test(u))return d}return null}}},ipe=new E6,ea=class{constructor(t){this.manager=t!==void 0?t:ipe,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,r){let n=this;return new Promise(function(i,o){n.load(t,i,r,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},jd={},Jc=class extends ea{constructor(t){super(t)}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=ex.get(t);if(o!==void 0)return this.manager.itemStart(t),setTimeout(()=>{r&&r(o),this.manager.itemEnd(t)},0),o;if(jd[t]!==void 0){jd[t].push({onLoad:r,onProgress:n,onError:i});return}jd[t]=[],jd[t].push({onLoad:r,onProgress:n,onError:i});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=jd[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),p=f?parseInt(f):0,d=p!==0,g=0,_=new ReadableStream({start(y){x();function x(){h.read().then(({done:b,value:S})=>{if(b)y.close();else{g+=S.byteLength;let C=new ProgressEvent("progress",{lengthComputable:d,loaded:g,total:p});for(let P=0,k=u.length;P<k;P++){let O=u[P];O.onProgress&&O.onProgress(C)}y.enqueue(S),x()}})}}});return new Response(_)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,s));case"json":return c.json();default:if(s===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(s),f=h&&h[1]?h[1].toLowerCase():void 0,p=new TextDecoder(f);return c.arrayBuffer().then(d=>p.decode(d))}}}).then(c=>{ex.add(t,c);let u=jd[t];delete jd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onLoad&&p.onLoad(c)}}).catch(c=>{let u=jd[t];if(u===void 0)throw this.manager.itemError(t),c;delete jd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onError&&p.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},oht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=[];for(let n=0;n<t.length;n++){let i=tx.parse(t[n]);r.push(i)}return r}},aht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=[],s=new a6,l=new Jc(this.manager);l.setPath(this.path),l.setResponseType("arraybuffer"),l.setRequestHeader(this.requestHeader),l.setWithCredentials(o.withCredentials);let c=0;function u(h){l.load(t[h],function(f){let p=o.parse(f,!0);a[h]={width:p.width,height:p.height,format:p.format,mipmaps:p.mipmaps},c+=1,c===6&&(p.mipmapCount===1&&(s.minFilter=ii),s.image=a,s.format=p.format,s.needsUpdate=!0,r&&r(s))},n,i)}if(Array.isArray(t))for(let h=0,f=t.length;h<f;++h)u(h);else l.load(t,function(h){let f=o.parse(h,!0);if(f.isCubemap){let p=f.mipmaps.length/f.mipmapCount;for(let d=0;d<p;d++){a[d]={mipmaps:[]};for(let g=0;g<f.mipmapCount;g++)a[d].mipmaps.push(f.mipmaps[d*f.mipmapCount+g]),a[d].format=f.format,a[d].width=f.width,a[d].height=f.height}s.image=a}else s.image.width=f.width,s.image.height=f.height,s.mipmaps=f.mipmaps;f.mipmapCount===1&&(s.minFilter=ii),s.format=f.format,s.needsUpdate=!0,r&&r(s)},n,i);return s}},rx=class extends ea{constructor(t){super(t)}load(t,r,n,i){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=ex.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s=t6("img");function l(){u(),ex.add(t,this),r&&r(this),o.manager.itemEnd(t)}function c(h){u(),i&&i(h),o.manager.itemError(t),o.manager.itemEnd(t)}function u(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},TU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new V0,a=new rx(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(u){o.images[c]=u,s++,s===6&&(o.needsUpdate=!0,r&&r(o))},void 0,i)}for(let c=0;c<t.length;++c)l(c);return o}},CU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Qd,s=new Jc(this.manager);return s.setResponseType("arraybuffer"),s.setRequestHeader(this.requestHeader),s.setPath(this.path),s.setWithCredentials(o.withCredentials),s.load(t,function(l){let c=o.parse(l);!c||(c.image!==void 0?a.image=c.image:c.data!==void 0&&(a.image.width=c.width,a.image.height=c.height,a.image.data=c.data),a.wrapS=c.wrapS!==void 0?c.wrapS:Jo,a.wrapT=c.wrapT!==void 0?c.wrapT:Jo,a.magFilter=c.magFilter!==void 0?c.magFilter:ii,a.minFilter=c.minFilter!==void 0?c.minFilter:ii,a.anisotropy=c.anisotropy!==void 0?c.anisotropy:1,c.encoding!==void 0&&(a.encoding=c.encoding),c.flipY!==void 0&&(a.flipY=c.flipY),c.format!==void 0&&(a.format=c.format),c.type!==void 0&&(a.type=c.type),c.mipmaps!==void 0&&(a.mipmaps=c.mipmaps,a.minFilter=ax),c.mipmapCount===1&&(a.minFilter=ii),c.generateMipmaps!==void 0&&(a.generateMipmaps=c.generateMipmaps),a.needsUpdate=!0,r&&r(a,c))},n,i),a}},AU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new vi,a=new rx(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,r!==void 0&&r(o)},n,i),o}},zl=class extends or{constructor(t,r=1){super(),this.type="Light",this.color=new ne(t),this.intensity=r}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let r=super.toJSON(t);return r.object.color=this.color.getHex(),r.object.intensity=this.intensity,this.groundColor!==void 0&&(r.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(r.object.distance=this.distance),this.angle!==void 0&&(r.object.angle=this.angle),this.decay!==void 0&&(r.object.decay=this.decay),this.penumbra!==void 0&&(r.object.penumbra=this.penumbra),this.shadow!==void 0&&(r.object.shadow=this.shadow.toJSON()),r}};zl.prototype.isLight=!0;var T6=class extends zl{constructor(t,r,n){super(t,n),this.type="HemisphereLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.groundColor=new ne(r)}copy(t){return zl.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};T6.prototype.isHemisphereLight=!0;var xhe=new Me,bhe=new j,whe=new j,C6=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new Lt(512,512),this.map=null,this.mapPass=null,this.matrix=new Me,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new D1,this._frameExtents=new Lt(1,1),this._viewportCount=1,this._viewports=[new en(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let r=this.camera,n=this.matrix;bhe.setFromMatrixPosition(t.matrixWorld),r.position.copy(bhe),whe.setFromMatrixPosition(t.target.matrixWorld),r.lookAt(whe),r.updateMatrixWorld(),xhe.multiplyMatrices(r.projectionMatrix,r.matrixWorldInverse),this._frustum.setFromProjectionMatrix(xhe),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(r.projectionMatrix),n.multiply(r.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},PU=class extends C6{constructor(){super(new Ui(50,1,.5,500)),this.focus=1}updateMatrices(t){let r=this.camera,n=QP*2*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,o=t.distance||r.far;(n!==r.fov||i!==r.aspect||o!==r.far)&&(r.fov=n,r.aspect=i,r.far=o,r.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};PU.prototype.isSpotLightShadow=!0;var A6=class extends zl{constructor(t,r,n=0,i=Math.PI/3,o=0,a=1){super(t,r),this.type="SpotLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.distance=n,this.angle=i,this.penumbra=o,this.decay=a,this.shadow=new PU}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};A6.prototype.isSpotLight=!0;var She=new Me,BP=new j,xut=new j,IU=class extends C6{constructor(){super(new Ui(90,1,.5,500)),this._frameExtents=new Lt(4,2),this._viewportCount=6,this._viewports=[new en(2,1,1,1),new en(0,1,1,1),new en(3,1,1,1),new en(1,1,1,1),new en(3,0,1,1),new en(1,0,1,1)],this._cubeDirections=[new j(1,0,0),new j(-1,0,0),new j(0,0,1),new j(0,0,-1),new j(0,1,0),new j(0,-1,0)],this._cubeUps=[new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,0,1),new j(0,0,-1)]}updateMatrices(t,r=0){let n=this.camera,i=this.matrix,o=t.distance||n.far;o!==n.far&&(n.far=o,n.updateProjectionMatrix()),BP.setFromMatrixPosition(t.matrixWorld),n.position.copy(BP),xut.copy(n.position),xut.add(this._cubeDirections[r]),n.up.copy(this._cubeUps[r]),n.lookAt(xut),n.updateMatrixWorld(),i.makeTranslation(-BP.x,-BP.y,-BP.z),She.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(She)}};IU.prototype.isPointLightShadow=!0;var P6=class extends zl{constructor(t,r,n=0,i=1){super(t,r),this.type="PointLight",this.distance=n,this.decay=i,this.shadow=new IU}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};P6.prototype.isPointLight=!0;var LU=class extends C6{constructor(){super(new O1(-5,5,5,-5,.5,500))}};LU.prototype.isDirectionalLightShadow=!0;var I6=class extends zl{constructor(t,r){super(t,r),this.type="DirectionalLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.shadow=new LU}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};I6.prototype.isDirectionalLight=!0;var L6=class extends zl{constructor(t,r){super(t,r),this.type="AmbientLight"}};L6.prototype.isAmbientLight=!0;var k6=class extends zl{constructor(t,r,n=10,i=10){super(t,r),this.type="RectAreaLight",this.width=n,this.height=i}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let r=super.toJSON(t);return r.object.width=this.width,r.object.height=this.height,r}};k6.prototype.isRectAreaLight=!0;var R6=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new j)}set(t){for(let r=0;r<9;r++)this.coefficients[r].copy(t[r]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.282095),r.addScaledVector(a[1],.488603*i),r.addScaledVector(a[2],.488603*o),r.addScaledVector(a[3],.488603*n),r.addScaledVector(a[4],1.092548*(n*i)),r.addScaledVector(a[5],1.092548*(i*o)),r.addScaledVector(a[6],.315392*(3*o*o-1)),r.addScaledVector(a[7],1.092548*(n*o)),r.addScaledVector(a[8],.546274*(n*n-i*i)),r}getIrradianceAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.886227),r.addScaledVector(a[1],2*.511664*i),r.addScaledVector(a[2],2*.511664*o),r.addScaledVector(a[3],2*.511664*n),r.addScaledVector(a[4],2*.429043*n*i),r.addScaledVector(a[5],2*.429043*i*o),r.addScaledVector(a[6],.743125*o*o-.247708),r.addScaledVector(a[7],2*.429043*n*o),r.addScaledVector(a[8],.429043*(n*n-i*i)),r}add(t){for(let r=0;r<9;r++)this.coefficients[r].add(t.coefficients[r]);return this}addScaledSH(t,r){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],r);return this}scale(t){for(let r=0;r<9;r++)this.coefficients[r].multiplyScalar(t);return this}lerp(t,r){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],r);return this}equals(t){for(let r=0;r<9;r++)if(!this.coefficients[r].equals(t.coefficients[r]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,r+i*3);return this}toArray(t=[],r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,r+i*3);return t}static getBasisAt(t,r){let n=t.x,i=t.y,o=t.z;r[0]=.282095,r[1]=.488603*i,r[2]=.488603*o,r[3]=.488603*n,r[4]=1.092548*n*i,r[5]=1.092548*i*o,r[6]=.315392*(3*o*o-1),r[7]=1.092548*n*o,r[8]=.546274*(n*n-i*i)}};R6.prototype.isSphericalHarmonics3=!0;var nx=class extends zl{constructor(t=new R6,r=1){super(void 0,r),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let r=super.toJSON(t);return r.object.sh=this.sh.toArray(),r}};nx.prototype.isLightProbe=!0;var kU=class extends ea{constructor(t){super(t),this.textures={}}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=this.textures;function n(o){return r[o]===void 0&&console.warn("THREE.MaterialLoader: Undefined texture",o),r[o]}let i=new u0r[t.type];if(t.uuid!==void 0&&(i.uuid=t.uuid),t.name!==void 0&&(i.name=t.name),t.color!==void 0&&i.color!==void 0&&i.color.setHex(t.color),t.roughness!==void 0&&(i.roughness=t.roughness),t.metalness!==void 0&&(i.metalness=t.metalness),t.sheen!==void 0&&(i.sheen=t.sheen),t.sheenColor!==void 0&&(i.sheenColor=new ne().setHex(t.sheenColor)),t.sheenRoughness!==void 0&&(i.sheenRoughness=t.sheenRoughness),t.emissive!==void 0&&i.emissive!==void 0&&i.emissive.setHex(t.emissive),t.specular!==void 0&&i.specular!==void 0&&i.specular.setHex(t.specular),t.specularIntensity!==void 0&&(i.specularIntensity=t.specularIntensity),t.specularColor!==void 0&&i.specularColor!==void 0&&i.specularColor.setHex(t.specularColor),t.shininess!==void 0&&(i.shininess=t.shininess),t.clearcoat!==void 0&&(i.clearcoat=t.clearcoat),t.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=t.clearcoatRoughness),t.transmission!==void 0&&(i.transmission=t.transmission),t.thickness!==void 0&&(i.thickness=t.thickness),t.attenuationDistance!==void 0&&(i.attenuationDistance=t.attenuationDistance),t.attenuationColor!==void 0&&i.attenuationColor!==void 0&&i.attenuationColor.setHex(t.attenuationColor),t.fog!==void 0&&(i.fog=t.fog),t.flatShading!==void 0&&(i.flatShading=t.flatShading),t.blending!==void 0&&(i.blending=t.blending),t.combine!==void 0&&(i.combine=t.combine),t.side!==void 0&&(i.side=t.side),t.shadowSide!==void 0&&(i.shadowSide=t.shadowSide),t.opacity!==void 0&&(i.opacity=t.opacity),t.transparent!==void 0&&(i.transparent=t.transparent),t.alphaTest!==void 0&&(i.alphaTest=t.alphaTest),t.depthTest!==void 0&&(i.depthTest=t.depthTest),t.depthWrite!==void 0&&(i.depthWrite=t.depthWrite),t.colorWrite!==void 0&&(i.colorWrite=t.colorWrite),t.alphaWrite!==void 0&&(i.alphaWrite=t.alphaWrite),t.stencilWrite!==void 0&&(i.stencilWrite=t.stencilWrite),t.stencilWriteMask!==void 0&&(i.stencilWriteMask=t.stencilWriteMask),t.stencilFunc!==void 0&&(i.stencilFunc=t.stencilFunc),t.stencilRef!==void 0&&(i.stencilRef=t.stencilRef),t.stencilFuncMask!==void 0&&(i.stencilFuncMask=t.stencilFuncMask),t.stencilFail!==void 0&&(i.stencilFail=t.stencilFail),t.stencilZFail!==void 0&&(i.stencilZFail=t.stencilZFail),t.stencilZPass!==void 0&&(i.stencilZPass=t.stencilZPass),t.wireframe!==void 0&&(i.wireframe=t.wireframe),t.wireframeLinewidth!==void 0&&(i.wireframeLinewidth=t.wireframeLinewidth),t.wireframeLinecap!==void 0&&(i.wireframeLinecap=t.wireframeLinecap),t.wireframeLinejoin!==void 0&&(i.wireframeLinejoin=t.wireframeLinejoin),t.rotation!==void 0&&(i.rotation=t.rotation),t.linewidth!==1&&(i.linewidth=t.linewidth),t.dashSize!==void 0&&(i.dashSize=t.dashSize),t.gapSize!==void 0&&(i.gapSize=t.gapSize),t.scale!==void 0&&(i.scale=t.scale),t.polygonOffset!==void 0&&(i.polygonOffset=t.polygonOffset),t.polygonOffsetFactor!==void 0&&(i.polygonOffsetFactor=t.polygonOffsetFactor),t.polygonOffsetUnits!==void 0&&(i.polygonOffsetUnits=t.polygonOffsetUnits),t.dithering!==void 0&&(i.dithering=t.dithering),t.alphaToCoverage!==void 0&&(i.alphaToCoverage=t.alphaToCoverage),t.premultipliedAlpha!==void 0&&(i.premultipliedAlpha=t.premultipliedAlpha),t.visible!==void 0&&(i.visible=t.visible),t.toneMapped!==void 0&&(i.toneMapped=t.toneMapped),t.userData!==void 0&&(i.userData=t.userData),t.vertexColors!==void 0&&(typeof t.vertexColors=="number"?i.vertexColors=t.vertexColors>0:i.vertexColors=t.vertexColors),t.uniforms!==void 0)for(let o in t.uniforms){let a=t.uniforms[o];switch(i.uniforms[o]={},a.type){case"t":i.uniforms[o].value=n(a.value);break;case"c":i.uniforms[o].value=new ne().setHex(a.value);break;case"v2":i.uniforms[o].value=new Lt().fromArray(a.value);break;case"v3":i.uniforms[o].value=new j().fromArray(a.value);break;case"v4":i.uniforms[o].value=new en().fromArray(a.value);break;case"m3":i.uniforms[o].value=new ki().fromArray(a.value);break;case"m4":i.uniforms[o].value=new Me().fromArray(a.value);break;default:i.uniforms[o].value=a.value}}if(t.defines!==void 0&&(i.defines=t.defines),t.vertexShader!==void 0&&(i.vertexShader=t.vertexShader),t.fragmentShader!==void 0&&(i.fragmentShader=t.fragmentShader),t.extensions!==void 0)for(let o in t.extensions)i.extensions[o]=t.extensions[o];if(t.shading!==void 0&&(i.flatShading=t.shading===1),t.size!==void 0&&(i.size=t.size),t.sizeAttenuation!==void 0&&(i.sizeAttenuation=t.sizeAttenuation),t.map!==void 0&&(i.map=n(t.map)),t.matcap!==void 0&&(i.matcap=n(t.matcap)),t.alphaMap!==void 0&&(i.alphaMap=n(t.alphaMap)),t.bumpMap!==void 0&&(i.bumpMap=n(t.bumpMap)),t.bumpScale!==void 0&&(i.bumpScale=t.bumpScale),t.normalMap!==void 0&&(i.normalMap=n(t.normalMap)),t.normalMapType!==void 0&&(i.normalMapType=t.normalMapType),t.normalScale!==void 0){let o=t.normalScale;Array.isArray(o)===!1&&(o=[o,o]),i.normalScale=new Lt().fromArray(o)}return t.displacementMap!==void 0&&(i.displacementMap=n(t.displacementMap)),t.displacementScale!==void 0&&(i.displacementScale=t.displacementScale),t.displacementBias!==void 0&&(i.displacementBias=t.displacementBias),t.roughnessMap!==void 0&&(i.roughnessMap=n(t.roughnessMap)),t.metalnessMap!==void 0&&(i.metalnessMap=n(t.metalnessMap)),t.emissiveMap!==void 0&&(i.emissiveMap=n(t.emissiveMap)),t.emissiveIntensity!==void 0&&(i.emissiveIntensity=t.emissiveIntensity),t.specularMap!==void 0&&(i.specularMap=n(t.specularMap)),t.specularIntensityMap!==void 0&&(i.specularIntensityMap=n(t.specularIntensityMap)),t.specularColorMap!==void 0&&(i.specularColorMap=n(t.specularColorMap)),t.envMap!==void 0&&(i.envMap=n(t.envMap)),t.envMapIntensity!==void 0&&(i.envMapIntensity=t.envMapIntensity),t.reflectivity!==void 0&&(i.reflectivity=t.reflectivity),t.refractionRatio!==void 0&&(i.refractionRatio=t.refractionRatio),t.lightMap!==void 0&&(i.lightMap=n(t.lightMap)),t.lightMapIntensity!==void 0&&(i.lightMapIntensity=t.lightMapIntensity),t.aoMap!==void 0&&(i.aoMap=n(t.aoMap)),t.aoMapIntensity!==void 0&&(i.aoMapIntensity=t.aoMapIntensity),t.gradientMap!==void 0&&(i.gradientMap=n(t.gradientMap)),t.clearcoatMap!==void 0&&(i.clearcoatMap=n(t.clearcoatMap)),t.clearcoatRoughnessMap!==void 0&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),t.clearcoatNormalMap!==void 0&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),t.clearcoatNormalScale!==void 0&&(i.clearcoatNormalScale=new Lt().fromArray(t.clearcoatNormalScale)),t.transmissionMap!==void 0&&(i.transmissionMap=n(t.transmissionMap)),t.thicknessMap!==void 0&&(i.thicknessMap=n(t.thicknessMap)),t.sheenColorMap!==void 0&&(i.sheenColorMap=n(t.sheenColorMap)),t.sheenRoughnessMap!==void 0&&(i.sheenRoughnessMap=n(t.sheenRoughnessMap)),i}setTextures(t){return this.textures=t,this}},dM=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let r="";for(let n=0,i=t.length;n<i;n++)r+=String.fromCharCode(t[n]);try{return decodeURIComponent(escape(r))}catch(n){return r}}static extractUrlBase(t){let r=t.lastIndexOf("/");return r===-1?"./":t.substr(0,r+1)}static resolveURL(t,r){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(r)&&/^\//.test(t)&&(r=r.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:r+t)}},N6=class extends Pe{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};N6.prototype.isInstancedBufferGeometry=!0;var RU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r={},n={};function i(p,d){if(r[d]!==void 0)return r[d];let _=p.interleavedBuffers[d],y=o(p,_.buffer),x=B3(_.type,y),b=new rm(x,_.stride);return b.uuid=_.uuid,r[d]=b,b}function o(p,d){if(n[d]!==void 0)return n[d];let _=p.arrayBuffers[d],y=new Uint32Array(_).buffer;return n[d]=y,y}let a=t.isInstancedBufferGeometry?new N6:new Pe,s=t.data.index;if(s!==void 0){let p=B3(s.type,s.array);a.setIndex(new Je(p,1))}let l=t.data.attributes;for(let p in l){let d=l[p],g;if(d.isInterleavedBufferAttribute){let _=i(t.data,d.data);g=new ep(_,d.itemSize,d.offset,d.normalized)}else{let _=B3(d.type,d.array),y=d.isInstancedBufferAttribute?nm:Je;g=new y(_,d.itemSize,d.normalized)}d.name!==void 0&&(g.name=d.name),d.usage!==void 0&&g.setUsage(d.usage),d.updateRange!==void 0&&(g.updateRange.offset=d.updateRange.offset,g.updateRange.count=d.updateRange.count),a.setAttribute(p,g)}let c=t.data.morphAttributes;if(c)for(let p in c){let d=c[p],g=[];for(let _=0,y=d.length;_<y;_++){let x=d[_],b;if(x.isInterleavedBufferAttribute){let S=i(t.data,x.data);b=new ep(S,x.itemSize,x.offset,x.normalized)}else{let S=B3(x.type,x.array);b=new Je(S,x.itemSize,x.normalized)}x.name!==void 0&&(b.name=x.name),g.push(b)}a.morphAttributes[p]=g}t.data.morphTargetsRelative&&(a.morphTargetsRelative=!0);let h=t.data.groups||t.data.drawcalls||t.data.offsets;if(h!==void 0)for(let p=0,d=h.length;p!==d;++p){let g=h[p];a.addGroup(g.start,g.count,g.materialIndex)}let f=t.data.boundingSphere;if(f!==void 0){let p=new j;f.center!==void 0&&p.fromArray(f.center),a.boundingSphere=new Jf(p,f.radius)}return t.name&&(a.name=t.name),t.userData&&(a.userData=t.userData),a}},sht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||a;let s=new Jc(this.manager);s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(l){let c=null;try{c=JSON.parse(l)}catch(h){i!==void 0&&i(h),console.error("THREE:ObjectLoader: Can't parse "+t+".",h.message);return}let u=c.metadata;if(u===void 0||u.type===void 0||u.type.toLowerCase()==="geometry"){console.error("THREE.ObjectLoader: Can't load "+t);return}o.parse(c,r)},n,i)}loadAsync(t,r){return Ri(this,null,function*(){let n=this,i=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||i;let o=new Jc(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials);let a=yield o.loadAsync(t,r),s=JSON.parse(a),l=s.metadata;if(l===void 0||l.type===void 0||l.type.toLowerCase()==="geometry")throw new Error("THREE.ObjectLoader: Can't load "+t);return yield n.parseAsync(s)})}parse(t,r){let n=this.parseAnimations(t.animations),i=this.parseShapes(t.shapes),o=this.parseGeometries(t.geometries,i),a=this.parseImages(t.images,function(){r!==void 0&&r(c)}),s=this.parseTextures(t.textures,a),l=this.parseMaterials(t.materials,s),c=this.parseObject(t.object,o,l,s,n),u=this.parseSkeletons(t.skeletons,c);if(this.bindSkeletons(c,u),r!==void 0){let h=!1;for(let f in a)if(a[f]instanceof HTMLImageElement){h=!0;break}h===!1&&r(c)}return c}parseAsync(t){return Ri(this,null,function*(){let r=this.parseAnimations(t.animations),n=this.parseShapes(t.shapes),i=this.parseGeometries(t.geometries,n),o=yield this.parseImagesAsync(t.images),a=this.parseTextures(t.textures,o),s=this.parseMaterials(t.materials,a),l=this.parseObject(t.object,i,s,a,r),c=this.parseSkeletons(t.skeletons,l);return this.bindSkeletons(l,c),l})}parseShapes(t){let r={};if(t!==void 0)for(let n=0,i=t.length;n<i;n++){let o=new Kc().fromJSON(t[n]);r[o.uuid]=o}return r}parseSkeletons(t,r){let n={},i={};if(r.traverse(function(o){o.isBone&&(i[o.uuid]=o)}),t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=new lM().fromJSON(t[o],i);n[s.uuid]=s}return n}parseGeometries(t,r){let n={};if(t!==void 0){let i=new RU;for(let o=0,a=t.length;o<a;o++){let s,l=t[o];switch(l.type){case"BufferGeometry":case"InstancedBufferGeometry":s=i.parse(l);break;case"Geometry":console.error("THREE.ObjectLoader: The legacy Geometry type is no longer supported.");break;default:l.type in vhe?s=vhe[l.type].fromJSON(l,r):console.warn(`THREE.ObjectLoader: Unsupported geometry type "${l.type}"`)}s.uuid=l.uuid,l.name!==void 0&&(s.name=l.name),s.isBufferGeometry===!0&&l.userData!==void 0&&(s.userData=l.userData),n[l.uuid]=s}}return n}parseMaterials(t,r){let n={},i={};if(t!==void 0){let o=new kU;o.setTextures(r);for(let a=0,s=t.length;a<s;a++){let l=t[a];if(l.type==="MultiMaterial"){let c=[];for(let u=0;u<l.materials.length;u++){let h=l.materials[u];n[h.uuid]===void 0&&(n[h.uuid]=o.parse(h)),c.push(n[h.uuid])}i[l.uuid]=c}else n[l.uuid]===void 0&&(n[l.uuid]=o.parse(l)),i[l.uuid]=n[l.uuid]}}return i}parseAnimations(t){let r={};if(t!==void 0)for(let n=0;n<t.length;n++){let i=t[n],o=tx.parse(i);r[o.uuid]=o}return r}parseImages(t,r){let n=this,i={},o;function a(l){return n.manager.itemStart(l),o.load(l,function(){n.manager.itemEnd(l)},void 0,function(){n.manager.itemError(l),n.manager.itemEnd(l)})}function s(l){if(typeof l=="string"){let c=l,u=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(c)?c:n.resourcePath+c;return a(u)}else return l.data?{data:B3(l.type,l.data),width:l.width,height:l.height}:null}if(t!==void 0&&t.length>0){let l=new E6(r);o=new rx(l),o.setCrossOrigin(this.crossOrigin);for(let c=0,u=t.length;c<u;c++){let h=t[c],f=h.url;if(Array.isArray(f)){i[h.uuid]=[];for(let p=0,d=f.length;p<d;p++){let g=f[p],_=s(g);_!==null&&(_ instanceof HTMLImageElement?i[h.uuid].push(_):i[h.uuid].push(new Qd(_.data,_.width,_.height)))}}else{let p=s(h.url);p!==null&&(i[h.uuid]=p)}}}return i}parseImagesAsync(t){return Ri(this,null,function*(){let r=this,n={},i;function o(a){return Ri(this,null,function*(){if(typeof a=="string"){let s=a,l=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(s)?s:r.resourcePath+s;return yield i.loadAsync(l)}else return a.data?{data:B3(a.type,a.data),width:a.width,height:a.height}:null})}if(t!==void 0&&t.length>0){i=new rx(this.manager),i.setCrossOrigin(this.crossOrigin);for(let a=0,s=t.length;a<s;a++){let l=t[a],c=l.url;if(Array.isArray(c)){n[l.uuid]=[];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=yield o(f);p!==null&&(p instanceof HTMLImageElement?n[l.uuid].push(p):n[l.uuid].push(new Qd(p.data,p.width,p.height)))}}else{let u=yield o(l.url);u!==null&&(n[l.uuid]=u)}}}return n})}parseTextures(t,r){function n(o,a){return typeof o=="number"?o:(console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",o),a[o])}let i={};if(t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=t[o];s.image===void 0&&console.warn('THREE.ObjectLoader: No "image" specified for',s.uuid),r[s.image]===void 0&&console.warn("THREE.ObjectLoader: Undefined image",s.image);let l,c=r[s.image];Array.isArray(c)?(l=new V0(c),c.length===6&&(l.needsUpdate=!0)):(c&&c.data?l=new Qd(c.data,c.width,c.height):l=new vi(c),c&&(l.needsUpdate=!0)),l.uuid=s.uuid,s.name!==void 0&&(l.name=s.name),s.mapping!==void 0&&(l.mapping=n(s.mapping,p0r)),s.offset!==void 0&&l.offset.fromArray(s.offset),s.repeat!==void 0&&l.repeat.fromArray(s.repeat),s.center!==void 0&&l.center.fromArray(s.center),s.rotation!==void 0&&(l.rotation=s.rotation),s.wrap!==void 0&&(l.wrapS=n(s.wrap[0],Mhe),l.wrapT=n(s.wrap[1],Mhe)),s.format!==void 0&&(l.format=s.format),s.type!==void 0&&(l.type=s.type),s.encoding!==void 0&&(l.encoding=s.encoding),s.minFilter!==void 0&&(l.minFilter=n(s.minFilter,Ehe)),s.magFilter!==void 0&&(l.magFilter=n(s.magFilter,Ehe)),s.anisotropy!==void 0&&(l.anisotropy=s.anisotropy),s.flipY!==void 0&&(l.flipY=s.flipY),s.premultiplyAlpha!==void 0&&(l.premultiplyAlpha=s.premultiplyAlpha),s.unpackAlignment!==void 0&&(l.unpackAlignment=s.unpackAlignment),s.userData!==void 0&&(l.userData=s.userData),i[s.uuid]=l}return i}parseObject(t,r,n,i,o){let a;function s(f){return r[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined geometry",f),r[f]}function l(f){if(f!==void 0){if(Array.isArray(f)){let p=[];for(let d=0,g=f.length;d<g;d++){let _=f[d];n[_]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",_),p.push(n[_])}return p}return n[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",f),n[f]}}function c(f){return i[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined texture",f),i[f]}let u,h;switch(t.type){case"Scene":a=new G0,t.background!==void 0&&(Number.isInteger(t.background)?a.background=new ne(t.background):a.background=c(t.background)),t.environment!==void 0&&(a.environment=c(t.environment)),t.fog!==void 0&&(t.fog.type==="Fog"?a.fog=new F1(t.fog.color,t.fog.near,t.fog.far):t.fog.type==="FogExp2"&&(a.fog=new z1(t.fog.color,t.fog.density)));break;case"PerspectiveCamera":a=new Ui(t.fov,t.aspect,t.near,t.far),t.focus!==void 0&&(a.focus=t.focus),t.zoom!==void 0&&(a.zoom=t.zoom),t.filmGauge!==void 0&&(a.filmGauge=t.filmGauge),t.filmOffset!==void 0&&(a.filmOffset=t.filmOffset),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"OrthographicCamera":a=new O1(t.left,t.right,t.top,t.bottom,t.near,t.far),t.zoom!==void 0&&(a.zoom=t.zoom),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"AmbientLight":a=new L6(t.color,t.intensity);break;case"DirectionalLight":a=new I6(t.color,t.intensity);break;case"PointLight":a=new P6(t.color,t.intensity,t.distance,t.decay);break;case"RectAreaLight":a=new k6(t.color,t.intensity,t.width,t.height);break;case"SpotLight":a=new A6(t.color,t.intensity,t.distance,t.angle,t.penumbra,t.decay);break;case"HemisphereLight":a=new T6(t.color,t.groundColor,t.intensity);break;case"LightProbe":a=new nx().fromJSON(t);break;case"SkinnedMesh":u=s(t.geometry),h=l(t.material),a=new aM(u,h),t.bindMode!==void 0&&(a.bindMode=t.bindMode),t.bindMatrix!==void 0&&a.bindMatrix.fromArray(t.bindMatrix),t.skeleton!==void 0&&(a.skeleton=t.skeleton);break;case"Mesh":u=s(t.geometry),h=l(t.material),a=new ti(u,h);break;case"InstancedMesh":u=s(t.geometry),h=l(t.material);let f=t.count,p=t.instanceMatrix,d=t.instanceColor;a=new i6(u,h,f),a.instanceMatrix=new nm(new Float32Array(p.array),16),d!==void 0&&(a.instanceColor=new nm(new Float32Array(d.array),d.itemSize));break;case"LOD":a=new _U;break;case"Line":a=new ch(s(t.geometry),l(t.material));break;case"LineLoop":a=new o6(s(t.geometry),l(t.material));break;case"LineSegments":a=new Pa(s(t.geometry),l(t.material));break;case"PointCloud":case"Points":a=new om(s(t.geometry),l(t.material));break;case"Sprite":a=new oM(l(t.material));break;case"Group":a=new $d;break;case"Bone":a=new sM;break;default:a=new or}if(a.uuid=t.uuid,t.name!==void 0&&(a.name=t.name),t.matrix!==void 0?(a.matrix.fromArray(t.matrix),t.matrixAutoUpdate!==void 0&&(a.matrixAutoUpdate=t.matrixAutoUpdate),a.matrixAutoUpdate&&a.matrix.decompose(a.position,a.quaternion,a.scale)):(t.position!==void 0&&a.position.fromArray(t.position),t.rotation!==void 0&&a.rotation.fromArray(t.rotation),t.quaternion!==void 0&&a.quaternion.fromArray(t.quaternion),t.scale!==void 0&&a.scale.fromArray(t.scale)),t.castShadow!==void 0&&(a.castShadow=t.castShadow),t.receiveShadow!==void 0&&(a.receiveShadow=t.receiveShadow),t.shadow&&(t.shadow.bias!==void 0&&(a.shadow.bias=t.shadow.bias),t.shadow.normalBias!==void 0&&(a.shadow.normalBias=t.shadow.normalBias),t.shadow.radius!==void 0&&(a.shadow.radius=t.shadow.radius),t.shadow.mapSize!==void 0&&a.shadow.mapSize.fromArray(t.shadow.mapSize),t.shadow.camera!==void 0&&(a.shadow.camera=this.parseObject(t.shadow.camera))),t.visible!==void 0&&(a.visible=t.visible),t.frustumCulled!==void 0&&(a.frustumCulled=t.frustumCulled),t.renderOrder!==void 0&&(a.renderOrder=t.renderOrder),t.userData!==void 0&&(a.userData=t.userData),t.layers!==void 0&&(a.layers.mask=t.layers),t.children!==void 0){let f=t.children;for(let p=0;p<f.length;p++)a.add(this.parseObject(f[p],r,n,i,o))}if(t.animations!==void 0){let f=t.animations;for(let p=0;p<f.length;p++){let d=f[p];a.animations.push(o[d])}}if(t.type==="LOD"){t.autoUpdate!==void 0&&(a.autoUpdate=t.autoUpdate);let f=t.levels;for(let p=0;p<f.length;p++){let d=f[p],g=a.getObjectByProperty("uuid",d.object);g!==void 0&&a.addLevel(g,d.distance)}}return a}bindSkeletons(t,r){Object.keys(r).length!==0&&t.traverse(function(n){if(n.isSkinnedMesh===!0&&n.skeleton!==void 0){let i=r[n.skeleton];i===void 0?console.warn("THREE.ObjectLoader: No skeleton found with UUID:",n.skeleton):n.bind(i,n.bindMatrix)}})}setTexturePath(t){return console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath()."),this.setResourcePath(t)}},p0r={UVMapping:XU,CubeReflectionMapping:ix,CubeRefractionMapping:ox,EquirectangularReflectionMapping:YP,EquirectangularRefractionMapping:jP,CubeUVReflectionMapping:xM,CubeUVRefractionMapping:z6},Mhe={RepeatWrapping:XP,ClampToEdgeWrapping:Jo,MirroredRepeatWrapping:$P},Ehe={NearestFilter:Li,NearestMipmapNearestFilter:oU,NearestMipmapLinearFilter:aU,LinearFilter:ii,LinearMipmapNearestFilter:Lht,LinearMipmapLinearFilter:ax},NU=class extends ea{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=ex.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){ex.add(t,l),r&&r(l),o.manager.itemEnd(t)}).catch(function(l){i&&i(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}};NU.prototype.isImageBitmapLoader=!0;var WV,zht={getContext:function(){return WV===void 0&&(WV=new(window.AudioContext||window.webkitAudioContext)),WV},setContext:function(e){WV=e}},DU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);zht.getContext().decodeAudioData(l,function(u){r(u)})}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}},OU=class extends nx{constructor(t,r,n=1){super(void 0,n);let i=new ne().set(t),o=new ne().set(r),a=new j(i.r,i.g,i.b),s=new j(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}};OU.prototype.isHemisphereLightProbe=!0;var zU=class extends nx{constructor(t,r=1){super(void 0,r);let n=new ne().set(t);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}};zU.prototype.isAmbientLightProbe=!0;var The=new Me,Che=new Me,v1=new Me,lht=class{constructor(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new Ui,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new Ui,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}update(t){let r=this._cache;if(r.focus!==t.focus||r.fov!==t.fov||r.aspect!==t.aspect*this.aspect||r.near!==t.near||r.far!==t.far||r.zoom!==t.zoom||r.eyeSep!==this.eyeSep){r.focus=t.focus,r.fov=t.fov,r.aspect=t.aspect*this.aspect,r.near=t.near,r.far=t.far,r.zoom=t.zoom,r.eyeSep=this.eyeSep,v1.copy(t.projectionMatrix);let i=r.eyeSep/2,o=i*r.near/r.focus,a=r.near*Math.tan(I1*r.fov*.5)/r.zoom,s,l;Che.elements[12]=-i,The.elements[12]=i,s=-a*r.aspect+o,l=a*r.aspect+o,v1.elements[0]=2*r.near/(l-s),v1.elements[8]=(l+s)/(l-s),this.cameraL.projectionMatrix.copy(v1),s=-a*r.aspect-o,l=a*r.aspect-o,v1.elements[0]=2*r.near/(l-s),v1.elements[8]=(l+s)/(l-s),this.cameraR.projectionMatrix.copy(v1)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(Che),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(The)}},mM=class{constructor(t=!0){this.autoStart=t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=Ahe(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){let r=Ahe();t=(r-this.oldTime)/1e3,this.oldTime=r,this.elapsedTime+=t}return t}};function Ahe(){return(typeof performance=="undefined"?Date:performance).now()}var x1=new j,Phe=new yi,d0r=new j,b1=new j,cht=class extends or{constructor(){super(),this.type="AudioListener",this.context=zht.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._clock=new mM}getInput(){return this.gain}removeFilter(){return this.filter!==null&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return this.filter!==null?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t);let r=this.context.listener,n=this.up;if(this.timeDelta=this._clock.getDelta(),this.matrixWorld.decompose(x1,Phe,d0r),b1.set(0,0,-1).applyQuaternion(Phe),r.positionX){let i=this.context.currentTime+this.timeDelta;r.positionX.linearRampToValueAtTime(x1.x,i),r.positionY.linearRampToValueAtTime(x1.y,i),r.positionZ.linearRampToValueAtTime(x1.z,i),r.forwardX.linearRampToValueAtTime(b1.x,i),r.forwardY.linearRampToValueAtTime(b1.y,i),r.forwardZ.linearRampToValueAtTime(b1.z,i),r.upX.linearRampToValueAtTime(n.x,i),r.upY.linearRampToValueAtTime(n.y,i),r.upZ.linearRampToValueAtTime(n.z,i)}else r.setPosition(x1.x,x1.y,x1.z),r.setOrientation(b1.x,b1.y,b1.z,n.x,n.y,n.z)}},D6=class extends or{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let r=this.context.createBufferSource();return r.buffer=this.buffer,r.loop=this.loop,r.loopStart=this.loopStart,r.loopEnd=this.loopEnd,r.onended=this.onEnded.bind(this),r.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=r,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}},w1=new j,Ihe=new yi,m0r=new j,S1=new j,uht=class extends D6{constructor(t){super(t),this.panner=this.context.createPanner(),this.panner.panningModel="HRTF",this.panner.connect(this.gain)}getOutput(){return this.panner}getRefDistance(){return this.panner.refDistance}setRefDistance(t){return this.panner.refDistance=t,this}getRolloffFactor(){return this.panner.rolloffFactor}setRolloffFactor(t){return this.panner.rolloffFactor=t,this}getDistanceModel(){return this.panner.distanceModel}setDistanceModel(t){return this.panner.distanceModel=t,this}getMaxDistance(){return this.panner.maxDistance}setMaxDistance(t){return this.panner.maxDistance=t,this}setDirectionalCone(t,r,n){return this.panner.coneInnerAngle=t,this.panner.coneOuterAngle=r,this.panner.coneOuterGain=n,this}updateMatrixWorld(t){if(super.updateMatrixWorld(t),this.hasPlaybackControl===!0&&this.isPlaying===!1)return;this.matrixWorld.decompose(w1,Ihe,m0r),S1.set(0,0,1).applyQuaternion(Ihe);let r=this.panner;if(r.positionX){let n=this.context.currentTime+this.listener.timeDelta;r.positionX.linearRampToValueAtTime(w1.x,n),r.positionY.linearRampToValueAtTime(w1.y,n),r.positionZ.linearRampToValueAtTime(w1.z,n),r.orientationX.linearRampToValueAtTime(S1.x,n),r.orientationY.linearRampToValueAtTime(S1.y,n),r.orientationZ.linearRampToValueAtTime(S1.z,n)}else r.setPosition(w1.x,w1.y,w1.z),r.setOrientation(S1.x,S1.y,S1.z)}},FU=class{constructor(t,r=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=r,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,r=this.getFrequencyData();for(let n=0;n<r.length;n++)t+=r[n];return t/r.length}},BU=class{constructor(t,r,n){this.binding=t,this.valueSize=n;let i,o,a;switch(r){case"quaternion":i=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(n*6),this._workIndex=5;break;case"string":case"bool":i=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(n*5);break;default:i=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(n*5)}this._mixBufferRegion=i,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,r){let n=this.buffer,i=this.valueSize,o=t*i+i,a=this.cumulativeWeight;if(a===0){for(let s=0;s!==i;++s)n[o+s]=n[s];a=r}else{a+=r;let s=r/a;this._mixBufferRegion(n,o,0,s,i)}this.cumulativeWeight=a}accumulateAdditive(t){let r=this.buffer,n=this.valueSize,i=n*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(r,i,0,t,n),this.cumulativeWeightAdditive+=t}apply(t){let r=this.valueSize,n=this.buffer,i=t*r+r,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1){let l=r*this._origIndex;this._mixBufferRegion(n,i,l,1-o,r)}a>0&&this._mixBufferRegionAdditive(n,i,this._addIndex*r,1,r);for(let l=r,c=r+r;l!==c;++l)if(n[l]!==n[l+r]){s.setValue(n,i);break}}saveOriginalState(){let t=this.binding,r=this.buffer,n=this.valueSize,i=n*this._origIndex;t.getValue(r,i);for(let o=n,a=i;o!==a;++o)r[o]=r[i+o%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,r=t+this.valueSize;for(let n=t;n<r;n++)this.buffer[n]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,r=this._addIndex*this.valueSize;for(let n=0;n<this.valueSize;n++)this.buffer[r+n]=this.buffer[t+n]}_select(t,r,n,i,o){if(i>=.5)for(let a=0;a!==o;++a)t[r+a]=t[n+a]}_slerp(t,r,n,i){yi.slerpFlat(t,r,t,r,t,n,i)}_slerpAdditive(t,r,n,i,o){let a=this._workIndex*o;yi.multiplyQuaternionsFlat(t,a,t,r,t,n),yi.slerpFlat(t,r,t,r,t,a,i)}_lerp(t,r,n,i,o){let a=1-i;for(let s=0;s!==o;++s){let l=r+s;t[l]=t[l]*a+t[n+s]*i}}_lerpAdditive(t,r,n,i,o){for(let a=0;a!==o;++a){let s=r+a;t[s]=t[s]+t[n+a]*i}}},Fht="\\[\\]\\.:\\/",g0r=new RegExp("["+Fht+"]","g"),Bht="[^"+Fht+"]",_0r="[^"+Fht.replace("\\.","")+"]",y0r=/((?:WC+[\/:])*)/.source.replace("WC",Bht),v0r=/(WCOD+)?/.source.replace("WCOD",_0r),x0r=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",Bht),b0r=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",Bht),w0r=new RegExp("^"+y0r+v0r+x0r+b0r+"$"),S0r=["material","materials","bones"],hht=class{constructor(t,r,n){let i=n||Cr.parseTrackName(r);this._targetGroup=t,this._bindings=t.subscribe_(r,i)}getValue(t,r){this.bind();let n=this._targetGroup.nCachedObjects_,i=this._bindings[n];i!==void 0&&i.getValue(t,r)}setValue(t,r){let n=this._bindings;for(let i=this._targetGroup.nCachedObjects_,o=n.length;i!==o;++i)n[i].setValue(t,r)}bind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].bind()}unbind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].unbind()}},Cr=class{constructor(t,r,n){this.path=r,this.parsedPath=n||Cr.parseTrackName(r),this.node=Cr.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,r,n){return t&&t.isAnimationObjectGroup?new Cr.Composite(t,r,n):new Cr(t,r,n)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(g0r,"")}static parseTrackName(t){let r=w0r.exec(t);if(!r)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let n={nodeName:r[2],objectName:r[3],objectIndex:r[4],propertyName:r[5],propertyIndex:r[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(i!==void 0&&i!==-1){let o=n.nodeName.substring(i+1);S0r.indexOf(o)!==-1&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=o)}if(n.propertyName===null||n.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n}static findNode(t,r){if(!r||r===""||r==="."||r===-1||r===t.name||r===t.uuid)return t;if(t.skeleton){let n=t.skeleton.getBoneByName(r);if(n!==void 0)return n}if(t.children){let n=function(o){for(let a=0;a<o.length;a++){let s=o[a];if(s.name===r||s.uuid===r)return s;let l=n(s.children);if(l)return l}return null},i=n(t.children);if(i)return i}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,r){t[r]=this.targetObject[this.propertyName]}_getValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)t[r++]=n[i]}_getValue_arrayElement(t,r){t[r]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,r){this.resolvedProperty.toArray(t,r)}_setValue_direct(t,r){this.targetObject[this.propertyName]=t[r]}_setValue_direct_setNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++]}_setValue_array_setNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,r){this.resolvedProperty[this.propertyIndex]=t[r]}_setValue_arrayElement_setNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,r){this.resolvedProperty.fromArray(t,r)}_setValue_fromArray_setNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,r){this.bind(),this.getValue(t,r)}_setValue_unbound(t,r){this.bind(),this.setValue(t,r)}bind(){let t=this.node,r=this.parsedPath,n=r.objectName,i=r.propertyName,o=r.propertyIndex;if(t||(t=Cr.findNode(this.rootNode,r.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(n){let c=r.objectIndex;switch(n){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[n]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[n]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let a=t[i];if(a===void 0){let c=r.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+i+" but it wasn't found.",t);return}let s=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?s=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(s=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(o!==void 0){if(i==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[o]!==void 0&&(o=t.morphTargetDictionary[o])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=o}else a.fromArray!==void 0&&a.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(l=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=i;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][s]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Cr.Composite=hht;Cr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Cr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Cr.prototype.GetterByBindingType=[Cr.prototype._getValue_direct,Cr.prototype._getValue_array,Cr.prototype._getValue_arrayElement,Cr.prototype._getValue_toArray];Cr.prototype.SetterByBindingTypeAndVersioning=[[Cr.prototype._setValue_direct,Cr.prototype._setValue_direct_setNeedsUpdate,Cr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_array,Cr.prototype._setValue_array_setNeedsUpdate,Cr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_arrayElement,Cr.prototype._setValue_arrayElement_setNeedsUpdate,Cr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_fromArray,Cr.prototype._setValue_fromArray_setNeedsUpdate,Cr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var HU=class{constructor(){this.uuid=Dl(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let n=0,i=arguments.length;n!==i;++n)t[arguments[n].uuid]=n;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let r=this;this.stats={objects:{get total(){return r._objects.length},get inUse(){return this.total-r.nCachedObjects_}},get bindingsPerObject(){return r._bindings.length}}}add(){let t=this._objects,r=this._indicesByUUID,n=this._paths,i=this._parsedPaths,o=this._bindings,a=o.length,s,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],p=f.uuid,d=r[p];if(d===void 0){d=l++,r[p]=d,t.push(f);for(let g=0,_=a;g!==_;++g)o[g].push(new Cr(f,n[g],i[g]))}else if(d<c){s=t[d];let g=--c,_=t[g];r[_.uuid]=d,t[d]=_,r[p]=g,t[g]=f;for(let y=0,x=a;y!==x;++y){let b=o[y],S=b[g],C=b[d];b[d]=S,C===void 0&&(C=new Cr(f,n[y],i[y])),b[g]=C}}else t[d]!==s&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_;for(let a=0,s=arguments.length;a!==s;++a){let l=arguments[a],c=l.uuid,u=r[c];if(u!==void 0&&u>=o){let h=o++,f=t[h];r[f.uuid]=u,t[u]=f,r[c]=h,t[h]=l;for(let p=0,d=i;p!==d;++p){let g=n[p],_=g[h],y=g[u];g[u]=_,g[h]=y}}}this.nCachedObjects_=o}uncache(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_,a=t.length;for(let s=0,l=arguments.length;s!==l;++s){let c=arguments[s],u=c.uuid,h=r[u];if(h!==void 0)if(delete r[u],h<o){let f=--o,p=t[f],d=--a,g=t[d];r[p.uuid]=h,t[h]=p,r[g.uuid]=f,t[f]=g,t.pop();for(let _=0,y=i;_!==y;++_){let x=n[_],b=x[f],S=x[d];x[h]=b,x[f]=S,x.pop()}}else{let f=--a,p=t[f];f>0&&(r[p.uuid]=h),t[h]=p,t.pop();for(let d=0,g=i;d!==g;++d){let _=n[d];_[h]=_[f],_.pop()}}}this.nCachedObjects_=o}subscribe_(t,r){let n=this._bindingsIndicesByPath,i=n[t],o=this._bindings;if(i!==void 0)return o[i];let a=this._paths,s=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);i=o.length,n[t]=i,a.push(t),s.push(r),o.push(h);for(let f=u,p=l.length;f!==p;++f){let d=l[f];h[f]=new Cr(d,t,r)}return h}unsubscribe_(t){let r=this._bindingsIndicesByPath,n=r[t];if(n!==void 0){let i=this._paths,o=this._parsedPaths,a=this._bindings,s=a.length-1,l=a[s],c=t[s];r[c]=n,a[n]=l,a.pop(),o[n]=o[s],o.pop(),i[n]=i[s],i.pop()}}};HU.prototype.isAnimationObjectGroup=!0;var fht=class{constructor(t,r,n=null,i=r.blendMode){this._mixer=t,this._clip=r,this._localRoot=n,this.blendMode=i;let o=r.tracks,a=o.length,s=new Array(a),l={endingStart:T1,endingEnd:T1};for(let c=0;c!==a;++c){let u=o[c].createInterpolant(null);s[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Ife,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,r){return this.loop=t,this.repetitions=r,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,r,n){if(t.fadeOut(r),this.fadeIn(r),n){let i=this._clip.duration,o=t._clip.duration,a=o/i,s=i/o;t.warp(1,a,r),this.warp(s,1,r)}return this}crossFadeTo(t,r,n){return t.crossFadeFrom(this,r,n)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,r,n){let i=this._mixer,o=i.time,a=this.timeScale,s=this._timeScaleInterpolant;s===null&&(s=i._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+n,c[0]=t/a,c[1]=r/a,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,r,n,i){if(!this.enabled){this._updateWeight(t);return}let o=this._startTime;if(o!==null){let l=(t-o)*n;if(l<0||n===0)return;this._startTime=null,r=n*l}r*=this._updateTimeScale(t);let a=this._updateTime(r),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case kht:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulateAdditive(s);break;case $U:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulate(i,s)}}}_updateWeight(t){let r=0;if(this.enabled){r=this.weight;let n=this._weightInterpolant;if(n!==null){let i=n.evaluate(t)[0];r*=i,t>n.parameterPositions[1]&&(this.stopFading(),i===0&&(this.enabled=!1))}}return this._effectiveWeight=r,r}_updateTimeScale(t){let r=0;if(!this.paused){r=this.timeScale;let n=this._timeScaleInterpolant;n!==null&&(r*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),r===0?this.paused=!0:this.timeScale=r))}return this._effectiveTimeScale=r,r}_updateTime(t){let r=this._clip.duration,n=this.loop,i=this.time+t,o=this._loopCount,a=n===Lfe;if(t===0)return o===-1?i:a&&(o&1)===1?r-i:i;if(n===Pfe){o===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=r)i=r;else if(i<0)i=0;else{this.time=i;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(o===-1&&(t>=0?(o=0,this._setEndings(!0,this.repetitions===0,a)):this._setEndings(this.repetitions===0,!0,a)),i>=r||i<0){let s=Math.floor(i/r);i-=r*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?r:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=i;if(a&&(o&1)===1)return r-i}return i}_setEndings(t,r,n){let i=this._interpolantSettings;n?(i.endingStart=C1,i.endingEnd=C1):(t?i.endingStart=this.zeroSlopeAtStart?C1:T1:i.endingStart=JP,r?i.endingEnd=this.zeroSlopeAtEnd?C1:T1:i.endingEnd=JP)}_scheduleFading(t,r,n){let i=this._mixer,o=i.time,a=this._weightInterpolant;a===null&&(a=i._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=r,s[1]=o+t,l[1]=n,this}},VU=class extends qs{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,r){let n=t._localRoot||this._root,i=t._clip.tracks,o=i.length,a=t._propertyBindings,s=t._interpolants,l=n.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==o;++h){let f=i[h],p=f.name,d=u[p];if(d!==void 0)++d.referenceCount,a[h]=d;else{if(d=a[h],d!==void 0){d._cacheIndex===null&&(++d.referenceCount,this._addInactiveBinding(d,l,p));continue}let g=r&&r._propertyBindings[h].binding.parsedPath;d=new BU(Cr.create(n,p,g),f.ValueTypeName,f.getValueSize()),++d.referenceCount,this._addInactiveBinding(d,l,p),a[h]=d}s[h].resultBuffer=d.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let n=(t._localRoot||this._root).uuid,i=t._clip.uuid,o=this._actionsByClip[i];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,i,n)}let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];o.useCount++===0&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.useCount===0&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let r=t._cacheIndex;return r!==null&&r<this._nActiveActions}_addInactiveAction(t,r,n){let i=this._actions,o=this._actionsByClip,a=o[r];if(a===void 0)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[r]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=i.length,i.push(t),a.actionByRoot[n]=t}_removeInactiveAction(t){let r=this._actions,n=r[r.length-1],i=t._cacheIndex;n._cacheIndex=i,r[i]=n,r.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=s.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.referenceCount===0&&this._removeInactiveBinding(o)}}_lendAction(t){let r=this._actions,n=t._cacheIndex,i=this._nActiveActions++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackAction(t){let r=this._actions,n=t._cacheIndex,i=--this._nActiveActions,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_addInactiveBinding(t,r,n){let i=this._bindingsByRootAndName,o=this._bindings,a=i[r];a===void 0&&(a={},i[r]=a),a[n]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let r=this._bindings,n=t.binding,i=n.rootNode.uuid,o=n.path,a=this._bindingsByRootAndName,s=a[i],l=r[r.length-1],c=t._cacheIndex;l._cacheIndex=c,r[c]=l,r.pop(),delete s[o],Object.keys(s).length===0&&delete a[i]}_lendBinding(t){let r=this._bindings,n=t._cacheIndex,i=this._nActiveBindings++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackBinding(t){let r=this._bindings,n=t._cacheIndex,i=--this._nActiveBindings,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_lendControlInterpolant(){let t=this._controlInterpolants,r=this._nActiveControlInterpolants++,n=t[r];return n===void 0&&(n=new S6(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),n.__cacheIndex=r,t[r]=n),n}_takeBackControlInterpolant(t){let r=this._controlInterpolants,n=t.__cacheIndex,i=--this._nActiveControlInterpolants,o=r[i];t.__cacheIndex=i,r[i]=t,o.__cacheIndex=n,r[n]=o}clipAction(t,r,n){let i=r||this._root,o=i.uuid,a=typeof t=="string"?tx.findByName(i,t):t,s=a!==null?a.uuid:t,l=this._actionsByClip[s],c=null;if(n===void 0&&(a!==null?n=a.blendMode:n=$U),l!==void 0){let h=l.actionByRoot[o];if(h!==void 0&&h.blendMode===n)return h;c=l.knownActions[0],a===null&&(a=c._clip)}if(a===null)return null;let u=new fht(this,a,r,n);return this._bindAction(u,c),this._addInactiveAction(u,s,o),u}existingAction(t,r){let n=r||this._root,i=n.uuid,o=typeof t=="string"?tx.findByName(n,t):t,a=o?o.uuid:t,s=this._actionsByClip[a];return s!==void 0&&s.actionByRoot[i]||null}stopAllAction(){let t=this._actions,r=this._nActiveActions;for(let n=r-1;n>=0;--n)t[n].stop();return this}update(t){t*=this.timeScale;let r=this._actions,n=this._nActiveActions,i=this.time+=t,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==n;++c)r[c]._update(i,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let r=0;r<this._actions.length;r++)this._actions[r].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let r=this._actions,n=t.uuid,i=this._actionsByClip,o=i[n];if(o!==void 0){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let u=c._cacheIndex,h=r[r.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,r[u]=h,r.pop(),this._removeInactiveBindingsForAction(c)}delete i[n]}}uncacheRoot(t){let r=t.uuid,n=this._actionsByClip;for(let a in n){let s=n[a].actionByRoot,l=s[r];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let i=this._bindingsByRootAndName,o=i[r];if(o!==void 0)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,r){let n=this.existingAction(t,r);n!==null&&(this._deactivateAction(n),this._removeInactiveAction(n))}};VU.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var gM=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new gM(this.value.clone===void 0?this.value:this.value.clone())}},UU=class extends rm{constructor(t,r,n=1){super(t,r),this.meshPerAttribute=n}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let r=super.clone(t);return r.meshPerAttribute=this.meshPerAttribute,r}toJSON(t){let r=super.toJSON(t);return r.isInstancedInterleavedBuffer=!0,r.meshPerAttribute=this.meshPerAttribute,r}};UU.prototype.isInstancedInterleavedBuffer=!0;var qU=class{constructor(t,r,n,i,o){this.buffer=t,this.type=r,this.itemSize=n,this.elementSize=i,this.count=o,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,r){return this.type=t,this.elementSize=r,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};qU.prototype.isGLBufferAttribute=!0;var pht=class{constructor(t,r,n=0,i=1/0){this.ray=new Qf(t,r),this.near=n,this.far=i,this.camera=null,this.layers=new X3,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}}}set(t,r){this.ray.set(t,r)}setFromCamera(t,r){r&&r.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(r.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(r).sub(this.ray.origin).normalize(),this.camera=r):r&&r.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(r.near+r.far)/(r.near-r.far)).unproject(r),this.ray.direction.set(0,0,-1).transformDirection(r.matrixWorld),this.camera=r):console.error("THREE.Raycaster: Unsupported camera type: "+r.type)}intersectObject(t,r=!0,n=[]){return dht(t,this,n,r),n.sort(Lhe),n}intersectObjects(t,r=!0,n=[]){for(let i=0,o=t.length;i<o;i++)dht(t[i],this,n,r);return n.sort(Lhe),n}};function Lhe(e,t){return e.distance-t.distance}function dht(e,t,r,n){if(e.layers.test(t.layers)&&e.raycast(t,r),n===!0){let i=e.children;for(let o=0,a=i.length;o<a;o++)dht(i[o],t,r,!0)}}var _M=class{constructor(t=1,r=0,n=0){return this.radius=t,this.phi=r,this.theta=n,this}set(t,r,n){return this.radius=t,this.phi=r,this.theta=n,this}copy(t){return this.radius=t.radius,this.phi=t.phi,this.theta=t.theta,this}makeSafe(){return this.phi=Math.max(1e-6,Math.min(Math.PI-1e-6,this.phi)),this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+r*r+n*n),this.radius===0?(this.theta=0,this.phi=0):(this.theta=Math.atan2(t,n),this.phi=Math.acos(Zo(r/this.radius,-1,1))),this}clone(){return new this.constructor().copy(this)}},mht=class{constructor(t=1,r=0,n=0){return this.radius=t,this.theta=r,this.y=n,this}set(t,r,n){return this.radius=t,this.theta=r,this.y=n,this}copy(t){return this.radius=t.radius,this.theta=t.theta,this.y=t.y,this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+n*n),this.theta=Math.atan2(t,n),this.y=r,this}clone(){return new this.constructor().copy(this)}},khe=new Lt,K0=class{constructor(t=new Lt(1/0,1/0),r=new Lt(-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=khe.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return khe.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};K0.prototype.isBox2=!0;var Rhe=new j,YV=new j,GU=class{constructor(t=new j,r=new j){this.start=t,this.end=r}set(t,r){return this.start.copy(t),this.end.copy(r),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,r){return this.delta(r).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,r){Rhe.subVectors(t,this.start),YV.subVectors(this.end,this.start);let n=YV.dot(YV),o=YV.dot(Rhe)/n;return r&&(o=Zo(o,0,1)),o}closestPointToPoint(t,r,n){let i=this.closestPointToPointParameter(t,r);return this.delta(n).multiplyScalar(i).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}},Nhe=new j,ght=class extends or{constructor(t,r){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=r;let n=new Pe,i=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let a=0,s=1,l=32;a<l;a++,s++){let c=a/l*Math.PI*2,u=s/l*Math.PI*2;i.push(Math.cos(c),Math.sin(c),1,Math.cos(u),Math.sin(u),1)}n.setAttribute("position",new xe(i,3));let o=new Gi({fog:!1,toneMapped:!1});this.cone=new Pa(n,o),this.add(this.cone),this.update()}dispose(){this.cone.geometry.dispose(),this.cone.material.dispose()}update(){this.light.updateMatrixWorld();let t=this.light.distance?this.light.distance:1e3,r=t*Math.tan(this.light.angle);this.cone.scale.set(r,r,t),Nhe.setFromMatrixPosition(this.light.target.matrixWorld),this.cone.lookAt(Nhe),this.color!==void 0?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)}},z0=new j,jV=new Me,but=new Me,WU=class extends Pa{constructor(t){let r=ope(t),n=new Pe,i=[],o=[],a=new ne(0,0,1),s=new ne(0,1,0);for(let c=0;c<r.length;c++){let u=r[c];u.parent&&u.parent.isBone&&(i.push(0,0,0),i.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}n.setAttribute("position",new xe(i,3)),n.setAttribute("color",new xe(o,3));let l=new Gi({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(n,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=r,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let r=this.bones,n=this.geometry,i=n.getAttribute("position");but.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<r.length;o++){let s=r[o];s.parent&&s.parent.isBone&&(jV.multiplyMatrices(but,s.matrixWorld),z0.setFromMatrixPosition(jV),i.setXYZ(a,z0.x,z0.y,z0.z),jV.multiplyMatrices(but,s.parent.matrixWorld),z0.setFromMatrixPosition(jV),i.setXYZ(a+1,z0.x,z0.y,z0.z),a+=2)}n.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function ope(e){let t=[];e&&e.isBone&&t.push(e);for(let r=0;r<e.children.length;r++)t.push.apply(t,ope(e.children[r]));return t}var _ht=class extends ti{constructor(t,r,n){let i=new X0(r,4,2),o=new sh({wireframe:!0,fog:!1,toneMapped:!1});super(i,o),this.light=t,this.light.updateMatrixWorld(),this.color=n,this.type="PointLightHelper",this.matrix=this.light.matrixWorld,this.matrixAutoUpdate=!1,this.update()}dispose(){this.geometry.dispose(),this.material.dispose()}update(){this.color!==void 0?this.material.color.set(this.color):this.material.color.copy(this.light.color)}},M0r=new j,Dhe=new ne,Ohe=new ne,yht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n;let i=new Y0(r);i.rotateY(Math.PI*.5),this.material=new sh({wireframe:!0,fog:!1,toneMapped:!1}),this.color===void 0&&(this.material.vertexColors=!0);let o=i.getAttribute("position"),a=new Float32Array(o.count*3);i.setAttribute("color",new Je(a,3)),this.add(new ti(i,this.material)),this.update()}dispose(){this.children[0].geometry.dispose(),this.children[0].material.dispose()}update(){let t=this.children[0];if(this.color!==void 0)this.material.color.set(this.color);else{let r=t.geometry.getAttribute("color");Dhe.copy(this.light.color),Ohe.copy(this.light.groundColor);for(let n=0,i=r.count;n<i;n++){let o=n<i/2?Dhe:Ohe;r.setXYZ(n,o.r,o.g,o.b)}r.needsUpdate=!0}t.lookAt(M0r.setFromMatrixPosition(this.light.matrixWorld).negate())}},YU=class extends Pa{constructor(t=10,r=10,n=4473924,i=8947848){n=new ne(n),i=new ne(i);let o=r/2,a=t/r,s=t/2,l=[],c=[];for(let f=0,p=0,d=-s;f<=r;f++,d+=a){l.push(-s,0,d,s,0,d),l.push(d,0,-s,d,0,s);let g=f===o?n:i;g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3}let u=new Pe;u.setAttribute("position",new xe(l,3)),u.setAttribute("color",new xe(c,3));let h=new Gi({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}},vht=class extends Pa{constructor(t=10,r=16,n=8,i=64,o=4473924,a=8947848){o=new ne(o),a=new ne(a);let s=[],l=[];for(let h=0;h<=r;h++){let f=h/r*(Math.PI*2),p=Math.sin(f)*t,d=Math.cos(f)*t;s.push(0,0,0),s.push(p,0,d);let g=h&1?o:a;l.push(g.r,g.g,g.b),l.push(g.r,g.g,g.b)}for(let h=0;h<=n;h++){let f=h&1?o:a,p=t-t/n*h;for(let d=0;d<i;d++){let g=d/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p;s.push(_,0,y),l.push(f.r,f.g,f.b),g=(d+1)/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p,s.push(_,0,y),l.push(f.r,f.g,f.b)}}let c=new Pe;c.setAttribute("position",new xe(s,3)),c.setAttribute("color",new xe(l,3));let u=new Gi({vertexColors:!0,toneMapped:!1});super(c,u),this.type="PolarGridHelper"}},zhe=new j,XV=new j,Fhe=new j,xht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,r===void 0&&(r=1);let i=new Pe;i.setAttribute("position",new xe([-r,r,0,r,r,0,r,-r,0,-r,-r,0,-r,r,0],3));let o=new Gi({fog:!1,toneMapped:!1});this.lightPlane=new ch(i,o),this.add(this.lightPlane),i=new Pe,i.setAttribute("position",new xe([0,0,0,0,0,1],3)),this.targetLine=new ch(i,o),this.add(this.targetLine),this.update()}dispose(){this.lightPlane.geometry.dispose(),this.lightPlane.material.dispose(),this.targetLine.geometry.dispose(),this.targetLine.material.dispose()}update(){zhe.setFromMatrixPosition(this.light.matrixWorld),XV.setFromMatrixPosition(this.light.target.matrixWorld),Fhe.subVectors(XV,zhe),this.lightPlane.lookAt(XV),this.color!==void 0?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color)),this.targetLine.lookAt(XV),this.targetLine.scale.z=Fhe.length()}},$V=new j,_i=new N1,bht=class extends Pa{constructor(t){let r=new Pe,n=new Gi({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],o=[],a={},s=new ne(16755200),l=new ne(16711680),c=new ne(43775),u=new ne(16777215),h=new ne(3355443);f("n1","n2",s),f("n2","n4",s),f("n4","n3",s),f("n3","n1",s),f("f1","f2",s),f("f2","f4",s),f("f4","f3",s),f("f3","f1",s),f("n1","f1",s),f("n2","f2",s),f("n3","f3",s),f("n4","f4",s),f("p","n1",l),f("p","n2",l),f("p","n3",l),f("p","n4",l),f("u1","u2",c),f("u2","u3",c),f("u3","u1",c),f("c","t",u),f("p","c",h),f("cn1","cn2",h),f("cn3","cn4",h),f("cf1","cf2",h),f("cf3","cf4",h);function f(d,g,_){p(d,_),p(g,_)}function p(d,g){i.push(0,0,0),o.push(g.r,g.g,g.b),a[d]===void 0&&(a[d]=[]),a[d].push(i.length/3-1)}r.setAttribute("position",new xe(i,3)),r.setAttribute("color",new xe(o,3)),super(r,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=a,this.update()}update(){let t=this.geometry,r=this.pointMap,n=1,i=1;_i.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),Pi("c",r,t,_i,0,0,-1),Pi("t",r,t,_i,0,0,1),Pi("n1",r,t,_i,-n,-i,-1),Pi("n2",r,t,_i,n,-i,-1),Pi("n3",r,t,_i,-n,i,-1),Pi("n4",r,t,_i,n,i,-1),Pi("f1",r,t,_i,-n,-i,1),Pi("f2",r,t,_i,n,-i,1),Pi("f3",r,t,_i,-n,i,1),Pi("f4",r,t,_i,n,i,1),Pi("u1",r,t,_i,n*.7,i*1.1,-1),Pi("u2",r,t,_i,-n*.7,i*1.1,-1),Pi("u3",r,t,_i,0,i*2,-1),Pi("cf1",r,t,_i,-n,0,1),Pi("cf2",r,t,_i,n,0,1),Pi("cf3",r,t,_i,0,-i,1),Pi("cf4",r,t,_i,0,i,1),Pi("cn1",r,t,_i,-n,0,-1),Pi("cn2",r,t,_i,n,0,-1),Pi("cn3",r,t,_i,0,-i,-1),Pi("cn4",r,t,_i,0,i,-1),t.getAttribute("position").needsUpdate=!0}dispose(){this.geometry.dispose(),this.material.dispose()}};function Pi(e,t,r,n,i,o,a){$V.set(i,o,a).unproject(n);let s=t[e];if(s!==void 0){let l=r.getAttribute("position");for(let c=0,u=s.length;c<u;c++)l.setXYZ(s[c],$V.x,$V.y,$V.z)}}var KV=new ta,yM=class extends Pa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(8*3),o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new Je(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(t!==void 0&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),this.object!==void 0&&KV.setFromObject(this.object),KV.isEmpty())return;let r=KV.min,n=KV.max,i=this.geometry.attributes.position,o=i.array;o[0]=n.x,o[1]=n.y,o[2]=n.z,o[3]=r.x,o[4]=n.y,o[5]=n.z,o[6]=r.x,o[7]=r.y,o[8]=n.z,o[9]=n.x,o[10]=r.y,o[11]=n.z,o[12]=n.x,o[13]=n.y,o[14]=r.z,o[15]=r.x,o[16]=n.y,o[17]=r.z,o[18]=r.x,o[19]=r.y,o[20]=r.z,o[21]=n.x,o[22]=r.y,o[23]=r.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t){return Pa.prototype.copy.call(this,t),this.object=t.object,this}},wht=class extends Pa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=[1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new xe(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){let r=this.box;r.isEmpty()||(r.getCenter(this.position),r.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}},Sht=class extends ch{constructor(t,r=1,n=16776960){let i=n,o=[1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],a=new Pe;a.setAttribute("position",new xe(o,3)),a.computeBoundingSphere(),super(a,new Gi({color:i,toneMapped:!1})),this.type="PlaneHelper",this.plane=t,this.size=r;let s=[1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],l=new Pe;l.setAttribute("position",new xe(s,3)),l.computeBoundingSphere(),this.add(new ti(l,new sh({color:i,opacity:.2,transparent:!0,depthWrite:!1,toneMapped:!1})))}updateMatrixWorld(t){let r=-this.plane.constant;Math.abs(r)<1e-8&&(r=1e-8),this.scale.set(.5*this.size,.5*this.size,r),this.children[0].material.side=r<0?Ii:L1,this.lookAt(this.plane.normal),super.updateMatrixWorld(t)}},Bhe=new j,ZV,wut,Mht=class extends or{constructor(t=new j(0,0,1),r=new j(0,0,0),n=1,i=16776960,o=n*.2,a=o*.2){super(),this.type="ArrowHelper",ZV===void 0&&(ZV=new Pe,ZV.setAttribute("position",new xe([0,0,0,0,1,0],3)),wut=new am(0,.5,1,5,1),wut.translate(0,-.5,0)),this.position.copy(r),this.line=new ch(ZV,new Gi({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new ti(wut,new sh({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,o,a)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{Bhe.set(t.z,0,-t.x).normalize();let r=Math.acos(t.y);this.quaternion.setFromAxisAngle(Bhe,r)}}setLength(t,r=t*.2,n=r*.2){this.line.scale.set(1,Math.max(1e-4,t-r),1),this.line.updateMatrix(),this.cone.scale.set(n,r,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}},vM=class extends Pa{constructor(t=1){let r=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],n=[1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],i=new Pe;i.setAttribute("position",new xe(r,3)),i.setAttribute("color",new xe(n,3));let o=new Gi({vertexColors:!0,toneMapped:!1});super(i,o),this.type="AxesHelper"}setColors(t,r,n){let i=new ne,o=this.geometry.attributes.color.array;return i.set(t),i.toArray(o,0),i.toArray(o,3),i.set(r),i.toArray(o,6),i.toArray(o,9),i.set(n),i.toArray(o,12),i.toArray(o,15),this.geometry.attributes.color.needsUpdate=!0,this}dispose(){this.geometry.dispose(),this.material.dispose()}},Eht=class{constructor(){this.type="ShapePath",this.color=new ne,this.subPaths=[],this.currentPath=null}moveTo(t,r){return this.currentPath=new G1,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,r),this}lineTo(t,r){return this.currentPath.lineTo(t,r),this}quadraticCurveTo(t,r,n,i){return this.currentPath.quadraticCurveTo(t,r,n,i),this}bezierCurveTo(t,r,n,i,o,a){return this.currentPath.bezierCurveTo(t,r,n,i,o,a),this}splineThru(t){return this.currentPath.splineThru(t),this}toShapes(t,r){function n(x){let b=[];for(let S=0,C=x.length;S<C;S++){let P=x[S],k=new Kc;k.curves=P.curves,b.push(k)}return b}function i(x,b){let S=b.length,C=!1;for(let P=S-1,k=0;k<S;P=k++){let O=b[P],D=b[k],B=D.x-O.x,I=D.y-O.y;if(Math.abs(I)>Number.EPSILON){if(I<0&&(O=b[k],B=-B,D=b[P],I=-I),x.y<O.y||x.y>D.y)continue;if(x.y===O.y){if(x.x===O.x)return!0}else{let L=I*(x.x-O.x)-B*(x.y-O.y);if(L===0)return!0;if(L<0)continue;C=!C}}else{if(x.y!==O.y)continue;if(D.x<=x.x&&x.x<=O.x||O.x<=x.x&&x.x<=D.x)return!0}}return C}let o=Zc.isClockWise,a=this.subPaths;if(a.length===0)return[];if(r===!0)return n(a);let s,l,c,u=[];if(a.length===1)return l=a[0],c=new Kc,c.curves=l.curves,u.push(c),u;let h=!o(a[0].getPoints());h=t?!h:h;let f=[],p=[],d=[],g=0,_;p[g]=void 0,d[g]=[];for(let x=0,b=a.length;x<b;x++)l=a[x],_=l.getPoints(),s=o(_),s=t?!s:s,s?(!h&&p[g]&&g++,p[g]={s:new Kc,p:_},p[g].s.curves=l.curves,h&&g++,d[g]=[]):d[g].push({h:l,p:_[0]});if(!p[0])return n(a);if(p.length>1){let x=!1,b=[];for(let S=0,C=p.length;S<C;S++)f[S]=[];for(let S=0,C=p.length;S<C;S++){let P=d[S];for(let k=0;k<P.length;k++){let O=P[k],D=!0;for(let B=0;B<p.length;B++)i(O.p,p[B].p)&&(S!==B&&b.push({froms:S,tos:B,hole:k}),D?(D=!1,f[B].push(O)):x=!0);D&&f[S].push(O)}}b.length>0&&(x||(d=f))}let y;for(let x=0,b=p.length;x<b;x++){c=p[x].s,u.push(c),y=d[x];for(let S=0,C=y.length;S<C;S++)c.holes.push(y[S].h)}return u}},ape=new Float32Array(1),E0r=new Int32Array(ape.buffer),Tht=class{static toHalfFloat(t){t>65504&&(console.warn("THREE.DataUtils.toHalfFloat(): value exceeds 65504."),t=65504),ape[0]=t;let r=E0r[0],n=r>>16&32768,i=r>>12&2047,o=r>>23&255;return o<103?n:o>142?(n|=31744,n|=(o==255?0:1)&&r&8388607,n):o<113?(i|=2048,n|=(i>>114-o)+(i>>113-o&1),n):(n|=o-112<<10|i>>1,n+=i&1,n)}},T0r=0,C0r=1,A0r=0,P0r=1,I0r=2;function L0r(e){return console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead."),e}function k0r(e=[]){return console.warn("THREE.MultiMaterial has been removed. Use an Array instead."),e.isMultiMaterial=!0,e.materials=e,e.clone=function(){return e.slice()},e}function R0r(e,t){return console.warn("THREE.PointCloud has been renamed to THREE.Points."),new om(e,t)}function N0r(e){return console.warn("THREE.Particle has been renamed to THREE.Sprite."),new oM(e)}function D0r(e,t){return console.warn("THREE.ParticleSystem has been renamed to THREE.Points."),new om(e,t)}function O0r(e){return console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial."),new im(e)}function z0r(e){return console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial."),new im(e)}function F0r(e){return console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial."),new im(e)}function B0r(e,t,r){return console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead."),new j(e,t,r)}function H0r(e,t){return console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead."),new Je(e,t).setUsage(Y3)}function V0r(e,t){return console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead."),new cU(e,t)}function U0r(e,t){return console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead."),new uU(e,t)}function q0r(e,t){return console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead."),new hU(e,t)}function G0r(e,t){return console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead."),new fU(e,t)}function W0r(e,t){return console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead."),new $3(e,t)}function Y0r(e,t){return console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead."),new pU(e,t)}function j0r(e,t){return console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead."),new K3(e,t)}function X0r(e,t){return console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead."),new xe(e,t)}function $0r(e,t){return console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead."),new mU(e,t)}ps.create=function(e,t){return console.log("THREE.Curve.create() has been deprecated"),e.prototype=Object.create(ps.prototype),e.prototype.constructor=e,e.prototype.getPoint=t,e};G1.prototype.fromPoints=function(e){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(e)};function K0r(e){return console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper."),new vM(e)}function Z0r(e,t){return console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead."),new yM(e,t)}function J0r(e,t){return console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead."),new Pa(new s6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}YU.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};WU.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};function Q0r(e,t){return console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead."),new Pa(new d6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}ea.prototype.extractUrlBase=function(e){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),dM.extractUrlBase(e)};ea.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};function t_r(e){return console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader."),new Jc(e)}function e_r(e){return console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader."),new CU(e)}K0.prototype.center=function(e){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(e)};K0.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};K0.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};K0.prototype.size=function(e){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(e)};ta.prototype.center=function(e){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ta.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};ta.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};ta.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};ta.prototype.size=function(e){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(e)};Jf.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};D1.prototype.setFromMatrix=function(e){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(e)};GU.prototype.center=function(e){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ki.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};ki.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};ki.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};ki.prototype.getInverse=function(e){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};Me.prototype.extractPosition=function(e){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(e)};Me.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};Me.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new j().setFromMatrixColumn(this,3)};Me.prototype.setRotationFromQuaternion=function(e){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(e)};Me.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};Me.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector4=function(e){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};Me.prototype.rotateAxis=function(e){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),e.transformDirection(this)};Me.prototype.crossVector=function(e){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};Me.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};Me.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};Me.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};Me.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};Me.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};Me.prototype.makeFrustum=function(e,t,r,n,i,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(e,t,n,r,i,o)};Me.prototype.getInverse=function(e){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};$c.prototype.isIntersectionLine=function(e){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(e)};yi.prototype.multiplyVector3=function(e){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),e.applyQuaternion(this)};yi.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};Qf.prototype.isIntersectionBox=function(e){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};Qf.prototype.isIntersectionPlane=function(e){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(e)};Qf.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};oi.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};oi.prototype.barycoordFromPoint=function(e,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(e,t)};oi.prototype.midpoint=function(e){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(e)};oi.prototypenormal=function(e){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(e)};oi.prototype.plane=function(e){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(e)};oi.barycoordFromPoint=function(e,t,r,n,i){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),oi.getBarycoord(e,t,r,n,i)};oi.normal=function(e,t,r,n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),oi.getNormal(e,t,r,n)};Kc.prototype.extractAllPoints=function(e){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(e)};Kc.prototype.extrude=function(e){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new hh(this,e)};Kc.prototype.makeGeometry=function(e){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new j0(this,e)};Lt.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};Lt.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};Lt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};j.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};j.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};j.prototype.getPositionFromMatrix=function(e){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(e)};j.prototype.getScaleFromMatrix=function(e){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(e)};j.prototype.getColumnFromMatrix=function(e,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,e)};j.prototype.applyProjection=function(e){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(e)};j.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};j.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};j.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};en.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};en.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};or.prototype.getChildByName=function(e){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(e)};or.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};or.prototype.translate=function(e,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,e)};or.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};or.prototype.applyMatrix=function(e){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(or.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(e){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=e}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});ti.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(ti.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),kfe},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});aM.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Ui.prototype.setLens=function(e,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(e)};Object.defineProperties(zl.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(e){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=e}},shadowCameraLeft:{set:function(e){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=e}},shadowCameraRight:{set:function(e){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=e}},shadowCameraTop:{set:function(e){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=e}},shadowCameraBottom:{set:function(e){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=e}},shadowCameraNear:{set:function(e){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=e}},shadowCameraFar:{set:function(e){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=e}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(e){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=e}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(e){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=e}},shadowMapHeight:{set:function(e){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=e}}});Object.defineProperties(Je.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===Y3},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(Y3)}}});Je.prototype.setDynamic=function(e){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};Je.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Je.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Pe.prototype.addIndex=function(e){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(e)};Pe.prototype.addAttribute=function(e,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(e,new Je(arguments[1],arguments[2]))):e==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(e,t)};Pe.prototype.addDrawCall=function(e,t,r){r!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(e,t)};Pe.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Pe.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Pe.prototype.removeAttribute=function(e){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(e)};Pe.prototype.applyMatrix=function(e){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(Pe.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});rm.prototype.setDynamic=function(e){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};rm.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};hh.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};hh.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};hh.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};G0.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};gM.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(qi.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ne}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=e===Aht}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(e){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=e}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(lh.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(e){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=e}}});rn.prototype.clearTarget=function(e,t,r,n){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(e),this.clear(t,r,n)};rn.prototype.animate=function(e){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(e)};rn.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};rn.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};rn.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};rn.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};rn.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};rn.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};rn.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};rn.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};rn.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};rn.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};rn.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};rn.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};rn.prototype.enableScissorTest=function(e){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(e)};rn.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};rn.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};rn.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};rn.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};rn.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};rn.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};rn.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};rn.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};rn.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};rn.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(rn.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=e}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=e}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(e){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=e===!0?Yn:tm}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(Jfe.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});function r_r(e,t,r){return console.warn("THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options )."),new Q3(e,r)}Object.defineProperties(hs.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=e}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=e}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=e}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=e}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(e){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=e}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(e){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=e}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(e){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=e}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(e){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=e}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(e){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=e}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(e){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=e}}});D6.prototype.load=function(e){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new DU().load(e,function(n){t.setBuffer(n)}),this};FU.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};J3.prototype.updateCubeMap=function(e,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(e,t)};J3.prototype.clear=function(e,t,r,n){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(e,t,r,n)};Zf.crossOrigin=void 0;Zf.loadTexture=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let i=new AU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Zf.loadTextureCube=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let i=new TU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Zf.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Zf.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};function n_r(){console.error("THREE.CanvasRenderer has been removed")}function i_r(){console.error("THREE.JSONLoader has been removed.")}var o_r={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")}};function a_r(){console.error("THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js")}function s_r(){return console.error("THREE.ParametricGeometry has been moved to /examples/jsm/geometries/ParametricGeometry.js"),new Pe}function l_r(){return console.error("THREE.TextGeometry has been moved to /examples/jsm/geometries/TextGeometry.js"),new Pe}function c_r(){console.error("THREE.FontLoader has been moved to /examples/jsm/loaders/FontLoader.js")}function u_r(){console.error("THREE.Font has been moved to /examples/jsm/loaders/FontLoader.js")}function h_r(){console.error("THREE.ImmediateRenderObject has been removed.")}typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:jU}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=jU);var spe={type:"change"},Hht={type:"start"},lpe={type:"end"},JU=class extends qs{constructor(t,r){super(),r===void 0&&console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.'),r===document&&console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'),this.object=t,this.domElement=r,this.domElement.style.touchAction="none",this.enabled=!0,this.target=new j,this.minDistance=0,this.maxDistance=1/0,this.minZoom=0,this.maxZoom=1/0,this.minPolarAngle=0,this.maxPolarAngle=Math.PI,this.minAzimuthAngle=-1/0,this.maxAzimuthAngle=1/0,this.enableDamping=!1,this.dampingFactor=.05,this.enableZoom=!0,this.zoomSpeed=1,this.enableRotate=!0,this.rotateSpeed=1,this.enablePan=!0,this.panSpeed=1,this.screenSpacePanning=!0,this.keyPanSpeed=7,this.autoRotate=!1,this.autoRotateSpeed=2,this.keys={LEFT:"ArrowLeft",UP:"ArrowUp",RIGHT:"ArrowRight",BOTTOM:"ArrowDown"},this.mouseButtons={LEFT:Z0.ROTATE,MIDDLE:Z0.DOLLY,RIGHT:Z0.PAN},this.touches={ONE:J0.ROTATE,TWO:J0.DOLLY_PAN},this.target0=this.target.clone(),this.position0=this.object.position.clone(),this.zoom0=this.object.zoom,this._domElementKeyEvents=null,this.getPolarAngle=function(){return s.phi},this.getAzimuthalAngle=function(){return s.theta},this.getDistance=function(){return this.object.position.distanceTo(this.target)},this.listenToKeyEvents=function(nt){nt.addEventListener("keydown",fr),this._domElementKeyEvents=nt},this.saveState=function(){n.target0.copy(n.target),n.position0.copy(n.object.position),n.zoom0=n.object.zoom},this.reset=function(){n.target.copy(n.target0),n.object.position.copy(n.position0),n.object.zoom=n.zoom0,n.object.updateProjectionMatrix(),n.dispatchEvent(spe),n.update(),o=i.NONE},this.update=function(){let nt=new j,Ct=new yi().setFromUnitVectors(t.up,new j(0,1,0)),Wt=Ct.clone().invert(),fe=new j,at=new yi,se=2*Math.PI;return function(){let Ce=n.object.position;nt.copy(Ce).sub(n.target),nt.applyQuaternion(Ct),s.setFromVector3(nt),n.autoRotate&&o===i.NONE&&D(k()),n.enableDamping?(s.theta+=l.theta*n.dampingFactor,s.phi+=l.phi*n.dampingFactor):(s.theta+=l.theta,s.phi+=l.phi);let Pt=n.minAzimuthAngle,Nt=n.maxAzimuthAngle;return isFinite(Pt)&&isFinite(Nt)&&(Pt<-Math.PI?Pt+=se:Pt>Math.PI&&(Pt-=se),Nt<-Math.PI?Nt+=se:Nt>Math.PI&&(Nt-=se),Pt<=Nt?s.theta=Math.max(Pt,Math.min(Nt,s.theta)):s.theta=s.theta>(Pt+Nt)/2?Math.max(Pt,s.theta):Math.min(Nt,s.theta)),s.phi=Math.max(n.minPolarAngle,Math.min(n.maxPolarAngle,s.phi)),s.makeSafe(),s.radius*=c,s.radius=Math.max(n.minDistance,Math.min(n.maxDistance,s.radius)),n.enableDamping===!0?n.target.addScaledVector(u,n.dampingFactor):n.target.add(u),nt.setFromSpherical(s),nt.applyQuaternion(Wt),Ce.copy(n.target).add(nt),n.object.lookAt(n.target),n.enableDamping===!0?(l.theta*=1-n.dampingFactor,l.phi*=1-n.dampingFactor,u.multiplyScalar(1-n.dampingFactor)):(l.set(0,0,0),u.set(0,0,0)),c=1,h||fe.distanceToSquared(n.object.position)>a||8*(1-at.dot(n.object.quaternion))>a?(n.dispatchEvent(spe),fe.copy(n.object.position),at.copy(n.object.quaternion),h=!1,!0):!1}}(),this.dispose=function(){n.domElement.removeEventListener("contextmenu",It),n.domElement.removeEventListener("pointerdown",ht),n.domElement.removeEventListener("pointercancel",ie),n.domElement.removeEventListener("wheel",ar),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt),n._domElementKeyEvents!==null&&n._domElementKeyEvents.removeEventListener("keydown",fr)};let n=this,i={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},o=i.NONE,a=1e-6,s=new _M,l=new _M,c=1,u=new j,h=!1,f=new Lt,p=new Lt,d=new Lt,g=new Lt,_=new Lt,y=new Lt,x=new Lt,b=new Lt,S=new Lt,C=[],P={};function k(){return 2*Math.PI/60/60*n.autoRotateSpeed}function O(){return Math.pow(.95,n.zoomSpeed)}function D(nt){l.theta-=nt}function B(nt){l.phi-=nt}let I=function(){let nt=new j;return function(Wt,fe){nt.setFromMatrixColumn(fe,0),nt.multiplyScalar(-Wt),u.add(nt)}}(),L=function(){let nt=new j;return function(Wt,fe){n.screenSpacePanning===!0?nt.setFromMatrixColumn(fe,1):(nt.setFromMatrixColumn(fe,0),nt.crossVectors(n.object.up,nt)),nt.multiplyScalar(Wt),u.add(nt)}}(),R=function(){let nt=new j;return function(Wt,fe){let at=n.domElement;if(n.object.isPerspectiveCamera){let se=n.object.position;nt.copy(se).sub(n.target);let Qt=nt.length();Qt*=Math.tan(n.object.fov/2*Math.PI/180),I(2*Wt*Qt/at.clientHeight,n.object.matrix),L(2*fe*Qt/at.clientHeight,n.object.matrix)}else n.object.isOrthographicCamera?(I(Wt*(n.object.right-n.object.left)/n.object.zoom/at.clientWidth,n.object.matrix),L(fe*(n.object.top-n.object.bottom)/n.object.zoom/at.clientHeight,n.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),n.enablePan=!1)}}();function F(nt){n.object.isPerspectiveCamera?c/=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom*nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function z(nt){n.object.isPerspectiveCamera?c*=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom/nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function U(nt){f.set(nt.clientX,nt.clientY)}function W(nt){x.set(nt.clientX,nt.clientY)}function Z(nt){g.set(nt.clientX,nt.clientY)}function rt(nt){p.set(nt.clientX,nt.clientY),d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p),n.update()}function ot(nt){b.set(nt.clientX,nt.clientY),S.subVectors(b,x),S.y>0?F(O()):S.y<0&&z(O()),x.copy(b),n.update()}function st(nt){_.set(nt.clientX,nt.clientY),y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_),n.update()}function St(nt){nt.deltaY<0?z(O()):nt.deltaY>0&&F(O()),n.update()}function bt(nt){let Ct=!1;switch(nt.code){case n.keys.UP:R(0,n.keyPanSpeed),Ct=!0;break;case n.keys.BOTTOM:R(0,-n.keyPanSpeed),Ct=!0;break;case n.keys.LEFT:R(n.keyPanSpeed,0),Ct=!0;break;case n.keys.RIGHT:R(-n.keyPanSpeed,0),Ct=!0;break}Ct&&(nt.preventDefault(),n.update())}function Mt(){if(C.length===1)f.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);f.set(nt,Ct)}}function lt(){if(C.length===1)g.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);g.set(nt,Ct)}}function Kt(){let nt=C[0].pageX-C[1].pageX,Ct=C[0].pageY-C[1].pageY,Wt=Math.sqrt(nt*nt+Ct*Ct);x.set(0,Wt)}function _t(){n.enableZoom&&Kt(),n.enablePan&&lt()}function ct(){n.enableZoom&&Kt(),n.enableRotate&&Mt()}function X(nt){if(C.length==1)p.set(nt.pageX,nt.pageY);else{let Wt=be(nt),fe=.5*(nt.pageX+Wt.x),at=.5*(nt.pageY+Wt.y);p.set(fe,at)}d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p)}function et(nt){if(C.length===1)_.set(nt.pageX,nt.pageY);else{let Ct=be(nt),Wt=.5*(nt.pageX+Ct.x),fe=.5*(nt.pageY+Ct.y);_.set(Wt,fe)}y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_)}function dt(nt){let Ct=be(nt),Wt=nt.pageX-Ct.x,fe=nt.pageY-Ct.y,at=Math.sqrt(Wt*Wt+fe*fe);b.set(0,at),S.set(0,Math.pow(b.y/x.y,n.zoomSpeed)),F(S.y),x.copy(b)}function q(nt){n.enableZoom&&dt(nt),n.enablePan&&et(nt)}function pt(nt){n.enableZoom&&dt(nt),n.enableRotate&&X(nt)}function ht(nt){n.enabled!==!1&&(C.length===0&&(n.domElement.setPointerCapture(nt.pointerId),n.domElement.addEventListener("pointermove",wt),n.domElement.addEventListener("pointerup",kt)),$t(nt),nt.pointerType==="touch"?tt(nt):ee(nt))}function wt(nt){n.enabled!==!1&&(nt.pointerType==="touch"?$(nt):Le(nt))}function kt(nt){he(nt),C.length===0&&(n.domElement.releasePointerCapture(nt.pointerId),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt)),n.dispatchEvent(lpe),o=i.NONE}function ie(nt){he(nt)}function ee(nt){let Ct;switch(nt.button){case 0:Ct=n.mouseButtons.LEFT;break;case 1:Ct=n.mouseButtons.MIDDLE;break;case 2:Ct=n.mouseButtons.RIGHT;break;default:Ct=-1}switch(Ct){case Z0.DOLLY:if(n.enableZoom===!1)return;W(nt),o=i.DOLLY;break;case Z0.ROTATE:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enablePan===!1)return;Z(nt),o=i.PAN}else{if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}break;case Z0.PAN:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}else{if(n.enablePan===!1)return;Z(nt),o=i.PAN}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function Le(nt){if(n.enabled!==!1)switch(o){case i.ROTATE:if(n.enableRotate===!1)return;rt(nt);break;case i.DOLLY:if(n.enableZoom===!1)return;ot(nt);break;case i.PAN:if(n.enablePan===!1)return;st(nt);break}}function ar(nt){n.enabled===!1||n.enableZoom===!1||o!==i.NONE||(nt.preventDefault(),n.dispatchEvent(Hht),St(nt),n.dispatchEvent(lpe))}function fr(nt){n.enabled===!1||n.enablePan===!1||bt(nt)}function tt(nt){switch(Tt(nt),C.length){case 1:switch(n.touches.ONE){case J0.ROTATE:if(n.enableRotate===!1)return;Mt(),o=i.TOUCH_ROTATE;break;case J0.PAN:if(n.enablePan===!1)return;lt(),o=i.TOUCH_PAN;break;default:o=i.NONE}break;case 2:switch(n.touches.TWO){case J0.DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;_t(),o=i.TOUCH_DOLLY_PAN;break;case J0.DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;ct(),o=i.TOUCH_DOLLY_ROTATE;break;default:o=i.NONE}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Hht)}function $(nt){switch(Tt(nt),o){case i.TOUCH_ROTATE:if(n.enableRotate===!1)return;X(nt),n.update();break;case i.TOUCH_PAN:if(n.enablePan===!1)return;et(nt),n.update();break;case i.TOUCH_DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;q(nt),n.update();break;case i.TOUCH_DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;pt(nt),n.update();break;default:o=i.NONE}}function It(nt){n.enabled!==!1&&nt.preventDefault()}function $t(nt){C.push(nt)}function he(nt){delete P[nt.pointerId];for(let Ct=0;Ct<C.length;Ct++)if(C[Ct].pointerId==nt.pointerId){C.splice(Ct,1);return}}function Tt(nt){let Ct=P[nt.pointerId];Ct===void 0&&(Ct=new Lt,P[nt.pointerId]=Ct),Ct.set(nt.pageX,nt.pageY)}function be(nt){let Ct=nt.pointerId===C[0].pointerId?C[1]:C[0];return P[Ct.pointerId]}n.domElement.addEventListener("contextmenu",It),n.domElement.addEventListener("pointerdown",ht),n.domElement.addEventListener("pointercancel",ie),n.domElement.addEventListener("wheel",ar,{passive:!1}),this.update()}};var F6=class extends qs{constructor(t){super(),this._lastMesh=null,this._clock=new mM,this._canvasSize=null,this._layersConfig=null,this._runColor=t}_isObject(t){var r=typeof t;return r=="object"&&t!=null&&!Array.isArray(t)}_applyDefaults(t,r){let n={},i=[t,r];for(let o=0;o<i.length;o++){let a=i[o];for(let s in a){let l=s in n;this._isObject(a[s])?n[s]=this._applyDefaults(n[s]||{},a[s]):l||(n[s]=a[s])}}return n}_createLayers(){if(!(!this._layersConfig||!this._scene||!this._lastMesh)){if(this._layersConfig.showBoundingBox){var t=new yM(this._lastMesh,new ne("rgb(0, 0, 255)"));this._scene.add(t)}if(this._layersConfig.showAxes){var r=new vM(5);this._scene.add(r)}}}setLayersConfig(t){this._layersConfig=this._applyDefaults(t,this._layersConfig||{})}_createWorld(t,r){var a,s,l,c;if(this.isReady())return;this._scene=new G0;var n=new wM[t.camera.cls](t.camera.fov,((a=this._canvasSize)==null?void 0:a.width)/((s=this._canvasSize)==null?void 0:s.height),t.camera.near,t.camera.far);this._camera=n,this.initCameraPosition=void 0,t.camera.position&&(this.initCameraPosition=new j().fromArray(t.camera.position)),this.initCameraLookAt=void 0,t.camera.lookAt&&(this.initCameraLookAt=new j().fromArray(t.camera.lookAt));var i=new JU(n,r);let o=i;o.lookSpeed=.4,o.movementSpeed=20,o.noFly=!0,o.lookVertical=!0,o.constrainVertical=!0,o.verticalMin=1,o.verticalMax=2,o.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=i,this._renderer=new rn({antialias:!0}),this._renderer.setPixelRatio(window.devicePixelRatio),this._renderer.setSize((l=this._canvasSize)==null?void 0:l.width,(c=this._canvasSize)==null?void 0:c.height),this._renderer.setClearColor(16777215,1)}_clearScene(){var t;if(this._scene)for(;this._scene.children.length>0;)this._scene.remove((t=this._scene)==null?void 0:t.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){var t,r,n;return{far:(t=this._camera)==null?void 0:t.far,position:(r=this._camera)==null?void 0:r.position.clone(),target:(n=this._cameraControls)==null?void 0:n.target.clone()}}setCanvasSize(t){this._canvasSize=t}draw(){var r,n,i,o;this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex),this._camera&&(this._camera.aspect=((r=this._canvasSize)==null?void 0:r.width)/((n=this._canvasSize)==null?void 0:n.height),this._camera.updateProjectionMatrix()),this._renderer.setSize((i=this._canvasSize)==null?void 0:i.width,(o=this._canvasSize)==null?void 0:o.height);let t=function(){var a=this._clock.getDelta();this._cameraControls.update(a),this._animationFrameIndex=requestAnimationFrame(t),this._renderer.render(this._scene,this._camera)}.bind(this);t()}updateScene(t,r){let n={};"config"in t&&t.config&&(n=JSON.parse(t.config)),this.dispatchEvent({type:"beforeUpdateScene"});let i={camera:{cls:"PerspectiveCamera",fov:75,near:.1,far:1e3},lights:[{cls:"AmbientLight",color:"#ffffff",intensity:.75},{cls:"DirectionalLight",color:"#ffffff",intensity:.75,position:[0,-1,2]}]};n=this._applyDefaults(n,i),this._createWorld(n,r),this._clearScene(),this._createLights(this._scene,n),this._createGeometry(t,n),this._createLayers(),this.draw()}resetView(t){var n,i;if(!this.isReady())return;(n=this._cameraControls)==null||n.reset();let r;!t&&this._lastMesh&&(r=this._lastMesh),r&&(this._fitObjectToViewport(r),this._lastMesh=r),(i=this._cameraControls)==null||i.update()}_createGeometry(t,r){let n=t.mesh;n.vertices&&n.faces&&n.faces.length?this._createMesh(n,r):this._createPointCloud(n,r)}_createPointCloud(t,r){var h;let n=t.vertices,i=t.colors,o={material:{cls:"PointsMaterial",size:.005}};i&&i.length==n.length?o.material.vertexColors=!0:o.material.color=this._runColor;let a=this._applyDefaults(r,o),s=new Pe,l=new Float32Array(n.flat());if(s.setAttribute("position",new Je(l,3)),i&&i.length==n.length){let f=new Float32Array(i.flat());for(let p=0;p<f.length;p++)f[p]=f[p]/255;s.setAttribute("color",new Je(f,3))}var c=new wM[a.material.cls](a.material),u=new om(s,c);(h=this._scene)==null||h.add(u),this._lastMesh=u}setCameraViewpoint(t,r,n){this._silent=!0,this._camera&&(this._camera.far=r,this._camera.position.set(t.x,t.y,t.z),this._camera.lookAt(n.clone()),this._camera.updateProjectionMatrix()),this._cameraControls&&(this._cameraControls.target=n.clone(),this._cameraControls.update()),this._silent=!1}_onCameraPositionChange(t){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:t})}_fitObjectToViewport(t){var p,d,g;let n=new ta,i=new j,o=new j;n.setFromObject(t),n.getCenter(i),n.getSize(o);let a=Math.max(o.x,o.y,o.z),s=((p=this._camera)==null?void 0:p.fov)*(Math.PI/180),l=Math.abs(a/(2*Math.tan(s/2)))*1.25,c=n.min.z,u=c<0?-c+l:l-c,h=(d=this.initCameraPosition)!=null?d:new j(i.x,i.y,l),f=(g=this.initCameraLookAt)!=null?g:i;this.setCameraViewpoint(h,u*3,f)}_createMesh(t,r){var f;let n=t.vertices,i=t.faces,o=t.colors,a=this._applyDefaults(r,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}}),s=new Pe,l=new Float32Array(n.flat());s.setAttribute("position",new Je(l,3));let c=new Uint16Array(i.flat());if(o&&o.length){let p=o.flat();for(let d=0;d<p.length;d++)p[d]=p[d]/255;s.setAttribute("color",new Je(new Float32Array(p),3)),a.material=a.material||{},a.material.vertexColors=!0}s.center(),s.computeBoundingSphere(),s.setIndex(new Je(c,1)),s.computeVertexNormals();let u=new wM[a.material.cls](a.material),h=new ti(s,u);h.castShadow=!0,h.receiveShadow=!0,(f=this._scene)==null||f.add(h),this._lastMesh=h}_createLights(t,r){for(let n=0;n<r.lights.length;n++){let i=r.lights[n],o=new wM[i.cls](i.color,i.intensity);i.position&&o.position.set(i.position[0],i.position[1],i.position[2]),t.add(o)}}};var kn=class extends Gt(mt){constructor(){super(...arguments),this.selectedView="all",this.active=!1,this._colorScaleFunction=fn,this._steps=[],this._meshViewerAttached=!1,this._cameraPositionInitialized=!1,this._isMeshLoading=!1}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}connectedCallback(){super.connectedCallback(),this._dataProvider=new IP(this.requestManager);let t=new F6(this._runColor);t.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this)),t.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this)),this._meshViewer=t}reload(){!this.active||!this._dataProvider||(this._isMeshLoading=!0,this._dataProvider.reload(this.run,this.tag,this.sample).then(t=>{!t||(this._steps=t,this._stepIndex=t.length-1)}).catch(t=>{if(!t||!t.code||t.code!=m1.CANCELLED)throw t=t||"Response processing failed.",new Error(t)}))}_updateScene(){var r;let t=this._currentStep;!t||!t.mesh||(this._meshViewer.updateScene(t,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||((r=this.shadowRoot)==null||r.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))}_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),100)}_maybeFetchMesh(){return Ri(this,null,function*(){let t=this._currentStep;if(!(!t||t.mesh||t.meshFetching)){t.meshFetching=!0,this._isMeshLoading=!0;try{let r=yield this._dataProvider.fetchData(t,this.run,this.tag,this.sample);t.mesh=r[0],this.notifyPath("_currentStep.mesh")}catch(r){if(!r||!r.code||r.code!=m1.CANCELLED)throw r=r||"Response processing failed.",new Error(r)}finally{this._isMeshLoading=!1,t.meshFetching=!1}}})}_onCameraPositionChange(){if(!this._meshViewer.isReady())return;let t=new CustomEvent("camera-position-change",{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(t)}setCameraViewpoint(t,r,n){this._meshViewer.setCameraViewpoint(t,r,n)}_updateCanvasSize(){let t=this.offsetWidth,r=t,n=this.$$(".tf-mesh-loader-header").offsetHeight,i={width:t,height:r-n};this._meshViewer.setCanvasSize(i)}redraw(){this._updateCanvasSize(),this.isConnected&&this._meshViewer.draw()}_hasAtLeastOneStep(t){return!!t&&t.length>0}_hasMultipleSteps(t){return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){let t=this._currentStep;return t?t.step:0}get _currentWallTime(){let t=this._currentStep;return t?s2(t.wall_time):""}_getMaxStepIndex(t){return t.length-1}_getSampleText(t){return String(t+1)}_hasMultipleSamples(t){return t>1}_updateView(){var t=this.selectedView;this._meshViewer&&t=="all"&&this._meshViewer.resetView()}toLocaleString_(t){return t.toLocaleString()}};kn.template=Q`
    <tf-card-heading color="[[_runColor]]" class="tf-mesh-loader-header">
      <template is="dom-if" if="[[_hasMultipleSamples(ofSamples)]]">
        <div>sample: [[_getSampleText(sample)]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep(_steps)]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[toLocaleString_(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isMeshLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps(_steps)]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_getMaxStepIndex(_steps)]]"
            max-markers="[[_getMaxStepIndex(_steps)]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <style>
      paper-slider {
        width: 100%;
        margin-left: 1px;
        margin-right: 1px;
      }
      .tf-mesh-loader-header {
        display: block;
        height: 105px;
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],kn.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],kn.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],kn.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],kn.prototype,"ofSamples",void 0);E([A({type:String}),w("design:type",String)],kn.prototype,"selectedView",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"active",void 0);E([A({type:Object}),w("design:type",Ae)],kn.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",F6)],kn.prototype,"_meshViewer",void 0);E([A({type:Object}),w("design:type",IP)],kn.prototype,"_dataProvider",void 0);E([A({type:Object}),w("design:type",Object)],kn.prototype,"_colorScaleFunction",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],kn.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],kn.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_meshViewerAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_cameraPositionInitialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_isMeshLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],kn.prototype,"_runColor",null);E([Bt("run","tag","active","_dataProvider","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"reload",null);E([Bt("_currentStep.*","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_updateScene",null);E([Bt("_currentStep"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_debouncedFetchMesh",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],kn.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],kn.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],kn.prototype,"_currentWallTime",null);E([Bt("selectedView"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_updateView",null);kn=E([yt("tf-mesh-loader")],kn);var ph=class extends mt{constructor(){super(),this.reloadOnReady=!0,this._tagFilter=".*",this._selectedView="all",this._requestManager=new Ae,window.addEventListener("resize",()=>{this._handleWindowResize()},!1),this.reloadOnReady&&this.reload()}_getAllChildren(){var t;return Array.from((t=this.shadowRoot)==null?void 0:t.querySelectorAll("tf-mesh-loader"))}_onCameraPositionChanged(t){this._selectedView=="share"&&this._getAllChildren().forEach(r=>{t.target!=r&&r.setCameraViewpoint(t.detail.position,t.detail.far,t.detail.target)})}_shouldOpen(t){return t<=2}reload(){this._fetchTags().then(this._reloadMeshes.bind(this))}_handleWindowResize(){this._getAllChildren().forEach(t=>{t.redraw()})}_fetchTags(){let t=_e().pluginRoute("mesh","/tags");return this._requestManager.request(t).then(r=>{if(lx.isEqual(r,this._runToTagInfo))return;let n=lx.mapValues(r,o=>Object.keys(o)),i=$i(n);this._dataNotFound=i.length===0,this._runToTagInfo=r})}_reloadMeshes(){this._getAllChildren().forEach(t=>{t.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=lx.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return lx.range(c).map(u=>Object.assign({},l,{sample:u,ofSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}};ph.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <div class="settings">
          <div class="sidebar-section view-control">
            <h3 class="title">Point of view</h3>
            <div>
              <paper-radio-group
                id="view-radio-group"
                selected="{{_selectedView}}"
              >
                <paper-radio-button id="all-radio-button" name="all">
                  Display all points
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="all-radio-button"
                  position="right"
                  offset="0"
                >
                  Zoom and center camera to display all points at once. Note,
                  that some points could be too far (i.e. too small) to be
                  visible.
                </paper-tooltip>
                <paper-radio-button id="user-radio-button" name="user">
                  Current view
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="user-radio-button"
                  position="right"
                  offset="0"
                >
                  Keep current camera position and zoom level.
                </paper-tooltip>
                <paper-radio-button id="share-radio-button" name="share">
                  Share viewpoint
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="share-radio-button"
                  position="right"
                  offset="0"
                >
                  Share viewpoint among all cameras.
                </paper-tooltip>
              </paper-radio-group>
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No point cloud data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any point cloud data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-mesh-loader
                  active="[[active]]"
                  selected-view="[[_selectedView]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  request-manager="[[_requestManager]]"
                  class="tf-mesh-loader-container"
                  on-camera-position-change="_onCameraPositionChanged"
                >
                </tf-mesh-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-radio-button {
        display: block;
        padding: 5px;
      }
      .sidebar-section h3 {
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .runs-selector {
        flex-grow: 1;
      }

      tf-runs-selector {
        display: flex;
      }

      .view-control {
        display: block !important;
      }

      .view-control h3.title {
        padding-top: 16px;
        padding-bottom: 16px;
      }

      .allcontrols .view-control paper-radio-group {
        margin-top: 5px;
      }
      /* Layout must be horizontal, i.e. items arranged in a row. If items cannot fit in a row,
       * they should be moved to next line. All items must be square at all times. Minimum size of
       * the item is 480px. This means that maximum size of the item must be 480px + 479px = 959px.
       * */
      .horizontal {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }
      tf-mesh-loader {
        width: 480px;
        flex-basis: 480px;
        flex-grow: 1;
        display: block;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],ph.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ph.prototype,"_tagFilter",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ph.prototype,"_selectedView",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],ph.prototype,"_categories",null);ph=E([yt("mesh-dashboard"),w("design:paramtypes",[])],ph);var QU=class extends Gt(mt){constructor(){super(...arguments),this._installCommand="pip install -U tensorboard-plugin-profile"}_copyInstallCommand(){return Ri(this,null,function*(){let t=()=>Ri(this,null,function*(){this.$.commandTextarea.select();try{yield navigator.clipboard.writeText(this._installCommand)}catch(i){if(!document.execCommand("copy"))return Promise.reject()}}),r=this.$.copiedMessage;try{yield t(),r.innerText="Copied."}catch(n){r.innerText="Failed to copy to clipboard."}})}_removeCopiedMessage(){let t=this.$.copiedMessage;t.innerText=""}};QU.template=Q`
    <div class="message">
      <h3>The profile plugin has moved.</h3>
      <p>
        Please install the new version of the profile plugin from PyPI by
        running the following command from the machine running TensorBoard:
      </p>
      <textarea
        id="commandTextarea"
        readonly=""
        rows="1"
        on-blur="_removeCopiedMessage"
      >
[[_installCommand]]</textarea
      >
      <div id="copyContainer">
        <span id="copiedMessage"></span>
        <paper-button raised="" on-tap="_copyInstallCommand"
          >Copy to clipboard</paper-button
        >
      </div>
    </div>

    <style>
      :host {
        display: flex;
      }

      .message {
        margin: 80px auto 0 auto;
        max-width: 540px;
      }
      #commandTextarea {
        margin-top: 1ex;
        padding: 1ex 1em;
        resize: vertical;
        width: 100%;
      }
      #copyContainer {
        display: flex;
      }
      #copiedMessage {
        align-self: center;
        flex-grow: 1;
        font-style: italic;
        padding-right: 1em;
        text-align: right;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],QU.prototype,"_installCommand",void 0);QU=E([yt("tf-profile-redirect-dashboard")],QU);var cm=Ee(Oe(),1);var Fl=Ee(Oe(),1),tq=Ee(Sl(),1);var nn=class extends mt{constructor(){super(...arguments),this._expanded=!1,this._runToPrCurveEntry={},this._previousRunToPrCurveEntry={},this._colorScaleFunction={scale:fn},this._canceller=new an,this._xComponentsCreationMethod=()=>{let t=new tq.Scales.Linear;return{scale:t,axis:new tq.Axes.Numeric(t,"bottom"),accessor:r=>r.recall}},this._yValueAccessor=t=>t.precision,this._tooltipColumns=(()=>{let t=Wu(r0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Run",evaluate:n=>n.dataset.metadata().name},{title:"Threshold",evaluate:n=>r(n.datum.thresholds)},{title:"Precision",evaluate:n=>r(n.datum.precision)},{title:"Recall",evaluate:n=>r(n.datum.recall)},{title:"TP",evaluate:n=>n.datum.true_positives},{title:"FP",evaluate:n=>n.datum.false_positives},{title:"TN",evaluate:n=>n.datum.true_negatives},{title:"FN",evaluate:n=>n.datum.false_negatives}]})(),this._seriesDataFields=["thresholds","precision","recall","true_positives","false_positives","true_negatives","false_negatives"],this._defaultXRange=[-.05,1.05],this._defaultYRange=[-.05,1.05],this._requestData=(t,r,n)=>{let o=_e().pluginRoute("pr_curves","/pr_curves");Promise.all(t.map(a=>{let s=a,l=this.tag,c=Mi(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._smoothingEnabled=!1}_createProcessDataFunction(){return(t,r,n)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,n))}}_computeRunColor(t){return fn(t)}connectedCallback(){super.connectedCallback(),this._attached=!0,this.reload()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){if(!!this._attached){if(this.runs.length===0){this.set("_runToDataOverTime",{});return}this._getChartDataLoader().reload()}}_setChartData(){var t=this._runToPrCurveEntry,r=this._previousRunToPrCurveEntry,n=this._setOfRelevantRuns;Fl.forOwn(t,(i,o)=>{let a=r[o];if(!(a&&t[o].step===a.step)){if(!n[o]){this._clearSeriesData(o);return}this._updateSeriesDataForRun(o,i)}})}_updateSeriesDataForRun(t,r){let n=Fl.reduce(this._seriesDataFields,(a,s)=>(a[s]=r[s].slice().reverse(),a),{}),i=new Array(n[this._seriesDataFields[0]].length);for(let a=0;a<i.length;a++)i[a]=Fl.mapValues(n,s=>s[a]);let o=this._getChartDataLoader();o.setSeriesData(t,i),o.commitChanges()}_clearSeriesData(t){let r=this._getChartDataLoader();r.setSeriesData(t,[]),r.commitChanges()}_updateRunToPrCurveEntry(){var t=this._runToDataOverTime,r=this.runToStepCap;let n={};Fl.forOwn(t,(i,o)=>{!i||!i.length||(n[o]=this._computeEntryClosestOrEqualToStepCap(r[o],i))}),this.set("_previousRunToPrCurveEntry",this._runToPrCurveEntry),this.set("_runToPrCurveEntry",n)}_notifyDataChange(){var t=this._runToDataOverTime;this.onDataChange&&this.onDataChange(t)}_computeEntryClosestOrEqualToStepCap(t,r){let n=Math.min(Fl.sortedIndex(r.map(i=>i.step),t),r.length-1);return r[n]}get _runsWithStepAvailable(){var t=this.runs,r=this._runToPrCurveEntry;return Fl.filter(t,n=>r[n]).sort()}get _setOfRelevantRuns(){var t=this._runsWithStepAvailable;let r={};return Fl.forEach(t,n=>{r[n]=!0}),r}_computeCurrentStepForRun(t,r){let n=t[r];return n?n.step:null}_computeCurrentWallTimeForRun(t,r){let n=t[r];return n?new Date(n.wall_time*1e3).toString():null}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_resetDomain(){this._getChartDataLoader().resetDomain()}redraw(){this._getChartDataLoader().redraw()}};nn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>

    <tf-line-chart-data-loader
      x-components-creation-method="[[_xComponentsCreationMethod]]"
      y-value-accessor="[[_yValueAccessor]]"
      tooltip-columns="[[_tooltipColumns]]"
      color-scale="[[_colorScaleFunction]]"
      default-x-range="[[_defaultXRange]]"
      default-y-range="[[_defaultYRange]]"
      smoothing-enabled="[[_smoothingEnabled]]"
      request-manager="[[requestManager]]"
      data-to-load="[[runs]]"
      data-series="[[runs]]"
      load-key="[[tag]]"
      request-data="[[_requestData]]"
      load-data-callback="[[_createProcessDataFunction()]]"
      active="[[active]]"
    ></tf-line-chart-data-loader>

    <div id="buttons-row">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Reset axes to [0, 1]."
      ></paper-icon-button>
    </div>

    <div id="step-legend">
      <template is="dom-repeat" items="[[_runsWithStepAvailable]]" as="run">
        <div class="legend-row">
          <div
            class="color-box"
            style="background: [[_computeRunColor(run)]];"
          ></div>
          [[run]] is at
          <span class="step-label-text">
            step [[_computeCurrentStepForRun(_runToPrCurveEntry, run)]] </span
          ><br />
          <span class="wall-time-label-text">
            ([[_computeCurrentWallTimeForRun(_runToPrCurveEntry, run)]])
          </span>
        </div>
      </template>
    </div>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 500px;
        margin-right: 10px;
        margin-bottom: 25px;
      }
      :host([_expanded]) {
        width: 100%;
      }
      tf-line-chart-data-loader {
        height: 300px;
        position: relative;
      }
      :host([_expanded]) tf-line-chart-data-loader {
        height: 600px;
      }
      #buttons-row {
        display: flex;
        flex-direction: row;
      }
      #buttons-row paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      #buttons-row paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      #step-legend {
        box-sizing: border-box;
        font-size: 0.8em;
        max-height: 200px;
        overflow-y: auto;
        padding: 0 0 0 10px;
        width: 100%;
      }
      .legend-row {
        margin: 5px 0 5px 0;
        width: 100%;
      }
      .color-box {
        display: inline-block;
        border-radius: 1px;
        width: 10px;
        height: 10px;
      }
      .step-label-text {
        font-weight: bold;
      }
      .wall-time-label-text {
        color: #888;
        font-size: 0.8em;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],nn.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],nn.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"runToStepCap",void 0);E([A({type:Object}),w("design:type",Ae)],nn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"active",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],nn.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_previousRunToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToDataOverTime",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"onDataChange",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_colorScaleFunction",void 0);E([A({type:Object}),w("design:type",an)],nn.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_seriesDataFields",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"_requestData",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_smoothingEnabled",void 0);E([Bt("runs","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"reload",null);E([Bt("_runToPrCurveEntry","_previousRunToPrCurveEntry","_setOfRelevantRuns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_setChartData",null);E([Bt("_runToDataOverTime","runToStepCap"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_updateRunToPrCurveEntry",null);E([Bt("_runToDataOverTime"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_notifyDataChange",null);E([Rt("runs","_runToPrCurveEntry"),w("design:type",Array),w("design:paramtypes",[])],nn.prototype,"_runsWithStepAvailable",null);E([Rt("_runsWithStepAvailable"),w("design:type",Object),w("design:paramtypes",[])],nn.prototype,"_setOfRelevantRuns",null);nn=E([yt("tf-pr-curve-card")],nn);var SM=Ee(Oe(),1);var rp=class extends mt{constructor(){super(...arguments),this._runToStepIndex={}}_computeColorForRun(t){return fn(t)}_computeTimeTextForRun(t,r,n,i){let o=r[n];if(!SM.isNumber(o))return"";let a=t[n];if(!a)return"";let s=a[o][i];if(i==="step")return`step ${s}`;if(i==="relative")return s<1?`${(s*1e3).toFixed(2)} ms`:`${s.toFixed(2)} s`;if(i==="wall_time")return new Date(s*1e3).toString();throw new Error(`The display type of ${i} is not recognized.`)}_sliderValueChanged(t){let r=t.target.dataset.run,n=t.target.immediateValue,i=Object.assign({},this._runToStepIndex);isNaN(n)?delete i[r]:i[r]=t.target.immediateValue,this._runToStepIndex=i}_computeMaxStepIndexForRun(t,r){let n=t[r];return n&&n.length?n.length-1:0}_updateStepsForNewRuns(){var t=this.runToAvailableTimeEntries;let r=Object.assign({},this._runToStepIndex);SM.forOwn(t,(n,i)=>{SM.isNumber(r[i])||(r[i]=n.length-1)}),this._runToStepIndex=r}_getStep(t,r){return this._runToStepIndex?this._runToStepIndex[r]:0}_computeRunToStep(t,r){let n={};return SM.forOwn(r,(i,o)=>{let a=t[o];!a||(n[o]=a[i].step)}),n}get _runsWithSliders(){var t=this.runs,r=this.runToAvailableTimeEntries;return t.filter(n=>r[n])}};rp.template=Q`
    <template is="dom-repeat" items="[[_runsWithSliders]]" as="run">
      <div class="run-widget">
        <div class="run-display-container">
          <div
            class="run-color-box"
            style="background:[[_computeColorForRun(run)]];"
          ></div>
          <div class="run-text">[[run]]</div>
        </div>
        <div class="step-display-container">
          [[_computeTimeTextForRun(runToAvailableTimeEntries, _runToStepIndex,
          run, timeDisplayType)]]
        </div>
        <paper-slider
          data-run$="[[run]]"
          step="1"
          type="number"
          min="0"
          max="[[_computeMaxStepIndexForRun(runToAvailableTimeEntries, run)]]"
          value="[[_getStep(_runToStepIndex, run)]]"
          on-immediate-value-changed="_sliderValueChanged"
        ></paper-slider>
      </div>
    </template>
    <style>
      .run-widget {
        margin: 10px 0 0 0;
      }
      paper-slider {
        margin: -8px 0 0 -15px;
        width: 100%;
      }
      .step-display-container {
        font-size: 0.9em;
        margin: 0 15px 0 0;
      }
      .run-text {
        display: inline-block;
      }
      .run-color-box {
        width: 12px;
        height: 12px;
        border-radius: 3px;
        display: inline-block;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],rp.prototype,"runs",void 0);E([A({type:Object}),w("design:type",Object)],rp.prototype,"runToAvailableTimeEntries",void 0);E([A({type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"}),w("design:type",Object)],rp.prototype,"runToStep",void 0);E([A({type:String}),w("design:type",String)],rp.prototype,"timeDisplayType",void 0);E([A({type:Object}),w("design:type",Object)],rp.prototype,"_runToStepIndex",void 0);E([Bt("runToAvailableTimeEntries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],rp.prototype,"_updateStepsForNewRuns",null);E([Rt("runs","runToAvailableTimeEntries"),w("design:type",Array),w("design:paramtypes",[])],rp.prototype,"_runsWithSliders",null);rp=E([yt("tf-pr-curve-steps-selector")],rp);var ko=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._timeDisplayType="step",this._selectedRuns=[],this._runToTagInfo={},this._tagToRunToData={},this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae,this._step=0}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){Promise.all([this._fetchTags()]).then(()=>{this._reloadCards()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("pr_curves","/tags");return this._requestManager.request(t).then(r=>{if(cm.isEqual(r,this._runToTagInfo))return;let n=cm.mapValues(r,o=>cm.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCards(){var t;cm.forEach((t=this.root)==null?void 0:t.querySelectorAll("tf-pr-curve-card"),r=>{r.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=cm.mapValues(t,o=>Object.keys(o));return hE(i,r,n)}get _relevantSelectedRuns(){var t=this._selectedRuns,r=this._runToTagInfo;return t.filter(n=>r[n])}_tagMetadata(t,r,n){let i={};r.forEach(a=>{i[a]=t[a][n]});let o=n.replace(/\/pr_curves$/,"");return oR(i,o)}_createDataChangeCallback(t){return r=>{this.set("_tagToRunToData",yh(ia({},this._tagToRunToData),{[t]:r}))}}get _runToAvailableTimeEntries(){var t=this._tagToRunToData;let r={};for(let[i,o]of Object.entries(t))for(let[a]of Object.entries(o))(r[a]==null||i<r[a])&&(r[a]=i);let n={};for(let[i,o]of Object.entries(r)){let a=t[o][i];n[i]=a.map(s=>({step:s.step,wall_time:s.wall_time,relative:s.wall_time-a[0].wall_time}))}return n}};ko.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="time-type-selector"
              name="Time Display Type"
              selected-id="{{_timeDisplayType}}"
            >
              <paper-button id="step">step</paper-button>
              <!--
            -->
              <paper-button id="relative">relative</paper-button>
              <!--
            -->
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
          <template is="dom-if" if="[[_runToAvailableTimeEntries]]">
            <div class="sidebar-section" id="steps-selector-container">
              <tf-pr-curve-steps-selector
                runs="[[_relevantSelectedRuns]]"
                run-to-step="{{_runToStep}}"
                run-to-available-time-entries="[[_runToAvailableTimeEntries]]"
                time-display-type="[[_timeDisplayType]]"
              >
              </tf-pr-curve-steps-selector>
            </div>
          </template>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No precision–recall curve data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any precision–recall data to your event
                files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-pr-curve-card
                  active="[[active]]"
                  runs="[[item.runs]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.runs, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  run-to-step-cap="[[_runToStep]]"
                  on-data-change="[[_createDataChangeCallback(item.tag)]]"
                ></tf-pr-curve-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      /** Do not let the steps selector occlude the run selector. */
      #steps-selector-container {
        max-height: 60%;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_timeDisplayType",void 0);E([A({type:Array}),w("design:type",Array)],ko.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_runToTagInfo",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_tagToRunToData",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ko.prototype,"_runToStep",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],ko.prototype,"_requestManager",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ko.prototype,"_step",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_categories",null);E([Rt("_selectedRuns","_runToTagInfo"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_relevantSelectedRuns",null);E([Rt("_tagToRunToData"),w("design:type",Object),w("design:paramtypes",[])],ko.prototype,"_runToAvailableTimeEntries",null);ko=E([yt("tf-pr-curve-dashboard")],ko);var B6=Ee(Oe(),1);var uo=class extends Gt(nb){constructor(){super(...arguments),this.reloadOnReady=!0,this._showDownloadLinks=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=_E("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType=Td.STEP,this._selectedRuns=[],this._tagFilter="",this._categories=[],this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae(50),this._showDownloadLinksObserver=bp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=yE("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=bp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}_getCategoryKey(t){return t.metadata.type==Da.SEARCH_RESULTS?"":t.name}_shouldOpen(t){return t<=2}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadCharts()})}_fetchTags(){let t=_e().pluginRoute("scalars","/tags");return this._requestManager.request(t).then(r=>{if(B6.isEqual(r,this._runToTagInfo))return;let n=B6.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCharts(){var t;(t=this.root)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.reload()})}_updateCategories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i,o=n,a=B6.mapValues(t,s=>Object.keys(s));i=hE(a,r,o),i.forEach(s=>{s.items=s.items.map(l=>({tag:l.tag,series:l.runs.map(c=>({run:c,tag:l.tag}))}))}),this.updateArrayProp("_categories",i,this._getCategoryKey)}_tagMetadata(t,r,n){let i=t.name,o=n.tag,a={};n.series.forEach(({run:u})=>{a[u]=r[u][o]});let s=o.replace(/\/scalar_summary$/,""),{description:l,displayName:c}=oR(a,s);return t.metadata.type==Da.PREFIX_GROUP&&c.startsWith(i+"/")&&(c=c.slice(i.length+1)),{description:l,displayName:c}}};uo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox
                id="show-download-links"
                checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox
                id="ignore-y-outlier"
                checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div>Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="0.999"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No scalar data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any scalar data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-scalar-card
                  active="[[active]]"
                  data-to-load="[[item.series]]"
                  ignore-y-outliers="[[_ignoreYOutliers]]"
                  multi-experiments="[[_getMultiExperiments(dataSelection)]]"
                  request-manager="[[_requestManager]]"
                  show-download-links="[[_showDownloadLinks]]"
                  smoothing-enabled="[[_smoothingEnabled]]"
                  smoothing-weight="[[_smoothingWeight]]"
                  tag-metadata="[[_tagMetadata(category, _runToTagInfo, item)]]"
                  tag="[[item.tag]]"
                  tooltip-sorting-method="[[_tooltipSortingMethod]]"
                  x-type="[[_xType]]"
                  batch-size="[[featureFlags.scalarsBatchSize]]"
                  in-colab="[[featureFlags.inColab]]"
                ></tf-scalar-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }

      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .center {
        overflow-x: hidden;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"reloadOnReady",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"featureFlags",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],uo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],uo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],uo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_categoriesDomReady",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_categories",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],uo.prototype,"_requestManager",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],uo.prototype,"_smoothingEnabled",null);E([Bt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],uo.prototype,"_updateCategories",null);uo=E([yt("tf-scalar-dashboard")],uo);var cpe=Ee(Oe(),1);var dh=class extends Gt(mt){constructor(){super(...arguments),this._texts=[],this._canceller=new an}get _runColor(){var t=this.run;return fn(t)}_changeRunColor(){var t=this._runColor;this.updateStyles({"--tb-text-loader-outline":t})}attached(){this.reload()}reload(){if(!this.isAttached)return;this._canceller.cancelAll();let t=_e(),r=Mi(t.pluginRoute("text","/text"),{tag:this.tag,run:this.run,markdown:this.markdownEnabled?"true":"false"}),n=this._canceller.cancellable(i=>{if(i.cancelled)return;let o=i.value.map(a=>({wall_time:new Date(a.wall_time*1e3),step:a.step,text:a.text}));this.set("_texts",o.slice().reverse())});this.requestManager.request(r).then(n)}_formatStep(t){return xn(",")(t)}};dh.template=Q`
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material
      elevation="1"
      id="steps-container"
      class="container scrollbar"
    >
      <template is="dom-repeat" items="[[_texts]]">
        <paper-material elevation="1" class="step-container">
          step <span class="step-value">[[_formatStep(item.step)]]</span>
        </paper-material>
        <paper-material elevation="1" class="text">
          <tf-markdown-view html="[[item.text]]"></tf-markdown-view>
        </paper-material>
      </template>
    </paper-material>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 100%;
        height: auto;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      .scrollbar {
        will-change: transform;
      }
      #steps-container {
        border-radius: 3px;
        border: 2px solid /* color computed and set as inline style */;
        display: block;
        max-height: 500px;
        overflow: auto;
        padding: 10px;
        border-color: var(--tb-text-loader-outline);
      }
      .text {
        background-color: inherit;
        border-radius: 0 3px 3px 3px;
        padding: 5px;
        word-break: break-word;
      }
      .step-container {
        background-color: var(--tb-ui-light-accent);
        border-bottom: none;
        border-radius: 3px 3px 0 0;
        border: 1px solid var(--tb-ui-border);
        display: inline-block;
        font-size: 12px;
        font-style: italic;
        margin-left: -1px; /* to correct for border */
        padding: 3px;
      }
      .step-container:not(:first-child) {
        margin-top: 15px;
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],dh.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],dh.prototype,"tag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dh.prototype,"markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],dh.prototype,"_texts",void 0);E([A({type:Object}),w("design:type",Ae)],dh.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],dh.prototype,"_canceller",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],dh.prototype,"_runColor",null);E([Bt("_runColor"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dh.prototype,"_changeRunColor",null);dh=E([yt("tf-text-loader")],dh);var Qc=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._markdownEnabled=xp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0}).call(this),this._requestManager=new Ae,this._markdownEnabledStorageObserver=bp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0})}static get observers(){return["_markdownEnabledObserver(_markdownEnabled)"]}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadTexts()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=_e().pluginRoute("text","/tags");return this._requestManager.request(t).then(r=>{if(cpe.isEqual(r,this._runToTag))return;let n=$i(r);this.set("_dataNotFound",n.length===0),this.set("_runToTag",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadTexts(){var t;(t=this.root)==null||t.querySelectorAll("tf-text-loader").forEach(r=>{r.reload()})}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter;return Ql(t,r,n)}_markdownEnabledObserver(){this._reloadTexts()}};Qc.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <div class="line-item">
            <paper-checkbox checked="{{_markdownEnabled}}"
              >Enable Markdown</paper-checkbox
            >
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No text data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any text data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-text-loader
                  active="[[active]]"
                  tag="[[item.tag]]"
                  run="[[item.run]]"
                  request-manager="[[_requestManager]]"
                  markdown-enabled="[[_markdownEnabled]]"
                ></tf-text-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"reloadOnReady",void 0);E([A({type:Boolean,notify:!0,observer:"_markdownEnabledStorageObserver"}),w("design:type",Boolean)],Qc.prototype,"_markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],Qc.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_runToTag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Qc.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Qc.prototype,"_categories",null);Qc=E([yt("tf-text-dashboard")],Qc);var Vht=class extends Gt(mt){};Vht.template=Q`
    <div class="message">
      <h3>The What-If Tool is no longer supported.</h3>
      <p>
        The
        <a href="https://pair-code.github.io/lit/"
          >Learning Interpretability Tool (LIT)</a
        >
        is an actively maintained alternative. Please follow the instructions
        <a href="https://pair-code.github.io/lit/setup/">here</a> to install and
        use this tool.
      </p>
      <style>
        :host {
          display: flex;
        }

        .message {
          margin: 80px auto 0 auto;
          max-width: 540px;
        }
        #commandTextarea {
          margin-top: 1ex;
          padding: 1ex 1em;
          resize: vertical;
          width: 100%;
        }
        #copyContainer {
          display: flex;
        }
        #copiedMessage {
          align-self: center;
          flex-grow: 1;
          font-style: italic;
          padding-right: 1em;
          text-align: right;
        }
      </style>
    </div>
  `;Vht=E([yt("tf-wit-redirect-dashboard")],Vht);var upe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_backend=RB}};upe=E([yt("tf-backend")],upe);var hpe=class extends mt{constructor(){super(...arguments),this._template=null,this.runsColorScale=fn}};hpe=E([yt("tf-color-scale")],hpe);var fpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_feature_flags=tW}};fpe=E([yt("tf-feature-flags")],fpe);var ppe;(function(e){e.STEP="step",e.WALL_TIME="wall_time",e.RELATIVE="relative"})(ppe||(ppe={}));var dpe;(function(e){e.OFFSET="offset",e.OVERLAY="overlay"})(dpe||(dpe={}));window.tensorboard=yh(ia({},window.tensorboard),{tf_globals:kW});var Uht={};Zs(Uht,{TfDomRepeat:()=>Oi,addLimitListener:()=>UW,getLimit:()=>GW,removeLimitListener:()=>qW,setLimit:()=>s2e});var mpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_paginated_view=Uht}};mpe=E([yt("tf-paginated-view-store")],mpe);window.tensorboard=yh(ia({},window.tensorboard),{tf_storage:OB});})();
/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/**
 * @fileoverview
 * @suppress {checkPrototypalTypes}
 * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2021 Vaadin Ltd.
 * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
 */
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 *
 * @fileoverview manually add d3-selection-multi to d3 default bundle. Most of this code is
 * copied from d3-selection-multi@1.0.0.
 * See https://github.com/d3/d3-selection-multi/issues/11 for why we have to do this
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a convenient thunk function to handle the common case
 * of creating a memoized function that takes its inputs from mutable class properties.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a function memoizer using the Signature API.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements the Signature API to help in comparing when two
 * Plottable objects have "changed".
 *
 * Memoization in Plottable is complicated by mutable scales and datasets. We cannot simply
 * reference compare two e.g. scales since it may have internally mutated. To resolve this,
 * we write a recursive Signature interface that holds an immutable snapshot of whatever
 * state the scale/data was in at the time. Then on memoized function invocation we sign the
 * new inputs and compare the signatures to decide if we should recompute.
 *
 * We must hand-write a signature for each custom class we wish to support.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 */
/**
 * Copyright 2017-present Palantir Technologies
 * @license MIT
 */
/**
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/

(()=>{var qie=Object.create,FA=Object.defineProperty,Xie=Object.getOwnPropertyDescriptor,Yie=Object.getOwnPropertyNames,Qie=Object.getPrototypeOf,Zie=Object.prototype.hasOwnProperty,JV=(n,t)=>()=>(t||n((t={exports:{}}).exports,t),t.exports),NA=(n,t)=>{for(var e in t)FA(n,e,{get:t[e],enumerable:!0})},$V=(n,t,e)=>(e=null!=n?qie(Qie(n)):{},((n,t,e,i)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let r of Yie(t))!Zie.call(n,r)&&undefined!==r&&FA(n,r,{get:()=>t[r],enumerable:!(i=Xie(t,r))||i.enumerable});return n})(!t&&n&&n.__esModule?e:FA(e,"default",{value:n,enumerable:!0}),n)),L4=JV((RUe,bC)=>{var p4,h4,m4,f4,g4,_4,b4,v4,y4,x4,C4,M4,w4,gC,ZA,S4,E4,T4,Lm,D4,I4,A4,R4,P4,k4,O4,F4,N4,_C;!function(n){var t="object"==typeof global?global:"object"==typeof self?self:"object"==typeof this?this:{};function e(i,r){return i!==t&&("function"==typeof Object.create?Object.defineProperty(i,"__esModule",{value:!0}):i.__esModule=!0),function(o,a){return i[o]=r?r(o,a):a}}"function"==typeof define&&define.amd?define("tslib",["exports"],function(i){n(e(t,e(i)))}):n("object"==typeof bC&&"object"==typeof bC.exports?e(t,e(bC.exports)):e(t))}(function(n){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(i,r){i.__proto__=r}||function(i,r){for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(i[o]=r[o])};p4=function(i,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=i}t(i,r),i.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)},h4=Object.assign||function(i){for(var r,o=1,a=arguments.length;o<a;o++)for(var s in r=arguments[o])Object.prototype.hasOwnProperty.call(r,s)&&(i[s]=r[s]);return i},m4=function(i,r){var o={};for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&r.indexOf(a)<0&&(o[a]=i[a]);if(null!=i&&"function"==typeof Object.getOwnPropertySymbols){var s=0;for(a=Object.getOwnPropertySymbols(i);s<a.length;s++)r.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(i,a[s])&&(o[a[s]]=i[a[s]])}return o},f4=function(i,r,o,a){var c,s=arguments.length,l=s<3?r:null===a?a=Object.getOwnPropertyDescriptor(r,o):a;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)l=Reflect.decorate(i,r,o,a);else for(var d=i.length-1;d>=0;d--)(c=i[d])&&(l=(s<3?c(l):s>3?c(r,o,l):c(r,o))||l);return s>3&&l&&Object.defineProperty(r,o,l),l},g4=function(i,r){return function(o,a){r(o,a,i)}},_4=function(i,r,o,a,s,l){function c(I){if(void 0!==I&&"function"!=typeof I)throw new TypeError("Function expected");return I}for(var m,d=a.kind,u="getter"===d?"get":"setter"===d?"set":"value",p=!r&&i?a.static?i:i.prototype:null,h=r||(p?Object.getOwnPropertyDescriptor(p,a.name):{}),_=!1,M=o.length-1;M>=0;M--){var y={};for(var x in a)y[x]="access"===x?{}:a[x];for(var x in a.access)y.access[x]=a.access[x];y.addInitializer=function(I){if(_)throw new TypeError("Cannot add initializers after decoration has completed");l.push(c(I||null))};var R=(0,o[M])("accessor"===d?{get:h.get,set:h.set}:h[u],y);if("accessor"===d){if(void 0===R)continue;if(null===R||"object"!=typeof R)throw new TypeError("Object expected");(m=c(R.get))&&(h.get=m),(m=c(R.set))&&(h.set=m),(m=c(R.init))&&s.push(m)}else(m=c(R))&&("field"===d?s.push(m):h[u]=m)}p&&Object.defineProperty(p,a.name,h),_=!0},b4=function(i,r,o){for(var a=arguments.length>2,s=0;s<r.length;s++)o=a?r[s].call(i,o):r[s].call(i);return a?o:void 0},v4=function(i){return"symbol"==typeof i?i:"".concat(i)},y4=function(i,r,o){return"symbol"==typeof r&&(r=r.description?"[".concat(r.description,"]"):""),Object.defineProperty(i,"name",{configurable:!0,value:o?"".concat(o," ",r):r})},x4=function(i,r){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(i,r)},C4=function(i,r,o,a){return new(o||(o=Promise))(function(l,c){function d(h){try{p(a.next(h))}catch(m){c(m)}}function u(h){try{p(a.throw(h))}catch(m){c(m)}}function p(h){h.done?l(h.value):function(l){return l instanceof o?l:new o(function(c){c(l)})}(h.value).then(d,u)}p((a=a.apply(i,r||[])).next())})},M4=function(i,r){var a,s,l,c,o={label:0,sent:function(){if(1&l[0])throw l[1];return l[1]},trys:[],ops:[]};return c={next:d(0),throw:d(1),return:d(2)},"function"==typeof Symbol&&(c[Symbol.iterator]=function(){return this}),c;function d(p){return function(h){return function(p){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,p[0]&&(o=0)),o;)try{if(a=1,s&&(l=2&p[0]?s.return:p[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,p[1])).done)return l;switch(s=0,l&&(p=[2&p[0],l.value]),p[0]){case 0:case 1:l=p;break;case 4:return o.label++,{value:p[1],done:!1};case 5:o.label++,s=p[1],p=[0];continue;case 7:p=o.ops.pop(),o.trys.pop();continue;default:if(!(l=(l=o.trys).length>0&&l[l.length-1])&&(6===p[0]||2===p[0])){o=0;continue}if(3===p[0]&&(!l||p[1]>l[0]&&p[1]<l[3])){o.label=p[1];break}if(6===p[0]&&o.label<l[1]){o.label=l[1],l=p;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(p);break}l[2]&&o.ops.pop(),o.trys.pop();continue}p=r.call(i,o)}catch(h){p=[6,h],s=0}finally{a=l=0}if(5&p[0])throw p[1];return{value:p[0]?p[1]:void 0,done:!0}}([p,h])}}},w4=function(i,r){for(var o in i)"default"!==o&&!Object.prototype.hasOwnProperty.call(r,o)&&_C(r,i,o)},_C=Object.create?function(i,r,o,a){void 0===a&&(a=o);var s=Object.getOwnPropertyDescriptor(r,o);(!s||("get"in s?!r.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return r[o]}}),Object.defineProperty(i,a,s)}:function(i,r,o,a){void 0===a&&(a=o),i[a]=r[o]},gC=function(i){var r="function"==typeof Symbol&&Symbol.iterator,o=r&&i[r],a=0;if(o)return o.call(i);if(i&&"number"==typeof i.length)return{next:function(){return i&&a>=i.length&&(i=void 0),{value:i&&i[a++],done:!i}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")},ZA=function(i,r){var o="function"==typeof Symbol&&i[Symbol.iterator];if(!o)return i;var s,c,a=o.call(i),l=[];try{for(;(void 0===r||r-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(d){c={error:d}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},S4=function(){for(var i=[],r=0;r<arguments.length;r++)i=i.concat(ZA(arguments[r]));return i},E4=function(){for(var i=0,r=0,o=arguments.length;r<o;r++)i+=arguments[r].length;var a=Array(i),s=0;for(r=0;r<o;r++)for(var l=arguments[r],c=0,d=l.length;c<d;c++,s++)a[s]=l[c];return a},T4=function(i,r,o){if(o||2===arguments.length)for(var l,a=0,s=r.length;a<s;a++)(l||!(a in r))&&(l||(l=Array.prototype.slice.call(r,0,a)),l[a]=r[a]);return i.concat(l||Array.prototype.slice.call(r))},Lm=function(i){return this instanceof Lm?(this.v=i,this):new Lm(i)},D4=function(i,r,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var s,a=o.apply(i,r||[]),l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(_){a[_]&&(s[_]=function(M){return new Promise(function(y,x){l.push([_,M,y,x])>1||d(_,M)})})}function d(_,M){try{!function(_){_.value instanceof Lm?Promise.resolve(_.value.v).then(p,h):m(l[0][2],_)}(a[_](M))}catch(y){m(l[0][3],y)}}function p(_){d("next",_)}function h(_){d("throw",_)}function m(_,M){_(M),l.shift(),l.length&&d(l[0][0],l[0][1])}},I4=function(i){var r,o;return r={},a("next"),a("throw",function(s){throw s}),a("return"),r[Symbol.iterator]=function(){return this},r;function a(s,l){r[s]=i[s]?function(c){return(o=!o)?{value:Lm(i[s](c)),done:!1}:l?l(c):c}:l}},A4=function(i){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var o,r=i[Symbol.asyncIterator];return r?r.call(i):(i=gC(i),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=i[l]&&function(c){return new Promise(function(d,u){!function(l,c,d,u){Promise.resolve(u).then(function(p){l({value:p,done:d})},c)}(d,u,(c=i[l](c)).done,c.value)})}}},R4=function(i,r){return Object.defineProperty?Object.defineProperty(i,"raw",{value:r}):i.raw=r,i};var e=Object.create?function(i,r){Object.defineProperty(i,"default",{enumerable:!0,value:r})}:function(i,r){i.default=r};P4=function(i){if(i&&i.__esModule)return i;var r={};if(null!=i)for(var o in i)"default"!==o&&Object.prototype.hasOwnProperty.call(i,o)&&_C(r,i,o);return e(r,i),r},k4=function(i){return i&&i.__esModule?i:{default:i}},O4=function(i,r,o,a){if("a"===o&&!a)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?i!==r||!a:!r.has(i))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===o?a:"a"===o?a.call(i):a?a.value:r.get(i)},F4=function(i,r,o,a,s){if("m"===a)throw new TypeError("Private method is not writable");if("a"===a&&!s)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?i!==r||!s:!r.has(i))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===a?s.call(i,o):s?s.value=o:r.set(i,o),o},N4=function(i,r){if(null===r||"object"!=typeof r&&"function"!=typeof r)throw new TypeError("Cannot use 'in' operator on non-object");return"function"==typeof i?r===i:i.has(r)},n("__extends",p4),n("__assign",h4),n("__rest",m4),n("__decorate",f4),n("__param",g4),n("__esDecorate",_4),n("__runInitializers",b4),n("__propKey",v4),n("__setFunctionName",y4),n("__metadata",x4),n("__awaiter",C4),n("__generator",M4),n("__exportStar",w4),n("__createBinding",_C),n("__values",gC),n("__read",ZA),n("__spread",S4),n("__spreadArrays",E4),n("__spreadArray",T4),n("__await",Lm),n("__asyncGenerator",D4),n("__asyncDelegator",I4),n("__asyncValues",A4),n("__makeTemplateObject",R4),n("__importStar",P4),n("__importDefault",k4),n("__classPrivateFieldGet",O4),n("__classPrivateFieldSet",F4),n("__classPrivateFieldIn",N4)})}),uG=JV(cO=>{"use strict";var n,uu=cO&&cO.__spreadArray||function(n,t,e){if(e||2===arguments.length)for(var o,i=0,r=t.length;i<r;i++)(o||!(i in t))&&(o||(o=Array.prototype.slice.call(t,0,i)),o[i]=t[i]);return n.concat(o||Array.prototype.slice.call(t))};n=function(){!function(j){var J=j.performance;function le(ft){J&&J.mark&&J.mark(ft)}function E(ft,me){J&&J.measure&&J.measure(ft,me)}le("Zone");var V=j.__Zone_symbol_prefix||"__zone_symbol__";function X(ft){return V+ft}var Z=!0===j[X("forceDuplicateZoneCheck")];if(j.Zone){if(Z||"function"!=typeof j.Zone.__symbol__)throw new Error("Zone already loaded.");return j.Zone}var ae=function(){function ft(me,ge){this._parent=me,this._name=ge?ge.name||"unnamed":"<root>",this._properties=ge&&ge.properties||{},this._zoneDelegate=new et(this,this._parent&&this._parent._zoneDelegate,ge)}return ft.assertZonePatched=function(){if(j.Promise!==On.ZoneAwarePromise)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(ft,"root",{get:function(){for(var me=ft.current;me.parent;)me=me.parent;return me},enumerable:!1,configurable:!0}),Object.defineProperty(ft,"current",{get:function(){return ir.zone},enumerable:!1,configurable:!0}),Object.defineProperty(ft,"currentTask",{get:function(){return Sa},enumerable:!1,configurable:!0}),ft.__load_patch=function(me,ge,Pe){if(void 0===Pe&&(Pe=!1),On.hasOwnProperty(me)){if(!Pe&&Z)throw Error("Already loaded patch: "+me)}else if(!j["__Zone_disable_"+me]){var Mn="Zone:"+me;le(Mn),On[me]=ge(j,ft,cr),E(Mn,Mn)}},Object.defineProperty(ft.prototype,"parent",{get:function(){return this._parent},enumerable:!1,configurable:!0}),Object.defineProperty(ft.prototype,"name",{get:function(){return this._name},enumerable:!1,configurable:!0}),ft.prototype.get=function(me){var ge=this.getZoneWith(me);if(ge)return ge._properties[me]},ft.prototype.getZoneWith=function(me){for(var ge=this;ge;){if(ge._properties.hasOwnProperty(me))return ge;ge=ge._parent}return null},ft.prototype.fork=function(me){if(!me)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,me)},ft.prototype.wrap=function(me,ge){if("function"!=typeof me)throw new Error("Expecting function got: "+me);var Pe=this._zoneDelegate.intercept(this,me,ge),Mn=this;return function(){return Mn.runGuarded(Pe,this,arguments,ge)}},ft.prototype.run=function(me,ge,Pe,Mn){ir={parent:ir,zone:this};try{return this._zoneDelegate.invoke(this,me,ge,Pe,Mn)}finally{ir=ir.parent}},ft.prototype.runGuarded=function(me,ge,Pe,Mn){void 0===ge&&(ge=null),ir={parent:ir,zone:this};try{try{return this._zoneDelegate.invoke(this,me,ge,Pe,Mn)}catch(ur){if(this._zoneDelegate.handleError(this,ur))throw ur}}finally{ir=ir.parent}},ft.prototype.runTask=function(me,ge,Pe){if(me.zone!=this)throw new Error("A task can only be run in the zone of creation! (Creation: "+(me.zone||Et).name+"; Execution: "+this.name+")");if(me.state!==gi||me.type!==_i&&me.type!==Pn){var Mn=me.state!=Qn;Mn&&me._transitionTo(Qn,Hn),me.runCount++;var ur=Sa;Sa=me,ir={parent:ir,zone:this};try{me.type==Pn&&me.data&&!me.data.isPeriodic&&(me.cancelFn=void 0);try{return this._zoneDelegate.invokeTask(this,me,ge,Pe)}catch(hl){if(this._zoneDelegate.handleError(this,hl))throw hl}}finally{me.state!==gi&&me.state!==Bi&&(me.type==_i||me.data&&me.data.isPeriodic?Mn&&me._transitionTo(Hn,Qn):(me.runCount=0,this._updateTaskCount(me,-1),Mn&&me._transitionTo(gi,Qn,gi))),ir=ir.parent,Sa=ur}}},ft.prototype.scheduleTask=function(me){if(me.zone&&me.zone!==this)for(var ge=this;ge;){if(ge===me.zone)throw Error("can not reschedule task to ".concat(this.name," which is descendants of the original zone ").concat(me.zone.name));ge=ge.parent}me._transitionTo(ti,gi);var Pe=[];me._zoneDelegates=Pe,me._zone=this;try{me=this._zoneDelegate.scheduleTask(this,me)}catch(Mn){throw me._transitionTo(Bi,ti,gi),this._zoneDelegate.handleError(this,Mn),Mn}return me._zoneDelegates===Pe&&this._updateTaskCount(me,1),me.state==ti&&me._transitionTo(Hn,ti),me},ft.prototype.scheduleMicroTask=function(me,ge,Pe,Mn){return this.scheduleTask(new qe(_n,me,ge,Pe,Mn,void 0))},ft.prototype.scheduleMacroTask=function(me,ge,Pe,Mn,ur){return this.scheduleTask(new qe(Pn,me,ge,Pe,Mn,ur))},ft.prototype.scheduleEventTask=function(me,ge,Pe,Mn,ur){return this.scheduleTask(new qe(_i,me,ge,Pe,Mn,ur))},ft.prototype.cancelTask=function(me){if(me.zone!=this)throw new Error("A task can only be cancelled in the zone of creation! (Creation: "+(me.zone||Et).name+"; Execution: "+this.name+")");if(me.state===Hn||me.state===Qn){me._transitionTo(zt,Hn,Qn);try{this._zoneDelegate.cancelTask(this,me)}catch(ge){throw me._transitionTo(Bi,zt),this._zoneDelegate.handleError(this,ge),ge}return this._updateTaskCount(me,-1),me._transitionTo(gi,zt),me.runCount=0,me}},ft.prototype._updateTaskCount=function(me,ge){var Pe=me._zoneDelegates;-1==ge&&(me._zoneDelegates=null);for(var Mn=0;Mn<Pe.length;Mn++)Pe[Mn]._updateTaskCount(me.type,ge)},ft}();ae.__symbol__=X;var qi,ze={name:"",onHasTask:function(ft,me,ge,Pe){return ft.hasTask(ge,Pe)},onScheduleTask:function(ft,me,ge,Pe){return ft.scheduleTask(ge,Pe)},onInvokeTask:function(ft,me,ge,Pe,Mn,ur){return ft.invokeTask(ge,Pe,Mn,ur)},onCancelTask:function(ft,me,ge,Pe){return ft.cancelTask(ge,Pe)}},et=function(){function ft(me,ge,Pe){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=me,this._parentDelegate=ge,this._forkZS=Pe&&(Pe&&Pe.onFork?Pe:ge._forkZS),this._forkDlgt=Pe&&(Pe.onFork?ge:ge._forkDlgt),this._forkCurrZone=Pe&&(Pe.onFork?this.zone:ge._forkCurrZone),this._interceptZS=Pe&&(Pe.onIntercept?Pe:ge._interceptZS),this._interceptDlgt=Pe&&(Pe.onIntercept?ge:ge._interceptDlgt),this._interceptCurrZone=Pe&&(Pe.onIntercept?this.zone:ge._interceptCurrZone),this._invokeZS=Pe&&(Pe.onInvoke?Pe:ge._invokeZS),this._invokeDlgt=Pe&&(Pe.onInvoke?ge:ge._invokeDlgt),this._invokeCurrZone=Pe&&(Pe.onInvoke?this.zone:ge._invokeCurrZone),this._handleErrorZS=Pe&&(Pe.onHandleError?Pe:ge._handleErrorZS),this._handleErrorDlgt=Pe&&(Pe.onHandleError?ge:ge._handleErrorDlgt),this._handleErrorCurrZone=Pe&&(Pe.onHandleError?this.zone:ge._handleErrorCurrZone),this._scheduleTaskZS=Pe&&(Pe.onScheduleTask?Pe:ge._scheduleTaskZS),this._scheduleTaskDlgt=Pe&&(Pe.onScheduleTask?ge:ge._scheduleTaskDlgt),this._scheduleTaskCurrZone=Pe&&(Pe.onScheduleTask?this.zone:ge._scheduleTaskCurrZone),this._invokeTaskZS=Pe&&(Pe.onInvokeTask?Pe:ge._invokeTaskZS),this._invokeTaskDlgt=Pe&&(Pe.onInvokeTask?ge:ge._invokeTaskDlgt),this._invokeTaskCurrZone=Pe&&(Pe.onInvokeTask?this.zone:ge._invokeTaskCurrZone),this._cancelTaskZS=Pe&&(Pe.onCancelTask?Pe:ge._cancelTaskZS),this._cancelTaskDlgt=Pe&&(Pe.onCancelTask?ge:ge._cancelTaskDlgt),this._cancelTaskCurrZone=Pe&&(Pe.onCancelTask?this.zone:ge._cancelTaskCurrZone),this._hasTaskZS=null,this._hasTaskDlgt=null,this._hasTaskDlgtOwner=null,this._hasTaskCurrZone=null;var Mn=Pe&&Pe.onHasTask;(Mn||ge&&ge._hasTaskZS)&&(this._hasTaskZS=Mn?Pe:ze,this._hasTaskDlgt=ge,this._hasTaskDlgtOwner=this,this._hasTaskCurrZone=me,Pe.onScheduleTask||(this._scheduleTaskZS=ze,this._scheduleTaskDlgt=ge,this._scheduleTaskCurrZone=this.zone),Pe.onInvokeTask||(this._invokeTaskZS=ze,this._invokeTaskDlgt=ge,this._invokeTaskCurrZone=this.zone),Pe.onCancelTask||(this._cancelTaskZS=ze,this._cancelTaskDlgt=ge,this._cancelTaskCurrZone=this.zone))}return ft.prototype.fork=function(me,ge){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,me,ge):new ae(me,ge)},ft.prototype.intercept=function(me,ge,Pe){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,me,ge,Pe):ge},ft.prototype.invoke=function(me,ge,Pe,Mn,ur){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,me,ge,Pe,Mn,ur):ge.apply(Pe,Mn)},ft.prototype.handleError=function(me,ge){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,me,ge)},ft.prototype.scheduleTask=function(me,ge){var Pe=ge;if(this._scheduleTaskZS)this._hasTaskZS&&Pe._zoneDelegates.push(this._hasTaskDlgtOwner),(Pe=this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,me,ge))||(Pe=ge);else if(ge.scheduleFn)ge.scheduleFn(ge);else{if(ge.type!=_n)throw new Error("Task is missing scheduleFn.");pn(ge)}return Pe},ft.prototype.invokeTask=function(me,ge,Pe,Mn){return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,me,ge,Pe,Mn):ge.callback.apply(Pe,Mn)},ft.prototype.cancelTask=function(me,ge){var Pe;if(this._cancelTaskZS)Pe=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,me,ge);else{if(!ge.cancelFn)throw Error("Task is not cancelable");Pe=ge.cancelFn(ge)}return Pe},ft.prototype.hasTask=function(me,ge){try{this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,me,ge)}catch(Pe){this.handleError(me,Pe)}},ft.prototype._updateTaskCount=function(me,ge){var Pe=this._taskCounts,Mn=Pe[me],ur=Pe[me]=Mn+ge;if(ur<0)throw new Error("More tasks executed then were scheduled.");0!=Mn&&0!=ur||this.hasTask(this.zone,{microTask:Pe.microTask>0,macroTask:Pe.macroTask>0,eventTask:Pe.eventTask>0,change:me})},ft}(),qe=function(){function ft(me,ge,Pe,Mn,ur,hl){if(this._zone=null,this.runCount=0,this._zoneDelegates=null,this._state="notScheduled",this.type=me,this.source=ge,this.data=Mn,this.scheduleFn=ur,this.cancelFn=hl,!Pe)throw new Error("callback is not defined");this.callback=Pe;var tt=this;this.invoke=me===_i&&Mn&&Mn.useG?ft.invokeTask:function(){return ft.invokeTask.call(j,tt,this,arguments)}}return ft.invokeTask=function(me,ge,Pe){me||(me=this),yr++;try{return me.runCount++,me.zone.runTask(me,ge,Pe)}finally{1==yr&&Rn(),yr--}},Object.defineProperty(ft.prototype,"zone",{get:function(){return this._zone},enumerable:!1,configurable:!0}),Object.defineProperty(ft.prototype,"state",{get:function(){return this._state},enumerable:!1,configurable:!0}),ft.prototype.cancelScheduleRequest=function(){this._transitionTo(gi,ti)},ft.prototype._transitionTo=function(me,ge,Pe){if(this._state!==ge&&this._state!==Pe)throw new Error("".concat(this.type," '").concat(this.source,"': can not transition to '").concat(me,"', expecting state '").concat(ge,"'").concat(Pe?" or '"+Pe+"'":"",", was '").concat(this._state,"'."));this._state=me,me==gi&&(this._zoneDelegates=null)},ft.prototype.toString=function(){return this.data&&typeof this.data.handleId<"u"?this.data.handleId.toString():Object.prototype.toString.call(this)},ft.prototype.toJSON=function(){return{type:this.type,state:this.state,source:this.source,zone:this.zone.name,runCount:this.runCount}},ft}(),rt=X("setTimeout"),dt=X("Promise"),St=X("then"),At=[],cn=!1;function yi(ft){if(qi||j[dt]&&(qi=j[dt].resolve(0)),qi){var me=qi[St];me||(me=qi.then),me.call(qi,ft)}else j[rt](ft,0)}function pn(ft){0===yr&&0===At.length&&yi(Rn),ft&&At.push(ft)}function Rn(){if(!cn){for(cn=!0;At.length;){var ft=At;At=[];for(var me=0;me<ft.length;me++){var ge=ft[me];try{ge.zone.runTask(ge,null,null)}catch(Pe){cr.onUnhandledError(Pe)}}}cr.microtaskDrainDone(),cn=!1}}var Et={name:"NO ZONE"},gi="notScheduled",ti="scheduling",Hn="scheduled",Qn="running",zt="canceling",Bi="unknown",_n="microTask",Pn="macroTask",_i="eventTask",On={},cr={symbol:X,currentZoneFrame:function(){return ir},onUnhandledError:dr,microtaskDrainDone:dr,scheduleMicroTask:pn,showUncaughtError:function(){return!ae[X("ignoreConsoleErrorUncaughtError")]},patchEventTarget:function(){return[]},patchOnProperties:dr,patchMethod:function(){return dr},bindArguments:function(){return[]},patchThen:function(){return dr},patchMacroTask:function(){return dr},patchEventPrototype:function(){return dr},isIEOrEdge:function(){return!1},getGlobalObjects:function(){},ObjectDefineProperty:function(){return dr},ObjectGetOwnPropertyDescriptor:function(){},ObjectCreate:function(){},ArraySlice:function(){return[]},patchClass:function(){return dr},wrapWithCurrentZone:function(){return dr},filterProperties:function(){return[]},attachOriginToPatched:function(){return dr},_redefineProperty:function(){return dr},patchCallbacks:function(){return dr},nativeScheduleMicroTask:yi},ir={parent:null,zone:new ae(null,null)},Sa=null,yr=0;function dr(){}E("Zone","Zone"),j.Zone=ae}(typeof window<"u"&&window||typeof self<"u"&&self||global);var n=Object.getOwnPropertyDescriptor,t=Object.defineProperty,e=Object.getPrototypeOf,i=Object.create,r=Array.prototype.slice,o="addEventListener",a="removeEventListener",s=Zone.__symbol__(o),l=Zone.__symbol__(a),c="true",d="false",u=Zone.__symbol__("");function p(j,J){return Zone.current.wrap(j,J)}function h(j,J,le,E,V){return Zone.current.scheduleMacroTask(j,J,le,E,V)}var m=Zone.__symbol__,_=typeof window<"u",M=_?window:void 0,y=_&&M||"object"==typeof self&&self||global,x="removeAttribute";function R(j,J){for(var le=j.length-1;le>=0;le--)"function"==typeof j[le]&&(j[le]=p(j[le],J+"_"+le));return j}function B(j){return!j||!1!==j.writable&&!("function"==typeof j.get&&typeof j.set>"u")}var ee=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope,Q=!("nw"in y)&&typeof y.process<"u"&&"[object process]"==={}.toString.call(y.process),we=!Q&&!ee&&!(!_||!M.HTMLElement),Qe=typeof y.process<"u"&&"[object process]"==={}.toString.call(y.process)&&!ee&&!(!_||!M.HTMLElement),Ae={},D=function(j){if(j=j||y.event){var J=Ae[j.type];J||(J=Ae[j.type]=m("ON_PROPERTY"+j.type));var V,le=this||j.target||y,E=le[J];return we&&le===M&&"error"===j.type?!0===(V=E&&E.call(this,j.message,j.filename,j.lineno,j.colno,j.error))&&j.preventDefault():null!=(V=E&&E.apply(this,arguments))&&!V&&j.preventDefault(),V}};function re(j,J,le){var E=n(j,J);if(!E&&le&&n(le,J)&&(E={enumerable:!0,configurable:!0}),E&&E.configurable){var X=m("on"+J+"patched");if(!j.hasOwnProperty(X)||!j[X]){delete E.writable,delete E.value;var Z=E.get,ae=E.set,ze=J.slice(2),et=Ae[ze];et||(et=Ae[ze]=m("ON_PROPERTY"+ze)),E.set=function(qe){var rt=this;!rt&&j===y&&(rt=y),rt&&("function"==typeof rt[et]&&rt.removeEventListener(ze,D),ae&&ae.call(rt,null),rt[et]=qe,"function"==typeof qe&&rt.addEventListener(ze,D,!1))},E.get=function(){var qe=this;if(!qe&&j===y&&(qe=y),!qe)return null;var rt=qe[et];if(rt)return rt;if(Z){var dt=Z.call(this);if(dt)return E.set.call(this,dt),"function"==typeof qe[x]&&qe.removeAttribute(J),dt}return null},t(j,J,E),j[X]=!0}}}function ce(j,J,le){if(J)for(var E=0;E<J.length;E++)re(j,"on"+J[E],le);else{var V=[];for(var X in j)"on"==X.slice(0,2)&&V.push(X);for(var Z=0;Z<V.length;Z++)re(j,V[Z],le)}}var he=m("originalInstance");function _e(j){var J=y[j];if(J){y[m(j)]=J,y[j]=function(){var V=R(arguments,j);switch(V.length){case 0:this[he]=new J;break;case 1:this[he]=new J(V[0]);break;case 2:this[he]=new J(V[0],V[1]);break;case 3:this[he]=new J(V[0],V[1],V[2]);break;case 4:this[he]=new J(V[0],V[1],V[2],V[3]);break;default:throw new Error("Arg list too long.")}},pe(y[j],J);var E,le=new J(function(){});for(E in le)"XMLHttpRequest"===j&&"responseBlob"===E||function(V){"function"==typeof le[V]?y[j].prototype[V]=function(){return this[he][V].apply(this[he],arguments)}:t(y[j].prototype,V,{set:function(X){"function"==typeof X?(this[he][V]=p(X,j+"."+V),pe(this[he][V],X)):this[he][V]=X},get:function(){return this[he][V]}})}(E);for(E in J)"prototype"!==E&&J.hasOwnProperty(E)&&(y[j][E]=J[E])}}function $(j,J,le){for(var E=j;E&&!E.hasOwnProperty(J);)E=e(E);!E&&j[J]&&(E=j);var V=m(J),X=null;if(E&&(!(X=E[V])||!E.hasOwnProperty(V))&&(X=E[V]=E[J],B(E&&n(E,J)))){var ae=le(X,V,J);E[J]=function(){return ae(this,arguments)},pe(E[J],X)}return X}function de(j,J,le){var E=null;function V(X){var Z=X.data;return Z.args[Z.cbIdx]=function(){X.invoke.apply(this,arguments)},E.apply(Z.target,Z.args),X}E=$(j,J,function(X){return function(Z,ae){var ze=le(Z,ae);return ze.cbIdx>=0&&"function"==typeof ae[ze.cbIdx]?h(ze.name,ae[ze.cbIdx],ze,V):X.apply(Z,ae)}})}function pe(j,J){j[m("OriginalDelegate")]=J}var Ge=!1,Se=!1;function lt(){if(Ge)return Se;Ge=!0;try{var j=M.navigator.userAgent;(-1!==j.indexOf("MSIE ")||-1!==j.indexOf("Trident/")||-1!==j.indexOf("Edge/"))&&(Se=!0)}catch{}return Se}Zone.__load_patch("ZoneAwarePromise",function(j,J,le){var E=Object.getOwnPropertyDescriptor,V=Object.defineProperty,Z=le.symbol,ae=[],ze=!0===j[Z("DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION")],et=Z("Promise"),qe=Z("then"),rt="__creationTrace__";le.onUnhandledError=function(tt){if(le.showUncaughtError()){var Pt=tt&&tt.rejection;Pt?console.error("Unhandled Promise rejection:",Pt instanceof Error?Pt.message:Pt,"; Zone:",tt.zone.name,"; Task:",tt.task&&tt.task.source,"; Value:",Pt,Pt instanceof Error?Pt.stack:void 0):console.error(tt)}},le.microtaskDrainDone=function(){for(var tt=function(){var Pt=ae.shift();try{Pt.zone.runGuarded(function(){throw Pt.throwOriginal?Pt.rejection:Pt})}catch(Ct){!function(tt){le.onUnhandledError(tt);try{var Pt=J[dt];"function"==typeof Pt&&Pt.call(this,tt)}catch{}}(Ct)}};ae.length;)tt()};var dt=Z("unhandledPromiseRejectionHandler");function At(tt){return tt&&tt.then}function cn(tt){return tt}function qi(tt){return ge.reject(tt)}var yi=Z("state"),pn=Z("value"),Rn=Z("finally"),Et=Z("parentPromiseValue"),gi=Z("parentPromiseState"),ti="Promise.then",Hn=null,Qn=!0,zt=!1,Bi=0;function _n(tt,Pt){return function(Ct){try{cr(tt,Pt,Ct)}catch(Je){cr(tt,!1,Je)}}}var Pn=function(){var tt=!1;return function(Ct){return function(){tt||(tt=!0,Ct.apply(null,arguments))}}},_i="Promise resolved with itself",On=Z("currentTaskTrace");function cr(tt,Pt,Ct){var Je=Pn();if(tt===Ct)throw new TypeError(_i);if(tt[yi]===Hn){var Zt=null;try{("object"==typeof Ct||"function"==typeof Ct)&&(Zt=Ct&&Ct.then)}catch(li){return Je(function(){cr(tt,!1,li)})(),tt}if(Pt!==zt&&Ct instanceof ge&&Ct.hasOwnProperty(yi)&&Ct.hasOwnProperty(pn)&&Ct[yi]!==Hn)Sa(Ct),cr(tt,Ct[yi],Ct[pn]);else if(Pt!==zt&&"function"==typeof Zt)try{Zt.call(Ct,Je(_n(tt,Pt)),Je(_n(tt,!1)))}catch(li){Je(function(){cr(tt,!1,li)})()}else{tt[yi]=Pt;var Ln=tt[pn];if(tt[pn]=Ct,tt[Rn]===Rn&&Pt===Qn&&(tt[yi]=tt[gi],tt[pn]=tt[Et]),Pt===zt&&Ct instanceof Error){var Dn=J.currentTask&&J.currentTask.data&&J.currentTask.data[rt];Dn&&V(Ct,On,{configurable:!0,enumerable:!1,writable:!0,value:Dn})}for(var ni=0;ni<Ln.length;)yr(tt,Ln[ni++],Ln[ni++],Ln[ni++],Ln[ni++]);if(0==Ln.length&&Pt==zt){tt[yi]=Bi;var ii=Ct;try{throw new Error("Uncaught (in promise): "+function(tt){return tt&&tt.toString===Object.prototype.toString?(tt.constructor&&tt.constructor.name||"")+": "+JSON.stringify(tt):tt?tt.toString():Object.prototype.toString.call(tt)}(Ct)+(Ct&&Ct.stack?"\n"+Ct.stack:""))}catch(li){ii=li}ze&&(ii.throwOriginal=!0),ii.rejection=Ct,ii.promise=tt,ii.zone=J.current,ii.task=J.currentTask,ae.push(ii),le.scheduleMicroTask()}}}return tt}var ir=Z("rejectionHandledHandler");function Sa(tt){if(tt[yi]===Bi){try{var Pt=J[ir];Pt&&"function"==typeof Pt&&Pt.call(this,{rejection:tt[pn],promise:tt})}catch{}tt[yi]=zt;for(var Ct=0;Ct<ae.length;Ct++)tt===ae[Ct].promise&&ae.splice(Ct,1)}}function yr(tt,Pt,Ct,Je,Zt){Sa(tt);var Ln=tt[yi],Dn=Ln?"function"==typeof Je?Je:cn:"function"==typeof Zt?Zt:qi;Pt.scheduleMicroTask(ti,function(){try{var ni=tt[pn],ii=!!Ct&&Rn===Ct[Rn];ii&&(Ct[Et]=ni,Ct[gi]=Ln);var li=Pt.run(Dn,void 0,ii&&Dn!==qi&&Dn!==cn?[]:[ni]);cr(Ct,!0,li)}catch(xi){cr(Ct,!1,xi)}},Ct)}var ft=function(){},me=j.AggregateError,ge=function(){function tt(Pt){var Ct=this;if(!(Ct instanceof tt))throw new Error("Must be an instanceof Promise.");Ct[yi]=Hn,Ct[pn]=[];try{var Je=Pn();Pt&&Pt(Je(_n(Ct,Qn)),Je(_n(Ct,zt)))}catch(Zt){cr(Ct,!1,Zt)}}return tt.toString=function(){return"function ZoneAwarePromise() { [native code] }"},tt.resolve=function(Pt){return cr(new this(null),Qn,Pt)},tt.reject=function(Pt){return cr(new this(null),zt,Pt)},tt.any=function(Pt){if(!Pt||"function"!=typeof Pt[Symbol.iterator])return Promise.reject(new me([],"All promises were rejected"));var Ct=[],Je=0;try{for(var Zt=0,Ln=Pt;Zt<Ln.length;Zt++)Je++,Ct.push(tt.resolve(Ln[Zt]))}catch{return Promise.reject(new me([],"All promises were rejected"))}if(0===Je)return Promise.reject(new me([],"All promises were rejected"));var ni=!1,ii=[];return new tt(function(li,xi){for(var pr=0;pr<Ct.length;pr++)Ct[pr].then(function(No){ni||(ni=!0,li(No))},function(No){ii.push(No),0==--Je&&(ni=!0,xi(new me(ii,"All promises were rejected")))})})},tt.race=function(Pt){var Ct,Je,Zt=new this(function(xi,pr){Ct=xi,Je=pr});function Ln(xi){Ct(xi)}function Dn(xi){Je(xi)}for(var ni=0,ii=Pt;ni<ii.length;ni++){var li=ii[ni];At(li)||(li=this.resolve(li)),li.then(Ln,Dn)}return Zt},tt.all=function(Pt){return tt.allWithCallback(Pt)},tt.allSettled=function(Pt){return(this&&this.prototype instanceof tt?this:tt).allWithCallback(Pt,{thenCallback:function(Je){return{status:"fulfilled",value:Je}},errorCallback:function(Je){return{status:"rejected",reason:Je}}})},tt.allWithCallback=function(Pt,Ct){for(var Je,Zt,Ln=new this(function(Zr,xo){Je=Zr,Zt=xo}),Dn=2,ni=0,ii=[],li=function(Zr){At(Zr)||(Zr=xi.resolve(Zr));var xo=ni;try{Zr.then(function(Hr){ii[xo]=Ct?Ct.thenCallback(Hr):Hr,0==--Dn&&Je(ii)},function(Hr){Ct?(ii[xo]=Ct.errorCallback(Hr),0==--Dn&&Je(ii)):Zt(Hr)})}catch(Hr){Zt(Hr)}Dn++,ni++},xi=this,pr=0,No=Pt;pr<No.length;pr++)li(No[pr]);return 0==(Dn-=2)&&Je(ii),Ln},Object.defineProperty(tt.prototype,Symbol.toStringTag,{get:function(){return"Promise"},enumerable:!1,configurable:!0}),Object.defineProperty(tt.prototype,Symbol.species,{get:function(){return tt},enumerable:!1,configurable:!0}),tt.prototype.then=function(Pt,Ct){var Je,Zt=null===(Je=this.constructor)||void 0===Je?void 0:Je[Symbol.species];(!Zt||"function"!=typeof Zt)&&(Zt=this.constructor||tt);var Ln=new Zt(ft),Dn=J.current;return this[yi]==Hn?this[pn].push(Dn,Ln,Pt,Ct):yr(this,Dn,Ln,Pt,Ct),Ln},tt.prototype.catch=function(Pt){return this.then(null,Pt)},tt.prototype.finally=function(Pt){var Ct,Je=null===(Ct=this.constructor)||void 0===Ct?void 0:Ct[Symbol.species];(!Je||"function"!=typeof Je)&&(Je=tt);var Zt=new Je(ft);Zt[Rn]=Rn;var Ln=J.current;return this[yi]==Hn?this[pn].push(Ln,Zt,Pt,Pt):yr(this,Ln,Zt,Pt,Pt),Zt},tt}();ge.resolve=ge.resolve,ge.reject=ge.reject,ge.race=ge.race,ge.all=ge.all;var Pe=j[et]=j.Promise;j.Promise=ge;var Mn=Z("thenPatched");function ur(tt){var Pt=tt.prototype,Ct=E(Pt,"then");if(!Ct||!1!==Ct.writable&&Ct.configurable){var Je=Pt.then;Pt[qe]=Je,tt.prototype.then=function(Zt,Ln){var Dn=this;return new ge(function(ii,li){Je.call(Dn,ii,li)}).then(Zt,Ln)},tt[Mn]=!0}}return le.patchThen=ur,Pe&&(ur(Pe),$(j,"fetch",function(tt){return function(tt){return function(Pt,Ct){var Je=tt.apply(Pt,Ct);if(Je instanceof ge)return Je;var Zt=Je.constructor;return Zt[Mn]||ur(Zt),Je}}(tt)})),Promise[J.__symbol__("uncaughtPromiseErrors")]=ae,ge}),Zone.__load_patch("toString",function(j){var J=Function.prototype.toString,le=m("OriginalDelegate"),E=m("Promise"),V=m("Error"),X=function(){if("function"==typeof this){var et=this[le];if(et)return"function"==typeof et?J.call(et):Object.prototype.toString.call(et);if(this===Promise){var qe=j[E];if(qe)return J.call(qe)}if(this===Error){var rt=j[V];if(rt)return J.call(rt)}}return J.call(this)};X[le]=J,Function.prototype.toString=X;var Z=Object.prototype.toString;Object.prototype.toString=function(){return"function"==typeof Promise&&this instanceof Promise?"[object Promise]":Z.call(this)}});var Mt=!1;if(typeof window<"u")try{var pt=Object.defineProperty({},"passive",{get:function(){Mt=!0}});window.addEventListener("test",pt,pt),window.removeEventListener("test",pt,pt)}catch{Mt=!1}var si,Ni,Li,Y,L,ke={useG:!0},Tn={},wt={},on=new RegExp("^"+u+"(\\w+)(true|false)$"),Ce=m("propagationStopped");function mt(j,J){var le=(J?J(j):j)+d,E=(J?J(j):j)+c,V=u+le,X=u+E;Tn[j]={},Tn[j][d]=V,Tn[j][c]=X}function ht(j,J,le,E){var V=E&&E.add||o,X=E&&E.rm||a,Z=E&&E.listeners||"eventListeners",ae=E&&E.rmAll||"removeAllListeners",ze=m(V),et="."+V+":",qe="prependListener",rt="."+qe+":",dt=function(Rn,Et,gi){if(!Rn.isRemoved){var Hn,ti=Rn.callback;"object"==typeof ti&&ti.handleEvent&&(Rn.callback=function(Bi){return ti.handleEvent(Bi)},Rn.originalDelegate=ti);try{Rn.invoke(Rn,Et,[gi])}catch(Bi){Hn=Bi}var Qn=Rn.options;return Qn&&"object"==typeof Qn&&Qn.once&&Et[X].call(Et,gi.type,Rn.originalDelegate?Rn.originalDelegate:Rn.callback,Qn),Hn}};function St(Rn,Et,gi){if(Et=Et||j.event){var ti=Rn||Et.target||j,Hn=ti[Tn[Et.type][gi?c:d]];if(Hn){var Qn=[];if(1===Hn.length)(zt=dt(Hn[0],ti,Et))&&Qn.push(zt);else for(var Bi=Hn.slice(),_n=0;_n<Bi.length&&(!Et||!0!==Et[Ce]);_n++){var zt;(zt=dt(Bi[_n],ti,Et))&&Qn.push(zt)}if(1===Qn.length)throw Qn[0];var Pn=function(_i){var On=Qn[_i];J.nativeScheduleMicroTask(function(){throw On})};for(_n=0;_n<Qn.length;_n++)Pn(_n)}}}var At=function(Rn){return St(this,Rn,!1)},cn=function(Rn){return St(this,Rn,!0)};function qi(Rn,Et){if(!Rn)return!1;var gi=!0;Et&&void 0!==Et.useG&&(gi=Et.useG);var ti=Et&&Et.vh,Hn=!0;Et&&void 0!==Et.chkDup&&(Hn=Et.chkDup);var Qn=!1;Et&&void 0!==Et.rt&&(Qn=Et.rt);for(var zt=Rn;zt&&!zt.hasOwnProperty(V);)zt=e(zt);if(!zt&&Rn[V]&&(zt=Rn),!zt||zt[ze])return!1;var ir,Bi=Et&&Et.eventNameToString,_n={},Pn=zt[ze]=zt[V],_i=zt[m(X)]=zt[X],On=zt[m(Z)]=zt[Z],cr=zt[m(ae)]=zt[ae];Et&&Et.prepend&&(ir=zt[m(Et.prepend)]=zt[Et.prepend]);var Pe=gi?function(Je){if(!_n.isExisting)return Pn.call(_n.target,_n.eventName,_n.capture?cn:At,_n.options)}:function(Je){return Pn.call(_n.target,_n.eventName,Je.invoke,_n.options)},Mn=gi?function(Je){if(!Je.isRemoved){var Zt=Tn[Je.eventName],Ln=void 0;Zt&&(Ln=Zt[Je.capture?c:d]);var Dn=Ln&&Je.target[Ln];if(Dn)for(var ni=0;ni<Dn.length;ni++)if(Dn[ni]===Je){Dn.splice(ni,1),Je.isRemoved=!0,0===Dn.length&&(Je.allRemoved=!0,Je.target[Ln]=null);break}}if(Je.allRemoved)return _i.call(Je.target,Je.eventName,Je.capture?cn:At,Je.options)}:function(Je){return _i.call(Je.target,Je.eventName,Je.invoke,Je.options)},hl=Et&&Et.diff?Et.diff:function(Je,Zt){var Ln=typeof Zt;return"function"===Ln&&Je.callback===Zt||"object"===Ln&&Je.originalDelegate===Zt},tt=Zone[m("UNPATCHED_EVENTS")],Pt=j[m("PASSIVE_EVENTS")],Ct=function(Je,Zt,Ln,Dn,ni,ii){return void 0===ni&&(ni=!1),void 0===ii&&(ii=!1),function(){var li=this||j,xi=arguments[0];Et&&Et.transferEventName&&(xi=Et.transferEventName(xi));var pr=arguments[1];if(!pr)return Je.apply(this,arguments);if(Q&&"uncaughtException"===xi)return Je.apply(this,arguments);var No=!1;if("function"!=typeof pr){if(!pr.handleEvent)return Je.apply(this,arguments);No=!0}if(!ti||ti(Je,pr,li,arguments)){var Yc=Mt&&!!Pt&&-1!==Pt.indexOf(xi),Zr=function(Je,Zt){return!Mt&&"object"==typeof Je&&Je?!!Je.capture:Mt&&Zt?"boolean"==typeof Je?{capture:Je,passive:!0}:Je?"object"==typeof Je&&!1!==Je.passive?Object.assign(Object.assign({},Je),{passive:!0}):Je:{passive:!0}:Je}(arguments[2],Yc);if(tt)for(var xo=0;xo<tt.length;xo++)if(xi===tt[xo])return Yc?Je.call(li,xi,pr,Zr):Je.apply(this,arguments);var Hr=!!Zr&&("boolean"==typeof Zr||Zr.capture),Im=!(!Zr||"object"!=typeof Zr)&&Zr.once,Wie=Zone.current,OA=Tn[xi];OA||(mt(xi,Bi),OA=Tn[xi]);var YV=OA[Hr?c:d],Am=li[YV],QV=!1;if(Am){if(QV=!0,Hn)for(xo=0;xo<Am.length;xo++)if(hl(Am[xo],pr))return}else Am=li[YV]=[];var nC,ZV=li.constructor.name,KV=wt[ZV];KV&&(nC=KV[xi]),nC||(nC=ZV+Zt+(Bi?Bi(xi):xi)),_n.options=Zr,Im&&(_n.options.once=!1),_n.target=li,_n.capture=Hr,_n.eventName=xi,_n.isExisting=QV;var E_=gi?ke:void 0;E_&&(E_.taskData=_n);var Yd=Wie.scheduleEventTask(nC,pr,E_,Ln,Dn);if(_n.target=null,E_&&(E_.taskData=null),Im&&(Zr.once=!0),!Mt&&"boolean"==typeof Yd.options||(Yd.options=Zr),Yd.target=li,Yd.capture=Hr,Yd.eventName=xi,No&&(Yd.originalDelegate=pr),ii?Am.unshift(Yd):Am.push(Yd),ni)return li}}};return zt[V]=Ct(Pn,et,Pe,Mn,Qn),ir&&(zt[qe]=Ct(ir,rt,function(Je){return ir.call(_n.target,_n.eventName,Je.invoke,_n.options)},Mn,Qn,!0)),zt[X]=function(){var Je=this||j,Zt=arguments[0];Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));var Ln=arguments[2],Dn=!!Ln&&("boolean"==typeof Ln||Ln.capture),ni=arguments[1];if(!ni)return _i.apply(this,arguments);if(!ti||ti(_i,ni,Je,arguments)){var li,ii=Tn[Zt];ii&&(li=ii[Dn?c:d]);var xi=li&&Je[li];if(xi)for(var pr=0;pr<xi.length;pr++){var No=xi[pr];if(hl(No,ni))return xi.splice(pr,1),No.isRemoved=!0,0===xi.length&&(No.allRemoved=!0,Je[li]=null,"string"==typeof Zt)&&(Je[u+"ON_PROPERTY"+Zt]=null),No.zone.cancelTask(No),Qn?Je:void 0}return _i.apply(this,arguments)}},zt[Z]=function(){var Je=this||j,Zt=arguments[0];Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));for(var Ln=[],Dn=oe(Je,Bi?Bi(Zt):Zt),ni=0;ni<Dn.length;ni++){var ii=Dn[ni];Ln.push(ii.originalDelegate?ii.originalDelegate:ii.callback)}return Ln},zt[ae]=function(){var Je=this||j,Zt=arguments[0];if(Zt){Et&&Et.transferEventName&&(Zt=Et.transferEventName(Zt));var xi=Tn[Zt];if(xi){var Yc=Je[xi[d]],Zr=Je[xi[c]];if(Yc)for(var xo=Yc.slice(),Dn=0;Dn<xo.length;Dn++)this[X].call(this,Zt,(Hr=xo[Dn]).originalDelegate?Hr.originalDelegate:Hr.callback,Hr.options);if(Zr)for(xo=Zr.slice(),Dn=0;Dn<xo.length;Dn++){var Hr;this[X].call(this,Zt,(Hr=xo[Dn]).originalDelegate?Hr.originalDelegate:Hr.callback,Hr.options)}}}else{var Ln=Object.keys(Je);for(Dn=0;Dn<Ln.length;Dn++){var ii=on.exec(Ln[Dn]),li=ii&&ii[1];li&&"removeListener"!==li&&this[ae].call(this,li)}this[ae].call(this,"removeListener")}if(Qn)return this},pe(zt[V],Pn),pe(zt[X],_i),cr&&pe(zt[ae],cr),On&&pe(zt[Z],On),!0}for(var yi=[],pn=0;pn<le.length;pn++)yi[pn]=qi(le[pn],E);return yi}function oe(j,J){if(!J){var le=[];for(var E in j){var V=on.exec(E),X=V&&V[1];if(X&&(!J||X===J)){var Z=j[E];if(Z)for(var ae=0;ae<Z.length;ae++)le.push(Z[ae])}}return le}var ze=Tn[J];ze||(mt(J),ze=Tn[J]);var et=j[ze[d]],qe=j[ze[c]];return et?qe?et.concat(qe):et.slice():qe?qe.slice():[]}function at(j,J){var le=j.Event;le&&le.prototype&&J.patchMethod(le.prototype,"stopImmediatePropagation",function(E){return function(V,X){V[Ce]=!0,E&&E.apply(V,X)}})}function Ye(j,J,le,E,V){var X=Zone.__symbol__(E);if(!J[X]){var Z=J[X]=J[E];J[E]=function(ae,ze,et){return ze&&ze.prototype&&V.forEach(function(qe){var rt="".concat(le,".").concat(E,"::")+qe,dt=ze.prototype;try{if(dt.hasOwnProperty(qe)){var St=j.ObjectGetOwnPropertyDescriptor(dt,qe);St&&St.value?(St.value=j.wrapWithCurrentZone(St.value,rt),j._redefineProperty(ze.prototype,qe,St)):dt[qe]&&(dt[qe]=j.wrapWithCurrentZone(dt[qe],rt))}else dt[qe]&&(dt[qe]=j.wrapWithCurrentZone(dt[qe],rt))}catch{}}),Z.call(J,ae,ze,et)},j.attachOriginToPatched(J[E],Z)}}function _t(j,J,le){if(!le||0===le.length)return J;var E=le.filter(function(X){return X.target===j});if(!E||0===E.length)return J;var V=E[0].ignoreProperties;return J.filter(function(X){return-1===V.indexOf(X)})}function ut(j,J,le,E){j&&ce(j,_t(j,J,le),E)}function an(j){return Object.getOwnPropertyNames(j).filter(function(J){return J.startsWith("on")&&J.length>2}).map(function(J){return J.substring(2)})}function yt(j,J,le){var E=le.configurable;return hn(j,J,le=Le(j,J,le),E)}function en(j,J){return j&&j[L]&&j[L][J]}function Le(j,J,le){return Object.isFrozen(le)||(le.configurable=!0),le.configurable||(!j[L]&&!Object.isFrozen(j)&&Ni(j,L,{writable:!0,value:{}}),j[L]&&(j[L][J]=!0)),le}function hn(j,J,le,E){try{return Ni(j,J,le)}catch(Z){if(!le.configurable)throw Z;typeof E>"u"?delete le.configurable:le.configurable=E;try{return Ni(j,J,le)}catch(ae){var V=!1;if(("createdCallback"===J||"attachedCallback"===J||"detachedCallback"===J||"attributeChangedCallback"===J)&&(V=!0),!V)throw ae;var X=null;try{X=JSON.stringify(le)}catch{X=le.toString()}console.log("Attempting to configure '".concat(J,"' with descriptor '").concat(X,"' on object '").concat(j,"' and got error, giving up: ").concat(ae))}}}Zone.__load_patch("util",function(j,J,le){var E=an(j);le.patchOnProperties=ce,le.patchMethod=$,le.bindArguments=R,le.patchMacroTask=de;var V=J.__symbol__("BLACK_LISTED_EVENTS"),X=J.__symbol__("UNPATCHED_EVENTS");j[X]&&(j[V]=j[X]),j[V]&&(J[V]=J[X]=j[V]),le.patchEventPrototype=at,le.patchEventTarget=ht,le.isIEOrEdge=lt,le.ObjectDefineProperty=t,le.ObjectGetOwnPropertyDescriptor=n,le.ObjectCreate=i,le.ArraySlice=r,le.patchClass=_e,le.wrapWithCurrentZone=p,le.filterProperties=_t,le.attachOriginToPatched=pe,le._redefineProperty=Object.defineProperty,le.patchCallbacks=Ye,le.getGlobalObjects=function(){return{globalSources:wt,zoneSymbolEventNames:Tn,eventNames:E,isBrowser:we,isMix:Qe,isNode:Q,TRUE_STR:c,FALSE_STR:d,ZONE_SYMBOL_PREFIX:u,ADD_EVENT_LISTENER_STR:o,REMOVE_EVENT_LISTENER_STR:a}}});var j,Wo=uu(uu(uu(uu(uu(uu(uu(uu([],["abort","animationcancel","animationend","animationiteration","auxclick","beforeinput","blur","cancel","canplay","canplaythrough","change","compositionstart","compositionupdate","compositionend","cuechange","click","close","contextmenu","curechange","dblclick","drag","dragend","dragenter","dragexit","dragleave","dragover","drop","durationchange","emptied","ended","error","focus","focusin","focusout","gotpointercapture","input","invalid","keydown","keypress","keyup","load","loadstart","loadeddata","loadedmetadata","lostpointercapture","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","mousewheel","orientationchange","pause","play","playing","pointercancel","pointerdown","pointerenter","pointerleave","pointerlockchange","mozpointerlockchange","webkitpointerlockerchange","pointerlockerror","mozpointerlockerror","webkitpointerlockerror","pointermove","pointout","pointerover","pointerup","progress","ratechange","reset","resize","scroll","seeked","seeking","select","selectionchange","selectstart","show","sort","stalled","submit","suspend","timeupdate","volumechange","touchcancel","touchmove","touchstart","touchend","transitioncancel","transitionend","waiting","wheel"],!0),["webglcontextrestored","webglcontextlost","webglcontextcreationerror"],!0),["autocomplete","autocompleteerror"],!0),["toggle"],!0),["afterscriptexecute","beforescriptexecute","DOMContentLoaded","freeze","fullscreenchange","mozfullscreenchange","webkitfullscreenchange","msfullscreenchange","fullscreenerror","mozfullscreenerror","webkitfullscreenerror","msfullscreenerror","readystatechange","visibilitychange","resume"],!0),["absolutedeviceorientation","afterinput","afterprint","appinstalled","beforeinstallprompt","beforeprint","beforeunload","devicelight","devicemotion","deviceorientation","deviceorientationabsolute","deviceproximity","hashchange","languagechange","message","mozbeforepaint","offline","online","paint","pageshow","pagehide","popstate","rejectionhandled","storage","unhandledrejection","unload","userproximity","vrdisplayconnected","vrdisplaydisconnected","vrdisplaypresentchange"],!0),["beforecopy","beforecut","beforepaste","copy","cut","paste","dragstart","loadend","animationstart","search","transitionrun","transitionstart","webkitanimationend","webkitanimationiteration","webkitanimationstart","webkittransitionend"],!0),["activate","afterupdate","ariarequest","beforeactivate","beforedeactivate","beforeeditfocus","beforeupdate","cellchange","controlselect","dataavailable","datasetchanged","datasetcomplete","errorupdate","filterchange","layoutcomplete","losecapture","move","moveend","movestart","propertychange","resizeend","resizestart","rowenter","rowexit","rowsdelete","rowsinserted","command","compassneedscalibration","deactivate","help","mscontentzoom","msmanipulationstatechanged","msgesturechange","msgesturedoubletap","msgestureend","msgesturehold","msgesturestart","msgesturetap","msgotpointercapture","msinertiastart","mslostpointercapture","mspointercancel","mspointerdown","mspointerenter","mspointerhover","mspointerleave","mspointermove","mspointerout","mspointerover","mspointerup","pointerout","mssitemodejumplistitemremoved","msthumbnailclick","stop","storagecommit"],!0);(j=typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{})[("legacyPatch",(j.__Zone_symbol_prefix||"__zone_symbol__")+"legacyPatch")]=function(){var E=j.Zone;E.__load_patch("defineProperty",function(V,X,Z){Z._redefineProperty=yt,si=Zone.__symbol__,Ni=Object[si("defineProperty")]=Object.defineProperty,Li=Object[si("getOwnPropertyDescriptor")]=Object.getOwnPropertyDescriptor,Y=Object.create,L=si("unconfigurables"),Object.defineProperty=function(j,J,le){if(en(j,J))throw new TypeError("Cannot assign to read only property '"+J+"' of "+j);var E=le.configurable;return"prototype"!==J&&(le=Le(j,J,le)),hn(j,J,le,E)},Object.defineProperties=function(j,J){Object.keys(J).forEach(function(Z){Object.defineProperty(j,Z,J[Z])});for(var le=0,E=Object.getOwnPropertySymbols(J);le<E.length;le++){var V=E[le];Object.getOwnPropertyDescriptor(J,V)?.enumerable&&Object.defineProperty(j,V,J[V])}return j},Object.create=function(j,J){return"object"==typeof J&&!Object.isFrozen(J)&&Object.keys(J).forEach(function(le){J[le]=Le(j,le,J[le])}),Y(j,J)},Object.getOwnPropertyDescriptor=function(j,J){var le=Li(j,J);return le&&en(j,J)&&(le.configurable=!1),le}}),E.__load_patch("registerElement",function(V,X,Z){!function(j,J){var le=J.getGlobalObjects();(le.isBrowser||le.isMix)&&"registerElement"in j.document&&J.patchCallbacks(J,document,"Document","registerElement",["createdCallback","attachedCallback","detachedCallback","attributeChangedCallback"])}(V,Z)}),E.__load_patch("EventTargetLegacy",function(V,X,Z){(function(j,J){var le=J.getGlobalObjects(),E=le.eventNames,V=le.globalSources,X=le.zoneSymbolEventNames,Z=le.TRUE_STR,ae=le.FALSE_STR,ze=le.ZONE_SYMBOL_PREFIX,qe="ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket".split(","),rt="EventTarget",dt=[],St=j.wtf,At="Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video".split(",");St?dt=At.map(function(yr){return"HTML"+yr+"Element"}).concat(qe):j[rt]?dt.push(rt):dt=qe;for(var cn=j.__Zone_disable_IE_check||!1,qi=j.__Zone_enable_cross_context_check||!1,yi=J.isIEOrEdge(),Rn="[object FunctionWrapper]",Et="function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }",gi={MSPointerCancel:"pointercancel",MSPointerDown:"pointerdown",MSPointerEnter:"pointerenter",MSPointerHover:"pointerhover",MSPointerLeave:"pointerleave",MSPointerMove:"pointermove",MSPointerOut:"pointerout",MSPointerOver:"pointerover",MSPointerUp:"pointerup"},ti=0;ti<E.length;ti++){var Bi=ze+((Hn=E[ti])+ae),_n=ze+(Hn+Z);X[Hn]={},X[Hn][ae]=Bi,X[Hn][Z]=_n}for(ti=0;ti<At.length;ti++)for(var Pn=At[ti],_i=V[Pn]={},On=0;On<E.length;On++){var Hn;_i[Hn=E[On]]=Pn+".addEventListener:"+Hn}var ir=[];for(ti=0;ti<dt.length;ti++){var Sa=j[dt[ti]];ir.push(Sa&&Sa.prototype)}J.patchEventTarget(j,J,ir,{vh:function(yr,dr,ft,me){if(!cn&&yi)if(qi)try{if((ge=dr.toString())===Rn||ge==Et)return yr.apply(ft,me),!1}catch{return yr.apply(ft,me),!1}else{var ge;if((ge=dr.toString())===Rn||ge==Et)return yr.apply(ft,me),!1}else if(qi)try{dr.toString()}catch{return yr.apply(ft,me),!1}return!0},transferEventName:function(yr){return gi[yr]||yr}}),Zone[J.symbol("patchEventTarget")]=!!j[rt]})(V,Z),function(j,J){var le=j.getGlobalObjects();if((!le.isNode||le.isMix)&&!function(j,J){var le=j.getGlobalObjects();if((le.isBrowser||le.isMix)&&!j.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&typeof Element<"u"){var X=j.ObjectGetOwnPropertyDescriptor(Element.prototype,"onclick");if(X&&!X.configurable)return!1;if(X){j.ObjectDefineProperty(Element.prototype,"onclick",{enumerable:!0,configurable:!0,get:function(){return!0}});var ae=!!document.createElement("div").onclick;return j.ObjectDefineProperty(Element.prototype,"onclick",X),ae}}var ze=J.XMLHttpRequest;if(!ze)return!1;var et="onreadystatechange",qe=ze.prototype,rt=j.ObjectGetOwnPropertyDescriptor(qe,et);if(rt)return j.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return!0}}),ae=!!(dt=new ze).onreadystatechange,j.ObjectDefineProperty(qe,et,rt||{}),ae;var St=j.symbol("fake");j.ObjectDefineProperty(qe,et,{enumerable:!0,configurable:!0,get:function(){return this[St]},set:function(yi){this[St]=yi}});var dt,At=function(){};return(dt=new ze).onreadystatechange=At,ae=dt[St]===At,dt.onreadystatechange=null,ae}(j,J)){var X=typeof WebSocket<"u";(function(j){for(var J=j.symbol("unbound"),le=function(V){var X=Wo[V],Z="on"+X;self.addEventListener(X,function(ae){var et,qe,ze=ae.target;for(qe=ze?ze.constructor.name+"."+Z:"unknown."+Z;ze;)ze[Z]&&!ze[Z][J]&&((et=j.wrapWithCurrentZone(ze[Z],qe))[J]=ze[Z],ze[Z]=et),ze=ze.parentElement},!0)},E=0;E<Wo.length;E++)le(E)})(j),j.patchClass("XMLHttpRequest"),X&&function(j,J){var le=j.getGlobalObjects(),E=le.ADD_EVENT_LISTENER_STR,V=le.REMOVE_EVENT_LISTENER_STR,X=J.WebSocket;J.EventTarget||j.patchEventTarget(J,j,[X.prototype]),J.WebSocket=function(ze,et){var rt,dt,qe=arguments.length>1?new X(ze,et):new X(ze),St=j.ObjectGetOwnPropertyDescriptor(qe,"onmessage");return St&&!1===St.configurable?(rt=j.ObjectCreate(qe),dt=qe,[E,V,"send","close"].forEach(function(At){rt[At]=function(){var cn=j.ArraySlice.call(arguments);if(At===E||At===V){var qi=cn.length>0?cn[0]:void 0;if(qi){var yi=Zone.__symbol__("ON_PROPERTY"+qi);qe[yi]=rt[yi]}}return qe[At].apply(qe,cn)}})):rt=qe,j.patchOnProperties(rt,["close","error","message","open"],dt),rt};var Z=J.WebSocket;for(var ae in X)Z[ae]=X[ae]}(j,J),Zone[j.symbol("patchEvents")]=!0}}(Z,V)})};var wa=m("zoneTask");function pl(j,J,le,E){var V=null,X=null;le+=E;var Z={};function ae(et){var qe=et.data;return qe.args[0]=function(){return et.invoke.apply(this,arguments)},qe.handleId=V.apply(j,qe.args),et}function ze(et){return X.call(j,et.data.handleId)}V=$(j,J+=E,function(et){return function(qe,rt){if("function"==typeof rt[0]){var dt={isPeriodic:"Interval"===E,delay:"Timeout"===E||"Interval"===E?rt[1]||0:void 0,args:rt},St=rt[0];rt[0]=function(){try{return St.apply(this,arguments)}finally{dt.isPeriodic||("number"==typeof dt.handleId?delete Z[dt.handleId]:dt.handleId&&(dt.handleId[wa]=null))}};var At=h(J,rt[0],dt,ae,ze);if(!At)return At;var cn=At.data.handleId;return"number"==typeof cn?Z[cn]=At:cn&&(cn[wa]=At),cn&&cn.ref&&cn.unref&&"function"==typeof cn.ref&&"function"==typeof cn.unref&&(At.ref=cn.ref.bind(cn),At.unref=cn.unref.bind(cn)),"number"==typeof cn||cn?cn:At}return et.apply(j,rt)}}),X=$(j,le,function(et){return function(qe,rt){var St,dt=rt[0];"number"==typeof dt?St=Z[dt]:(St=dt&&dt[wa])||(St=dt),St&&"string"==typeof St.type?"notScheduled"!==St.state&&(St.cancelFn&&St.data.isPeriodic||0===St.runCount)&&("number"==typeof dt?delete Z[dt]:dt&&(dt[wa]=null),St.zone.cancelTask(St)):et.apply(j,rt)}})}Zone.__load_patch("legacy",function(j){var J=j[Zone.__symbol__("legacyPatch")];J&&J()}),Zone.__load_patch("queueMicrotask",function(j,J,le){le.patchMethod(j,"queueMicrotask",function(E){return function(V,X){J.current.scheduleMicroTask("queueMicrotask",X[0])}})}),Zone.__load_patch("timers",function(j){var J="set",le="clear";pl(j,J,le,"Timeout"),pl(j,J,le,"Interval"),pl(j,J,le,"Immediate")}),Zone.__load_patch("requestAnimationFrame",function(j){pl(j,"request","cancel","AnimationFrame"),pl(j,"mozRequest","mozCancel","AnimationFrame"),pl(j,"webkitRequest","webkitCancel","AnimationFrame")}),Zone.__load_patch("blocking",function(j,J){for(var le=["alert","prompt","confirm"],E=0;E<le.length;E++)$(j,le[E],function(X,Z,ae){return function(ze,et){return J.current.run(X,j,et,ae)}})}),Zone.__load_patch("EventTarget",function(j,J,le){(function(j,J){J.patchEventPrototype(j,J)})(j,le),function(j,J){if(!Zone[J.symbol("patchEventTarget")]){for(var le=J.getGlobalObjects(),E=le.eventNames,V=le.zoneSymbolEventNames,X=le.TRUE_STR,Z=le.FALSE_STR,ae=le.ZONE_SYMBOL_PREFIX,ze=0;ze<E.length;ze++){var et=E[ze],dt=ae+(et+Z),St=ae+(et+X);V[et]={},V[et][Z]=dt,V[et][X]=St}var At=j.EventTarget;At&&At.prototype&&J.patchEventTarget(j,J,[At&&At.prototype])}}(j,le);var E=j.XMLHttpRequestEventTarget;E&&E.prototype&&le.patchEventTarget(j,le,[E.prototype])}),Zone.__load_patch("MutationObserver",function(j,J,le){_e("MutationObserver"),_e("WebKitMutationObserver")}),Zone.__load_patch("IntersectionObserver",function(j,J,le){_e("IntersectionObserver")}),Zone.__load_patch("FileReader",function(j,J,le){_e("FileReader")}),Zone.__load_patch("on_property",function(j,J,le){!function(j,J){if((!Q||Qe)&&!Zone[j.symbol("patchEvents")]){var le=J.__Zone_ignore_on_properties,E=[];if(we){var V=window;E=E.concat(["Document","SVGElement","Element","HTMLElement","HTMLBodyElement","HTMLMediaElement","HTMLFrameSetElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement","Worker"]);var X=function(){try{var j=M.navigator.userAgent;if(-1!==j.indexOf("MSIE ")||-1!==j.indexOf("Trident/"))return!0}catch{}return!1}()?[{target:V,ignoreProperties:["error"]}]:[];ut(V,an(V),le&&le.concat(X),e(V))}E=E.concat(["XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","WebSocket"]);for(var Z=0;Z<E.length;Z++){var ae=J[E[Z]];ae&&ae.prototype&&ut(ae.prototype,an(ae.prototype),le)}}}(le,j)}),Zone.__load_patch("customElements",function(j,J,le){!function(j,J){var le=J.getGlobalObjects();(le.isBrowser||le.isMix)&&j.customElements&&"customElements"in j&&J.patchCallbacks(J,j.customElements,"customElements","define",["connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback"])}(j,le)}),Zone.__load_patch("XHR",function(j,J){!function(et){var qe=et.XMLHttpRequest;if(qe){var rt=qe.prototype,St=rt[s],At=rt[l];if(!St){var cn=et.XMLHttpRequestEventTarget;if(cn){var qi=cn.prototype;St=qi[s],At=qi[l]}}var yi="readystatechange",pn="scheduled",ti=$(rt,"open",function(){return function(Pn,_i){return Pn[E]=0==_i[2],Pn[Z]=_i[1],ti.apply(Pn,_i)}}),Qn=m("fetchTaskAborting"),zt=m("fetchTaskScheduling"),Bi=$(rt,"send",function(){return function(Pn,_i){if(!0===J.current[zt]||Pn[E])return Bi.apply(Pn,_i);var On={target:Pn,url:Pn[Z],isPeriodic:!1,args:_i,aborted:!1},cr=h("XMLHttpRequest.send",Et,On,Rn,gi);Pn&&!0===Pn[ae]&&!On.aborted&&cr.state===pn&&cr.invoke()}}),_n=$(rt,"abort",function(){return function(Pn,_i){var On=function(Pn){return Pn[le]}(Pn);if(On&&"string"==typeof On.type){if(null==On.cancelFn||On.data&&On.data.aborted)return;On.zone.cancelTask(On)}else if(!0===J.current[Qn])return _n.apply(Pn,_i)}})}function Rn(Pn){var _i=Pn.data,On=_i.target;On[X]=!1,On[ae]=!1;var cr=On[V];St||(St=On[s],At=On[l]),cr&&At.call(On,yi,cr);var ir=On[V]=function(){if(On.readyState===On.DONE)if(!_i.aborted&&On[X]&&Pn.state===pn){var yr=On[J.__symbol__("loadfalse")];if(0!==On.status&&yr&&yr.length>0){var dr=Pn.invoke;Pn.invoke=function(){for(var ft=On[J.__symbol__("loadfalse")],me=0;me<ft.length;me++)ft[me]===Pn&&ft.splice(me,1);!_i.aborted&&Pn.state===pn&&dr.call(Pn)},yr.push(Pn)}else Pn.invoke()}else!_i.aborted&&!1===On[X]&&(On[ae]=!0)};return St.call(On,yi,ir),On[le]||(On[le]=Pn),Bi.apply(On,_i.args),On[X]=!0,Pn}function Et(){}function gi(Pn){var _i=Pn.data;return _i.aborted=!0,_n.apply(_i.target,_i.args)}}(j);var le=m("xhrTask"),E=m("xhrSync"),V=m("xhrListener"),X=m("xhrScheduled"),Z=m("xhrURL"),ae=m("xhrErrorBeforeScheduled")}),Zone.__load_patch("geolocation",function(j){j.navigator&&j.navigator.geolocation&&function(j,J){for(var le=j.constructor.name,E=function(X){var et,qe,Z=J[X],ae=j[Z];if(ae){if(!B(n(j,Z)))return"continue";j[Z]=(qe=function(){return et.apply(this,R(arguments,le+"."+Z))},pe(qe,et=ae),qe)}},V=0;V<J.length;V++)E(V)}(j.navigator.geolocation,["getCurrentPosition","watchPosition"])}),Zone.__load_patch("PromiseRejectionEvent",function(j,J){function le(E){return function(V){oe(j,E).forEach(function(Z){var ae=j.PromiseRejectionEvent;if(ae){var ze=new ae(E,{promise:V.promise,reason:V.rejection});Z.invoke(ze)}})}}j.PromiseRejectionEvent&&(J[m("unhandledPromiseRejectionHandler")]=le("unhandledrejection"),J[m("rejectionHandledHandler")]=le("rejectionhandled"))})},"function"==typeof define&&define.amd?define(n):n()});function mn(n){return"function"==typeof n}function Rm(n){let e=n(i=>{Error.call(i),i.stack=(new Error).stack});return e.prototype=Object.create(Error.prototype),e.prototype.constructor=e,e}var iC=Rm(n=>function(e){n(this),this.message=e?`${e.length} errors occurred during unsubscription:\n${e.map((i,r)=>`${r+1}) ${i.toString()}`).join("\n  ")}`:"",this.name="UnsubscriptionError",this.errors=e});function Op(n,t){if(n){let e=n.indexOf(t);0<=e&&n.splice(e,1)}}var En=class{constructor(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}unsubscribe(){let t;if(!this.closed){this.closed=!0;let{_parentage:e}=this;if(e)if(this._parentage=null,Array.isArray(e))for(let o of e)o.remove(this);else e.remove(this);let{initialTeardown:i}=this;if(mn(i))try{i()}catch(o){t=o instanceof iC?o.errors:[o]}let{_finalizers:r}=this;if(r){this._finalizers=null;for(let o of r)try{e4(o)}catch(a){t=t??[],a instanceof iC?t=[...t,...a.errors]:t.push(a)}}if(t)throw new iC(t)}}add(t){var e;if(t&&t!==this)if(this.closed)e4(t);else{if(t instanceof En){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=null!==(e=this._finalizers)&&void 0!==e?e:[]).push(t)}}_hasParent(t){let{_parentage:e}=this;return e===t||Array.isArray(e)&&e.includes(t)}_addParent(t){let{_parentage:e}=this;this._parentage=Array.isArray(e)?(e.push(t),e):e?[e,t]:t}_removeParent(t){let{_parentage:e}=this;e===t?this._parentage=null:Array.isArray(e)&&Op(e,t)}remove(t){let{_finalizers:e}=this;e&&Op(e,t),t instanceof En&&t._removeParent(this)}};En.EMPTY=(()=>{let n=new En;return n.closed=!0,n})();var LA=En.EMPTY;function rC(n){return n instanceof En||n&&"closed"in n&&mn(n.remove)&&mn(n.add)&&mn(n.unsubscribe)}function e4(n){mn(n)?n():n.unsubscribe()}var ml={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1},Pm={setTimeout(n,t,...e){let{delegate:i}=Pm;return i?.setTimeout?i.setTimeout(n,t,...e):setTimeout(n,t,...e)},clearTimeout(n){let{delegate:t}=Pm;return(t?.clearTimeout||clearTimeout)(n)},delegate:void 0};function oC(n){Pm.setTimeout(()=>{let{onUnhandledError:t}=ml;if(!t)throw n;t(n)})}function fl(){}var t4=BA("C",void 0,void 0);function BA(n,t,e){return{kind:n,value:t,error:e}}var Fp=null;function km(n){if(ml.useDeprecatedSynchronousErrorHandling){let t=!Fp;if(t&&(Fp={errorThrown:!1,error:null}),n(),t){let{errorThrown:e,error:i}=Fp;if(Fp=null,e)throw i}}else n()}var Np=class extends En{constructor(t){super(),this.isStopped=!1,t?(this.destination=t,rC(t)&&t.add(this)):this.destination=ere}static create(t,e,i){return new gl(t,e,i)}next(t){this.isStopped?HA(BA("N",t,void 0),this):this._next(t)}error(t){this.isStopped?HA(BA("E",void 0,t),this):(this.isStopped=!0,this._error(t))}complete(){this.isStopped?HA(t4,this):(this.isStopped=!0,this._complete())}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe(),this.destination=null)}_next(t){this.destination.next(t)}_error(t){try{this.destination.error(t)}finally{this.unsubscribe()}}_complete(){try{this.destination.complete()}finally{this.unsubscribe()}}},Jie=Function.prototype.bind;function VA(n,t){return Jie.call(n,t)}var gl=class extends Np{constructor(t,e,i){let r;if(super(),mn(t)||!t)r={next:t??void 0,error:e??void 0,complete:i??void 0};else{let o;this&&ml.useDeprecatedNextContext?(o=Object.create(t),o.unsubscribe=()=>this.unsubscribe(),r={next:t.next&&VA(t.next,o),error:t.error&&VA(t.error,o),complete:t.complete&&VA(t.complete,o)}):r=t}this.destination=new class{constructor(t){this.partialObserver=t}next(t){let{partialObserver:e}=this;if(e.next)try{e.next(t)}catch(i){aC(i)}}error(t){let{partialObserver:e}=this;if(e.error)try{e.error(t)}catch(i){aC(i)}else aC(t)}complete(){let{partialObserver:t}=this;if(t.complete)try{t.complete()}catch(e){aC(e)}}}(r)}};function aC(n){ml.useDeprecatedSynchronousErrorHandling?function(n){ml.useDeprecatedSynchronousErrorHandling&&Fp&&(Fp.errorThrown=!0,Fp.error=n)}(n):oC(n)}function HA(n,t){let{onStoppedNotification:e}=ml;e&&Pm.setTimeout(()=>e(n,t))}var ere={closed:!0,next:fl,error:function(n){throw n},complete:fl},Om="function"==typeof Symbol&&Symbol.observable||"@@observable";function sa(n){return n}function jA(n){return 0===n.length?sa:1===n.length?n[0]:function(e){return n.reduce((i,r)=>r(i),e)}}var Kt=(()=>{class n{constructor(e){e&&(this._subscribe=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}subscribe(e,i,r){let o=function(n){return n&&n instanceof Np||function(n){return n&&mn(n.next)&&mn(n.error)&&mn(n.complete)}(n)&&rC(n)}(e)?e:new gl(e,i,r);return km(()=>{let{operator:a,source:s}=this;o.add(a?a.call(o,s):s?this._subscribe(o):this._trySubscribe(o))}),o}_trySubscribe(e){try{return this._subscribe(e)}catch(i){e.error(i)}}forEach(e,i){return new(i=o4(i))((r,o)=>{let a=new gl({next:s=>{try{e(s)}catch(l){o(l),a.unsubscribe()}},error:o,complete:r});this.subscribe(a)})}_subscribe(e){var i;return null===(i=this.source)||void 0===i?void 0:i.subscribe(e)}[Om](){return this}pipe(...e){return jA(e)(this)}toPromise(e){return new(e=o4(e))((i,r)=>{let o;this.subscribe(a=>o=a,a=>r(a),()=>i(o))})}}return n.create=t=>new n(t),n})();function o4(n){var t;return null!==(t=n??ml.Promise)&&void 0!==t?t:Promise}function GA(n){return mn(n?.lift)}function Yt(n){return t=>{if(GA(t))return t.lift(function(e){try{return n(e,this)}catch(i){this.error(i)}});throw new TypeError("Unable to lift unknown Observable type")}}function Ht(n,t,e,i,r){return new T_(n,t,e,i,r)}var WA,T_=class extends Np{constructor(t,e,i,r,o,a){super(t),this.onFinalize=o,this.shouldUnsubscribe=a,this._next=e?function(s){try{e(s)}catch(l){t.error(l)}}:super._next,this._error=r?function(s){try{r(s)}catch(l){t.error(l)}finally{this.unsubscribe()}}:super._error,this._complete=i?function(){try{i()}catch(s){t.error(s)}finally{this.unsubscribe()}}:super._complete}unsubscribe(){var t;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){let{closed:e}=this;super.unsubscribe(),!e&&(null===(t=this.onFinalize)||void 0===t||t.call(this))}}},D_=class extends Kt{constructor(t,e){super(),this.source=t,this.subjectFactory=e,this._subject=null,this._refCount=0,this._connection=null,GA(t)&&(this.lift=t.lift)}_subscribe(t){return this.getSubject().subscribe(t)}getSubject(){let t=this._subject;return(!t||t.isStopped)&&(this._subject=this.subjectFactory()),this._subject}_teardown(){this._refCount=0;let{_connection:t}=this;this._subject=this._connection=null,t?.unsubscribe()}connect(){let t=this._connection;if(!t){t=this._connection=new En;let e=this.getSubject();t.add(this.source.subscribe(Ht(e,void 0,()=>{this._teardown(),e.complete()},i=>{this._teardown(),e.error(i)},()=>this._teardown()))),t.closed&&(this._connection=null,t=En.EMPTY)}return t}refCount(){return Yt((n,t)=>{let e=null;n._refCount++;let i=Ht(t,void 0,void 0,void 0,()=>{if(!n||n._refCount<=0||0<--n._refCount)return void(e=null);let r=n._connection,o=e;e=null,r&&(!o||r===o)&&r.unsubscribe(),t.unsubscribe()});n.subscribe(i),i.closed||(e=n.connect())})(this)}},Fm={schedule(n){let t=requestAnimationFrame,e=cancelAnimationFrame,{delegate:i}=Fm;i&&(t=i.requestAnimationFrame,e=i.cancelAnimationFrame);let r=t(o=>{e=void 0,n(o)});return new En(()=>e?.(r))},requestAnimationFrame(...n){let{delegate:t}=Fm;return(t?.requestAnimationFrame||requestAnimationFrame)(...n)},cancelAnimationFrame(...n){let{delegate:t}=Fm;return(t?.cancelAnimationFrame||cancelAnimationFrame)(...n)},delegate:void 0},s4=Rm(n=>function(){n(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}),Ee=(()=>{class n extends Kt{constructor(){super(),this.closed=!1,this.currentObservers=null,this.observers=[],this.isStopped=!1,this.hasError=!1,this.thrownError=null}lift(e){let i=new sC(this,this);return i.operator=e,i}_throwIfClosed(){if(this.closed)throw new s4}next(e){km(()=>{if(this._throwIfClosed(),!this.isStopped){this.currentObservers||(this.currentObservers=Array.from(this.observers));for(let i of this.currentObservers)i.next(e)}})}error(e){km(()=>{if(this._throwIfClosed(),!this.isStopped){this.hasError=this.isStopped=!0,this.thrownError=e;let{observers:i}=this;for(;i.length;)i.shift().error(e)}})}complete(){km(()=>{if(this._throwIfClosed(),!this.isStopped){this.isStopped=!0;let{observers:e}=this;for(;e.length;)e.shift().complete()}})}unsubscribe(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null}get observed(){var e;return(null===(e=this.observers)||void 0===e?void 0:e.length)>0}_trySubscribe(e){return this._throwIfClosed(),super._trySubscribe(e)}_subscribe(e){return this._throwIfClosed(),this._checkFinalizedStatuses(e),this._innerSubscribe(e)}_innerSubscribe(e){let{hasError:i,isStopped:r,observers:o}=this;return i||r?LA:(this.currentObservers=null,o.push(e),new En(()=>{this.currentObservers=null,Op(o,e)}))}_checkFinalizedStatuses(e){let{hasError:i,thrownError:r,isStopped:o}=this;i?e.error(r):o&&e.complete()}asObservable(){let e=new Kt;return e.source=this,e}}return n.create=(t,e)=>new sC(t,e),n})(),sC=class extends Ee{constructor(t,e){super(),this.destination=t,this.source=e}next(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.next)||void 0===i||i.call(e,t)}error(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.error)||void 0===i||i.call(e,t)}complete(){var t,e;null===(e=null===(t=this.destination)||void 0===t?void 0:t.complete)||void 0===e||e.call(t)}_subscribe(t){var e,i;return null!==(i=null===(e=this.source)||void 0===e?void 0:e.subscribe(t))&&void 0!==i?i:LA}},xr=class extends Ee{constructor(t){super(),this._value=t}get value(){return this.getValue()}_subscribe(t){let e=super._subscribe(t);return!e.closed&&t.next(this._value),e}getValue(){let{hasError:t,thrownError:e,_value:i}=this;if(t)throw e;return this._throwIfClosed(),i}next(t){super.next(this._value=t)}},I_={now:()=>(I_.delegate||Date).now(),delegate:void 0},Lp=class extends Ee{constructor(t=1/0,e=1/0,i=I_){super(),this._bufferSize=t,this._windowTime=e,this._timestampProvider=i,this._buffer=[],this._infiniteTimeWindow=!0,this._infiniteTimeWindow=e===1/0,this._bufferSize=Math.max(1,t),this._windowTime=Math.max(1,e)}next(t){let{isStopped:e,_buffer:i,_infiniteTimeWindow:r,_timestampProvider:o,_windowTime:a}=this;e||(i.push(t),!r&&i.push(o.now()+a)),this._trimBuffer(),super.next(t)}_subscribe(t){this._throwIfClosed(),this._trimBuffer();let e=this._innerSubscribe(t),{_infiniteTimeWindow:i,_buffer:r}=this,o=r.slice();for(let a=0;a<o.length&&!t.closed;a+=i?1:2)t.next(o[a]);return this._checkFinalizedStatuses(t),e}_trimBuffer(){let{_bufferSize:t,_timestampProvider:e,_buffer:i,_infiniteTimeWindow:r}=this,o=(r?1:2)*t;if(t<1/0&&o<i.length&&i.splice(0,i.length-o),!r){let a=e.now(),s=0;for(let l=1;l<i.length&&i[l]<=a;l+=2)s=l;s&&i.splice(0,s+1)}}},lC=class extends En{constructor(t,e){super()}schedule(t,e=0){return this}},A_={setInterval(n,t,...e){let{delegate:i}=A_;return i?.setInterval?i.setInterval(n,t,...e):setInterval(n,t,...e)},clearInterval(n){let{delegate:t}=A_;return(t?.clearInterval||clearInterval)(n)},delegate:void 0},Jl=class extends lC{constructor(t,e){super(t,e),this.scheduler=t,this.work=e,this.pending=!1}schedule(t,e=0){var i;if(this.closed)return this;this.state=t;let r=this.id,o=this.scheduler;return null!=r&&(this.id=this.recycleAsyncId(o,r,e)),this.pending=!0,this.delay=e,this.id=null!==(i=this.id)&&void 0!==i?i:this.requestAsyncId(o,this.id,e),this}requestAsyncId(t,e,i=0){return A_.setInterval(t.flush.bind(t,this),i)}recycleAsyncId(t,e,i=0){if(null!=i&&this.delay===i&&!1===this.pending)return e;null!=e&&A_.clearInterval(e)}execute(t,e){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;let i=this._execute(t,e);if(i)return i;!1===this.pending&&null!=this.id&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))}_execute(t,e){let r,i=!1;try{this.work(t)}catch(o){i=!0,r=o||new Error("Scheduled action threw falsy error")}if(i)return this.unsubscribe(),r}unsubscribe(){if(!this.closed){let{id:t,scheduler:e}=this,{actions:i}=e;this.work=this.state=this.scheduler=null,this.pending=!1,Op(i,this),null!=t&&(this.id=this.recycleAsyncId(e,t,null)),this.delay=null,super.unsubscribe()}}},ire=1,qA={};function l4(n){return n in qA&&(delete qA[n],!0)}var c4={setImmediate(n){let t=ire++;return qA[t]=!0,WA||(WA=Promise.resolve()),WA.then(()=>l4(t)&&n()),t},clearImmediate(n){l4(n)}},{setImmediate:rre,clearImmediate:ore}=c4,R_={setImmediate(...n){let{delegate:t}=R_;return(t?.setImmediate||rre)(...n)},clearImmediate(n){let{delegate:t}=R_;return(t?.clearImmediate||ore)(n)},delegate:void 0},Qd=class{constructor(t,e=Qd.now){this.schedulerActionCtor=t,this.now=e}schedule(t,e=0,i){return new this.schedulerActionCtor(this,t).schedule(i,e)}};Qd.now=I_.now;var $l=class extends Qd{constructor(t,e=Qd.now){super(t,e),this.actions=[],this._active=!1}flush(t){let i,{actions:e}=this;if(this._active)e.push(t);else{this._active=!0;do{if(i=t.execute(t.state,t.delay))break}while(t=e.shift());if(this._active=!1,i){for(;t=e.shift();)t.unsubscribe();throw i}}}},Nm=new class extends $l{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends Jl{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=R_.setImmediate(t.flush.bind(t,void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(R_.clearImmediate(e),t._scheduled=void 0)}}),Qc=new $l(Jl),d4=Qc,XA=new class extends $l{}(class extends Jl{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}schedule(t,e=0){return e>0?super.schedule(t,e):(this.delay=e,this.state=t,this.scheduler.flush(this),this)}execute(t,e){return e>0||this.closed?super.execute(t,e):this._execute(t,e)}requestAsyncId(t,e,i=0){return null!=i&&i>0||null==i&&this.delay>0?super.requestAsyncId(t,e,i):(t.flush(this),0)}}),YA=new class extends $l{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends Jl{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=Fm.requestAnimationFrame(()=>t.flush(void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(Fm.cancelAnimationFrame(e),t._scheduled=void 0)}}),Kr=new Kt(n=>n.complete());function fC(n){return n&&mn(n.schedule)}function QA(n){return n[n.length-1]}function ec(n){return mn(QA(n))?n.pop():void 0}function tc(n){return fC(QA(n))?n.pop():void 0}var B4=$V(L4(),1),{__decorate:V4,__awaiter:H4,__await:vC,__asyncGenerator:z4,__asyncValues:U4}=B4.default,Bm=n=>n&&"number"==typeof n.length&&"function"!=typeof n;function yC(n){return mn(n?.then)}function xC(n){return mn(n[Om])}function CC(n){return Symbol.asyncIterator&&mn(n?.[Symbol.asyncIterator])}function MC(n){return new TypeError(`You provided ${null!==n&&"object"==typeof n?"an invalid object":`'${n}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`)}var wC="function"==typeof Symbol&&Symbol.iterator?Symbol.iterator:"@@iterator";function SC(n){return mn(n?.[wC])}function EC(n){return z4(this,arguments,function*(){let e=n.getReader();try{for(;;){let{value:i,done:r}=yield vC(e.read());if(r)return yield vC(void 0);yield yield vC(i)}}finally{e.releaseLock()}})}function TC(n){return mn(n?.getReader)}function ci(n){if(n instanceof Kt)return n;if(null!=n){if(xC(n))return function(n){return new Kt(t=>{let e=n[Om]();if(mn(e.subscribe))return e.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}(n);if(Bm(n))return function(n){return new Kt(t=>{for(let e=0;e<n.length&&!t.closed;e++)t.next(n[e]);t.complete()})}(n);if(yC(n))return function(n){return new Kt(t=>{n.then(e=>{t.closed||(t.next(e),t.complete())},e=>t.error(e)).then(null,oC)})}(n);if(CC(n))return j4(n);if(SC(n))return function(n){return new Kt(t=>{for(let e of n)if(t.next(e),t.closed)return;t.complete()})}(n);if(TC(n))return function(n){return j4(EC(n))}(n)}throw MC(n)}function j4(n){return new Kt(t=>{(function(n,t){var e,i,r,o;return H4(this,void 0,void 0,function*(){try{for(e=U4(n);!(i=yield e.next()).done;)if(t.next(i.value),t.closed)return}catch(a){r={error:a}}finally{try{i&&!i.done&&(o=e.return)&&(yield o.call(e))}finally{if(r)throw r.error}}t.complete()})})(n,t).catch(e=>t.error(e))})}function Ea(n,t,e,i=0,r=!1){let o=t.schedule(function(){e(),r?n.add(this.schedule(null,i)):this.unsubscribe()},i);if(n.add(o),!r)return o}function Bp(n,t=0){return Yt((e,i)=>{e.subscribe(Ht(i,r=>Ea(i,n,()=>i.next(r),t),()=>Ea(i,n,()=>i.complete(),t),r=>Ea(i,n,()=>i.error(r),t)))})}function DC(n,t=0){return Yt((e,i)=>{i.add(n.schedule(()=>e.subscribe(i),t))})}function IC(n,t){if(!n)throw new Error("Iterable cannot be null");return new Kt(e=>{Ea(e,t,()=>{let i=n[Symbol.asyncIterator]();Ea(e,t,()=>{i.next().then(r=>{r.done?e.complete():e.next(r.value)})},0,!0)})})}function Jr(n,t){return t?function(n,t){if(null!=n){if(xC(n))return function(n,t){return ci(n).pipe(DC(t),Bp(t))}(n,t);if(Bm(n))return function(n,t){return new Kt(e=>{let i=0;return t.schedule(function(){i===n.length?e.complete():(e.next(n[i++]),e.closed||this.schedule())})})}(n,t);if(yC(n))return function(n,t){return ci(n).pipe(DC(t),Bp(t))}(n,t);if(CC(n))return IC(n,t);if(SC(n))return function(n,t){return new Kt(e=>{let i;return Ea(e,t,()=>{i=n[wC](),Ea(e,t,()=>{let r,o;try{({value:r,done:o}=i.next())}catch(a){return void e.error(a)}o?e.complete():e.next(r)},0,!0)}),()=>mn(i?.return)&&i.return()})}(n,t);if(TC(n))return function(n,t){return IC(EC(n),t)}(n,t)}throw MC(n)}(n,t):ci(n)}function $t(...n){return Jr(n,tc(n))}function _l(n,t){let e=mn(n)?n:()=>n,i=r=>r.error(e());return new Kt(t?r=>t.schedule(i,0,r):i)}var As=class{constructor(t,e,i){this.kind=t,this.value=e,this.error=i,this.hasValue="N"===t}observe(t){return KA(this,t)}do(t,e,i){let{kind:r,value:o,error:a}=this;return"N"===r?t?.(o):"E"===r?e?.(a):i?.()}accept(t,e,i){var r;return mn(null===(r=t)||void 0===r?void 0:r.next)?this.observe(t):this.do(t,e,i)}toObservable(){let{kind:t,value:e,error:i}=this,r="N"===t?$t(e):"E"===t?_l(()=>i):"C"===t?Kr:0;if(!r)throw new TypeError(`Unexpected notification kind ${t}`);return r}static createNext(t){return new As("N",t)}static createError(t){return new As("E",void 0,t)}static createComplete(){return As.completeNotification}};function KA(n,t){var e,i,r;let{kind:o,value:a,error:s}=n;if("string"!=typeof o)throw new TypeError('Invalid notification, missing "kind"');"N"===o?null===(e=t.next)||void 0===e||e.call(t,a):"E"===o?null===(i=t.error)||void 0===i||i.call(t,s):null===(r=t.complete)||void 0===r||r.call(t)}function P_(n){return!!n&&(n instanceof Kt||mn(n.lift)&&mn(n.subscribe))}As.completeNotification=new As("C");var Vm=Rm(n=>function(){n(this),this.name="EmptyError",this.message="no elements in sequence"});function AC(n,t){let e="object"==typeof t;return new Promise((i,r)=>{let o=new gl({next:a=>{i(a),o.unsubscribe()},error:r,complete:()=>{e?i(t.defaultValue):r(new Vm)}});n.subscribe(o)})}function q(n,t){return Yt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>{i.next(n.call(t,o,r++))}))})}var{isArray:hre}=Array;function Zd(n){return q(t=>function(n,t){return hre(t)?n(...t):n(t)}(n,t))}var{isArray:fre}=Array,{getPrototypeOf:gre,prototype:_re,keys:bre}=Object;function RC(n){if(1===n.length){let t=n[0];if(fre(t))return{args:t,keys:null};if(function(n){return n&&"object"==typeof n&&gre(n)===_re}(t)){let e=bre(t);return{args:e.map(i=>t[i]),keys:e}}}return{args:n,keys:null}}function PC(n,t){return n.reduce((e,i,r)=>(e[i]=t[r],e),{})}function In(...n){let t=tc(n),e=ec(n),{args:i,keys:r}=RC(n);if(0===i.length)return Jr([],t);let o=new Kt(JA(i,t,r?a=>PC(r,a):sa));return e?o.pipe(Zd(e)):o}function JA(n,t,e=sa){return i=>{K4(t,()=>{let{length:r}=n,o=new Array(r),a=r,s=r;for(let l=0;l<r;l++)K4(t,()=>{let c=Jr(n[l],t),d=!1;c.subscribe(Ht(i,u=>{o[l]=u,d||(d=!0,s--),s||i.next(e(o.slice()))},()=>{--a||i.complete()}))},i)},i)}}function K4(n,t,e){n?Ea(e,n,t):t()}function xn(n,t,e=1/0){return mn(t)?xn((i,r)=>q((o,a)=>t(i,o,r,a))(ci(n(i,r))),e):("number"==typeof t&&(e=t),Yt((i,r)=>function(n,t,e,i,r,o,a,s){let l=[],c=0,d=0,u=!1,p=()=>{u&&!l.length&&!c&&t.complete()},h=_=>c<i?m(_):l.push(_),m=_=>{c++;let M=!1;ci(e(_,d++)).subscribe(Ht(t,y=>{t.next(y)},()=>{M=!0},void 0,()=>{if(M)try{for(c--;l.length&&c<i;){let y=l.shift();m(y)}p()}catch(y){t.error(y)}}))};return n.subscribe(Ht(t,h,()=>{u=!0,p()})),()=>{}}(i,r,n,e)))}function kC(n=1/0){return xn(sa,n)}function Kd(...n){return kC(1)(Jr(n,tc(n)))}function is(n){return new Kt(t=>{ci(n()).subscribe(t)})}function Co(...n){let t=ec(n),{args:e,keys:i}=RC(n),r=new Kt(o=>{let{length:a}=e;if(!a)return void o.complete();let s=new Array(a),l=a,c=a;for(let d=0;d<a;d++){let u=!1;ci(e[d]).subscribe(Ht(o,p=>{u||(u=!0,c--),s[d]=p},()=>l--,void 0,()=>{(!l||!u)&&(c||o.next(i?PC(i,s):s),o.complete())}))}});return t?r.pipe(Zd(t)):r}var yre=["addListener","removeListener"],xre=["addEventListener","removeEventListener"],Cre=["on","off"];function Ei(n,t,e,i){if(mn(e)&&(i=e,e=void 0),i)return Ei(n,t,e).pipe(Zd(i));let[r,o]=function(n){return mn(n.addEventListener)&&mn(n.removeEventListener)}(n)?xre.map(a=>s=>n[a](t,s,e)):function(n){return mn(n.addListener)&&mn(n.removeListener)}(n)?yre.map(eH(n,t)):function(n){return mn(n.on)&&mn(n.off)}(n)?Cre.map(eH(n,t)):[];if(!r&&Bm(n))return xn(a=>Ei(a,t,e))(ci(n));if(!r)throw new TypeError("Invalid event target");return new Kt(a=>{let s=(...l)=>a.next(1<l.length?l:l[0]);return r(s),()=>o(s)})}function eH(n,t){return e=>i=>n[e](t,i)}function rs(n=0,t,e=d4){let i=-1;return null!=t&&(fC(t)?e=t:i=t),new Kt(r=>{let o=function(n){return n instanceof Date&&!isNaN(n)}(n)?+n-e.now():n;o<0&&(o=0);let a=0;return e.schedule(function(){r.closed||(r.next(a++),0<=i?this.schedule(void 0,i):r.complete())},o)})}function tn(...n){let t=tc(n),e=function(n,t){return"number"==typeof QA(n)?n.pop():1/0}(n),i=n;return i.length?1===i.length?ci(i[0]):kC(e)(Jr(i,t)):Kr}var{isArray:Ere}=Array;function OC(n){return 1===n.length&&Ere(n[0])?n[0]:n}function Oe(n,t){return Yt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>n.call(t,o,r++)&&i.next(o)))})}function nc(n,t=Qc){return function(n){return Yt((t,e)=>{let i=!1,r=null,o=null,a=!1,s=()=>{if(o?.unsubscribe(),o=null,i){i=!1;let c=r;r=null,e.next(c)}a&&e.complete()},l=()=>{o=null,a&&e.complete()};t.subscribe(Ht(e,c=>{i=!0,r=c,o||ci(n()).subscribe(o=Ht(e,s,l))},()=>{a=!0,(!i||!o||o.closed)&&e.complete()}))})}(()=>rs(n,t))}function co(n){return Yt((t,e)=>{let o,i=null,r=!1;i=t.subscribe(Ht(e,void 0,void 0,a=>{o=ci(n(a,co(n)(t))),i?(i.unsubscribe(),i=null,o.subscribe(e)):r=!0})),r&&(i.unsubscribe(),i=null,o.subscribe(e))})}function tR(...n){let t=ec(n);return t?function(...n){return jA(n)}(tR(...n),Zd(t)):Yt((e,i)=>{JA([e,...OC(n)])(i)})}function Vi(...n){return tR(...n)}function Cr(n,t=Qc){return Yt((e,i)=>{let r=null,o=null,a=null,s=()=>{if(r){r.unsubscribe(),r=null;let c=o;o=null,i.next(c)}};function l(){let c=a+n,d=t.now();if(d<c)return r=this.schedule(void 0,c-d),void i.add(r);s()}e.subscribe(Ht(i,c=>{o=c,a=t.now(),r||(r=t.schedule(l,n),i.add(r))},()=>{s(),i.complete()},void 0,()=>{o=r=null}))})}function Lt(n){return n<=0?()=>Kr:Yt((t,e)=>{let i=0;t.subscribe(Ht(e,r=>{++i<=n&&(e.next(r),n<=i&&e.complete())}))})}function k_(){return Yt((n,t)=>{n.subscribe(Ht(t,fl))})}function Hm(n,t){return t?e=>Kd(t.pipe(Lt(1),k_()),e.pipe(Hm(n))):xn((e,i)=>n(e,i).pipe(Lt(1),function(n){return q(()=>n)}(e)))}function Rs(n,t=Qc){let e=rs(n,t);return Hm(()=>e)}function ri(n,t=sa){return n=n??Tre,Yt((e,i)=>{let r,o=!0;e.subscribe(Ht(i,a=>{let s=t(a);(o||!n(r,s))&&(o=!1,r=s,i.next(a))}))})}function Tre(n,t){return n===t}function oH(n=Dre){return Yt((t,e)=>{let i=!1;t.subscribe(Ht(e,r=>{i=!0,e.next(r)},()=>i?e.complete():e.error(n())))})}function Dre(){return new Vm}function NC(n,t){return t?e=>e.pipe(NC((i,r)=>ci(n(i,r)).pipe(q((o,a)=>t(i,o,r,a))))):Yt((e,i)=>{let r=0,o=null,a=!1;e.subscribe(Ht(i,s=>{o||(o=Ht(i,void 0,()=>{o=null,a&&i.complete()}),ci(n(s,r++)).subscribe(o))},()=>{a=!0,!o&&i.complete()}))})}function zm(n,t){let e=arguments.length>=2;return i=>i.pipe(n?Oe((r,o)=>n(r,o,i)):sa,Lt(1),e?function(n){return Yt((t,e)=>{let i=!1;t.subscribe(Ht(e,r=>{i=!0,e.next(r)},()=>{i||e.next(n),e.complete()}))})}(t):oH(()=>new Vm))}function BC(n,t,e,i){return Yt((r,o)=>{let a;t&&"function"!=typeof t?({duration:e,element:a,connector:i}=t):a=t;let s=new Map,l=m=>{s.forEach(m),m(o)},c=m=>l(_=>_.error(m)),d=0,u=!1,p=new T_(o,m=>{try{let _=n(m),M=s.get(_);if(!M){s.set(_,M=i?i():new Ee);let y=function(m,_){let M=new Kt(y=>{d++;let x=_.subscribe(y);return()=>{x.unsubscribe(),0==--d&&u&&p.unsubscribe()}});return M.key=m,M}(_,M);if(o.next(y),e){let x=Ht(M,()=>{M.complete(),x?.unsubscribe()},void 0,void 0,()=>s.delete(_));p.add(ci(e(y)).subscribe(x))}}M.next(a?a(m):m)}catch(_){c(_)}},()=>l(m=>m.complete()),c,()=>s.clear(),()=>(u=!0,0===d));r.subscribe(p)})}function Ta(n={}){let{connector:t=(()=>new Ee),resetOnError:e=!0,resetOnComplete:i=!0,resetOnRefCountZero:r=!0}=n;return o=>{let a,s,l,c=0,d=!1,u=!1,p=()=>{s?.unsubscribe(),s=void 0},h=()=>{p(),a=l=void 0,d=u=!1},m=()=>{let _=a;h(),_?.unsubscribe()};return Yt((_,M)=>{c++,!u&&!d&&p();let y=l=l??t();M.add(()=>{c--,0===c&&!u&&!d&&(s=lR(m,r))}),y.subscribe(M),!a&&c>0&&(a=new gl({next:x=>y.next(x),error:x=>{u=!0,p(),s=lR(h,e,x),y.error(x)},complete:()=>{d=!0,p(),s=lR(h,i),y.complete()}}),ci(_).subscribe(a))})(o)}}function lR(n,t,...e){if(!0===t)return void n();if(!1===t)return;let i=new gl({next:()=>{i.unsubscribe(),n()}});return t(...e).subscribe(i)}function Da(n,t,e){let i,r=!1;return n&&"object"==typeof n?({bufferSize:i=1/0,windowTime:t=1/0,refCount:r=!1,scheduler:e}=n):i=n??1/0,Ta({connector:()=>new Lp(i,t,e),resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:r})}function os(n){return Oe((t,e)=>n<=e)}function kn(...n){let t=tc(n);return Yt((e,i)=>{(t?Kd(n,e,t):Kd(n,e)).subscribe(i)})}function Jn(n,t){return Yt((e,i)=>{let r=null,o=0,a=!1,s=()=>a&&!r&&i.complete();e.subscribe(Ht(i,l=>{r?.unsubscribe();let c=0,d=o++;ci(n(l,d)).subscribe(r=Ht(i,u=>i.next(t?t(l,u,d,c++):u),()=>{r=null,s()}))},()=>{a=!0,s()}))})}function it(n){return Yt((t,e)=>{ci(n).subscribe(Ht(e,()=>e.complete(),fl)),!e.closed&&t.subscribe(e)})}function O_(n,t=!1){return Yt((e,i)=>{let r=0;e.subscribe(Ht(i,o=>{let a=n(o,r++);(a||t)&&i.next(o),!a&&i.complete()}))})}function Dt(n,t,e){let i=mn(n)||t||e?{next:n,error:t,complete:e}:n;return i?Yt((r,o)=>{var a;null===(a=i.subscribe)||void 0===a||a.call(i);let s=!0;r.subscribe(Ht(o,l=>{var c;null===(c=i.next)||void 0===c||c.call(i,l),o.next(l)},()=>{var l;s=!1,null===(l=i.complete)||void 0===l||l.call(i),o.complete()},l=>{var c;s=!1,null===(c=i.error)||void 0===c||c.call(i,l),o.error(l)},()=>{var l,c;s&&(null===(l=i.unsubscribe)||void 0===l||l.call(i)),null===(c=i.finalize)||void 0===c||c.call(i)}))}):sa}var cR={leading:!0,trailing:!1};function ic(n,t=Qc,e=cR){let i=rs(n,t);return function(n,t=cR){return Yt((e,i)=>{let{leading:r,trailing:o}=t,a=!1,s=null,l=null,c=!1,d=()=>{l?.unsubscribe(),l=null,o&&(h(),c&&i.complete())},u=()=>{l=null,c&&i.complete()},p=m=>l=ci(n(m)).subscribe(Ht(i,d,u)),h=()=>{if(a){a=!1;let m=s;s=null,i.next(m),!c&&p(m)}};e.subscribe(Ht(i,m=>{a=!0,s=m,(!l||l.closed)&&(r?h():p(m))},()=>{c=!0,(!(o&&a&&l)||l.closed)&&i.complete()}))})}(()=>i,e)}function It(...n){let t=ec(n);return Yt((e,i)=>{let r=n.length,o=new Array(r),a=n.map(()=>!1),s=!1;for(let l=0;l<r;l++)ci(n[l]).subscribe(Ht(i,c=>{o[l]=c,!s&&!a[l]&&(a[l]=!0,(s=a.every(sa))&&(a=null))},fl));e.subscribe(Ht(i,l=>{if(s){let c=[l,...o];i.next(t?t(...c):c)}}))})}function $i(n){for(let t in n)if(n[t]===$i)return t;throw Error("Could not find renamed property on target object.")}function dR(n,t){for(let e in t)t.hasOwnProperty(e)&&!n.hasOwnProperty(e)&&(n[e]=t[e])}function po(n){if("string"==typeof n)return n;if(Array.isArray(n))return"["+n.map(po).join(", ")+"]";if(null==n)return""+n;if(n.overriddenName)return`${n.overriddenName}`;if(n.name)return`${n.name}`;let t=n.toString();if(null==t)return""+t;let e=t.indexOf("\n");return-1===e?t:t.substring(0,e)}function RR(n,t){return null==n||""===n?null===t?"":t:null==t||""===t?n:n+" "+t}var Ire=$i({__forward_ref__:$i});function Wn(n){return n.__forward_ref__=Wn,n.toString=function(){return po(this())},n}function Ai(n){return t5(n)?n():n}function t5(n){return"function"==typeof n&&n.hasOwnProperty(Ire)&&n.__forward_ref__===Wn}function n5(n){return n&&!!n.\u0275providers}var ob="https://g.co/ng/security#xss",xt=class extends Error{constructor(t,e){super(function(n,t){return`NG0${Math.abs(n)}${t?": "+t.trim():""}`}(t,e)),this.code=t}};function jn(n){return"string"==typeof n?n:null==n?"":String(n)}function BP(n){return"function"==typeof n?n.name||n.toString():"object"==typeof n&&null!=n&&"function"==typeof n.type?n.type.name||n.type.toString():jn(n)}function VP(n,t){throw new xt(-201,!1)}function i5(n,t,e,i){throw new Error(`ASSERTION ERROR: ${n}`+(null==i?"":` [Expected=> ${e} ${i} ${t} <=Actual]`))}function ue(n){return{token:n.token,providedIn:n.providedIn||null,factory:n.factory,value:void 0}}function H(n){return{providers:n.providers||[],imports:n.imports||[]}}function HP(n){return sH(n,$C)||sH(n,r5)}function sH(n,t){return n.hasOwnProperty(t)?n[t]:null}function lH(n){return n&&(n.hasOwnProperty(PR)||n.hasOwnProperty(Ore))?n[PR]:null}var kR,$C=$i({"\u0275prov":$i}),PR=$i({"\u0275inj":$i}),r5=$i({ngInjectableDef:$i}),Ore=$i({ngInjectorDef:$i}),Ci=(()=>{return(n=Ci||(Ci={}))[n.Default=0]="Default",n[n.Host=1]="Host",n[n.Self=2]="Self",n[n.SkipSelf=4]="SkipSelf",n[n.Optional=8]="Optional",Ci;var n})();function Ps(n){let t=kR;return kR=n,t}function o5(n,t,e){let i=HP(n);return i&&"root"==i.providedIn?void 0===i.value?i.value=i.factory():i.value:e&Ci.Optional?null:void 0!==t?t:void VP(po(n))}var L_,zr=(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)(),X_={},OR="__NG_DI_FLAG__",eM="ngTempTokenPath",Lre="ngTokenPath",Bre=/\n/gm,Vre="\u0275",cH="__source";function Um(n){let t=L_;return L_=n,t}function Hre(n,t=Ci.Default){if(void 0===L_)throw new xt(-203,!1);return null===L_?o5(n,void 0,t):L_.get(n,t&Ci.Optional?null:void 0,t)}function O(n,t=Ci.Default){return(kR||Hre)(Ai(n),t)}function a5(n){throw new xt(202,!1)}function $n(n,t=Ci.Default){return O(n,SM(t))}function SM(n){return typeof n>"u"||"number"==typeof n?n:0|(n.optional&&8)|(n.host&&1)|(n.self&&2)|(n.skipSelf&&4)}function FR(n){let t=[];for(let e=0;e<n.length;e++){let i=Ai(n[e]);if(Array.isArray(i)){if(0===i.length)throw new xt(900,!1);let r,o=Ci.Default;for(let a=0;a<i.length;a++){let s=i[a],l=zre(s);"number"==typeof l?-1===l?r=s.token:o|=l:r=s}t.push(O(r,o))}else t.push(O(i))}return t}function ab(n,t){return n[OR]=t,n.prototype[OR]=t,n}function zre(n){return n[OR]}function ru(n){return{toString:n}.toString()}var B_=(()=>{return(n=B_||(B_={}))[n.OnPush=0]="OnPush",n[n.Default=1]="Default",B_;var n})(),as=(()=>{return(n=as||(as={}))[n.Emulated=0]="Emulated",n[n.None=2]="None",n[n.ShadowDom=3]="ShadowDom",as;var n})(),Zc={},ji=[],EM=$i({"\u0275cmp":$i}),zP=$i({"\u0275dir":$i}),UP=$i({"\u0275pipe":$i}),s5=$i({"\u0275mod":$i}),Kc=$i({"\u0275fac":$i}),V_=$i({__NG_ELEMENT_ID__:$i}),Gre=0;function P(n){return ru(()=>{let t=c5(n),e={...t,decls:n.decls,vars:n.vars,template:n.template,consts:n.consts||null,ngContentSelectors:n.ngContentSelectors,onPush:n.changeDetection===B_.OnPush,directiveDefs:null,pipeDefs:null,dependencies:t.standalone&&n.dependencies||null,getStandaloneInjector:null,data:n.data||{},encapsulation:n.encapsulation||as.Emulated,id:"c"+Gre++,styles:n.styles||ji,_:null,schemas:n.schemas||null,tView:null};d5(e);let i=n.dependencies;return e.directiveDefs=tM(i,!1),e.pipeDefs=tM(i,!0),e})}function sb(n,t,e){let i=n.\u0275cmp;i.directiveDefs=tM(t,!1),i.pipeDefs=tM(e,!0)}function Wre(n){return Os(n)||eu(n)}function qre(n){return null!==n}function z(n){return ru(()=>({type:n.type,bootstrap:n.bootstrap||ji,declarations:n.declarations||ji,imports:n.imports||ji,exports:n.exports||ji,transitiveCompileScopes:null,schemas:n.schemas||null,id:n.id||null}))}function dH(n,t){if(null==n)return Zc;let e={};for(let i in n)if(n.hasOwnProperty(i)){let r=n[i],o=r;Array.isArray(r)&&(o=r[1],r=r[0]),e[r]=i,t&&(t[r]=o)}return e}function Me(n){return ru(()=>{let t=c5(n);return d5(t),t})}function rf(n){return{type:n.type,name:n.name,factory:null,pure:!1!==n.pure,standalone:!0===n.standalone,onDestroy:n.type.prototype.ngOnDestroy||null}}function Os(n){return n[EM]||null}function eu(n){return n[zP]||null}function tu(n){return n[UP]||null}function l5(n){let t=Os(n)||eu(n)||tu(n);return null!==t&&t.standalone}function Zm(n,t){let e=n[s5]||null;if(!e&&!0===t)throw new Error(`Type ${po(n)} does not have '\u0275mod' property.`);return e}function c5(n){let t={};return{type:n.type,providersResolver:null,factory:null,hostBindings:n.hostBindings||null,hostVars:n.hostVars||0,hostAttrs:n.hostAttrs||null,contentQueries:n.contentQueries||null,declaredInputs:t,exportAs:n.exportAs||null,standalone:!0===n.standalone,selectors:n.selectors||ji,viewQuery:n.viewQuery||null,features:n.features||null,setInput:null,findHostDirectiveDefs:null,hostDirectives:null,inputs:dH(n.inputs,t),outputs:dH(n.outputs)}}function d5(n){n.features?.forEach(t=>t(n))}function tM(n,t){if(!n)return null;let e=t?tu:Wre;return()=>("function"==typeof n?n():n).map(i=>e(i)).filter(qre)}var ou=0,Fn=1,di=2,jr=3,yl=4,zp=5,Aa=6,Y_=7,Ra=8,nM=9,iM=10,ui=11,NR=12,Q_=13,uH=14,of=15,xl=16,lb=17,jm=18,oc=19,TM=20,u5=21,Gr=22,jP=1,p5=2,GP=7,rM=8,Km=9,Ia=10;function Up(n){return Array.isArray(n)&&"object"==typeof n[jP]}function $c(n){return Array.isArray(n)&&!0===n[jP]}function WP(n){return 0!=(4&n.flags)}function DM(n){return n.componentOffset>-1}function IM(n){return 1==(1&n.flags)}function Cl(n){return!!n.template}function Xre(n){return 0!=(256&n[di])}function Gp(n,t){return n.hasOwnProperty(Kc)?n[Kc]:null}var LR=class{constructor(t,e,i){this.previousValue=t,this.currentValue=e,this.firstChange=i}isFirstChange(){return this.firstChange}};function qt(){return h5}function h5(n){return n.type.prototype.ngOnChanges&&(n.setInput=Qre),Yre}function Yre(){let n=f5(this),t=n?.current;if(t){let e=n.previous;if(e===Zc)n.previous=t;else for(let i in t)e[i]=t[i];n.current=null,this.ngOnChanges(t)}}function Qre(n,t,e,i){let r=this.declaredInputs[e],o=f5(n)||function(n,t){return n[m5]=t}(n,{previous:Zc,current:null}),a=o.current||(o.current={}),s=o.previous,l=s[r];a[r]=new LR(l&&l.currentValue,t,s===Zc),n[i]=t}qt.ngInherit=!0;var m5="__ngSimpleChanges__";function f5(n){return n[m5]||null}var ks=function(n,t,e){},g5="svg",_5="math";function Ls(n){for(;Array.isArray(n);)n=n[ou];return n}function AM(n,t){return Ls(t[n])}function ss(n,t){return Ls(t[n.index])}function b5(n,t){return n.data[t]}function af(n,t){return n[t]}function ed(n,t){let e=t[n];return Up(e)?e:e[ou]}function oM(n){return 64==(64&n[di])}function nu(n,t){return null==t?null:n[t]}function v5(n){n[jm]=0}function qP(n,t){n[zp]+=t;let e=n,i=n[jr];for(;null!==i&&(1===t&&1===e[zp]||-1===t&&0===e[zp]);)i[zp]+=t,e=i,i=i[jr]}var Gn={lFrame:T5(null),bindingsEnabled:!0};function y5(){return Gn.bindingsEnabled}function Ze(){return Gn.lFrame.lView}function Ti(){return Gn.lFrame.tView}function ne(n){return Gn.lFrame.contextLView=n,n[Ra]}function ie(n){return Gn.lFrame.contextLView=null,n}function Lo(){let n=x5();for(;null!==n&&64===n.type;)n=n.parent;return n}function x5(){return Gn.lFrame.currentTNode}function Z_(){let n=Gn.lFrame,t=n.currentTNode;return n.isParent?t:t.parent}function ac(n,t){let e=Gn.lFrame;e.currentTNode=n,e.isParent=t}function XP(){return Gn.lFrame.isParent}function YP(){Gn.lFrame.isParent=!1}function ca(){let n=Gn.lFrame,t=n.bindingRootIndex;return-1===t&&(t=n.bindingRootIndex=n.tView.bindingStartIndex),t}function td(){return Gn.lFrame.bindingIndex}function C5(n){return Gn.lFrame.bindingIndex=n}function sf(){return Gn.lFrame.bindingIndex++}function nd(n){let t=Gn.lFrame,e=t.bindingIndex;return t.bindingIndex=t.bindingIndex+n,e}function M5(n){Gn.lFrame.inI18n=n}function soe(n,t){let e=Gn.lFrame;e.bindingIndex=e.bindingRootIndex=n,BR(t)}function BR(n){Gn.lFrame.currentDirectiveIndex=n}function QP(n){let t=Gn.lFrame.currentDirectiveIndex;return-1===t?null:n[t]}function w5(){return Gn.lFrame.currentQueryIndex}function ZP(n){Gn.lFrame.currentQueryIndex=n}function coe(n){let t=n[Fn];return 2===t.type?t.declTNode:1===t.type?n[Aa]:null}function S5(n,t,e){if(e&Ci.SkipSelf){let r=t,o=n;for(;!(r=r.parent,null!==r||e&Ci.Host||(r=coe(o),null===r||(o=o[of],10&r.type))););if(null===r)return!1;t=r,n=o}let i=Gn.lFrame=E5();return i.currentTNode=t,i.lView=n,!0}function KP(n){let t=E5(),e=n[Fn];Gn.lFrame=t,t.currentTNode=e.firstChild,t.lView=n,t.tView=e,t.contextLView=n,t.bindingIndex=e.bindingStartIndex,t.inI18n=!1}function E5(){let n=Gn.lFrame,t=null===n?null:n.child;return null===t?T5(n):t}function T5(n){let t={currentTNode:null,isParent:!0,lView:null,tView:null,selectedIndex:-1,contextLView:null,elementDepthCount:0,currentNamespace:null,currentDirectiveIndex:-1,bindingRootIndex:-1,bindingIndex:-1,currentQueryIndex:0,parent:n,child:null,inI18n:!1};return null!==n&&(n.child=t),t}function D5(){let n=Gn.lFrame;return Gn.lFrame=n.parent,n.currentTNode=null,n.lView=null,n}var I5=D5;function JP(){let n=D5();n.isParent=!0,n.tView=null,n.selectedIndex=-1,n.contextLView=null,n.elementDepthCount=0,n.currentDirectiveIndex=-1,n.currentNamespace=null,n.bindingRootIndex=-1,n.bindingIndex=-1,n.currentQueryIndex=0}function da(){return Gn.lFrame.selectedIndex}function Wp(n){Gn.lFrame.selectedIndex=n}function Pr(){let n=Gn.lFrame;return b5(n.tView,n.selectedIndex)}function qn(){Gn.lFrame.currentNamespace=g5}function ua(){Gn.lFrame.currentNamespace=null}function RM(n,t){for(let e=t.directiveStart,i=t.directiveEnd;e<i;e++){let o=n.data[e].type.prototype,{ngAfterContentInit:a,ngAfterContentChecked:s,ngAfterViewInit:l,ngAfterViewChecked:c,ngOnDestroy:d}=o;a&&(n.contentHooks??(n.contentHooks=[])).push(-e,a),s&&((n.contentHooks??(n.contentHooks=[])).push(e,s),(n.contentCheckHooks??(n.contentCheckHooks=[])).push(e,s)),l&&(n.viewHooks??(n.viewHooks=[])).push(-e,l),c&&((n.viewHooks??(n.viewHooks=[])).push(e,c),(n.viewCheckHooks??(n.viewCheckHooks=[])).push(e,c)),null!=d&&(n.destroyHooks??(n.destroyHooks=[])).push(e,d)}}function GC(n,t,e){A5(n,t,3,e)}function WC(n,t,e,i){(3&n[di])===e&&A5(n,t,e,i)}function uR(n,t){let e=n[di];(3&e)===t&&(e&=2047,e+=1,n[di]=e)}function A5(n,t,e,i){let o=i??-1,a=t.length-1,s=0;for(let l=void 0!==i?65535&n[jm]:0;l<a;l++)if("number"==typeof t[l+1]){if(s=t[l],null!=i&&s>=i)break}else t[l]<0&&(n[jm]+=65536),(s<o||-1==o)&&(goe(n,e,t,l),n[jm]=(4294901760&n[jm])+l+2),l++}function goe(n,t,e,i){let r=e[i]<0,o=e[i+1],s=n[r?-e[i]:e[i]];if(r){if(n[di]>>11<n[jm]>>16&&(3&n[di])===t){n[di]+=2048,ks(4,s,o);try{o.call(s)}finally{ks(5,s,o)}}}else{ks(4,s,o);try{o.call(s)}finally{ks(5,s,o)}}}var Qm=-1,qp=class{constructor(t,e,i){this.factory=t,this.resolving=!1,this.canSeeViewProviders=e,this.injectImpl=i}};function VR(n,t,e){let i=0;for(;i<e.length;){let r=e[i];if("number"==typeof r){if(0!==r)break;i++;let o=e[i++],a=e[i++],s=e[i++];n.setAttribute(t,a,s,o)}else{let o=r,a=e[++i];yoe(o)?n.setProperty(t,o,a):n.setAttribute(t,o,a),i++}}return i}function R5(n){return 3===n||4===n||6===n}function yoe(n){return 64===n.charCodeAt(0)}function K_(n,t){if(null!==t&&0!==t.length)if(null===n||0===n.length)n=t.slice();else{let e=-1;for(let i=0;i<t.length;i++){let r=t[i];"number"==typeof r?e=r:0===e||hH(n,e,r,null,-1===e||2===e?t[++i]:null)}}return n}function hH(n,t,e,i,r){let o=0,a=n.length;if(-1===t)a=-1;else for(;o<n.length;){let s=n[o++];if("number"==typeof s){if(s===t){a=-1;break}if(s>t){a=o-1;break}}}for(;o<n.length;){let s=n[o];if("number"==typeof s)break;if(s===e){if(null===i)return void(null!==r&&(n[o+1]=r));if(i===n[o+1])return void(n[o+2]=r)}o++,null!==i&&o++,null!==r&&o++}-1!==a&&(n.splice(a,0,t),o=a+1),n.splice(o++,0,e),null!==i&&n.splice(o++,0,i),null!==r&&n.splice(o++,0,r)}function P5(n){return n!==Qm}function aM(n){return 32767&n}function sM(n,t){let e=function(n){return n>>16}(n),i=t;for(;e>0;)i=i[of],e--;return i}var HR=!0;function lM(n){let t=HR;return HR=n,t}var k5=255,O5=5,Moe=0,rc={};function cM(n,t){let e=F5(n,t);if(-1!==e)return e;let i=t[Fn];i.firstCreatePass&&(n.injectorIndex=t.length,pR(i.data,n),pR(t,null),pR(i.blueprint,null));let r=$P(n,t),o=n.injectorIndex;if(P5(r)){let a=aM(r),s=sM(r,t),l=s[Fn].data;for(let c=0;c<8;c++)t[o+c]=s[a+c]|l[a+c]}return t[o+8]=r,o}function pR(n,t){n.push(0,0,0,0,0,0,0,0,t)}function F5(n,t){return-1===n.injectorIndex||n.parent&&n.parent.injectorIndex===n.injectorIndex||null===t[n.injectorIndex+8]?-1:n.injectorIndex}function $P(n,t){if(n.parent&&-1!==n.parent.injectorIndex)return n.parent.injectorIndex;let e=0,i=null,r=t;for(;null!==r;){if(i=H5(r),null===i)return Qm;if(e++,r=r[of],-1!==i.injectorIndex)return i.injectorIndex|e<<16}return Qm}function zR(n,t,e){!function(n,t,e){let i;"string"==typeof e?i=e.charCodeAt(0)||0:e.hasOwnProperty(V_)&&(i=e[V_]),null==i&&(i=e[V_]=Moe++);let r=i&k5;t.data[n+(r>>O5)]|=1<<r}(n,t,e)}function N5(n,t,e){if(e&Ci.Optional||void 0!==n)return n;VP()}function L5(n,t,e,i){if(e&Ci.Optional&&void 0===i&&(i=null),0==(e&(Ci.Self|Ci.Host))){let r=n[nM],o=Ps(void 0);try{return r?r.get(t,i,e&Ci.Optional):o5(t,i,e&Ci.Optional)}finally{Ps(o)}}return N5(i,0,e)}function B5(n,t,e,i=Ci.Default,r){if(null!==n){if(1024&t[di]){let a=function(n,t,e,i,r){let o=n,a=t;for(;null!==o&&null!==a&&1024&a[di]&&!(256&a[di]);){let s=V5(o,a,e,i|Ci.Self,rc);if(s!==rc)return s;let l=o.parent;if(!l){let c=a[u5];if(c){let d=c.get(e,rc,i);if(d!==rc)return d}l=H5(a),a=a[of]}o=l}return r}(n,t,e,i,rc);if(a!==rc)return a}let o=V5(n,t,e,i,rc);if(o!==rc)return o}return L5(t,e,i,r)}function V5(n,t,e,i,r){let o=function(n){if("string"==typeof n)return n.charCodeAt(0)||0;let t=n.hasOwnProperty(V_)?n[V_]:void 0;return"number"==typeof t?t>=0?t&k5:Doe:t}(e);if("function"==typeof o){if(!S5(t,n,i))return i&Ci.Host?N5(r,0,i):L5(t,e,i,r);try{let a=o(i);if(null!=a||i&Ci.Optional)return a;VP()}finally{I5()}}else if("number"==typeof o){let a=null,s=F5(n,t),l=Qm,c=i&Ci.Host?t[xl][Aa]:null;for((-1===s||i&Ci.SkipSelf)&&(l=-1===s?$P(n,t):t[s+8],l!==Qm&&fH(i,!1)?(a=t[Fn],s=aM(l),t=sM(l,t)):s=-1);-1!==s;){let d=t[Fn];if(mH(o,s,d.data)){let u=Eoe(s,t,e,a,i,c);if(u!==rc)return u}l=t[s+8],l!==Qm&&fH(i,t[Fn].data[s+8]===c)&&mH(o,s,t)?(a=d,s=aM(l),t=sM(l,t)):s=-1}}return r}function Eoe(n,t,e,i,r,o){let a=t[Fn],s=a.data[n+8],d=qC(s,a,e,null==i?DM(s)&&HR:i!=a&&0!=(3&s.type),r&Ci.Host&&o===s);return null!==d?Xp(t,a,d,s):rc}function qC(n,t,e,i,r){let o=n.providerIndexes,a=t.data,s=1048575&o,l=n.directiveStart,d=o>>20,p=r?s+d:n.directiveEnd;for(let h=i?s:s+d;h<p;h++){let m=a[h];if(h<l&&e===m||h>=l&&m.type===e)return h}if(r){let h=a[l];if(h&&Cl(h)&&h.type===e)return l}return null}function Xp(n,t,e,i){let r=n[e],o=t.data;if(function(n){return n instanceof qp}(r)){let a=r;a.resolving&&function(n,t){throw new xt(-200,`Circular dependency in DI detected for ${n}`)}(BP(o[e]));let s=lM(a.canSeeViewProviders);a.resolving=!0;let l=a.injectImpl?Ps(a.injectImpl):null;S5(n,i,Ci.Default);try{r=n[e]=a.factory(void 0,o,n,i),t.firstCreatePass&&e>=i.directiveStart&&function(n,t,e){let{ngOnChanges:i,ngOnInit:r,ngDoCheck:o}=t.type.prototype;if(i){let a=h5(t);(e.preOrderHooks??(e.preOrderHooks=[])).push(n,a),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,a)}r&&(e.preOrderHooks??(e.preOrderHooks=[])).push(0-n,r),o&&((e.preOrderHooks??(e.preOrderHooks=[])).push(n,o),(e.preOrderCheckHooks??(e.preOrderCheckHooks=[])).push(n,o))}(e,o[e],t)}finally{null!==l&&Ps(l),lM(s),a.resolving=!1,I5()}}return r}function mH(n,t,e){return!!(e[t+(n>>O5)]&1<<n)}function fH(n,t){return!(n&Ci.Self||n&Ci.Host&&t)}var jp=class{constructor(t,e){this._tNode=t,this._lView=e}get(t,e,i){return B5(this._tNode,this._lView,t,SM(i),e)}};function Doe(){return new jp(Lo(),Ze())}function Xn(n){return ru(()=>{let t=n.prototype.constructor,e=t[Kc]||UR(t),i=Object.prototype,r=Object.getPrototypeOf(n.prototype).constructor;for(;r&&r!==i;){let o=r[Kc]||UR(r);if(o&&o!==e)return o;r=Object.getPrototypeOf(r)}return o=>new o})}function UR(n){return t5(n)?()=>{let t=UR(Ai(n));return t&&t()}:Gp(n)}function H5(n){let t=n[Fn],e=t.type;return 2===e?t.declTNode:1===e?n[Aa]:null}function Mo(n){return function(n,t){if("class"===t)return n.classes;if("style"===t)return n.styles;let e=n.attrs;if(e){let i=e.length,r=0;for(;r<i;){let o=e[r];if(R5(o))break;if(0===o)r+=2;else if("number"==typeof o)for(r++;r<i&&"string"==typeof e[r];)r++;else{if(o===t)return e[r+1];r+=2}}}return null}(Lo(),n)}var Gm="__annotations__",Wm="__parameters__",qm="__prop__metadata__";function cb(n,t,e,i,r){return ru(()=>{let o=ek(t);function a(...s){if(this instanceof a)return o.call(this,...s),this;let l=new a(...s);return function(d){return r&&r(d,...s),(d.hasOwnProperty(Gm)?d[Gm]:Object.defineProperty(d,Gm,{value:[]})[Gm]).push(l),i&&i(d),d}}return e&&(a.prototype=Object.create(e.prototype)),a.prototype.ngMetadataName=n,a.annotationCls=a,a})}function ek(n){return function(...e){if(n){let i=n(...e);for(let r in i)this[r]=i[r]}}}function lf(n,t,e){return ru(()=>{let i=ek(t);function r(...o){if(this instanceof r)return i.apply(this,o),this;let a=new r(...o);return s.annotation=a,s;function s(l,c,d){let u=l.hasOwnProperty(Wm)?l[Wm]:Object.defineProperty(l,Wm,{value:[]})[Wm];for(;u.length<=d;)u.push(null);return(u[d]=u[d]||[]).push(a),l}}return e&&(r.prototype=Object.create(e.prototype)),r.prototype.ngMetadataName=n,r.annotationCls=r,r})}function au(n,t,e,i){return ru(()=>{let r=ek(t);function o(...a){if(this instanceof o)return r.apply(this,a),this;let s=new o(...a);return function(c,d){let u=c.constructor,p=u.hasOwnProperty(qm)?u[qm]:Object.defineProperty(u,qm,{value:{}})[qm];p[d]=p.hasOwnProperty(d)&&p[d]||[],p[d].unshift(s),i&&i(c,d,...a)}}return e&&(o.prototype=Object.create(e.prototype)),o.prototype.ngMetadataName=n,o.annotationCls=o,o})}var Aoe=lf("Attribute",n=>({attributeName:n,__NG_ELEMENT_ID__:()=>Mo(n)})),te=class{constructor(t,e){this._desc=t,this.ngMetadataName="InjectionToken",this.\u0275prov=void 0,"number"==typeof e?this.__NG_ELEMENT_ID__=e:void 0!==e&&(this.\u0275prov=ue({token:this,providedIn:e.providedIn||"root",factory:e.factory}))}get multi(){return this}toString(){return`InjectionToken ${this._desc}`}},Jm=(new te("AnalyzeForEntryComponents"),class{});function Fs(n){let t=zr.ng;if(t&&t.\u0275compilerFacade)return t.\u0275compilerFacade;throw new Error("JIT compiler unavailable")}au("ContentChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!1,descendants:!1,emitDistinctChangesOnly:!0,...t}),Jm),au("ContentChild",(n,t={})=>({selector:n,first:!0,isViewQuery:!1,descendants:!0,...t}),Jm),au("ViewChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!0,descendants:!0,emitDistinctChangesOnly:!0,...t}),Jm),au("ViewChild",(n,t)=>({selector:n,first:!0,isViewQuery:!0,descendants:!0,...t}),Jm);var Roe=Function;function F_(n){return"function"==typeof n}function Jd(n){return n.flat(Number.POSITIVE_INFINITY)}function tk(n,t){n.forEach(e=>Array.isArray(e)?tk(e,t):t(e))}function U5(n,t,e){t>=n.length?n.push(e):n.splice(t,0,e)}function dM(n,t){return t>=n.length-1?n.pop():n.splice(t,1)[0]}function H_(n,t){let e=[];for(let i=0;i<n;i++)e.push(t);return e}function ls(n,t,e){let i=db(n,t);return i>=0?n[1|i]=e:(i=~i,function(n,t,e,i){let r=n.length;if(r==t)n.push(e,i);else if(1===r)n.push(i,n[0]),n[0]=e;else{for(r--,n.push(n[r-1],n[r]);r>t;)n[r]=n[r-2],r--;n[t]=e,n[t+1]=i}}(n,i,t,e)),i}function hR(n,t){let e=db(n,t);if(e>=0)return n[1|e]}function db(n,t){return function(n,t,e){let i=0,r=n.length>>1;for(;r!==i;){let o=i+(r-i>>1),a=n[o<<1];if(t===a)return o<<1;a>t?r=o:i=o+1}return~(r<<1)}(n,t)}var Foe=/^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/,Noe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/,Loe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/,Boe=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/,jR=class{constructor(t){this._reflect=t||zr.Reflect}factory(t){return(...e)=>new t(...e)}_zipTypesAndAnnotations(t,e){let i;i=H_(typeof t>"u"?e.length:t.length);for(let r=0;r<i.length;r++)i[r]=typeof t>"u"?[]:t[r]&&t[r]!=Object?[t[r]]:[],e&&null!=e[r]&&(i[r]=i[r].concat(e[r]));return i}_ownParameters(t,e){let i=t.toString();if(Foe.test(n=i)||Boe.test(n)||Noe.test(n)&&!Loe.test(n))return null;var n;if(t.parameters&&t.parameters!==e.parameters)return t.parameters;let r=t.ctorParameters;if(r&&r!==e.ctorParameters){let s="function"==typeof r?r():r,l=s.map(d=>d&&d.type),c=s.map(d=>d&&mR(d.decorators));return this._zipTypesAndAnnotations(l,c)}let o=t.hasOwnProperty(Wm)&&t[Wm],a=this._reflect&&this._reflect.getOwnMetadata&&this._reflect.getOwnMetadata("design:paramtypes",t);return a||o?this._zipTypesAndAnnotations(a,o):H_(t.length)}parameters(t){if(!F_(t))return[];let e=VC(t),i=this._ownParameters(t,e);return!i&&e!==Object&&(i=this.parameters(e)),i||[]}_ownAnnotations(t,e){if(t.annotations&&t.annotations!==e.annotations){let i=t.annotations;return"function"==typeof i&&i.annotations&&(i=i.annotations),i}return t.decorators&&t.decorators!==e.decorators?mR(t.decorators):t.hasOwnProperty(Gm)?t[Gm]:null}annotations(t){if(!F_(t))return[];let e=VC(t),i=this._ownAnnotations(t,e)||[];return(e!==Object?this.annotations(e):[]).concat(i)}_ownPropMetadata(t,e){if(t.propMetadata&&t.propMetadata!==e.propMetadata){let i=t.propMetadata;return"function"==typeof i&&i.propMetadata&&(i=i.propMetadata),i}if(t.propDecorators&&t.propDecorators!==e.propDecorators){let i=t.propDecorators,r={};return Object.keys(i).forEach(o=>{r[o]=mR(i[o])}),r}return t.hasOwnProperty(qm)?t[qm]:null}propMetadata(t){if(!F_(t))return{};let e=VC(t),i={};if(e!==Object){let o=this.propMetadata(e);Object.keys(o).forEach(a=>{i[a]=o[a]})}let r=this._ownPropMetadata(t,e);return r&&Object.keys(r).forEach(o=>{let a=[];i.hasOwnProperty(o)&&a.push(...i[o]),a.push(...r[o]),i[o]=a}),i}ownPropMetadata(t){return F_(t)&&this._ownPropMetadata(t,VC(t))||{}}hasLifecycleHook(t,e){return t instanceof Roe&&e in t.prototype}};function mR(n){return n?n.map(t=>new(0,t.type.annotationCls)(...t.args?t.args:[])):[]}function VC(n){let t=n.prototype?Object.getPrototypeOf(n.prototype):null;return(t?t.constructor:null)||Object}var cf=ab(lf("Inject",n=>({token:n})),-1),ka=ab(lf("Optional"),8),Hoe=ab(lf("Self"),2),id=ab(lf("SkipSelf"),4),zoe=ab(lf("Host"),1),gH=null;function nk(){return gH=gH||new jR}function PM(n){return j5(nk().parameters(n))}function j5(n){return n.map(t=>function(n){let t={token:null,attribute:null,host:!1,optional:!1,self:!1,skipSelf:!1};if(Array.isArray(n)&&n.length>0)for(let e=0;e<n.length;e++){let i=n[e];if(void 0===i)continue;let r=Object.getPrototypeOf(i);if(i instanceof ka||"Optional"===r.ngMetadataName)t.optional=!0;else if(i instanceof id||"SkipSelf"===r.ngMetadataName)t.skipSelf=!0;else if(i instanceof Hoe||"Self"===r.ngMetadataName)t.self=!0;else if(i instanceof zoe||"Host"===r.ngMetadataName)t.host=!0;else if(i instanceof cf)t.token=i.token;else if(i instanceof Aoe){if(void 0===i.attributeName)throw new xt(204,!1);t.attribute=i.attributeName}else t.token=i}else t.token=void 0===n||Array.isArray(n)&&0===n.length?null:n;return t}(t))}var J_=new Map,G5=new Set;function W5(n){return!!(n.templateUrl&&!n.hasOwnProperty("template")||n.styleUrls&&n.styleUrls.length)}var _H=new Map,Qoe=!0;function q5(n,t){(function(n,t,e){if(t&&t!==e&&Qoe)throw new Error(`Duplicate module registered for ${n} - ${po(t)} vs ${po(t.name)}`)})(t,_H.get(t)||null,n),_H.set(t,n)}var GR,Ns=(()=>{return(n=Ns||(Ns={}))[n.Important=1]="Important",n[n.DashCase=2]="DashCase",Ns;var n})(),Koe=/^>|^->|<!--|-->|--!>|<!-$/g,Joe=/(<|>)/,$oe="\u200b$1\u200b",X5=new Map,tae=0,bH="__ngContext__";function sc(n,t){Up(t)?(n[bH]=t[TM],function(n){X5.set(n[TM],n)}(t)):n[bH]=t}function ik(n,t){return GR(n,t)}function rk(n){let t=n[jr];return $c(t)?t[jr]:t}function ok(n){return Y5(n[Q_])}function ak(n){return Y5(n[yl])}function Y5(n){for(;null!==n&&!$c(n);)n=n[yl];return n}function Xm(n,t,e,i,r){if(null!=i){let o,a=!1;$c(i)?o=i:Up(i)&&(a=!0,i=i[ou]);let s=Ls(i);0===n&&null!==e?null==r?ez(t,e,s):Yp(t,e,s,r||null,!0):1===n&&null!==e?Yp(t,e,s,r||null,!0):2===n?ck(t,s,a):3===n&&t.destroyNode(s),null!=o&&function(n,t,e,i,r){let o=e[GP];o!==Ls(e)&&Xm(t,n,i,o,r);for(let s=Ia;s<e.length;s++){let l=e[s];ub(l[Fn],l,n,t,i,o)}}(t,n,o,e,r)}}function sk(n,t){return n.createText(t)}function Q5(n,t,e){n.setValue(t,e)}function aae(n,t){return n.createComment(function(n){return n.replace(Koe,t=>t.replace(Joe,$oe))}(t))}function lk(n,t,e){return n.createElement(t,e)}function Z5(n,t){let e=n[Km],i=e.indexOf(t),r=t[jr];512&t[di]&&(t[di]&=-513,qP(r,-1)),e.splice(i,1)}function WR(n,t){if(n.length<=Ia)return;let e=Ia+t,i=n[e];if(i){let r=i[lb];null!==r&&r!==n&&Z5(r,i),t>0&&(n[e-1][yl]=i[yl]);let o=dM(n,Ia+t);!function(n,t){ub(n,t,t[ui],2,null,null),t[ou]=null,t[Aa]=null}(i[Fn],i);let a=o[oc];null!==a&&a.detachView(o[Fn]),i[jr]=null,i[yl]=null,i[di]&=-65}return i}function K5(n,t){if(!(128&t[di])){let e=t[ui];e.destroyNode&&ub(n,t,e,3,null,null),function(n){let t=n[Q_];if(!t)return fR(n[Fn],n);for(;t;){let e=null;if(Up(t))e=t[Q_];else{let i=t[Ia];i&&(e=i)}if(!e){for(;t&&!t[yl]&&t!==n;)Up(t)&&fR(t[Fn],t),t=t[jr];null===t&&(t=n),Up(t)&&fR(t[Fn],t),e=t&&t[yl]}t=e}}(t)}}function fR(n,t){if(!(128&t[di])){t[di]&=-65,t[di]|=128,function(n,t){let e;if(null!=n&&null!=(e=n.destroyHooks))for(let i=0;i<e.length;i+=2){let r=t[e[i]];if(!(r instanceof qp)){let o=e[i+1];if(Array.isArray(o))for(let a=0;a<o.length;a+=2){let s=r[o[a]],l=o[a+1];ks(4,s,l);try{l.call(s)}finally{ks(5,s,l)}}else{ks(4,r,o);try{o.call(r)}finally{ks(5,r,o)}}}}}(n,t),function(n,t){let e=n.cleanup,i=t[Y_],r=-1;if(null!==e)for(let o=0;o<e.length-1;o+=2)if("string"==typeof e[o]){let a=e[o+3];a>=0?i[r=a]():i[r=-a].unsubscribe(),o+=2}else{let a=i[r=e[o+1]];e[o].call(a)}if(null!==i){for(let o=r+1;o<i.length;o++)(0,i[o])();t[Y_]=null}}(n,t),1===t[Fn].type&&t[ui].destroy();let e=t[lb];if(null!==e&&$c(t[jr])){e!==t[jr]&&Z5(e,t);let i=t[oc];null!==i&&i.detachView(n)}!function(n){X5.delete(n[TM])}(t)}}function J5(n,t,e){return $5(n,t.parent,e)}function $5(n,t,e){let i=t;for(;null!==i&&40&i.type;)i=(t=i).parent;if(null===i)return e[ou];{let{componentOffset:r}=i;if(r>-1){let{encapsulation:o}=n.data[i.directiveStart+r];if(o===as.None||o===as.Emulated)return null}return ss(i,e)}}function Yp(n,t,e,i,r){n.insertBefore(t,e,i,r)}function ez(n,t,e){n.appendChild(t,e)}function vH(n,t,e,i,r){null!==i?Yp(n,t,e,i,r):ez(n,t,e)}function kM(n,t){return n.parentNode(t)}function tz(n,t,e){return iz(n,t,e)}function nz(n,t,e){return 40&n.type?ss(n,e):null}var qR,HC,YR,zC,iz=nz;function rz(n,t){iz=n,qR=t}function OM(n,t,e,i){let r=J5(n,i,t),o=t[ui],s=tz(i.parent||t[Aa],i,t);if(null!=r)if(Array.isArray(e))for(let l=0;l<e.length;l++)vH(o,r,e[l],s,!1);else vH(o,r,e,s,!1);void 0!==qR&&qR(o,i,t,e,r)}function XC(n,t){if(null!==t){let e=t.type;if(3&e)return ss(t,n);if(4&e)return XR(-1,n[t.index]);if(8&e){let i=t.child;if(null!==i)return XC(n,i);{let r=n[t.index];return $c(r)?XR(-1,r):Ls(r)}}if(32&e)return ik(t,n)()||Ls(n[t.index]);{let i=oz(n,t);return null!==i?Array.isArray(i)?i[0]:XC(rk(n[xl]),i):XC(n,t.next)}}return null}function oz(n,t){return null!==t?n[xl][Aa].projection[t.projection]:null}function XR(n,t){let e=Ia+n+1;if(e<t.length){let i=t[e],r=i[Fn].firstChild;if(null!==r)return XC(i,r)}return t[GP]}function ck(n,t,e){let i=kM(n,t);i&&function(n,t,e,i){n.removeChild(t,e,i)}(n,i,t,e)}function dk(n,t,e,i,r,o,a){for(;null!=e;){let s=i[e.index],l=e.type;if(a&&0===t&&(s&&sc(Ls(s),i),e.flags|=2),32!=(32&e.flags))if(8&l)dk(n,t,e.child,i,r,o,!1),Xm(t,n,r,s,o);else if(32&l){let d,c=ik(e,i);for(;d=c();)Xm(t,n,r,d,o);Xm(t,n,r,s,o)}else 16&l?az(n,t,i,e,r,o):Xm(t,n,r,s,o);e=a?e.projectionNext:e.next}}function ub(n,t,e,i,r,o){dk(e,i,n.firstChild,t,r,o,!1)}function az(n,t,e,i,r,o){let a=e[xl],l=a[Aa].projection[i.projection];if(Array.isArray(l))for(let c=0;c<l.length;c++)Xm(t,n,r,l[c],o);else dk(n,t,l,a[jr],r,o,!0)}function sz(n,t,e){""===e?n.removeAttribute(t,"class"):n.setAttribute(t,"class",e)}function lz(n,t,e){let{mergedAttrs:i,classes:r,styles:o}=e;null!==i&&VR(n,t,i),null!==r&&sz(n,t,r),null!==o&&function(n,t,e){n.setAttribute(t,"style",e)}(n,t,o)}function cz(){if(void 0===HC&&(HC=null,zr.trustedTypes))try{HC=zr.trustedTypes.createPolicy("angular",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return HC}function df(n){return cz()?.createHTML(n)||n}function uz(){return void 0!==YR?YR:typeof document<"u"?document:void 0}function uk(){if(void 0===zC&&(zC=null,zr.trustedTypes))try{zC=zr.trustedTypes.createPolicy("angular#unsafe-bypass",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return zC}function yH(n){return uk()?.createHTML(n)||n}function xH(n){return uk()?.createScript(n)||n}function CH(n){return uk()?.createScriptURL(n)||n}var Jc=class{constructor(t){this.changingThisBreaksApplicationSecurity=t}toString(){return`SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see ${ob})`}},QR=class extends Jc{getTypeName(){return"HTML"}},ZR=class extends Jc{getTypeName(){return"Style"}},KR=class extends Jc{getTypeName(){return"Script"}},JR=class extends Jc{getTypeName(){return"URL"}},$R=class extends Jc{getTypeName(){return"ResourceURL"}};function Oa(n){return n instanceof Jc?n.changingThisBreaksApplicationSecurity:n}function wl(n,t){let e=function(n){return n instanceof Jc&&n.getTypeName()||null}(n);if(null!=e&&e!==t){if("ResourceURL"===e&&"URL"===t)return!0;throw new Error(`Required a safe ${t}, got a ${e} (see ${ob})`)}return e===t}function _z(n){let t=new tP(n);return function(){try{return!!(new window.DOMParser).parseFromString(df(""),"text/html")}catch{return!1}}()?new eP(t):t}var eP=class{constructor(t){this.inertDocumentHelper=t}getInertBodyElement(t){t="<body><remove></remove>"+t;try{let e=(new window.DOMParser).parseFromString(df(t),"text/html").body;return null===e?this.inertDocumentHelper.getInertBodyElement(t):(e.removeChild(e.firstChild),e)}catch{return null}}},tP=class{constructor(t){this.defaultDoc=t,this.inertDocument=this.defaultDoc.implementation.createHTMLDocument("sanitization-inert")}getInertBodyElement(t){let e=this.inertDocument.createElement("template");return e.innerHTML=df(t),e}},Sae=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;function pb(n){return(n=String(n)).match(Sae)?n:"unsafe:"+n}function rd(n){let t={};for(let e of n.split(","))t[e]=!0;return t}function hb(...n){let t={};for(let e of n)for(let i in e)e.hasOwnProperty(i)&&(t[i]=!0);return t}var UC,bz=rd("area,br,col,hr,img,wbr"),vz=rd("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),yz=rd("rp,rt"),Eae=hb(yz,vz),Tae=hb(vz,rd("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul")),Dae=hb(yz,rd("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video")),nP=hb(bz,Tae,Dae,Eae),pk=rd("background,cite,href,itemtype,longdesc,poster,src,xlink:href"),Iae=rd("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width"),Aae=rd("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext"),xz=hb(pk,Iae,Aae),Rae=rd("script,style,template"),iP=class{constructor(){this.sanitizedSomething=!1,this.buf=[]}sanitizeChildren(t){let e=t.firstChild,i=!0;for(;e;)if(e.nodeType===Node.ELEMENT_NODE?i=this.startElement(e):e.nodeType===Node.TEXT_NODE?this.chars(e.nodeValue):this.sanitizedSomething=!0,i&&e.firstChild)e=e.firstChild;else for(;e;){e.nodeType===Node.ELEMENT_NODE&&this.endElement(e);let r=this.checkClobberedElement(e,e.nextSibling);if(r){e=r;break}e=this.checkClobberedElement(e,e.parentNode)}return this.buf.join("")}startElement(t){let e=t.nodeName.toLowerCase();if(!nP.hasOwnProperty(e))return this.sanitizedSomething=!0,!Rae.hasOwnProperty(e);this.buf.push("<"),this.buf.push(e);let i=t.attributes;for(let r=0;r<i.length;r++){let o=i.item(r),a=o.name,s=a.toLowerCase();if(!xz.hasOwnProperty(s)){this.sanitizedSomething=!0;continue}let l=o.value;pk[s]&&(l=pb(l)),this.buf.push(" ",a,'="',MH(l),'"')}return this.buf.push(">"),!0}endElement(t){let e=t.nodeName.toLowerCase();nP.hasOwnProperty(e)&&!bz.hasOwnProperty(e)&&(this.buf.push("</"),this.buf.push(e),this.buf.push(">"))}chars(t){this.buf.push(MH(t))}checkClobberedElement(t,e){if(e&&(t.compareDocumentPosition(e)&Node.DOCUMENT_POSITION_CONTAINED_BY)===Node.DOCUMENT_POSITION_CONTAINED_BY)throw new Error(`Failed to sanitize html because the element is clobbered: ${t.outerHTML}`);return e}},Pae=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,kae=/([^\#-~ |!])/g;function MH(n){return n.replace(/&/g,"&amp;").replace(Pae,function(t){return"&#"+(1024*(t.charCodeAt(0)-55296)+(t.charCodeAt(1)-56320)+65536)+";"}).replace(kae,function(t){return"&#"+t.charCodeAt(0)+";"}).replace(/</g,"&lt;").replace(/>/g,"&gt;")}function hk(n,t){let e=null;try{UC=UC||_z(n);let i=t?String(t):"";e=UC.getInertBodyElement(i);let r=5,o=i;do{if(0===r)throw new Error("Failed to sanitize html because the input is unstable");r--,i=o,o=e.innerHTML,e=UC.getInertBodyElement(i)}while(i!==o);return df((new iP).sanitizeChildren(rP(e)||e))}finally{if(e){let i=rP(e)||e;for(;i.firstChild;)i.removeChild(i.firstChild)}}}function rP(n){return"content"in n&&function(n){return n.nodeType===Node.ELEMENT_NODE&&"TEMPLATE"===n.nodeName}(n)?n.content:null}var Ur=(()=>{return(n=Ur||(Ur={}))[n.NONE=0]="NONE",n[n.HTML=1]="HTML",n[n.STYLE=2]="STYLE",n[n.SCRIPT=3]="SCRIPT",n[n.URL=4]="URL",n[n.RESOURCE_URL=5]="RESOURCE_URL",Ur;var n})();function mk(n){let t=mb();return t?yH(t.sanitize(Ur.HTML,n)||""):wl(n,"HTML")?yH(Oa(n)):hk(uz(),jn(n))}function Vs(n){let t=mb();return t?t.sanitize(Ur.URL,n)||"":wl(n,"URL")?Oa(n):pb(jn(n))}function Cz(n){let t=mb();if(t)return CH(t.sanitize(Ur.RESOURCE_URL,n)||"");if(wl(n,"ResourceURL"))return CH(Oa(n));throw new xt(904,!1)}function mb(){let n=Ze();return n&&n[NR]}var FM=new te("ENVIRONMENT_INITIALIZER"),Mz=new te("INJECTOR",-1),wz=new te("INJECTOR_DEF_TYPES"),uM=class{get(t,e=X_){if(e===X_){let i=new Error(`NullInjectorError: No provider for ${po(t)}!`);throw i.name="NullInjectorError",i}return e}};function zae(...n){return{"\u0275providers":Sz(0,n),"\u0275fromNgModule":!0}}function Sz(n,...t){let r,e=[],i=new Set;return tk(t,o=>{let a=o;oP(a,e,[],i)&&(r||(r=[]),r.push(a))}),void 0!==r&&Ez(r,e),e}function Ez(n,t){for(let e=0;e<n.length;e++){let{providers:r}=n[e];fk(r,o=>{t.push(o)})}}function oP(n,t,e,i){if(!(n=Ai(n)))return!1;let r=null,o=lH(n),a=!o&&Os(n);if(o||a){if(a&&!a.standalone)return!1;r=n}else{let l=n.ngModule;if(o=lH(l),!o)return!1;r=l}let s=i.has(r);if(a){if(s)return!1;if(i.add(r),a.dependencies){let l="function"==typeof a.dependencies?a.dependencies():a.dependencies;for(let c of l)oP(c,t,e,i)}}else{if(!o)return!1;{if(null!=o.imports&&!s){let c;i.add(r);try{tk(o.imports,d=>{oP(d,t,e,i)&&(c||(c=[]),c.push(d))})}finally{}void 0!==c&&Ez(c,t)}if(!s){let c=Gp(r)||(()=>new r);t.push({provide:r,useFactory:c,deps:ji},{provide:wz,useValue:r,multi:!0},{provide:FM,useValue:()=>O(r),multi:!0})}let l=o.providers;null==l||s||fk(l,d=>{t.push(d)})}}return r!==n&&void 0!==n.providers}function fk(n,t){for(let e of n)n5(e)&&(e=e.\u0275providers),Array.isArray(e)?fk(e,t):t(e)}var Uae=$i({provide:String,useValue:$i});function Tz(n){return null!==n&&"object"==typeof n&&Uae in n}function $m(n){return"function"==typeof n}var gR,LM=new te("Set Injector scope."),YC={},qae={};function gk(){return void 0===gR&&(gR=new uM),gR}var lc=class{},pM=class extends lc{get destroyed(){return this._destroyed}constructor(t,e,i,r){super(),this.parent=e,this.source=i,this.scopes=r,this.records=new Map,this._ngOnDestroyHooks=new Set,this._onDestroyHooks=[],this._destroyed=!1,sP(t,a=>this.processProvider(a)),this.records.set(Mz,Ym(void 0,this)),r.has("environment")&&this.records.set(lc,Ym(void 0,this));let o=this.records.get(LM);null!=o&&"string"==typeof o.value&&this.scopes.add(o.value),this.injectorDefTypes=new Set(this.get(wz.multi,ji,Ci.Self))}destroy(){this.assertNotDestroyed(),this._destroyed=!0;try{for(let t of this._ngOnDestroyHooks)t.ngOnDestroy();for(let t of this._onDestroyHooks)t()}finally{this.records.clear(),this._ngOnDestroyHooks.clear(),this.injectorDefTypes.clear(),this._onDestroyHooks.length=0}}onDestroy(t){this._onDestroyHooks.push(t)}runInContext(t){this.assertNotDestroyed();let e=Um(this),i=Ps(void 0);try{return t()}finally{Um(e),Ps(i)}}get(t,e=X_,i=Ci.Default){this.assertNotDestroyed(),i=SM(i);let r=Um(this),o=Ps(void 0);try{if(!(i&Ci.SkipSelf)){let s=this.records.get(t);if(void 0===s){let l=("function"==typeof(n=t)||"object"==typeof n&&n instanceof te)&&HP(t);s=l&&this.injectableDefInScope(l)?Ym(aP(t),YC):null,this.records.set(t,s)}if(null!=s)return this.hydrate(t,s)}return(i&Ci.Self?gk():this.parent).get(t,e=i&Ci.Optional&&e===X_?null:e)}catch(a){if("NullInjectorError"===a.name){if((a[eM]=a[eM]||[]).unshift(po(t)),r)throw a;return function(n,t,e,i){let r=n[eM];throw t[cH]&&r.unshift(t[cH]),n.message=function(n,t,e,i=null){n=n&&"\n"===n.charAt(0)&&n.charAt(1)==Vre?n.slice(2):n;let r=po(t);if(Array.isArray(t))r=t.map(po).join(" -> ");else if("object"==typeof t){let o=[];for(let a in t)if(t.hasOwnProperty(a)){let s=t[a];o.push(a+":"+("string"==typeof s?JSON.stringify(s):po(s)))}r=`{${o.join(", ")}}`}return`${e}${i?"("+i+")":""}[${r}]: ${n.replace(Bre,"\n  ")}`}("\n"+n.message,r,e,i),n[Lre]=r,n[eM]=null,n}(a,t,"R3InjectorError",this.source)}throw a}finally{Ps(o),Um(r)}var n}resolveInjectorInitializers(){let t=Um(this),e=Ps(void 0);try{let i=this.get(FM.multi,ji,Ci.Self);for(let r of i)r()}finally{Um(t),Ps(e)}}toString(){let t=[],e=this.records;for(let i of e.keys())t.push(po(i));return`R3Injector[${t.join(", ")}]`}assertNotDestroyed(){if(this._destroyed)throw new xt(205,!1)}processProvider(t){let e=$m(t=Ai(t))?t:Ai(t&&t.provide),i=function(n){return Tz(n)?Ym(void 0,n.useValue):Ym(Dz(n),YC)}(t);if($m(t)||!0!==t.multi)this.records.get(e);else{let r=this.records.get(e);r||(r=Ym(void 0,YC,!0),r.factory=()=>FR(r.multi),this.records.set(e,r)),e=t,r.multi.push(t)}this.records.set(e,i)}hydrate(t,e){return e.value===YC&&(e.value=qae,e.value=e.factory()),"object"==typeof e.value&&e.value&&null!==(n=e.value)&&"object"==typeof n&&"function"==typeof n.ngOnDestroy&&this._ngOnDestroyHooks.add(e.value),e.value;var n}injectableDefInScope(t){if(!t.providedIn)return!1;let e=Ai(t.providedIn);return"string"==typeof e?"any"===e||this.scopes.has(e):this.injectorDefTypes.has(e)}};function aP(n){let t=HP(n),e=null!==t?t.factory:Gp(n);if(null!==e)return e;if(n instanceof te)throw new xt(204,!1);if(n instanceof Function)return function(n){let t=n.length;if(t>0)throw H_(t,"?"),new xt(204,!1);let e=function(n){return n&&(n[$C]||n[r5])||null}(n);return null!==e?()=>e.factory(n):()=>new n}(n);throw new xt(204,!1)}function Dz(n,t,e){let i;if($m(n)){let r=Ai(n);return Gp(r)||aP(r)}if(Tz(n))i=()=>Ai(n.useValue);else if(function(n){return!(!n||!n.useFactory)}(n))i=()=>n.useFactory(...FR(n.deps||[]));else if(function(n){return!(!n||!n.useExisting)}(n))i=()=>O(Ai(n.useExisting));else{let r=Ai(n&&(n.useClass||n.provide));if(!function(n){return!!n.deps}(n))return Gp(r)||aP(r);i=()=>new r(...FR(n.deps))}return i}function Ym(n,t,e=!1){return{factory:n,value:t,multi:e?[]:void 0}}function sP(n,t){for(let e of n)Array.isArray(e)?sP(e,t):e&&n5(e)?sP(e.\u0275providers,t):t(e)}var lP=class{},hM=class{},cP=class{resolveComponentFactory(t){throw function(n){let t=Error(`No component factory found for ${po(n)}. Did you add it to @NgModule.entryComponents?`);return t.ngComponent=n,t}(t)}},ho=(()=>{class n{}return n.NULL=new cP,n})();function ese(){return uf(Lo(),Ze())}function uf(n,t){return new xe(ss(n,t))}var xe=(()=>{class n{constructor(e){this.nativeElement=e}}return n.__NG_ELEMENT_ID__=ese,n})();function tse(n){return n instanceof xe?n.nativeElement:n}var cc=class{},dc=(()=>{class n{}return n.__NG_ELEMENT_ID__=()=>function(){let n=Ze(),e=ed(Lo().index,n);return(Up(e)?e:n)[ui]}(),n})(),ise=(()=>{class n{}return n.\u0275prov=ue({token:n,providedIn:"root",factory:()=>null}),n})(),Ml=class{constructor(t){this.full=t,this.major=t.split(".")[0],this.minor=t.split(".")[1],this.patch=t.split(".").slice(2).join(".")}},rse=new Ml("15.2.9"),_R={},ose="ngOriginalError";function bR(n){return n[ose]}var la=class{constructor(){this._console=console}handleError(t){let e=this._findOriginalError(t);this._console.error("ERROR",t),e&&this._console.error("ORIGINAL ERROR",e)}_findOriginalError(t){let e=t&&bR(t);for(;e&&bR(e);)e=bR(e);return e||null}};function su(n){return n.ownerDocument}function QC(n){return n instanceof Function?n():n}function Iz(n,t,e){let i=n.length;for(;;){let r=n.indexOf(t,e);if(-1===r)return r;if(0===r||n.charCodeAt(r-1)<=32){let o=t.length;if(r+o===i||n.charCodeAt(r+o)<=32)return r}e=r+1}}var Az="ng-template";function lse(n,t,e){let i=0,r=!0;for(;i<n.length;){let o=n[i++];if("string"==typeof o&&r){let a=n[i++];if(e&&"class"===o&&-1!==Iz(a.toLowerCase(),t,0))return!0}else{if(1===o){for(;i<n.length&&"string"==typeof(o=n[i++]);)if(o.toLowerCase()===t)return!0;return!1}"number"==typeof o&&(r=!1)}}return!1}function Rz(n){return 4===n.type&&n.value!==Az}function cse(n,t,e){return t===(4!==n.type||e?n.value:Az)}function dse(n,t,e){let i=4,r=n.attrs||[],o=function(n){for(let t=0;t<n.length;t++)if(R5(n[t]))return t;return n.length}(r),a=!1;for(let s=0;s<t.length;s++){let l=t[s];if("number"!=typeof l){if(!a)if(4&i){if(i=2|1&i,""!==l&&!cse(n,l,e)||""===l&&1===t.length){if(bl(i))return!1;a=!0}}else{let c=8&i?l:t[++s];if(8&i&&null!==n.attrs){if(!lse(n.attrs,c,e)){if(bl(i))return!1;a=!0}continue}let u=use(8&i?"class":l,r,Rz(n),e);if(-1===u){if(bl(i))return!1;a=!0;continue}if(""!==c){let p;p=u>o?"":r[u+1].toLowerCase();let h=8&i?p:null;if(h&&-1!==Iz(h,c,0)||2&i&&c!==p){if(bl(i))return!1;a=!0}}}}else{if(!a&&!bl(i)&&!bl(l))return!1;if(a&&bl(l))continue;a=!1,i=l|1&i}}return bl(i)||a}function bl(n){return 0==(1&n)}function use(n,t,e,i){if(null===t)return-1;let r=0;if(i||!e){let o=!1;for(;r<t.length;){let a=t[r];if(a===n)return r;if(3===a||6===a)o=!0;else{if(1===a||2===a){let s=t[++r];for(;"string"==typeof s;)s=t[++r];continue}if(4===a)break;if(0===a){r+=4;continue}}r+=o?1:2}return-1}return function(n,t){let e=n.indexOf(4);if(e>-1)for(e++;e<n.length;){let i=n[e];if("number"==typeof i)return-1;if(i===t)return e;e++}return-1}(t,n)}function Pz(n,t,e=!1){for(let i=0;i<t.length;i++)if(dse(n,t[i],e))return!0;return!1}function fse(n,t){e:for(let e=0;e<t.length;e++){let i=t[e];if(n.length===i.length){for(let r=0;r<n.length;r++)if(n[r]!==i[r])continue e;return!0}}return!1}function wH(n,t){return n?":not("+t.trim()+")":t}function gse(n){let t=n[0],e=1,i=2,r="",o=!1;for(;e<n.length;){let a=n[e];if("string"==typeof a)if(2&i){let s=n[++e];r+="["+a+(s.length>0?'="'+s+'"':"")+"]"}else 8&i?r+="."+a:4&i&&(r+=" "+a);else""!==r&&!bl(a)&&(t+=wH(o,r),r=""),i=a,o=o||!bl(i);e++}return""!==r&&(t+=wH(o,r)),t}var zn={};function v(n){kz(Ti(),Ze(),da()+n,!1)}function kz(n,t,e,i){if(!i)if(3==(3&t[di])){let o=n.preOrderCheckHooks;null!==o&&GC(t,o,e)}else{let o=n.preOrderHooks;null!==o&&WC(t,o,0,e)}Wp(e)}var SH={"\u0275\u0275defineInjectable":ue,"\u0275\u0275defineInjector":H,"\u0275\u0275inject":O,"\u0275\u0275invalidFactoryDep":a5,resolveForwardRef:Ai};var yse=$i({provide:String,useValue:$i});function EH(n){return void 0!==n.useClass}function TH(n){return void 0!==n.useFactory}var Oz=cb("Injectable",void 0,void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;n.hasOwnProperty($C)||Object.defineProperty(n,$C,{get:()=>(null===e&&(e=Fs().compileInjectable(SH,`ng:///${n.name}/\u0275prov.js`,function(n,t){let e=t||{providedIn:null},i={name:n.name,type:n,typeArgumentCount:0,providedIn:e.providedIn};return(EH(e)||TH(e))&&void 0!==e.deps&&(i.deps=j5(e.deps)),EH(e)?i.useClass=e.useClass:function(n){return yse in n}(e)?i.useValue=e.useValue:TH(e)?i.useFactory=e.useFactory:function(n){return void 0!==n.useExisting}(e)&&(i.useExisting=e.useExisting),i}(n,t))),e)}),n.hasOwnProperty(Kc)||Object.defineProperty(n,Kc,{get:()=>{if(null===i){let r=Fs();i=r.compileFactory(SH,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,typeArgumentCount:0,deps:PM(n),target:r.FactoryTarget.Injectable})}return i},configurable:!0})}(n,t));function DH(n,t=null,e=null,i){let r=Fz(n,t,e,i);return r.resolveInjectorInitializers(),r}function Fz(n,t=null,e=null,i,r=new Set){let o=[e||ji,zae(n)];return i=i||("object"==typeof n?void 0:po(n)),new pM(o,t||gk(),i||null,r)}var wi=(()=>{class n{static create(e,i){if(Array.isArray(e))return DH({name:""},i,e,"");{let r=e.name??"";return DH({name:r},e.parent,e.providers,r)}}}return n.THROW_IF_NOT_FOUND=X_,n.NULL=new uM,n.\u0275prov=ue({token:n,providedIn:"any",factory:()=>O(Mz)}),n.__NG_ELEMENT_ID__=-1,n})(),z_=class{constructor(t,e){if(this.token=t,this.id=e,!t)throw new xt(208,!1);this.displayName=po(this.token)}static get(t){return IH.get(Ai(t))}static get numberOfKeys(){return IH.numberOfKeys}},IH=new class{constructor(){this._allKeys=new Map}get(t){if(t instanceof z_)return t;if(this._allKeys.has(t))return this._allKeys.get(t);let e=new z_(t,z_.numberOfKeys);return this._allKeys.set(t,e),e}get numberOfKeys(){return this._allKeys.size}};function C(n,t=Ci.Default){let e=Ze();return null===e?O(n,t):B5(Lo(),e,Ai(n),t)}function cs(){throw new Error("invalid")}function Nz(n,t){let e=n.contentQueries;if(null!==e)for(let i=0;i<e.length;i+=2){let o=e[i+1];if(-1!==o){let a=n.data[o];ZP(e[i]),a.contentQueries(2,t[o],o)}}}function BM(n,t,e,i,r,o,a,s,l,c,d){let u=t.blueprint.slice();return u[ou]=r,u[di]=76|i,(null!==d||n&&1024&n[di])&&(u[di]|=1024),v5(u),u[jr]=u[of]=n,u[Ra]=e,u[iM]=a||n&&n[iM],u[ui]=s||n&&n[ui],u[NR]=l||n&&n[NR]||null,u[nM]=c||n&&n[nM]||null,u[Aa]=o,u[TM]=tae++,u[u5]=d,u[xl]=2==t.type?n[xl]:u,u}function pf(n,t,e,i,r){let o=n.data[t];if(null===o)o=_k(n,t,e,i,r),Gn.lFrame.inI18n&&(o.flags|=32);else if(64&o.type){o.type=e,o.value=i,o.attrs=r;let a=Z_();o.injectorIndex=null===a?-1:a.injectorIndex}return ac(o,!0),o}function _k(n,t,e,i,r){let o=x5(),a=XP(),l=n.data[t]=function(n,t,e,i,r,o){return{type:e,index:i,insertBeforeIndex:null,injectorIndex:t?t.injectorIndex:-1,directiveStart:-1,directiveEnd:-1,directiveStylingLast:-1,componentOffset:-1,propertyBindings:null,flags:0,providerIndexes:0,value:r,attrs:o,mergedAttrs:null,localNames:null,initialInputs:void 0,inputs:null,outputs:null,tView:null,next:null,prev:null,projectionNext:null,child:null,parent:t,projection:null,styles:null,stylesWithoutHost:null,residualStyles:void 0,classes:null,classesWithoutHost:null,residualClasses:void 0,classBindings:0,styleBindings:0}}(0,a?o:o&&o.parent,e,t,i,r);return null===n.firstChild&&(n.firstChild=l),null!==o&&(a?null==o.child&&null!==l.parent&&(o.child=l):null===o.next&&(o.next=l,l.prev=o)),l}function fb(n,t,e,i){if(0===e)return-1;let r=t.length;for(let o=0;o<e;o++)t.push(i),n.blueprint.push(i),n.data.push(null);return r}function bk(n,t,e){KP(t);try{let i=n.viewQuery;null!==i&&hP(1,i,e);let r=n.template;null!==r&&Lz(n,t,r,1,e),n.firstCreatePass&&(n.firstCreatePass=!1),n.staticContentQueries&&Nz(n,t),n.staticViewQueries&&hP(2,n.viewQuery,e);let o=n.components;null!==o&&function(n,t){for(let e=0;e<t.length;e++)Yse(n,t[e])}(t,o)}catch(i){throw n.firstCreatePass&&(n.incompleteFirstPass=!0,n.firstCreatePass=!1),i}finally{t[di]&=-5,JP()}}function VM(n,t,e,i){let r=t[di];if(128!=(128&r)){KP(t);try{v5(t),C5(n.bindingStartIndex),null!==e&&Lz(n,t,e,2,i);let a=3==(3&r);if(a){let c=n.preOrderCheckHooks;null!==c&&GC(t,c,null)}else{let c=n.preOrderHooks;null!==c&&WC(t,c,0,null),uR(t,0)}if(function(n){for(let t=ok(n);null!==t;t=ak(t)){if(!t[p5])continue;let e=t[Km];for(let i=0;i<e.length;i++){let r=e[i];0==(512&r[di])&&qP(r[jr],1),r[di]|=512}}}(t),function(n){for(let t=ok(n);null!==t;t=ak(t))for(let e=Ia;e<t.length;e++){let i=t[e],r=i[Fn];oM(i)&&VM(r,i,r.template,i[Ra])}}(t),null!==n.contentQueries&&Nz(n,t),a){let c=n.contentCheckHooks;null!==c&&GC(t,c)}else{let c=n.contentHooks;null!==c&&WC(t,c,1),uR(t,1)}!function(n,t){let e=n.hostBindingOpCodes;if(null!==e)try{for(let i=0;i<e.length;i++){let r=e[i];if(r<0)Wp(~r);else{let o=r,a=e[++i],s=e[++i];soe(a,o),s(2,t[o])}}}finally{Wp(-1)}}(n,t);let s=n.components;null!==s&&function(n,t){for(let e=0;e<t.length;e++)Xse(n,t[e])}(t,s);let l=n.viewQuery;if(null!==l&&hP(2,l,i),a){let c=n.viewCheckHooks;null!==c&&GC(t,c)}else{let c=n.viewHooks;null!==c&&WC(t,c,2),uR(t,2)}!0===n.firstUpdatePass&&(n.firstUpdatePass=!1),t[di]&=-41,512&t[di]&&(t[di]&=-513,qP(t[jr],-1))}finally{JP()}}}function Lz(n,t,e,i,r){let o=da(),a=2&i;try{Wp(-1),a&&t.length>Gr&&kz(n,t,Gr,!1),ks(a?2:0,r),e(i,r)}finally{Wp(o),ks(a?3:1,r)}}function vk(n,t,e){if(WP(t)){let r=t.directiveEnd;for(let o=t.directiveStart;o<r;o++){let a=n.data[o];a.contentQueries&&a.contentQueries(1,e[o],o)}}}function yk(n,t,e){!y5()||(function(n,t,e,i){let r=e.directiveStart,o=e.directiveEnd;DM(e)&&function(n,t,e){let i=ss(t,n),r=Bz(e),o=n[iM],a=HM(n,BM(n,r,null,e.onPush?32:16,i,t,o,o.createRenderer(i,e),null,null,null));n[t.index]=a}(t,e,n.data[r+e.componentOffset]),n.firstCreatePass||cM(e,t),sc(i,t);let a=e.initialInputs;for(let s=r;s<o;s++){let l=n.data[s],c=Xp(t,n,s,e);sc(c,t),null!==a&&jse(0,s-r,c,l,0,a),Cl(l)&&(ed(e.index,t)[Ra]=Xp(t,n,s,e))}}(n,t,e,ss(e,t)),64==(64&e.flags)&&zz(n,t,e))}function xk(n,t,e=ss){let i=t.localNames;if(null!==i){let r=t.index+1;for(let o=0;o<i.length;o+=2){let a=i[o+1],s=-1===a?e(t,n):n[a];n[r++]=s}}}function Bz(n){let t=n.tView;return null===t||t.incompleteFirstPass?n.tView=Ck(1,null,n.template,n.decls,n.vars,n.directiveDefs,n.pipeDefs,n.viewQuery,n.schemas,n.consts):t}function Ck(n,t,e,i,r,o,a,s,l,c){let d=Gr+i,u=d+r,p=function(n,t){let e=[];for(let i=0;i<t;i++)e.push(i<n?null:zn);return e}(d,u),h="function"==typeof c?c():c;return p[Fn]={type:n,blueprint:p,template:e,queries:null,viewQuery:s,declTNode:t,data:p.slice().fill(null,d),bindingStartIndex:d,expandoStartIndex:u,hostBindingOpCodes:null,firstCreatePass:!0,firstUpdatePass:!0,staticViewQueries:!1,staticContentQueries:!1,preOrderHooks:null,preOrderCheckHooks:null,contentHooks:null,contentCheckHooks:null,viewHooks:null,viewCheckHooks:null,destroyHooks:null,cleanup:null,contentQueries:null,components:null,directiveRegistry:"function"==typeof o?o():o,pipeRegistry:"function"==typeof a?a():a,firstChild:null,schemas:l,consts:h,incompleteFirstPass:!1}}function Vz(n,t,e,i){let r=Gz(t);null===e?r.push(i):(r.push(e),n.firstCreatePass&&Wz(n).push(i,r.length-1))}function AH(n,t,e,i){for(let r in n)if(n.hasOwnProperty(r)){e=null===e?{}:e;let o=n[r];null===i?RH(e,t,r,o):i.hasOwnProperty(r)&&RH(e,t,i[r],o)}return e}function RH(n,t,e,i){n.hasOwnProperty(e)?n[e].push(t,i):n[e]=[t,i]}function ds(n,t,e,i,r,o,a,s){let d,l=ss(t,e),c=t.inputs;!s&&null!=c&&(d=c[i])?(Ek(n,e,d,i,r),DM(t)&&function(n,t){let e=ed(t,n);16&e[di]||(e[di]|=32)}(e,t.index)):3&t.type&&(i=function(n){return"class"===n?"className":"for"===n?"htmlFor":"formaction"===n?"formAction":"innerHtml"===n?"innerHTML":"readonly"===n?"readOnly":"tabindex"===n?"tabIndex":n}(i),r=null!=a?a(r,t.value||"",i):r,o.setProperty(l,i,r))}function Mk(n,t,e,i){if(y5()){let a,s,r=null===i?null:{"":-1},o=function(n,t){let e=n.directiveRegistry,i=null,r=null;if(e)for(let o=0;o<e.length;o++){let a=e[o];if(Pz(t,a.selectors,!1))if(i||(i=[]),Cl(a))if(null!==a.findHostDirectiveDefs){let s=[];r=r||new Map,a.findHostDirectiveDefs(a,s,r),i.unshift(...s,a),uP(n,t,s.length)}else i.unshift(a),uP(n,t,0);else r=r||new Map,a.findHostDirectiveDefs?.(a,i,r),i.push(a)}return null===i?null:[i,r]}(n,e);null===o?a=s=null:[a,s]=o,null!==a&&Hz(n,t,e,a,r,s),r&&function(n,t,e){if(t){let i=n.localNames=[];for(let r=0;r<t.length;r+=2){let o=e[t[r+1]];if(null==o)throw new xt(-301,!1);i.push(t[r],o)}}}(e,i,r)}e.mergedAttrs=K_(e.mergedAttrs,e.attrs)}function Hz(n,t,e,i,r,o){for(let c=0;c<i.length;c++)zR(cM(e,t),n,i[c].type);!function(n,t,e){n.flags|=1,n.directiveStart=t,n.directiveEnd=t+e,n.providerIndexes=t}(e,n.data.length,i.length);for(let c=0;c<i.length;c++){let d=i[c];d.providersResolver&&d.providersResolver(d)}let a=!1,s=!1,l=fb(n,t,i.length,null);for(let c=0;c<i.length;c++){let d=i[c];e.mergedAttrs=K_(e.mergedAttrs,d.hostAttrs),zse(n,e,t,l,d),Vse(l,d,r),null!==d.contentQueries&&(e.flags|=4),(null!==d.hostBindings||null!==d.hostAttrs||0!==d.hostVars)&&(e.flags|=64);let u=d.type.prototype;!a&&(u.ngOnChanges||u.ngOnInit||u.ngDoCheck)&&((n.preOrderHooks??(n.preOrderHooks=[])).push(e.index),a=!0),!s&&(u.ngOnChanges||u.ngDoCheck)&&((n.preOrderCheckHooks??(n.preOrderCheckHooks=[])).push(e.index),s=!0),l++}!function(n,t,e){let r=t.directiveEnd,o=n.data,a=t.attrs,s=[],l=null,c=null;for(let d=t.directiveStart;d<r;d++){let u=o[d],p=e?e.get(u):null,m=p?p.outputs:null;l=AH(u.inputs,d,l,p?p.inputs:null),c=AH(u.outputs,d,c,m);let _=null===l||null===a||Rz(t)?null:Gse(l,d,a);s.push(_)}null!==l&&(l.hasOwnProperty("class")&&(t.flags|=8),l.hasOwnProperty("style")&&(t.flags|=16)),t.initialInputs=s,t.inputs=l,t.outputs=c}(n,e,o)}function zz(n,t,e){let i=e.directiveStart,r=e.directiveEnd,o=e.index,a=Gn.lFrame.currentDirectiveIndex;try{Wp(o);for(let s=i;s<r;s++){let l=n.data[s],c=t[s];BR(s),(null!==l.hostBindings||0!==l.hostVars||null!==l.hostAttrs)&&Nse(l,c)}}finally{Wp(-1),BR(a)}}function Nse(n,t){null!==n.hostBindings&&n.hostBindings(1,t)}function uP(n,t,e){t.componentOffset=e,(n.components??(n.components=[])).push(t.index)}function Vse(n,t,e){if(e){if(t.exportAs)for(let i=0;i<t.exportAs.length;i++)e[t.exportAs[i]]=n;Cl(t)&&(e[""]=n)}}function zse(n,t,e,i,r){n.data[i]=r;let o=r.factory||(r.factory=Gp(r.type)),a=new qp(o,Cl(r),C);n.blueprint[i]=a,e[i]=a,function(n,t,e,i,r){let o=r.hostBindings;if(o){let a=n.hostBindingOpCodes;null===a&&(a=n.hostBindingOpCodes=[]);let s=~t.index;(function(n){let t=n.length;for(;t>0;){let e=n[--t];if("number"==typeof e&&e<0)return e}return 0})(a)!=s&&a.push(s),a.push(e,i,o)}}(n,t,i,fb(n,e,r.hostVars,zn),r)}function uc(n,t,e,i,r,o){let a=ss(n,t);wk(t[ui],a,o,n.value,e,i,r)}function wk(n,t,e,i,r,o,a){if(null==o)n.removeAttribute(t,r,e);else{let s=null==a?jn(o):a(o,i||"",r);n.setAttribute(t,r,s,e)}}function jse(n,t,e,i,r,o){let a=o[t];if(null!==a){let s=i.setInput;for(let l=0;l<a.length;){let c=a[l++],d=a[l++],u=a[l++];null!==s?i.setInput(e,u,c,d):e[d]=u}}}function Gse(n,t,e){let i=null,r=0;for(;r<e.length;){let o=e[r];if(0!==o)if(5!==o){if("number"==typeof o)break;if(n.hasOwnProperty(o)){null===i&&(i=[]);let a=n[o];for(let s=0;s<a.length;s+=2)if(a[s]===t){i.push(o,a[s+1],e[r+1]);break}}r+=2}else r+=2;else r+=4}return i}function Uz(n,t,e,i){return[n,!0,!1,t,null,0,i,e,null,null]}function Xse(n,t){let e=ed(t,n);if(oM(e)){let i=e[Fn];48&e[di]?VM(i,e,i.template,e[Ra]):e[zp]>0&&pP(e)}}function pP(n){for(let i=ok(n);null!==i;i=ak(i))for(let r=Ia;r<i.length;r++){let o=i[r];if(oM(o))if(512&o[di]){let a=o[Fn];VM(a,o,a.template,o[Ra])}else o[zp]>0&&pP(o)}let e=n[Fn].components;if(null!==e)for(let i=0;i<e.length;i++){let r=ed(e[i],n);oM(r)&&r[zp]>0&&pP(r)}}function Yse(n,t){let e=ed(t,n),i=e[Fn];(function(n,t){for(let e=t.length;e<n.blueprint.length;e++)t.push(n.blueprint[e])})(i,e),bk(i,e,e[Ra])}function HM(n,t){return n[Q_]?n[uH][yl]=t:n[Q_]=t,n[uH]=t,t}function Sk(n){for(;n;){n[di]|=32;let t=rk(n);if(Xre(n)&&!t)return n;n=t}return null}function jz(n,t,e,i=!0){let r=t[iM];r.begin&&r.begin();try{VM(n,t,n.template,e)}catch(a){throw i&&Xz(t,a),a}finally{r.end&&r.end()}}function hP(n,t,e){ZP(0),t(n,e)}function Gz(n){return n[Y_]||(n[Y_]=[])}function Wz(n){return n.cleanup||(n.cleanup=[])}function qz(n,t,e){return(null===n||Cl(n))&&(e=function(n){for(;Array.isArray(n);){if("object"==typeof n[jP])return n;n=n[ou]}return null}(e[t.index])),e[ui]}function Xz(n,t){let e=n[nM],i=e?e.get(la,null):null;i&&i.handleError(t)}function Ek(n,t,e,i,r){for(let o=0;o<e.length;){let a=e[o++],s=e[o++],l=t[a],c=n.data[a];null!==c.setInput?c.setInput(l,r,i,s):l[s]=r}}function od(n,t,e){let i=AM(t,n);Q5(n[ui],i,e)}function mM(n,t,e){let i=e?n.styles:null,r=e?n.classes:null,o=0;if(null!==t)for(let a=0;a<t.length;a++){let s=t[a];"number"==typeof s?o=s:1==o?r=RR(r,s):2==o&&(i=RR(i,s+": "+t[++a]+";"))}e?n.styles=i:n.stylesWithoutHost=i,e?n.classes=r:n.classesWithoutHost=r}function ZC(n,t,e,i,r=!1){for(;null!==e;){let o=t[e.index];if(null!==o&&i.push(Ls(o)),$c(o))for(let s=Ia;s<o.length;s++){let l=o[s],c=l[Fn].firstChild;null!==c&&ZC(l[Fn],l,c,i)}let a=e.type;if(8&a)ZC(n,t,e.child,i);else if(32&a){let l,s=ik(e,t);for(;l=s();)i.push(l)}else if(16&a){let s=oz(t,e);if(Array.isArray(s))i.push(...s);else{let l=rk(t[xl]);ZC(l[Fn],l,s,i,!0)}}e=r?e.projectionNext:e.next}return i}var Qp=class{get rootNodes(){let t=this._lView,e=t[Fn];return ZC(e,t,e.firstChild,[])}constructor(t,e){this._lView=t,this._cdRefInjectingView=e,this._appRef=null,this._attachedToViewContainer=!1}get context(){return this._lView[Ra]}set context(t){this._lView[Ra]=t}get destroyed(){return 128==(128&this._lView[di])}destroy(){if(this._appRef)this._appRef.detachView(this);else if(this._attachedToViewContainer){let t=this._lView[jr];if($c(t)){let e=t[rM],i=e?e.indexOf(this):-1;i>-1&&(WR(t,i),dM(e,i))}this._attachedToViewContainer=!1}K5(this._lView[Fn],this._lView)}onDestroy(t){Vz(this._lView[Fn],this._lView,null,t)}markForCheck(){Sk(this._cdRefInjectingView||this._lView)}detach(){this._lView[di]&=-65}reattach(){this._lView[di]|=64}detectChanges(){jz(this._lView[Fn],this._lView,this.context)}checkNoChanges(){}attachToViewContainerRef(){if(this._appRef)throw new xt(902,!1);this._attachedToViewContainer=!0}detachFromAppRef(){var t;this._appRef=null,ub(this._lView[Fn],t=this._lView,t[ui],2,null,null)}attachToAppRef(t){if(this._attachedToViewContainer)throw new xt(902,!1);this._appRef=t}},mP=class extends Qp{constructor(t){super(t),this._view=t}detectChanges(){let t=this._view;jz(t[Fn],t,t[Ra],!1)}checkNoChanges(){}get context(){return null}},fM=class extends ho{constructor(t){super(),this.ngModule=t}resolveComponentFactory(t){let e=Os(t);return new gM(e,this.ngModule)}};function PH(n){let t=[];for(let e in n)n.hasOwnProperty(e)&&t.push({propName:n[e],templateName:e});return t}var gM=class extends hM{get inputs(){return PH(this.componentDef.inputs)}get outputs(){return PH(this.componentDef.outputs)}constructor(t,e){super(),this.componentDef=t,this.ngModule=e,this.componentType=t.type,this.selector=t.selectors.map(gse).join(","),this.ngContentSelectors=t.ngContentSelectors?t.ngContentSelectors:[],this.isBoundToModule=!!e}create(t,e,i,r){let o=(r=r||this.ngModule)instanceof lc?r:r?.injector;o&&null!==this.componentDef.getStandaloneInjector&&(o=this.componentDef.getStandaloneInjector(o)||o);let a=o?new class{constructor(t,e){this.injector=t,this.parentInjector=e}get(t,e,i){i=SM(i);let r=this.injector.get(t,_R,i);return r!==_R||e===_R?r:this.parentInjector.get(t,e,i)}}(t,o):t,s=a.get(cc,null);if(null===s)throw new xt(407,!1);let _,M,l=a.get(ise,null),c=s.createRenderer(null,this.componentDef),d=this.componentDef.selectors[0][0]||"div",u=i?function(n,t,e){return n.selectRootElement(t,e===as.ShadowDom)}(c,i,this.componentDef.encapsulation):lk(c,d,function(n){let t=n.toLowerCase();return"svg"===t?g5:"math"===t?_5:null}(d)),p=this.componentDef.onPush?288:272,h=Ck(0,null,null,1,0,null,null,null,null,null),m=BM(null,h,null,p,null,null,s,c,l,a,null);KP(m);try{let x,y=this.componentDef,R=null;y.findHostDirectiveDefs?(x=[],R=new Map,y.findHostDirectiveDefs(y,x,R),x.push(y)):x=[y];let I=function(n,t){let e=n[Fn],i=Gr;return n[i]=t,pf(e,i,2,"#host",null)}(m,u),B=function(n,t,e,i,r,o,a,s){let l=r[Fn];!function(n,t,e,i){for(let r of n)t.mergedAttrs=K_(t.mergedAttrs,r.hostAttrs);null!==t.mergedAttrs&&(mM(t,t.mergedAttrs,!0),null!==e&&lz(i,e,t))}(i,n,t,a);let c=o.createRenderer(t,e),d=BM(r,Bz(e),null,e.onPush?32:16,r[n.index],n,o,c,null,null,null);return l.firstCreatePass&&uP(l,n,i.length-1),HM(r,d),r[n.index]=d}(I,u,y,x,m,s,c);M=b5(h,Gr),u&&function(n,t,e,i){if(i)VR(n,e,["ng-version",rse.full]);else{let{attrs:r,classes:o}=function(n){let t=[],e=[],i=1,r=2;for(;i<n.length;){let o=n[i];if("string"==typeof o)2===r?""!==o&&t.push(o,n[++i]):8===r&&e.push(o);else{if(!bl(r))break;r=o}i++}return{attrs:t,classes:e}}(t.selectors[0]);r&&VR(n,e,r),o&&o.length>0&&sz(n,e,o.join(" "))}}(c,y,u,i),void 0!==e&&function(n,t,e){let i=n.projection=[];for(let r=0;r<t.length;r++){let o=e[r];i.push(null!=o?Array.from(o):null)}}(M,this.ngContentSelectors,e),_=function(n,t,e,i,r,o){let a=Lo(),s=r[Fn],l=ss(a,r);Hz(s,r,a,e,null,i);for(let d=0;d<e.length;d++)sc(Xp(r,s,a.directiveStart+d,a),r);zz(s,r,a),l&&sc(l,r);let c=Xp(r,s,a.directiveStart+a.componentOffset,a);if(n[Ra]=r[Ra]=c,null!==o)for(let d of o)d(c,t);return vk(s,a,n),c}(B,y,x,R,m,[ile]),bk(h,m,null)}finally{JP()}return new gP(this.componentType,_,uf(M,m),m,M)}},gP=class extends lP{constructor(t,e,i,r,o){super(),this.location=i,this._rootLView=r,this._tNode=o,this.instance=e,this.hostView=this.changeDetectorRef=new mP(r),this.componentType=t}setInput(t,e){let r,i=this._tNode.inputs;if(null!==i&&(r=i[t])){let o=this._rootLView;Ek(o[Fn],o,r,t,e),Sk(ed(this._tNode.index,o))}}get injector(){return new jp(this._tNode,this._rootLView)}destroy(){this.hostView.destroy()}onDestroy(t){this.hostView.onDestroy(t)}};function ile(){let n=Lo();RM(Ze()[Fn],n)}function Yz(n){return Object.getPrototypeOf(n.prototype).constructor}function Xe(n){let t=Yz(n.type),e=!0,i=[n];for(;t;){let r;if(Cl(n))r=t.\u0275cmp||t.\u0275dir;else{if(t.\u0275cmp)throw new xt(903,!1);r=t.\u0275dir}if(r){if(e){i.push(r);let a=n;a.inputs=vR(n.inputs),a.declaredInputs=vR(n.declaredInputs),a.outputs=vR(n.outputs);let s=r.hostBindings;s&&sle(n,s);let l=r.viewQuery,c=r.contentQueries;if(l&&ole(n,l),c&&ale(n,c),dR(n.inputs,r.inputs),dR(n.declaredInputs,r.declaredInputs),dR(n.outputs,r.outputs),Cl(r)&&r.data.animation){let d=n.data;d.animation=(d.animation||[]).concat(r.data.animation)}}let o=r.features;if(o)for(let a=0;a<o.length;a++){let s=o[a];s&&s.ngInherit&&s(n),s===Xe&&(e=!1)}}t=Object.getPrototypeOf(t)}!function(n){let t=0,e=null;for(let i=n.length-1;i>=0;i--){let r=n[i];r.hostVars=t+=r.hostVars,r.hostAttrs=K_(r.hostAttrs,e=K_(e,r.hostAttrs))}}(i)}function vR(n){return n===Zc?{}:n===ji?[]:n}function ole(n,t){let e=n.viewQuery;n.viewQuery=e?(i,r)=>{t(i,r),e(i,r)}:t}function ale(n,t){let e=n.contentQueries;n.contentQueries=e?(i,r,o)=>{t(i,r,o),e(i,r,o)}:t}function sle(n,t){let e=n.hostBindings;n.hostBindings=e?(i,r)=>{t(i,r),e(i,r)}:t}var lle=["providersResolver"],cle=["template","decls","consts","vars","onPush","ngContentSelectors","styles","encapsulation","schemas"];function Qz(n,t,e){if(null!==n.hostDirectives)for(let i of n.hostDirectives){let r=eu(i.directive);ple(r.declaredInputs,i.inputs),Qz(r,t,e),e.set(r,i),t.push(r)}}function kH(n){if(void 0===n||0===n.length)return Zc;let t={};for(let e=0;e<n.length;e+=2)t[n[e]]=n[e+1];return t}function ple(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[t[e]]=n[e])}function Zz(n){return!!Tk(n)&&(Array.isArray(n)||!(n instanceof Map)&&Symbol.iterator in n)}function Tk(n){return null!==n&&("function"==typeof n||"object"==typeof n)}function pc(n,t,e){return n[t]=e}function gb(n,t){return n[t]}function qo(n,t,e){return!Object.is(n[t],e)&&(n[t]=e,!0)}function Zp(n,t,e,i){let r=qo(n,t,e);return qo(n,t+1,i)||r}function zM(n,t,e,i,r){let o=Zp(n,t,e,i);return qo(n,t+2,r)||o}function Bs(n,t,e,i,r,o){let a=Zp(n,t,e,i);return Zp(n,t+2,r,o)||a}function Be(n,t,e,i){let r=Ze();return qo(r,sf(),t)&&(Ti(),uc(Pr(),r,n,t,e,i)),Be}function hf(n,t){let e=!1,i=td();for(let o=1;o<t.length;o+=2)e=qo(n,i++,t[o])||e;if(C5(i),!e)return zn;let r=t[0];for(let o=1;o<t.length;o+=2)r+=jn(t[o])+t[o+1];return r}function mf(n,t,e,i){return qo(n,sf(),e)?t+jn(e)+i:zn}function ff(n,t,e,i,r,o){let s=Zp(n,td(),e,r);return nd(2),s?t+jn(e)+i+jn(r)+o:zn}function gf(n,t,e,i,r,o,a,s){let c=zM(n,td(),e,r,a);return nd(3),c?t+jn(e)+i+jn(r)+o+jn(a)+s:zn}function _f(n,t,e,i,r,o,a,s,l,c){let u=Bs(n,td(),e,r,a,l);return nd(4),u?t+jn(e)+i+jn(r)+o+jn(a)+s+jn(l)+c:zn}function bf(n,t,e,i,r,o,a,s,l,c,d,u){let p=td(),h=Bs(n,p,e,r,a,l);return h=qo(n,p+4,d)||h,nd(5),h?t+jn(e)+i+jn(r)+o+jn(a)+s+jn(l)+c+jn(d)+u:zn}function vf(n,t,e,i,r,o,a,s,l,c,d,u,p,h){let m=td(),_=Bs(n,m,e,r,a,l);return _=Zp(n,m+4,d,p)||_,nd(6),_?t+jn(e)+i+jn(r)+o+jn(a)+s+jn(l)+c+jn(d)+u+jn(p)+h:zn}function yf(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_){let M=td(),y=Bs(n,M,e,r,a,l);return y=zM(n,M+4,d,p,m)||y,nd(7),y?t+jn(e)+i+jn(r)+o+jn(a)+s+jn(l)+c+jn(d)+u+jn(p)+h+jn(m)+_:zn}function xf(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y){let x=td(),R=Bs(n,x,e,r,a,l);return R=Bs(n,x+4,d,p,m,M)||R,nd(8),R?t+jn(e)+i+jn(r)+o+jn(a)+s+jn(l)+c+jn(d)+u+jn(p)+h+jn(m)+_+jn(M)+y:zn}function S(n,t,e,i,r,o,a,s){let l=Ze(),c=Ti(),d=n+Gr,u=c.firstCreatePass?function(n,t,e,i,r,o,a,s,l){let c=t.consts,d=pf(t,n,4,a||null,nu(c,s));Mk(t,e,d,nu(c,l)),RM(t,d);let u=d.tView=Ck(2,d,i,r,o,t.directiveRegistry,t.pipeRegistry,null,t.schemas,c);return null!==t.queries&&(t.queries.template(t,d),u.queries=t.queries.embeddedTView(d)),d}(d,c,l,t,e,i,r,o,a):c.data[d];ac(u,!1);let p=l[ui].createComment("");OM(c,l,p,u),sc(p,l),HM(l,l[d]=Uz(p,l,p,u)),IM(u)&&yk(c,l,u),null!=a&&xk(l,u,s)}function st(n){return af(Gn.lFrame.contextLView,Gr+n)}function b(n,t,e){let i=Ze();return qo(i,sf(),t)&&ds(Ti(),Pr(),i,n,t,i[ui],e,!1),b}function _P(n,t,e,i,r){let a=r?"class":"style";Ek(n,e,t.inputs[a],a,i)}function f(n,t,e,i){let r=Ze(),o=Ti(),a=Gr+n,s=r[ui],l=o.firstCreatePass?function(n,t,e,i,r,o){let a=t.consts,l=pf(t,n,2,i,nu(a,r));return Mk(t,e,l,nu(a,o)),null!==l.attrs&&mM(l,l.attrs,!1),null!==l.mergedAttrs&&mM(l,l.mergedAttrs,!0),null!==t.queries&&t.queries.elementStart(t,l),l}(a,o,r,t,e,i):o.data[a],c=r[a]=lk(s,t,Gn.lFrame.currentNamespace),d=IM(l);return ac(l,!0),lz(s,c,l),32!=(32&l.flags)&&OM(o,r,c,l),0===Gn.lFrame.elementDepthCount&&sc(c,r),Gn.lFrame.elementDepthCount++,d&&(yk(o,r,l),vk(o,l,r)),null!==i&&xk(r,l),f}function g(){let n=Lo();XP()?YP():(n=n.parent,ac(n,!1));let t=n;Gn.lFrame.elementDepthCount--;let e=Ti();return e.firstCreatePass&&(RM(e,n),WP(n)&&e.queries.elementEnd(n)),null!=t.classesWithoutHost&&function(n){return 0!=(8&n.flags)}(t)&&_P(e,t,Ze(),t.classesWithoutHost,!0),null!=t.stylesWithoutHost&&function(n){return 0!=(16&n.flags)}(t)&&_P(e,t,Ze(),t.stylesWithoutHost,!1),g}function k(n,t,e,i){return f(n,t,e,i),g(),k}function Gt(n,t,e){let i=Ze(),r=Ti(),o=n+Gr,a=r.firstCreatePass?function(n,t,e,i,r){let o=t.consts,a=nu(o,i),s=pf(t,n,8,"ng-container",a);return null!==a&&mM(s,a,!0),Mk(t,e,s,nu(o,r)),null!==t.queries&&t.queries.elementStart(t,s),s}(o,r,i,t,e):r.data[o];ac(a,!0);let s=i[o]=i[ui].createComment("");return OM(r,i,s,a),sc(s,i),IM(a)&&(yk(r,i,a),vk(r,a,i)),null!=e&&xk(i,a),Gt}function Wt(){let n=Lo(),t=Ti();return XP()?YP():(n=n.parent,ac(n,!1)),t.firstCreatePass&&(RM(t,n),WP(n)&&t.queries.elementEnd(n)),Wt}function hi(n,t,e){return Gt(n,t,e),Wt(),hi}function Te(){return Ze()}function Cf(n){return!!n&&"function"==typeof n.then}function Dk(n){return!!n&&"function"==typeof n.subscribe}var Ik=Dk;function A(n,t,e,i){let r=Ze(),o=Ti(),a=Lo();return aU(o,r,r[ui],a,n,t,i),A}function UM(n,t){let e=Lo(),i=Ze(),r=Ti();return aU(r,i,qz(QP(r.data),e,i),e,n,t),UM}function aU(n,t,e,i,r,o,a){let s=IM(i),c=n.firstCreatePass&&Wz(n),d=t[Ra],u=Gz(t),p=!0;if(3&i.type||a){let _=ss(i,t),M=a?a(_):_,y=u.length,x=a?I=>a(Ls(I[i.index])):i.index,R=null;if(!a&&s&&(R=function(n,t,e,i){let r=n.cleanup;if(null!=r)for(let o=0;o<r.length-1;o+=2){let a=r[o];if(a===e&&r[o+1]===i){let s=t[Y_],l=r[o+2];return s.length>l?s[l]:null}"string"==typeof a&&(o+=2)}return null}(n,t,r,i.index)),null!==R)(R.__ngLastListenerFn__||R).__ngNextListenerFn__=o,R.__ngLastListenerFn__=o,p=!1;else{o=FH(i,t,d,o,!1);let I=e.listen(M,r,o);u.push(o,I),c&&c.push(r,x,y,y+1)}}else o=FH(i,t,d,o,!1);let m,h=i.outputs;if(p&&null!==h&&(m=h[r])){let _=m.length;if(_)for(let M=0;M<_;M+=2){let B=t[m[M]][m[M+1]].subscribe(o),ee=u.length;u.push(o,B),c&&c.push(r,i.index,ee,-(ee+1))}}}function OH(n,t,e,i){try{return ks(6,t,e),!1!==e(i)}catch(r){return Xz(n,r),!1}finally{ks(7,t,e)}}function FH(n,t,e,i,r){return function o(a){if(a===Function)return i;Sk(n.componentOffset>-1?ed(n.index,t):t);let l=OH(t,e,i,a),c=o.__ngNextListenerFn__;for(;c;)l=OH(t,e,c,a)&&l,c=c.__ngNextListenerFn__;return r&&!1===l&&(a.preventDefault(),a.returnValue=!1),l}}function w(n=1){return function(n){return(Gn.lFrame.contextLView=function(n,t){for(;n>0;)t=t[of],n--;return t}(n,Gn.lFrame.contextLView))[Ra]}(n)}function vle(n,t){let e=null,i=function(n){let t=n.attrs;if(null!=t){let e=t.indexOf(5);if(0==(1&e))return t[e+1]}return null}(n);for(let r=0;r<t.length;r++){let o=t[r];if("*"!==o){if(null===i?Pz(n,o,!0):fse(i,o))return r}else e=r}return e}function fn(n){let t=Ze()[xl][Aa];if(!t.projection){let i=t.projection=H_(n?n.length:1,null),r=i.slice(),o=t.child;for(;null!==o;){let a=n?vle(o,n):0;null!==a&&(r[a]?r[a].projectionNext=o:i[a]=o,r[a]=o),o=o.next}}}function Tt(n,t=0,e){let i=Ze(),r=Ti(),o=pf(r,Gr+n,16,null,e||null);null===o.projection&&(o.projection=t),YP(),32!=(32&o.flags)&&function(n,t,e){az(t[ui],0,t,e,J5(n,e,t),tz(e.parent||t[Aa],e,t))}(r,i,o)}function Zi(n,t,e){return _b(n,"",t,"",e),Zi}function _b(n,t,e,i,r){let o=Ze(),a=mf(o,t,e,i);return a!==zn&&ds(Ti(),Pr(),o,n,a,o[ui],r,!1),_b}function jM(n,t,e,i,r,o,a){let s=Ze(),l=ff(s,t,e,i,r,o);return l!==zn&&ds(Ti(),Pr(),s,n,l,s[ui],a,!1),jM}function jC(n,t){return n<<17|t<<2}function Kp(n){return n>>17&32767}function bP(n){return 2|n}function ef(n){return(131068&n)>>2}function yR(n,t){return-131069&n|t<<2}function vP(n){return 1|n}function NH(n,t,e,i,r){let o=n[e+1],a=null===t,s=i?Kp(o):ef(o),l=!1;for(;0!==s&&(!1===l||a);){let d=n[s+1];Sle(n[s],t)&&(l=!0,n[s+1]=i?vP(d):bP(d)),s=i?Kp(d):ef(d)}l&&(n[e+1]=i?bP(o):vP(o))}function Sle(n,t){return null===n||null==t||(Array.isArray(n)?n[1]:n)===t||!(!Array.isArray(n)||"string"!=typeof t)&&db(n,t)>=0}var uo={textEnd:0,key:0,keyEnd:0,value:0,valueEnd:0};function mU(n){return n.substring(uo.key,uo.keyEnd)}function Ele(n){return n.substring(uo.value,uo.valueEnd)}function fU(n,t){let e=uo.textEnd;return e===t?-1:(t=uo.keyEnd=function(n,t,e){for(;t<e&&n.charCodeAt(t)>32;)t++;return t}(n,uo.key=t,e),tf(n,t,e))}function gU(n,t){let e=uo.textEnd,i=uo.key=tf(n,t,e);return e===i?-1:(i=uo.keyEnd=function(n,t,e){let i;for(;t<e&&(45===(i=n.charCodeAt(t))||95===i||(-33&i)>=65&&(-33&i)<=90||i>=48&&i<=57);)t++;return t}(n,i,e),i=LH(n,i,e),i=uo.value=tf(n,i,e),i=uo.valueEnd=function(n,t,e){let i=-1,r=-1,o=-1,a=t,s=a;for(;a<e;){let l=n.charCodeAt(a++);if(59===l)return s;34===l||39===l?s=a=BH(n,l,a,e):t===a-4&&85===o&&82===r&&76===i&&40===l?s=a=BH(n,41,a,e):l>32&&(s=a),o=r,r=i,i=-33&l}return s}(n,i,e),LH(n,i,e))}function _U(n){uo.key=0,uo.keyEnd=0,uo.value=0,uo.valueEnd=0,uo.textEnd=n.length}function tf(n,t,e){for(;t<e&&n.charCodeAt(t)<=32;)t++;return t}function LH(n,t,e,i){return(t=tf(n,t,e))<e&&t++,t}function BH(n,t,e,i){let r=-1,o=e;for(;o<i;){let a=n.charCodeAt(o++);if(a==t&&92!==r)return o;r=92==a&&92===r?0:a}throw new Error}function Bt(n,t,e){return Sl(n,t,e,!1),Bt}function nt(n,t){return Sl(n,t,null,!0),nt}function Hs(n){El(yU,Ple,n,!1)}function Ple(n,t){for(let e=function(n){return _U(n),gU(n,tf(n,0,uo.textEnd))}(t);e>=0;e=gU(t,e))yU(n,mU(t),Ele(t))}function Xo(n){El(Ble,hc,n,!0)}function hc(n,t){for(let e=function(n){return _U(n),fU(n,tf(n,0,uo.textEnd))}(t);e>=0;e=fU(t,e))ls(n,mU(t),!0)}function Sl(n,t,e,i){let r=Ze(),o=Ti(),a=nd(2);o.firstUpdatePass&&vU(o,n,a,i),t!==zn&&qo(r,a,t)&&xU(o,o.data[da()],r,r[ui],n,r[a+1]=function(n,t){return null==n||""===n||("string"==typeof t?n+=t:"object"==typeof n&&(n=po(Oa(n)))),n}(t,e),i,a)}function El(n,t,e,i){let r=Ti(),o=nd(2);r.firstUpdatePass&&vU(r,null,o,i);let a=Ze();if(e!==zn&&qo(a,o,e)){let s=r.data[da()];if(CU(s,i)&&!bU(r,o)){let l=i?s.classesWithoutHost:s.stylesWithoutHost;null!==l&&(e=RR(l,e||"")),_P(r,s,a,e,i)}else!function(n,t,e,i,r,o,a,s){r===zn&&(r=ji);let l=0,c=0,d=0<r.length?r[0]:null,u=0<o.length?o[0]:null;for(;null!==d||null!==u;){let _,p=l<r.length?r[l+1]:void 0,h=c<o.length?o[c+1]:void 0,m=null;d===u?(l+=2,c+=2,p!==h&&(m=u,_=h)):null===u||null!==d&&d<u?(l+=2,m=d):(c+=2,m=u,_=h),null!==m&&xU(n,t,e,i,m,_,a,s),d=l<r.length?r[l]:null,u=c<o.length?o[c]:null}}(r,s,a,a[ui],a[o+1],a[o+1]=function(n,t,e){if(null==e||""===e)return ji;let i=[],r=Oa(e);if(Array.isArray(r))for(let o=0;o<r.length;o++)n(i,r[o],!0);else if("object"==typeof r)for(let o in r)r.hasOwnProperty(o)&&n(i,o,r[o]);else"string"==typeof r&&t(i,r);return i}(n,t,e),i,o)}}function bU(n,t){return t>=n.expandoStartIndex}function vU(n,t,e,i){let r=n.data;if(null===r[e+1]){let o=r[da()],a=bU(n,e);CU(o,i)&&null===t&&!a&&(t=!1),t=function(n,t,e,i){let r=QP(n),o=i?t.residualClasses:t.residualStyles;if(null===r)0===(i?t.classBindings:t.styleBindings)&&(e=$_(e=xR(null,n,t,e,i),t.attrs,i),o=null);else{let a=t.directiveStylingLast;if(-1===a||n[a]!==r)if(e=xR(r,n,t,e,i),null===o){let l=function(n,t,e){let i=e?t.classBindings:t.styleBindings;if(0!==ef(i))return n[Kp(i)]}(n,t,i);void 0!==l&&Array.isArray(l)&&(l=xR(null,n,t,l[1],i),l=$_(l,t.attrs,i),function(n,t,e,i){n[Kp(e?t.classBindings:t.styleBindings)]=i}(n,t,i,l))}else o=function(n,t,e){let i,r=t.directiveEnd;for(let o=1+t.directiveStylingLast;o<r;o++)i=$_(i,n[o].hostAttrs,e);return $_(i,t.attrs,e)}(n,t,i)}return void 0!==o&&(i?t.residualClasses=o:t.residualStyles=o),e}(r,o,t,i),function(n,t,e,i,r,o){let a=o?t.classBindings:t.styleBindings,s=Kp(a),l=ef(a);n[i]=e;let d,c=!1;if(Array.isArray(e)?(d=e[1],(null===d||db(e,d)>0)&&(c=!0)):d=e,r)if(0!==l){let p=Kp(n[s+1]);n[i+1]=jC(p,s),0!==p&&(n[p+1]=yR(n[p+1],i)),n[s+1]=function(n,t){return 131071&n|t<<17}(n[s+1],i)}else n[i+1]=jC(s,0),0!==s&&(n[s+1]=yR(n[s+1],i)),s=i;else n[i+1]=jC(l,0),0===s?s=i:n[l+1]=yR(n[l+1],i),l=i;c&&(n[i+1]=bP(n[i+1])),NH(n,d,i,!0),NH(n,d,i,!1),function(n,t,e,i,r){let o=r?n.residualClasses:n.residualStyles;null!=o&&"string"==typeof t&&db(o,t)>=0&&(e[i+1]=vP(e[i+1]))}(t,d,n,i,o),a=jC(s,l),o?t.classBindings=a:t.styleBindings=a}(r,o,t,e,a,i)}}function xR(n,t,e,i,r){let o=null,a=e.directiveEnd,s=e.directiveStylingLast;for(-1===s?s=e.directiveStart:s++;s<a&&(o=t[s],i=$_(i,o.hostAttrs,r),o!==n);)s++;return null!==n&&(e.directiveStylingLast=s),i}function $_(n,t,e){let i=e?1:2,r=-1;if(null!==t)for(let o=0;o<t.length;o++){let a=t[o];"number"==typeof a?r=a:r===i&&(Array.isArray(n)||(n=void 0===n?[]:["",n]),ls(n,a,!!e||t[++o]))}return void 0===n?null:n}function yU(n,t,e){ls(n,t,Oa(e))}function Ble(n,t,e){let i=String(t);""!==i&&!i.includes(" ")&&ls(n,i,e)}function xU(n,t,e,i,r,o,a,s){if(!(3&t.type))return;let l=n.data,c=l[s+1],d=function(n){return 1==(1&n)}(c)?VH(l,t,e,r,ef(c),a):void 0;_M(d)||(_M(o)||function(n){return 2==(2&n)}(c)&&(o=VH(l,null,e,r,s,a)),function(n,t,e,i,r){if(t)r?n.addClass(e,i):n.removeClass(e,i);else{let o=-1===i.indexOf("-")?void 0:Ns.DashCase;null==r?n.removeStyle(e,i,o):("string"==typeof r&&r.endsWith("!important")&&(r=r.slice(0,-10),o|=Ns.Important),n.setStyle(e,i,r,o))}}(i,a,AM(da(),e),r,o))}function VH(n,t,e,i,r,o){let s,a=null===t;for(;r>0;){let l=n[r],c=Array.isArray(l),d=c?l[1]:l,u=null===d,p=e[r+1];p===zn&&(p=u?ji:void 0);let h=u?hR(p,i):d===i?p:void 0;if(c&&!_M(h)&&(h=hR(l,i)),_M(h)&&(s=h,a))return s;let m=n[r+1];r=a?Kp(m):ef(m)}if(null!==t){let l=o?t.residualClasses:t.residualStyles;null!=l&&(s=hR(l,i))}return s}function _M(n){return void 0!==n}function CU(n,t){return 0!=(n.flags&(t?8:16))}function T(n,t=""){let e=Ze(),i=Ti(),r=n+Gr,o=i.firstCreatePass?pf(i,r,1,t,null):i.data[r],a=e[r]=sk(e[ui],t);OM(i,e,a,o),ac(o,!1)}function kt(n){return Ve("",n,""),kt}function Ve(n,t,e){let i=Ze(),r=mf(i,n,t,e);return r!==zn&&od(i,da(),r),Ve}function lu(n,t,e,i,r){let o=Ze(),a=ff(o,n,t,e,i,r);return a!==zn&&od(o,da(),a),lu}function GM(n,t,e,i,r,o,a){let s=Ze(),l=gf(s,n,t,e,i,r,o,a);return l!==zn&&od(s,da(),l),GM}function bb(n,t,e){El(ls,hc,mf(Ze(),n,t,e),!0)}function wo(n,t,e){let i=Ze();return qo(i,sf(),t)&&ds(Ti(),Pr(),i,n,t,i[ui],e,!0),wo}function WM(n,t,e){let i=Ze();if(qo(i,sf(),t)){let o=Ti(),a=Pr();ds(o,a,i,n,t,qz(QP(o.data),a,i),e,!0)}return WM}var Vp=void 0,oce=["en",[["a","p"],["AM","PM"],Vp],[["AM","PM"],Vp,Vp],[["S","M","T","W","T","F","S"],["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],["Su","Mo","Tu","We","Th","Fr","Sa"]],Vp,[["J","F","M","A","M","J","J","A","S","O","N","D"],["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],["January","February","March","April","May","June","July","August","September","October","November","December"]],Vp,[["B","A"],["BC","AD"],["Before Christ","Anno Domini"]],0,[6,0],["M/d/yy","MMM d, y","MMMM d, y","EEEE, MMMM d, y"],["h:mm a","h:mm:ss a","h:mm:ss a z","h:mm:ss a zzzz"],["{1}, {0}",Vp,"{1} 'at' {0}",Vp],[".",",",";","%","+","-","E","\xd7","\u2030","\u221e","NaN",":"],["#,##0.###","#,##0%","\xa4#,##0.00","#E0"],"USD","$","US Dollar",{},"ltr",function(n){let e=Math.floor(Math.abs(n)),i=n.toString().replace(/^[^.]*\.?/,"").length;return 1===e&&0===i?1:5}],CR={};function Fa(n){let t=function(n){return n.toLowerCase().replace(/_/g,"-")}(n),e=HH(t);if(e)return e;let i=t.split("-")[0];if(e=HH(i),e)return e;if("en"===i)return oce;throw new xt(701,!1)}function HH(n){return n in CR||(CR[n]=zr.ng&&zr.ng.common&&zr.ng.common.locales&&zr.ng.common.locales[n]),CR[n]}var hr=(()=>{return(n=hr||(hr={}))[n.LocaleId=0]="LocaleId",n[n.DayPeriodsFormat=1]="DayPeriodsFormat",n[n.DayPeriodsStandalone=2]="DayPeriodsStandalone",n[n.DaysFormat=3]="DaysFormat",n[n.DaysStandalone=4]="DaysStandalone",n[n.MonthsFormat=5]="MonthsFormat",n[n.MonthsStandalone=6]="MonthsStandalone",n[n.Eras=7]="Eras",n[n.FirstDayOfWeek=8]="FirstDayOfWeek",n[n.WeekendRange=9]="WeekendRange",n[n.DateFormat=10]="DateFormat",n[n.TimeFormat=11]="TimeFormat",n[n.DateTimeFormat=12]="DateTimeFormat",n[n.NumberSymbols=13]="NumberSymbols",n[n.NumberFormats=14]="NumberFormats",n[n.CurrencyCode=15]="CurrencyCode",n[n.CurrencySymbol=16]="CurrencySymbol",n[n.CurrencyName=17]="CurrencyName",n[n.Currencies=18]="Currencies",n[n.Directionality=19]="Directionality",n[n.PluralCase=20]="PluralCase",n[n.ExtraData=21]="ExtraData",hr;var n})(),sce=["zero","one","two","few","many"];var bM="en-US",VU={marker:"element"},HU={marker:"ICU"},vl=(()=>{return(n=vl||(vl={}))[n.SHIFT=2]="SHIFT",n[n.APPEND_EAGERLY=1]="APPEND_EAGERLY",n[n.COMMENT=2]="COMMENT",vl;var n})(),zU=bM;function UU(n,t,e){let i=t.insertBeforeIndex,r=Array.isArray(i)?i[0]:i;return null===r?nz(n,0,e):Ls(e[r])}function jU(n,t,e,i,r){let o=t.insertBeforeIndex;if(Array.isArray(o)){let a=i,s=null;if(3&t.type||(s=a,a=r),null!==a&&-1===t.componentOffset)for(let l=1;l<o.length;l++)Yp(n,a,e[o[l]],s,!1)}}function GU(n,t){if(n.push(t),n.length>1)for(let e=n.length-2;e>=0;e--){let i=n[e];WU(i)||pce(i,t)&&null===hce(i)&&mce(i,t.index)}}function WU(n){return!(64&n.type)}function pce(n,t){return WU(t)||n.index>t.index}function hce(n){let t=n.insertBeforeIndex;return Array.isArray(t)?t[0]:t}function mce(n,t){let e=n.insertBeforeIndex;Array.isArray(e)?e[0]=t:(rz(UU,jU),n.insertBeforeIndex=t)}function U_(n,t){let e=n.data[t];return null===e||"string"==typeof e?null:e.hasOwnProperty("currentCaseLViewIndex")?e:e.value}function _ce(n,t,e){let i=_k(n,e,64,null,null);return GU(t,i),i}function qM(n,t){let e=t[n.currentCaseLViewIndex];return null===e?e:e<0?~e:e}function bce(n){return n>>>17}function vce(n){return(131070&n)>>>1}var eb=0,j_=0;function qU(n,t,e,i){let a,r=e[ui],o=null;for(let s=0;s<t.length;s++){let l=t[s];if("string"==typeof l){let c=t[++s];null===e[c]&&(e[c]=sk(r,l))}else if("number"==typeof l)switch(1&l){case 0:let d,u,c=bce(l);if(null===o&&(o=c,a=kM(r,i)),c===o?(d=i,u=a):(d=null,u=Ls(e[c])),null!==u){let _=vce(l);Yp(r,u,e[_],d,!1);let y=U_(n,_);if(null!==y&&"object"==typeof y){let x=qM(y,e);null!==x&&qU(n,y.create[x],e,e[y.anchorIdx])}}break;case 1:let h=t[++s],m=t[++s];wk(r,AM(l>>>1,e),null,null,h,m,null)}else switch(l){case HU:let c=t[++s],d=t[++s];null===e[d]&&sc(e[d]=aae(r,c),e);break;case VU:let u=t[++s],p=t[++s];null===e[p]&&sc(e[p]=lk(r,u,null),e)}}}function XU(n,t,e,i,r){for(let o=0;o<e.length;o++){let a=e[o],s=e[++o];if(a&r){let l="";for(let c=o+1;c<=o+s;c++){let d=e[c];if("string"==typeof d)l+=d;else if("number"==typeof d)if(d<0)l+=jn(t[i-d]);else{let u=d>>>2;switch(3&d){case 1:let p=e[++c],h=e[++c],m=n.data[u];"string"==typeof m?wk(t[ui],t[u],null,m,p,l,h):ds(n,m,t,p,l,t[ui],h,!1);break;case 0:let _=t[u];null!==_&&Q5(t[ui],_,l);break;case 2:wce(n,U_(n,u),t,l);break;case 3:zH(n,U_(n,u),i,t)}}}}else{let l=e[o+1];if(l>0&&3==(3&l)){let d=U_(n,l>>>2);t[d.currentCaseLViewIndex]<0&&zH(n,d,i,t)}}o+=s}}function zH(n,t,e,i){let r=i[t.currentCaseLViewIndex];if(null!==r){let o=eb;r<0&&(r=i[t.currentCaseLViewIndex]=~r,o=-1),XU(n,i,t.update[r],e,o)}}function wce(n,t,e,i){let r=function(n,t){let e=n.cases.indexOf(t);if(-1===e)switch(n.type){case 1:{let i=function(n,t){let e=function(n){return Fa(n)[hr.PluralCase]}(t)(parseInt(n,10)),i=sce[e];return void 0!==i?i:"other"}(t,zU);e=n.cases.indexOf(i),-1===e&&"other"!==i&&(e=n.cases.indexOf("other"));break}case 0:e=n.cases.indexOf("other")}return-1===e?null:e}(t,i);if(qM(t,e)!==r&&(YU(n,t,e),e[t.currentCaseLViewIndex]=null===r?null:~r,null!==r)){let a=e[t.anchorIdx];a&&qU(n,t.create[r],e,a)}}function YU(n,t,e){let i=qM(t,e);if(null!==i){let r=t.remove[i];for(let o=0;o<r.length;o++){let a=r[o];if(a>0){let s=AM(a,e);null!==s&&ck(e[ui],s)}else YU(n,U_(n,~a),e)}}}function Ece(){let e,i,n=[],t=-1;function o(s,l){t=0;let c=qM(s,l);i=null!==c?s.remove[c]:ji}function a(){if(t<i.length){let s=i[t++];return s>0?e[s]:(n.push(t,i),o(e[Fn].data[~s],e),a())}return 0===n.length?null:(i=n.pop(),t=n.pop(),a())}return function(s,l){for(e=l;n.length;)n.pop();return o(s.value,l),a}}var vM=/\ufffd(\d+):?\d*\ufffd/gi,Tce=/({\s*\ufffd\d+:?\d*\ufffd\s*,\s*\S{6}\s*,[\s\S]*})/gi,Dce=/\ufffd(\d+)\ufffd/,QU=/^\s*(\ufffd\d+:?\d*\ufffd)\s*,\s*(select|plural)\s*,/,G_="\ufffd",Ice=/\ufffd\/?\*(\d+:\d+)\ufffd/gi,Ace=/\ufffd(\/?[#*]\d+):?\d*\ufffd/gi,Rce=/\uE500/g;function ZU(n,t,e,i,r,o,a){let s=fb(n,i,1,null),l=s<<vl.SHIFT,c=Z_();t===c&&(c=null),null===c&&(l|=vl.APPEND_EAGERLY),a&&(l|=vl.COMMENT,function(n){void 0===GR&&(GR=n())}(Ece)),r.push(l,null===o?"":o);let d=_k(n,s,a?32:1,null===o?"":o,null);GU(e,d);let u=d.index;return ac(d,!1),null!==c&&t!==c&&function(n,t){let e=n.insertBeforeIndex;null===e?(rz(UU,jU),e=n.insertBeforeIndex=[null,t]):(function(n,t,e){1!=n&&i5("Expecting array here",n,!0,"==")}(Array.isArray(e)),e.push(t))}(c,u),d}function Oce(n,t,e,i,r,o,a){let s=a.match(vM),l=ZU(n,t,e,o,i,s?null:a,!1);s&&W_(r,a,l.index,null,0,null)}function W_(n,t,e,i,r,o){let a=n.length,s=a+1;n.push(null,null);let l=a+2,c=t.split(vM),d=0;for(let u=0;u<c.length;u++){let p=c[u];if(1&u){let h=r+parseInt(p,10);n.push(-1-h),d|=KU(h)}else""!==p&&n.push(p)}return n.push(e<<2|(i?1:0)),i&&n.push(i,o),n[a]=d,n[s]=n.length-l,d}function Nce(n){let t=0;for(let e=0;e<n.length;e++){let i=n[e];"number"==typeof i&&i<0&&t++}return t}function KU(n){return 1<<Math.min(n,31)}function UH(n){let t,o,e="",i=0,r=!1;for(;null!==(t=Ice.exec(n));)r?t[0]===`${G_}/*${o}${G_}`&&(i=t.index,r=!1):(e+=n.substring(i,t.index+t[0].length),o=t[1],r=!0);return e+=n.slice(i),e}function JU(n,t,e,i,r,o){let a=0,s={type:r.type,currentCaseLViewIndex:fb(n,t,1,null),anchorIdx:o,cases:[],create:[],remove:[],update:[]};(function(n,t,e){n.push(KU(t.mainBinding),2,-1-t.mainBinding,e<<2|2)})(e,r,o),function(n,t,e){let i=n.data[t];null===i?n.data[t]=e:i.value=e}(n,o,s);let l=r.values;for(let c=0;c<l.length;c++){let d=l[c],u=[];for(let p=0;p<d.length;p++){let h=d[p];if("string"!=typeof h){let m=u.push(h)-1;d[p]=`\x3c!--\ufffd${m}\ufffd--\x3e`}}a=Hce(n,s,t,e,i,r.cases[c],d.join(""),u)|a}a&&function(n,t,e){n.push(t,1,e<<2|3)}(e,a,o)}function Vce(n){let t=[],e=[],i=1,r=0,o=yP(n=n.replace(QU,function(a,s,l){return i="select"===l?0:1,r=parseInt(s.slice(1),10),""}));for(let a=0;a<o.length;){let s=o[a++].trim();1===i&&(s=s.replace(/\s*(?:=)?(\w+)\s*/,"$1")),s.length&&t.push(s);let l=yP(o[a++]);t.length>e.length&&e.push(l)}return{type:i,mainBinding:r,cases:t,values:e}}function yP(n){if(!n)return[];let o,t=0,e=[],i=[],r=/[{}]/g;for(r.lastIndex=0;o=r.exec(n);){let s=o.index;if("}"==o[0]){if(e.pop(),0==e.length){let l=n.substring(t,s);QU.test(l)?i.push(Vce(l)):i.push(l),t=s+1}}else{if(0==e.length){let l=n.substring(t,s);i.push(l),t=s+1}e.push("{")}}let a=n.substring(t);return i.push(a),i}function Hce(n,t,e,i,r,o,a,s){let l=[],c=[],d=[];t.cases.push(o),t.create.push(l),t.remove.push(c),t.update.push(d);let p=_z(uz()).getInertBodyElement(a),h=rP(p)||p;return h?$U(n,t,e,i,l,c,d,h,r,s,0):0}function $U(n,t,e,i,r,o,a,s,l,c,d){let u=0,p=s.firstChild;for(;p;){let h=fb(n,e,1,null);switch(p.nodeType){case Node.ELEMENT_NODE:let m=p,_=m.tagName.toLowerCase();if(nP.hasOwnProperty(_)){MR(r,VU,_,l,h),n.data[h]=_;let R=m.attributes;for(let I=0;I<R.length;I++){let B=R.item(I),ee=B.name.toLowerCase();B.value.match(vM)?xz.hasOwnProperty(ee)&&W_(a,B.value,h,B.name,0,pk[ee]?pb:null):Gce(r,h,B)}u=$U(n,t,e,i,r,o,a,p,h,c,d+1)|u,jH(o,h,d)}break;case Node.TEXT_NODE:let M=p.textContent||"",y=M.match(vM);MR(r,null,y?"":M,l,h),jH(o,h,d),y&&(u=W_(a,M,h,null,0,null)|u);break;case Node.COMMENT_NODE:let x=Dce.exec(p.textContent||"");if(x){let I=c[parseInt(x[1],10)];MR(r,HU,"",l,h),JU(n,e,i,l,I,h),zce(o,h,d)}}p=p.nextSibling}return u}function jH(n,t,e){0===e&&n.push(t)}function zce(n,t,e){0===e&&(n.push(~t),n.push(t))}function MR(n,t,e,i,r){null!==t&&n.push(t),n.push(e,r,function(n,t,e){return 0|t<<17|e<<1}(0,i,r))}function Gce(n,t,e){n.push(t<<1|1,e.name,e.value)}var GH=0,Wce=/\[(\ufffd.+?\ufffd?)\]/,qce=/\[(\ufffd.+?\ufffd?)\]|(\ufffd\/?\*\d+:\d+\ufffd)/g,Xce=/({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g,Yce=/{([A-Z0-9_]+)}/g,Qce=/\ufffdI18N_EXP_(ICU(_\d+)?)\ufffd/g,Zce=/\/\*/,Kce=/\d+\:(\d+)/;function ej(n,t,e=-1){let i=Ti(),r=Ze(),o=Gr+n,a=nu(i.consts,t),s=Z_();i.firstCreatePass&&function(n,t,e,i,r,o){let a=Z_(),s=[],l=[],c=[[]];r=function(n,t){if(function(n){return-1===n}(t))return UH(n);{let e=n.indexOf(`:${t}${G_}`)+2+t.toString().length,i=n.search(new RegExp(`${G_}\\/\\*\\d+:${t}${G_}`));return UH(n.substring(e,i))}}(r,o);let d=function(n){return n.replace(Rce," ")}(r).split(Ace);for(let u=0;u<d.length;u++){let p=d[u];if(0==(1&u)){let h=yP(p);for(let m=0;m<h.length;m++){let _=h[m];if(0==(1&m))""!==_&&Oce(n,a,c[0],s,l,e,_);else{let M=_;if("object"!=typeof M)throw new Error(`Unable to parse ICU expression in "${r}" message.`);JU(n,e,l,t,M,ZU(n,a,c[0],e,s,"",!0).index)}}}else{let h=47===p.charCodeAt(0),_=(p.charCodeAt(h?1:0),Gr+Number.parseInt(p.substring(h?2:1)));if(h)c.shift(),ac(Z_(),!1);else{let M=_ce(n,c[0],_);c.unshift([]),ac(M,!0)}}}n.data[i]={create:s,update:l}}(i,null===s?0:s.index,r,o,a,e);let l=i.data[o],d=$5(i,s===r[Aa]?null:s,r);(function(n,t,e,i){let r=n[ui];for(let o=0;o<t.length;o++){let a=t[o++],s=t[o],c=(a&vl.APPEND_EAGERLY)===vl.APPEND_EAGERLY,d=a>>>vl.SHIFT,u=n[d];null===u&&(u=n[d]=(a&vl.COMMENT)===vl.COMMENT?r.createComment(s):sk(r,s)),c&&null!==e&&Yp(r,e,u,i,!1)}})(r,l.create,d,s&&8&s.type?r[s.index]:null),M5(!0)}function tj(){M5(!1)}function XM(n,t,e){ej(n,t,e),tj()}function vb(n){return function(n){n&&(eb|=1<<Math.min(j_,31)),j_++}(qo(Ze(),sf(),n)),vb}function YM(n){!function(n,t,e){if(j_>0){let i=n.data[e];XU(n,t,Array.isArray(i)?i:i.update,td()-j_-1,eb)}eb=0,j_=0}(Ti(),Ze(),n+Gr)}function QM(n,t={}){return function(n,t={}){let e=n;if(Wce.test(n)){let i={},r=[GH];e=e.replace(qce,(o,a,s)=>{let l=a||s,c=i[l]||[];if(c.length||(l.split("|").forEach(_=>{let M=_.match(Kce),y=M?parseInt(M[1],10):GH,x=Zce.test(_);c.push([y,x,_])}),i[l]=c),!c.length)throw new Error(`i18n postprocess: unmatched placeholder - ${l}`);let d=r[r.length-1],u=0;for(let _=0;_<c.length;_++)if(c[_][0]===d){u=_;break}let[p,h,m]=c[u];return h?r.pop():d!==p&&r.push(p),c.splice(u,1),m})}return Object.keys(t).length&&(e=e.replace(Xce,(i,r,o,a,s,l)=>t.hasOwnProperty(o)?`${r}${t[o]}${l}`:i),e=e.replace(Yce,(i,r)=>t.hasOwnProperty(r)?t[r]:i),e=e.replace(Qce,(i,r)=>{if(t.hasOwnProperty(r)){let o=t[r];if(!o.length)throw new Error(`i18n postprocess: unmatched ICU - ${i} with key: ${r}`);return o.shift()}return i})),e}(n,t)}function xP(n,t,e,i,r){if(n=Ai(n),Array.isArray(n))for(let o=0;o<n.length;o++)xP(n[o],t,e,i,r);else{let o=Ti(),a=Ze(),s=$m(n)?n:Ai(n.provide),l=Dz(n),c=Lo(),d=1048575&c.providerIndexes,u=c.directiveStart,p=c.providerIndexes>>20;if($m(n)||!n.multi){let h=new qp(l,r,C),m=SR(s,t,r?d:d+p,u);-1===m?(zR(cM(c,a),o,s),wR(o,n,t.length),t.push(s),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(h),a.push(h)):(e[m]=h,a[m]=h)}else{let h=SR(s,t,d+p,u),m=SR(s,t,d,d+p),M=m>=0&&e[m];if(r&&!M||!r&&!(h>=0&&e[h])){zR(cM(c,a),o,s);let y=function(n,t,e,i,r){let o=new qp(n,e,C);return o.multi=[],o.index=t,o.componentProviders=0,nj(o,r,i&&!e),o}(r?nde:tde,e.length,r,i,l);!r&&M&&(e[m].providerFactory=y),wR(o,n,t.length,0),t.push(s),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(y),a.push(y)}else wR(o,n,h>-1?h:m,nj(e[r?m:h],l,!r&&i));!r&&i&&M&&e[m].componentProviders++}}}function wR(n,t,e,i){let r=$m(t),o=function(n){return!!n.useClass}(t);if(r||o){let l=(o?Ai(t.useClass):t).prototype.ngOnDestroy;if(l){let c=n.destroyHooks||(n.destroyHooks=[]);if(!r&&t.multi){let d=c.indexOf(e);-1===d?c.push(e,[i,l]):c[d+1].push(i,l)}else c.push(e,l)}}}function nj(n,t,e){return e&&n.componentProviders++,n.multi.push(t)-1}function SR(n,t,e,i){for(let r=e;r<i;r++)if(t[r]===n)return r;return-1}function tde(n,t,e,i){return CP(this.multi,[])}function nde(n,t,e,i){let o,r=this.multi;if(this.providerFactory){let a=this.providerFactory.componentProviders,s=Xp(e,e[Fn],this.providerFactory.index,i);o=s.slice(0,a),CP(r,o);for(let l=a;l<s.length;l++)o.push(s[l])}else o=[],CP(r,o);return o}function CP(n,t){for(let e=0;e<n.length;e++)t.push((0,n[e])());return t}function Vt(n,t=[]){return e=>{e.providersResolver=(i,r)=>function(n,t,e){let i=Ti();if(i.firstCreatePass){let r=Cl(n);xP(e,i.data,i.blueprint,r,!0),xP(t,i.data,i.blueprint,r,!1)}}(i,r?r(n):n,t)}}var iu=class{},MP=class{},wP=class extends iu{constructor(t,e){super(),this._parent=e,this._bootstrapComponents=[],this.destroyCbs=[],this.componentFactoryResolver=new fM(this);let i=Zm(t);this._bootstrapComponents=QC(i.bootstrap),this._r3Injector=Fz(t,e,[{provide:iu,useValue:this},{provide:ho,useValue:this.componentFactoryResolver}],po(t),new Set(["environment"])),this._r3Injector.resolveInjectorInitializers(),this.instance=this._r3Injector.get(t)}get injector(){return this._r3Injector}destroy(){let t=this._r3Injector;!t.destroyed&&t.destroy(),this.destroyCbs.forEach(e=>e()),this.destroyCbs=null}onDestroy(t){this.destroyCbs.push(t)}},SP=class extends MP{constructor(t){super(),this.moduleType=t}create(t){return new wP(this.moduleType,t)}},EP=class extends iu{constructor(t,e,i){super(),this.componentFactoryResolver=new fM(this),this.instance=null;let r=new pM([...t,{provide:iu,useValue:this},{provide:ho,useValue:this.componentFactoryResolver}],e||gk(),i,new Set(["environment"]));this.injector=r,r.resolveInjectorInitializers()}destroy(){this.injector.destroy()}onDestroy(t){this.injector.onDestroy(t)}},ode=(()=>{class n{constructor(e){this._injector=e,this.cachedInjectors=new Map}getOrCreateStandaloneInjector(e){if(!e.standalone)return null;if(!this.cachedInjectors.has(e.id)){let i=Sz(0,e.type),r=i.length>0?function(n,t,e=null){return new EP(n,t,e).injector}([i],this._injector,`Standalone[${e.type.name}]`):null;this.cachedInjectors.set(e.id,r)}return this.cachedInjectors.get(e.id)}ngOnDestroy(){try{for(let e of this.cachedInjectors.values())null!==e&&e.destroy()}finally{this.cachedInjectors.clear()}}}return n.\u0275prov=ue({token:n,providedIn:"environment",factory:()=>new n(O(lc))}),n})();function Ak(n){n.getStandaloneInjector=t=>t.get(ode).getOrCreateStandaloneInjector(n)}function mc(n,t,e){let i=ca()+n,r=Ze();return r[i]===zn?pc(r,i,e?t.call(e):t()):gb(r,i)}function Un(n,t,e,i){return ij(Ze(),ca(),n,t,e,i)}function So(n,t,e,i,r){return rj(Ze(),ca(),n,t,e,i,r)}function yb(n,t,e,i,r,o){return oj(Ze(),ca(),n,t,e,i,r,o)}function Rk(n,t,e,i,r,o,a){return aj(Ze(),ca(),n,t,e,i,r,o,a)}function Pk(n,t,e,i,r,o,a,s){let l=ca()+n,c=Ze(),d=Bs(c,l,e,i,r,o);return qo(c,l+4,a)||d?pc(c,l+5,s?t.call(s,e,i,r,o,a):t(e,i,r,o,a)):gb(c,l+5)}function xb(n,t){let e=n[t];return e===zn?void 0:e}function ij(n,t,e,i,r,o){let a=t+e;return qo(n,a,r)?pc(n,a+1,o?i.call(o,r):i(r)):xb(n,a+1)}function rj(n,t,e,i,r,o,a){let s=t+e;return Zp(n,s,r,o)?pc(n,s+2,a?i.call(a,r,o):i(r,o)):xb(n,s+2)}function oj(n,t,e,i,r,o,a,s){let l=t+e;return zM(n,l,r,o,a)?pc(n,l+3,s?i.call(s,r,o,a):i(r,o,a)):xb(n,l+3)}function aj(n,t,e,i,r,o,a,s,l){let c=t+e;return Bs(n,c,r,o,a,s)?pc(n,c+4,l?i.call(l,r,o,a,s):i(r,o,a,s)):xb(n,c+4)}function sj(n,t,e,i,r,o){let a=t+e,s=!1;for(let l=0;l<r.length;l++)qo(n,a++,r[l])&&(s=!0);return s?pc(n,a,i.apply(o,r)):xb(n,a)}function U(n,t){let i,e=Ti(),r=n+Gr;e.firstCreatePass?(i=function(n,t){if(t)for(let e=t.length-1;e>=0;e--){let i=t[e];if(n===i.name)return i}}(t,e.pipeRegistry),e.data[r]=i,i.onDestroy&&(e.destroyHooks??(e.destroyHooks=[])).push(r,i.onDestroy)):i=e.data[r];let o=i.factory||(i.factory=Gp(i.type)),a=Ps(C);try{let s=lM(!1),l=o();return lM(s),function(n,t,e,i){e>=n.data.length&&(n.data[e]=null,n.blueprint[e]=null),t[e]=i}(e,Ze(),r,l),l}finally{Ps(a)}}function G(n,t,e){let i=n+Gr,r=Ze(),o=af(r,i);return Cb(r,i)?ij(r,ca(),t,o.transform,e,o):o.transform(e)}function Jp(n,t,e,i){let r=n+Gr,o=Ze(),a=af(o,r);return Cb(o,r)?rj(o,ca(),t,a.transform,e,i,a):a.transform(e,i)}function kk(n,t,e,i,r){let o=n+Gr,a=Ze(),s=af(a,o);return Cb(a,o)?oj(a,ca(),t,s.transform,e,i,r,s):s.transform(e,i,r)}function Cb(n,t){return n[Fn].data[t].pure}function ER(n){return t=>{setTimeout(n,void 0,t)}}var F=class extends Ee{constructor(t=!1){super(),this.__isAsync=t}emit(t){super.next(t)}subscribe(t,e,i){let r=t,o=e||(()=>null),a=i;if(t&&"object"==typeof t){let l=t;r=l.next?.bind(l),o=l.error?.bind(l),a=l.complete?.bind(l)}this.__isAsync&&(o=ER(o),r&&(r=ER(r)),a&&(a=ER(a)));let s=super.subscribe({next:r,error:o,complete:a});return t instanceof En&&t.add(s),s}};function hde(){return this._results[Symbol.iterator]()}var Pa=class{get changes(){return this._changes||(this._changes=new F)}constructor(t=!1){this._emitDistinctChangesOnly=t,this.dirty=!0,this._results=[],this._changesDetected=!1,this._changes=null,this.length=0,this.first=void 0,this.last=void 0;let e=Pa.prototype;e[Symbol.iterator]||(e[Symbol.iterator]=hde)}get(t){return this._results[t]}map(t){return this._results.map(t)}filter(t){return this._results.filter(t)}find(t){return this._results.find(t)}reduce(t,e){return this._results.reduce(t,e)}forEach(t){this._results.forEach(t)}some(t){return this._results.some(t)}toArray(){return this._results.slice()}toString(){return this._results.toString()}reset(t,e){let i=this;i.dirty=!1;let r=Jd(t);(this._changesDetected=!function(n,t,e){if(n.length!==t.length)return!1;for(let i=0;i<n.length;i++){let r=n[i],o=t[i];if(e&&(r=e(r),o=e(o)),o!==r)return!1}return!0}(i._results,r,e))&&(i._results=r,i.length=r.length,i.last=r[this.length-1],i.first=r[0])}notifyOnChanges(){this._changes&&(this._changesDetected||!this._emitDistinctChangesOnly)&&this._changes.emit(this)}setDirty(){this.dirty=!0}destroy(){this.changes.complete(),this.changes.unsubscribe()}},oi=(()=>{class n{}return n.__NG_ELEMENT_ID__=gde,n})(),mde=oi,fde=class extends mde{constructor(t,e,i){super(),this._declarationLView=t,this._declarationTContainer=e,this.elementRef=i}createEmbeddedView(t,e){let i=this._declarationTContainer.tView,r=BM(this._declarationLView,i,t,16,null,i.declTNode,null,null,null,null,e||null);r[lb]=this._declarationLView[this._declarationTContainer.index];let a=this._declarationLView[oc];return null!==a&&(r[oc]=a.createEmbeddedView(i)),bk(i,r,t),new Qp(r)}};function gde(){return ZM(Lo(),Ze())}function ZM(n,t){return 4&n.type?new fde(t,n,uf(n,t)):null}var ei=(()=>{class n{}return n.__NG_ELEMENT_ID__=_de,n})();function _de(){return cj(Lo(),Ze())}var bde=ei,lj=class extends bde{constructor(t,e,i){super(),this._lContainer=t,this._hostTNode=e,this._hostLView=i}get element(){return uf(this._hostTNode,this._hostLView)}get injector(){return new jp(this._hostTNode,this._hostLView)}get parentInjector(){let t=$P(this._hostTNode,this._hostLView);if(P5(t)){let e=sM(t,this._hostLView),i=aM(t);return new jp(e[Fn].data[i+8],e)}return new jp(null,this._hostLView)}clear(){for(;this.length>0;)this.remove(this.length-1)}get(t){let e=WH(this._lContainer);return null!==e&&e[t]||null}get length(){return this._lContainer.length-Ia}createEmbeddedView(t,e,i){let r,o;"number"==typeof i?r=i:null!=i&&(r=i.index,o=i.injector);let a=t.createEmbeddedView(e||{},o);return this.insert(a,r),a}createComponent(t,e,i,r,o){let s,a=t&&!F_(t);if(a)s=e;else{let u=e||{};s=u.index,i=u.injector,r=u.projectableNodes,o=u.environmentInjector||u.ngModuleRef}let l=a?t:new gM(Os(t)),c=i||this.parentInjector;if(!o&&null==l.ngModule){let p=(a?c:this.parentInjector).get(lc,null);p&&(o=p)}let d=l.create(c,r,void 0,o);return this.insert(d.hostView,s),d}insert(t,e){let i=t._lView,r=i[Fn];if($c(i[jr])){let d=this.indexOf(t);if(-1!==d)this.detach(d);else{let u=i[jr],p=new lj(u,u[Aa],u[jr]);p.detach(p.indexOf(t))}}let o=this._adjustIndex(e),a=this._lContainer;!function(n,t,e,i){let r=Ia+i,o=e.length;i>0&&(e[r-1][yl]=t),i<o-Ia?(t[yl]=e[r],U5(e,Ia+i,t)):(e.push(t),t[yl]=null),t[jr]=e;let a=t[lb];null!==a&&e!==a&&function(n,t){let e=n[Km];t[xl]!==t[jr][jr][xl]&&(n[p5]=!0),null===e?n[Km]=[t]:e.push(t)}(a,t);let s=t[oc];null!==s&&s.insertView(n),t[di]|=64}(r,i,a,o);let s=XR(o,a),l=i[ui],c=kM(l,a[GP]);return null!==c&&function(n,t,e,i,r,o){i[ou]=r,i[Aa]=t,ub(n,i,e,1,r,o)}(r,a[Aa],l,i,c,s),t.attachToViewContainerRef(),U5(TR(a),o,t),t}move(t,e){return this.insert(t,e)}indexOf(t){let e=WH(this._lContainer);return null!==e?e.indexOf(t):-1}remove(t){let e=this._adjustIndex(t,-1),i=WR(this._lContainer,e);i&&(dM(TR(this._lContainer),e),K5(i[Fn],i))}detach(t){let e=this._adjustIndex(t,-1),i=WR(this._lContainer,e);return i&&null!=dM(TR(this._lContainer),e)?new Qp(i):null}_adjustIndex(t,e=0){return t??this.length+e}};function WH(n){return n[rM]}function TR(n){return n[rM]||(n[rM]=[])}function cj(n,t){let e,i=t[n.index];if($c(i))e=i;else{let r;if(8&n.type)r=Ls(i);else{let o=t[ui];r=o.createComment("");let a=ss(n,t);Yp(o,kM(o,a),r,function(n,t){return n.nextSibling(t)}(o,a),!1)}t[n.index]=e=Uz(i,t,r,n),HM(t,e)}return new lj(e,n,t)}var tb=class{constructor(t){this.queryList=t,this.matches=null}clone(){return new tb(this.queryList)}setDirty(){this.queryList.setDirty()}},nb=class{constructor(t=[]){this.queries=t}createEmbeddedView(t){let e=t.queries;if(null!==e){let i=null!==t.contentQueries?t.contentQueries[0]:e.length,r=[];for(let o=0;o<i;o++){let a=e.getByIndex(o);r.push(this.queries[a.indexInDeclarationView].clone())}return new nb(r)}return null}insertView(t){this.dirtyQueriesWithMatches(t)}detachView(t){this.dirtyQueriesWithMatches(t)}dirtyQueriesWithMatches(t){for(let e=0;e<this.queries.length;e++)null!==hj(t,e).matches&&this.queries[e].setDirty()}},yM=class{constructor(t,e,i=null){this.predicate=t,this.flags=e,this.read=i}},ib=class{constructor(t=[]){this.queries=t}elementStart(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].elementStart(t,e)}elementEnd(t){for(let e=0;e<this.queries.length;e++)this.queries[e].elementEnd(t)}embeddedTView(t){let e=null;for(let i=0;i<this.length;i++){let r=null!==e?e.length:0,o=this.getByIndex(i).embeddedTView(t,r);o&&(o.indexInDeclarationView=i,null!==e?e.push(o):e=[o])}return null!==e?new ib(e):null}template(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].template(t,e)}getByIndex(t){return this.queries[t]}get length(){return this.queries.length}track(t){this.queries.push(t)}},rb=class{constructor(t,e=-1){this.metadata=t,this.matches=null,this.indexInDeclarationView=-1,this.crossesNgTemplate=!1,this._appliesToNextNode=!0,this._declarationNodeIndex=e}elementStart(t,e){this.isApplyingToNode(e)&&this.matchTNode(t,e)}elementEnd(t){this._declarationNodeIndex===t.index&&(this._appliesToNextNode=!1)}template(t,e){this.elementStart(t,e)}embeddedTView(t,e){return this.isApplyingToNode(t)?(this.crossesNgTemplate=!0,this.addMatch(-t.index,e),new rb(this.metadata)):null}isApplyingToNode(t){if(this._appliesToNextNode&&1!=(1&this.metadata.flags)){let e=this._declarationNodeIndex,i=t.parent;for(;null!==i&&8&i.type&&i.index!==e;)i=i.parent;return e===(null!==i?i.index:-1)}return this._appliesToNextNode}matchTNode(t,e){let i=this.metadata.predicate;if(Array.isArray(i))for(let r=0;r<i.length;r++){let o=i[r];this.matchTNodeWithReadOption(t,e,vde(e,o)),this.matchTNodeWithReadOption(t,e,qC(e,t,o,!1,!1))}else i===oi?4&e.type&&this.matchTNodeWithReadOption(t,e,-1):this.matchTNodeWithReadOption(t,e,qC(e,t,i,!1,!1))}matchTNodeWithReadOption(t,e,i){if(null!==i){let r=this.metadata.read;if(null!==r)if(r===xe||r===ei||r===oi&&4&e.type)this.addMatch(e.index,-2);else{let o=qC(e,t,r,!1,!1);null!==o&&this.addMatch(e.index,o)}else this.addMatch(e.index,i)}}addMatch(t,e){null===this.matches?this.matches=[t,e]:this.matches.push(t,e)}};function vde(n,t){let e=n.localNames;if(null!==e)for(let i=0;i<e.length;i+=2)if(e[i]===t)return e[i+1];return null}function xde(n,t,e,i){return-1===e?function(n,t){return 11&n.type?uf(n,t):4&n.type?ZM(n,t):null}(t,n):-2===e?function(n,t,e){return e===xe?uf(t,n):e===oi?ZM(t,n):e===ei?cj(t,n):void 0}(n,t,i):Xp(n,n[Fn],e,t)}function dj(n,t,e,i){let r=t[oc].queries[i];if(null===r.matches){let o=n.data,a=e.matches,s=[];for(let l=0;l<a.length;l+=2){let c=a[l];s.push(c<0?null:xde(t,o[c],a[l+1],e.metadata.read))}r.matches=s}return r.matches}function DP(n,t,e,i){let r=n.queries.getByIndex(e),o=r.matches;if(null!==o){let a=dj(n,t,r,e);for(let s=0;s<o.length;s+=2){let l=o[s];if(l>0)i.push(a[s/2]);else{let c=o[s+1],d=t[-l];for(let u=Ia;u<d.length;u++){let p=d[u];p[lb]===p[jr]&&DP(p[Fn],p,c,i)}if(null!==d[Km]){let u=d[Km];for(let p=0;p<u.length;p++){let h=u[p];DP(h[Fn],h,c,i)}}}}}return i}function be(n){let t=Ze(),e=Ti(),i=w5();ZP(i+1);let r=hj(e,i);if(n.dirty&&function(n){return 4==(4&n[di])}(t)===(2==(2&r.metadata.flags))){if(null===r.matches)n.reset([]);else{let o=r.crossesNgTemplate?DP(e,t,i,[]):dj(e,t,r,i);n.reset(o,tse),n.notifyOnChanges()}return!0}return!1}function Ue(n,t,e){let i=Ti();i.firstCreatePass&&(pj(i,new yM(n,t,e),-1),2==(2&t)&&(i.staticViewQueries=!0)),uj(i,Ze(),t)}function Bn(n,t,e,i){let r=Ti();if(r.firstCreatePass){let o=Lo();pj(r,new yM(t,e,i),o.index),function(n,t){let e=n.contentQueries||(n.contentQueries=[]);t!==(e.length?e[e.length-1]:-1)&&e.push(n.queries.length-1,t)}(r,n),2==(2&e)&&(r.staticContentQueries=!0)}uj(r,Ze(),e)}function ve(){return n=Ze(),t=w5(),n[oc].queries[t].queryList;var n,t}function uj(n,t,e){let i=new Pa(4==(4&e));Vz(n,t,i,i.destroy),null===t[oc]&&(t[oc]=new nb),t[oc].queries.push(new tb(i))}function pj(n,t,e){null===n.queries&&(n.queries=new ib),n.queries.track(new rb(t,e))}function hj(n,t){return n.queries.getByIndex(t)}function jt(n,t){return ZM(n,t)}var $d={"\u0275\u0275attribute":Be,"\u0275\u0275attributeInterpolate1":function Kz(n,t,e,i,r,o){let a=Ze(),s=mf(a,t,e,i);return s!==zn&&uc(Pr(),a,n,s,r,o),Kz},"\u0275\u0275attributeInterpolate2":function Jz(n,t,e,i,r,o,a,s){let l=Ze(),c=ff(l,t,e,i,r,o);return c!==zn&&uc(Pr(),l,n,c,a,s),Jz},"\u0275\u0275attributeInterpolate3":function $z(n,t,e,i,r,o,a,s,l,c){let d=Ze(),u=gf(d,t,e,i,r,o,a,s);return u!==zn&&uc(Pr(),d,n,u,l,c),$z},"\u0275\u0275attributeInterpolate4":function eU(n,t,e,i,r,o,a,s,l,c,d,u){let p=Ze(),h=_f(p,t,e,i,r,o,a,s,l,c);return h!==zn&&uc(Pr(),p,n,h,d,u),eU},"\u0275\u0275attributeInterpolate5":function tU(n,t,e,i,r,o,a,s,l,c,d,u,p,h){let m=Ze(),_=bf(m,t,e,i,r,o,a,s,l,c,d,u);return _!==zn&&uc(Pr(),m,n,_,p,h),tU},"\u0275\u0275attributeInterpolate6":function nU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_){let M=Ze(),y=vf(M,t,e,i,r,o,a,s,l,c,d,u,p,h);return y!==zn&&uc(Pr(),M,n,y,m,_),nU},"\u0275\u0275attributeInterpolate7":function iU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y){let x=Ze(),R=yf(x,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_);return R!==zn&&uc(Pr(),x,n,R,M,y),iU},"\u0275\u0275attributeInterpolate8":function rU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y,x,R){let I=Ze(),B=xf(I,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y);return B!==zn&&uc(Pr(),I,n,B,x,R),rU},"\u0275\u0275attributeInterpolateV":function oU(n,t,e,i){let r=Ze(),o=hf(r,t);return o!==zn&&uc(Pr(),r,n,o,e,i),oU},"\u0275\u0275defineComponent":P,"\u0275\u0275defineDirective":Me,"\u0275\u0275defineInjectable":ue,"\u0275\u0275defineInjector":H,"\u0275\u0275defineNgModule":z,"\u0275\u0275definePipe":rf,"\u0275\u0275directiveInject":C,"\u0275\u0275getInheritedFactory":Xn,"\u0275\u0275inject":O,"\u0275\u0275injectAttribute":Mo,"\u0275\u0275invalidFactory":cs,"\u0275\u0275invalidFactoryDep":a5,"\u0275\u0275templateRefExtractor":jt,"\u0275\u0275resetView":ie,"\u0275\u0275HostDirectivesFeature":function(n){return t=>{t.findHostDirectiveDefs=Qz,t.hostDirectives=(Array.isArray(n)?n:n()).map(e=>"function"==typeof e?{directive:Ai(e),inputs:Zc,outputs:Zc}:{directive:Ai(e.directive),inputs:kH(e.inputs),outputs:kH(e.outputs)})}},"\u0275\u0275NgOnChangesFeature":qt,"\u0275\u0275ProvidersFeature":Vt,"\u0275\u0275CopyDefinitionFeature":function(n){let e,t=Yz(n.type);e=Cl(n)?t.\u0275cmp:t.\u0275dir;let i=n;for(let r of lle)i[r]=e[r];if(Cl(e))for(let r of cle)i[r]=e[r]},"\u0275\u0275InheritDefinitionFeature":Xe,"\u0275\u0275StandaloneFeature":Ak,"\u0275\u0275nextContext":w,"\u0275\u0275namespaceHTML":ua,"\u0275\u0275namespaceMathML":function(){Gn.lFrame.currentNamespace=_5},"\u0275\u0275namespaceSVG":qn,"\u0275\u0275enableBindings":function(){Gn.bindingsEnabled=!0},"\u0275\u0275disableBindings":function(){Gn.bindingsEnabled=!1},"\u0275\u0275elementStart":f,"\u0275\u0275elementEnd":g,"\u0275\u0275element":k,"\u0275\u0275elementContainerStart":Gt,"\u0275\u0275elementContainerEnd":Wt,"\u0275\u0275elementContainer":hi,"\u0275\u0275pureFunction0":mc,"\u0275\u0275pureFunction1":Un,"\u0275\u0275pureFunction2":So,"\u0275\u0275pureFunction3":yb,"\u0275\u0275pureFunction4":Rk,"\u0275\u0275pureFunction5":Pk,"\u0275\u0275pureFunction6":function(n,t,e,i,r,o,a,s,l){let c=ca()+n,d=Ze(),u=Bs(d,c,e,i,r,o);return Zp(d,c+4,a,s)||u?pc(d,c+6,l?t.call(l,e,i,r,o,a,s):t(e,i,r,o,a,s)):gb(d,c+6)},"\u0275\u0275pureFunction7":function(n,t,e,i,r,o,a,s,l,c){let d=ca()+n,u=Ze(),p=Bs(u,d,e,i,r,o);return zM(u,d+4,a,s,l)||p?pc(u,d+7,c?t.call(c,e,i,r,o,a,s,l):t(e,i,r,o,a,s,l)):gb(u,d+7)},"\u0275\u0275pureFunction8":function(n,t,e,i,r,o,a,s,l,c,d){let u=ca()+n,p=Ze(),h=Bs(p,u,e,i,r,o);return Bs(p,u+4,a,s,l,c)||h?pc(p,u+8,d?t.call(d,e,i,r,o,a,s,l,c):t(e,i,r,o,a,s,l,c)):gb(p,u+8)},"\u0275\u0275pureFunctionV":function(n,t,e,i){return sj(Ze(),ca(),n,t,e,i)},"\u0275\u0275getCurrentView":Te,"\u0275\u0275restoreView":ne,"\u0275\u0275listener":A,"\u0275\u0275projection":Tt,"\u0275\u0275syntheticHostProperty":WM,"\u0275\u0275syntheticHostListener":UM,"\u0275\u0275pipeBind1":G,"\u0275\u0275pipeBind2":Jp,"\u0275\u0275pipeBind3":kk,"\u0275\u0275pipeBind4":function(n,t,e,i,r,o){let a=n+Gr,s=Ze(),l=af(s,a);return Cb(s,a)?aj(s,ca(),t,l.transform,e,i,r,o,l):l.transform(e,i,r,o)},"\u0275\u0275pipeBindV":function(n,t,e){let i=n+Gr,r=Ze(),o=af(r,i);return Cb(r,i)?sj(r,ca(),t,o.transform,e,o):o.transform.apply(o,e)},"\u0275\u0275projectionDef":fn,"\u0275\u0275hostProperty":wo,"\u0275\u0275property":b,"\u0275\u0275propertyInterpolate":Zi,"\u0275\u0275propertyInterpolate1":_b,"\u0275\u0275propertyInterpolate2":jM,"\u0275\u0275propertyInterpolate3":function sU(n,t,e,i,r,o,a,s,l){let c=Ze(),d=gf(c,t,e,i,r,o,a,s);return d!==zn&&ds(Ti(),Pr(),c,n,d,c[ui],l,!1),sU},"\u0275\u0275propertyInterpolate4":function lU(n,t,e,i,r,o,a,s,l,c,d){let u=Ze(),p=_f(u,t,e,i,r,o,a,s,l,c);return p!==zn&&ds(Ti(),Pr(),u,n,p,u[ui],d,!1),lU},"\u0275\u0275propertyInterpolate5":function cU(n,t,e,i,r,o,a,s,l,c,d,u,p){let h=Ze(),m=bf(h,t,e,i,r,o,a,s,l,c,d,u);return m!==zn&&ds(Ti(),Pr(),h,n,m,h[ui],p,!1),cU},"\u0275\u0275propertyInterpolate6":function dU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m){let _=Ze(),M=vf(_,t,e,i,r,o,a,s,l,c,d,u,p,h);return M!==zn&&ds(Ti(),Pr(),_,n,M,_[ui],m,!1),dU},"\u0275\u0275propertyInterpolate7":function uU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){let y=Ze(),x=yf(y,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_);return x!==zn&&ds(Ti(),Pr(),y,n,x,y[ui],M,!1),uU},"\u0275\u0275propertyInterpolate8":function pU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y,x){let R=Ze(),I=xf(R,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y);return I!==zn&&ds(Ti(),Pr(),R,n,I,R[ui],x,!1),pU},"\u0275\u0275propertyInterpolateV":function hU(n,t,e){let i=Ze(),r=hf(i,t);return r!==zn&&ds(Ti(),Pr(),i,n,r,i[ui],e,!1),hU},"\u0275\u0275pipe":U,"\u0275\u0275queryRefresh":be,"\u0275\u0275viewQuery":Ue,"\u0275\u0275loadQuery":ve,"\u0275\u0275contentQuery":Bn,"\u0275\u0275reference":st,"\u0275\u0275classMap":Xo,"\u0275\u0275classMapInterpolate1":bb,"\u0275\u0275classMapInterpolate2":function(n,t,e,i,r){El(ls,hc,ff(Ze(),n,t,e,i,r),!0)},"\u0275\u0275classMapInterpolate3":function(n,t,e,i,r,o,a){El(ls,hc,gf(Ze(),n,t,e,i,r,o,a),!0)},"\u0275\u0275classMapInterpolate4":function(n,t,e,i,r,o,a,s,l){El(ls,hc,_f(Ze(),n,t,e,i,r,o,a,s,l),!0)},"\u0275\u0275classMapInterpolate5":function(n,t,e,i,r,o,a,s,l,c,d){El(ls,hc,bf(Ze(),n,t,e,i,r,o,a,s,l,c,d),!0)},"\u0275\u0275classMapInterpolate6":function(n,t,e,i,r,o,a,s,l,c,d,u,p){El(ls,hc,vf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p),!0)},"\u0275\u0275classMapInterpolate7":function(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m){El(ls,hc,yf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p,h,m),!0)},"\u0275\u0275classMapInterpolate8":function(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){El(ls,hc,xf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M),!0)},"\u0275\u0275classMapInterpolateV":function(n){El(ls,hc,hf(Ze(),n),!0)},"\u0275\u0275styleMap":Hs,"\u0275\u0275styleMapInterpolate1":function(n,t,e){Hs(mf(Ze(),n,t,e))},"\u0275\u0275styleMapInterpolate2":function(n,t,e,i,r){Hs(ff(Ze(),n,t,e,i,r))},"\u0275\u0275styleMapInterpolate3":function(n,t,e,i,r,o,a){Hs(gf(Ze(),n,t,e,i,r,o,a))},"\u0275\u0275styleMapInterpolate4":function(n,t,e,i,r,o,a,s,l){Hs(_f(Ze(),n,t,e,i,r,o,a,s,l))},"\u0275\u0275styleMapInterpolate5":function(n,t,e,i,r,o,a,s,l,c,d){Hs(bf(Ze(),n,t,e,i,r,o,a,s,l,c,d))},"\u0275\u0275styleMapInterpolate6":function(n,t,e,i,r,o,a,s,l,c,d,u,p){Hs(vf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p))},"\u0275\u0275styleMapInterpolate7":function(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m){Hs(yf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p,h,m))},"\u0275\u0275styleMapInterpolate8":function(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){Hs(xf(Ze(),n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M))},"\u0275\u0275styleMapInterpolateV":function(n){Hs(hf(Ze(),n))},"\u0275\u0275styleProp":Bt,"\u0275\u0275stylePropInterpolate1":function IU(n,t,e,i,r){return Sl(n,mf(Ze(),t,e,i),r,!1),IU},"\u0275\u0275stylePropInterpolate2":function AU(n,t,e,i,r,o,a){return Sl(n,ff(Ze(),t,e,i,r,o),a,!1),AU},"\u0275\u0275stylePropInterpolate3":function RU(n,t,e,i,r,o,a,s,l){return Sl(n,gf(Ze(),t,e,i,r,o,a,s),l,!1),RU},"\u0275\u0275stylePropInterpolate4":function PU(n,t,e,i,r,o,a,s,l,c,d){return Sl(n,_f(Ze(),t,e,i,r,o,a,s,l,c),d,!1),PU},"\u0275\u0275stylePropInterpolate5":function kU(n,t,e,i,r,o,a,s,l,c,d,u,p){return Sl(n,bf(Ze(),t,e,i,r,o,a,s,l,c,d,u),p,!1),kU},"\u0275\u0275stylePropInterpolate6":function OU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m){return Sl(n,vf(Ze(),t,e,i,r,o,a,s,l,c,d,u,p,h),m,!1),OU},"\u0275\u0275stylePropInterpolate7":function FU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){return Sl(n,yf(Ze(),t,e,i,r,o,a,s,l,c,d,u,p,h,m,_),M,!1),FU},"\u0275\u0275stylePropInterpolate8":function NU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y,x){return Sl(n,xf(Ze(),t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y),x,!1),NU},"\u0275\u0275stylePropInterpolateV":function LU(n,t,e){return Sl(n,hf(Ze(),t),e,!1),LU},"\u0275\u0275classProp":nt,"\u0275\u0275advance":v,"\u0275\u0275template":S,"\u0275\u0275text":T,"\u0275\u0275textInterpolate":kt,"\u0275\u0275textInterpolate1":Ve,"\u0275\u0275textInterpolate2":lu,"\u0275\u0275textInterpolate3":GM,"\u0275\u0275textInterpolate4":function MU(n,t,e,i,r,o,a,s,l){let c=Ze(),d=_f(c,n,t,e,i,r,o,a,s,l);return d!==zn&&od(c,da(),d),MU},"\u0275\u0275textInterpolate5":function wU(n,t,e,i,r,o,a,s,l,c,d){let u=Ze(),p=bf(u,n,t,e,i,r,o,a,s,l,c,d);return p!==zn&&od(u,da(),p),wU},"\u0275\u0275textInterpolate6":function SU(n,t,e,i,r,o,a,s,l,c,d,u,p){let h=Ze(),m=vf(h,n,t,e,i,r,o,a,s,l,c,d,u,p);return m!==zn&&od(h,da(),m),SU},"\u0275\u0275textInterpolate7":function EU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m){let _=Ze(),M=yf(_,n,t,e,i,r,o,a,s,l,c,d,u,p,h,m);return M!==zn&&od(_,da(),M),EU},"\u0275\u0275textInterpolate8":function TU(n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){let y=Ze(),x=xf(y,n,t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M);return x!==zn&&od(y,da(),x),TU},"\u0275\u0275textInterpolateV":function DU(n){let t=Ze(),e=hf(t,n);return e!==zn&&od(t,da(),e),DU},"\u0275\u0275i18n":XM,"\u0275\u0275i18nAttributes":function(n,t){let e=Ti(),i=nu(e.consts,t);!function(n,t,e){let r=Lo().index,o=[];if(n.firstCreatePass&&null===n.data[t]){for(let a=0;a<e.length;a+=2){let s=e[a],l=e[a+1];if(""!==l){if(Tce.test(l))throw new Error(`ICU expressions are not supported in attributes. Message: "${l}".`);W_(o,l,r,s,Nce(o),null)}}n.data[t]=o}}(e,n+Gr,i)},"\u0275\u0275i18nExp":vb,"\u0275\u0275i18nStart":ej,"\u0275\u0275i18nEnd":tj,"\u0275\u0275i18nApply":YM,"\u0275\u0275i18nPostprocess":QM,"\u0275\u0275resolveWindow":function(n){return n.ownerDocument.defaultView},"\u0275\u0275resolveDocument":su,"\u0275\u0275resolveBody":function(n){return n.ownerDocument.body},"\u0275\u0275setComponentScope":sb,"\u0275\u0275setNgModuleScope":function(n,t){return ru(()=>{let e=Zm(n,!0);e.declarations=t.declarations||ji,e.imports=t.imports||ji,e.exports=t.exports||ji})},"\u0275\u0275registerNgModuleType":q5,"\u0275\u0275sanitizeHtml":mk,"\u0275\u0275sanitizeStyle":function(n){let t=mb();return t?t.sanitize(Ur.STYLE,n)||"":wl(n,"Style")?Oa(n):jn(n)},"\u0275\u0275sanitizeResourceUrl":Cz,"\u0275\u0275sanitizeScript":function(n){let t=mb();if(t)return xH(t.sanitize(Ur.SCRIPT,n)||"");if(wl(n,"Script"))return xH(Oa(n));throw new xt(905,!1)},"\u0275\u0275sanitizeUrl":Vs,"\u0275\u0275sanitizeUrlOrResourceUrl":function(n,t,e){return function(n,t){return"src"===t&&("embed"===n||"frame"===n||"iframe"===n||"media"===n||"script"===n)||"href"===t&&("base"===n||"link"===n)?Cz:Vs}(t,e)(n)},"\u0275\u0275trustConstantHtml":function(n){return df(n[0])},"\u0275\u0275trustConstantResourceUrl":function(n){return function(n){return cz()?.createScriptURL(n)||n}(n[0])},"\u0275\u0275validateIframeAttribute":function(n,t,e){let i=Ze(),r=Pr(),o=ss(r,i);if(2===r.type&&"iframe"===t.toLowerCase()){let a=o;throw a.src="",a.srcdoc=df(""),ck(i[ui],a),new xt(-910,!1)}return n},forwardRef:Wn,resolveForwardRef:Ai},N_=null;function mj(n){return!!Zm(n)}var KC=[],DR=!1;function fj(n){return Array.isArray(n)?n.every(fj):!!Ai(n)}function Pde(n,t){let e=Jd(t.declarations||ji),i=nf(n);e.forEach(r=>{(r=Ai(r)).hasOwnProperty(EM)?gj(Os(r),i):!r.hasOwnProperty(zP)&&!r.hasOwnProperty(UP)&&(r.ngSelectorScope=n)})}function gj(n,t){n.directiveDefs=()=>Array.from(t.compilation.directives).map(e=>e.hasOwnProperty(EM)?Os(e):eu(e)).filter(e=>!!e),n.pipeDefs=()=>Array.from(t.compilation.pipes).map(e=>tu(e)),n.schemas=t.schemas,n.tView=null}function nf(n){if(mj(n))return function(n){let t=Zm(n,!0);if(null!==t.transitiveCompileScopes)return t.transitiveCompileScopes;let e={schemas:t.schemas||null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set}};return QC(t.imports).forEach(i=>{let r=nf(i);r.exported.directives.forEach(o=>e.compilation.directives.add(o)),r.exported.pipes.forEach(o=>e.compilation.pipes.add(o))}),QC(t.declarations).forEach(i=>{tu(i)?e.compilation.pipes.add(i):e.compilation.directives.add(i)}),QC(t.exports).forEach(i=>{let r=i;if(mj(r)){let o=nf(r);o.exported.directives.forEach(a=>{e.compilation.directives.add(a),e.exported.directives.add(a)}),o.exported.pipes.forEach(a=>{e.compilation.pipes.add(a),e.exported.pipes.add(a)})}else tu(r)?e.exported.pipes.add(r):e.exported.directives.add(r)}),t.transitiveCompileScopes=e,e}(n);if(l5(n)){if(null!==(Os(n)||eu(n)))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set([n]),pipes:new Set}};if(null!==tu(n))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set([n])}}}throw new Error(`${n.name} does not have a module def (\u0275mod property)`)}function qH(n){return function(n){return void 0!==n.ngModule}(n)?n.ngModule:n}var IR=0;function _j(n,t){let e=null;vj(n,t||{}),Object.defineProperty(n,zP,{get:()=>{if(null===e){let i=bj(n,t||{});e=Fs().compileDirective($d,i.sourceMapUrl,i.metadata)}return e},configurable:!1})}function bj(n,t){let e=n&&n.name,i=`ng:///${e}/\u0275dir.js`,r=Fs(),o=yj(n,t);return o.typeSourceSpan=r.createParseSourceSpan("Directive",e,i),o.usesInheritance&&xj(n),{metadata:o,sourceMapUrl:i}}function vj(n,t){let e=null;Object.defineProperty(n,Kc,{get:()=>{if(null===e){let i=bj(n,t),r=Fs();e=r.compileFactory($d,`ng:///${n.name}/\u0275fac.js`,{name:i.metadata.name,type:i.metadata.type,typeArgumentCount:0,deps:PM(n),target:r.FactoryTarget.Directive})}return e},configurable:!1})}function Lde(n){return Object.getPrototypeOf(n.prototype)===Object.prototype}function yj(n,t){let e=nk(),i=e.ownPropMetadata(n);return{name:n.name,type:n,selector:void 0!==t.selector?t.selector:null,host:t.host||Zc,propMetadata:i,inputs:t.inputs||ji,outputs:t.outputs||ji,queries:XH(n,i,Cj),lifecycle:{usesOnChanges:e.hasLifecycleHook(n,"ngOnChanges")},typeSourceSpan:null,usesInheritance:!Lde(n),exportAs:Hde(t.exportAs),providers:t.providers||null,viewQueries:XH(n,i,Mj),isStandalone:!!t.standalone,hostDirectives:t.hostDirectives?.map(r=>"function"==typeof r?{directive:r}:r)||null}}function xj(n){let t=Object.prototype,e=Object.getPrototypeOf(n.prototype).constructor;for(;e&&e!==t;)!eu(e)&&!Os(e)&&Ude(e)&&_j(e,null),e=Object.getPrototypeOf(e)}function Bde(n){return"string"==typeof n?Sj(n):Ai(n)}function Vde(n,t){return{propertyName:n,predicate:Bde(t.selector),descendants:t.descendants,first:t.first,read:t.read?t.read:null,static:!!t.static,emitDistinctChangesOnly:!!t.emitDistinctChangesOnly}}function XH(n,t,e){let i=[];for(let r in t)if(t.hasOwnProperty(r)){let o=t[r];o.forEach(a=>{if(e(a)){if(!a.selector)throw new Error(`Can't construct a query for the property "${r}" of "${BP(n)}" since the query selector wasn't defined.`);if(o.some(wj))throw new Error("Cannot combine @Input decorators with query decorators");i.push(Vde(r,a))}})}return i}function Hde(n){return void 0===n?null:Sj(n)}function Cj(n){let t=n.ngMetadataName;return"ContentChild"===t||"ContentChildren"===t}function Mj(n){let t=n.ngMetadataName;return"ViewChild"===t||"ViewChildren"===t}function wj(n){return"Input"===n.ngMetadataName}function Sj(n){return n.split(",").map(t=>t.trim())}var zde=["ngOnChanges","ngOnInit","ngOnDestroy","ngDoCheck","ngAfterViewInit","ngAfterViewChecked","ngAfterContentInit","ngAfterContentChecked"];function Ude(n){let t=nk();if(zde.some(i=>t.hasLifecycleHook(n,i)))return!0;let e=t.propMetadata(n);for(let i in e){let r=e[i];for(let o=0;o<r.length;o++){let a=r[o],s=a.ngMetadataName;if(wj(a)||Cj(a)||Mj(a)||"Output"===s||"HostBinding"===s||"HostListener"===s)return!0}}return!1}function YH(n,t){return{type:n,name:n.name,pipeName:t.name,pure:void 0===t.pure||t.pure,isStandalone:!!t.standalone}}var Gde=cb("Directive",(n={})=>n,void 0,void 0,(n,t)=>_j(n,t));function xM(...n){}cb("Component",(n={})=>({changeDetection:B_.Default,...n}),Gde,void 0,(n,t)=>function(n,t){let e=null;(function(n,t){W5(t)&&(J_.set(n,t),G5.add(n))})(n,t),vj(n,t),Object.defineProperty(n,EM,{get:()=>{if(null===e){let i=Fs();if(W5(t)){let c=[`Component '${n.name}' is not resolved:`];throw t.templateUrl&&c.push(` - templateUrl: ${t.templateUrl}`),t.styleUrls&&t.styleUrls.length&&c.push(` - styleUrls: ${JSON.stringify(t.styleUrls)}`),c.push("Did you run and wait for 'resolveComponentResources()'?"),new Error(c.join("\n"))}let o=t.preserveWhitespaces;void 0===o&&(o=null!==N_&&void 0!==N_.preserveWhitespaces&&N_.preserveWhitespaces);let a=t.encapsulation;void 0===a&&(a=null!==N_&&void 0!==N_.defaultEncapsulation?N_.defaultEncapsulation:as.Emulated);let s=t.templateUrl||`ng:///${n.name}/template.html`,l={...yj(n,t),typeSourceSpan:i.createParseSourceSpan("Component",n.name,s),template:t.template||"",preserveWhitespaces:o,styles:t.styles||ji,animations:t.animations,declarations:[],changeDetection:t.changeDetection,encapsulation:a,interpolation:t.interpolation,viewProviders:t.viewProviders||null};IR++;try{if(l.usesInheritance&&xj(n),e=i.compileComponent($d,s,l),t.standalone){let c=Jd(t.imports||ji),{directiveDefs:d,pipeDefs:u}=function(n,t){let e=null,i=null;return{directiveDefs:()=>{if(null===e){e=[Os(n)];let a=new Set;for(let s of t){let l=Ai(s);if(!a.has(l))if(a.add(l),Zm(l)){let c=nf(l);for(let d of c.exported.directives){let u=Os(d)||eu(d);u&&!a.has(d)&&(a.add(d),e.push(u))}}else{let c=Os(l)||eu(l);c&&e.push(c)}}}return e},pipeDefs:()=>{if(null===i){i=[];let a=new Set;for(let s of t){let l=Ai(s);if(!a.has(l))if(a.add(l),Zm(l)){let c=nf(l);for(let d of c.exported.pipes){let u=tu(d);u&&!a.has(d)&&(a.add(d),i.push(u))}}else{let c=tu(l);c&&i.push(c)}}}return i}}}(n,c);e.directiveDefs=d,e.pipeDefs=u,e.dependencies=()=>c.map(Ai)}}finally{IR--}if(0===IR&&function(){if(!DR){DR=!0;try{for(let n=KC.length-1;n>=0;n--){let{moduleType:t,ngModule:e}=KC[n];e.declarations&&e.declarations.every(fj)&&(KC.splice(n,1),Pde(t,e))}}finally{DR=!1}}}(),function(n){return void 0!==n.ngSelectorScope}(n)){let c=nf(n.ngSelectorScope);gj(e,c)}if(t.schemas){if(!t.standalone)throw new Error(`The 'schemas' was specified for the ${BP(n)} but is only valid on a component that is standalone.`);e.schemas=t.schemas}else t.standalone&&(e.schemas=[])}return e},configurable:!1})}(n,t)),cb("Pipe",n=>({pure:!0,...n}),void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;Object.defineProperty(n,Kc,{get:()=>{if(null===i){let r=YH(n,t),o=Fs();i=o.compileFactory($d,`ng:///${r.name}/\u0275fac.js`,{name:r.name,type:r.type,typeArgumentCount:0,deps:PM(n),target:o.FactoryTarget.Pipe})}return i},configurable:!1}),Object.defineProperty(n,UP,{get:()=>{if(null===e){let r=YH(n,t);e=Fs().compilePipe($d,`ng:///${r.name}/\u0275pipe.js`,r)}return e},configurable:!1})}(n,t)),au("Input",n=>({bindingPropertyName:n})),au("Output",n=>({bindingPropertyName:n})),au("HostBinding",n=>({hostPropertyName:n})),au("HostListener",(n,t)=>({eventName:n,args:t})),cb("NgModule",n=>n,void 0,void 0,(n,t)=>function(n,t={}){(function(n,t,e=!1){let i=Jd(t.declarations||ji),r=null;Object.defineProperty(n,s5,{configurable:!0,get:()=>(null===r&&(r=Fs().compileNgModule($d,`ng:///${n.name}/\u0275mod.js`,{type:n,bootstrap:Jd(t.bootstrap||ji).map(Ai),declarations:i.map(Ai),imports:Jd(t.imports||ji).map(Ai).map(qH),exports:Jd(t.exports||ji).map(Ai).map(qH),schemas:t.schemas?Jd(t.schemas):null,id:t.id||null}),r.schemas||(r.schemas=[])),r)});let o=null;Object.defineProperty(n,Kc,{get:()=>{if(null===o){let s=Fs();o=s.compileFactory($d,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,deps:PM(n),target:s.FactoryTarget.NgModule,typeArgumentCount:0})}return o},configurable:!1});let a=null;Object.defineProperty(n,PR,{get:()=>{if(null===a){let s={name:n.name,type:n,providers:t.providers||ji,imports:[(t.imports||ji).map(Ai),(t.exports||ji).map(Ai)]};a=Fs().compileInjector($d,`ng:///${n.name}/\u0275inj.js`,s)}return a},configurable:!1})})(n,t),void 0!==t.id&&q5(n,t.id),function(n,t){KC.push({moduleType:n,ngModule:t})}(n,t)}(n,t));var Ok=new te("Application Initializer"),KM=(()=>{class n{constructor(e){this.appInits=e,this.resolve=xM,this.reject=xM,this.initialized=!1,this.done=!1,this.donePromise=new Promise((i,r)=>{this.resolve=i,this.reject=r})}runInitializers(){if(this.initialized)return;let e=[],i=()=>{this.done=!0,this.resolve()};if(this.appInits)for(let r=0;r<this.appInits.length;r++){let o=this.appInits[r]();if(Cf(o))e.push(o);else if(Ik(o)){let a=new Promise((s,l)=>{o.subscribe({complete:s,error:l})});e.push(a)}}Promise.all(e).then(()=>{i()}).catch(r=>{this.reject(r)}),0===e.length&&i(),this.initialized=!0}}return n.\u0275fac=function(e){return new(e||n)(O(Ok,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),$p=new te("AppId",{providedIn:"root",factory:function(){return`${AR()}${AR()}${AR()}`}});function AR(){return String.fromCharCode(97+Math.floor(25*Math.random()))}var Fk=new te("Platform Initializer"),fc=new te("Platform ID",{providedIn:"platform",factory:()=>"unknown"}),pi=(new te("Application Packages Root URL"),new te("AnimationModuleType")),ad=new te("LocaleId",{providedIn:"root",factory:()=>$n(ad,Ci.Optional|Ci.SkipSelf)||typeof $localize<"u"&&$localize.locale||bM}),Qde=(new te("DefaultCurrencyCode",{providedIn:"root",factory:()=>"USD"}),new te("Translations"),new te("TranslationsFormat"),new te("compilerOptions"),Promise.resolve(0));function IP(n){typeof Zone>"u"?Qde.then(()=>{n&&n.apply(null,null)}):Zone.current.scheduleMicroTask("scheduleMicrotask",n)}var ot=class{constructor({enableLongStackTrace:t=!1,shouldCoalesceEventChangeDetection:e=!1,shouldCoalesceRunChangeDetection:i=!1}){if(this.hasPendingMacrotasks=!1,this.hasPendingMicrotasks=!1,this.isStable=!0,this.onUnstable=new F(!1),this.onMicrotaskEmpty=new F(!1),this.onStable=new F(!1),this.onError=new F(!1),typeof Zone>"u")throw new xt(908,!1);Zone.assertZonePatched();let r=this;r._nesting=0,r._outer=r._inner=Zone.current,Zone.TaskTrackingZoneSpec&&(r._inner=r._inner.fork(new Zone.TaskTrackingZoneSpec)),t&&Zone.longStackTraceZoneSpec&&(r._inner=r._inner.fork(Zone.longStackTraceZoneSpec)),r.shouldCoalesceEventChangeDetection=!i&&e,r.shouldCoalesceRunChangeDetection=i,r.lastRequestAnimationFrameId=-1,r.nativeRequestAnimationFrame=function(){let n=zr.requestAnimationFrame,t=zr.cancelAnimationFrame;if(typeof Zone<"u"&&n&&t){let e=n[Zone.__symbol__("OriginalDelegate")];e&&(n=e);let i=t[Zone.__symbol__("OriginalDelegate")];i&&(t=i)}return{nativeRequestAnimationFrame:n,nativeCancelAnimationFrame:t}}().nativeRequestAnimationFrame,function(n){let t=()=>{!function(n){n.isCheckStableRunning||-1!==n.lastRequestAnimationFrameId||(n.lastRequestAnimationFrameId=n.nativeRequestAnimationFrame.call(zr,()=>{n.fakeTopEventTask||(n.fakeTopEventTask=Zone.root.scheduleEventTask("fakeTopEventTask",()=>{n.lastRequestAnimationFrameId=-1,AP(n),n.isCheckStableRunning=!0,Nk(n),n.isCheckStableRunning=!1},void 0,()=>{},()=>{})),n.fakeTopEventTask.invoke()}),AP(n))}(n)};n._inner=n._inner.fork({name:"angular",properties:{isAngularZone:!0},onInvokeTask:(e,i,r,o,a,s)=>{try{return QH(n),e.invokeTask(r,o,a,s)}finally{(n.shouldCoalesceEventChangeDetection&&"eventTask"===o.type||n.shouldCoalesceRunChangeDetection)&&t(),ZH(n)}},onInvoke:(e,i,r,o,a,s,l)=>{try{return QH(n),e.invoke(r,o,a,s,l)}finally{n.shouldCoalesceRunChangeDetection&&t(),ZH(n)}},onHasTask:(e,i,r,o)=>{e.hasTask(r,o),i===r&&("microTask"==o.change?(n._hasPendingMicrotasks=o.microTask,AP(n),Nk(n)):"macroTask"==o.change&&(n.hasPendingMacrotasks=o.macroTask))},onHandleError:(e,i,r,o)=>(e.handleError(r,o),n.runOutsideAngular(()=>n.onError.emit(o)),!1)})}(r)}static isInAngularZone(){return typeof Zone<"u"&&!0===Zone.current.get("isAngularZone")}static assertInAngularZone(){if(!ot.isInAngularZone())throw new xt(909,!1)}static assertNotInAngularZone(){if(ot.isInAngularZone())throw new xt(909,!1)}run(t,e,i){return this._inner.run(t,e,i)}runTask(t,e,i,r){let o=this._inner,a=o.scheduleEventTask("NgZoneEvent: "+r,t,Kde,xM,xM);try{return o.runTask(a,e,i)}finally{o.cancelTask(a)}}runGuarded(t,e,i){return this._inner.runGuarded(t,e,i)}runOutsideAngular(t){return this._outer.run(t)}},Kde={};function Nk(n){if(0==n._nesting&&!n.hasPendingMicrotasks&&!n.isStable)try{n._nesting++,n.onMicrotaskEmpty.emit(null)}finally{if(n._nesting--,!n.hasPendingMicrotasks)try{n.runOutsideAngular(()=>n.onStable.emit(null))}finally{n.isStable=!0}}}function AP(n){n.hasPendingMicrotasks=!!(n._hasPendingMicrotasks||(n.shouldCoalesceEventChangeDetection||n.shouldCoalesceRunChangeDetection)&&-1!==n.lastRequestAnimationFrameId)}function QH(n){n._nesting++,n.isStable&&(n.isStable=!1,n.onUnstable.emit(null))}function ZH(n){n._nesting--,Nk(n)}var Bk,Lk=new te(""),Mb=new te(""),JM=(()=>{class n{constructor(e,i,r){this._ngZone=e,this.registry=i,this._pendingCount=0,this._isZoneStable=!0,this._didWork=!1,this._callbacks=[],this.taskTrackingZone=null,Bk||(function(n){Bk=n}(r),r.addToWindow(i)),this._watchAngularEvents(),e.run(()=>{this.taskTrackingZone=typeof Zone>"u"?null:Zone.current.get("TaskTrackingZone")})}_watchAngularEvents(){this._ngZone.onUnstable.subscribe({next:()=>{this._didWork=!0,this._isZoneStable=!1}}),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.subscribe({next:()=>{ot.assertNotInAngularZone(),IP(()=>{this._isZoneStable=!0,this._runCallbacksIfReady()})}})})}increasePendingRequestCount(){return this._pendingCount+=1,this._didWork=!0,this._pendingCount}decreasePendingRequestCount(){if(this._pendingCount-=1,this._pendingCount<0)throw new Error("pending async requests below zero");return this._runCallbacksIfReady(),this._pendingCount}isStable(){return this._isZoneStable&&0===this._pendingCount&&!this._ngZone.hasPendingMacrotasks}_runCallbacksIfReady(){if(this.isStable())IP(()=>{for(;0!==this._callbacks.length;){let e=this._callbacks.pop();clearTimeout(e.timeoutId),e.doneCb(this._didWork)}this._didWork=!1});else{let e=this.getPendingTasks();this._callbacks=this._callbacks.filter(i=>!i.updateCb||!i.updateCb(e)||(clearTimeout(i.timeoutId),!1)),this._didWork=!0}}getPendingTasks(){return this.taskTrackingZone?this.taskTrackingZone.macroTasks.map(e=>({source:e.source,creationLocation:e.creationLocation,data:e.data})):[]}addCallback(e,i,r){let o=-1;i&&i>0&&(o=setTimeout(()=>{this._callbacks=this._callbacks.filter(a=>a.timeoutId!==o),e(this._didWork,this.getPendingTasks())},i)),this._callbacks.push({doneCb:e,timeoutId:o,updateCb:r})}whenStable(e,i,r){if(r&&!this.taskTrackingZone)throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');this.addCallback(e,i,r),this._runCallbacksIfReady()}getPendingRequestCount(){return this._pendingCount}registerApplication(e){this.registry.registerApplication(e,this)}unregisterApplication(e){this.registry.unregisterApplication(e)}findProviders(e,i,r){return[]}}return n.\u0275fac=function(e){return new(e||n)(O(ot),O($M),O(Mb))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),$M=(()=>{class n{constructor(){this._applications=new Map}registerApplication(e,i){this._applications.set(e,i)}unregisterApplication(e){this._applications.delete(e)}unregisterAllApplications(){this._applications.clear()}getTestability(e){return this._applications.get(e)||null}getAllTestabilities(){return Array.from(this._applications.values())}getAllRootElements(){return Array.from(this._applications.keys())}findTestabilityInTree(e,i=!0){return Bk?.findTestabilityInTree(this,e,i)??null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})(),q_=null,Ej=new te("AllowMultipleToken"),Tj=new te("PlatformDestroyListeners"),tue=new te("appBootstrapListener");function Vk(n,t,e=[]){let i=`Platform: ${t}`,r=new te(i);return(o=[])=>{let a=Dj();if(!a||a.injector.get(Ej,!1)){let s=[...e,...o,{provide:r,useValue:!0}];n?n(s):function(n){if(q_&&!q_.get(Ej,!1))throw new xt(400,!1);q_=n;let t=n.get(Ij);(function(n){let t=n.get(Fk,null);t&&t.forEach(e=>e())})(n)}(function(n=[],t){return wi.create({name:t,providers:[{provide:LM,useValue:"platform"},{provide:Tj,useValue:new Set([()=>q_=null])},...n]})}(s,i))}return function(n){let t=Dj();if(!t)throw new xt(401,!1);return t}()}}function Dj(){return q_?.get(Ij)??null}var Ij=(()=>{class n{constructor(e){this._injector=e,this._modules=[],this._destroyListeners=[],this._destroyed=!1}bootstrapModuleFactory(e,i){let r=function(n,t){let e;return e="noop"===n?new class{constructor(){this.hasPendingMicrotasks=!1,this.hasPendingMacrotasks=!1,this.isStable=!0,this.onUnstable=new F,this.onMicrotaskEmpty=new F,this.onStable=new F,this.onError=new F}run(t,e,i){return t.apply(e,i)}runGuarded(t,e,i){return t.apply(e,i)}runOutsideAngular(t){return t()}runTask(t,e,i,r){return t.apply(e,i)}}:("zone.js"===n?void 0:n)||new ot(t),e}(i?.ngZone,function(n){return{enableLongStackTrace:!1,shouldCoalesceEventChangeDetection:!(!n||!n.ngZoneEventCoalescing)||!1,shouldCoalesceRunChangeDetection:!(!n||!n.ngZoneRunCoalescing)||!1}}(i)),o=[{provide:ot,useValue:r}];return r.run(()=>{let a=wi.create({providers:o,parent:this.injector,name:e.moduleType.name}),s=e.create(a),l=s.injector.get(la,null);if(!l)throw new xt(402,!1);return r.runOutsideAngular(()=>{let c=r.onError.subscribe({next:d=>{l.handleError(d)}});s.onDestroy(()=>{JC(this._modules,s),c.unsubscribe()})}),function(n,t,e){try{let i=e();return Cf(i)?i.catch(r=>{throw t.runOutsideAngular(()=>n.handleError(r)),r}):i}catch(i){throw t.runOutsideAngular(()=>n.handleError(i)),i}}(l,r,()=>{let c=s.injector.get(KM);return c.runInitializers(),c.donePromise.then(()=>(function(n){(function(n,t){null==n&&i5("Expected localeId to be defined",n,null,"!=")})(n),"string"==typeof n&&(zU=n.toLowerCase().replace(/_/g,"-"))}(s.injector.get(ad,bM)||bM),this._moduleDoBootstrap(s),s))})})}bootstrapModule(e,i=[]){let r=Aj({},i);return function(n,t,e){let i=new SP(e);return Promise.resolve(i)}(0,0,e).then(o=>this.bootstrapModuleFactory(o,r))}_moduleDoBootstrap(e){let i=e.injector.get(gc);if(e._bootstrapComponents.length>0)e._bootstrapComponents.forEach(r=>i.bootstrap(r));else{if(!e.instance.ngDoBootstrap)throw new xt(-403,!1);e.instance.ngDoBootstrap(i)}this._modules.push(e)}onDestroy(e){this._destroyListeners.push(e)}get injector(){return this._injector}destroy(){if(this._destroyed)throw new xt(404,!1);this._modules.slice().forEach(i=>i.destroy()),this._destroyListeners.forEach(i=>i());let e=this._injector.get(Tj,null);e&&(e.forEach(i=>i()),e.clear()),this._destroyed=!0}get destroyed(){return this._destroyed}}return n.\u0275fac=function(e){return new(e||n)(O(wi))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})();function Aj(n,t){return Array.isArray(t)?t.reduce(Aj,n):{...n,...t}}var gc=(()=>{class n{get destroyed(){return this._destroyed}get injector(){return this._injector}constructor(e,i,r){this._zone=e,this._injector=i,this._exceptionHandler=r,this._bootstrapListeners=[],this._views=[],this._runningTick=!1,this._stable=!0,this._destroyed=!1,this._destroyListeners=[],this.componentTypes=[],this.components=[],this._onMicrotaskEmptySubscription=this._zone.onMicrotaskEmpty.subscribe({next:()=>{this._zone.run(()=>{this.tick()})}});let o=new Kt(s=>{this._stable=this._zone.isStable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks,this._zone.runOutsideAngular(()=>{s.next(this._stable),s.complete()})}),a=new Kt(s=>{let l;this._zone.runOutsideAngular(()=>{l=this._zone.onStable.subscribe(()=>{ot.assertNotInAngularZone(),IP(()=>{!this._stable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks&&(this._stable=!0,s.next(!0))})})});let c=this._zone.onUnstable.subscribe(()=>{ot.assertInAngularZone(),this._stable&&(this._stable=!1,this._zone.runOutsideAngular(()=>{s.next(!1)}))});return()=>{l.unsubscribe(),c.unsubscribe()}});this.isStable=tn(o,a.pipe(Ta()))}bootstrap(e,i){let a,r=e instanceof hM;if(!this._injector.get(KM).done)throw!r&&l5(e),new xt(405,false);a=r?e:this._injector.get(ho).resolveComponentFactory(e),this.componentTypes.push(a.componentType);let s=function(n){return n.isBoundToModule}(a)?void 0:this._injector.get(iu),c=a.create(wi.NULL,[],i||a.selector,s),d=c.location.nativeElement,u=c.injector.get(Lk,null);return u?.registerApplication(d),c.onDestroy(()=>{this.detachView(c.hostView),JC(this.components,c),u?.unregisterApplication(d)}),this._loadComponent(c),c}tick(){if(this._runningTick)throw new xt(101,!1);try{this._runningTick=!0;for(let e of this._views)e.detectChanges()}catch(e){this._zone.runOutsideAngular(()=>this._exceptionHandler.handleError(e))}finally{this._runningTick=!1}}attachView(e){let i=e;this._views.push(i),i.attachToAppRef(this)}detachView(e){let i=e;JC(this._views,i),i.detachFromAppRef()}_loadComponent(e){this.attachView(e.hostView),this.tick(),this.components.push(e);let i=this._injector.get(tue,[]);i.push(...this._bootstrapListeners),i.forEach(r=>r(e))}ngOnDestroy(){if(!this._destroyed)try{this._destroyListeners.forEach(e=>e()),this._views.slice().forEach(e=>e.destroy()),this._onMicrotaskEmptySubscription.unsubscribe()}finally{this._destroyed=!0,this._views=[],this._bootstrapListeners=[],this._destroyListeners=[]}}onDestroy(e){return this._destroyListeners.push(e),()=>JC(this._destroyListeners,e)}destroy(){if(this._destroyed)throw new xt(406,!1);let e=this._injector;e.destroy&&!e.destroyed&&e.destroy()}get viewCount(){return this._views.length}warnIfDestroyed(){}}return n.\u0275fac=function(e){return new(e||n)(O(ot),O(lc),O(la))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function JC(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}var Qt=(()=>{class n{}return n.__NG_ELEMENT_ID__=pue,n})();function pue(n){return function(n,t,e){if(DM(n)&&!e){let i=ed(n.index,t);return new Qp(i,i)}return 47&n.type?new Qp(t[xl],t):null}(Lo(),Ze(),16==(16&n))}var CM=class{constructor(){}supports(t){return Zz(t)}create(t){return new PP(t)}},mue=(n,t)=>t,PP=class{constructor(t){this.length=0,this._linkedRecords=null,this._unlinkedRecords=null,this._previousItHead=null,this._itHead=null,this._itTail=null,this._additionsHead=null,this._additionsTail=null,this._movesHead=null,this._movesTail=null,this._removalsHead=null,this._removalsTail=null,this._identityChangesHead=null,this._identityChangesTail=null,this._trackByFn=t||mue}forEachItem(t){let e;for(e=this._itHead;null!==e;e=e._next)t(e)}forEachOperation(t){let e=this._itHead,i=this._removalsHead,r=0,o=null;for(;e||i;){let a=!i||e&&e.currentIndex<JH(i,r,o)?e:i,s=JH(a,r,o),l=a.currentIndex;if(a===i)r--,i=i._nextRemoved;else if(e=e._next,null==a.previousIndex)r++;else{o||(o=[]);let c=s-r,d=l-r;if(c!=d){for(let p=0;p<c;p++){let h=p<o.length?o[p]:o[p]=0,m=h+p;d<=m&&m<c&&(o[p]=h+1)}o[a.previousIndex]=d-c}}s!==l&&t(a,s,l)}}forEachPreviousItem(t){let e;for(e=this._previousItHead;null!==e;e=e._nextPrevious)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachMovedItem(t){let e;for(e=this._movesHead;null!==e;e=e._nextMoved)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}forEachIdentityChange(t){let e;for(e=this._identityChangesHead;null!==e;e=e._nextIdentityChange)t(e)}diff(t){if(null==t&&(t=[]),!Zz(t))throw new xt(900,!1);return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let r,o,a,e=this._itHead,i=!1;if(Array.isArray(t)){this.length=t.length;for(let s=0;s<this.length;s++)o=t[s],a=this._trackByFn(s,o),null!==e&&Object.is(e.trackById,a)?(i&&(e=this._verifyReinsertion(e,o,a,s)),Object.is(e.item,o)||this._addIdentityChange(e,o)):(e=this._mismatch(e,o,a,s),i=!0),e=e._next}else r=0,function(n,t){if(Array.isArray(n))for(let e=0;e<n.length;e++)t(n[e]);else{let i,e=n[Symbol.iterator]();for(;!(i=e.next()).done;)t(i.value)}}(t,s=>{a=this._trackByFn(r,s),null!==e&&Object.is(e.trackById,a)?(i&&(e=this._verifyReinsertion(e,s,a,r)),Object.is(e.item,s)||this._addIdentityChange(e,s)):(e=this._mismatch(e,s,a,r),i=!0),e=e._next,r++}),this.length=r;return this._truncate(e),this.collection=t,this.isDirty}get isDirty(){return null!==this._additionsHead||null!==this._movesHead||null!==this._removalsHead||null!==this._identityChangesHead}_reset(){if(this.isDirty){let t;for(t=this._previousItHead=this._itHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._additionsHead;null!==t;t=t._nextAdded)t.previousIndex=t.currentIndex;for(this._additionsHead=this._additionsTail=null,t=this._movesHead;null!==t;t=t._nextMoved)t.previousIndex=t.currentIndex;this._movesHead=this._movesTail=null,this._removalsHead=this._removalsTail=null,this._identityChangesHead=this._identityChangesTail=null}}_mismatch(t,e,i,r){let o;return null===t?o=this._itTail:(o=t._prev,this._remove(t)),null!==(t=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._reinsertAfter(t,o,r)):null!==(t=null===this._linkedRecords?null:this._linkedRecords.get(i,r))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._moveAfter(t,o,r)):t=this._addAfter(new kP(e,i),o,r),t}_verifyReinsertion(t,e,i,r){let o=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null);return null!==o?t=this._reinsertAfter(o,t._prev,r):t.currentIndex!=r&&(t.currentIndex=r,this._addToMoves(t,r)),t}_truncate(t){for(;null!==t;){let e=t._next;this._addToRemovals(this._unlink(t)),t=e}null!==this._unlinkedRecords&&this._unlinkedRecords.clear(),null!==this._additionsTail&&(this._additionsTail._nextAdded=null),null!==this._movesTail&&(this._movesTail._nextMoved=null),null!==this._itTail&&(this._itTail._next=null),null!==this._removalsTail&&(this._removalsTail._nextRemoved=null),null!==this._identityChangesTail&&(this._identityChangesTail._nextIdentityChange=null)}_reinsertAfter(t,e,i){null!==this._unlinkedRecords&&this._unlinkedRecords.remove(t);let r=t._prevRemoved,o=t._nextRemoved;return null===r?this._removalsHead=o:r._nextRemoved=o,null===o?this._removalsTail=r:o._prevRemoved=r,this._insertAfter(t,e,i),this._addToMoves(t,i),t}_moveAfter(t,e,i){return this._unlink(t),this._insertAfter(t,e,i),this._addToMoves(t,i),t}_addAfter(t,e,i){return this._insertAfter(t,e,i),this._additionsTail=null===this._additionsTail?this._additionsHead=t:this._additionsTail._nextAdded=t,t}_insertAfter(t,e,i){let r=null===e?this._itHead:e._next;return t._next=r,t._prev=e,null===r?this._itTail=t:r._prev=t,null===e?this._itHead=t:e._next=t,null===this._linkedRecords&&(this._linkedRecords=new MM),this._linkedRecords.put(t),t.currentIndex=i,t}_remove(t){return this._addToRemovals(this._unlink(t))}_unlink(t){null!==this._linkedRecords&&this._linkedRecords.remove(t);let e=t._prev,i=t._next;return null===e?this._itHead=i:e._next=i,null===i?this._itTail=e:i._prev=e,t}_addToMoves(t,e){return t.previousIndex===e||(this._movesTail=null===this._movesTail?this._movesHead=t:this._movesTail._nextMoved=t),t}_addToRemovals(t){return null===this._unlinkedRecords&&(this._unlinkedRecords=new MM),this._unlinkedRecords.put(t),t.currentIndex=null,t._nextRemoved=null,null===this._removalsTail?(this._removalsTail=this._removalsHead=t,t._prevRemoved=null):(t._prevRemoved=this._removalsTail,this._removalsTail=this._removalsTail._nextRemoved=t),t}_addIdentityChange(t,e){return t.item=e,this._identityChangesTail=null===this._identityChangesTail?this._identityChangesHead=t:this._identityChangesTail._nextIdentityChange=t,t}},kP=class{constructor(t,e){this.item=t,this.trackById=e,this.currentIndex=null,this.previousIndex=null,this._nextPrevious=null,this._prev=null,this._next=null,this._prevDup=null,this._nextDup=null,this._prevRemoved=null,this._nextRemoved=null,this._nextAdded=null,this._nextMoved=null,this._nextIdentityChange=null}},MM=class{constructor(){this.map=new Map}put(t){let e=t.trackById,i=this.map.get(e);i||(i=new class{constructor(){this._head=null,this._tail=null}add(t){null===this._head?(this._head=this._tail=t,t._nextDup=null,t._prevDup=null):(this._tail._nextDup=t,t._prevDup=this._tail,t._nextDup=null,this._tail=t)}get(t,e){let i;for(i=this._head;null!==i;i=i._nextDup)if((null===e||e<=i.currentIndex)&&Object.is(i.trackById,t))return i;return null}remove(t){let e=t._prevDup,i=t._nextDup;return null===e?this._head=i:e._nextDup=i,null===i?this._tail=e:i._prevDup=e,null===this._head}},this.map.set(e,i)),i.add(t)}get(t,e){let r=this.map.get(t);return r?r.get(t,e):null}remove(t){let e=t.trackById;return this.map.get(e).remove(t)&&this.map.delete(e),t}get isEmpty(){return 0===this.map.size}clear(){this.map.clear()}};function JH(n,t,e){let i=n.previousIndex;if(null===i)return i;let r=0;return e&&i<e.length&&(r=e[i]),i+t+r}var wM=class{constructor(){}supports(t){return t instanceof Map||Tk(t)}create(){return new FP}},FP=class{constructor(){this._records=new Map,this._mapHead=null,this._appendAfter=null,this._previousMapHead=null,this._changesHead=null,this._changesTail=null,this._additionsHead=null,this._additionsTail=null,this._removalsHead=null,this._removalsTail=null}get isDirty(){return null!==this._additionsHead||null!==this._changesHead||null!==this._removalsHead}forEachItem(t){let e;for(e=this._mapHead;null!==e;e=e._next)t(e)}forEachPreviousItem(t){let e;for(e=this._previousMapHead;null!==e;e=e._nextPrevious)t(e)}forEachChangedItem(t){let e;for(e=this._changesHead;null!==e;e=e._nextChanged)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}diff(t){if(t){if(!(t instanceof Map||Tk(t)))throw new xt(900,!1)}else t=new Map;return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let e=this._mapHead;if(this._appendAfter=null,this._forEach(t,(i,r)=>{if(e&&e.key===r)this._maybeAddToChanges(e,i),this._appendAfter=e,e=e._next;else{let o=this._getOrCreateRecordForKey(r,i);e=this._insertBeforeOrAppend(e,o)}}),e){e._prev&&(e._prev._next=null),this._removalsHead=e;for(let i=e;null!==i;i=i._nextRemoved)i===this._mapHead&&(this._mapHead=null),this._records.delete(i.key),i._nextRemoved=i._next,i.previousValue=i.currentValue,i.currentValue=null,i._prev=null,i._next=null}return this._changesTail&&(this._changesTail._nextChanged=null),this._additionsTail&&(this._additionsTail._nextAdded=null),this.isDirty}_insertBeforeOrAppend(t,e){if(t){let i=t._prev;return e._next=t,e._prev=i,t._prev=e,i&&(i._next=e),t===this._mapHead&&(this._mapHead=e),this._appendAfter=t,t}return this._appendAfter?(this._appendAfter._next=e,e._prev=this._appendAfter):this._mapHead=e,this._appendAfter=e,null}_getOrCreateRecordForKey(t,e){if(this._records.has(t)){let r=this._records.get(t);this._maybeAddToChanges(r,e);let o=r._prev,a=r._next;return o&&(o._next=a),a&&(a._prev=o),r._next=null,r._prev=null,r}let i=new NP(t);return this._records.set(t,i),i.currentValue=e,this._addToAdditions(i),i}_reset(){if(this.isDirty){let t;for(this._previousMapHead=this._mapHead,t=this._previousMapHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._changesHead;null!==t;t=t._nextChanged)t.previousValue=t.currentValue;for(t=this._additionsHead;null!=t;t=t._nextAdded)t.previousValue=t.currentValue;this._changesHead=this._changesTail=null,this._additionsHead=this._additionsTail=null,this._removalsHead=null}}_maybeAddToChanges(t,e){Object.is(e,t.currentValue)||(t.previousValue=t.currentValue,t.currentValue=e,this._addToChanges(t))}_addToAdditions(t){null===this._additionsHead?this._additionsHead=this._additionsTail=t:(this._additionsTail._nextAdded=t,this._additionsTail=t)}_addToChanges(t){null===this._changesHead?this._changesHead=this._changesTail=t:(this._changesTail._nextChanged=t,this._changesTail=t)}_forEach(t,e){t instanceof Map?t.forEach(e):Object.keys(t).forEach(i=>e(t[i],i))}},NP=class{constructor(t){this.key=t,this.previousValue=null,this.currentValue=null,this._nextPrevious=null,this._next=null,this._prev=null,this._nextAdded=null,this._nextRemoved=null,this._nextChanged=null}};function $H(){return new Tl([new CM])}var Tl=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(null!=i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||$H()),deps:[[n,new id,new ka]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(null!=i)return i;throw new xt(901,!1)}}return n.\u0275prov=ue({token:n,providedIn:"root",factory:$H}),n})();function e5(){return new Sb([new wM])}var Sb=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||e5()),deps:[[n,new id,new ka]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(i)return i;throw new xt(901,!1)}}return n.\u0275prov=ue({token:n,providedIn:"root",factory:e5}),n})(),fue=[new wM],gue=[new CM],Rj=(new Tl(gue),new Sb(fue),Vk(null,"core",[])),Pj=(()=>{class n{constructor(e){}}return n.\u0275fac=function(e){return new(e||n)(O(gc))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})();function ew(n){return"boolean"==typeof n?n:null!=n&&"false"!==n}var _ue=":",cu=class{static zero(){return new cu([0])}static one(){return new cu([1])}constructor(t){this.digits=t}clone(){return new cu(this.digits.slice())}add(t){let e=this.clone();return e.addToSelf(t),e}addToSelf(t){let e=Math.max(this.digits.length,t.digits.length),i=0;for(let r=0;r<e;r++){let o=i;r<this.digits.length&&(o+=this.digits[r]),r<t.digits.length&&(o+=t.digits[r]),o>=10?(this.digits[r]=o-10,i=1):(this.digits[r]=o,i=0)}i>0&&(this.digits[e]=1)}toString(){let t="";for(let e=this.digits.length-1;e>=0;e--)t+=this.digits[e];return t}},tw=class{constructor(t){this.powerOfTwos=[t]}getValue(){return this.powerOfTwos[0]}multiplyBy(t){let e=cu.zero();return this.multiplyByAndAddTo(t,e),e}multiplyByAndAddTo(t,e){for(let i=0;0!==t;t>>>=1,i++)if(1&t){let r=this.getMultipliedByPowerOfTwo(i);e.addToSelf(r)}}getMultipliedByPowerOfTwo(t){for(let e=this.powerOfTwos.length;e<=t;e++){let i=this.powerOfTwos[e-1];this.powerOfTwos[e]=i.add(i)}return this.powerOfTwos[t]}};new class{visitText(t,e){return t.value}visitContainer(t,e){return`[${t.children.map(i=>i.visit(this)).join(", ")}]`}visitIcu(t,e){let i=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.expression}, ${t.type}, ${i.join(", ")}}`}visitTagPlaceholder(t,e){return t.isVoid?`<ph tag name="${t.startName}"/>`:`<ph tag name="${t.startName}">${t.children.map(i=>i.visit(this)).join(", ")}</ph name="${t.closeName}">`}visitPlaceholder(t,e){return t.value?`<ph name="${t.name}">${t.value}</ph>`:`<ph name="${t.name}"/>`}visitIcuPlaceholder(t,e){return`<ph icu name="${t.name}">${t.value.visit(this)}</ph>`}},new class{constructor(t){this.base=t,this.exponents=[new tw(cu.one())]}toThePowerOf(t){for(let e=this.exponents.length;e<=t;e++){let i=this.exponents[e-1].multiplyBy(this.base);this.exponents[e]=new tw(i)}return this.exponents[t]}}(256);var nw=function(n,...t){if(nw.translate){let i=nw.translate(n,t);n=i[0],t=i[1]}let e=kj(n[0],n.raw[0]);for(let i=1;i<n.length;i++)e+=t[i-1]+kj(n[i],n.raw[i]);return e},vue=":";function kj(n,t){return t.charAt(0)===vue?n.substring(function(n,t){for(let e=1,i=1;e<n.length;e++,i++)if("\\"===t[i])i++;else if(n[e]===_ue)return e;throw new Error(`Unterminated $localize metadata block in "${t}".`)}(n,t)+1):n}(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)().$localize=nw;var Yk=null;function Al(){return Yk}var uw=class{},Nt=new te("DocumentToken"),Wj=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(){return O(qj)},providedIn:"platform"}),n})();new te("Location Initialized");var qj=(()=>{class n extends Wj{constructor(e){super(),this._doc=e,this._location=window.location,this._history=window.history}getBaseHrefFromDOM(){return Al().getBaseHref(this._doc)}onPopState(e){let i=Al().getGlobalEventTarget(this._doc,"window");return i.addEventListener("popstate",e,!1),()=>i.removeEventListener("popstate",e)}onHashChange(e){let i=Al().getGlobalEventTarget(this._doc,"window");return i.addEventListener("hashchange",e,!1),()=>i.removeEventListener("hashchange",e)}get href(){return this._location.href}get protocol(){return this._location.protocol}get hostname(){return this._location.hostname}get port(){return this._location.port}get pathname(){return this._location.pathname}get search(){return this._location.search}get hash(){return this._location.hash}set pathname(e){this._location.pathname=e}pushState(e,i,r){Fj()?this._history.pushState(e,i,r):this._location.hash=r}replaceState(e,i,r){Fj()?this._history.replaceState(e,i,r):this._location.hash=r}forward(){this._history.forward()}back(){this._history.back()}historyGo(e=0){this._history.go(e)}getState(){return this._history.state}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:function(){return new qj(O(Nt))},providedIn:"platform"}),n})();function Fj(){return!!window.history.pushState}function Xj(n,t){if(0==n.length)return t;if(0==t.length)return n;let e=0;return n.endsWith("/")&&e++,t.startsWith("/")&&e++,2==e?n+t.substring(1):1==e?n+t:n+"/"+t}function Nj(n){let t=n.match(/#|\?|$/),e=t&&t.index||n.length;return n.slice(0,e-("/"===n[e-1]?1:0))+n.slice(e)}function eh(n){return n&&"?"!==n[0]?"?"+n:n}var $k=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(){return $n(Mue)},providedIn:"root"}),n})(),Cue=new te("appBaseHref"),Mue=(()=>{class n extends $k{constructor(e,i){super(),this._platformLocation=e,this._removeListenerFns=[],this._baseHref=i??this._platformLocation.getBaseHrefFromDOM()??$n(Nt).location?.origin??""}ngOnDestroy(){for(;this._removeListenerFns.length;)this._removeListenerFns.pop()()}onPopState(e){this._removeListenerFns.push(this._platformLocation.onPopState(e),this._platformLocation.onHashChange(e))}getBaseHref(){return this._baseHref}prepareExternalUrl(e){return Xj(this._baseHref,e)}path(e=!1){let i=this._platformLocation.pathname+eh(this._platformLocation.search),r=this._platformLocation.hash;return r&&e?`${i}${r}`:i}pushState(e,i,r,o){let a=this.prepareExternalUrl(r+eh(o));this._platformLocation.pushState(e,i,a)}replaceState(e,i,r,o){let a=this.prepareExternalUrl(r+eh(o));this._platformLocation.replaceState(e,i,a)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}getState(){return this._platformLocation.getState()}historyGo(e=0){this._platformLocation.historyGo?.(e)}}return n.\u0275fac=function(e){return new(e||n)(O(Wj),O(Cue,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Db=(()=>{class n{constructor(e){this._subject=new F,this._urlChangeListeners=[],this._urlChangeSubscription=null,this._locationStrategy=e;let i=this._locationStrategy.getBaseHref();this._basePath=function(n){if(new RegExp("^(https?:)?//").test(n)){let[,e]=n.split(/\/\/[^\/]+/);return e}return n}(Nj(Lj(i))),this._locationStrategy.onPopState(r=>{this._subject.emit({url:this.path(!0),pop:!0,state:r.state,type:r.type})})}ngOnDestroy(){this._urlChangeSubscription?.unsubscribe(),this._urlChangeListeners=[]}path(e=!1){return this.normalize(this._locationStrategy.path(e))}getState(){return this._locationStrategy.getState()}isCurrentPathEqualTo(e,i=""){return this.path()==this.normalize(e+eh(i))}normalize(e){return n.stripTrailingSlash(function(n,t){if(!n||!t.startsWith(n))return t;let e=t.substring(n.length);return""===e||["/",";","?","#"].includes(e[0])?e:t}(this._basePath,Lj(e)))}prepareExternalUrl(e){return e&&"/"!==e[0]&&(e="/"+e),this._locationStrategy.prepareExternalUrl(e)}go(e,i="",r=null){this._locationStrategy.pushState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+eh(i)),r)}replaceState(e,i="",r=null){this._locationStrategy.replaceState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+eh(i)),r)}forward(){this._locationStrategy.forward()}back(){this._locationStrategy.back()}historyGo(e=0){this._locationStrategy.historyGo?.(e)}onUrlChange(e){return this._urlChangeListeners.push(e),this._urlChangeSubscription||(this._urlChangeSubscription=this.subscribe(i=>{this._notifyUrlChangeListeners(i.url,i.state)})),()=>{let i=this._urlChangeListeners.indexOf(e);this._urlChangeListeners.splice(i,1),0===this._urlChangeListeners.length&&(this._urlChangeSubscription?.unsubscribe(),this._urlChangeSubscription=null)}}_notifyUrlChangeListeners(e="",i){this._urlChangeListeners.forEach(r=>r(e,i))}subscribe(e,i,r){return this._subject.subscribe({next:e,error:i,complete:r})}}return n.normalizeQueryParams=eh,n.joinWithSlash=Xj,n.stripTrailingSlash=Nj,n.\u0275fac=function(e){return new(e||n)(O($k))},n.\u0275prov=ue({token:n,factory:function(){return new Db(O($k))},providedIn:"root"}),n})();function Lj(n){return n.replace(/\/index.html$/,"")}var cw=(()=>{return(n=cw||(cw={}))[n.Decimal=0]="Decimal",n[n.Percent=1]="Percent",n[n.Currency=2]="Currency",n[n.Scientific=3]="Scientific",cw;var n})(),Bo=(()=>{return(n=Bo||(Bo={}))[n.Format=0]="Format",n[n.Standalone=1]="Standalone",Bo;var n})(),Xi=(()=>{return(n=Xi||(Xi={}))[n.Narrow=0]="Narrow",n[n.Abbreviated=1]="Abbreviated",n[n.Wide=2]="Wide",n[n.Short=3]="Short",Xi;var n})(),pa=(()=>{return(n=pa||(pa={}))[n.Short=0]="Short",n[n.Medium=1]="Medium",n[n.Long=2]="Long",n[n.Full=3]="Full",pa;var n})(),Yo=(()=>{return(n=Yo||(Yo={}))[n.Decimal=0]="Decimal",n[n.Group=1]="Group",n[n.List=2]="List",n[n.PercentSign=3]="PercentSign",n[n.PlusSign=4]="PlusSign",n[n.MinusSign=5]="MinusSign",n[n.Exponential=6]="Exponential",n[n.SuperscriptingExponent=7]="SuperscriptingExponent",n[n.PerMille=8]="PerMille",n[n.Infinity=9]="Infinity",n[n.NaN=10]="NaN",n[n.TimeSeparator=11]="TimeSeparator",n[n.CurrencyDecimal=12]="CurrencyDecimal",n[n.CurrencyGroup=13]="CurrencyGroup",Yo;var n})();function iw(n,t){return zs(Fa(n)[hr.DateFormat],t)}function rw(n,t){return zs(Fa(n)[hr.TimeFormat],t)}function ow(n,t){return zs(Fa(n)[hr.DateTimeFormat],t)}function ld(n,t){let e=Fa(n),i=e[hr.NumberSymbols][t];if(typeof i>"u"){if(t===Yo.CurrencyDecimal)return e[hr.NumberSymbols][Yo.Decimal];if(t===Yo.CurrencyGroup)return e[hr.NumberSymbols][Yo.Group]}return i}function Yj(n){if(!n[hr.ExtraData])throw new Error(`Missing extra locale data for the locale "${n[hr.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`)}function zs(n,t){for(let e=t;e>-1;e--)if(typeof n[e]<"u")return n[e];throw new Error("Locale data API: locale data undefined")}function Uk(n){let[t,e]=n.split(":");return{hours:+t,minutes:+e}}var Fue=/^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/,Eb={},Nue=/((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/,Il=(()=>{return(n=Il||(Il={}))[n.Short=0]="Short",n[n.ShortGMT=1]="ShortGMT",n[n.Long=2]="Long",n[n.Extended=3]="Extended",Il;var n})(),Ii=(()=>{return(n=Ii||(Ii={}))[n.FullYear=0]="FullYear",n[n.Month=1]="Month",n[n.Date=2]="Date",n[n.Hours=3]="Hours",n[n.Minutes=4]="Minutes",n[n.Seconds=5]="Seconds",n[n.FractionalSeconds=6]="FractionalSeconds",n[n.Day=7]="Day",Ii;var n})(),Di=(()=>{return(n=Di||(Di={}))[n.DayPeriods=0]="DayPeriods",n[n.Days=1]="Days",n[n.Months=2]="Months",n[n.Eras=3]="Eras",Di;var n})();function Lue(n,t,e,i){let r=function(n){if(Bj(n))return n;if("number"==typeof n&&!isNaN(n))return new Date(n);if("string"==typeof n){if(n=n.trim(),/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(n)){let[r,o=1,a=1]=n.split("-").map(s=>+s);return pw(r,o-1,a)}let i,e=parseFloat(n);if(!isNaN(n-e))return new Date(e);if(i=n.match(Fue))return function(n){let t=new Date(0),e=0,i=0,r=n[8]?t.setUTCFullYear:t.setFullYear,o=n[8]?t.setUTCHours:t.setHours;n[9]&&(e=Number(n[9]+n[10]),i=Number(n[9]+n[11])),r.call(t,Number(n[1]),Number(n[2])-1,Number(n[3]));let a=Number(n[4]||0)-e,s=Number(n[5]||0)-i,l=Number(n[6]||0),c=Math.floor(1e3*parseFloat("0."+(n[7]||0)));return o.call(t,a,s,l,c),t}(i)}let t=new Date(n);if(!Bj(t))throw new Error(`Unable to convert "${n}" into a date`);return t}(n);t=sd(e,t)||t;let s,a=[];for(;t;){if(s=Nue.exec(t),!s){a.push(t);break}{a=a.concat(s.slice(1));let d=a.pop();if(!d)break;t=d}}let l=r.getTimezoneOffset();i&&(l=Zj(i,l),r=function(n,t,e){let r=n.getTimezoneOffset();return function(n,t){return(n=new Date(n.getTime())).setMinutes(n.getMinutes()+t),n}(n,-1*(Zj(t,r)-r))}(r,i));let c="";return a.forEach(d=>{let u=function(n){if(Gk[n])return Gk[n];let t;switch(n){case"G":case"GG":case"GGG":t=rr(Di.Eras,Xi.Abbreviated);break;case"GGGG":t=rr(Di.Eras,Xi.Wide);break;case"GGGGG":t=rr(Di.Eras,Xi.Narrow);break;case"y":t=$r(Ii.FullYear,1,0,!1,!0);break;case"yy":t=$r(Ii.FullYear,2,0,!0,!0);break;case"yyy":t=$r(Ii.FullYear,3,0,!1,!0);break;case"yyyy":t=$r(Ii.FullYear,4,0,!1,!0);break;case"Y":t=lw(1);break;case"YY":t=lw(2,!0);break;case"YYY":t=lw(3);break;case"YYYY":t=lw(4);break;case"M":case"L":t=$r(Ii.Month,1,1);break;case"MM":case"LL":t=$r(Ii.Month,2,1);break;case"MMM":t=rr(Di.Months,Xi.Abbreviated);break;case"MMMM":t=rr(Di.Months,Xi.Wide);break;case"MMMMM":t=rr(Di.Months,Xi.Narrow);break;case"LLL":t=rr(Di.Months,Xi.Abbreviated,Bo.Standalone);break;case"LLLL":t=rr(Di.Months,Xi.Wide,Bo.Standalone);break;case"LLLLL":t=rr(Di.Months,Xi.Narrow,Bo.Standalone);break;case"w":t=jk(1);break;case"ww":t=jk(2);break;case"W":t=jk(1,!0);break;case"d":t=$r(Ii.Date,1);break;case"dd":t=$r(Ii.Date,2);break;case"c":case"cc":t=$r(Ii.Day,1);break;case"ccc":t=rr(Di.Days,Xi.Abbreviated,Bo.Standalone);break;case"cccc":t=rr(Di.Days,Xi.Wide,Bo.Standalone);break;case"ccccc":t=rr(Di.Days,Xi.Narrow,Bo.Standalone);break;case"cccccc":t=rr(Di.Days,Xi.Short,Bo.Standalone);break;case"E":case"EE":case"EEE":t=rr(Di.Days,Xi.Abbreviated);break;case"EEEE":t=rr(Di.Days,Xi.Wide);break;case"EEEEE":t=rr(Di.Days,Xi.Narrow);break;case"EEEEEE":t=rr(Di.Days,Xi.Short);break;case"a":case"aa":case"aaa":t=rr(Di.DayPeriods,Xi.Abbreviated);break;case"aaaa":t=rr(Di.DayPeriods,Xi.Wide);break;case"aaaaa":t=rr(Di.DayPeriods,Xi.Narrow);break;case"b":case"bb":case"bbb":t=rr(Di.DayPeriods,Xi.Abbreviated,Bo.Standalone,!0);break;case"bbbb":t=rr(Di.DayPeriods,Xi.Wide,Bo.Standalone,!0);break;case"bbbbb":t=rr(Di.DayPeriods,Xi.Narrow,Bo.Standalone,!0);break;case"B":case"BB":case"BBB":t=rr(Di.DayPeriods,Xi.Abbreviated,Bo.Format,!0);break;case"BBBB":t=rr(Di.DayPeriods,Xi.Wide,Bo.Format,!0);break;case"BBBBB":t=rr(Di.DayPeriods,Xi.Narrow,Bo.Format,!0);break;case"h":t=$r(Ii.Hours,1,-12);break;case"hh":t=$r(Ii.Hours,2,-12);break;case"H":t=$r(Ii.Hours,1);break;case"HH":t=$r(Ii.Hours,2);break;case"m":t=$r(Ii.Minutes,1);break;case"mm":t=$r(Ii.Minutes,2);break;case"s":t=$r(Ii.Seconds,1);break;case"ss":t=$r(Ii.Seconds,2);break;case"S":t=$r(Ii.FractionalSeconds,1);break;case"SS":t=$r(Ii.FractionalSeconds,2);break;case"SSS":t=$r(Ii.FractionalSeconds,3);break;case"Z":case"ZZ":case"ZZZ":t=sw(Il.Short);break;case"ZZZZZ":t=sw(Il.Extended);break;case"O":case"OO":case"OOO":case"z":case"zz":case"zzz":t=sw(Il.ShortGMT);break;case"OOOO":case"ZZZZ":case"zzzz":t=sw(Il.Long);break;default:return null}return Gk[n]=t,t}(d);c+=u?u(r,e,l):"''"===d?"'":d.replace(/(^'|'$)/g,"").replace(/''/g,"'")}),c}function pw(n,t,e){let i=new Date(0);return i.setFullYear(n,t,e),i.setHours(0,0,0),i}function sd(n,t){let e=function(n){return Fa(n)[hr.LocaleId]}(n);if(Eb[e]=Eb[e]||{},Eb[e][t])return Eb[e][t];let i="";switch(t){case"shortDate":i=iw(n,pa.Short);break;case"mediumDate":i=iw(n,pa.Medium);break;case"longDate":i=iw(n,pa.Long);break;case"fullDate":i=iw(n,pa.Full);break;case"shortTime":i=rw(n,pa.Short);break;case"mediumTime":i=rw(n,pa.Medium);break;case"longTime":i=rw(n,pa.Long);break;case"fullTime":i=rw(n,pa.Full);break;case"short":let r=sd(n,"shortTime"),o=sd(n,"shortDate");i=aw(ow(n,pa.Short),[r,o]);break;case"medium":let a=sd(n,"mediumTime"),s=sd(n,"mediumDate");i=aw(ow(n,pa.Medium),[a,s]);break;case"long":let l=sd(n,"longTime"),c=sd(n,"longDate");i=aw(ow(n,pa.Long),[l,c]);break;case"full":let d=sd(n,"fullTime"),u=sd(n,"fullDate");i=aw(ow(n,pa.Full),[d,u])}return i&&(Eb[e][t]=i),i}function aw(n,t){return t&&(n=n.replace(/\{([^}]+)}/g,function(e,i){return null!=t&&i in t?t[i]:e})),n}function Dl(n,t,e="-",i,r){let o="";(n<0||r&&n<=0)&&(r?n=1-n:(n=-n,o=e));let a=String(n);for(;a.length<t;)a="0"+a;return i&&(a=a.slice(a.length-t)),o+a}function $r(n,t,e=0,i=!1,r=!1){return function(o,a){let s=function(n,t){switch(n){case Ii.FullYear:return t.getFullYear();case Ii.Month:return t.getMonth();case Ii.Date:return t.getDate();case Ii.Hours:return t.getHours();case Ii.Minutes:return t.getMinutes();case Ii.Seconds:return t.getSeconds();case Ii.FractionalSeconds:return t.getMilliseconds();case Ii.Day:return t.getDay();default:throw new Error(`Unknown DateType value "${n}".`)}}(n,o);if((e>0||s>-e)&&(s+=e),n===Ii.Hours)0===s&&-12===e&&(s=12);else if(n===Ii.FractionalSeconds)return function(n,t){return Dl(n,3).substring(0,t)}(s,t);let l=ld(a,Yo.MinusSign);return Dl(s,t,l,i,r)}}function rr(n,t,e=Bo.Format,i=!1){return function(r,o){return function(n,t,e,i,r,o){switch(e){case Di.Months:return function(n,t,e){let i=Fa(n),o=zs([i[hr.MonthsFormat],i[hr.MonthsStandalone]],t);return zs(o,e)}(t,r,i)[n.getMonth()];case Di.Days:return function(n,t,e){let i=Fa(n),o=zs([i[hr.DaysFormat],i[hr.DaysStandalone]],t);return zs(o,e)}(t,r,i)[n.getDay()];case Di.DayPeriods:let a=n.getHours(),s=n.getMinutes();if(o){let c=function(n){let t=Fa(n);return Yj(t),(t[hr.ExtraData][2]||[]).map(i=>"string"==typeof i?Uk(i):[Uk(i[0]),Uk(i[1])])}(t),d=function(n,t,e){let i=Fa(n);Yj(i);let o=zs([i[hr.ExtraData][0],i[hr.ExtraData][1]],t)||[];return zs(o,e)||[]}(t,r,i),u=c.findIndex(p=>{if(Array.isArray(p)){let[h,m]=p,_=a>=h.hours&&s>=h.minutes,M=a<m.hours||a===m.hours&&s<m.minutes;if(h.hours<m.hours){if(_&&M)return!0}else if(_||M)return!0}else if(p.hours===a&&p.minutes===s)return!0;return!1});if(-1!==u)return d[u]}return function(n,t,e){let i=Fa(n),o=zs([i[hr.DayPeriodsFormat],i[hr.DayPeriodsStandalone]],t);return zs(o,e)}(t,r,i)[a<12?0:1];case Di.Eras:return function(n,t){return zs(Fa(n)[hr.Eras],t)}(t,i)[n.getFullYear()<=0?0:1];default:throw new Error(`unexpected translation type ${e}`)}}(r,o,n,t,e,i)}}function sw(n){return function(t,e,i){let r=-1*i,o=ld(e,Yo.MinusSign),a=r>0?Math.floor(r/60):Math.ceil(r/60);switch(n){case Il.Short:return(r>=0?"+":"")+Dl(a,2,o)+Dl(Math.abs(r%60),2,o);case Il.ShortGMT:return"GMT"+(r>=0?"+":"")+Dl(a,1,o);case Il.Long:return"GMT"+(r>=0?"+":"")+Dl(a,2,o)+":"+Dl(Math.abs(r%60),2,o);case Il.Extended:return 0===i?"Z":(r>=0?"+":"")+Dl(a,2,o)+":"+Dl(Math.abs(r%60),2,o);default:throw new Error(`Unknown zone width "${n}"`)}}}var zue=0,dw=4;function Qj(n){return pw(n.getFullYear(),n.getMonth(),n.getDate()+(dw-n.getDay()))}function jk(n,t=!1){return function(e,i){let r;if(t){let o=new Date(e.getFullYear(),e.getMonth(),1).getDay()-1,a=e.getDate();r=1+Math.floor((a+o)/7)}else{let o=Qj(e),a=function(n){let t=pw(n,zue,1).getDay();return pw(n,0,1+(t<=dw?dw:dw+7)-t)}(o.getFullYear()),s=o.getTime()-a.getTime();r=1+Math.round(s/6048e5)}return Dl(r,n,ld(i,Yo.MinusSign))}}function lw(n,t=!1){return function(e,i){return Dl(Qj(e).getFullYear(),n,ld(i,Yo.MinusSign),t)}}var Gk={};function Zj(n,t){n=n.replace(/:/g,"");let e=Date.parse("Jan 01, 1970 00:00:00 "+n)/6e4;return isNaN(e)?t:e}function Bj(n){return n instanceof Date&&!isNaN(n.valueOf())}var Yue=/^(\d+)?\.((\d+)(-(\d+))?)?$/,Vj=22,hw=".",Tb="0",Que=";",Zue=",",Wk="#";function eO(n,t,e){let i=function(n,t){return Fa(n)[hr.NumberFormats][t]}(t,cw.Decimal),r=function(n,t="-"){let e={minInt:1,minFrac:0,maxFrac:0,posPre:"",posSuf:"",negPre:"",negSuf:"",gSize:0,lgSize:0},i=n.split(Que),r=i[0],o=i[1],a=-1!==r.indexOf(hw)?r.split(hw):[r.substring(0,r.lastIndexOf(Tb)+1),r.substring(r.lastIndexOf(Tb)+1)],s=a[0],l=a[1]||"";e.posPre=s.substring(0,s.indexOf(Wk));for(let d=0;d<l.length;d++){let u=l.charAt(d);u===Tb?e.minFrac=e.maxFrac=d+1:u===Wk?e.maxFrac=d+1:e.posSuf+=u}let c=s.split(Zue);if(e.gSize=c[1]?c[1].length:0,e.lgSize=c[2]||c[1]?(c[2]||c[1]).length:0,o){let d=r.length-e.posPre.length-e.posSuf.length,u=o.indexOf(Wk);e.negPre=o.substring(0,u).replace(/'/g,""),e.negSuf=o.slice(u+d).replace(/'/g,"")}else e.negPre=t+e.posPre,e.negSuf=e.posSuf;return e}(i,ld(t,Yo.MinusSign));return function(n,t,e,i,r,o,a=!1){let s="",l=!1;if(isFinite(n)){let c=function(n){let i,r,o,a,s,t=Math.abs(n)+"",e=0;for((r=t.indexOf(hw))>-1&&(t=t.replace(hw,"")),(o=t.search(/e/i))>0?(r<0&&(r=o),r+=+t.slice(o+1),t=t.substring(0,o)):r<0&&(r=t.length),o=0;t.charAt(o)===Tb;o++);if(o===(s=t.length))i=[0],r=1;else{for(s--;t.charAt(s)===Tb;)s--;for(r-=o,i=[],a=0;o<=s;o++,a++)i[a]=Number(t.charAt(o))}return r>Vj&&(i=i.splice(0,Vj-1),e=r-1,r=1),{digits:i,exponent:e,integerLen:r}}(n);a&&(c=function(n){if(0===n.digits[0])return n;let t=n.digits.length-n.integerLen;return n.exponent?n.exponent+=2:(0===t?n.digits.push(0,0):1===t&&n.digits.push(0),n.integerLen+=2),n}(c));let d=t.minInt,u=t.minFrac,p=t.maxFrac;if(o){let x=o.match(Yue);if(null===x)throw new Error(`${o} is not a valid digit info`);let R=x[1],I=x[3],B=x[5];null!=R&&(d=qk(R)),null!=I&&(u=qk(I)),null!=B?p=qk(B):null!=I&&u>p&&(p=u)}!function(n,t,e){if(t>e)throw new Error(`The minimum number of digits after fraction (${t}) is higher than the maximum (${e}).`);let i=n.digits,r=i.length-n.integerLen,o=Math.min(Math.max(t,r),e),a=o+n.integerLen,s=i[a];if(a>0){i.splice(Math.max(n.integerLen,a));for(let u=a;u<i.length;u++)i[u]=0}else{r=Math.max(0,r),n.integerLen=1,i.length=Math.max(1,a=o+1),i[0]=0;for(let u=1;u<a;u++)i[u]=0}if(s>=5)if(a-1<0){for(let u=0;u>a;u--)i.unshift(0),n.integerLen++;i.unshift(1),n.integerLen++}else i[a-1]++;for(;r<Math.max(0,o);r++)i.push(0);let l=0!==o,c=t+n.integerLen,d=i.reduceRight(function(u,p,h,m){return m[h]=(p+=u)<10?p:p-10,l&&(0===m[h]&&h>=c?m.pop():l=!1),p>=10?1:0},0);d&&(i.unshift(d),n.integerLen++)}(c,u,p);let h=c.digits,m=c.integerLen,_=c.exponent,M=[];for(l=h.every(x=>!x);m<d;m++)h.unshift(0);for(;m<0;m++)h.unshift(0);m>0?M=h.splice(m,h.length):(M=h,h=[0]);let y=[];for(h.length>=t.lgSize&&y.unshift(h.splice(-t.lgSize,h.length).join(""));h.length>t.gSize;)y.unshift(h.splice(-t.gSize,h.length).join(""));h.length&&y.unshift(h.join("")),s=y.join(ld(e,i)),M.length&&(s+=ld(e,r)+M.join("")),_&&(s+=ld(e,Yo.Exponential)+"+"+_)}else s=ld(e,Yo.Infinity);return s=n<0&&!l?t.negPre+s+t.negSuf:t.posPre+s+t.posSuf,s}(n,r,t,Yo.Group,Yo.Decimal,e)}function qk(n){let t=parseInt(n);if(isNaN(t))throw new Error("Invalid integer literal when parsing "+n);return t}function fw(n,t){t=encodeURIComponent(t);for(let e of n.split(";")){let i=e.indexOf("="),[r,o]=-1==i?[e,""]:[e.slice(0,i),e.slice(i+1)];if(r.trim()===t)return decodeURIComponent(o)}return null}var Xk=/\s+/,Hj=[],wn=(()=>{class n{constructor(e,i,r,o){this._iterableDiffers=e,this._keyValueDiffers=i,this._ngEl=r,this._renderer=o,this.initialClasses=Hj,this.stateMap=new Map}set klass(e){this.initialClasses=null!=e?e.trim().split(Xk):Hj}set ngClass(e){this.rawClass="string"==typeof e?e.trim().split(Xk):e}ngDoCheck(){for(let i of this.initialClasses)this._updateState(i,!0);let e=this.rawClass;if(Array.isArray(e)||e instanceof Set)for(let i of e)this._updateState(i,!0);else if(null!=e)for(let i of Object.keys(e))this._updateState(i,Boolean(e[i]));this._applyStateDiff()}_updateState(e,i){let r=this.stateMap.get(e);void 0!==r?(r.enabled!==i&&(r.changed=!0,r.enabled=i),r.touched=!0):this.stateMap.set(e,{enabled:i,changed:!0,touched:!0})}_applyStateDiff(){for(let e of this.stateMap){let i=e[0],r=e[1];r.changed?(this._toggleClass(i,r.enabled),r.changed=!1):r.touched||(r.enabled&&this._toggleClass(i,!1),this.stateMap.delete(i)),r.touched=!1}}_toggleClass(e,i){(e=e.trim()).length>0&&e.split(Xk).forEach(r=>{i?this._renderer.addClass(this._ngEl.nativeElement,r):this._renderer.removeClass(this._ngEl.nativeElement,r)})}}return n.\u0275fac=function(e){return new(e||n)(C(Tl),C(Sb),C(xe),C(dc))},n.\u0275dir=Me({type:n,selectors:[["","ngClass",""]],inputs:{klass:["class","klass"],ngClass:"ngClass"},standalone:!0}),n})(),nn=(()=>{class n{set ngForOf(e){this._ngForOf=e,this._ngForOfDirty=!0}set ngForTrackBy(e){this._trackByFn=e}get ngForTrackBy(){return this._trackByFn}constructor(e,i,r){this._viewContainer=e,this._template=i,this._differs=r,this._ngForOf=null,this._ngForOfDirty=!0,this._differ=null}set ngForTemplate(e){e&&(this._template=e)}ngDoCheck(){if(this._ngForOfDirty){this._ngForOfDirty=!1;let e=this._ngForOf;!this._differ&&e&&(this._differ=this._differs.find(e).create(this.ngForTrackBy))}if(this._differ){let e=this._differ.diff(this._ngForOf);e&&this._applyChanges(e)}}_applyChanges(e){let i=this._viewContainer;e.forEachOperation((r,o,a)=>{if(null==r.previousIndex)i.createEmbeddedView(this._template,new class{constructor(t,e,i,r){this.$implicit=t,this.ngForOf=e,this.index=i,this.count=r}get first(){return 0===this.index}get last(){return this.index===this.count-1}get even(){return this.index%2==0}get odd(){return!this.even}}(r.item,this._ngForOf,-1,-1),null===a?void 0:a);else if(null==a)i.remove(null===o?void 0:o);else if(null!==o){let s=i.get(o);i.move(s,a),Uj(s,r)}});for(let r=0,o=i.length;r<o;r++){let s=i.get(r).context;s.index=r,s.count=o,s.ngForOf=this._ngForOf}e.forEachIdentityChange(r=>{Uj(i.get(r.currentIndex),r)})}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(oi),C(Tl))},n.\u0275dir=Me({type:n,selectors:[["","ngFor","","ngForOf",""]],inputs:{ngForOf:"ngForOf",ngForTrackBy:"ngForTrackBy",ngForTemplate:"ngForTemplate"},standalone:!0}),n})();function Uj(n,t){n.context.$implicit=t.item}var Ne=(()=>{class n{constructor(e,i){this._viewContainer=e,this._context=new Zk,this._thenTemplateRef=null,this._elseTemplateRef=null,this._thenViewRef=null,this._elseViewRef=null,this._thenTemplateRef=i}set ngIf(e){this._context.$implicit=this._context.ngIf=e,this._updateView()}set ngIfThen(e){jj("ngIfThen",e),this._thenTemplateRef=e,this._thenViewRef=null,this._updateView()}set ngIfElse(e){jj("ngIfElse",e),this._elseTemplateRef=e,this._elseViewRef=null,this._updateView()}_updateView(){this._context.$implicit?this._thenViewRef||(this._viewContainer.clear(),this._elseViewRef=null,this._thenTemplateRef&&(this._thenViewRef=this._viewContainer.createEmbeddedView(this._thenTemplateRef,this._context))):this._elseViewRef||(this._viewContainer.clear(),this._thenViewRef=null,this._elseTemplateRef&&(this._elseViewRef=this._viewContainer.createEmbeddedView(this._elseTemplateRef,this._context)))}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(oi))},n.\u0275dir=Me({type:n,selectors:[["","ngIf",""]],inputs:{ngIf:"ngIf",ngIfThen:"ngIfThen",ngIfElse:"ngIfElse"},standalone:!0}),n})(),Zk=class{constructor(){this.$implicit=null,this.ngIf=null}};function jj(n,t){if(t&&!t.createEmbeddedView)throw new Error(`${n} must be a TemplateRef, but received '${po(t)}'.`)}var mw=class{constructor(t,e){this._viewContainerRef=t,this._templateRef=e,this._created=!1}create(){this._created=!0,this._viewContainerRef.createEmbeddedView(this._templateRef)}destroy(){this._created=!1,this._viewContainerRef.clear()}enforceState(t){t&&!this._created?this.create():!t&&this._created&&this.destroy()}},mr=(()=>{class n{constructor(){this._defaultViews=[],this._defaultUsed=!1,this._caseCount=0,this._lastCaseCheckIndex=0,this._lastCasesMatched=!1}set ngSwitch(e){this._ngSwitch=e,0===this._caseCount&&this._updateDefaultCases(!0)}_addCase(){return this._caseCount++}_addDefault(e){this._defaultViews.push(e)}_matchCase(e){let i=e==this._ngSwitch;return this._lastCasesMatched=this._lastCasesMatched||i,this._lastCaseCheckIndex++,this._lastCaseCheckIndex===this._caseCount&&(this._updateDefaultCases(!this._lastCasesMatched),this._lastCaseCheckIndex=0,this._lastCasesMatched=!1),i}_updateDefaultCases(e){if(this._defaultViews.length>0&&e!==this._defaultUsed){this._defaultUsed=e;for(let i of this._defaultViews)i.enforceState(e)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","ngSwitch",""]],inputs:{ngSwitch:"ngSwitch"},standalone:!0}),n})(),kr=(()=>{class n{constructor(e,i,r){this.ngSwitch=r,r._addCase(),this._view=new mw(e,i)}ngDoCheck(){this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase))}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(oi),C(mr,9))},n.\u0275dir=Me({type:n,selectors:[["","ngSwitchCase",""]],inputs:{ngSwitchCase:"ngSwitchCase"},standalone:!0}),n})(),du=(()=>{class n{constructor(e,i,r){r._addDefault(new mw(e,i))}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(oi),C(mr,9))},n.\u0275dir=Me({type:n,selectors:[["","ngSwitchDefault",""]],standalone:!0}),n})(),Mf=(()=>{class n{constructor(e,i,r){this._ngEl=e,this._differs=i,this._renderer=r,this._ngStyle=null,this._differ=null}set ngStyle(e){this._ngStyle=e,!this._differ&&e&&(this._differ=this._differs.find(e).create())}ngDoCheck(){if(this._differ){let e=this._differ.diff(this._ngStyle);e&&this._applyChanges(e)}}_setStyle(e,i){let[r,o]=e.split("."),a=-1===r.indexOf("-")?void 0:Ns.DashCase;null!=i?this._renderer.setStyle(this._ngEl.nativeElement,r,o?`${i}${o}`:i,a):this._renderer.removeStyle(this._ngEl.nativeElement,r,a)}_applyChanges(e){e.forEachRemovedItem(i=>this._setStyle(i.key,null)),e.forEachAddedItem(i=>this._setStyle(i.key,i.currentValue)),e.forEachChangedItem(i=>this._setStyle(i.key,i.currentValue))}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Sb),C(dc))},n.\u0275dir=Me({type:n,selectors:[["","ngStyle",""]],inputs:{ngStyle:"ngStyle"},standalone:!0}),n})(),eo=(()=>{class n{constructor(e){this._viewContainerRef=e,this._viewRef=null,this.ngTemplateOutletContext=null,this.ngTemplateOutlet=null,this.ngTemplateOutletInjector=null}ngOnChanges(e){if(e.ngTemplateOutlet||e.ngTemplateOutletInjector){let i=this._viewContainerRef;if(this._viewRef&&i.remove(i.indexOf(this._viewRef)),this.ngTemplateOutlet){let{ngTemplateOutlet:r,ngTemplateOutletContext:o,ngTemplateOutletInjector:a}=this;this._viewRef=i.createEmbeddedView(r,o,a?{injector:a}:void 0)}else this._viewRef=null}else this._viewRef&&e.ngTemplateOutletContext&&this.ngTemplateOutletContext&&(this._viewRef.context=this.ngTemplateOutletContext)}}return n.\u0275fac=function(e){return new(e||n)(C(ei))},n.\u0275dir=Me({type:n,selectors:[["","ngTemplateOutlet",""]],inputs:{ngTemplateOutletContext:"ngTemplateOutletContext",ngTemplateOutlet:"ngTemplateOutlet",ngTemplateOutletInjector:"ngTemplateOutletInjector"},standalone:!0,features:[qt]}),n})();function gw(n,t){return new xt(2100,!1)}var ipe=new class{createSubscription(t,e){return t.then(e,i=>{throw i})}dispose(t){}},rpe=new class{createSubscription(t,e){return t.subscribe({next:e,error:i=>{throw i}})}dispose(t){t.unsubscribe()}},ct=(()=>{class n{constructor(e){this._latestValue=null,this._subscription=null,this._obj=null,this._strategy=null,this._ref=e}ngOnDestroy(){this._subscription&&this._dispose(),this._ref=null}transform(e){return this._obj?e!==this._obj?(this._dispose(),this.transform(e)):this._latestValue:(e&&this._subscribe(e),this._latestValue)}_subscribe(e){this._obj=e,this._strategy=this._selectStrategy(e),this._subscription=this._strategy.createSubscription(e,i=>this._updateLatestValue(e,i))}_selectStrategy(e){if(Cf(e))return ipe;if(Dk(e))return rpe;throw gw()}_dispose(){this._strategy.dispose(this._subscription),this._latestValue=null,this._subscription=null,this._obj=null}_updateLatestValue(e,i){e===this._obj&&(this._latestValue=i,this._ref.markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C(Qt,16))},n.\u0275pipe=rf({name:"async",type:n,pure:!1,standalone:!0}),n})(),ape=new te("DATE_PIPE_DEFAULT_TIMEZONE"),spe=new te("DATE_PIPE_DEFAULT_OPTIONS"),wf=(()=>{class n{constructor(e,i,r){this.locale=e,this.defaultTimezone=i,this.defaultOptions=r}transform(e,i,r,o){if(null==e||""===e||e!=e)return null;try{return Lue(e,i??this.defaultOptions?.dateFormat??"mediumDate",o||this.locale,r??this.defaultOptions?.timezone??this.defaultTimezone??void 0)}catch(a){throw gw()}}}return n.\u0275fac=function(e){return new(e||n)(C(ad,16),C(ape,24),C(spe,24))},n.\u0275pipe=rf({name:"date",type:n,pure:!0,standalone:!0}),n})(),Us=(()=>{class n{constructor(e){this._locale=e}transform(e,i,r){if(!function(n){return!(null==n||""===n||n!=n)}(e))return null;r=r||this._locale;try{let o=function(n){if("string"==typeof n&&!isNaN(Number(n)-parseFloat(n)))return Number(n);if("number"!=typeof n)throw new Error(`${n} is not a number`);return n}(e);return eO(o,r,i)}catch(o){throw gw()}}}return n.\u0275fac=function(e){return new(e||n)(C(ad,16))},n.\u0275pipe=rf({name:"number",type:n,pure:!0,standalone:!0}),n})(),Kj=(()=>{class n{transform(e,i,r){if(null==e)return null;if(!this.supports(e))throw gw();return e.slice(i,r)}supports(e){return"string"==typeof e||Array.isArray(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275pipe=rf({name:"slice",type:n,pure:!1,standalone:!0}),n})(),De=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),tO="browser";function _w(n){return n===tO}new Ml("15.2.9");var th=class{};function hpe(n){return n.startsWith("/")?n.slice(1):n}var mpe=n=>n.src,fpe=new te("ImageLoader",{providedIn:"root",factory:()=>mpe});function bw(n,t){return function(i){return function(n){if("string"!=typeof n||""===n.trim())return!1;try{return new URL(n),!0}catch{return!1}}(i)||function(n,t){throw new xt(2959,!1)}(),i=function(n){return n.endsWith("/")?n.slice(0,-1):n}(i),[{provide:fpe,useValue:a=>(function(n){return/^https?:\/\//.test(n)}(a.src)&&function(n,t){throw new xt(2959,!1)}(),n(i,{...a,src:hpe(a.src)}))}]}}bw(function(n,t){let e="format=auto";return t.width&&(e+=`,width=${t.width}`),`${n}/cdn-cgi/image/${e}/${t.src}`}),bw(function(n,t){let e="f_auto,q_auto";return t.width&&(e+=`,w_${t.width}`),`${n}/image/upload/${e}/${t.src}`}),bw(function(n,t){let r,{src:e,width:i}=t;return r=i?[n,`tr:w-${i}`,e]:[n,e],r.join("/")}),bw(function(n,t){let e=new URL(`${n}/${t.src}`);return e.searchParams.set("auto","format"),t.width&&e.searchParams.set("w",t.width.toString()),e.href}),new te("PRECONNECT_CHECK_BLOCKLIST"),new te("NG_OPTIMIZED_PRELOADED_IMAGES",{providedIn:"root",factory:()=>new Set});var vw,Cpe={breakpoints:[16,32,48,64,96,128,256,384,640,750,828,1080,1200,1920,2048,3840]},iO=(new te("ImageConfig",{providedIn:"root",factory:()=>Cpe}),class extends uw{constructor(){super(...arguments),this.supportsDOMEvents=!0}}),Pb=class extends iO{static makeCurrent(){var n;n=new Pb,Yk||(Yk=n)}onAndCancel(t,e,i){return t.addEventListener(e,i,!1),()=>{t.removeEventListener(e,i,!1)}}dispatchEvent(t,e){t.dispatchEvent(e)}remove(t){t.parentNode&&t.parentNode.removeChild(t)}createElement(t,e){return(e=e||this.getDefaultDocument()).createElement(t)}createHtmlDocument(){return document.implementation.createHTMLDocument("fakeTitle")}getDefaultDocument(){return document}isElementNode(t){return t.nodeType===Node.ELEMENT_NODE}isShadowRoot(t){return t instanceof DocumentFragment}getGlobalEventTarget(t,e){return"window"===e?window:"document"===e?t:"body"===e?t.body:null}getBaseHref(t){let e=(Ib=Ib||document.querySelector("base"))?Ib.getAttribute("href"):null;return null==e?null:function(n){(vw=vw||document.createElement("a")).setAttribute("href",n);let t=vw.pathname;return"/"===t.charAt(0)?t:`/${t}`}(e)}resetBaseElement(){Ib=null}getUserAgent(){return window.navigator.userAgent}getCookie(t){return fw(document.cookie,t)}},Ib=null,iG=new te("TRANSITION_ID"),Tpe=[{provide:Ok,useFactory:function(n,t,e){return()=>{e.get(KM).donePromise.then(()=>{let i=Al(),r=t.querySelectorAll(`style[ng-transition="${n}"]`);for(let o=0;o<r.length;o++)i.remove(r[o])})}},deps:[iG,Nt,wi],multi:!0}],Dpe=(()=>{class n{build(){return new XMLHttpRequest}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),yw=new te("EventManagerPlugins"),xw=(()=>{class n{constructor(e,i){this._zone=i,this._eventNameToPlugin=new Map,e.forEach(r=>{r.manager=this}),this._plugins=e.slice().reverse()}addEventListener(e,i,r){return this._findPluginFor(i).addEventListener(e,i,r)}addGlobalEventListener(e,i,r){return this._findPluginFor(i).addGlobalEventListener(e,i,r)}getZone(){return this._zone}_findPluginFor(e){let i=this._eventNameToPlugin.get(e);if(i)return i;let r=this._plugins;for(let o=0;o<r.length;o++){let a=r[o];if(a.supports(e))return this._eventNameToPlugin.set(e,a),a}throw new Error(`No event manager plugin found for event ${e}`)}}return n.\u0275fac=function(e){return new(e||n)(O(yw),O(ot))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Cw=class{constructor(t){this._doc=t}addGlobalEventListener(t,e,i){let r=Al().getGlobalEventTarget(this._doc,t);if(!r)throw new Error(`Unsupported event target ${r} for event ${e}`);return this.addEventListener(r,e,i)}},rG=(()=>{class n{constructor(){this.usageCount=new Map}addStyles(e){for(let i of e)1===this.changeUsageCount(i,1)&&this.onStyleAdded(i)}removeStyles(e){for(let i of e)0===this.changeUsageCount(i,-1)&&this.onStyleRemoved(i)}onStyleRemoved(e){}onStyleAdded(e){}getAllStyles(){return this.usageCount.keys()}changeUsageCount(e,i){let r=this.usageCount,o=r.get(e)??0;return o+=i,o>0?r.set(e,o):r.delete(e),o}ngOnDestroy(){for(let e of this.getAllStyles())this.onStyleRemoved(e);this.usageCount.clear()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ab=(()=>{class n extends rG{constructor(e){super(),this.doc=e,this.styleRef=new Map,this.hostNodes=new Set,this.resetHostNodes()}onStyleAdded(e){for(let i of this.hostNodes)this.addStyleToHost(i,e)}onStyleRemoved(e){let i=this.styleRef;i.get(e)?.forEach(o=>o.remove()),i.delete(e)}ngOnDestroy(){super.ngOnDestroy(),this.styleRef.clear(),this.resetHostNodes()}addHost(e){this.hostNodes.add(e);for(let i of this.getAllStyles())this.addStyleToHost(e,i)}removeHost(e){this.hostNodes.delete(e)}addStyleToHost(e,i){let r=this.doc.createElement("style");r.textContent=i,e.appendChild(r);let o=this.styleRef.get(i);o?o.push(r):this.styleRef.set(i,[r])}resetHostNodes(){let e=this.hostNodes;e.clear(),e.add(this.doc.head)}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),nO={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/",math:"http://www.w3.org/1998/MathML/"},aO=/%COMP%/g,aG=new te("RemoveStylesOnCompDestory",{providedIn:"root",factory:()=>!1});function sG(n,t){return t.flat(100).map(e=>e.replace(aO,n))}function $j(n){return t=>{if("__ngUnwrap__"===t)return n;!1===n(t)&&(t.preventDefault(),t.returnValue=!1)}}var Rb=(()=>{class n{constructor(e,i,r,o){this.eventManager=e,this.sharedStylesHost=i,this.appId=r,this.removeStylesOnCompDestory=o,this.rendererByCompId=new Map,this.defaultRenderer=new kb(e)}createRenderer(e,i){if(!e||!i)return this.defaultRenderer;let r=this.getOrCreateRenderer(e,i);return r instanceof Mw?r.applyToHost(e):r instanceof Ob&&r.applyStyles(),r}getOrCreateRenderer(e,i){let r=this.rendererByCompId,o=r.get(i.id);if(!o){let a=this.eventManager,s=this.sharedStylesHost,l=this.removeStylesOnCompDestory;switch(i.encapsulation){case as.Emulated:o=new Mw(a,s,i,this.appId,l);break;case as.ShadowDom:return new oO(a,s,e,i);default:o=new Ob(a,s,i,l)}o.onDestroy=()=>r.delete(i.id),r.set(i.id,o)}return o}ngOnDestroy(){this.rendererByCompId.clear()}begin(){}end(){}}return n.\u0275fac=function(e){return new(e||n)(O(xw),O(Ab),O($p),O(aG))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),kb=class{constructor(t){this.eventManager=t,this.data=Object.create(null),this.destroyNode=null}destroy(){}createElement(t,e){return e?document.createElementNS(nO[e]||e,t):document.createElement(t)}createComment(t){return document.createComment(t)}createText(t){return document.createTextNode(t)}appendChild(t,e){(tG(t)?t.content:t).appendChild(e)}insertBefore(t,e,i){t&&(tG(t)?t.content:t).insertBefore(e,i)}removeChild(t,e){t&&t.removeChild(e)}selectRootElement(t,e){let i="string"==typeof t?document.querySelector(t):t;if(!i)throw new Error(`The selector "${t}" did not match any elements`);return e||(i.textContent=""),i}parentNode(t){return t.parentNode}nextSibling(t){return t.nextSibling}setAttribute(t,e,i,r){if(r){e=r+":"+e;let o=nO[r];o?t.setAttributeNS(o,e,i):t.setAttribute(e,i)}else t.setAttribute(e,i)}removeAttribute(t,e,i){if(i){let r=nO[i];r?t.removeAttributeNS(r,e):t.removeAttribute(`${i}:${e}`)}else t.removeAttribute(e)}addClass(t,e){t.classList.add(e)}removeClass(t,e){t.classList.remove(e)}setStyle(t,e,i,r){r&(Ns.DashCase|Ns.Important)?t.style.setProperty(e,i,r&Ns.Important?"important":""):t.style[e]=i}removeStyle(t,e,i){i&Ns.DashCase?t.style.removeProperty(e):t.style[e]=""}setProperty(t,e,i){t[e]=i}setValue(t,e){t.nodeValue=e}listen(t,e,i){return"string"==typeof t?this.eventManager.addGlobalEventListener(t,e,$j(i)):this.eventManager.addEventListener(t,e,$j(i))}};function tG(n){return"TEMPLATE"===n.tagName&&void 0!==n.content}"@".charCodeAt(0);var oO=class extends kb{constructor(t,e,i,r){super(t),this.sharedStylesHost=e,this.hostEl=i,this.shadowRoot=i.attachShadow({mode:"open"}),this.sharedStylesHost.addHost(this.shadowRoot);let o=sG(r.id,r.styles);for(let a of o){let s=document.createElement("style");s.textContent=a,this.shadowRoot.appendChild(s)}}nodeOrShadowRoot(t){return t===this.hostEl?this.shadowRoot:t}appendChild(t,e){return super.appendChild(this.nodeOrShadowRoot(t),e)}insertBefore(t,e,i){return super.insertBefore(this.nodeOrShadowRoot(t),e,i)}removeChild(t,e){return super.removeChild(this.nodeOrShadowRoot(t),e)}parentNode(t){return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))}destroy(){this.sharedStylesHost.removeHost(this.shadowRoot)}},Ob=class extends kb{constructor(t,e,i,r,o=i.id){super(t),this.sharedStylesHost=e,this.removeStylesOnCompDestory=r,this.rendererUsageCount=0,this.styles=sG(o,i.styles)}applyStyles(){this.sharedStylesHost.addStyles(this.styles),this.rendererUsageCount++}destroy(){!this.removeStylesOnCompDestory||(this.sharedStylesHost.removeStyles(this.styles),this.rendererUsageCount--,0===this.rendererUsageCount&&this.onDestroy?.())}},Mw=class extends Ob{constructor(t,e,i,r,o){let a=r+"-"+i.id;super(t,e,i,o,a),this.contentAttr="_ngcontent-%COMP%".replace(aO,a),this.hostAttr=function(n){return"_nghost-%COMP%".replace(aO,n)}(a)}applyToHost(t){this.applyStyles(),this.setAttribute(t,this.hostAttr,"")}createElement(t,e){let i=super.createElement(t,e);return super.setAttribute(i,this.contentAttr,""),i}},Fpe=(()=>{class n extends Cw{constructor(e){super(e)}supports(e){return!0}addEventListener(e,i,r){return e.addEventListener(i,r,!1),()=>this.removeEventListener(e,i,r)}removeEventListener(e,i,r){return e.removeEventListener(i,r)}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),nG=["alt","control","meta","shift"],Npe={"\b":"Backspace","\t":"Tab","\x7f":"Delete","\x1b":"Escape",Del:"Delete",Esc:"Escape",Left:"ArrowLeft",Right:"ArrowRight",Up:"ArrowUp",Down:"ArrowDown",Menu:"ContextMenu",Scroll:"ScrollLock",Win:"OS"},Lpe={alt:n=>n.altKey,control:n=>n.ctrlKey,meta:n=>n.metaKey,shift:n=>n.shiftKey},Bpe=(()=>{class n extends Cw{constructor(e){super(e)}supports(e){return null!=n.parseEventName(e)}addEventListener(e,i,r){let o=n.parseEventName(i),a=n.eventCallback(o.fullKey,r,this.manager.getZone());return this.manager.getZone().runOutsideAngular(()=>Al().onAndCancel(e,o.domEventName,a))}static parseEventName(e){let i=e.toLowerCase().split("."),r=i.shift();if(0===i.length||"keydown"!==r&&"keyup"!==r)return null;let o=n._normalizeKey(i.pop()),a="",s=i.indexOf("code");if(s>-1&&(i.splice(s,1),a="code."),nG.forEach(c=>{let d=i.indexOf(c);d>-1&&(i.splice(d,1),a+=c+".")}),a+=o,0!=i.length||0===o.length)return null;let l={};return l.domEventName=r,l.fullKey=a,l}static matchEventFullKeyCode(e,i){let r=Npe[e.key]||e.key,o="";return i.indexOf("code.")>-1&&(r=e.code,o="code."),!(null==r||!r)&&(r=r.toLowerCase()," "===r?r="space":"."===r&&(r="dot"),nG.forEach(a=>{a!==r&&(0,Lpe[a])(e)&&(o+=a+".")}),o+=r,o===i)}static eventCallback(e,i,r){return o=>{n.matchEventFullKeyCode(o,e)&&r.runGuarded(()=>i(o))}}static _normalizeKey(e){return"esc"===e?"escape":e}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Upe=[{provide:fc,useValue:tO},{provide:Fk,useValue:function(){Pb.makeCurrent()},multi:!0},{provide:Nt,useFactory:function(){return n=document,YR=n,document;var n},deps:[]}],lO=Vk(Rj,"browser",Upe),lG=new te(""),jpe=[{provide:Mb,useClass:class{addToWindow(t){zr.getAngularTestability=(i,r=!0)=>{let o=t.findTestabilityInTree(i,r);if(null==o)throw new Error("Could not find testability for element.");return o},zr.getAllAngularTestabilities=()=>t.getAllTestabilities(),zr.getAllAngularRootElements=()=>t.getAllRootElements(),zr.frameworkStabilizers||(zr.frameworkStabilizers=[]),zr.frameworkStabilizers.push(i=>{let r=zr.getAllAngularTestabilities(),o=r.length,a=!1,s=function(l){a=a||l,o--,0==o&&i(a)};r.forEach(function(l){l.whenStable(s)})})}findTestabilityInTree(t,e,i){return null==e?null:t.getTestability(e)??(i?Al().isShadowRoot(e)?this.findTestabilityInTree(t,e.host,!0):this.findTestabilityInTree(t,e.parentElement,!0):null)}},deps:[]},{provide:Lk,useClass:JM,deps:[ot,$M,Mb]},{provide:JM,useClass:JM,deps:[ot,$M,Mb]}],Gpe=[{provide:LM,useValue:"root"},{provide:la,useFactory:function(){return new la},deps:[]},{provide:yw,useClass:Fpe,multi:!0,deps:[Nt,ot,fc]},{provide:yw,useClass:Bpe,multi:!0,deps:[Nt]},{provide:Rb,useClass:Rb,deps:[xw,Ab,$p,aG]},{provide:cc,useExisting:Rb},{provide:rG,useExisting:Ab},{provide:Ab,useClass:Ab,deps:[Nt]},{provide:xw,useClass:xw,deps:[yw,ot]},{provide:th,useClass:Dpe,deps:[]},[]],ww=(()=>{class n{constructor(e){}static withServerTransition(e){return{ngModule:n,providers:[{provide:$p,useValue:e.appId},{provide:iG,useExisting:$p},Tpe]}}}return n.\u0275fac=function(e){return new(e||n)(O(lG,12))},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[...Gpe,...jpe],imports:[De,Pj]}),n})(),nh=(new te("HammerGestureConfig"),new te("HammerLoader"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:function(e){let i=null;return i=e?new(e||n):O(cG),i},providedIn:"root"}),n})()),cG=(()=>{class n extends nh{constructor(e){super(),this._doc=e}sanitize(e,i){if(null==i)return null;switch(e){case Ur.NONE:return i;case Ur.HTML:return wl(i,"HTML")?Oa(i):hk(this._doc,String(i)).toString();case Ur.STYLE:return wl(i,"Style")?Oa(i):i;case Ur.SCRIPT:if(wl(i,"Script"))return Oa(i);throw new Error("unsafe value used in a script context");case Ur.URL:return wl(i,"URL")?Oa(i):pb(String(i));case Ur.RESOURCE_URL:if(wl(i,"ResourceURL"))return Oa(i);throw new Error(`unsafe value used in a resource URL context (see ${ob})`);default:throw new Error(`Unexpected SecurityContext ${e} (see ${ob})`)}}bypassSecurityTrustHtml(e){return function(n){return new QR(n)}(e)}bypassSecurityTrustStyle(e){return function(n){return new ZR(n)}(e)}bypassSecurityTrustScript(e){return function(n){return new KR(n)}(e)}bypassSecurityTrustUrl(e){return function(n){return new JR(n)}(e)}bypassSecurityTrustResourceUrl(e){return function(n){return new $R(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:function(e){let i=null;return i=e?new e:function(n){return new cG(n.get(Nt))}(O(wi)),i},providedIn:"root"}),n})(),Fb=(new Ml("15.2.9"),$V(uG(),1),class{}),Sw=class{},_c="*";function fr(n,t){return{type:7,name:n,definitions:t,options:{}}}function Mi(n,t=null){return{type:4,styles:t,timings:n}}function Lb(n,t=null){return{type:3,steps:n,options:t}}function Ew(n,t=null){return{type:2,steps:n,options:t}}function rn(n){return{type:6,styles:n,offset:null}}function Si(n,t,e){return{type:0,name:n,styles:t,options:e}}function Bb(n){return{type:5,steps:n}}function bi(n,t,e=null){return{type:1,expr:n,animation:t,options:e}}function ih(n=null){return{type:9,options:n}}function rh(n,t,e=null){return{type:11,selector:n,animation:t,options:e}}function pG(n){Promise.resolve().then(n)}var pu=class{constructor(t=0,e=0){this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._originalOnDoneFns=[],this._originalOnStartFns=[],this._started=!1,this._destroyed=!1,this._finished=!1,this._position=0,this.parentPlayer=null,this.totalTime=t+e}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}init(){}play(){this.hasStarted()||(this._onStart(),this.triggerMicrotask()),this._started=!0}triggerMicrotask(){pG(()=>this._onFinish())}_onStart(){this._onStartFns.forEach(t=>t()),this._onStartFns=[]}pause(){}restart(){}finish(){this._onFinish()}destroy(){this._destroyed||(this._destroyed=!0,this.hasStarted()||this._onStart(),this.finish(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this._started=!1,this._finished=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}setPosition(t){this._position=this.totalTime?t*this.totalTime:1}getPosition(){return this.totalTime?this._position/this.totalTime:1}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Nb=class{constructor(t){this._onDoneFns=[],this._onStartFns=[],this._finished=!1,this._started=!1,this._destroyed=!1,this._onDestroyFns=[],this.parentPlayer=null,this.totalTime=0,this.players=t;let e=0,i=0,r=0,o=this.players.length;0==o?pG(()=>this._onFinish()):this.players.forEach(a=>{a.onDone(()=>{++e==o&&this._onFinish()}),a.onDestroy(()=>{++i==o&&this._onDestroy()}),a.onStart(()=>{++r==o&&this._onStart()})}),this.totalTime=this.players.reduce((a,s)=>Math.max(a,s.totalTime),0)}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this.players.forEach(t=>t.init())}onStart(t){this._onStartFns.push(t)}_onStart(){this.hasStarted()||(this._started=!0,this._onStartFns.forEach(t=>t()),this._onStartFns=[])}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}play(){this.parentPlayer||this.init(),this._onStart(),this.players.forEach(t=>t.play())}pause(){this.players.forEach(t=>t.pause())}restart(){this.players.forEach(t=>t.restart())}finish(){this._onFinish(),this.players.forEach(t=>t.finish())}destroy(){this._onDestroy()}_onDestroy(){this._destroyed||(this._destroyed=!0,this._onFinish(),this.players.forEach(t=>t.destroy()),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this.players.forEach(t=>t.reset()),this._destroyed=!1,this._finished=!1,this._started=!1}setPosition(t){let e=t*this.totalTime;this.players.forEach(i=>{let r=i.totalTime?Math.min(1,e/i.totalTime):1;i.setPosition(r)})}getPosition(){let t=this.players.reduce((e,i)=>null===e||i.totalTime>e.totalTime?i:e,null);return null!=t?t.getPosition():0}beforeDestroy(){this.players.forEach(t=>{t.beforeDestroy&&t.beforeDestroy()})}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},Tw="!";function hG(n){return new xt(3e3,!1)}function AO(){return typeof process<"u"&&"[object process]"==={}.toString.call(process)}function hu(n){switch(n.length){case 0:return new pu;case 1:return n[0];default:return new Nb(n)}}function DG(n,t,e,i,r=new Map,o=new Map){let a=[],s=[],l=-1,c=null;if(i.forEach(d=>{let u=d.get("offset"),p=u==l,h=p&&c||new Map;d.forEach((m,_)=>{let M=_,y=m;if("offset"!==_)switch(M=t.normalizePropertyName(M,a),y){case Tw:y=r.get(_);break;case _c:y=o.get(_);break;default:y=t.normalizeStyleValue(_,M,y,a)}h.set(M,y)}),p||s.push(h),c=h,l=u}),a.length)throw new xt(3502,!1);return s}function RO(n,t,e,i){switch(t){case"start":n.onStart(()=>i(e&&dO(e,"start",n)));break;case"done":n.onDone(()=>i(e&&dO(e,"done",n)));break;case"destroy":n.onDestroy(()=>i(e&&dO(e,"destroy",n)))}}function dO(n,t,e){let o=PO(n.element,n.triggerName,n.fromState,n.toState,t||n.phaseName,e.totalTime??n.totalTime,!!e.disabled),a=n._data;return null!=a&&(o._data=a),o}function PO(n,t,e,i,r="",o=0,a){return{element:n,triggerName:t,fromState:e,toState:i,phaseName:r,totalTime:o,disabled:!!a}}function ps(n,t,e){let i=n.get(t);return i||n.set(t,i=e),i}function mG(n){let t=n.indexOf(":");return[n.substring(1,t),n.slice(t+1)]}var gO=(n,t)=>!1,IG=(n,t,e)=>[],AG=null;function kO(n){let t=n.parentNode||n.host;return t===AG?null:t}(AO()||typeof Element<"u")&&(typeof window<"u"&&typeof window.document<"u"?(AG=(()=>document.documentElement)(),gO=(n,t)=>{for(;t;){if(t===n)return!0;t=kO(t)}return!1}):gO=(n,t)=>n.contains(t),IG=(n,t,e)=>{if(e)return Array.from(n.querySelectorAll(t));let i=n.querySelector(t);return i?[i]:[]});var oh=null,fG=!1;var RG=gO,PG=IG,OO=(()=>{class n{validateStyleProperty(e){return function(n){oh||(oh=(typeof document<"u"?document.body:null)||{},fG=!!oh.style&&"WebkitAppearance"in oh.style);let t=!0;return oh.style&&!function(n){return"ebkit"==n.substring(1,6)}(n)&&(t=n in oh.style,!t&&fG&&(t="Webkit"+n.charAt(0).toUpperCase()+n.slice(1)in oh.style)),t}(e)}matchesElement(e,i){return!1}containsElement(e,i){return RG(e,i)}getParentElement(e){return kO(e)}query(e,i,r){return PG(e,i,r)}computeStyle(e,i,r){return r||""}animate(e,i,r,o,a,s=[],l){return new pu(r,o)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),qb=(()=>{class n{}return n.NOOP=new OO,n})(),Dhe=1e3,OG="ng-enter",_O="ng-leave",Dw="ng-trigger",Pw=".ng-trigger",gG="ng-animating",bO=".ng-animating";function cd(n){if("number"==typeof n)return n;let t=n.match(/^(-?[\.\d]+)(m?s)/);return!t||t.length<2?0:vO(parseFloat(t[1]),t[2])}function vO(n,t){return"s"===t?n*Dhe:n}function kw(n,t,e){return n.hasOwnProperty("duration")?n:function(n,t,e){let r,o=0,a="";if("string"==typeof n){let s=n.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i);if(null===s)return t.push(hG()),{duration:0,delay:0,easing:""};r=vO(parseFloat(s[1]),s[2]);let l=s[3];null!=l&&(o=vO(parseFloat(l),s[4]));let c=s[5];c&&(a=c)}else r=n;if(!e){let s=!1,l=t.length;r<0&&(t.push(new xt(3100,!1)),s=!0),o<0&&(t.push(new xt(3101,!1)),s=!0),s&&t.splice(l,0,hG())}return{duration:r,delay:o,easing:a}}(n,t,e)}function Xb(n,t={}){return Object.keys(n).forEach(e=>{t[e]=n[e]}),t}function FG(n){let t=new Map;return Object.keys(n).forEach(e=>{t.set(e,n[e])}),t}function Ef(n,t=new Map,e){if(e)for(let[i,r]of e)t.set(i,r);for(let[i,r]of n)t.set(i,r);return t}function _G(n,t,e){return e?t+":"+e+";":""}function NG(n){let t="";for(let e=0;e<n.style.length;e++){let i=n.style.item(e);t+=_G(0,i,n.style.getPropertyValue(i))}for(let e in n.style)n.style.hasOwnProperty(e)&&!e.startsWith("_")&&(t+=_G(0,Ohe(e),n.style[e]));n.setAttribute("style",t)}function bc(n,t,e){n.style&&(t.forEach((i,r)=>{let o=FO(r);e&&!e.has(r)&&e.set(r,n.style[o]),n.style[o]=i}),AO()&&NG(n))}function sh(n,t){n.style&&(t.forEach((e,i)=>{let r=FO(i);n.style[r]=""}),AO()&&NG(n))}function Vb(n){return Array.isArray(n)?1==n.length?n[0]:Ew(n):n}var yO=new RegExp("{{\\s*(.+?)\\s*}}","g");function LG(n){let t=[];if("string"==typeof n){let e;for(;e=yO.exec(n);)t.push(e[1]);yO.lastIndex=0}return t}function zb(n,t,e){let i=n.toString(),r=i.replace(yO,(o,a)=>{let s=t[a];return null==s&&(e.push(new xt(3003,!1)),s=""),s.toString()});return r==i?n:r}function Ow(n){let t=[],e=n.next();for(;!e.done;)t.push(e.value),e=n.next();return t}var khe=/-+([a-z0-9])/g;function FO(n){return n.replace(khe,(...t)=>t[1].toUpperCase())}function Ohe(n){return n.replace(/([a-z])([A-Z])/g,"$1-$2").toLowerCase()}function us(n,t,e){switch(t.type){case 7:return n.visitTrigger(t,e);case 0:return n.visitState(t,e);case 1:return n.visitTransition(t,e);case 2:return n.visitSequence(t,e);case 3:return n.visitGroup(t,e);case 4:return n.visitAnimate(t,e);case 5:return n.visitKeyframes(t,e);case 6:return n.visitStyle(t,e);case 8:return n.visitReference(t,e);case 9:return n.visitAnimateChild(t,e);case 10:return n.visitAnimateRef(t,e);case 11:return n.visitQuery(t,e);case 12:return n.visitStagger(t,e);default:throw new xt(3004,!1)}}function BG(n,t){return window.getComputedStyle(n)[t]}var Fw="*";function Vhe(n,t){let e=[];return"string"==typeof n?n.split(/\s*,\s*/).forEach(i=>function(n,t,e){if(":"==n[0]){let l=function(n,t){switch(n){case":enter":return"void => *";case":leave":return"* => void";case":increment":return(e,i)=>parseFloat(i)>parseFloat(e);case":decrement":return(e,i)=>parseFloat(i)<parseFloat(e);default:return t.push(new xt(3016,!1)),"* => *"}}(n,e);if("function"==typeof l)return void t.push(l);n=l}let i=n.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);if(null==i||i.length<4)return e.push(new xt(3015,!1)),t;let r=i[1],o=i[2],a=i[3];t.push(bG(r,a)),"<"==o[0]&&!(r==Fw&&a==Fw)&&t.push(bG(a,r))}(i,e,t)):e.push(n),e}var Iw=new Set(["true","1"]),Aw=new Set(["false","0"]);function bG(n,t){let e=Iw.has(n)||Aw.has(n),i=Iw.has(t)||Aw.has(t);return(r,o)=>{let a=n==Fw||n==r,s=t==Fw||t==o;return!a&&e&&"boolean"==typeof r&&(a=r?Iw.has(n):Aw.has(n)),!s&&i&&"boolean"==typeof o&&(s=o?Iw.has(t):Aw.has(t)),a&&s}}var Uhe=new RegExp("s*:selfs*,?","g");function UG(n,t,e,i){return new xO(n).build(t,e,i)}var xO=class{constructor(t){this._driver=t}build(t,e,i){let r=new CO(e);return this._resetContextStyleTimingState(r),us(this,Vb(t),r)}_resetContextStyleTimingState(t){t.currentQuerySelector="",t.collectedStyles=new Map,t.collectedStyles.set("",new Map),t.currentTime=0}visitTrigger(t,e){let i=e.queryCount=0,r=e.depCount=0,o=[],a=[];return"@"==t.name.charAt(0)&&e.errors.push(new xt(3006,!1)),t.definitions.forEach(s=>{if(this._resetContextStyleTimingState(e),0==s.type){let l=s,c=l.name;c.toString().split(/\s*,\s*/).forEach(d=>{l.name=d,o.push(this.visitState(l,e))}),l.name=c}else if(1==s.type){let l=this.visitTransition(s,e);i+=l.queryCount,r+=l.depCount,a.push(l)}else e.errors.push(new xt(3007,!1))}),{type:7,name:t.name,states:o,transitions:a,queryCount:i,depCount:r,options:null}}visitState(t,e){let i=this.visitStyle(t.styles,e),r=t.options&&t.options.params||null;if(i.containsDynamicStyles){let o=new Set,a=r||{};i.styles.forEach(s=>{s instanceof Map&&s.forEach(l=>{LG(l).forEach(c=>{a.hasOwnProperty(c)||o.add(c)})})}),o.size&&(Ow(o.values()),e.errors.push(new xt(3008,!1)))}return{type:0,name:t.name,style:i,options:r?{params:r}:null}}visitTransition(t,e){e.queryCount=0,e.depCount=0;let i=us(this,Vb(t.animation),e);return{type:1,matchers:Vhe(t.expr,e.errors),animation:i,queryCount:e.queryCount,depCount:e.depCount,options:ah(t.options)}}visitSequence(t,e){return{type:2,steps:t.steps.map(i=>us(this,i,e)),options:ah(t.options)}}visitGroup(t,e){let i=e.currentTime,r=0,o=t.steps.map(a=>{e.currentTime=i;let s=us(this,a,e);return r=Math.max(r,e.currentTime),s});return e.currentTime=r,{type:3,steps:o,options:ah(t.options)}}visitAnimate(t,e){let i=function(n,t){if(n.hasOwnProperty("duration"))return n;if("number"==typeof n)return uO(kw(n,t).duration,0,"");let e=n;if(e.split(/\s+/).some(o=>"{"==o.charAt(0)&&"{"==o.charAt(1))){let o=uO(0,0,"");return o.dynamic=!0,o.strValue=e,o}let r=kw(e,t);return uO(r.duration,r.delay,r.easing)}(t.timings,e.errors);e.currentAnimateTimings=i;let r,o=t.styles?t.styles:rn({});if(5==o.type)r=this.visitKeyframes(o,e);else{let a=t.styles,s=!1;if(!a){s=!0;let c={};i.easing&&(c.easing=i.easing),a=rn(c)}e.currentTime+=i.duration+i.delay;let l=this.visitStyle(a,e);l.isEmptyStep=s,r=l}return e.currentAnimateTimings=null,{type:4,timings:i,style:r,options:null}}visitStyle(t,e){let i=this._makeStyleAst(t,e);return this._validateStyleAst(i,e),i}_makeStyleAst(t,e){let i=[],r=Array.isArray(t.styles)?t.styles:[t.styles];for(let s of r)"string"==typeof s?s===_c?i.push(s):e.errors.push(new xt(3002,!1)):i.push(FG(s));let o=!1,a=null;return i.forEach(s=>{if(s instanceof Map&&(s.has("easing")&&(a=s.get("easing"),s.delete("easing")),!o))for(let l of s.values())if(l.toString().indexOf("{{")>=0){o=!0;break}}),{type:6,styles:i,easing:a,offset:t.offset,containsDynamicStyles:o,options:null}}_validateStyleAst(t,e){let i=e.currentAnimateTimings,r=e.currentTime,o=e.currentTime;i&&o>0&&(o-=i.duration+i.delay),t.styles.forEach(a=>{"string"!=typeof a&&a.forEach((s,l)=>{let c=e.collectedStyles.get(e.currentQuerySelector),d=c.get(l),u=!0;d&&(o!=r&&o>=d.startTime&&r<=d.endTime&&(e.errors.push(new xt(3010,!1)),u=!1),o=d.startTime),u&&c.set(l,{startTime:o,endTime:r}),e.options&&function(n,t,e){let i=t.params||{},r=LG(n);r.length&&r.forEach(o=>{i.hasOwnProperty(o)||e.push(new xt(3001,!1))})}(s,e.options,e.errors)})})}visitKeyframes(t,e){let i={type:5,styles:[],options:null};if(!e.currentAnimateTimings)return e.errors.push(new xt(3011,!1)),i;let o=0,a=[],s=!1,l=!1,c=0,d=t.steps.map(y=>{let x=this._makeStyleAst(y,e),R=null!=x.offset?x.offset:function(n){if("string"==typeof n)return null;let t=null;if(Array.isArray(n))n.forEach(e=>{if(e instanceof Map&&e.has("offset")){let i=e;t=parseFloat(i.get("offset")),i.delete("offset")}});else if(n instanceof Map&&n.has("offset")){let e=n;t=parseFloat(e.get("offset")),e.delete("offset")}return t}(x.styles),I=0;return null!=R&&(o++,I=x.offset=R),l=l||I<0||I>1,s=s||I<c,c=I,a.push(I),x});l&&e.errors.push(new xt(3012,!1)),s&&e.errors.push(new xt(3200,!1));let u=t.steps.length,p=0;o>0&&o<u?e.errors.push(new xt(3202,!1)):0==o&&(p=1/(u-1));let h=u-1,m=e.currentTime,_=e.currentAnimateTimings,M=_.duration;return d.forEach((y,x)=>{let R=p>0?x==h?1:p*x:a[x],I=R*M;e.currentTime=m+_.delay+I,_.duration=I,this._validateStyleAst(y,e),y.offset=R,i.styles.push(y)}),i}visitReference(t,e){return{type:8,animation:us(this,Vb(t.animation),e),options:ah(t.options)}}visitAnimateChild(t,e){return e.depCount++,{type:9,options:ah(t.options)}}visitAnimateRef(t,e){return{type:10,animation:this.visitReference(t.animation,e),options:ah(t.options)}}visitQuery(t,e){let i=e.currentQuerySelector,r=t.options||{};e.queryCount++,e.currentQuery=t;let[o,a]=function(n){let t=!!n.split(/\s*,\s*/).find(e=>":self"==e);return t&&(n=n.replace(Uhe,"")),n=n.replace(/@\*/g,Pw).replace(/@\w+/g,e=>Pw+"-"+e.slice(1)).replace(/:animating/g,bO),[n,t]}(t.selector);e.currentQuerySelector=i.length?i+" "+o:o,ps(e.collectedStyles,e.currentQuerySelector,new Map);let s=us(this,Vb(t.animation),e);return e.currentQuery=null,e.currentQuerySelector=i,{type:11,selector:o,limit:r.limit||0,optional:!!r.optional,includeSelf:a,animation:s,originalSelector:t.selector,options:ah(t.options)}}visitStagger(t,e){e.currentQuery||e.errors.push(new xt(3013,!1));let i="full"===t.timings?{duration:0,delay:0,easing:"full"}:kw(t.timings,e.errors,!0);return{type:12,animation:us(this,Vb(t.animation),e),timings:i,options:null}}},CO=class{constructor(t){this.errors=t,this.queryCount=0,this.depCount=0,this.currentTransition=null,this.currentQuery=null,this.currentQuerySelector=null,this.currentAnimateTimings=null,this.currentTime=0,this.collectedStyles=new Map,this.options=null,this.unsupportedCSSPropertiesFound=new Set}};function ah(n){return n?(n=Xb(n)).params&&(n.params=function(n){return n?Xb(n):null}(n.params)):n={},n}function uO(n,t,e){return{duration:n,delay:t,easing:e}}function NO(n,t,e,i,r,o,a=null,s=!1){return{type:1,element:n,keyframes:t,preStyleProps:e,postStyleProps:i,duration:r,delay:o,totalTime:r+o,easing:a,subTimeline:s}}var Ub=class{constructor(){this._map=new Map}get(t){return this._map.get(t)||[]}append(t,e){let i=this._map.get(t);i||this._map.set(t,i=[]),i.push(...e)}has(t){return this._map.has(t)}clear(){this._map.clear()}},Qhe=new RegExp(":enter","g"),Khe=new RegExp(":leave","g");function jG(n,t,e,i,r,o=new Map,a=new Map,s,l,c=[]){return(new MO).buildKeyframes(n,t,e,i,r,o,a,s,l,c)}var MO=class{buildKeyframes(t,e,i,r,o,a,s,l,c,d=[]){c=c||new Ub;let u=new jb(t,e,c,r,o,d,[]);u.options=l;let p=l.delay?cd(l.delay):0;u.currentTimeline.delayNextStep(p),u.currentTimeline.setStyles([a],null,u.errors,l),us(this,i,u);let h=u.timelines.filter(m=>m.containsAnimation());if(h.length&&s.size){let m;for(let _=h.length-1;_>=0;_--){let M=h[_];if(M.element===e){m=M;break}}m&&!m.allowOnlyTimelineStyles()&&m.setStyles([s],null,u.errors,l)}return h.length?h.map(m=>m.buildKeyframes()):[NO(e,[],[],[],0,p,"",!1)]}visitTrigger(t,e){}visitState(t,e){}visitTransition(t,e){}visitAnimateChild(t,e){let i=e.subInstructions.get(e.element);if(i){let r=e.createSubContext(t.options),o=e.currentTimeline.currentTime,a=this._visitSubInstructions(i,r,r.options);o!=a&&e.transformIntoNewTimeline(a)}e.previousNode=t}visitAnimateRef(t,e){let i=e.createSubContext(t.options);i.transformIntoNewTimeline(),this._applyAnimationRefDelays([t.options,t.animation.options],e,i),this.visitReference(t.animation,i),e.transformIntoNewTimeline(i.currentTimeline.currentTime),e.previousNode=t}_applyAnimationRefDelays(t,e,i){for(let r of t){let o=r?.delay;if(o){let a="number"==typeof o?o:cd(zb(o,r?.params??{},e.errors));i.delayNextStep(a)}}}_visitSubInstructions(t,e,i){let o=e.currentTimeline.currentTime,a=null!=i.duration?cd(i.duration):null,s=null!=i.delay?cd(i.delay):null;return 0!==a&&t.forEach(l=>{let c=e.appendInstructionToTimeline(l,a,s);o=Math.max(o,c.duration+c.delay)}),o}visitReference(t,e){e.updateOptions(t.options,!0),us(this,t.animation,e),e.previousNode=t}visitSequence(t,e){let i=e.subContextCount,r=e,o=t.options;if(o&&(o.params||o.delay)&&(r=e.createSubContext(o),r.transformIntoNewTimeline(),null!=o.delay)){6==r.previousNode.type&&(r.currentTimeline.snapshotCurrentStyles(),r.previousNode=Nw);let a=cd(o.delay);r.delayNextStep(a)}t.steps.length&&(t.steps.forEach(a=>us(this,a,r)),r.currentTimeline.applyStylesToKeyframe(),r.subContextCount>i&&r.transformIntoNewTimeline()),e.previousNode=t}visitGroup(t,e){let i=[],r=e.currentTimeline.currentTime,o=t.options&&t.options.delay?cd(t.options.delay):0;t.steps.forEach(a=>{let s=e.createSubContext(t.options);o&&s.delayNextStep(o),us(this,a,s),r=Math.max(r,s.currentTimeline.currentTime),i.push(s.currentTimeline)}),i.forEach(a=>e.currentTimeline.mergeTimelineCollectedStyles(a)),e.transformIntoNewTimeline(r),e.previousNode=t}_visitTiming(t,e){if(t.dynamic){let i=t.strValue;return kw(e.params?zb(i,e.params,e.errors):i,e.errors)}return{duration:t.duration,delay:t.delay,easing:t.easing}}visitAnimate(t,e){let i=e.currentAnimateTimings=this._visitTiming(t.timings,e),r=e.currentTimeline;i.delay&&(e.incrementTime(i.delay),r.snapshotCurrentStyles());let o=t.style;5==o.type?this.visitKeyframes(o,e):(e.incrementTime(i.duration),this.visitStyle(o,e),r.applyStylesToKeyframe()),e.currentAnimateTimings=null,e.previousNode=t}visitStyle(t,e){let i=e.currentTimeline,r=e.currentAnimateTimings;!r&&i.hasCurrentStyleProperties()&&i.forwardFrame();let o=r&&r.easing||t.easing;t.isEmptyStep?i.applyEmptyStep(o):i.setStyles(t.styles,o,e.errors,e.options),e.previousNode=t}visitKeyframes(t,e){let i=e.currentAnimateTimings,r=e.currentTimeline.duration,o=i.duration,s=e.createSubContext().currentTimeline;s.easing=i.easing,t.styles.forEach(l=>{s.forwardTime((l.offset||0)*o),s.setStyles(l.styles,l.easing,e.errors,e.options),s.applyStylesToKeyframe()}),e.currentTimeline.mergeTimelineCollectedStyles(s),e.transformIntoNewTimeline(r+o),e.previousNode=t}visitQuery(t,e){let i=e.currentTimeline.currentTime,r=t.options||{},o=r.delay?cd(r.delay):0;o&&(6===e.previousNode.type||0==i&&e.currentTimeline.hasCurrentStyleProperties())&&(e.currentTimeline.snapshotCurrentStyles(),e.previousNode=Nw);let a=i,s=e.invokeQuery(t.selector,t.originalSelector,t.limit,t.includeSelf,!!r.optional,e.errors);e.currentQueryTotal=s.length;let l=null;s.forEach((c,d)=>{e.currentQueryIndex=d;let u=e.createSubContext(t.options,c);o&&u.delayNextStep(o),c===e.element&&(l=u.currentTimeline),us(this,t.animation,u),u.currentTimeline.applyStylesToKeyframe(),a=Math.max(a,u.currentTimeline.currentTime)}),e.currentQueryIndex=0,e.currentQueryTotal=0,e.transformIntoNewTimeline(a),l&&(e.currentTimeline.mergeTimelineCollectedStyles(l),e.currentTimeline.snapshotCurrentStyles()),e.previousNode=t}visitStagger(t,e){let i=e.parentContext,r=e.currentTimeline,o=t.timings,a=Math.abs(o.duration),s=a*(e.currentQueryTotal-1),l=a*e.currentQueryIndex;switch(o.duration<0?"reverse":o.easing){case"reverse":l=s-l;break;case"full":l=i.currentStaggerTime}let d=e.currentTimeline;l&&d.delayNextStep(l);let u=d.currentTime;us(this,t.animation,e),e.previousNode=t,i.currentStaggerTime=r.currentTime-u+(r.startTime-i.currentTimeline.startTime)}},Nw={},jb=class{constructor(t,e,i,r,o,a,s,l){this._driver=t,this.element=e,this.subInstructions=i,this._enterClassName=r,this._leaveClassName=o,this.errors=a,this.timelines=s,this.parentContext=null,this.currentAnimateTimings=null,this.previousNode=Nw,this.subContextCount=0,this.options={},this.currentQueryIndex=0,this.currentQueryTotal=0,this.currentStaggerTime=0,this.currentTimeline=l||new Tf(this._driver,e,0),s.push(this.currentTimeline)}get params(){return this.options.params}updateOptions(t,e){if(!t)return;let i=t,r=this.options;null!=i.duration&&(r.duration=cd(i.duration)),null!=i.delay&&(r.delay=cd(i.delay));let o=i.params;if(o){let a=r.params;a||(a=this.options.params={}),Object.keys(o).forEach(s=>{(!e||!a.hasOwnProperty(s))&&(a[s]=zb(o[s],a,this.errors))})}}_copyOptions(){let t={};if(this.options){let e=this.options.params;if(e){let i=t.params={};Object.keys(e).forEach(r=>{i[r]=e[r]})}}return t}createSubContext(t=null,e,i){let r=e||this.element,o=new jb(this._driver,r,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(r,i||0));return o.previousNode=this.previousNode,o.currentAnimateTimings=this.currentAnimateTimings,o.options=this._copyOptions(),o.updateOptions(t),o.currentQueryIndex=this.currentQueryIndex,o.currentQueryTotal=this.currentQueryTotal,o.parentContext=this,this.subContextCount++,o}transformIntoNewTimeline(t){return this.previousNode=Nw,this.currentTimeline=this.currentTimeline.fork(this.element,t),this.timelines.push(this.currentTimeline),this.currentTimeline}appendInstructionToTimeline(t,e,i){let r={duration:e??t.duration,delay:this.currentTimeline.currentTime+(i??0)+t.delay,easing:""},o=new wO(this._driver,t.element,t.keyframes,t.preStyleProps,t.postStyleProps,r,t.stretchStartingKeyframe);return this.timelines.push(o),r}incrementTime(t){this.currentTimeline.forwardTime(this.currentTimeline.duration+t)}delayNextStep(t){t>0&&this.currentTimeline.delayNextStep(t)}invokeQuery(t,e,i,r,o,a){let s=[];if(r&&s.push(this.element),t.length>0){t=(t=t.replace(Qhe,"."+this._enterClassName)).replace(Khe,"."+this._leaveClassName);let c=this._driver.query(this.element,t,1!=i);0!==i&&(c=i<0?c.slice(c.length+i,c.length):c.slice(0,i)),s.push(...c)}return!o&&0==s.length&&a.push(new xt(3014,!1)),s}},Tf=class{constructor(t,e,i,r){this._driver=t,this.element=e,this.startTime=i,this._elementTimelineStylesLookup=r,this.duration=0,this.easing=null,this._previousKeyframe=new Map,this._currentKeyframe=new Map,this._keyframes=new Map,this._styleSummary=new Map,this._localTimelineStyles=new Map,this._pendingStyles=new Map,this._backFill=new Map,this._currentEmptyStepKeyframe=null,this._elementTimelineStylesLookup||(this._elementTimelineStylesLookup=new Map),this._globalTimelineStyles=this._elementTimelineStylesLookup.get(e),this._globalTimelineStyles||(this._globalTimelineStyles=this._localTimelineStyles,this._elementTimelineStylesLookup.set(e,this._localTimelineStyles)),this._loadKeyframe()}containsAnimation(){switch(this._keyframes.size){case 0:return!1;case 1:return this.hasCurrentStyleProperties();default:return!0}}hasCurrentStyleProperties(){return this._currentKeyframe.size>0}get currentTime(){return this.startTime+this.duration}delayNextStep(t){let e=1===this._keyframes.size&&this._pendingStyles.size;this.duration||e?(this.forwardTime(this.currentTime+t),e&&this.snapshotCurrentStyles()):this.startTime+=t}fork(t,e){return this.applyStylesToKeyframe(),new Tf(this._driver,t,e||this.currentTime,this._elementTimelineStylesLookup)}_loadKeyframe(){this._currentKeyframe&&(this._previousKeyframe=this._currentKeyframe),this._currentKeyframe=this._keyframes.get(this.duration),this._currentKeyframe||(this._currentKeyframe=new Map,this._keyframes.set(this.duration,this._currentKeyframe))}forwardFrame(){this.duration+=1,this._loadKeyframe()}forwardTime(t){this.applyStylesToKeyframe(),this.duration=t,this._loadKeyframe()}_updateStyle(t,e){this._localTimelineStyles.set(t,e),this._globalTimelineStyles.set(t,e),this._styleSummary.set(t,{time:this.currentTime,value:e})}allowOnlyTimelineStyles(){return this._currentEmptyStepKeyframe!==this._currentKeyframe}applyEmptyStep(t){t&&this._previousKeyframe.set("easing",t);for(let[e,i]of this._globalTimelineStyles)this._backFill.set(e,i||_c),this._currentKeyframe.set(e,_c);this._currentEmptyStepKeyframe=this._currentKeyframe}setStyles(t,e,i,r){e&&this._previousKeyframe.set("easing",e);let o=r&&r.params||{},a=function(n,t){let i,e=new Map;return n.forEach(r=>{if("*"===r){i=i||t.keys();for(let o of i)e.set(o,_c)}else Ef(r,e)}),e}(t,this._globalTimelineStyles);for(let[s,l]of a){let c=zb(l,o,i);this._pendingStyles.set(s,c),this._localTimelineStyles.has(s)||this._backFill.set(s,this._globalTimelineStyles.get(s)??_c),this._updateStyle(s,c)}}applyStylesToKeyframe(){0!=this._pendingStyles.size&&(this._pendingStyles.forEach((t,e)=>{this._currentKeyframe.set(e,t)}),this._pendingStyles.clear(),this._localTimelineStyles.forEach((t,e)=>{this._currentKeyframe.has(e)||this._currentKeyframe.set(e,t)}))}snapshotCurrentStyles(){for(let[t,e]of this._localTimelineStyles)this._pendingStyles.set(t,e),this._updateStyle(t,e)}getFinalKeyframe(){return this._keyframes.get(this.duration)}get properties(){let t=[];for(let e in this._currentKeyframe)t.push(e);return t}mergeTimelineCollectedStyles(t){t._styleSummary.forEach((e,i)=>{let r=this._styleSummary.get(i);(!r||e.time>r.time)&&this._updateStyle(i,e.value)})}buildKeyframes(){this.applyStylesToKeyframe();let t=new Set,e=new Set,i=1===this._keyframes.size&&0===this.duration,r=[];this._keyframes.forEach((s,l)=>{let c=Ef(s,new Map,this._backFill);c.forEach((d,u)=>{d===Tw?t.add(u):d===_c&&e.add(u)}),i||c.set("offset",l/this.duration),r.push(c)});let o=t.size?Ow(t.values()):[],a=e.size?Ow(e.values()):[];if(i){let s=r[0],l=new Map(s);s.set("offset",0),l.set("offset",1),r=[s,l]}return NO(this.element,r,o,a,this.duration,this.startTime,this.easing,!1)}},wO=class extends Tf{constructor(t,e,i,r,o,a,s=!1){super(t,e,a.delay),this.keyframes=i,this.preStyleProps=r,this.postStyleProps=o,this._stretchStartingKeyframe=s,this.timings={duration:a.duration,delay:a.delay,easing:a.easing}}containsAnimation(){return this.keyframes.length>1}buildKeyframes(){let t=this.keyframes,{delay:e,duration:i,easing:r}=this.timings;if(this._stretchStartingKeyframe&&e){let o=[],a=i+e,s=e/a,l=Ef(t[0]);l.set("offset",0),o.push(l);let c=Ef(t[0]);c.set("offset",yG(s)),o.push(c);let d=t.length-1;for(let u=1;u<=d;u++){let p=Ef(t[u]),h=p.get("offset");p.set("offset",yG((e+h*i)/a)),o.push(p)}i=a,e=0,r="",t=o}return NO(this.element,t,this.preStyleProps,this.postStyleProps,i,e,r,!0)}};function yG(n,t=3){let e=Math.pow(10,t-1);return Math.round(n*e)/e}var lh=class{},$he=new Set(["width","height","minWidth","minHeight","maxWidth","maxHeight","left","top","bottom","right","fontSize","outlineWidth","outlineOffset","paddingTop","paddingLeft","paddingBottom","paddingRight","marginTop","marginLeft","marginBottom","marginRight","borderRadius","borderWidth","borderTopWidth","borderLeftWidth","borderRightWidth","borderBottomWidth","textIndent","perspective"]),Lw=class extends lh{normalizePropertyName(t,e){return FO(t)}normalizeStyleValue(t,e,i,r){let o="",a=i.toString().trim();if($he.has(e)&&0!==i&&"0"!==i)if("number"==typeof i)o="px";else{let s=i.match(/^[+-]?[\d\.]+([a-z]*)$/);s&&0==s[1].length&&r.push(new xt(3005,!1))}return a+o}};function xG(n,t,e,i,r,o,a,s,l,c,d,u,p){return{type:0,element:n,triggerName:t,isRemovalTransition:r,fromState:e,fromStyles:o,toState:i,toStyles:a,timelines:s,queriedElements:l,preStyleProps:c,postStyleProps:d,totalTime:u,errors:p}}var pO={},Bw=class{constructor(t,e,i){this._triggerName=t,this.ast=e,this._stateStyles=i}match(t,e,i,r){return function(n,t,e,i,r){return n.some(o=>o(t,e,i,r))}(this.ast.matchers,t,e,i,r)}buildStyles(t,e,i){let r=this._stateStyles.get("*");return void 0!==t&&(r=this._stateStyles.get(t?.toString())||r),r?r.buildStyles(e,i):new Map}build(t,e,i,r,o,a,s,l,c,d){let u=[],p=this.ast.options&&this.ast.options.params||pO,m=this.buildStyles(i,s&&s.params||pO,u),_=l&&l.params||pO,M=this.buildStyles(r,_,u),y=new Set,x=new Map,R=new Map,I="void"===r,B={params:tme(_,p),delay:this.ast.options?.delay},ee=d?[]:jG(t,e,this.ast.animation,o,a,m,M,B,c,u),Q=0;if(ee.forEach(Qe=>{Q=Math.max(Qe.duration+Qe.delay,Q)}),u.length)return xG(e,this._triggerName,i,r,I,m,M,[],[],x,R,Q,u);ee.forEach(Qe=>{let Ae=Qe.element,D=ps(x,Ae,new Set);Qe.preStyleProps.forEach(ce=>D.add(ce));let re=ps(R,Ae,new Set);Qe.postStyleProps.forEach(ce=>re.add(ce)),Ae!==e&&y.add(Ae)});let we=Ow(y.values());return xG(e,this._triggerName,i,r,I,m,M,ee,we,x,R,Q)}};function tme(n,t){let e=Xb(t);for(let i in n)n.hasOwnProperty(i)&&null!=n[i]&&(e[i]=n[i]);return e}function CG(n,t,e){n.has(t)?n.has(e)||n.set(e,n.get(t)):n.has(e)&&n.set(t,n.get(e))}var rme=new Ub,MG="ng-animate-queued",hO="ng-animate-disabled",cme=[],GG={namespaceId:"",setForRemoval:!1,setForMove:!1,hasAnimation:!1,removedBeforeQueried:!1},dme={namespaceId:"",setForMove:!1,setForRemoval:!1,hasAnimation:!1,removedBeforeQueried:!0},js="__ng_removed",Gb=class{get params(){return this.options.params}constructor(t,e=""){this.namespaceId=e;let i=t&&t.hasOwnProperty("value");if(this.value=(i?t.value:t)??null,i){let o=Xb(t);delete o.value,this.options=o}else this.options={};this.options.params||(this.options.params={})}absorbOptions(t){let e=t.params;if(e){let i=this.options.params;Object.keys(e).forEach(r=>{null==i[r]&&(i[r]=e[r])})}}},Hb="void",mO=new Gb(Hb),Wb=class{constructor(t,e,i){this.namespaceId=t,this.triggerName=e,this.element=i,this._player=new pu,this._containsRealPlayer=!1,this._queuedCallbacks=new Map,this.destroyed=!1,this.parentPlayer=null,this.markedForDestroy=!1,this.disabled=!1,this.queued=!0,this.totalTime=0}setRealPlayer(t){this._containsRealPlayer||(this._player=t,this._queuedCallbacks.forEach((e,i)=>{e.forEach(r=>RO(t,i,void 0,r))}),this._queuedCallbacks.clear(),this._containsRealPlayer=!0,this.overrideTotalTime(t.totalTime),this.queued=!1)}getRealPlayer(){return this._player}overrideTotalTime(t){this.totalTime=t}syncPlayerEvents(t){let e=this._player;e.triggerCallback&&t.onStart(()=>e.triggerCallback("start")),t.onDone(()=>this.finish()),t.onDestroy(()=>this.destroy())}_queueEvent(t,e){ps(this._queuedCallbacks,t,[]).push(e)}onDone(t){this.queued&&this._queueEvent("done",t),this._player.onDone(t)}onStart(t){this.queued&&this._queueEvent("start",t),this._player.onStart(t)}onDestroy(t){this.queued&&this._queueEvent("destroy",t),this._player.onDestroy(t)}init(){this._player.init()}hasStarted(){return!this.queued&&this._player.hasStarted()}play(){!this.queued&&this._player.play()}pause(){!this.queued&&this._player.pause()}restart(){!this.queued&&this._player.restart()}finish(){this._player.finish()}destroy(){this.destroyed=!0,this._player.destroy()}reset(){!this.queued&&this._player.reset()}setPosition(t){this.queued||this._player.setPosition(t)}getPosition(){return this.queued?0:this._player.getPosition()}triggerCallback(t){let e=this._player;e.triggerCallback&&e.triggerCallback(t)}};function Rw(n){return n&&1===n.nodeType}function wG(n,t){let e=n.style.display;return n.style.display=t??"none",e}function SG(n,t,e,i,r){let o=[];e.forEach(l=>o.push(wG(l)));let a=[];i.forEach((l,c)=>{let d=new Map;l.forEach(u=>{let p=t.computeStyle(c,u,r);d.set(u,p),(!p||0==p.length)&&(c[js]=dme,a.push(c))}),n.set(c,d)});let s=0;return e.forEach(l=>wG(l,o[s++])),a}function EG(n,t){let e=new Map;if(n.forEach(s=>e.set(s,[])),0==t.length)return e;let i=1,r=new Set(t),o=new Map;function a(s){if(!s)return i;let l=o.get(s);if(l)return l;let c=s.parentNode;return l=e.has(c)?c:r.has(c)?i:a(c),o.set(s,l),l}return t.forEach(s=>{let l=a(s);l!==i&&e.get(l).push(s)}),e}function Gs(n,t){n.classList?.add(t)}function Sf(n,t){n.classList?.remove(t)}function mme(n,t,e){hu(e).onDone(()=>n.processLeaveNode(t))}function WG(n,t){for(let e=0;e<n.length;e++){let i=n[e];i instanceof Nb?WG(i.players,t):t.push(i)}}function TG(n,t,e){let i=e.get(n);if(!i)return!1;let r=t.get(n);return r?i.forEach(o=>r.add(o)):t.set(n,i),e.delete(n),!0}var mu=class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._triggerCache={},this.onRemovalComplete=(r,o)=>{},this._transitionEngine=new class{_onRemovalComplete(t,e){this.onRemovalComplete(t,e)}constructor(t,e,i){this.bodyNode=t,this.driver=e,this._normalizer=i,this.players=[],this.newHostElements=new Map,this.playersByElement=new Map,this.playersByQueriedElement=new Map,this.statesByElement=new Map,this.disabledNodes=new Set,this.totalAnimations=0,this.totalQueuedPlayers=0,this._namespaceLookup={},this._namespaceList=[],this._flushFns=[],this._whenQuietFns=[],this.namespacesByHostElement=new Map,this.collectedEnterElements=[],this.collectedLeaveElements=[],this.onRemovalComplete=(r,o)=>{}}get queuedPlayers(){let t=[];return this._namespaceList.forEach(e=>{e.players.forEach(i=>{i.queued&&t.push(i)})}),t}createNamespace(t,e){let i=new class{constructor(t,e,i){this.id=t,this.hostElement=e,this._engine=i,this.players=[],this._triggers=new Map,this._queue=[],this._elementListeners=new Map,this._hostClassName="ng-tns-"+t,Gs(e,this._hostClassName)}listen(t,e,i,r){if(!this._triggers.has(e))throw new xt(3302,!1);if(null==i||0==i.length)throw new xt(3303,!1);if("start"!=(n=i)&&"done"!=n)throw new xt(3400,!1);var n;let o=ps(this._elementListeners,t,[]),a={name:e,phase:i,callback:r};o.push(a);let s=ps(this._engine.statesByElement,t,new Map);return s.has(e)||(Gs(t,Dw),Gs(t,Dw+"-"+e),s.set(e,mO)),()=>{this._engine.afterFlush(()=>{let l=o.indexOf(a);l>=0&&o.splice(l,1),this._triggers.has(e)||s.delete(e)})}}register(t,e){return!this._triggers.has(t)&&(this._triggers.set(t,e),!0)}_getTrigger(t){let e=this._triggers.get(t);if(!e)throw new xt(3401,!1);return e}trigger(t,e,i,r=!0){let o=this._getTrigger(e),a=new Wb(this.id,e,t),s=this._engine.statesByElement.get(t);s||(Gs(t,Dw),Gs(t,Dw+"-"+e),this._engine.statesByElement.set(t,s=new Map));let l=s.get(e),c=new Gb(i,this.id);if(!(i&&i.hasOwnProperty("value"))&&l&&c.absorbOptions(l.options),s.set(e,c),l||(l=mO),c.value!==Hb&&l.value===c.value){if(!function(n,t){let e=Object.keys(n),i=Object.keys(t);if(e.length!=i.length)return!1;for(let r=0;r<e.length;r++){let o=e[r];if(!t.hasOwnProperty(o)||n[o]!==t[o])return!1}return!0}(l.params,c.params)){let _=[],M=o.matchStyles(l.value,l.params,_),y=o.matchStyles(c.value,c.params,_);_.length?this._engine.reportError(_):this._engine.afterFlush(()=>{sh(t,M),bc(t,y)})}return}let p=ps(this._engine.playersByElement,t,[]);p.forEach(_=>{_.namespaceId==this.id&&_.triggerName==e&&_.queued&&_.destroy()});let h=o.matchTransition(l.value,c.value,t,c.params),m=!1;if(!h){if(!r)return;h=o.fallbackTransition,m=!0}return this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:e,transition:h,fromState:l,toState:c,player:a,isFallbackTransition:m}),m||(Gs(t,MG),a.onStart(()=>{Sf(t,MG)})),a.onDone(()=>{let _=this.players.indexOf(a);_>=0&&this.players.splice(_,1);let M=this._engine.playersByElement.get(t);if(M){let y=M.indexOf(a);y>=0&&M.splice(y,1)}}),this.players.push(a),p.push(a),a}deregister(t){this._triggers.delete(t),this._engine.statesByElement.forEach(e=>e.delete(t)),this._elementListeners.forEach((e,i)=>{this._elementListeners.set(i,e.filter(r=>r.name!=t))})}clearElementCache(t){this._engine.statesByElement.delete(t),this._elementListeners.delete(t);let e=this._engine.playersByElement.get(t);e&&(e.forEach(i=>i.destroy()),this._engine.playersByElement.delete(t))}_signalRemovalForInnerTriggers(t,e){let i=this._engine.driver.query(t,Pw,!0);i.forEach(r=>{if(r[js])return;let o=this._engine.fetchNamespacesByElement(r);o.size?o.forEach(a=>a.triggerLeaveAnimation(r,e,!1,!0)):this.clearElementCache(r)}),this._engine.afterFlushAnimationsDone(()=>i.forEach(r=>this.clearElementCache(r)))}triggerLeaveAnimation(t,e,i,r){let o=this._engine.statesByElement.get(t),a=new Map;if(o){let s=[];if(o.forEach((l,c)=>{if(a.set(c,l.value),this._triggers.has(c)){let d=this.trigger(t,c,Hb,r);d&&s.push(d)}}),s.length)return this._engine.markElementAsRemoved(this.id,t,!0,e,a),i&&hu(s).onDone(()=>this._engine.processLeaveNode(t)),!0}return!1}prepareLeaveAnimationListeners(t){let e=this._elementListeners.get(t),i=this._engine.statesByElement.get(t);if(e&&i){let r=new Set;e.forEach(o=>{let a=o.name;if(r.has(a))return;r.add(a);let l=this._triggers.get(a).fallbackTransition,c=i.get(a)||mO,d=new Gb(Hb),u=new Wb(this.id,a,t);this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:a,transition:l,fromState:c,toState:d,player:u,isFallbackTransition:!0})})}}removeNode(t,e){let i=this._engine;if(t.childElementCount&&this._signalRemovalForInnerTriggers(t,e),this.triggerLeaveAnimation(t,e,!0))return;let r=!1;if(i.totalAnimations){let o=i.players.length?i.playersByQueriedElement.get(t):[];if(o&&o.length)r=!0;else{let a=t;for(;a=a.parentNode;)if(i.statesByElement.get(a)){r=!0;break}}}if(this.prepareLeaveAnimationListeners(t),r)i.markElementAsRemoved(this.id,t,!1,e);else{let o=t[js];(!o||o===GG)&&(i.afterFlush(()=>this.clearElementCache(t)),i.destroyInnerAnimations(t),i._onRemovalComplete(t,e))}}insertNode(t,e){Gs(t,this._hostClassName)}drainQueuedTransitions(t){let e=[];return this._queue.forEach(i=>{let r=i.player;if(r.destroyed)return;let o=i.element,a=this._elementListeners.get(o);a&&a.forEach(s=>{if(s.name==i.triggerName){let l=PO(o,i.triggerName,i.fromState.value,i.toState.value);l._data=t,RO(i.player,s.phase,l,s.callback)}}),r.markedForDestroy?this._engine.afterFlush(()=>{r.destroy()}):e.push(i)}),this._queue=[],e.sort((i,r)=>{let o=i.transition.ast.depCount,a=r.transition.ast.depCount;return 0==o||0==a?o-a:this._engine.driver.containsElement(i.element,r.element)?1:-1})}destroy(t){this.players.forEach(e=>e.destroy()),this._signalRemovalForInnerTriggers(this.hostElement,t)}elementContainsData(t){let e=!1;return this._elementListeners.has(t)&&(e=!0),e=!!this._queue.find(i=>i.element===t)||e,e}}(t,e,this);return this.bodyNode&&this.driver.containsElement(this.bodyNode,e)?this._balanceNamespaceList(i,e):(this.newHostElements.set(e,i),this.collectEnterElement(e)),this._namespaceLookup[t]=i}_balanceNamespaceList(t,e){let i=this._namespaceList,r=this.namespacesByHostElement;if(i.length-1>=0){let a=!1,s=this.driver.getParentElement(e);for(;s;){let l=r.get(s);if(l){let c=i.indexOf(l);i.splice(c+1,0,t),a=!0;break}s=this.driver.getParentElement(s)}a||i.unshift(t)}else i.push(t);return r.set(e,t),t}register(t,e){let i=this._namespaceLookup[t];return i||(i=this.createNamespace(t,e)),i}registerTrigger(t,e,i){let r=this._namespaceLookup[t];r&&r.register(e,i)&&this.totalAnimations++}destroy(t,e){if(!t)return;let i=this._fetchNamespace(t);this.afterFlush(()=>{this.namespacesByHostElement.delete(i.hostElement),delete this._namespaceLookup[t];let r=this._namespaceList.indexOf(i);r>=0&&this._namespaceList.splice(r,1)}),this.afterFlushAnimationsDone(()=>i.destroy(e))}_fetchNamespace(t){return this._namespaceLookup[t]}fetchNamespacesByElement(t){let e=new Set,i=this.statesByElement.get(t);if(i)for(let r of i.values())if(r.namespaceId){let o=this._fetchNamespace(r.namespaceId);o&&e.add(o)}return e}trigger(t,e,i,r){if(Rw(e)){let o=this._fetchNamespace(t);if(o)return o.trigger(e,i,r),!0}return!1}insertNode(t,e,i,r){if(!Rw(e))return;let o=e[js];if(o&&o.setForRemoval){o.setForRemoval=!1,o.setForMove=!0;let a=this.collectedLeaveElements.indexOf(e);a>=0&&this.collectedLeaveElements.splice(a,1)}if(t){let a=this._fetchNamespace(t);a&&a.insertNode(e,i)}r&&this.collectEnterElement(e)}collectEnterElement(t){this.collectedEnterElements.push(t)}markElementAsDisabled(t,e){e?this.disabledNodes.has(t)||(this.disabledNodes.add(t),Gs(t,hO)):this.disabledNodes.has(t)&&(this.disabledNodes.delete(t),Sf(t,hO))}removeNode(t,e,i,r){if(Rw(e)){let o=t?this._fetchNamespace(t):null;if(o?o.removeNode(e,r):this.markElementAsRemoved(t,e,!1,r),i){let a=this.namespacesByHostElement.get(e);a&&a.id!==t&&a.removeNode(e,r)}}else this._onRemovalComplete(e,r)}markElementAsRemoved(t,e,i,r,o){this.collectedLeaveElements.push(e),e[js]={namespaceId:t,setForRemoval:r,hasAnimation:i,removedBeforeQueried:!1,previousTriggersValues:o}}listen(t,e,i,r,o){return Rw(e)?this._fetchNamespace(t).listen(e,i,r,o):()=>{}}_buildInstruction(t,e,i,r,o){return t.transition.build(this.driver,t.element,t.fromState.value,t.toState.value,i,r,t.fromState.options,t.toState.options,e,o)}destroyInnerAnimations(t){let e=this.driver.query(t,Pw,!0);e.forEach(i=>this.destroyActiveAnimationsForElement(i)),0!=this.playersByQueriedElement.size&&(e=this.driver.query(t,bO,!0),e.forEach(i=>this.finishActiveQueriedAnimationOnElement(i)))}destroyActiveAnimationsForElement(t){let e=this.playersByElement.get(t);e&&e.forEach(i=>{i.queued?i.markedForDestroy=!0:i.destroy()})}finishActiveQueriedAnimationOnElement(t){let e=this.playersByQueriedElement.get(t);e&&e.forEach(i=>i.finish())}whenRenderingDone(){return new Promise(t=>{if(this.players.length)return hu(this.players).onDone(()=>t());t()})}processLeaveNode(t){let e=t[js];if(e&&e.setForRemoval){if(t[js]=GG,e.namespaceId){this.destroyInnerAnimations(t);let i=this._fetchNamespace(e.namespaceId);i&&i.clearElementCache(t)}this._onRemovalComplete(t,e.setForRemoval)}t.classList?.contains(hO)&&this.markElementAsDisabled(t,!1),this.driver.query(t,".ng-animate-disabled",!0).forEach(i=>{this.markElementAsDisabled(i,!1)})}flush(t=-1){let e=[];if(this.newHostElements.size&&(this.newHostElements.forEach((i,r)=>this._balanceNamespaceList(i,r)),this.newHostElements.clear()),this.totalAnimations&&this.collectedEnterElements.length)for(let i=0;i<this.collectedEnterElements.length;i++)Gs(this.collectedEnterElements[i],"ng-star-inserted");if(this._namespaceList.length&&(this.totalQueuedPlayers||this.collectedLeaveElements.length)){let i=[];try{e=this._flushAnimations(i,t)}finally{for(let r=0;r<i.length;r++)i[r]()}}else for(let i=0;i<this.collectedLeaveElements.length;i++)this.processLeaveNode(this.collectedLeaveElements[i]);if(this.totalQueuedPlayers=0,this.collectedEnterElements.length=0,this.collectedLeaveElements.length=0,this._flushFns.forEach(i=>i()),this._flushFns=[],this._whenQuietFns.length){let i=this._whenQuietFns;this._whenQuietFns=[],e.length?hu(e).onDone(()=>{i.forEach(r=>r())}):i.forEach(r=>r())}}reportError(t){throw new xt(3402,!1)}_flushAnimations(t,e){let i=new Ub,r=[],o=new Map,a=[],s=new Map,l=new Map,c=new Map,d=new Set;this.disabledNodes.forEach($=>{d.add($);let de=this.driver.query($,".ng-animate-queued",!0);for(let pe=0;pe<de.length;pe++)d.add(de[pe])});let u=this.bodyNode,p=Array.from(this.statesByElement.keys()),h=EG(p,this.collectedEnterElements),m=new Map,_=0;h.forEach(($,de)=>{let pe=OG+_++;m.set(de,pe),$.forEach(Ge=>Gs(Ge,pe))});let M=[],y=new Set,x=new Set;for(let $=0;$<this.collectedLeaveElements.length;$++){let de=this.collectedLeaveElements[$],pe=de[js];pe&&pe.setForRemoval&&(M.push(de),y.add(de),pe.hasAnimation?this.driver.query(de,".ng-star-inserted",!0).forEach(Ge=>y.add(Ge)):x.add(de))}let R=new Map,I=EG(p,Array.from(y));I.forEach(($,de)=>{let pe=_O+_++;R.set(de,pe),$.forEach(Ge=>Gs(Ge,pe))}),t.push(()=>{h.forEach(($,de)=>{let pe=m.get(de);$.forEach(Ge=>Sf(Ge,pe))}),I.forEach(($,de)=>{let pe=R.get(de);$.forEach(Ge=>Sf(Ge,pe))}),M.forEach($=>{this.processLeaveNode($)})});let B=[],ee=[];for(let $=this._namespaceList.length-1;$>=0;$--)this._namespaceList[$].drainQueuedTransitions(e).forEach(pe=>{let Ge=pe.player,Se=pe.element;if(B.push(Ge),this.collectedEnterElements.length){let wt=Se[js];if(wt&&wt.setForMove){if(wt.previousTriggersValues&&wt.previousTriggersValues.has(pe.triggerName)){let on=wt.previousTriggersValues.get(pe.triggerName),Ce=this.statesByElement.get(pe.element);if(Ce&&Ce.has(pe.triggerName)){let mt=Ce.get(pe.triggerName);mt.value=on,Ce.set(pe.triggerName,mt)}}return void Ge.destroy()}}let Fe=!u||!this.driver.containsElement(u,Se),lt=R.get(Se),Mt=m.get(Se),pt=this._buildInstruction(pe,i,Mt,lt,Fe);if(pt.errors&&pt.errors.length)return void ee.push(pt);if(Fe)return Ge.onStart(()=>sh(Se,pt.fromStyles)),Ge.onDestroy(()=>bc(Se,pt.toStyles)),void r.push(Ge);if(pe.isFallbackTransition)return Ge.onStart(()=>sh(Se,pt.fromStyles)),Ge.onDestroy(()=>bc(Se,pt.toStyles)),void r.push(Ge);let ke=[];pt.timelines.forEach(wt=>{wt.stretchStartingKeyframe=!0,this.disabledNodes.has(wt.element)||ke.push(wt)}),pt.timelines=ke,i.append(Se,pt.timelines),a.push({instruction:pt,player:Ge,element:Se}),pt.queriedElements.forEach(wt=>ps(s,wt,[]).push(Ge)),pt.preStyleProps.forEach((wt,on)=>{if(wt.size){let Ce=l.get(on);Ce||l.set(on,Ce=new Set),wt.forEach((mt,ht)=>Ce.add(ht))}}),pt.postStyleProps.forEach((wt,on)=>{let Ce=c.get(on);Ce||c.set(on,Ce=new Set),wt.forEach((mt,ht)=>Ce.add(ht))})});if(ee.length){let $=[];ee.forEach(de=>{$.push(new xt(3505,!1))}),B.forEach(de=>de.destroy()),this.reportError($)}let Q=new Map,we=new Map;a.forEach($=>{let de=$.element;i.has(de)&&(we.set(de,de),this._beforeAnimationBuild($.player.namespaceId,$.instruction,Q))}),r.forEach($=>{let de=$.element;this._getPreviousPlayers(de,!1,$.namespaceId,$.triggerName,null).forEach(Ge=>{ps(Q,de,[]).push(Ge),Ge.destroy()})});let Qe=M.filter($=>TG($,l,c)),Ae=new Map;SG(Ae,this.driver,x,c,_c).forEach($=>{TG($,l,c)&&Qe.push($)});let re=new Map;h.forEach(($,de)=>{SG(re,this.driver,new Set($),l,Tw)}),Qe.forEach($=>{let de=Ae.get($),pe=re.get($);Ae.set($,new Map([...Array.from(de?.entries()??[]),...Array.from(pe?.entries()??[])]))});let ce=[],he=[],_e={};a.forEach($=>{let{element:de,player:pe,instruction:Ge}=$;if(i.has(de)){if(d.has(de))return pe.onDestroy(()=>bc(de,Ge.toStyles)),pe.disabled=!0,pe.overrideTotalTime(Ge.totalTime),void r.push(pe);let Se=_e;if(we.size>1){let lt=de,Mt=[];for(;lt=lt.parentNode;){let pt=we.get(lt);if(pt){Se=pt;break}Mt.push(lt)}Mt.forEach(pt=>we.set(pt,Se))}let Fe=this._buildAnimation(pe.namespaceId,Ge,Q,o,re,Ae);if(pe.setRealPlayer(Fe),Se===_e)ce.push(pe);else{let lt=this.playersByElement.get(Se);lt&&lt.length&&(pe.parentPlayer=hu(lt)),r.push(pe)}}else sh(de,Ge.fromStyles),pe.onDestroy(()=>bc(de,Ge.toStyles)),he.push(pe),d.has(de)&&r.push(pe)}),he.forEach($=>{let de=o.get($.element);if(de&&de.length){let pe=hu(de);$.setRealPlayer(pe)}}),r.forEach($=>{$.parentPlayer?$.syncPlayerEvents($.parentPlayer):$.destroy()});for(let $=0;$<M.length;$++){let de=M[$],pe=de[js];if(Sf(de,_O),pe&&pe.hasAnimation)continue;let Ge=[];if(s.size){let Fe=s.get(de);Fe&&Fe.length&&Ge.push(...Fe);let lt=this.driver.query(de,bO,!0);for(let Mt=0;Mt<lt.length;Mt++){let pt=s.get(lt[Mt]);pt&&pt.length&&Ge.push(...pt)}}let Se=Ge.filter(Fe=>!Fe.destroyed);Se.length?mme(this,de,Se):this.processLeaveNode(de)}return M.length=0,ce.forEach($=>{this.players.push($),$.onDone(()=>{$.destroy();let de=this.players.indexOf($);this.players.splice(de,1)}),$.play()}),ce}elementContainsData(t,e){let i=!1,r=e[js];return r&&r.setForRemoval&&(i=!0),this.playersByElement.has(e)&&(i=!0),this.playersByQueriedElement.has(e)&&(i=!0),this.statesByElement.has(e)&&(i=!0),this._fetchNamespace(t).elementContainsData(e)||i}afterFlush(t){this._flushFns.push(t)}afterFlushAnimationsDone(t){this._whenQuietFns.push(t)}_getPreviousPlayers(t,e,i,r,o){let a=[];if(e){let s=this.playersByQueriedElement.get(t);s&&(a=s)}else{let s=this.playersByElement.get(t);if(s){let l=!o||o==Hb;s.forEach(c=>{c.queued||!l&&c.triggerName!=r||a.push(c)})}}return(i||r)&&(a=a.filter(s=>!(i&&i!=s.namespaceId||r&&r!=s.triggerName))),a}_beforeAnimationBuild(t,e,i){let o=e.element,a=e.isRemovalTransition?void 0:t,s=e.isRemovalTransition?void 0:e.triggerName;for(let l of e.timelines){let c=l.element,d=c!==o,u=ps(i,c,[]);this._getPreviousPlayers(c,d,a,s,e.toState).forEach(h=>{let m=h.getRealPlayer();m.beforeDestroy&&m.beforeDestroy(),h.destroy(),u.push(h)})}sh(o,e.fromStyles)}_buildAnimation(t,e,i,r,o,a){let s=e.triggerName,l=e.element,c=[],d=new Set,u=new Set,p=e.timelines.map(m=>{let _=m.element;d.add(_);let M=_[js];if(M&&M.removedBeforeQueried)return new pu(m.duration,m.delay);let y=_!==l,x=function(n){let t=[];return WG(n,t),t}((i.get(_)||cme).map(Q=>Q.getRealPlayer())).filter(Q=>!!Q.element&&Q.element===_),R=o.get(_),I=a.get(_),B=DG(0,this._normalizer,0,m.keyframes,R,I),ee=this._buildPlayer(m,B,x);if(m.subTimeline&&r&&u.add(_),y){let Q=new Wb(t,s,_);Q.setRealPlayer(ee),c.push(Q)}return ee});c.forEach(m=>{ps(this.playersByQueriedElement,m.element,[]).push(m),m.onDone(()=>function(n,t,e){let i=n.get(t);if(i){if(i.length){let r=i.indexOf(e);i.splice(r,1)}0==i.length&&n.delete(t)}return i}(this.playersByQueriedElement,m.element,m))}),d.forEach(m=>Gs(m,gG));let h=hu(p);return h.onDestroy(()=>{d.forEach(m=>Sf(m,gG)),bc(l,e.toStyles)}),u.forEach(m=>{ps(r,m,[]).push(h)}),h}_buildPlayer(t,e,i){return e.length>0?this.driver.animate(t.element,e,t.duration,t.delay,t.easing,i):new pu(t.duration,t.delay)}}(t,e,i),this._timelineEngine=new class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._animations=new Map,this._playersById=new Map,this.players=[]}register(t,e){let i=[],r=[],o=UG(this._driver,e,i,r);if(i.length)throw new xt(3503,!1);this._animations.set(t,o)}_buildPlayer(t,e,i){let r=t.element,o=DG(0,this._normalizer,0,t.keyframes,e,i);return this._driver.animate(r,o,t.duration,t.delay,t.easing,[],!0)}create(t,e,i={}){let a,r=[],o=this._animations.get(t),s=new Map;if(o?(a=jG(this._driver,e,o,OG,_O,new Map,new Map,i,rme,r),a.forEach(d=>{let u=ps(s,d.element,new Map);d.postStyleProps.forEach(p=>u.set(p,null))})):(r.push(new xt(3300,!1)),a=[]),r.length)throw new xt(3504,!1);s.forEach((d,u)=>{d.forEach((p,h)=>{d.set(h,this._driver.computeStyle(u,h,_c))})});let c=hu(a.map(d=>{let u=s.get(d.element);return this._buildPlayer(d,new Map,u)}));return this._playersById.set(t,c),c.onDestroy(()=>this.destroy(t)),this.players.push(c),c}destroy(t){let e=this._getPlayer(t);e.destroy(),this._playersById.delete(t);let i=this.players.indexOf(e);i>=0&&this.players.splice(i,1)}_getPlayer(t){let e=this._playersById.get(t);if(!e)throw new xt(3301,!1);return e}listen(t,e,i,r){let o=PO(e,"","","");return RO(this._getPlayer(t),i,o,r),()=>{}}command(t,e,i,r){if("register"==i)return void this.register(t,r[0]);if("create"==i)return void this.create(t,e,r[0]||{});let o=this._getPlayer(t);switch(i){case"play":o.play();break;case"pause":o.pause();break;case"reset":o.reset();break;case"restart":o.restart();break;case"finish":o.finish();break;case"init":o.init();break;case"setPosition":o.setPosition(parseFloat(r[0]));break;case"destroy":this.destroy(t)}}}(t,e,i),this._transitionEngine.onRemovalComplete=(r,o)=>this.onRemovalComplete(r,o)}registerTrigger(t,e,i,r,o){let a=t+"-"+r,s=this._triggerCache[a];if(!s){let l=[],c=[],d=UG(this._driver,o,l,c);if(l.length)throw new xt(3404,!1);s=function(n,t,e){return new class{constructor(t,e,i){this.name=t,this.ast=e,this._normalizer=i,this.transitionFactories=[],this.states=new Map,e.states.forEach(r=>{let o=r.options&&r.options.params||{};this.states.set(r.name,new class{constructor(t,e,i){this.styles=t,this.defaultParams=e,this.normalizer=i}buildStyles(t,e){let i=new Map,r=Xb(this.defaultParams);return Object.keys(t).forEach(o=>{let a=t[o];null!==a&&(r[o]=a)}),this.styles.styles.forEach(o=>{"string"!=typeof o&&o.forEach((a,s)=>{a&&(a=zb(a,r,e));let l=this.normalizer.normalizePropertyName(s,e);a=this.normalizer.normalizeStyleValue(s,l,a,e),i.set(s,a)})}),i}}(r.style,o,i))}),CG(this.states,"true","1"),CG(this.states,"false","0"),e.transitions.forEach(r=>{this.transitionFactories.push(new Bw(t,r,this.states))}),this.fallbackTransition=function(n,t,e){return new Bw(n,{type:1,animation:{type:2,steps:[],options:null},matchers:[(a,s)=>!0],options:null,queryCount:0,depCount:0},t)}(t,this.states)}get containsQueries(){return this.ast.queryCount>0}matchTransition(t,e,i,r){return this.transitionFactories.find(a=>a.match(t,e,i,r))||null}matchStyles(t,e,i){return this.fallbackTransition.buildStyles(t,e,i)}}(n,t,e)}(r,d,this._normalizer),this._triggerCache[a]=s}this._transitionEngine.registerTrigger(e,r,s)}register(t,e){this._transitionEngine.register(t,e)}destroy(t,e){this._transitionEngine.destroy(t,e)}onInsert(t,e,i,r){this._transitionEngine.insertNode(t,e,i,r)}onRemove(t,e,i,r){this._transitionEngine.removeNode(t,e,r||!1,i)}disableAnimations(t,e){this._transitionEngine.markElementAsDisabled(t,e)}process(t,e,i,r){if("@"==i.charAt(0)){let[o,a]=mG(i);this._timelineEngine.command(o,e,a,r)}else this._transitionEngine.trigger(t,e,i,r)}listen(t,e,i,r,o){if("@"==i.charAt(0)){let[a,s]=mG(i);return this._timelineEngine.listen(a,e,s,o)}return this._transitionEngine.listen(t,e,i,r,o)}flush(t=-1){this._transitionEngine.flush(t)}get players(){return this._transitionEngine.players.concat(this._timelineEngine.players)}whenRenderingDone(){return this._transitionEngine.whenRenderingDone()}},bme=(()=>{class n{constructor(e,i,r){this._element=e,this._startStyles=i,this._endStyles=r,this._state=0;let o=n.initialStylesByElement.get(e);o||n.initialStylesByElement.set(e,o=new Map),this._initialStyles=o}start(){this._state<1&&(this._startStyles&&bc(this._element,this._startStyles,this._initialStyles),this._state=1)}finish(){this.start(),this._state<2&&(bc(this._element,this._initialStyles),this._endStyles&&(bc(this._element,this._endStyles),this._endStyles=null),this._state=1)}destroy(){this.finish(),this._state<3&&(n.initialStylesByElement.delete(this._element),this._startStyles&&(sh(this._element,this._startStyles),this._endStyles=null),this._endStyles&&(sh(this._element,this._endStyles),this._endStyles=null),bc(this._element,this._initialStyles),this._state=3)}}return n.initialStylesByElement=new WeakMap,n})();function fO(n){let t=null;return n.forEach((e,i)=>{(function(n){return"display"===n||"position"===n})(i)&&(t=t||new Map,t.set(i,e))}),t}var Vw=class{constructor(t,e,i,r){this.element=t,this.keyframes=e,this.options=i,this._specialStyles=r,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._initialized=!1,this._finished=!1,this._started=!1,this._destroyed=!1,this._originalOnDoneFns=[],this._originalOnStartFns=[],this.time=0,this.parentPlayer=null,this.currentSnapshot=new Map,this._duration=i.duration,this._delay=i.delay||0,this.time=this._duration+this._delay}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this._buildPlayer(),this._preparePlayerBeforeStart()}_buildPlayer(){if(this._initialized)return;this._initialized=!0;let t=this.keyframes;this.domPlayer=this._triggerWebAnimation(this.element,t,this.options),this._finalKeyframe=t.length?t[t.length-1]:new Map,this.domPlayer.addEventListener("finish",()=>this._onFinish())}_preparePlayerBeforeStart(){this._delay?this._resetDomPlayerState():this.domPlayer.pause()}_convertKeyframesToObject(t){let e=[];return t.forEach(i=>{e.push(Object.fromEntries(i))}),e}_triggerWebAnimation(t,e,i){return t.animate(this._convertKeyframesToObject(e),i)}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}play(){this._buildPlayer(),this.hasStarted()||(this._onStartFns.forEach(t=>t()),this._onStartFns=[],this._started=!0,this._specialStyles&&this._specialStyles.start()),this.domPlayer.play()}pause(){this.init(),this.domPlayer.pause()}finish(){this.init(),this._specialStyles&&this._specialStyles.finish(),this._onFinish(),this.domPlayer.finish()}reset(){this._resetDomPlayerState(),this._destroyed=!1,this._finished=!1,this._started=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}_resetDomPlayerState(){this.domPlayer&&this.domPlayer.cancel()}restart(){this.reset(),this.play()}hasStarted(){return this._started}destroy(){this._destroyed||(this._destroyed=!0,this._resetDomPlayerState(),this._onFinish(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}setPosition(t){void 0===this.domPlayer&&this.init(),this.domPlayer.currentTime=t*this.time}getPosition(){return this.domPlayer.currentTime/this.time}get totalTime(){return this._delay+this._duration}beforeDestroy(){let t=new Map;this.hasStarted()&&this._finalKeyframe.forEach((i,r)=>{"offset"!==r&&t.set(r,this._finished?i:BG(this.element,r))}),this.currentSnapshot=t}triggerCallback(t){let e="start"===t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},xme=(()=>{class n extends Fb{constructor(e,i){super(),this._nextAnimationId=0,this._renderer=e.createRenderer(i.body,{id:"0",encapsulation:as.None,styles:[],data:{animation:[]}})}build(e){let i=this._nextAnimationId.toString();this._nextAnimationId++;let r=Array.isArray(e)?Ew(e):e;return XG(this._renderer,null,i,"register",[r]),new LO(i,this._renderer)}}return n.\u0275fac=function(e){return new(e||n)(O(cc),O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),LO=class extends Sw{constructor(t,e){super(),this._id=t,this._renderer=e}create(t,e){return new BO(this._id,t,e||{},this._renderer)}},BO=class{constructor(t,e,i,r){this.id=t,this.element=e,this._renderer=r,this.parentPlayer=null,this._started=!1,this.totalTime=0,this._command("create",i)}_listen(t,e){return this._renderer.listen(this.element,`@@${this.id}:${t}`,e)}_command(t,...e){return XG(this._renderer,this.element,this.id,t,e)}onDone(t){this._listen("done",t)}onStart(t){this._listen("start",t)}onDestroy(t){this._listen("destroy",t)}init(){this._command("init")}hasStarted(){return this._started}play(){this._command("play"),this._started=!0}pause(){this._command("pause")}restart(){this._command("restart")}finish(){this._command("finish")}destroy(){this._command("destroy")}reset(){this._command("reset"),this._started=!1}setPosition(t){this._command("setPosition",t)}getPosition(){return this._renderer.engine.players[+this.id]?.getPosition()??0}};function XG(n,t,e,i,r){return n.setProperty(t,`@@${e}:${i}`,r)}var YG="@.disabled",Cme=(()=>{class n{constructor(e,i,r){this.delegate=e,this.engine=i,this._zone=r,this._currentId=0,this._microtaskId=1,this._animationCallbacksBuffer=[],this._rendererCache=new Map,this._cdRecurDepth=0,this.promise=Promise.resolve(0),i.onRemovalComplete=(o,a)=>{let s=a?.parentNode(o);s&&a.removeChild(s,o)}}createRenderer(e,i){let o=this.delegate.createRenderer(e,i);if(!(e&&i&&i.data&&i.data.animation)){let d=this._rendererCache.get(o);return d||(d=new Uw("",o,this.engine,()=>this._rendererCache.delete(o)),this._rendererCache.set(o,d)),d}let a=i.id,s=i.id+"-"+this._currentId;this._currentId++,this.engine.register(s,e);let l=d=>{Array.isArray(d)?d.forEach(l):this.engine.registerTrigger(a,s,e,d.name,d)};return i.data.animation.forEach(l),new VO(this,s,o,this.engine)}begin(){this._cdRecurDepth++,this.delegate.begin&&this.delegate.begin()}_scheduleCountTask(){this.promise.then(()=>{this._microtaskId++})}scheduleListenerCallback(e,i,r){e>=0&&e<this._microtaskId?this._zone.run(()=>i(r)):(0==this._animationCallbacksBuffer.length&&Promise.resolve(null).then(()=>{this._zone.run(()=>{this._animationCallbacksBuffer.forEach(o=>{let[a,s]=o;a(s)}),this._animationCallbacksBuffer=[]})}),this._animationCallbacksBuffer.push([i,r]))}end(){this._cdRecurDepth--,0==this._cdRecurDepth&&this._zone.runOutsideAngular(()=>{this._scheduleCountTask(),this.engine.flush(this._microtaskId)}),this.delegate.end&&this.delegate.end()}whenRenderingDone(){return this.engine.whenRenderingDone()}}return n.\u0275fac=function(e){return new(e||n)(O(cc),O(mu),O(ot))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Uw=class{constructor(t,e,i,r){this.namespaceId=t,this.delegate=e,this.engine=i,this._onDestroy=r,this.destroyNode=this.delegate.destroyNode?o=>e.destroyNode(o):null}get data(){return this.delegate.data}destroy(){this.engine.destroy(this.namespaceId,this.delegate),this.delegate.destroy(),this._onDestroy?.()}createElement(t,e){return this.delegate.createElement(t,e)}createComment(t){return this.delegate.createComment(t)}createText(t){return this.delegate.createText(t)}appendChild(t,e){this.delegate.appendChild(t,e),this.engine.onInsert(this.namespaceId,e,t,!1)}insertBefore(t,e,i,r=!0){this.delegate.insertBefore(t,e,i),this.engine.onInsert(this.namespaceId,e,t,r)}removeChild(t,e,i){this.engine.onRemove(this.namespaceId,e,this.delegate,i)}selectRootElement(t,e){return this.delegate.selectRootElement(t,e)}parentNode(t){return this.delegate.parentNode(t)}nextSibling(t){return this.delegate.nextSibling(t)}setAttribute(t,e,i,r){this.delegate.setAttribute(t,e,i,r)}removeAttribute(t,e,i){this.delegate.removeAttribute(t,e,i)}addClass(t,e){this.delegate.addClass(t,e)}removeClass(t,e){this.delegate.removeClass(t,e)}setStyle(t,e,i,r){this.delegate.setStyle(t,e,i,r)}removeStyle(t,e,i){this.delegate.removeStyle(t,e,i)}setProperty(t,e,i){"@"==e.charAt(0)&&e==YG?this.disableAnimations(t,!!i):this.delegate.setProperty(t,e,i)}setValue(t,e){this.delegate.setValue(t,e)}listen(t,e,i){return this.delegate.listen(t,e,i)}disableAnimations(t,e){this.engine.disableAnimations(t,e)}},VO=class extends Uw{constructor(t,e,i,r,o){super(e,i,r,o),this.factory=t,this.namespaceId=e}setProperty(t,e,i){"@"==e.charAt(0)?"."==e.charAt(1)&&e==YG?this.disableAnimations(t,i=void 0===i||!!i):this.engine.process(this.namespaceId,t,e.slice(1),i):this.delegate.setProperty(t,e,i)}listen(t,e,i){if("@"==e.charAt(0)){let r=function(n){switch(n){case"body":return document.body;case"document":return document;case"window":return window;default:return n}}(t),o=e.slice(1),a="";return"@"!=o.charAt(0)&&([o,a]=function(n){let t=n.indexOf(".");return[n.substring(0,t),n.slice(t+1)]}(o)),this.engine.listen(this.namespaceId,r,o,a,s=>{this.factory.scheduleListenerCallback(s._data||-1,i,s)})}return this.delegate.listen(t,e,i)}},Sme=(()=>{class n extends mu{constructor(e,i,r,o){super(e.body,i,r)}ngOnDestroy(){this.flush()}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(qb),O(lh),O(gc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),QG=[{provide:Fb,useClass:xme},{provide:lh,useFactory:function(){return new Lw}},{provide:mu,useClass:Sme},{provide:cc,useFactory:function(n,t,e){return new Cme(n,t,e)},deps:[Rb,mu,ot]}],qG=[{provide:qb,useFactory:()=>new class{validateStyleProperty(t){return!0}validateAnimatableStyleProperty(t){return!0}matchesElement(t,e){return!1}containsElement(t,e){return RG(t,e)}getParentElement(t){return kO(t)}query(t,e,i){return PG(t,e,i)}computeStyle(t,e,i){return window.getComputedStyle(t)[e]}animate(t,e,i,r,o,a=[]){let l={duration:i,delay:r,fill:0==r?"both":"forwards"};o&&(l.easing=o);let c=new Map,d=a.filter(h=>h instanceof Vw);(function(n,t){return 0===n||0===t})(i,r)&&d.forEach(h=>{h.currentSnapshot.forEach((m,_)=>c.set(_,m))});let u=(n=e,n.length?n[0]instanceof Map?n:n.map(t=>FG(t)):[]).map(h=>Ef(h));var n;u=function(n,t,e){if(e.size&&t.length){let i=t[0],r=[];if(e.forEach((o,a)=>{i.has(a)||r.push(a),i.set(a,o)}),r.length)for(let o=1;o<t.length;o++){let a=t[o];r.forEach(s=>a.set(s,BG(n,s)))}}return t}(t,u,c);let p=function(n,t){let e=null,i=null;return Array.isArray(t)&&t.length?(e=fO(t[0]),t.length>1&&(i=fO(t[t.length-1]))):t instanceof Map&&(e=fO(t)),e||i?new bme(n,e,i):null}(t,u);return new Vw(t,u,l,p)}}},{provide:pi,useValue:"BrowserAnimations"},...QG],Dme=[{provide:qb,useClass:OO},{provide:pi,useValue:"NoopAnimations"},...QG],ZG=(()=>{class n{static withConfig(e){return{ngModule:n,providers:e.disableAnimations?Dme:qG}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:qG,imports:[ww]}),n})(),jO={};function fe(n,t){if(jO[n]=(jO[n]||0)+1,"function"==typeof t)return HO(n,(...i)=>({...t(...i),type:n}));switch(t?t._as:"empty"){case"empty":return HO(n,()=>({type:n}));case"props":return HO(n,i=>({...i,type:n}));default:throw new Error("Unexpected config.")}}function HO(n,t){return Object.defineProperty(t,"type",{value:n,writable:!1})}var p8="@ngrx/store/init",If=(()=>{class n extends xr{constructor(){super({type:p8})}next(e){if("function"==typeof e)throw new TypeError("\n        Dispatch expected an object, instead it received a function.\n        If you're using the createAction function, make sure to invoke the function\n        before dispatching the action. For example, someAction should be someAction().");if(typeof e>"u")throw new TypeError("Actions must be objects");if(typeof e.type>"u")throw new TypeError("Actions must have a type property");super.next(e)}complete(){}ngOnDestroy(){super.complete()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ime=[If],h8=new te("@ngrx/store Internal Root Guard"),KG=new te("@ngrx/store Internal Initial State"),XO=new te("@ngrx/store Initial State"),m8=new te("@ngrx/store Reducer Factory"),JG=new te("@ngrx/store Internal Reducer Factory Provider"),f8=new te("@ngrx/store Initial Reducers"),zO=new te("@ngrx/store Internal Initial Reducers"),$G=new te("@ngrx/store Store Features"),e8=new te("@ngrx/store Internal Store Reducers"),UO=new te("@ngrx/store Internal Feature Reducers"),t8=new te("@ngrx/store Internal Feature Configs"),g8=new te("@ngrx/store Internal Store Features"),n8=new te("@ngrx/store Internal Feature Reducers Token"),_8=new te("@ngrx/store Feature Reducers"),i8=new te("@ngrx/store User Provided Meta Reducers"),Df=new te("@ngrx/store Meta Reducers"),r8=new te("@ngrx/store Internal Resolved Meta Reducers"),o8=new te("@ngrx/store User Runtime Checks Config"),a8=new te("@ngrx/store Internal User Runtime Checks Config"),Yb=new te("@ngrx/store Internal Runtime Checks"),YO=new te("@ngrx/store Check if Action types are unique");function ch(n,t={}){let e=Object.keys(n),i={};for(let o=0;o<e.length;o++){let a=e[o];"function"==typeof n[a]&&(i[a]=n[a])}let r=Object.keys(i);return function(a,s){a=void 0===a?t:a;let l=!1,c={};for(let d=0;d<r.length;d++){let u=r[d],h=a[u],m=(0,i[u])(h,s);c[u]=m,l=l||m!==h}return l?c:a}}function b8(...n){return function(t){if(0===n.length)return t;let e=n[n.length-1];return n.slice(0,-1).reduceRight((r,o)=>o(r),e(t))}}function v8(n,t){return Array.isArray(t)&&t.length>0&&(n=b8.apply(null,[...t,n])),(e,i)=>{let r=n(e);return(o,a)=>r(o=void 0===o?i:o,a)}}new te("@ngrx/store Root Store Provider"),new te("@ngrx/store Feature State Provider");var Qb=class extends Kt{},jw=class extends If{},Gw=(()=>{class n extends xr{constructor(e,i,r,o){super(o(r,i)),this.dispatcher=e,this.initialState=i,this.reducers=r,this.reducerFactory=o}get currentReducers(){return this.reducers}addFeature(e){this.addFeatures([e])}addFeatures(e){let i=e.reduce((r,{reducers:o,reducerFactory:a,metaReducers:s,initialState:l,key:c})=>{let d="function"==typeof o?function(n){let t=Array.isArray(n)&&n.length>0?b8(...n):e=>e;return(e,i)=>(e=t(e),(r,o)=>e(r=void 0===r?i:r,o))}(s)(o,l):v8(a,s)(o,l);return r[c]=d,r},{});this.addReducers(i)}removeFeature(e){this.removeFeatures([e])}removeFeatures(e){this.removeReducers(e.map(i=>i.key))}addReducer(e,i){this.addReducers({[e]:i})}addReducers(e){this.reducers={...this.reducers,...e},this.updateReducers(Object.keys(e))}removeReducer(e){this.removeReducers([e])}removeReducers(e){e.forEach(i=>{this.reducers=function(n,t){return Object.keys(n).filter(e=>e!==t).reduce((e,i)=>Object.assign(e,{[i]:n[i]}),{})}(this.reducers,i)}),this.updateReducers(e)}updateReducers(e){this.next(this.reducerFactory(this.reducers,this.initialState)),this.dispatcher.next({type:"@ngrx/store/update-reducers",features:e})}ngOnDestroy(){this.complete()}}return n.\u0275fac=function(e){return new(e||n)(O(jw),O(XO),O(f8),O(m8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Fme=[Gw,{provide:Qb,useExisting:Gw},{provide:jw,useExisting:If}],Zb=(()=>{class n extends Ee{ngOnDestroy(){this.complete()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Nme=[Zb],Ww=class extends Kt{},s8=(()=>{class n extends xr{constructor(e,i,r,o){super(o);let c=e.pipe(Bp(XA)).pipe(It(i)).pipe(function(n,t){return Yt(function(n,t,e,i,r){return(o,a)=>{let s=e,l=t,c=0;o.subscribe(Ht(a,d=>{let u=c++;l=s?n(l,d,u):(s=!0,d),a.next(l)},void 0))}}(n,t,arguments.length>=2))}(Lme,{state:o}));this.stateSubscription=c.subscribe(({state:d,action:u})=>{this.next(d),r.next(u)})}ngOnDestroy(){this.stateSubscription.unsubscribe(),this.complete()}}return n.INIT=p8,n.\u0275fac=function(e){return new(e||n)(O(If),O(Qb),O(Zb),O(XO))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function Lme(n={state:void 0},[t,e]){let{state:i}=n;return{state:e(i,t),action:t}}var Bme=[s8,{provide:Ww,useExisting:s8}],Ie=(()=>{class n extends Kt{constructor(e,i,r){super(),this.actionsObserver=i,this.reducerManager=r,this.source=e}select(e,...i){return un.call(null,e,...i)(this)}lift(e){let i=new n(this,this.actionsObserver,this.reducerManager);return i.operator=e,i}dispatch(e){this.actionsObserver.next(e)}next(e){this.actionsObserver.next(e)}error(e){this.actionsObserver.error(e)}complete(){this.actionsObserver.complete()}addReducer(e,i){this.reducerManager.addReducer(e,i)}removeReducer(e){this.reducerManager.removeReducer(e)}}return n.\u0275fac=function(e){return new(e||n)(O(Ww),O(If),O(Gw))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Vme=[Ie];function un(n,t,...e){return function(r){let o;if("string"==typeof n){let a=[t,...e].filter(Boolean);o=r.pipe(function(...n){let t=n.length;if(0===t)throw new Error("list of properties cannot be empty.");return q(e=>{let i=e;for(let r=0;r<t;r++){let o=i?.[n[r]];if(!(typeof o<"u"))return;i=o}return i})}(n,...a))}else{if("function"!=typeof n)throw new TypeError(`Unexpected type '${typeof n}' in select operator, expected 'string' or 'function'`);o=r.pipe(q(a=>n(a,t)))}return o.pipe(ri())}}var QO="https://ngrx.io/guide/store/configuration/runtime-checks";function l8(n){return void 0===n}function c8(n){return null===n}function y8(n){return Array.isArray(n)}function x8(n){return"object"==typeof n&&null!==n}function GO(n){return"function"==typeof n}function d8(n,t){return n===t}function C8(n,t=d8,e=d8){let o,i=null,r=null;return{memoized:function(){if(void 0!==o)return o.result;if(!i)return r=n.apply(null,arguments),i=arguments,r;if(!function(n,t,e){for(let i=0;i<n.length;i++)if(!e(n[i],t[i]))return!0;return!1}(arguments,i,t))return r;let d=n.apply(null,arguments);return i=arguments,e(r,d)?r:(r=d,d)},reset:function(){i=null,r=null},setResult:function(d){o={result:d}},clearResult:function(){o=void 0}}}function W(...n){return function(n,t={stateFn:Zme}){return function(...e){let i=e;if(Array.isArray(i[0])){let[d,...u]=i;i=[...d,...u]}else 1===i.length&&function(n){return!!n&&"object"==typeof n&&Object.values(n).every(t=>"function"==typeof t)}(i[0])&&(i=function(n){let t=Object.values(n),e=Object.keys(n);return[...t,(...r)=>e.reduce((o,a,s)=>({...o,[a]:r[s]}),{})]}(i[0]));let r=i.slice(0,i.length-1),o=i[i.length-1],a=r.filter(d=>d.release&&"function"==typeof d.release),s=n(function(...d){return o.apply(null,d)}),l=C8(function(d,u){return t.stateFn.apply(null,[d,r,u,s])});return Object.assign(l.memoized,{release:function(){l.reset(),s.reset(),a.forEach(d=>d.release())},projector:s.memoized,setResult:l.setResult,clearResult:l.clearResult})}}(C8)(...n)}function Zme(n,t,e,i){if(void 0===e){let o=t.map(a=>a(n));return i.memoized.apply(null,o)}let r=t.map(o=>o(n,e));return i.memoized.apply(null,[...r,e])}function Mr(n){return W(t=>t[n],t=>t)}function efe(n){return n instanceof te?$n(n):n}function tfe(n,t){return t.map((e,i)=>{if(n[i]instanceof te){let r=$n(n[i]);return{key:e.key,reducerFactory:r.reducerFactory?r.reducerFactory:ch,metaReducers:r.metaReducers?r.metaReducers:[],initialState:r.initialState}}return e})}function nfe(n){return n.map(t=>t instanceof te?$n(t):t)}function M8(n){return"function"==typeof n?n():n}function ife(n,t){return n.concat(t)}function rfe(){if($n(Ie,{optional:!0,skipSelf:!0}))throw new TypeError("The root Store has been provided more than once. Feature modules should provide feature states instead.");return"guarded"}function WO(n){Object.freeze(n);let t=GO(n);return Object.getOwnPropertyNames(n).forEach(e=>{if(!e.startsWith("\u0275")&&function(n,t){return Object.prototype.hasOwnProperty.call(n,t)}(n,e)&&(!t||"caller"!==e&&"callee"!==e&&"arguments"!==e)){let i=n[e];(x8(i)||GO(i))&&!Object.isFrozen(i)&&WO(i)}}),n}function qO(n,t=[]){return(l8(n)||c8(n))&&0===t.length?{path:["root"],value:n}:Object.keys(n).reduce((i,r)=>{if(i)return i;let o=n[r];return function(n){return GO(n)&&n.hasOwnProperty("\u0275cmp")}(o)?i:!(l8(o)||c8(o)||function(n){return"number"==typeof n}(o)||function(n){return"boolean"==typeof n}(o)||function(n){return"string"==typeof n}(o)||y8(o))&&(function(n){if(!function(n){return x8(n)&&!y8(n)}(n))return!1;let t=Object.getPrototypeOf(n);return t===Object.prototype||null===t}(o)?qO(o,[...t,r]):{path:[...t,r],value:o})},!1)}function u8(n,t){if(!1===n)return;let e=n.path.join("."),i=new Error(`Detected unserializable ${t} at "${e}". ${QO}#strict${t}serializability`);throw i.value=n.value,i.unserializablePath=e,i}function lfe(n){return{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!1,strictActionImmutability:!1,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1}}function cfe({strictActionSerializability:n,strictStateSerializability:t}){return e=>n||t?function(n,t){return function(e,i){t.action(i)&&u8(qO(i),"action");let r=n(e,i);return t.state()&&u8(qO(r),"state"),r}}(e,{action:i=>n&&!ZO(i),state:()=>t}):e}function dfe({strictActionImmutability:n,strictStateImmutability:t}){return e=>n||t?function(n,t){return function(e,i){let r=t.action(i)?WO(i):i,o=n(e,r);return t.state()?WO(o):o}}(e,{action:i=>n&&!ZO(i),state:()=>t}):e}function ZO(n){return n.type.startsWith("@ngrx")}function ufe({strictActionWithinNgZone:n}){return t=>n?function(n,t){return function(e,i){if(t.action(i)&&!ot.isInAngularZone())throw new Error(`Action '${i.type}' running outside NgZone. ${QO}#strictactionwithinngzone`);return n(e,i)}}(t,{action:e=>n&&!ZO(e)}):t}function pfe(n){return[{provide:a8,useValue:n},{provide:o8,useFactory:hfe,deps:[a8]},{provide:Yb,deps:[o8],useFactory:lfe},{provide:Df,multi:!0,deps:[Yb],useFactory:dfe},{provide:Df,multi:!0,deps:[Yb],useFactory:cfe},{provide:Df,multi:!0,deps:[Yb],useFactory:ufe}]}function w8(){return[{provide:YO,multi:!0,deps:[Yb],useFactory:mfe}]}function hfe(n){return n}function mfe(n){if(!n.strictActionTypeUniqueness)return;let t=Object.entries(jO).filter(([,e])=>e>1).map(([e])=>e);if(t.length)throw new Error(`Action types are registered more than once, ${t.map(e=>`"${e}"`).join(", ")}. ${QO}#strictactiontypeuniqueness`)}function ffe(n={},t={}){return[{provide:h8,useFactory:rfe},{provide:KG,useValue:t.initialState},{provide:XO,useFactory:M8,deps:[KG]},{provide:zO,useValue:n},{provide:e8,useExisting:n instanceof te?n:zO},{provide:f8,deps:[zO,[new cf(e8)]],useFactory:efe},{provide:i8,useValue:t.metaReducers?t.metaReducers:[]},{provide:r8,deps:[Df,i8],useFactory:ife},{provide:JG,useValue:t.reducerFactory?t.reducerFactory:ch},{provide:m8,deps:[JG,r8],useFactory:v8},Ime,Fme,Nme,Bme,Vme,pfe(t.runtimeChecks),w8()]}function gfe(n,t,e={}){return[{provide:t8,multi:!0,useValue:n instanceof Object?{}:e},{provide:$G,multi:!0,useValue:{key:n instanceof Object?n.name:n,reducerFactory:e instanceof te||!e.reducerFactory?ch:e.reducerFactory,metaReducers:e instanceof te||!e.metaReducers?[]:e.metaReducers,initialState:e instanceof te||!e.initialState?void 0:e.initialState}},{provide:g8,deps:[t8,$G],useFactory:tfe},{provide:UO,multi:!0,useValue:n instanceof Object?n.reducer:t},{provide:n8,multi:!0,useExisting:t instanceof te?t:UO},{provide:_8,multi:!0,deps:[UO,[new cf(n8)]],useFactory:nfe},w8()]}var Kb=(()=>{class n{constructor(e,i,r,o,a,s){}}return n.\u0275fac=function(e){return new(e||n)(O(If),O(Qb),O(Zb),O(Ie),O(h8,8),O(YO,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),qw=(()=>{class n{constructor(e,i,r,o,a){this.features=e,this.featureReducers=i,this.reducerManager=r;let s=e.map((l,c)=>{let u=i.shift()[c];return{...l,reducers:u,initialState:M8(l.initialState)}});r.addFeatures(s)}ngOnDestroy(){this.reducerManager.removeFeatures(this.features)}}return n.\u0275fac=function(e){return new(e||n)(O(g8),O(_8),O(Gw),O(Kb),O(YO,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),wr=(()=>{class n{static forRoot(e,i){return{ngModule:Kb,providers:[...ffe(e,i)]}}static forFeature(e,i,r={}){return{ngModule:qw,providers:[...gfe(e,i,r)]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})();function ye(...n){return{reducer:n.pop(),types:n.map(i=>i.type)}}function gr(n,...t){let e=new Map;for(let i of t)for(let r of i.types){let o=e.get(r);e.set(r,o?(s,l)=>i.reducer(o(s,l),l):i.reducer)}return function(i=n,r){let o=e.get(r.type);return o?o(i,r):i}}var _fe={dispatch:!0,functional:!1,useEffectsErrorHandler:!0},Yw="__@ngrx/effects_create__";function _r(n,t={}){let e=t.functional?n:n(),i={..._fe,...t};return Object.defineProperty(e,Yw,{value:i}),e}function D8(n){return Object.getPrototypeOf(n)}function I8(n){return"function"==typeof n}function S8(n){return n.filter(I8)}function xfe(n,t,e){let i=D8(n).constructor.name,r=function(n){return function(n){return Object.getOwnPropertyNames(n).filter(i=>!(!n[i]||!n[i].hasOwnProperty(Yw))&&n[i][Yw].hasOwnProperty("dispatch")).map(i=>({propertyName:i,...n[i][Yw]}))}(n)}(n).map(({propertyName:o,dispatch:a,useEffectsErrorHandler:s})=>{let l="function"==typeof n[o]?n[o]():n[o],c=s?e(l,t):l;return!1===a?c.pipe(k_()):c.pipe(Yt((n,t)=>{n.subscribe(Ht(t,e=>{t.next(As.createNext(e))},()=>{t.next(As.createComplete()),t.complete()},e=>{t.next(As.createError(e)),t.complete()}))})).pipe(q(u=>({effect:n[o],notification:u,propertyName:o,sourceName:i,sourceInstance:n})))});return tn(...r)}var Cfe=10;function A8(n,t,e=Cfe){return n.pipe(co(i=>(t&&t.handleError(i),e<=1?n:A8(n,t,e-1))))}var Eo=(()=>{class n extends Kt{constructor(e){super(),e&&(this.source=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}}return n.\u0275fac=function(e){return new(e||n)(O(Zb))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Zn(...n){return Oe(t=>n.some(e=>"string"==typeof e?e===t.type:e.type===t.type))}var R8=new te("@ngrx/effects Internal Root Guard"),Xw=new te("@ngrx/effects User Provided Effects"),KO=new te("@ngrx/effects Internal Root Effects"),P8=new te("@ngrx/effects Internal Root Effects Instances"),E8=new te("@ngrx/effects Internal Feature Effects"),k8=new te("@ngrx/effects Internal Feature Effects Instance Groups"),Mfe=new te("@ngrx/effects Effects Error Handler",{providedIn:"root",factory:()=>A8}),O8="@ngrx/effects/init";fe(O8);var Dfe="ngrxOnIdentifyEffects",Pfe="ngrxOnInitEffects";function kfe(n){return JO(n,Pfe)}function JO(n,t){return n&&t in n&&"function"==typeof n[t]}var F8=(()=>{class n extends Ee{constructor(e,i){super(),this.errorHandler=e,this.effectsErrorHandler=i}addEffects(e){this.next(e)}toActions(){return this.pipe(BC(e=>function(n){return"Object"!==n.constructor.name&&"Function"!==n.constructor.name}(e)?D8(e):e),xn(e=>e.pipe(BC(Ofe))),xn(e=>{let i=e.pipe(NC(o=>function(n,t){return e=>{let i=xfe(e,n,t);return function(n){return JO(n,"ngrxOnRunEffects")}(e)?e.ngrxOnRunEffects(i):i}}(this.errorHandler,this.effectsErrorHandler)(o)),q(o=>(function(n,t){if("N"===n.notification.kind){let e=n.notification.value;!function(n){return"function"!=typeof n&&n&&n.type&&"string"==typeof n.type}(e)&&t.handleError(new Error(`Effect ${function({propertyName:n,sourceInstance:t,sourceName:e}){let i="function"==typeof t[n];return`"${e}.${String(n)}${i?"()":""}"`}(n)} dispatched an invalid action: ${function(n){try{return JSON.stringify(n)}catch{return n}}(e)}`))}}(o,this.errorHandler),o.notification)),Oe(o=>"N"===o.kind&&null!=o.value),Yt((n,t)=>{n.subscribe(Ht(t,e=>KA(e,t)))}));return tn(i,e.pipe(Lt(1),Oe(kfe),q(o=>o.ngrxOnInitEffects())))}))}}return n.\u0275fac=function(e){return new(e||n)(O(la),O(Mfe))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Ofe(n){return function(n){return JO(n,Dfe)}(n)?n.ngrxOnIdentifyEffects():""}var N8=(()=>{class n{constructor(e,i){this.effectSources=e,this.store=i,this.effectsSubscription=null}get isStarted(){return!!this.effectsSubscription}start(){this.effectsSubscription||(this.effectsSubscription=this.effectSources.toActions().subscribe(this.store))}ngOnDestroy(){this.effectsSubscription&&(this.effectsSubscription.unsubscribe(),this.effectsSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(O(F8),O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),L8=(()=>{class n{constructor(e,i,r,o,a,s,l){this.sources=e,i.start();for(let c of o)e.addEffects(c);r.dispatch({type:O8})}addEffects(e){this.sources.addEffects(e)}}return n.\u0275fac=function(e){return new(e||n)(O(F8),O(N8),O(Ie),O(P8),O(Kb,8),O(qw,8),O(R8,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),Nfe=(()=>{class n{constructor(e,i,r,o){let a=i.flat();for(let s of a)e.addEffects(s)}}return n.\u0275fac=function(e){return new(e||n)(O(L8),O(k8),O(Kb,8),O(qw,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),to=(()=>{class n{static forFeature(...e){let i=e.flat(),r=S8(i);return{ngModule:Nfe,providers:[r,{provide:E8,multi:!0,useValue:i},{provide:Xw,multi:!0,useValue:[]},{provide:k8,multi:!0,useFactory:T8,deps:[E8,Xw]}]}}static forRoot(...e){let i=e.flat(),r=S8(i);return{ngModule:L8,providers:[r,{provide:KO,useValue:[i]},{provide:R8,useFactory:Lfe},{provide:Xw,multi:!0,useValue:[]},{provide:P8,useFactory:T8,deps:[KO,Xw]}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})();function T8(n,t){let e=[];for(let i of n)e.push(...i);for(let i of t)e.push(...i);return e.map(i=>I8(i)?$n(i):i)}function Lfe(){let n=$n(N8,{optional:!0,skipSelf:!0}),t=$n(KO,{self:!0});if((1!==t.length||0!==t[0].length)&&n)throw new TypeError("EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.");return"guarded"}var Cn=(()=>{return(n=Cn||(Cn={}))[n.UNKNOWN=0]="UNKNOWN",n[n.EXPERIMENTS=1]="EXPERIMENTS",n[n.EXPERIMENT=2]="EXPERIMENT",n[n.COMPARE_EXPERIMENT=3]="COMPARE_EXPERIMENT",n[n.CARD=4]="CARD",n[n.NOT_SET=5]="NOT_SET",Cn;var n})(),Qw="defaultExperimentId",Af=(()=>{return(n=Af||(Af={}))[n.EXPERIMENTS=0]="EXPERIMENTS",n[n.DASHBOARD=1]="DASHBOARD",Af;var n})();function Rf(n){return n.split(",").map(t=>{let e=t.indexOf(":");if(e<0)throw new Error(`Expect colon delimiting name and ID: ${t}`);let i=t.slice(0,e),r=t.slice(e+1);if(!r)throw new Error(`Expect id to be non-falsy: ${t}`);return{name:i,id:r}})}function B8(n){return n.map(({alias:t,id:e})=>`${t}:${e}`).join(",")}function Jb(n,t){switch(n){case Cn.EXPERIMENT:return Object.prototype.hasOwnProperty.call(t,"experimentId")?[t.experimentId]:[Qw];case Cn.CARD:{let e=t.experimentIds;return e.indexOf(",")<0?[e]:Rf(e).map(({id:i})=>i)}case Cn.COMPARE_EXPERIMENT:return Rf(t.experimentIds).map(({id:i})=>i);default:return null}}function Vo(n,t){if(!n||!t)return n===t;if(n.routeKind!==t.routeKind)return!1;let e=Jb(n.routeKind,n.params),i=Jb(t.routeKind,t.params);if(null===e||null===i)return e===i;if(e.length!==i.length)return!1;let r=i.sort();return e.sort().every((o,a)=>r[a]===o)}function $O(n){switch(n){case Cn.EXPERIMENTS:return Af.EXPERIMENTS;case Cn.EXPERIMENT:case Cn.CARD:case Cn.COMPARE_EXPERIMENT:return Af.DASHBOARD;case Cn.UNKNOWN:case Cn.NOT_SET:return null}}function Zw(n,t,e){let i=$O(n);return null!==i&&!e.some(r=>r.deepLinkGroup===i&&r.namespaceId===t)}var U8_getHref=()=>window.location.href,dh=(()=>{class n{getHref(){return U8_getHref()}getSearch(){let e=new URLSearchParams(window.location.search),i=[];return e.forEach((r,o)=>{i.push({key:o,value:r})}),i}getHash(){return window.location.hash}getPath(){return window.location.pathname}getHistoryState(){return window.history.state}replaceStateUrl(e){window.history.replaceState(window.history.state,"",e)}pushStateUrl(e){window.history.pushState(null,"",e)}replaceStateData(e){window.history.replaceState(e,"")}onPopState(){return Ei(window,"popstate").pipe(q(e=>({pathname:this.getPath(),state:e.state})))}getResolvedPath(e){return new URL(e,U8_getHref()).pathname}getFullPath(e,i,r){let o=this.getResolvedPath(e),a="";return i.length&&(a="?"+function(n){let t=new URLSearchParams;for(let{key:e,value:i}of n)t.append(e,i);return t}(i).toString()),`${o}${a}${r?this.getHash():""}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),uh=(()=>{class n{constructor(e){this.appRoot=this.getAppRootFromMetaElement(e)}getAppRootFromMetaElement(e){let i=document.querySelector('head meta[name="tb-relative-root"]');if(!i)return"/";let{pathname:r}=new URL(i.content,e.getHref());return r.replace(/\/*$/,"/")}getAbsPathnameWithAppRoot(e){return this.appRoot.slice(0,-1)+e}getAppRootlessPathname(e){return e.startsWith(this.appRoot)?"/"+e.slice(this.appRoot.length):e}}return n.\u0275fac=function(e){return new(e||n)(O(dh))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Pf=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[dh]}),n})(),kf=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[uh],imports:[Pf]}),n})(),nF=new te("[App Routing] Dirty Updates"),Kw=(()=>{class n{constructor(e){this.dirtyUpdatesSelectorFactories=e}getDirtyUpdatesSelectors(){return this.dirtyUpdatesSelectorFactories??[]}static registerDirtyUpdates(e){return{ngModule:n,providers:[{provide:nF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(nF,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),j8=fe("[App Routing] Discarding Unsaved Updates"),fu=fe("[App Routing] State Rehydrated From Url",{_as:"props",_p:void 0}),Jw=fe("[App Routing] Route Config Loaded",{_as:"props",_p:void 0}),iF=fe("[App Routing] In App Navigation Requested",{_as:"props",_p:void 0}),Of=fe("[App Routing] In App Navigating",{_as:"props",_p:void 0}),Na=fe("[App Routing] In App Navigated",{_as:"props",_p:void 0}),oF=new te("[App Routing] Programmatical Navigation Provider"),$w=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[]){if(this.providers.has(i.actionCreator.type))throw new RangeError(`"${i.actionCreator.type}" is already registered for nav. Multiple navigations on same kick is not allowed.`);this.providers.set(i.actionCreator.type,i.lambda)}}getNavigation(e){let i=this.providers.get(e.type);return i?i(e):null}static registerProgrammaticalNavigation(e){return{ngModule:n,providers:[{provide:oF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(oF,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})();function $b(n){return null!=n.routeKind}function lF(n){return q8(n).map(e=>{let i=e.startsWith(":");return i?{pathPart:e,isParam:!0,paramName:e.slice(1)}:{pathPart:e,isParam:i}})}var Ff=class{static getMatcher(t){return $b(t)?new ev(t):void 0!==t.redirectionPath?new aF(t):new sF(t)}constructor(t){this.validateConfig(t),this.pathFragments=lF(t.path),this.pathMatchers=this.getPathMatchers(this.pathFragments)}validateConfig({path:t}){if(!t.startsWith("/"))throw new RangeError(`config.path should start with '/'. ${t}`);let e=0;for(;(e=t.indexOf(":",e+1))>=0;){if("/"!==t[e-1])throw new RangeError(`config.path parameter should come after '/'. ${t}`);if(void 0===t[e+1]||"/"===t[e+1])throw new RangeError(`config.path parameter should have non-empty name. ${t}`)}}getPathMatchers(t){return t.map(e=>{let{pathPart:i}=e;return e.isParam?r=>({isParamPathPart:!0,partMatched:!0,paramName:e.paramName,paramValue:r}):r=>({isParamPathPart:!1,partMatched:r===i})})}match(t){let e={};if(this.pathMatchers.length!==t.length)return{result:!1};let i=0;for(let r of this.pathMatchers){let a=r(t[i++]);if(!a.partMatched)return{result:!1};a.isParamPathPart&&(e={...e,[a.paramName]:a.paramValue})}return{result:!0,params:e,pathParts:t,isRedirection:!1,redirectionQueryParams:void 0}}matchByParams(t){return{result:!0,params:t,pathParts:this.reprojectPathByParams(this.pathFragments,t),isRedirection:!1,redirectionQueryParams:void 0}}reprojectPathByParams(t,e){let i=[];for(let r of t)if(r.isParam){let{paramName:o}=r;if(!e.hasOwnProperty(o))throw new RangeError(`Failed to reproject parameter. "${o}" parameter should be present.`);i.push(e[o])}else i.push(r.pathPart);return i}},ev=class extends Ff{constructor(t){super(t),this.definition=t}},aF=class extends Ff{constructor(t){super(t),this.definition=t,this.redirectionFragments=lF(t.redirectionPath)}match(t){let e=super.match(t);if(!e.result)return e;let i=this.reprojectPathByParams(this.redirectionFragments,e.params);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:void 0}}},sF=class extends Ff{constructor(t){super(t),this.definition=t}match(t){let e=super.match(t);if(!e.result)return e;let{pathParts:i,queryParams:r}=this.definition.redirector(t);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:r}}},tv=class{constructor(t,e=3){if(this.maxRedirection=e,e<0)throw new RangeError("maxRedirection has to be non-negative number");this.validateRouteConfigs(t),this.defaultRouteConfig=null,this.routeKindToConcreteConfigMatchers=new Map,this.configMatchers=[];for(let i of t){let r=Ff.getMatcher(i);this.configMatchers.push(r),r instanceof ev&&(this.routeKindToConcreteConfigMatchers.set(r.definition.routeKind,r),r.definition.defaultRoute&&(this.defaultRouteConfig=r))}}validateRouteConfigs(t){let e=t.filter($b),i=e.filter(o=>o.defaultRoute);if(i.length>1){let o=i.map(({path:a})=>a).join(", ");throw new RangeError(`There are more than one defaultRoutes. ${o}`)}if(1===i.length){let{path:o}=i[0];if(Boolean(lF(o).find(({isParam:s})=>s)))throw new RangeError(`A defaultRoute cannot have any params. ${o}`)}let r=new Set;for(let{routeKind:o}of e){if(r.has(o))throw new RangeError(`Multiple route configuration for kind: ${o}. Configurations should have unique routeKinds`);r.add(o)}}generateAction(t,e){return t.actionGenerator?t.actionGenerator(e):null}match(t){if(!t.pathname.startsWith("/"))throw new RangeError('Navigation has to made with pathname that starts with "/"');let o,e=q8(t.pathname),i=0,r=!1;for(;;){let a=!1;for(let s of this.configMatchers){let l=s.match(e);if(l.result){a=!0;let{params:c,pathParts:d,isRedirection:u}=l;if(u){e=d,r=!0,o=l.redirectionQueryParams;break}if(!(s instanceof ev))throw new RangeError("No concrete route definition `match` return redirection");let{definition:p}=s,h={routeKind:p.routeKind,params:c,pathname:W8(d),deepLinkProvider:p.deepLinkProvider||null,action:this.generateAction(p,d)};return r?{...h,originateFromRedirection:!0,redirectionOnlyQueryParams:o}:{...h,originateFromRedirection:!1}}}if(r&&i++,!a||i>this.maxRedirection)break}if(i>this.maxRedirection)throw new Error(`Potential redirection loop (redirecting more than ${this.maxRedirection} times. Please do not have cycles in the routes.`);if(this.defaultRouteConfig){let{definition:a}=this.defaultRouteConfig;return{routeKind:a.routeKind,deepLinkProvider:a.deepLinkProvider??null,pathname:a.path,params:{},originateFromRedirection:!0,redirectionOnlyQueryParams:void 0,action:this.generateAction(a,e)}}return null}matchByRouteKind(t,e){let i=this.routeKindToConcreteConfigMatchers.get(t);if(!i)throw new RangeError(`Requires configuration for routeKind: ${t}`);let r=i.matchByParams(e);return{routeKind:t,params:e,pathname:W8(r.pathParts),deepLinkProvider:i.definition.deepLinkProvider||null,originateFromRedirection:!1,action:this.generateAction(i.definition,r.pathParts)}}};function q8(n){return n.split("/").slice(1)}function W8(n){return"/"+n.join("/")}var cF=new te("[App Routing] Route Config"),Rl=(()=>{class n{constructor(e){if(this.routeKindToNgComponent=new Map,!e)return void(this.routeConfigs=new tv([]));let i=[];for(let r of e)for(let o of r)i.push(o);this.routeConfigs=new tv(i),i.forEach(r=>{$b(r)&&this.routeKindToNgComponent.set(r.routeKind,r.ngComponent)})}getRegisteredRouteKinds(){return this.routeKindToNgComponent.keys()}getRouteConfigs(){return this.routeConfigs}getNgComponentByRouteKind(e){return this.routeKindToNgComponent.get(e)||null}static registerRoutes(e){return{ngModule:n,providers:[{provide:cF,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(cF,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),eS="app_routing",nv=Mr(eS),Ho=W(nv,n=>n.activeRoute),Q8=W(nv,n=>n.nextRoute),Z8=W(nv,n=>n.activeNamespaceId),K8=W(nv,n=>n.rehydratedDeepLinks),J8=W(nv,n=>n.registeredRouteKeys),Ws=W(Ho,n=>n?n.routeKind:Cn.NOT_SET),uF=W(Ho,n=>n?n.params:{}),or=W(Ws,uF,(n,t)=>Jb(n,t)),qs=(W(Ws,uF,(n,t)=>{if(n!==Cn.COMPARE_EXPERIMENT)return{};let i=function(n){let t=new Map,e=Rf(n.experimentIds);for(let{id:i,name:r}of e)r&&t.set(i,r);return t}(t);return Object.fromEntries(i.entries())}),W(Ws,uF,(n,t)=>{let e=t;if(n!==Cn.COMPARE_EXPERIMENT&&(n!==Cn.CARD||-1===e.experimentIds.indexOf(",")))return{};let i=function(n){let t=new Map,e=Rf(n.experimentIds),i=0;for(let{id:r,name:o}of e)i++,!t.has(r)&&t.set(r,{aliasText:o,aliasNumber:i});return t}(e);return Object.fromEntries(i.entries())})),pF=fe("[App Routing] Effects Init"),ha=(()=>{return(n=ha||(ha={}))[n.UNCHANGED=0]="UNCHANGED",n[n.NEW=1]="NEW",n[n.FROM_HISTORY=2]="FROM_HISTORY",ha;var n})(),$8=(()=>{class n{constructor(e,i,r,o,a,s,l){this.actions$=e,this.store=i,this.location=r,this.dirtyUpdatesRegistry=o,this.registry=a,this.programmaticalNavModule=s,this.appRootProvider=l,this.onNavigationRequested$=this.actions$.pipe(Zn(iF),q(c=>({pathname:c.pathname.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(c.pathname):this.location.getResolvedPath(c.pathname),options:{browserInitiated:!1,replaceState:c.replaceState??!1,namespaceUpdate:{option:c.resetNamespacedState?ha.NEW:ha.UNCHANGED}}}))),this.bootstrapReducers$=_r(()=>this.actions$.pipe(Zn(pF),q(()=>Jw({routeKinds:new Set(this.registry.getRegisteredRouteKinds())})))),this.onInit$=this.actions$.pipe(Zn(pF)).pipe(Rs(0),q(()=>{let c=this.location.getHistoryState()?.namespaceId,d=void 0===c?{option:ha.NEW}:{option:ha.FROM_HISTORY,namespaceId:c};return{pathname:this.location.getPath(),options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:d}}})),this.onPopState$=this.location.onPopState().pipe(q(c=>({pathname:c.pathname,options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:void 0===c.state?.namespaceId?{option:ha.UNCHANGED}:{option:ha.FROM_HISTORY,namespaceId:c.state.namespaceId}}}))),this.userInitNavRoute$=tn(this.onNavigationRequested$,this.onInit$,this.onPopState$).pipe(q(c=>{if(!c.pathname.startsWith("/"))throw new Error(`[App routing] pathname must start with '/'. Got: ${c.pathname}`);return{...c,pathname:this.appRootProvider.getAppRootlessPathname(c.pathname)}}),q(c=>({routeMatch:this.routeConfigs.match(c),options:c.options}))),this.programmaticalNavRoute$=this.actions$.pipe(q(c=>this.programmaticalNavModule.getNavigation(c)),Oe(c=>null!==c),q(c=>{let m,d=c,{replaceState:u=!1,resetNamespacedState:p,routeKind:h}=d;return m=d.routeKind===Cn.COMPARE_EXPERIMENT?{experimentIds:B8(d.routeParams.aliasAndExperimentIds)}:d.routeParams,{replaceState:u,routeKind:h,routeParams:m,resetNamespacedState:p}}),q(({replaceState:c,routeKind:d,routeParams:u,resetNamespacedState:p})=>({routeMatch:this.routeConfigs?this.routeConfigs.matchByRouteKind(d,u):null,options:{replaceState:c,browserInitiated:!1,namespaceUpdate:{option:p?ha.NEW:ha.UNCHANGED}}}))),this.validatedRouteMatch$=tn(this.userInitNavRoute$,this.programmaticalNavRoute$).pipe(Oe(({routeMatch:c})=>Boolean(c)),q(({routeMatch:c,options:d})=>({routeMatch:c,options:d}))),this.navigate$=_r(()=>this.validatedRouteMatch$.pipe(It(this.store.select(Ho)),xn(([u,p])=>{let h=null!==p&&Vo(p,u.routeMatch),m=this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors();return h||!m.length?$t(u):Co(this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors().map(_=>this.store.select(_).pipe(Lt(1)))).pipe(q(_=>void 0!==_[0].experimentIds&&_[0].experimentIds.length>0),Oe(_=>{if(_){let M=window.confirm("You have unsaved edits, are you sure you want to discard them?");return M&&this.store.dispatch(j8()),M}return!0}),q(()=>u))}),It(this.store.select(K8)),Dt(([{routeMatch:u,options:p},h])=>{if(!p.browserInitiated||!u.deepLinkProvider||p.namespaceUpdate.option===ha.FROM_HISTORY&&!Zw(u.routeKind,p.namespaceUpdate.namespaceId,h))return;let m=u.originateFromRedirection&&u.redirectionOnlyQueryParams?u.redirectionOnlyQueryParams:this.location.getSearch(),_=u.deepLinkProvider.deserializeQueryParams(m);this.store.dispatch(fu({routeKind:u.routeKind,partialState:_}))}),Dt(([{routeMatch:u}])=>{u.action&&this.store.dispatch(u.action)}),Jn(([{routeMatch:u,options:p}])=>null===u.deepLinkProvider?$t({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:[],options:p}):u.deepLinkProvider.serializeStateToQueryParams(this.store).pipe(q((h,m)=>({route:{routeKind:u.routeKind,params:u.params},pathname:u.pathname,queryParams:h,options:0===m?p:{...p,namespaceUpdate:{option:ha.UNCHANGED},replaceState:!0}})))),Dt(({route:u})=>{this.store.dispatch(Of({after:u}))}),Cr(0)).pipe(It(this.store.select(Ho)),q(([u,p])=>{let h=null===p||null===u.route||Vo(p,u.route);return{...u,preserveHash:h}}),Dt(({preserveHash:u,pathname:p,queryParams:h,options:m})=>{(function(n,t){return n.pathname===t.pathname&&n.queryParams.length===t.queryParams.length&&n.queryParams.every((e,i)=>{let r=t.queryParams[i];return e.key===r.key&&e.value===r.value})})({pathname:p,queryParams:h},{pathname:this.appRootProvider.getAppRootlessPathname(this.location.getPath()),queryParams:this.location.getSearch()})||(m.replaceState?this.location.replaceStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,h,u))):this.location.pushStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,h,u))))})).pipe(It(this.store.select(Ho),this.store.select(Z8)),q(([{route:u,options:p},h,m])=>{let _=function(n,t,e){return t.namespaceUpdate.option===ha.FROM_HISTORY?t.namespaceUpdate.namespaceId:null==e||t.namespaceUpdate.option===ha.NEW?`${Date.now().toString()}:${function(){let n=new Uint8Array(32);crypto.getRandomValues(n);let t="";for(let e of n)t+=(e>>4).toString(16);return t}()}`:e}(0,p,m);return this.location.replaceStateData({...this.location.getHistoryState(),namespaceId:_}),Na({before:h,after:u,beforeNamespaceId:m,afterNamespaceId:_})}))),this.routeConfigs=a.getRouteConfigs()}ngrxOnInitEffects(){return pF()}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(dh),O(Kw),O(Rl),O($w),O(uh))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Ufe=gr({activeRoute:null,nextRoute:null,activeNamespaceId:null,rehydratedDeepLinks:[],registeredRouteKeys:new Set},ye(Of,(n,{after:t})=>({...n,nextRoute:t})),ye(Na,(n,{after:t,afterNamespaceId:e})=>{let i=n.rehydratedDeepLinks;return Zw(t.routeKind,e,i)&&(i=[...i],i.push({deepLinkGroup:$O(t.routeKind),namespaceId:e})),{...n,activeRoute:t,nextRoute:null,activeNamespaceId:e,rehydratedDeepLinks:i}}),ye(Jw,(n,{routeKinds:t})=>({...n,registeredRouteKeys:t})));function e6(n,t){return Ufe(n,t)}var Nf=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Kw,$w],imports:[Rl,wr.forFeature(eS,e6),to.forFeature([$8]),kf,Pf]}),n})(),no=(()=>{return(n=no||(no={})).STEP="step",n.WALL_TIME="wall_time",n.RELATIVE="relative",no;var n})(),Sr=(()=>{return(n=Sr||(Sr={})).OFFSET="offset",n.OVERLAY="overlay",Sr;var n})(),t6="__tab__",n6=(()=>{class n{constructor(){window.tensorboard.tf_storage.migrateLegacyURLScheme(),window.tensorboard.tf_globals.setUseHash(!0)}getString(e){return window.tensorboard.tf_storage.getString(e)}setString(e,i,r){window.tensorboard.tf_storage.setString(e,i,r)}getPluginId(){return window.tensorboard.tf_storage.getString(t6)}setPluginId(e,i){this.setString(t6,e,i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),gu=class{},La=(()=>{return(n=La||(La={})).BROWSER_DEFAULT="browser_default",n.LIGHT="light",n.DARK="dark",La;var n})(),hs=fe("[Persistent Settings] Global Settings Loaded",{_as:"props",_p:void 0}),hF=new te("[Persistent Settings] Global Settings"),Ri=(()=>{class n{constructor(e){this.globalSettingSelectors=[],e&&(this.globalSettingSelectors=e.map(i=>i()))}getGlobalSettingSelectors(){return this.globalSettingSelectors??[]}static defineGlobalSetting(e){return{ngModule:n,providers:[{provide:hF,multi:!0,useValue:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(hF,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),i6="_tb_global_settings.timeseries",r6="_tb_global_settings",o6="notificationLastReadTimestamp";function a6(n){n.forEach(t=>{t.sortable=!0,"RUN"===t.type?(t.movable=!1,t.removable=!1):(t.movable=!0,t.removable=!0)})}var tS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),nS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),mF=(()=>{class n extends nS{uiToBackend(e){let i={};return void 0!==e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),void 0!==e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),void 0!==e.tooltipSort&&(i.tooltipSort=e.tooltipSort),void 0!==e.autoReload&&(i.autoReload=e.autoReload),void 0!==e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),void 0!==e.pageSize&&(i.paginationSize=e.pageSize),void 0!==e.themeOverride&&(i.theme=e.themeOverride),void 0!==e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),void 0!==e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),void 0!==e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),void 0!==e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),void 0!==e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),void 0!==e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),void 0!==e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),void 0!==e.singleSelectionHeaders&&(i.singleSelectionHeaders=e.singleSelectionHeaders),void 0!==e.rangeSelectionHeaders&&(i.rangeSelectionHeaders=e.rangeSelectionHeaders),void 0!==e.dashboardDisplayedHparamColumns&&(i.dashboardDisplayedHparamColumns=e.dashboardDisplayedHparamColumns),void 0!==e.savingPinsEnabled&&(i.savingPinsEnabled=e.savingPinsEnabled),i}backendToUi(e){let i={};return e.hasOwnProperty("scalarSmoothing")&&"number"==typeof e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),e.hasOwnProperty("ignoreOutliers")&&"boolean"==typeof e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),e.hasOwnProperty("tooltipSort")&&"string"==typeof e.tooltipSort&&(i.tooltipSort=e.tooltipSort),e.hasOwnProperty("autoReload")&&"boolean"==typeof e.autoReload&&(i.autoReload=e.autoReload),e.hasOwnProperty("autoReloadPeriodInMs")&&"number"==typeof e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),e.hasOwnProperty("paginationSize")&&"number"==typeof e.paginationSize&&(i.pageSize=e.paginationSize),e.hasOwnProperty("theme")&&"string"==typeof e.theme&&new Set(Object.values(La)).has(e.theme)&&(i.themeOverride=e.theme),e.hasOwnProperty("notificationLastReadTimeInMs")&&"number"==typeof e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),e.hasOwnProperty("sideBarWidthInPercent")&&"number"==typeof e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),e.hasOwnProperty("timeSeriesSettingsPaneOpened")&&"boolean"==typeof e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),e.hasOwnProperty("timeSeriesCardMinWidth")&&"number"==typeof e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),e.hasOwnProperty("stepSelectorEnabled")&&"boolean"==typeof e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),e.hasOwnProperty("rangeSelectionEnabled")&&"boolean"==typeof e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),e.hasOwnProperty("linkedTimeEnabled")&&"boolean"==typeof e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),Array.isArray(e.singleSelectionHeaders)&&void 0!==e.singleSelectionHeaders[0].name&&"RUN"===e.singleSelectionHeaders[0].type&&(a6(e.singleSelectionHeaders),i.singleSelectionHeaders=e.singleSelectionHeaders),Array.isArray(e.rangeSelectionHeaders)&&void 0!==e.rangeSelectionHeaders[0].name&&"RUN"===e.rangeSelectionHeaders[0].type&&(a6(e.rangeSelectionHeaders),i.rangeSelectionHeaders=e.rangeSelectionHeaders),Array.isArray(e.dashboardDisplayedHparamColumns)&&(i.dashboardDisplayedHparamColumns=e.dashboardDisplayedHparamColumns),e.hasOwnProperty("savingPinsEnabled")&&"boolean"==typeof e.savingPinsEnabled&&(i.savingPinsEnabled=e.savingPinsEnabled),i}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),s6=(()=>{class n{constructor(e){this.converter=e}setSettings(e){return Object.keys(e)?this.getSettings().pipe(Dt(i=>{window.localStorage.setItem(r6,JSON.stringify(this.converter.uiToBackend({...i,...e}))),window.localStorage.removeItem(i6),window.localStorage.removeItem(o6)}),q(()=>{})):Kr}deserialize(e){try{return JSON.parse(e)}catch{return{}}}getSettings(){let e=window.localStorage.getItem(o6);return $t({...this.converter.backendToUi(this.deserialize(e?JSON.stringify({notificationLastReadTimeInMs:Number(e)}):"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(i6)??"{}")),...this.converter.backendToUi(this.deserialize(window.localStorage.getItem(r6)??"{}"))})}}return n.\u0275fac=function(e){return new(e||n)(O(nS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),l6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:tS,useClass:s6},mF,{provide:nS,useExisting:mF}]}),n})(),iS="persistent_settings",ph=W(Mr(iS),n=>n.shouldPersistSettings),c6=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.configModule=r,this.dataSource=o,this.initializeAndUpdateSettings$=_r(()=>{let a=this.actions$.pipe(Zn(Of),Lt(1),It(this.store.select(ph)),Oe(([,s])=>s),xn(()=>this.dataSource.getSettings()),Dt(s=>{this.store.dispatch(hs({partialSettings:s}))}),Rs(0),xn(()=>tn(...this.configModule.getGlobalSettingSelectors().map(l=>this.store.select(l).pipe(ri((c,d)=>{let u=Object.values(c),p=Object.values(d);return u.length===p.length&&u.every((h,m)=>h===p[m])}),os(1))))),Ta());return a.pipe(function(n){return Yt((t,e)=>{let i=[];return t.subscribe(Ht(e,r=>i.push(r),()=>{e.next(i),e.complete()})),n.subscribe(Ht(e,()=>{let r=i;i=[],e.next(r)},fl)),()=>{i=null}})}(a.pipe(Cr(500))),xn(s=>{if(0===s.length)return Kr;let l={};for(let c of s)Object.assign(l,c);return this.dataSource.setSettings(l)}))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(Ri),O(tS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Yfe=gr({shouldPersistSettings:!0});function d6(n,t){return Yfe(n,t)}var iv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Ri],imports:[wr.forFeature(iS,d6),to.forFeature([c6]),l6]}),n})(),rv=class{},aS=class{},ms=class{constructor(t){this.normalizedNames=new Map,this.lazyUpdate=null,t?this.lazyInit="string"==typeof t?()=>{this.headers=new Map,t.split("\n").forEach(e=>{let i=e.indexOf(":");if(i>0){let r=e.slice(0,i),o=r.toLowerCase(),a=e.slice(i+1).trim();this.maybeSetNormalizedName(r,o),this.headers.has(o)?this.headers.get(o).push(a):this.headers.set(o,[a])}})}:()=>{this.headers=new Map,Object.entries(t).forEach(([e,i])=>{let r;if(r="string"==typeof i?[i]:"number"==typeof i?[i.toString()]:i.map(o=>o.toString()),r.length>0){let o=e.toLowerCase();this.headers.set(o,r),this.maybeSetNormalizedName(e,o)}})}:this.headers=new Map}has(t){return this.init(),this.headers.has(t.toLowerCase())}get(t){this.init();let e=this.headers.get(t.toLowerCase());return e&&e.length>0?e[0]:null}keys(){return this.init(),Array.from(this.normalizedNames.values())}getAll(t){return this.init(),this.headers.get(t.toLowerCase())||null}append(t,e){return this.clone({name:t,value:e,op:"a"})}set(t,e){return this.clone({name:t,value:e,op:"s"})}delete(t,e){return this.clone({name:t,value:e,op:"d"})}maybeSetNormalizedName(t,e){this.normalizedNames.has(e)||this.normalizedNames.set(e,t)}init(){this.lazyInit&&(this.lazyInit instanceof ms?this.copyFrom(this.lazyInit):this.lazyInit(),this.lazyInit=null,this.lazyUpdate&&(this.lazyUpdate.forEach(t=>this.applyUpdate(t)),this.lazyUpdate=null))}copyFrom(t){t.init(),Array.from(t.headers.keys()).forEach(e=>{this.headers.set(e,t.headers.get(e)),this.normalizedNames.set(e,t.normalizedNames.get(e))})}clone(t){let e=new ms;return e.lazyInit=this.lazyInit&&this.lazyInit instanceof ms?this.lazyInit:this,e.lazyUpdate=(this.lazyUpdate||[]).concat([t]),e}applyUpdate(t){let e=t.name.toLowerCase();switch(t.op){case"a":case"s":let i=t.value;if("string"==typeof i&&(i=[i]),0===i.length)return;this.maybeSetNormalizedName(t.name,e);let r=("a"===t.op?this.headers.get(e):void 0)||[];r.push(...i),this.headers.set(e,r);break;case"d":let o=t.value;if(o){let a=this.headers.get(e);if(!a)return;a=a.filter(s=>-1===o.indexOf(s)),0===a.length?(this.headers.delete(e),this.normalizedNames.delete(e)):this.headers.set(e,a)}else this.headers.delete(e),this.normalizedNames.delete(e)}}forEach(t){this.init(),Array.from(this.normalizedNames.keys()).forEach(e=>t(this.normalizedNames.get(e),this.headers.get(e)))}},Zfe=/%(\d[a-f0-9])/gi,Kfe={40:"@","3A":":",24:"$","2C":",","3B":";","3D":"=","3F":"?","2F":"/"};function u6(n){return encodeURIComponent(n).replace(Zfe,(t,e)=>Kfe[e]??t)}function rS(n){return`${n}`}var vc=class{constructor(t={}){if(this.updates=null,this.cloneFrom=null,this.encoder=t.encoder||new class{encodeKey(t){return u6(t)}encodeValue(t){return u6(t)}decodeKey(t){return decodeURIComponent(t)}decodeValue(t){return decodeURIComponent(t)}},t.fromString){if(t.fromObject)throw new Error("Cannot specify both fromString and fromObject.");this.map=function(n,t){let e=new Map;return n.length>0&&n.replace(/^\?/,"").split("&").forEach(r=>{let o=r.indexOf("="),[a,s]=-1==o?[t.decodeKey(r),""]:[t.decodeKey(r.slice(0,o)),t.decodeValue(r.slice(o+1))],l=e.get(a)||[];l.push(s),e.set(a,l)}),e}(t.fromString,this.encoder)}else t.fromObject?(this.map=new Map,Object.keys(t.fromObject).forEach(e=>{let i=t.fromObject[e],r=Array.isArray(i)?i.map(rS):[rS(i)];this.map.set(e,r)})):this.map=null}has(t){return this.init(),this.map.has(t)}get(t){this.init();let e=this.map.get(t);return e?e[0]:null}getAll(t){return this.init(),this.map.get(t)||null}keys(){return this.init(),Array.from(this.map.keys())}append(t,e){return this.clone({param:t,value:e,op:"a"})}appendAll(t){let e=[];return Object.keys(t).forEach(i=>{let r=t[i];Array.isArray(r)?r.forEach(o=>{e.push({param:i,value:o,op:"a"})}):e.push({param:i,value:r,op:"a"})}),this.clone(e)}set(t,e){return this.clone({param:t,value:e,op:"s"})}delete(t,e){return this.clone({param:t,value:e,op:"d"})}toString(){return this.init(),this.keys().map(t=>{let e=this.encoder.encodeKey(t);return this.map.get(t).map(i=>e+"="+this.encoder.encodeValue(i)).join("&")}).filter(t=>""!==t).join("&")}clone(t){let e=new vc({encoder:this.encoder});return e.cloneFrom=this.cloneFrom||this,e.updates=(this.updates||[]).concat(t),e}init(){null===this.map&&(this.map=new Map),null!==this.cloneFrom&&(this.cloneFrom.init(),this.cloneFrom.keys().forEach(t=>this.map.set(t,this.cloneFrom.map.get(t))),this.updates.forEach(t=>{switch(t.op){case"a":case"s":let e=("a"===t.op?this.map.get(t.param):void 0)||[];e.push(rS(t.value)),this.map.set(t.param,e);break;case"d":if(void 0===t.value){this.map.delete(t.param);break}{let i=this.map.get(t.param)||[],r=i.indexOf(rS(t.value));-1!==r&&i.splice(r,1),i.length>0?this.map.set(t.param,i):this.map.delete(t.param)}}}),this.cloneFrom=this.updates=null)}};function p6(n){return typeof ArrayBuffer<"u"&&n instanceof ArrayBuffer}function h6(n){return typeof Blob<"u"&&n instanceof Blob}function m6(n){return typeof FormData<"u"&&n instanceof FormData}var hh=class{constructor(t,e,i,r){let o;if(this.url=e,this.body=null,this.reportProgress=!1,this.withCredentials=!1,this.responseType="json",this.method=t.toUpperCase(),function(n){switch(n){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"JSONP":return!1;default:return!0}}(this.method)||r?(this.body=void 0!==i?i:null,o=r):o=i,o&&(this.reportProgress=!!o.reportProgress,this.withCredentials=!!o.withCredentials,o.responseType&&(this.responseType=o.responseType),o.headers&&(this.headers=o.headers),o.context&&(this.context=o.context),o.params&&(this.params=o.params)),this.headers||(this.headers=new ms),this.context||(this.context=new class{constructor(){this.map=new Map}set(t,e){return this.map.set(t,e),this}get(t){return this.map.has(t)||this.map.set(t,t.defaultValue()),this.map.get(t)}delete(t){return this.map.delete(t),this}has(t){return this.map.has(t)}keys(){return this.map.keys()}}),this.params){let a=this.params.toString();if(0===a.length)this.urlWithParams=e;else{let s=e.indexOf("?");this.urlWithParams=e+(-1===s?"?":s<e.length-1?"&":"")+a}}else this.params=new vc,this.urlWithParams=e}serializeBody(){return null===this.body?null:p6(this.body)||h6(this.body)||m6(this.body)||typeof URLSearchParams<"u"&&this.body instanceof URLSearchParams||"string"==typeof this.body?this.body:this.body instanceof vc?this.body.toString():"object"==typeof this.body||"boolean"==typeof this.body||Array.isArray(this.body)?JSON.stringify(this.body):this.body.toString()}detectContentTypeHeader(){return null===this.body||m6(this.body)?null:h6(this.body)?this.body.type||null:p6(this.body)?null:"string"==typeof this.body?"text/plain":this.body instanceof vc?"application/x-www-form-urlencoded;charset=UTF-8":"object"==typeof this.body||"number"==typeof this.body||"boolean"==typeof this.body?"application/json":null}clone(t={}){let e=t.method||this.method,i=t.url||this.url,r=t.responseType||this.responseType,o=void 0!==t.body?t.body:this.body,a=void 0!==t.withCredentials?t.withCredentials:this.withCredentials,s=void 0!==t.reportProgress?t.reportProgress:this.reportProgress,l=t.headers||this.headers,c=t.params||this.params,d=t.context??this.context;return void 0!==t.setHeaders&&(l=Object.keys(t.setHeaders).reduce((u,p)=>u.set(p,t.setHeaders[p]),l)),t.setParams&&(c=Object.keys(t.setParams).reduce((u,p)=>u.set(p,t.setParams[p]),c)),new hh(e,i,o,{params:c,headers:l,context:d,reportProgress:s,responseType:r,withCredentials:a})}},_u=(()=>{return(n=_u||(_u={}))[n.Sent=0]="Sent",n[n.UploadProgress=1]="UploadProgress",n[n.ResponseHeader=2]="ResponseHeader",n[n.DownloadProgress=3]="DownloadProgress",n[n.Response=4]="Response",n[n.User=5]="User",_u;var n})(),ov=class{constructor(t,e=200,i="OK"){this.headers=t.headers||new ms,this.status=void 0!==t.status?t.status:e,this.statusText=t.statusText||i,this.url=t.url||null,this.ok=this.status>=200&&this.status<300}},av=class extends ov{constructor(t={}){super(t),this.type=_u.ResponseHeader}clone(t={}){return new av({headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},Bf=class extends ov{constructor(t={}){super(t),this.type=_u.Response,this.body=void 0!==t.body?t.body:null}clone(t={}){return new Bf({body:void 0!==t.body?t.body:this.body,headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},ud=class extends ov{constructor(t){super(t,0,"Unknown Error"),this.name="HttpErrorResponse",this.ok=!1,this.message=this.status>=200&&this.status<300?`Http failure during parsing for ${t.url||"(unknown url)"}`:`Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`,this.error=t.error||null}};function fF(n,t){return{body:t,headers:n.headers,context:n.context,observe:n.observe,params:n.params,reportProgress:n.reportProgress,responseType:n.responseType,withCredentials:n.withCredentials}}var mh=(()=>{class n{constructor(e){this.handler=e}request(e,i,r={}){let o;if(e instanceof hh)o=e;else{let l,c;l=r.headers instanceof ms?r.headers:new ms(r.headers),r.params&&(c=r.params instanceof vc?r.params:new vc({fromObject:r.params})),o=new hh(e,i,void 0!==r.body?r.body:null,{headers:l,context:r.context,params:c,reportProgress:r.reportProgress,responseType:r.responseType||"json",withCredentials:r.withCredentials})}let a=$t(o).pipe(function(n,t){return mn(t)?xn(n,t,1):xn(n,1)}(l=>this.handler.handle(l)));if(e instanceof hh||"events"===r.observe)return a;let s=a.pipe(Oe(l=>l instanceof Bf));switch(r.observe||"body"){case"body":switch(o.responseType){case"arraybuffer":return s.pipe(q(l=>{if(null!==l.body&&!(l.body instanceof ArrayBuffer))throw new Error("Response is not an ArrayBuffer.");return l.body}));case"blob":return s.pipe(q(l=>{if(null!==l.body&&!(l.body instanceof Blob))throw new Error("Response is not a Blob.");return l.body}));case"text":return s.pipe(q(l=>{if(null!==l.body&&"string"!=typeof l.body)throw new Error("Response is not a string.");return l.body}));default:return s.pipe(q(l=>l.body))}case"response":return s;default:throw new Error(`Unreachable: unhandled observe type ${r.observe}}`)}}delete(e,i={}){return this.request("DELETE",e,i)}get(e,i={}){return this.request("GET",e,i)}head(e,i={}){return this.request("HEAD",e,i)}jsonp(e,i){return this.request("JSONP",e,{params:(new vc).append(i,"JSONP_CALLBACK"),observe:"body",responseType:"json"})}options(e,i={}){return this.request("OPTIONS",e,i)}patch(e,i,r={}){return this.request("PATCH",e,fF(r,i))}post(e,i,r={}){return this.request("POST",e,fF(r,i))}put(e,i,r={}){return this.request("PUT",e,fF(r,i))}}return n.\u0275fac=function(e){return new(e||n)(O(rv))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function b6(n,t){return t(n)}function ege(n,t){return(e,i)=>t.intercept(e,{handle:r=>n(r,i)})}var bF=new te("HTTP_INTERCEPTORS"),vF=new te("HTTP_INTERCEPTOR_FNS");function nge(){let n=null;return(t,e)=>(null===n&&(n=($n(bF,{optional:!0})??[]).reduceRight(ege,b6)),n(t,e))}var f6=(()=>{class n extends rv{constructor(e,i){super(),this.backend=e,this.injector=i,this.chain=null}handle(e){if(null===this.chain){let i=Array.from(new Set(this.injector.get(vF)));this.chain=i.reduceRight((r,o)=>function(n,t,e){return(i,r)=>e.runInContext(()=>t(i,o=>n(o,r)))}(r,o,this.injector),b6)}return this.chain(e,i=>this.backend.handle(i))}}return n.\u0275fac=function(e){return new(e||n)(O(aS),O(lc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),ige=/^\)\]\}',?\n/,g6=(()=>{class n{constructor(e){this.xhrFactory=e}handle(e){if("JSONP"===e.method)throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");return new Kt(i=>{let r=this.xhrFactory.build();if(r.open(e.method,e.urlWithParams),e.withCredentials&&(r.withCredentials=!0),e.headers.forEach((h,m)=>r.setRequestHeader(h,m.join(","))),e.headers.has("Accept")||r.setRequestHeader("Accept","application/json, text/plain, */*"),!e.headers.has("Content-Type")){let h=e.detectContentTypeHeader();null!==h&&r.setRequestHeader("Content-Type",h)}if(e.responseType){let h=e.responseType.toLowerCase();r.responseType="json"!==h?h:"text"}let o=e.serializeBody(),a=null,s=()=>{if(null!==a)return a;let h=r.statusText||"OK",m=new ms(r.getAllResponseHeaders()),_=function(n){return"responseURL"in n&&n.responseURL?n.responseURL:/^X-Request-URL:/m.test(n.getAllResponseHeaders())?n.getResponseHeader("X-Request-URL"):null}(r)||e.url;return a=new av({headers:m,status:r.status,statusText:h,url:_}),a},l=()=>{let{headers:h,status:m,statusText:_,url:M}=s(),y=null;204!==m&&(y=typeof r.response>"u"?r.responseText:r.response),0===m&&(m=y?200:0);let x=m>=200&&m<300;if("json"===e.responseType&&"string"==typeof y){let R=y;y=y.replace(ige,"");try{y=""!==y?JSON.parse(y):null}catch(I){y=R,x&&(x=!1,y={error:I,text:y})}}x?(i.next(new Bf({body:y,headers:h,status:m,statusText:_,url:M||void 0})),i.complete()):i.error(new ud({error:y,headers:h,status:m,statusText:_,url:M||void 0}))},c=h=>{let{url:m}=s(),_=new ud({error:h,status:r.status||0,statusText:r.statusText||"Unknown Error",url:m||void 0});i.error(_)},d=!1,u=h=>{d||(i.next(s()),d=!0);let m={type:_u.DownloadProgress,loaded:h.loaded};h.lengthComputable&&(m.total=h.total),"text"===e.responseType&&!!r.responseText&&(m.partialText=r.responseText),i.next(m)},p=h=>{let m={type:_u.UploadProgress,loaded:h.loaded};h.lengthComputable&&(m.total=h.total),i.next(m)};return r.addEventListener("load",l),r.addEventListener("error",c),r.addEventListener("timeout",c),r.addEventListener("abort",c),e.reportProgress&&(r.addEventListener("progress",u),null!==o&&r.upload&&r.upload.addEventListener("progress",p)),r.send(o),i.next({type:_u.Sent}),()=>{r.removeEventListener("error",c),r.removeEventListener("abort",c),r.removeEventListener("load",l),r.removeEventListener("timeout",c),e.reportProgress&&(r.removeEventListener("progress",u),null!==o&&r.upload&&r.upload.removeEventListener("progress",p)),r.readyState!==r.DONE&&r.abort()}})}}return n.\u0275fac=function(e){return new(e||n)(O(th))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),v6=new te("XSRF_ENABLED"),age=new te("XSRF_COOKIE_NAME",{providedIn:"root",factory:()=>"XSRF-TOKEN"}),lge=new te("XSRF_HEADER_NAME",{providedIn:"root",factory:()=>"X-XSRF-TOKEN"}),sS=class{},cge=(()=>{class n{constructor(e,i,r){this.doc=e,this.platform=i,this.cookieName=r,this.lastCookieString="",this.lastToken=null,this.parseCount=0}getToken(){if("server"===this.platform)return null;let e=this.doc.cookie||"";return e!==this.lastCookieString&&(this.parseCount++,this.lastToken=fw(e,this.cookieName),this.lastCookieString=e),this.lastToken}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(fc),O(age))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function dge(n,t){let e=n.url.toLowerCase();if(!$n(v6)||"GET"===n.method||"HEAD"===n.method||e.startsWith("http://")||e.startsWith("https://"))return t(n);let i=$n(sS).getToken(),r=$n(lge);return null!=i&&!n.headers.has(r)&&(n=n.clone({headers:n.headers.set(r,i)})),t(n)}var oS=(()=>{return(n=oS||(oS={}))[n.Interceptors=0]="Interceptors",n[n.LegacyInterceptors=1]="LegacyInterceptors",n[n.CustomXsrfConfiguration=2]="CustomXsrfConfiguration",n[n.NoXsrfProtection=3]="NoXsrfProtection",n[n.JsonpSupport=4]="JsonpSupport",n[n.RequestsMadeViaParent=5]="RequestsMadeViaParent",oS;var n})();function pge(...n){let t=[mh,g6,f6,{provide:rv,useExisting:f6},{provide:aS,useExisting:g6},{provide:vF,useValue:dge,multi:!0},{provide:v6,useValue:!0},{provide:sS,useClass:cge}];for(let e of n)t.push(...e.\u0275providers);return function(n){return{"\u0275providers":n}}(t)}var _6=new te("LEGACY_INTERCEPTOR_FN"),y6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[pge({"\u0275kind":oS.LegacyInterceptors,"\u0275providers":[{provide:_6,useFactory:nge},{provide:vF,useExisting:_6,multi:!0}]})]}),n})(),lS="feature",Vf=Mr(lS),bu=W(Vf,n=>n.isFeatureFlagsLoaded),Qo=W(Vf,n=>({...n.defaultFlags,...n.flagOverrides})),C6=W(Vf,n=>n.defaultFlags),sv=W(Vf,n=>n.flagOverrides||{}),fh=W(Vf,n=>n.metadata),Hf=W(Vf,n=>{let t={};for(let e in n.flagOverrides){let i=n.metadata[e];i&&i.queryParamOverride&&i.sendToServerWhenOverridden&&(t[e]=n.flagOverrides[e])}return t}),M6=W(Qo,n=>n.isAutoDarkModeAllowed),Pl=W(Qo,n=>null!==n.enableDarkModeOverride?n.enableDarkModeOverride:n.defaultEnableDarkMode),cS=W(Qo,n=>n.enableDarkModeOverride),w6=W(Qo,n=>n.enabledExperimentalPlugins),S6=W(Qo,n=>n.inColab),dS=W(Qo,n=>n.metricsImageSupportEnabled),yF=W(Qo,n=>n.forceSvg),E6=W(Qo,n=>void 0!==n.showFlags),uS=W(Qo,n=>n.enableScalarColumnCustomization),T6=W(Qo,n=>n.enableScalarColumnContextMenus),pd=W(Qo,n=>n.enableGlobalPins),D6=W(Qo,n=>n.enableColorByExperiment);function fge(n,t){if(!n)return;let e=n instanceof FormData?function(n){let t={};for(let[e,i]of n.entries())t[e]=i;return t}(n):n;return t?{[t]:JSON.stringify(e)}:e}var gge="X-XSRF-Protected";function xF(n){let t=n.headers||new ms;return t=t.append(gge,"1"),{...n,headers:t}}var Xs=(()=>{class n{constructor(e,i,r){this.appRootProvider=e,this.http=i,this.store=r}resolveAppRoot(e){return e.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(e):e}get(e,i={}){return this.http.get(this.resolveAppRoot(e),i)}post(e,i,r={},o){return r=xF(r),this.store.select(bu).pipe(Oe(a=>Boolean(a)),Lt(1),It(this.store.select(S6)),xn(([,a])=>{let s=this.resolveAppRoot(e);return a?this.http.get(s,{headers:r.headers??{},params:fge(i,o)}):this.http.post(s,i,r)}))}put(e,i,r={}){return this.http.put(this.resolveAppRoot(e),i,xF(r))}delete(e,i={}){return this.http.delete(this.resolveAppRoot(e),xF(i))}}return n.\u0275fac=function(e){return new(e||n)(O(uh),O(mh),O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),zf=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Xs],imports:[y6,kf]}),n})(),Ys=(()=>{return(n=Ys||(Ys={})).UNKNOWN="UNKNOWN",n.NOT_FOUND="NOT_FOUND",n.PERMISSION_DENIED="PERMISSION_DENIED",Ys;var n})(),I6=new te("TensorBoard brand name");function A6(n){let t=Ys.UNKNOWN;return n instanceof ud&&(404===n.status&&(t=Ys.NOT_FOUND),403===n.status&&(t=Ys.PERMISSION_DENIED)),_l(new cv(t))}var cv=class{constructor(t){this.failureCode=t}},pS=(()=>{class n{constructor(e){this.http=e,this.tfBackend=document.createElement("tf-backend").tf_backend}fetchPluginsListing(e){let i=function(n){if(!n.length)return null;let t=new URLSearchParams;for(let e of n)t.append("experimentalPlugin",e);return t}(e),r=i?`data/plugins_listing?${i.toString()}`:"data/plugins_listing";return this.http.get(r).pipe(co(A6))}fetchEnvironment(){return Co([this.http.get("data/environment"),Jr(this.tfBackend.environmentStore.refresh())]).pipe(q(([r])=>r),co(A6))}}return n.\u0275fac=function(e){return new(e||n)(O(Xs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),R6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[pS],imports:[zf]}),n})(),Re=(()=>{return(n=Re||(Re={}))[n.NOT_LOADED=0]="NOT_LOADED",n[n.LOADED=1]="LOADED",n[n.LOADING=2]="LOADING",n[n.FAILED=3]="FAILED",Re;var n})(),yc=fe("[Core] Plugin Changed",{_as:"props",_p:void 0}),hS=fe("[Core] Plugin Url Hash Changed",{_as:"props",_p:void 0}),P6=fe("[Core] Loaded"),Ba=fe("[Core] User Triggered Reload"),ma=fe("[Core] Auto Reload"),mS=fe("[Core] PluginListing Fetch Requested"),gh=fe("[Core] PluginListing Fetch Successful",{_as:"props",_p:void 0}),dv=fe("[Core] PluginListing Fetch Failed",{_as:"props",_p:void 0}),fS=fe("[Core] Polymer Component Runs Fetch Requested"),gS=fe("[Core] Polymer Component Runs Fetch Successful"),_S=fe("[Core] Polymer Component Runs Fetch Failed"),bS=fe("[Core] Environment Fetch Successful",{_as:"props",_p:void 0}),k6=fe("[Core] Run Selection Changed",{_as:"props",_p:void 0}),O6=fe("[Core] Run Fetch Successful",{_as:"props",_p:void 0}),Uf=fe("[Core] Side Bar Width Changed",{_as:"props",_p:void 0}),vS=fe("[Core] Runs Table Full Screen Toggled");function _h(n,t,e){let i=Object.keys(n),r={...n,...t,privateNamespacedState:{}};return{initialState:r,reducers:gr(r,ye(Na,(s,{before:l,after:c,beforeNamespaceId:d,afterNamespaceId:u})=>{let p=s;return d!==u&&(p=function(s,l,c){let d={...s.privateNamespacedState};if(l){let p={};for(let h of i)p[h]=s[h];d={...d,[l]:p}}let u={};return s.privateNamespacedState?.[c]?u=s.privateNamespacedState[c]:l&&(u=n),{...s,...u,privateNamespacedState:d}}(s,d,u)),e&&(p=e(p,l,c)),p}))}}function bh(...n){return(t,e)=>{let i=t;for(let r of n)i=r(i,e);return i}}var pv={activePlugin:null,plugins:{},coreDataLoadState:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},pluginsListLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null,failureCode:null},environment:{data_location:"",window_title:""},polymerRunsLoadState:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},polymerInteropRuns:[],polymerInteropRunSelection:new Set,sideBarWidthInPercent:20,runsTableFullScreen:!1,unknownQueryParams:{}},vge=gr(pv,ye(yc,hS,(n,{plugin:t})=>({...n,activePlugin:t})),ye(mS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Re.LOADING},pluginsListLoaded:{...n.pluginsListLoaded,state:Re.LOADING}})),ye(dv,(n,{failureCode:t})=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Re.FAILED},pluginsListLoaded:{...n.pluginsListLoaded,state:Re.FAILED,failureCode:t}})),ye(gh,(n,{plugins:t})=>{let e=Object.keys(t).find(a=>t[a].enabled)||null,i=n.activePlugin||e,r=Date.now(),o=n.coreDataLoadState;return n.polymerRunsLoadState.state===Re.LOADED&&(o={state:Re.LOADED,lastLoadedTimeInMs:r}),{...n,activePlugin:i,coreDataLoadState:o,plugins:t,pluginsListLoaded:{state:Re.LOADED,lastLoadedTimeInMs:r,failureCode:null}}}),ye(fS,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Re.LOADING},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Re.LOADING}})),ye(gS,n=>{let t=Date.now(),e=n.coreDataLoadState;return n.pluginsListLoaded.state===Re.LOADED&&(e={state:Re.LOADED,lastLoadedTimeInMs:t}),{...n,coreDataLoadState:e,polymerRunsLoadState:{...n.polymerRunsLoadState,state:Re.LOADED,lastLoadedTimeInMs:t}}}),ye(_S,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Re.FAILED},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Re.FAILED}})),ye(bS,(n,{environment:t})=>({...n,environment:t})),ye(O6,(n,{runs:t})=>({...n,polymerInteropRuns:t})),ye(k6,(n,{nextSelection:t})=>({...n,polymerInteropRunSelection:new Set(t)})),ye(Uf,(n,{widthInPercent:t})=>({...n,sideBarWidthInPercent:Math.min(Math.max(0,t),100)})),ye(hs,(n,{partialSettings:t})=>{let e={...n},i=t.sideBarWidthInPercent;return"number"==typeof i&&i>=0&&i<=100&&(e.sideBarWidthInPercent=i),e}),ye(vS,n=>({...n,runsTableFullScreen:!n.runsTableFullScreen})),ye(fu,(n,{partialState:t})=>{let{unknownQueryParams:e={}}=t;return{...n,unknownQueryParams:e}})),{reducers:yge}=_h(pv,{});function F6(n,t){return bh(vge,yge)(n,t)}var xc=Mr("core"),xS=W(xc,n=>n.pluginsListLoaded),N6=W(xc,n=>n.polymerRunsLoadState),L6=W(xc,n=>n.coreDataLoadState.state),jf=W(xc,n=>n.coreDataLoadState.lastLoadedTimeInMs),Zo=W(xc,n=>n.activePlugin),Gf=W(xc,n=>n.plugins),B6=W(xc,n=>n.unknownQueryParams),CS=W(xc,n=>n.environment),MS=W(xc,n=>n.sideBarWidthInPercent),wS=W(xc,n=>n.runsTableFullScreen),V6=new Set([Cn.COMPARE_EXPERIMENT,Cn.EXPERIMENT,Cn.NOT_SET]),H6=(()=>{class n{refreshPolymerRuns(){return Jr(this.tfBackend.ref.runsStore.refresh())}fetchEnvironment(){return this.webappDataSource.fetchEnvironment().pipe(Dt(e=>{this.store.dispatch(bS({environment:e}))}))}constructor(e,i,r){this.actions$=e,this.store=i,this.webappDataSource=r,this.tfBackend={ref:document.createElement("tf-backend").tf_backend},this.onDashboardLoad$=tn(this.actions$.pipe(Zn(P6,Na),It(this.store.select(Ho)),ri(([,o],[,a])=>Vo(o,a))),this.actions$.pipe(Zn(ma,Ba))).pipe(It(this.store.select(Ws)),Oe(([,o])=>V6.has(o)),ic(1,void 0,{leading:!0})),this.fetchWebAppData$=_r(()=>{let o=this.onDashboardLoad$.pipe(It(this.store.select(xS),this.store.select(w6)),Oe(([,{state:s}])=>s!==Re.LOADING),Dt(()=>this.store.dispatch(mS())),xn(([,,s])=>function(...n){let t=ec(n),e=OC(n);return e.length?new Kt(i=>{let r=e.map(()=>[]),o=e.map(()=>!1);i.add(()=>{r=o=null});for(let a=0;!i.closed&&a<e.length;a++)ci(e[a]).subscribe(Ht(i,s=>{if(r[a].push(s),r.every(l=>l.length)){let l=r.map(c=>c.shift());i.next(t?t(...l):l),r.some((c,d)=>!c.length&&o[d])&&i.complete()}},()=>{o[a]=!0,!r[a].length&&i.complete()}));return()=>{r=o=null}}):Kr}(this.webappDataSource.fetchPluginsListing(s),this.fetchEnvironment()).pipe(q(([l])=>{this.store.dispatch(gh({plugins:l}))}),co(l=>(this.store.dispatch(dv(l instanceof cv?{failureCode:l.failureCode}:{failureCode:Ys.UNKNOWN})),Kr)))));return tn(o,this.onDashboardLoad$.pipe(q(([,s])=>s),Jn(s=>s!==Cn.COMPARE_EXPERIMENT?$t([]):this.store.select(qs).pipe(ri((l,c)=>{let d=Object.entries(l),u=new Map(Object.entries(c));if(d.length!==u.size)return!1;for(let[p,h]of d)if(!u.get(p)||u.get(p).aliasText!==h.aliasText||u.get(p).aliasNumber!==h.aliasNumber)return!1;return!0}),Rs(0),ic(500,void 0,{leading:!0,trailing:!0}))),It(this.store.select(Ws),this.store.select(N6)),Oe(([,s,l])=>V6.has(s)&&l.state!==Re.LOADING),Dt(()=>{this.store.dispatch(fS())}),Jn(()=>this.refreshPolymerRuns()),Dt(()=>{this.store.dispatch(gS())}),co(()=>(this.store.dispatch(_S()),Kr))))},{dispatch:!1}),this.dispatchChangePlugin$=_r(()=>tn(this.onDashboardLoad$,this.actions$.pipe(Zn(gh))).pipe(It(this.store.select(Zo)),q(([,o])=>o),ri(),Oe(o=>null!==o),Lt(1),Dt(o=>{this.store.dispatch(yc({plugin:o}))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(pS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),CF=new te("Core Feature Config");function z6(n){return{initialState:{...pv,activePlugin:n.getPluginId()||null}}}function Mge(){return W(MS,n=>({sideBarWidthInPercent:n}))}var Qs=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:CF,deps:[gu],useFactory:z6}],imports:[to.forFeature([H6]),wr.forFeature("core",F6,CF),R6,Ri.defineGlobalSetting(Mge)]}),n})(),U6=new te("[Alert] Action-To-Alert Provider"),Cc=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[])for(let r of i){if(this.providers.has(r.actionCreator.type))throw new RangeError(`"${r.actionCreator.type}" is already registered for alerts. Multiple alerts for the same action is not allowed.`);this.providers.set(r.actionCreator.type,r.alertFromAction)}}getAlertFromAction(e){let i=this.providers.get(e.type);return i?i(e):null}static registerAlertActions(e){return{ngModule:n,providers:[{provide:U6,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(O(U6,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),gt=(()=>{return(n=gt||(gt={})).COLOR="COLOR",n.RELATIVE_TIME="RELATIVE_TIME",n.RUN="RUN",n.STEP="STEP",n.EXPERIMENT="EXPERIMENT",n.TIME="TIME",n.VALUE="VALUE",n.SMOOTHED="SMOOTHED",n.VALUE_CHANGE="VALUE_CHANGE",n.START_STEP="START_STEP",n.END_STEP="END_STEP",n.START_VALUE="START_VALUE",n.END_VALUE="END_VALUE",n.MIN_VALUE="MIN_VALUE",n.MAX_VALUE="MAX_VALUE",n.PERCENTAGE_CHANGE="PERCENTAGE_CHANGE",n.STEP_AT_MAX="STEP_AT_MAX",n.STEP_AT_MIN="STEP_AT_MIN",n.MEAN="MEAN",n.RAW_CHANGE="RAW_CHANGE",n.HPARAM="HPARAM",n.METRIC="METRIC",n.CUSTOM="CUSTOM",gt;var n})(),io=(()=>{return(n=io||(io={}))[n.DISCRETE=0]="DISCRETE",n[n.INTERVAL=1]="INTERVAL",io;var n})(),Lr=(()=>{return(n=Lr||(Lr={}))[n.ASCENDING=0]="ASCENDING",n[n.DESCENDING=1]="DESCENDING",Lr;var n})(),Wr=(()=>{return(n=Wr||(Wr={}))[n.SINGLE=0]="SINGLE",n[n.RANGE=1]="RANGE",Wr;var n})(),mo=(()=>{return(n=mo||(mo={}))[n.RIGHT=0]="RIGHT",n[n.LEFT=1]="LEFT",mo;var n})(),Zs=(()=>{return(n=Zs||(Zs={})).RUN="RUN",n.EXPERIMENT_ALIAS="EXPERIMENT_ALIAS",n.HPARAM="HPARAM",n.OTHER="OTHER",Zs;var n})(),vu=(()=>{return(n=vu||(vu={})).DEFAULT="DEFAULT",n.SMALL="SMALL",vu;var n})();function j6(n){return"RUN"===n.type?Zs.RUN:"CUSTOM"===n.type&&"experimentAlias"===n.name?Zs.EXPERIMENT_ALIAS:"HPARAM"===n.type?Zs.HPARAM:Zs.OTHER}var kl={moveColumn:function(n,t,e,i){let r=n.findIndex(s=>s.name===t.name),o=n.findIndex(s=>s.name===e.name);if(-1===r||r===o)return n;if(-1===o){if(void 0===i)return n;o=i===mo.LEFT?0:n.length-1}let a=[...n];return a.splice(r,1),a.splice(o,0,t),a},groupColumns:function(n){let t=new Map([[Zs.RUN,[]],[Zs.EXPERIMENT_ALIAS,[]],[Zs.HPARAM,[]],[Zs.OTHER,[]]]);return n.forEach(e=>{t.get(j6(e))?.push(e)}),Array.from(t.values()).flat()},columnToGroup:j6},ro={};NA(ro,{dashboardHparamColumnAdded:()=>EF,dashboardHparamColumnOrderChanged:()=>IF,dashboardHparamColumnRemoved:()=>TF,dashboardHparamColumnToggled:()=>DF,dashboardHparamFilterAdded:()=>wF,dashboardHparamFilterRemoved:()=>mv,dashboardMetricFilterAdded:()=>SF,dashboardMetricFilterRemoved:()=>fv,hparamsFetchSessionGroupsSucceeded:()=>hv,loadAllDashboardHparams:()=>gv});var hv=fe("[Hparams] Hparams Fetch Session Groups Succeeded",{_as:"props",_p:void 0}),wF=fe("[Hparams] Dashboard Hparam Filter Added",{_as:"props",_p:void 0}),SF=fe("[Hparams] Dashboard Metric Filter Added",{_as:"props",_p:void 0}),mv=fe("[Hparams] Dashboard Hparam Filter Removed",{_as:"props",_p:void 0}),fv=fe("[Hparams] Dashboard Metric Filter Removed",{_as:"props",_p:void 0}),EF=fe("[Hparams] Dashboard Hparam Column Added",{_as:"props",_p:void 0}),TF=fe("[Hparams] Dashboard Hparam Column Removed",{_as:"props",_p:void 0}),DF=fe("[Hparams] Dashboard Hparam Column Toggled",{_as:"props",_p:void 0}),IF=fe("[Hparams] Dashboard Hparam Column Order Changed",{_as:"props",_p:void 0}),gv=fe("[Hparams] Load all Hparams"),Dge=gr({dashboardHparamSpecs:[],dashboardSessionGroups:[],dashboardFilters:{hparams:new Map,metrics:new Map},dashboardDisplayedHparamColumns:[],numDashboardHparamsToLoad:1e3,numDashboardHparamsLoaded:0},ye(hs,(n,{partialSettings:t})=>{let{dashboardDisplayedHparamColumns:e}=t;return e?{...n,dashboardDisplayedHparamColumns:e}:n}),ye(hv,(n,t)=>{let e=t.hparamSpecs;return{...n,dashboardHparamSpecs:e,dashboardSessionGroups:t.sessionGroups,numDashboardHparamsLoaded:e.length}}),ye(wF,(n,t)=>{let e=new Map(n.dashboardFilters.hparams);return e.set(t.name,t.filter),{...n,dashboardFilters:{...n.dashboardFilters,hparams:e}}}),ye(SF,(n,t)=>{let e=new Map(n.dashboardFilters.metrics);return e.set(t.name,t.filter),{...n,dashboardFilters:{...n.dashboardFilters,metrics:e}}}),ye(mv,(n,t)=>{let e=new Map(n.dashboardFilters.hparams);return e.delete(t.name),{...n,dashboardFilters:{...n.dashboardFilters,hparams:e}}}),ye(fv,(n,t)=>{let e=new Map(n.dashboardFilters.metrics);return e.delete(t.name),{...n,dashboardFilters:{...n.dashboardFilters,metrics:e}}}),ye(EF,(n,{column:t,nextTo:e,side:i})=>{let{dashboardDisplayedHparamColumns:r}=n,o=r.length;if(void 0!==e&&void 0!==i){let l=r.findIndex(c=>c.name===e.name);-1!==l&&(o=i===mo.RIGHT?l+1:l)}let a={...t,enabled:!0},s=[...r];return s.splice(o,0,a),{...n,dashboardDisplayedHparamColumns:s}}),ye(TF,(n,{column:t})=>{let e=n.dashboardDisplayedHparamColumns.filter(({name:i})=>i!==t.name);return{...n,dashboardDisplayedHparamColumns:e}}),ye(DF,(n,{column:t})=>{let e=n.dashboardDisplayedHparamColumns.map(i=>i.name===t.name?{...i,enabled:!t.enabled}:i);return{...n,dashboardDisplayedHparamColumns:e}}),ye(IF,(n,{source:t,destination:e,side:i})=>{let{dashboardDisplayedHparamColumns:r}=n,o=kl.moveColumn(r,t,e,i);return{...n,dashboardDisplayedHparamColumns:o}}),ye(gv,n=>({...n,numDashboardHparamsToLoad:0})));function G6(n,t){return Dge(n,t)}var SS="hparams",hd=(()=>{return(n=hd||(hd={})).STATUS_UNKNOWN="STATUS_UNKNOWN",n.STATUS_SUCCESS="STATUS_SUCCESS",n.STATUS_FAILURE="STATUS_FAILURE",n.STATUS_RUNNING="STATUS_RUNNING",hd;var n})(),ES=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),q6="data/plugin/hparams";function kge(n){return function(n){return Boolean(n.domainDiscrete)}(n)?{type:io.DISCRETE,values:n.domainDiscrete}:function(n){return Boolean(n.domainInterval)}(n)?{...n.domainInterval,type:io.INTERVAL}:{values:[],type:io.DISCRETE}}var TS=(()=>{class n{constructor(e){this.http=e}getPrefix(e){return e.length>1?"compare":"experiment"}formatExperimentIds(e){return 1===e.length?e[0]:e.map((i,r)=>`${r}:${i}`).join(",")}fetchExperimentInfo(e,i){let r=this.formatExperimentIds(e),o={experimentName:r,hparamsLimit:i,includeMetrics:!1};return this.http.post(`/${this.getPrefix(e)}/${r}/${q6}/experiment`,o,{},"request").pipe(q(a=>a.hparamInfos.map(s=>{let l={...s,domain:kge(s)};return delete l.domainInterval,delete l.domainDiscrete,l})))}fetchSessionGroups(e,i){let r=this.formatExperimentIds(e),o=[];for(let s of i)o.push({hparam:s.name,includeInResult:!0});let a={experimentName:r,allowedStatuses:[hd.STATUS_FAILURE,hd.STATUS_RUNNING,hd.STATUS_SUCCESS,hd.STATUS_UNKNOWN],colParams:o,startIndex:0,sliceSize:1e6,includeMetrics:!1};return this.http.post(`/${this.getPrefix(e)}/${r}/${q6}/session_groups`,a,{},"request").pipe(q(s=>s.sessionGroups.map(l=>(l.sessions=l.sessions.map(c=>{if(e.length>1){let[,...d]=c.name.split(" "),[u,...p]=d.join(" ").split("/");c.name=[e[parseInt(u)],...p].join("/")}else c.name=[e[0],c.name].join("/");return c}),l))))}}return n.\u0275fac=function(e){return new(e||n)(O(Xs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Mc={};function X6(n){return n.domain.type===io.DISCRETE?{type:io.DISCRETE,includeUndefined:!0,possibleValues:n.domain.values,filterValues:n.domain.values}:{type:io.INTERVAL,includeUndefined:!0,minValue:n.domain.minValue,maxValue:n.domain.maxValue,filterLowerValue:n.domain.minValue,filterUpperValue:n.domain.maxValue}}NA(Mc,{getDashboardDefaultHparamFilters:()=>RF,getDashboardDisplayedHparamColumns:()=>md,getDashboardHparamFilterMap:()=>IS,getDashboardHparamSpecs:()=>DS,getDashboardMetricsFilterMap:()=>AS,getDashboardSessionGroups:()=>AF,getNumDashboardHparamsLoaded:()=>Fge,getNumDashboardHparamsToLoad:()=>PF});var vh=Mr(SS),DS=W(vh,n=>n.dashboardHparamSpecs),AF=W(vh,n=>n.dashboardSessionGroups),RF=W(DS,n=>new Map(n.map(e=>[e.name,X6(e)]))),md=W(vh,n=>{let t=new Set(n.dashboardHparamSpecs.map(e=>e.name));return n.dashboardDisplayedHparamColumns.filter(e=>t.has(e.name))}),IS=W(vh,n=>n.dashboardFilters.hparams),AS=W(vh,n=>n.dashboardFilters.metrics),PF=W(vh,n=>n.numDashboardHparamsToLoad),Fge=W(vh,n=>n.numDashboardHparamsLoaded),Y6=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.navigated$=this.actions$.pipe(Zn(Na),It(this.store.select(or)),Oe(([,o])=>Boolean(o)),q(([,o])=>o),ri((o,a)=>o.join("")===a.join(""))),this.loadHparamsOnReload$=this.actions$.pipe(Zn(ma,Ba,gv),It(this.store.select(or)),Oe(([,o])=>Boolean(o)),q(([,o])=>o)),this.loadHparamsData$=_r(()=>tn(this.navigated$,this.loadHparamsOnReload$).pipe(It(this.store.select(Ho),this.store.select(PF)),Oe(([,o])=>o?.routeKind===Cn.EXPERIMENT||o?.routeKind===Cn.COMPARE_EXPERIMENT),ic(10),Jn(([o,,a])=>this.loadHparamsForExperiments(o,a)),q(o=>hv(o))))}loadHparamsForExperiments(e,i){return this.dataSource.fetchExperimentInfo(e,i).pipe(Jn(r=>this.dataSource.fetchSessionGroups(e,r).pipe(co(o=>o instanceof ud&&400===o.status?$t([]):_l(()=>o)),q(o=>({hparamSpecs:r,sessionGroups:o})))))}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(TS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Q6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[TS],imports:[wr.forFeature(SS,G6),to.forFeature([Y6])]}),n})();function Nge(){return W(md,n=>({dashboardDisplayedHparamColumns:n}))}var RS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Q6,Ri.defineGlobalSetting(Nge)]}),n})(),PS=fe("[Runs] Fetch Runs Requested",{_as:"props",_p:void 0}),Wf=fe("[Runs] Fetch Runs Succeeded",{_as:"props",_p:void 0}),qf=fe("[Runs] Fetch Runs Failed",{_as:"props",_p:void 0}),kS=fe("[Runs] Run Selection Toggled",{_as:"props",_p:void 0}),OS=fe("[Runs] Single Run Selected",{_as:"props",_p:void 0}),FS=fe("[Runs] Run Page Selection Toggled",{_as:"props",_p:void 0}),NS=fe("[Runs] Run Selector Regex Filter Changed",{_as:"props",_p:void 0}),LS=fe("[Runs] Run Color Changed",{_as:"props",_p:void 0}),Xf=fe("[Runs] Run Group By Changed",{_as:"props",_p:void 0}),Z6=fe("[Runs] Runs Table Header Added",{_as:"props",_p:void 0}),BS=fe("[Runs] Runs Table Header Removed",{_as:"props",_p:void 0}),K6=fe("[Runs] Runs Table Header Order Changed",{_as:"props",_p:void 0}),VS=fe("[Runs] Runs Table Sorting Info Changed",{_as:"props",_p:void 0});function Lge(n,t){return`${t}/${n}`}var J6=(()=>{class n{constructor(e){this.http=e}fetchRuns(e){return this.http.get(`/experiment/${e}/data/runs`).pipe(q(i=>i.map(r=>({id:Lge(r,e),name:r,startTime:0}))))}}return n.\u0275fac=function(e){return new(e||n)(O(Xs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),$6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:ES,useClass:J6}]}),n})(),eW=W(Mr("alerts"),n=>n.latestAlert),zS="experiments",tW=W(Mr(zS),n=>n.data),US=W(tW,(n,t)=>{let{experimentId:e}=t;return n.experimentMap[e]||null}),yu=W(tW,or,(n,t)=>(t??[]).map(e=>n.experimentMap[e]).filter(Boolean).reduce((e,i)=>(e[i.id]=i.name,e),{}));function jS(n,t,e){return n<t?t:n>e?e:n}function Yf(n,t,e){let i=jS(n.start.step,t,e),r=n.end?jS(n.end.step,t,e):null;return{startStep:i,endStep:r,clipped:i!==n.start.step||r!==(n.end?.step??null)}}function GS(n,t){let e=t[n.id];return e&&e.visible&&!Boolean(e.aux)}function OF(n,t){return t?n:{start:n.start,end:null}}function FF(n,t,e){return OF(function(n,{minStep:t,maxStep:e}){return{start:{step:jS(n.start.step,t,e)},end:n.end?{step:jS(n.end.step,t,e)}:null}}(n,t),e)}var An=(()=>{return(n=An||(An={})).SCALARS="scalars",n.HISTOGRAMS="histograms",n.IMAGES="images",An;var n})(),Pi=(()=>{return(n=Pi||(Pi={})).STEP="step",n.RELATIVE="relative",n.WALL_TIME="walltime",Pi;var n})(),_v="timeseries";function aW(n){return n===An.SCALARS||n===An.HISTOGRAMS||n===An.IMAGES}var Uge=[An.IMAGES];function fs(n){return Uge.includes(n)}var jge=[An.HISTOGRAMS,An.IMAGES];function gs(n){return jge.includes(n)}function NF(n){return gs(n.plugin)}var wc=class{};function qS(n){return n.hasOwnProperty("error")}var LF="data/plugin/timeseries";function sW(n){let t=n.indexOf("/");return{run:n.substring(t+1),experimentId:n.substring(0,t)}}function cW(n,t){return`${t}/${n}`}function lW(n,t){let{runToSeries:e,run:i,...r}=n,o={...r};return e&&(o.runToSeries=BF(e,t)),i&&(o.runId=cW(i,t)),o}function BF(n,t){let e={};for(let i in n)n.hasOwnProperty(i)&&(e[cW(i,t)]=n[i]);return e}var dW=(()=>{class n{constructor(e,i){this.http=e,this.store=i}fetchTagMetadata(e){let i=e.map(o=>this.http.get(`/experiment/${o}/${LF}/tags`).pipe(q(s=>function(n,t){let e={};for(let i of Object.keys(n)){let r=i;if(fs(r)){let{tagRunSampledInfo:o,...a}=n[r],s={};for(let l in o)o.hasOwnProperty(l)&&(s[l]=BF(o[l],t));e[r]={...a,tagRunSampledInfo:s}}else{let{runTagInfo:o,...a}=n[r];e[r]={...a,runTagInfo:BF(o,t)}}}return e}(s,o)))),r=this.store.select(bu).pipe(Oe(Boolean),Lt(1),It(this.store.select(dS)),q(([,o])=>o));return Co(i).pipe(It(r),q(([o,a])=>{let s=function(n){let t={};for(let e of n)for(let i of Object.values(An))if(fs(i)){t[i]=t[i]||{tagDescriptions:{},tagRunSampledInfo:{}};let{tagDescriptions:r,tagRunSampledInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r};let a=t[i].tagRunSampledInfo;for(let s of Object.keys(o)){a[s]=a[s]||{};for(let l of Object.keys(o[s]))a[s][l]=o[s][l]}}else{t[i]=t[i]||{tagDescriptions:{},runTagInfo:{}};let{tagDescriptions:r,runTagInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r},t[i].runTagInfo={...t[i].runTagInfo,...o}}return t}(o);return a||(s[An.IMAGES]={tagDescriptions:{},tagRunSampledInfo:{}}),s}))}fetchTimeSeries(e){let i=e.map(r=>{if(gs(r.plugin)){let{runId:l,...c}=r,{run:d,experimentId:u}=sW(l),p={...c,run:d};return this.fetchTimeSeriesBackendRequest(p,u).pipe(q(({response:h,experimentId:m})=>lW(h,m)))}let{experimentIds:o,...a}=r;return Co(o.map(l=>this.fetchTimeSeriesBackendRequest(a,l))).pipe(q(l=>{let{runToSeries:c,error:d,...u}=l[0].response,p=u;for(let{response:h,experimentId:m}of l){let _=lW(h,m);if(p.error)continue;let{runToSeries:M,error:y}=_;if(y)p.error=y,p.runToSeries=void 0;else{p.runToSeries=p.runToSeries||{};for(let x of Object.keys(M))p.runToSeries[x]=M[x]}}return p}))});return Co(i)}fetchTimeSeriesBackendRequest(e,i){let r=new FormData;return r.append("requests",JSON.stringify([e])),this.http.post(`/experiment/${i}/${LF}/timeSeries`,r).pipe(q(o=>({response:o[0],experimentId:i})))}imageUrl(e){return`${LF}/imageData?imageId=${e}`}downloadUrl(e,i,r,o){let l,{run:a,experimentId:s}=sW(r);if(e!==An.SCALARS)throw new Error(`Not implemented: downloadUrl for ${e} is not implemented yet`);if(l="scalars/scalars",!s)throw new Error("experimentId is empty; it is required to form downloadUrl.");return`/experiment/${s}/data/plugin/scalars/scalars?${new URLSearchParams({tag:i,run:a,format:o})}`}}return n.\u0275fac=function(e){return new(e||n)(O(Xs),O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),bv="tb-saved-scalar-pins",XS=(()=>{class n{saveScalarPin(e){let i=this.getSavedScalarPins();i.includes(e)||i.push(e),window.localStorage.setItem(bv,JSON.stringify(i))}saveScalarPins(e){let i=this.getSavedScalarPins(),r=e.filter(o=>!i.includes(o));i.push(...r),window.localStorage.setItem(bv,JSON.stringify(i))}removeScalarPin(e){let i=this.getSavedScalarPins();window.localStorage.setItem(bv,JSON.stringify(i.filter(r=>r!==e)))}getSavedScalarPins(){let e=window.localStorage.getItem(bv);return e?JSON.parse(e):[]}removeAllScalarPins(){window.localStorage.setItem(bv,JSON.stringify([]))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Xge=new URLSearchParams(window.location.search),YS=(()=>{class n{getParams(){return Xge}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),vv="tb_feature_flag_storage_key",VF=(()=>{class n{constructor(e){this.queryParams=e}getFeatures(e,i){let r=e?this.getPartialFeaturesFromMediaQuery():{},o=function(n,t){return Object.entries(n).reduce((e,[i,r])=>{let o=function(n,t){let e=n.queryParamOverride;if(!e||!t.has(e))return null;let i=t.get(e);return null==i?null:n.parseValue(i)}(r,t);return null!==o&&(e[i]=o),e},{})}(i,this.queryParams.getParams());return{...r,...Object.fromEntries(Object.entries(this.getPersistentFeatureFlags()).filter(([s])=>i[s])),...o}}persistFeatureFlags(e){let r={...this.getPersistentFeatureFlags(),...e};window.localStorage.setItem(vv,JSON.stringify(r))}resetPersistedFeatureFlag(e){let i=this.getPersistentFeatureFlags();if(null!=i[e]){if(delete i[e],0===Object.keys(i).length)return void window.localStorage.removeItem(vv);window.localStorage.setItem(vv,JSON.stringify(i))}}resetAllPersistedFeatureFlags(){window.localStorage.removeItem(vv)}getPersistentFeatureFlags(){let e=window.localStorage.getItem(vv);return null==e?{}:JSON.parse(e)}getPartialFeaturesFromMediaQuery(){let e={};return window.matchMedia("(prefers-color-scheme: dark)").matches&&(e.defaultEnableDarkMode=!0),e}}return n.\u0275fac=function(e){return new(e||n)(O(YS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),QS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),hW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[VF,YS,{provide:QS,useClass:VF}]}),n})(),yv=fe("[FEATURE FLAG] Partial Feature Flags Loaded",{_as:"props",_p:void 0}),ZS=fe("[FEATURE FLAG] Enable Dark Mode Override Changed",{_as:"props",_p:void 0}),yh=fe("[FEATURE FLAG] Store the feature flags in persistent localStorage",{_as:"props",_p:void 0}),xu=fe("[FEATURE FLAG] Reset feature flag overrides",{_as:"props",_p:void 0}),Qf=fe("[FEATURE FLAG] Reset all feature flag overrides"),mW=fe("[FEATURE FLAG] Effects Init"),fW=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.tfFeatureFlags={ref:document.createElement("tf-feature-flags").tf_feature_flags},this.getFeatureFlags$=_r(()=>this.actions$.pipe(Zn(mW),Vi(this.store.select(M6),this.store.select(fh)),q(([,o,a])=>{let s=this.dataSource.getFeatures(o,a);return yv({features:s})}))),this.updatePolymerFeatureFlags$=_r(()=>this.actions$.pipe(Zn(yv),It(this.store.select(Qo),this.store.select(Hf)),Dt(([,o,a])=>{this.tfFeatureFlags.ref.setFeatureFlags(o,a)})),{dispatch:!1}),this.storeFeatureFlag$=_r(()=>this.actions$.pipe(Zn(yh),Dt(({flags:o})=>{this.dataSource.persistFeatureFlags(o)})),{dispatch:!1}),this.resetFeatureFlagOverrides$=_r(()=>this.actions$.pipe(Zn(xu),Dt(({flags:o})=>{o.forEach(a=>{this.dataSource.resetPersistedFeatureFlag(a)})})),{dispatch:!1}),this.resetAllFeatureFlagOverrides$=_r(()=>this.actions$.pipe(Zn(Qf),Dt(()=>{this.dataSource.resetAllPersistedFeatureFlags()})),{dispatch:!1})}ngrxOnInitEffects(){return mW()}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(QS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),bW=(()=>{class n{constructor(e){this.store=e}intercept(e,i){return this.store.pipe(un(Hf),zm(),Jn(r=>(e=e.clone({headers:e.headers.set("X-TensorBoard-Feature-Flags",JSON.stringify(r))}),i.handle(e))))}}return n.\u0275fac=function(e){return new(e||n)(O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function Cu(n){return"false"!==n}var n,HF={scalarsBatchSize:{defaultValue:void 0,queryParamOverride:"scalarsBatchSize",parseValue:parseInt},enabledExperimentalPlugins:{defaultValue:[],queryParamOverride:"experimentalPlugin",parseValue:function(n){return n?n.split(","):[]}},forceSvg:{defaultValue:!1,queryParamOverride:"forceSVG",parseValue:Cu},enableDarkModeOverride:{defaultValue:null,queryParamOverride:null},defaultEnableDarkMode:{defaultValue:!1,queryParamOverride:"darkMode",parseValue:Cu},isAutoDarkModeAllowed:{defaultValue:!0,queryParamOverride:null},inColab:{defaultValue:!1,queryParamOverride:"tensorboardColab",parseValue:Cu},metricsImageSupportEnabled:{defaultValue:!0,queryParamOverride:null},showFlags:{defaultValue:void 0,queryParamOverride:"showFlags",parseValue:n=>n},enableScalarColumnCustomization:{defaultValue:!1,queryParamOverride:"enableScalarColumnCustomization",parseValue:Cu},enableScalarColumnContextMenus:{defaultValue:!1,queryParamOverride:"enableScalarColumnContextMenus",parseValue:Cu},enableSuggestedCards:{defaultValue:!1,queryParamOverride:"enableSuggestedCards",parseValue:Cu},enableGlobalPins:{defaultValue:!0,queryParamOverride:"enableGlobalPins",parseValue:Cu},enableColorByExperiment:{defaultValue:!1,queryParamOverride:"enableColorByExperiment",parseValue:Cu}},zF={isFeatureFlagsLoaded:!1,defaultFlags:(n=HF,Object.entries(n).reduce((t,[e,i])=>(t[e]=i.defaultValue,t),{})),metadata:HF,flagOverrides:{}},UF=new te("[Feature Flag] Store Config");function yW(){return{initialState:zF}}var e0e=gr(zF,ye(yv,(n,{features:t})=>({...n,isFeatureFlagsLoaded:!0,flagOverrides:{...n.flagOverrides,...t}})),ye(ZS,(n,{enableDarkMode:t})=>({...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:t}})),ye(yh,(n,t)=>({...n,flagOverrides:{...n.flagOverrides,...t.flags}})),ye(xu,(n,t)=>{if(!t||!t.flags||!t.flags.length)return n;let e={...n.flagOverrides};return t.flags.forEach(i=>{delete e[i]}),{...n,flagOverrides:e}}),ye(Qf,n=>({...n,flagOverrides:{}})),ye(hs,(n,{partialSettings:t})=>{if(!t.themeOverride)return n;let e;switch(t.themeOverride){case La.BROWSER_DEFAULT:e=null;break;case La.DARK:e=!0;break;case La.LIGHT:e=!1}return{...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:e}}}));function xW(n,t){return e0e(n,t)}function t0e(){return W(cS,n=>null===n?{themeOverride:La.BROWSER_DEFAULT}:{themeOverride:n?La.DARK:La.LIGHT})}var Mu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:UF,useFactory:yW},{provide:bF,useClass:bW,multi:!0}],imports:[hW,wr.forFeature(lS,xW,UF),to.forFeature([fW]),Ri.defineGlobalSetting(t0e)]}),n})(),KS=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:wc,useClass:dW}],imports:[Mu,zf]}),n})(),CW=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[XS]}),n})(),oo=(()=>(function(n){n.DEFAULT="default",n.ALPHABETICAL="alphabetical",n.ASCENDING="ascending",n.DESCENDING="descending",n.NEAREST="nearest",n.NEAREST_Y="nearest_Y"}(oo||(oo={})),oo))(),JS="metrics",Va=(()=>(function(n){n[n.NONE=0]="NONE",n[n.OVERRIDE_AS_ENABLED=1]="OVERRIDE_AS_ENABLED",n[n.OVERRIDE_AS_DISABLED=2]="OVERRIDE_AS_DISABLED"}(Va||(Va={})),Va))(),$S={cardMinWidth:null,tooltipSort:oo.ALPHABETICAL,ignoreOutliers:!0,xAxisType:Pi.STEP,hideEmptyCards:!0,scalarSmoothing:.6,scalarPartitionNonMonotonicX:!1,imageBrightnessInMilli:1e3,imageContrastInMilli:1e3,imageShowActualSize:!1,histogramMode:Sr.OFFSET,savingPinsEnabled:!0},n0e=.1;function fd(n,t,e,i){return n[t].hasOwnProperty(e)?fs(t)?n[t][e].hasOwnProperty(i)?n[t][e][i]:null:n[t][e]:null}function e1(n,t,e,i){if(fs(t)){let a={...n[t]},s=function(n,t,e){let r=n.hasOwnProperty(t)?{...n[t]}:{},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}(a,e,i);return a[e]=s,a}let r={...n[t]},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}function jF(n){return JSON.stringify(n)}function t1(n,t,e){let i={...e};for(let r of t)i[r]=n;return i}function Zf(n,t,e,i){if(fs(t)){let o=n[t].tagRunSampledInfo;return o.hasOwnProperty(e)?Object.keys(o[e]).filter(s=>i<o[e][s].maxSamplesPerStep):[]}let r=n[t].tagToRuns;return r.hasOwnProperty(e)?r[e]:[]}function o0e(n,t){return n.plugin===t.plugin&&n.tag===t.tag&&n.sample===t.sample&&(n.runId===t.runId||!n.runId&&!t.runId)}function GF(n,t,e,i,r,o,a,s){let l=new Set(n),c=[];for(let u of n)for(let p of t)if(o0e(e[p],u)){c.push(p),l.delete(u);break}if(!c.length)return{unresolvedImportedPinnedCards:n,cardMetadataMap:e,cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:a,cardStateMap:s};let d={cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:a,cardMetadataMap:e,cardStateMap:s};for(let u of c)d=WF(u,d.cardToPinnedCopy,d.cardToPinnedCopyCache,d.pinnedCardToOriginal,d.cardStepIndex,d.cardMetadataMap,s);return{...d,unresolvedImportedPinnedCards:[...l]}}function WF(n,t,e,i,r,o,a){if(t.has(n))return{cardToPinnedCopy:t,cardToPinnedCopyCache:e,pinnedCardToOriginal:i,cardStepIndex:r,cardMetadataMap:o,cardStateMap:a};let s=new Map(t),l=new Map(e),c=new Map(i),d={...r},u={...o},p={...a},h=function(n){return JSON.stringify({baseCardId:n})}(n);s.set(n,h),l.set(n,h),c.set(h,n),r.hasOwnProperty(n)&&(d[h]=r[n]);let m=o[n];if(!m)throw new Error("Cannot pin a card without metadata");return u[h]=m,p[n]&&(p[h]=p[n]),{cardToPinnedCopy:s,cardToPinnedCopyCache:l,pinnedCardToOriginal:c,cardStepIndex:d,cardMetadataMap:u,cardStateMap:p}}var a0e={MAX_PIN_COUNT:10};function n1(n){return n.pinnedCardToOriginal.size+n.unresolvedImportedPinnedCards.length<a0e.MAX_PIN_COUNT}function qF(n,t,e,i){let r={...n};return Object.keys(n).forEach(o=>{if(!o.includes('"plugin":"images"'))return;let a=XF(o,t,e),s=null;if(null===i.end)s=function(n,t){let e=t.indexOf(n);if(-1!==e)return{index:e,isClosest:!1};for(let i=0;i<t.length-1;i++){let r=t[i],o=t[i+1],a=(o-r)*n0e;if(n<r)return null;if(!(n>o)){if(n-r<=a)return{index:i,isClosest:!0};if(o-n<=a)return{index:i+1,isClosest:!0}}}return null}(i.start.step,a);else{let c=a[n[o].index],d=function(n,t){if(!n)return[];if(null===n.end)return-1!==t.indexOf(n.start.step)?[n.start.step]:[];let e=[];for(let i of t)i>=n.start.step&&i<=n.end.step&&e.push(i);return e}(i,a);s=function(n,t,e){if(0===n.length)return null;let i=n[0],r=n[n.length-1];return e>r?{index:t.indexOf(r),isClosest:!1}:e<i?{index:t.indexOf(i),isClosest:!1}:null}(d,a,c)}null!==s&&(r[o]=s)}),r}function XF(n,t,e){if(!t.hasOwnProperty(n))return[];let{plugin:i,tag:r,sample:o,runId:a}=t[n];if(null===a)return[];let s=fd(e,i,r,o);return null!==s&&s.runToSeries.hasOwnProperty(a)?s.runToSeries[a].map(l=>l.step):[]}function YF(n){let{dataMinMax:t,userViewBox:e}=n,i=e?.x;if(!i)return t;let r=i[0]<i[1]?i[0]:i[1],o=r===i[0]?i[1]:i[0];return{minStep:Math.ceil(r),maxStep:Math.floor(o)}}function i1(n,t){switch(n){case Va.OVERRIDE_AS_ENABLED:return!0;case Va.OVERRIDE_AS_DISABLED:return!1;default:return t}}function r1(n,t,e,i){return e?t:i1(n[i]?.rangeSelectionOverride,t)}function _s(n){let t=new Map;return(...e)=>{let i=JSON.stringify(e);if(t.has(i))return t.get(i);{let r=n(...e);return t.set(i,r),r}}}var Hi=Mr(JS),xv=W(Hi,n=>n.tagMetadataLoadState),DW=W(Hi,n=>n.tagMetadata),u0e=W(Hi,n=>n.cardList),gd=W(Hi,(n,t)=>{if(!n.cardMetadataMap.hasOwnProperty(t))return Re.NOT_LOADED;let{plugin:e,tag:i,runId:r,sample:o}=n.cardMetadataMap[t],a=fd(n.timeSeriesData,e,i,o);if(!a)return Re.NOT_LOADED;let s=a.runToLoadState;if(r)return s.hasOwnProperty(r)?s[r]:Re.NOT_LOADED;let l=Zf(n.tagMetadata,e,i,o);if(!l.length)throw new Error("Cannot load a card whose tag has no runs");return l.every(c=>s[c]===Re.LOADED)?Re.LOADED:l.some(c=>s[c]===Re.LOADING)?Re.LOADING:Re.NOT_LOADED}),p0e=_s(n=>W(t=>t,t=>{let{plugin:e,tag:i,sample:r}=n,o=fd(t.timeSeriesData,e,i,r);return o?o.runToSeries:null})),wu=W(Hi,(n,t)=>n.cardMetadataMap.hasOwnProperty(t)?p0e(n.cardMetadataMap[t])(n):null),QF=W(Hi,n=>n.cardMetadataMap),Ks=W(QF,(n,t)=>n.hasOwnProperty(t)?n[t]:null),Js=W(Hi,n=>n.cardStateMap),h0e=W(Hi,n=>n.visibleCardMap),IW=W(h0e,n=>new Set(n.values())),o1=W(u0e,QF,(n,t)=>n.filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),ZF=W(Hi,(n,t)=>n.cardStepIndex.hasOwnProperty(t)?n.cardStepIndex[t]:null),AW=W(Hi,(n,t)=>XF(t,n.cardMetadataMap,n.timeSeriesData)),RW=W(Hi,n=>n.cardToPinnedCopy),m0e=W(Hi,n=>n.pinnedCardToOriginal),Kf=W(RW,QF,(n,t)=>[...n.values()].filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),Su=W(RW,m0e,(n,t,e)=>n.has(e)||t.has(e)),PW=W(Hi,n=>n.unresolvedImportedPinnedCards),kW=W(Hi,n=>n1(n)),OW=W(Hi,n=>n.lastPinnedCardTime),$s=W(Hi,n=>({...n.settings,...n.settingOverrides})),FW=W(Hi,n=>n.settingOverrides),Jf=W($s,n=>n.cardMinWidth),xh=W($s,n=>n.tooltipSort),Ch=W($s,n=>n.ignoreOutliers),Ol=W($s,n=>n.xAxisType),a1=W($s,n=>n.histogramMode),NW=W($s,n=>n.hideEmptyCards),_d=W($s,n=>n.scalarSmoothing),s1=W($s,n=>n.scalarPartitionNonMonotonicX),l1=W($s,n=>n.imageBrightnessInMilli),c1=W($s,n=>n.imageContrastInMilli),d1=W($s,n=>n.imageShowActualSize),bd=W($s,n=>n.savingPinsEnabled),Fl=W(Hi,n=>n.tagFilter),u1=W(Hi,(n,t)=>Boolean(n.tagGroupExpanded.get(t))),Eu=W(Hi,n=>n.linkedTimeEnabled),Cv=W(Hi,n=>n.stepSelectorEnabled),Tu=W(Hi,n=>n.rangeSelectionEnabled),KF=W(Hi,n=>{let{min:t,max:e}=n.stepMinMax;return{min:t===1/0?0:t,max:e===-1/0?1e3:e}}),JF=W(Hi,KF,(n,t)=>n.linkedTimeSelection?n.linkedTimeSelection:{start:{step:t.max},end:null}),Du=W(Hi,JF,(n,t)=>n.linkedTimeEnabled?t:null),Sc=W(Hi,n=>n.filteredPluginTypes),p1=W(Hi,n=>n.isSettingsPaneOpen),h1=W(Hi,n=>n.isSlideoutMenuOpen),LW=W(Hi,n=>n.tableEditorSelectedTab),m1=_s(n=>W(Js,Tu,Eu,(t,e,i)=>r1(t,e,i,n))),BW=W(Js,(n,t)=>{if(n[t])return YF(n[t])}),VW=W(Js,(n,t)=>n[t]?.dataMinMax),$F=W(Js,(n,t)=>n[t]?.userViewBox??null),HW=W(Js,Cv,Tu,Eu,Du,(n,t,e,i,r,o)=>{let a=n[o];if(!a)return;let s=YF(a);if(!s)return;if(i&&r)return FF(r,s,e);if(!i1(a.stepSelectionOverride,t))return;let l=i1(a.rangeSelectionOverride,e),c=a.timeSelection;return c||(c={start:{step:s.minStep},end:{step:s.maxStep}}),l?c.end||(c={start:{step:s.minStep},end:c.start}):c={start:c.end??c.start,end:null},FF(c,s,l)}),Mv=W(Hi,n=>n.singleSelectionHeaders),wv=W(Hi,n=>n.rangeSelectionHeaders),e2=_s(n=>W(m1(n),Mv,wv,(t,e,i)=>t?i:e)),zW=_s(n=>W(e2(n),md,(t,e)=>kl.groupColumns([...t,...e]))),jW=Mr("notification"),Yn=(W(jW,n=>n.notifications),W(jW,n=>n.lastReadTimestampInMs??-1),(()=>(function(n){n[n.RUN=0]="RUN",n[n.EXPERIMENT=1]="EXPERIMENT",n[n.REGEX=2]="REGEX",n[n.REGEX_BY_EXP=3]="REGEX_BY_EXP"}(Yn||(Yn={})),Yn))());function Ev(n,t,e,i){let s,r={},o=[],a={matches:r,nonMatches:o};switch(n.key){case Yn.RUN:for(let l of t)r[l.id]=[l];break;case Yn.EXPERIMENT:for(let l of t){let c=e[l.id],d=r[c]||[];d.push(l),r[c]=d}break;case Yn.REGEX:if(!n.regexString)break;try{s=new RegExp(n.regexString)}catch{break}for(let l of t){let c=l.name.match(s);if(c){let u=c.length>1?JSON.stringify(c.slice(1)):"pseudo_group",p=r[u]||[];p.push(l),r[u]=p}else o.push(l)}break;case Yn.REGEX_BY_EXP:if(!n.regexString||!i||0===Object.keys(i).length)break;try{s=new RegExp(n.regexString)}catch{break}for(let l of t){let d=i[e[l.id]].match(s);if(d){let p=d.length>1?JSON.stringify(d.slice(1)):"pseudo_group",h=r[p]||[];h.push(l),r[p]=h}else o.push(l)}}return a}function g1(n,t){switch(n){case Yn.REGEX:case Yn.REGEX_BY_EXP:return{key:n,regexString:t??""};default:return{key:n}}}var GW=Mr("runs"),fa=W(GW,n=>n.data),WW=W(fa,n=>n.runIdToExpId),_1=W(fa,(n,t)=>n.runIdToExpId[t.runId]??null),b1=W(fa,(n,t)=>n.runMetadata[t.runId]??null),Iu=W(fa,(n,t)=>(n.runIds[t.experimentId]||[]).filter(i=>Boolean(n.runMetadata[i])).map(i=>n.runMetadata[i])),qW=W(AF,or,fa,(n,t,e)=>{if(!t)return{};let i=[];for(let s of t)i.push(...e.runIds[s]||[]);let r={};for(let s of n){let l=Object.entries(s.hparams).map(c=>{let[d,u]=c;return{name:d,value:u}});for(let c of s.sessions)r[c.name]=l}let o=Object.keys(r).sort((s,l)=>l.length-s.length),a={};for(let s of i)for(let l of o)if(s.startsWith(l)){a[s]={hparams:r[l],metrics:[]};break}return a}),XW=W(qW,n=>{let t={};for(let[e,{hparams:i}]of Object.entries(n))t[e]=new Map(i.map(({name:r,value:o})=>[r,o]));return t}),v1=W(fa,or,qW,(n,t,e)=>t?t.map(i=>(n.runIds[i]||[]).filter(r=>Boolean(n.runMetadata[r])).map(r=>{let o={...n.runMetadata[r],experimentId:i};return o.hparams=e[r]?.hparams??null,o.metrics=e[r]?.metrics??null,o})).flat():[]),YW=W(fa,(n,t)=>n.runIds[t.experimentId]??[]),QW=W(fa,n=>new Map(Object.entries(n.runMetadata))),Tv=W(fa,(n,t)=>n.runsLoadState[t.experimentId]||{lastLoadedTimeInMs:null,state:Re.NOT_LOADED}),t2=W(fa,n=>null!==n.userSetGroupByKey?g1(n.userSetGroupByKey,n.colorGroupRegexString):null),Dv=W(t2,fa,(n,t)=>n??t.initialGroupBy),Au=W(fa,n=>n.regexFilter),n2=W(GW,n=>n.ui),ZW=W(n2,n=>n.selectionState),KW=W(fa,n=>n.runColorOverrideForGroupBy),JW=W(fa,n=>n.defaultRunColorIdForGroupBy),y1=W(fa,n=>n.colorGroupRegexString),f0e=W(n2,n=>n.runsTableHeaders),$W=W(n2,n=>n.sortingInfo),e7=W(f0e,md,(n,t)=>kl.groupColumns([...n,...t])),x1=fe("[Settings] Reload Enable Toggled"),C1=fe("[Settings] Reload Period Change",{_as:"props",_p:void 0}),M1=fe("[Settings] Page Size Change",{_as:"props",_p:void 0}),Ha={};NA(Ha,{getColorPalette:()=>g0e,getPageSize:()=>Mh,getReloadEnabled:()=>Av,getReloadPeriodInMs:()=>Rv,getSettingsLoadState:()=>i2});var w1="settings",i7={state:Re.LOADED,lastLoadedTimeInMs:Date.now(),settings:{reloadPeriodInMs:3e4,reloadEnabled:!1,pageSize:12,colorPalette:{id:"default",name:"Defalt",colors:[{name:"Slate",lightHex:"#425066",darkHex:"#8e98a3"},{name:"Cyan",lightHex:"#12b5cb",darkHex:"#12b5cb"},{name:"Pink",lightHex:"#e52592",darkHex:"#e52592"},{name:"Yellow",lightHex:"#f9ab00",darkHex:"#f9ab00"},{name:"Purple",lightHex:"#9334e6",darkHex:"#9334e6"},{name:"Light Green",lightHex:"#7cb342",darkHex:"#7cb342"},{name:"Orange",lightHex:"#e8710a",darkHex:"#e8710a"}],inactive:{name:"Gray",lightHex:"#e0e0e0",darkHex:"#3b3b3b"}}}},Iv=Mr(w1),i2=W(Iv,n=>n.state),Av=W(Iv,n=>n.settings.reloadEnabled),Rv=W(Iv,n=>n.settings.reloadPeriodInMs),Mh=W(Iv,n=>n.settings.pageSize),g0e=W(Iv,n=>n.settings.colorPalette);function S1(n,t,e){if(!t)return!0;let i;try{i=new RegExp(t,"i")}catch{return!1}let r=[n.runName];return e&&r.push(n.experimentAlias.aliasText,`${n.experimentAlias.aliasText}/${n.runName}`),r.some(o=>i.test(o))}var _0e=W(or,ZW,WW,(n,t,e)=>{if(!n)return new Map;let i=new Map;for(let[r,o]of t.entries()){let a=e[r];a&&n.indexOf(a)>=0&&i.set(r,o)}return i}),b0e=W(qs,v1,(n,t)=>{let e=new Map;for(let i of t)e.set(i.id,{runName:i.name,experimentAlias:n[i.experimentId]});return e}),Ru=W(or,_0e,Au,b0e,Ws,(n,t,e,i,r)=>{if(!n)return null;let o=r===Cn.COMPARE_EXPERIMENT,a=new Map;for(let[s,l]of t.entries()){let c=i.get(s);a.set(s,S1(c,e,o)&&l)}return a}),Pu=W(Ha.getColorPalette,JW,KW,Pl,(n,t,e,i)=>{let r={};return t.forEach((o,a)=>{let s=i?n.inactive.darkHex:n.inactive.lightHex;if(e.has(a))s=e.get(a);else if(o>=0){let l=n.colors[o%n.colors.length];s=i?l.darkHex:l.lightHex}r[a]=s}),r}),r7=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.runsDataSource=r,this.experimentsWithStaleRunsOnRouteChange$=this.actions$.pipe(Zn(Na),It(this.store.select(Ho)),ri(([,o],[,a])=>Vo(o,a)),It(this.store.select(or)),Oe(([,o])=>!!o),q(([,o])=>o),xn(o=>this.getExperimentsWithLoadState(o,a=>a===Re.FAILED||a===Re.NOT_LOADED).pipe(q(a=>({experimentIds:o,experimentIdsToBeFetched:a}))))),this.experimentsWithStaleRunsOnReload$=this.actions$.pipe(Zn(ma,Ba),It(this.store.select(or)),Oe(([,o])=>!!o),q(([,o])=>o),xn(o=>this.getExperimentsWithLoadState(o,a=>a!==Re.LOADING).pipe(q(a=>({experimentIds:o,experimentIdsToBeFetched:a}))))),this.loadRunsOnNavigationOrReload$=_r(()=>tn(this.experimentsWithStaleRunsOnRouteChange$,this.experimentsWithStaleRunsOnReload$).pipe(It(this.store.select(Ho)),Oe(([,o])=>null!==o&&o.routeKind!==Cn.CARD),xn(([{experimentIds:o,experimentIdsToBeFetched:a}])=>this.fetchAllRunsList(o,a))),{dispatch:!1}),this.removeHparamFilterWhenColumnIsRemoved$=_r(()=>this.actions$.pipe(Zn(BS),Dt(({header:o})=>{o.type!==gt.HPARAM?o.type===gt.METRIC&&this.store.dispatch(fv({name:o.name})):this.store.dispatch(mv({name:o.name}))})),{dispatch:!1})}getRunsListLoadState(e){return this.store.select(Tv,{experimentId:e}).pipe(Lt(1))}getExperimentsWithLoadState(e,i){return Co(e.map(r=>this.getRunsListLoadState(r))).pipe(q(r=>e.filter((o,a)=>i(r[a].state))))}fetchAllRunsList(e,i){return $t({experimentIds:e,experimentIdsToBeFetched:i}).pipe(Dt(()=>{this.store.dispatch(PS({experimentIds:e,requestedExperimentIds:i}))}),xn(()=>{let r=new Set(i);return Co(e.map(a=>r.has(a)?this.fetchRunsForExperiment(a):this.maybeWaitForRunsAndGetRuns(a)))}),q(r=>{let o={},a=[];for(let s of r)a.push(...s.runs),s.fromRemote&&(o[s.experimentId]={runs:s.runs});return{newRuns:o,runsForAllExperiments:a}}),It(this.store.select(yu)),Dt(([r,o])=>{let{newRuns:a,runsForAllExperiments:s}=r;this.store.dispatch(Wf({experimentIds:e,newRuns:a,runsForAllExperiments:s,expNameByExpId:o}))}),co(r=>(this.store.dispatch(qf({experimentIds:e,requestedExperimentIds:i})),$t(null))),q(()=>null))}maybeWaitForRunsAndGetRuns(e){return this.store.select(Tv,{experimentId:e}).pipe(Oe(i=>i.state!==Re.LOADING),Lt(1),xn(i=>i.state===Re.FAILED?_l(new Error("Pending request failed")):$t(i)),It(this.store.select(Iu,{experimentId:e})),q(([,i])=>({fromRemote:!1,experimentId:e,runs:i})))}fetchRunsForExperiment(e){return this.runsDataSource.fetchRuns(e).pipe(q(i=>({fromRemote:!0,experimentId:e,runs:i})))}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(ES))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),{initialState:v0e,reducers:y0e}=_h({runColorOverrideForGroupBy:new Map,defaultRunColorIdForGroupBy:new Map,groupKeyToColorId:new Map,initialGroupBy:{key:Yn.RUN},userSetGroupByKey:null,colorGroupRegexString:"",regexFilter:""},{runIds:{},runIdToExpId:{},runMetadata:{},runsLoadState:{}},(n,t,e)=>Vo(t,e)?n:{...n,initialGroupBy:{key:e.routeKind===Cn.COMPARE_EXPERIMENT?Yn.EXPERIMENT:Yn.RUN}}),x0e=gr(v0e,ye(fu,(n,{routeKind:t,partialState:e})=>{if(t!==Cn.COMPARE_EXPERIMENT&&t!==Cn.EXPERIMENT)return n;let r=e.runs.groupBy,o=e.runs.regexFilter??"";if(!r&&!o)return n;let{colorGroupRegexString:a,userSetGroupByKey:s}=n;return r&&(a=r.key===Yn.REGEX||r.key===Yn.REGEX_BY_EXP?r.regexString:n.colorGroupRegexString,s=r.key??null),{...n,colorGroupRegexString:a,regexFilter:o,userSetGroupByKey:s}}),ye(PS,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Re.LOADING}:{lastLoadedTimeInMs:null,state:Re.LOADING};return{...n,runsLoadState:e}}),ye(Wf,(n,t)=>{let e={...n.runIds},i={...n.runMetadata},r={...n.runIdToExpId},o={...n.runsLoadState};for(let a of Object.keys(t.newRuns)){let{runs:s}=t.newRuns[a];e[a]=s.map(({id:l})=>l),o[a]={...o[a],lastLoadedTimeInMs:Date.now(),state:Re.LOADED};for(let l of s)i[l.id]={...l,hparams:null,metrics:null},r[l.id]=a}return{...n,runIds:e,runIdToExpId:r,runMetadata:i,runsLoadState:o}}),ye(qf,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Re.FAILED}:{lastLoadedTimeInMs:null,state:Re.FAILED};return{...n,runsLoadState:e}}),ye(Wf,(n,{runsForAllExperiments:t,expNameByExpId:e})=>{let i=new Map(n.groupKeyToColorId),r=new Map(n.defaultRunColorIdForGroupBy),o=n.initialGroupBy;null!==n.userSetGroupByKey&&(o=g1(n.userSetGroupByKey,n.colorGroupRegexString));let a=Ev(o,t,n.runIdToExpId,e);Object.entries(a.matches).forEach(([s,l])=>{let c=i.get(s)??i.size;i.set(s,c);for(let d of l)r.set(d.id,c)});for(let s of a.nonMatches)r.set(s.id,-1);return{...n,defaultRunColorIdForGroupBy:r,groupKeyToColorId:i}}),ye(Xf,(n,{experimentIds:t,groupBy:e,expNameByExpId:i})=>{let r=new Map,o=new Map(n.defaultRunColorIdForGroupBy),s=Ev(e,t.flatMap(c=>n.runIds[c]).map(c=>n.runMetadata[c]),n.runIdToExpId,i);Object.entries(s.matches).forEach(([c,d])=>{let u=r.get(c)??r.size;r.set(c,u);for(let p of d)o.set(p.id,u)});for(let c of s.nonMatches)o.set(c.id,-1);let l=e.key===Yn.REGEX||e.key===Yn.REGEX_BY_EXP?e.regexString:n.colorGroupRegexString;return{...n,colorGroupRegexString:l,userSetGroupByKey:e.key,defaultRunColorIdForGroupBy:o,groupKeyToColorId:r,runColorOverrideForGroupBy:new Map}}),ye(LS,(n,{runId:t,newColor:e})=>{let i=new Map(n.runColorOverrideForGroupBy);return i.set(t,e),{...n,runColorOverrideForGroupBy:i}}),ye(NS,(n,t)=>({...n,regexFilter:t.regexString}))),C0e=bh(x0e,y0e),{initialState:M0e,reducers:w0e}=_h({selectionState:new Map,runsTableHeaders:[{type:gt.RUN,name:"run",displayName:"Run",enabled:!0,sortable:!0,removable:!1,movable:!1,filterable:!1}],sortingInfo:{name:"run",order:Lr.ASCENDING}},{},(n,t,e)=>{if(!Vo(t,e)){if(e.routeKind===Cn.COMPARE_EXPERIMENT&&!n.runsTableHeaders.find(i=>"experimentAlias"===i.name)){let i=[...n.runsTableHeaders,{type:gt.CUSTOM,name:"experimentAlias",displayName:"Experiment",enabled:!0,movable:!1,sortable:!0}];return{...n,runsTableHeaders:i}}if(t?.routeKind===Cn.COMPARE_EXPERIMENT&&e.routeKind!==Cn.COMPARE_EXPERIMENT){let i=n.runsTableHeaders.filter(r=>"experimentAlias"!==r.name);return{...n,runsTableHeaders:i}}}return n}),S0e=gr(M0e,ye(Wf,(n,t)=>{let e=new Map(n.selectionState),i=t.runsForAllExperiments.length<=500;for(let r of t.runsForAllExperiments)e.has(r.id)||e.set(r.id,i);return{...n,selectionState:e}}),ye(kS,(n,{runId:t})=>{let e=new Map(n.selectionState);return e.set(t,!Boolean(e.get(t))),{...n,selectionState:e}}),ye(OS,(n,{runId:t})=>{let e=new Map;for(let i of n.selectionState.keys())e.set(i,t===i);return{...n,selectionState:e}}),ye(FS,(n,{runIds:t})=>{let e=new Map(n.selectionState),i=!t.every(r=>Boolean(e.get(r)));for(let r of t)e.set(r,i);return{...n,selectionState:e}}),ye(Z6,(n,{header:t,index:e})=>{let i=[...n.runsTableHeaders];return void 0===e?i.push(t):i.splice(e,0,t),{...n,runsTableHeaders:i}}),ye(BS,(n,{header:t})=>{let e=n.runsTableHeaders.filter(({name:i})=>i!==t.name);return{...n,runsTableHeaders:e}}),ye(K6,(n,{newHeaderOrder:t})=>({...n,runsTableHeaders:t})),ye(VS,(n,{sortingInfo:t})=>({...n,sortingInfo:t}))),E0e=bh(S0e,w0e);function o7(n,t){return ch({data:C0e,ui:E0e})(n,t)}function T0e(){return[{actionCreator:qf,alertFromAction:()=>({localizedMessage:"Failed to fetch runs"})}]}var E1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[wr.forFeature("runs",o7),to.forFeature([r7]),$6,Cc.registerAlertActions(T0e),RS]}),n})(),vd=(()=>(function(n){n.RUNS_CHANGED="experimental.RunsChanged",n.GET_RUNS="experimental.GetRuns",n.GET_URL_DATA="experimental.GetURLPluginData",n.DATA_RELOADED="experimental.DataReloaded"}(vd||(vd={})),vd))(),s7=new WeakMap,$f=new Set,r2=new Map,D1=new Map;function l7(n,t){return e=>{let i=D1.get(t),r=s7.get(i)||null;return n(r,e)}}window.addEventListener("message",n=>{if("experimental.bootstrap"!==n.data)return;let t=n.ports[0];if(!t)return;let e=n.source?n.source.frameElement:null;!e||function(n,t){let e=new class{constructor(t){this.port=t,this.id=0,this.responseWaits=new Map,this.listeners=new Map,this.port.addEventListener("message",e=>this.onMessage(e))}listen(t,e){this.listeners.set(t,e)}unlisten(t){this.listeners.delete(t)}async onMessage(t){let e=JSON.parse(t.data),i=e.type,r=e.id,o=e.payload,a=e.error;if(e.isReply){if(!this.responseWaits.has(r))return;let{resolve:u,reject:p}=this.responseWaits.get(r);return this.responseWaits.delete(r),void(a?p(new Error(a)):u(o))}let l=null,c=null;if(this.listeners.has(i)){let u=this.listeners.get(i);try{l=await u(o)}catch(p){c=p}}this.postMessage({type:i,id:r,payload:l,error:c,isReply:!0})}postMessage(t){this.port.postMessage(JSON.stringify(t))}sendMessage(t,e){let i=this.id++;return this.postMessage({type:t,id:i,payload:e,error:null,isReply:!1}),new Promise((o,a)=>{this.responseWaits.set(i,{resolve:o,reject:a})})}}(n);$f.add(e),D1.set(e,t),n.start();for(let[i,r]of r2){let o=l7(r,e);e.listen(i,o)}}(t,e)});var a2,eg=(()=>{class n{broadcast(e,i){return function(n,t){for(let i of $f)D1.get(i).isConnected||($f.delete(i),D1.delete(i));let e=[...$f].map(i=>i.sendMessage(n,t));return Promise.all(e)}(e,i)}listen(e,i){!function(n,t){r2.set(n,t);for(let e of $f){let i=l7(t,e);e.listen(n,i)}}(e,i)}unlisten(e){!function(n){r2.delete(n);for(let t of $f)t.unlisten(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),I1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){this.ipc.listen(vd.GET_URL_DATA,e=>{if(!e)return;let i=`p.${e.pluginName}.`,r={},o=window.tensorboard.tf_storage.getUrlHashDict();for(let a in o)a.startsWith(i)&&(r[a.substring(i.length)]=o[a]);return r}),this.store.select(jf).pipe(Oe(e=>null!==e),ri()).subscribe(()=>{this.ipc.broadcast(vd.DATA_RELOADED,void 0)})}}return n.\u0275fac=function(e){return new(e||n)(O(eg),O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),A1=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=this.store.select(or).pipe(xn(i=>i?In(i.map(o=>this.store.select(Iu,{experimentId:o}))).pipe(q(o=>o.flat()),ri((o,a)=>o.length===a.length&&o.every((s,l)=>a[l].id===s.id)),q(o=>o.map(({name:a})=>a))):$t([])));e.subscribe(i=>{this.ipc.broadcast(vd.RUNS_CHANGED,i)}),this.ipc.listen(vd.GET_RUNS,()=>e.pipe(Lt(1)).toPromise())}}return n.\u0275fac=function(e){return new(e||n)(O(eg),O(Ie))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),R1=(()=>{class n{constructor(e,i){i.init(),e.init()}registerPluginIframe(e,i){!function(n,t){s7.set(n,{pluginName:t})}(e,i)}}return n.\u0275fac=function(e){return new(e||n)(O(A1),O(I1))},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[eg,I1,A1],imports:[Nf,Qs,E1]}),n})(),tg=fe("[Alert] Alert Reported",{_as:"props",_p:void 0}),u7=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.alertActionModule=r,this.reportRegisteredActionAlerts$=_r(()=>this.actions$.pipe(Dt(o=>{let a=this.alertActionModule.getAlertFromAction(o);a&&this.store.dispatch(tg(a))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(Cc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),L0e=gr({latestAlert:null},ye(tg,(n,{localizedMessage:t,followupAction:e})=>{let i={localizedMessage:t,created:Date.now()};return e&&(i.followupAction=e),{...n,latestAlert:i}}));function p7(n,t){return L0e(n,t)}try{a2=typeof Intl<"u"&&Intl.v8BreakIterator}catch{a2=!1}var ng,kv,P1,wh,o2,Vn=(()=>{class n{constructor(e){this._platformId=e,this.isBrowser=this._platformId?_w(this._platformId):"object"==typeof document&&!!document,this.EDGE=this.isBrowser&&/(edge)/i.test(navigator.userAgent),this.TRIDENT=this.isBrowser&&/(msie|trident)/i.test(navigator.userAgent),this.BLINK=this.isBrowser&&!(!window.chrome&&!a2)&&typeof CSS<"u"&&!this.EDGE&&!this.TRIDENT,this.WEBKIT=this.isBrowser&&/AppleWebKit/i.test(navigator.userAgent)&&!this.BLINK&&!this.EDGE&&!this.TRIDENT,this.IOS=this.isBrowser&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!("MSStream"in window),this.FIREFOX=this.isBrowser&&/(firefox|minefield)/i.test(navigator.userAgent),this.ANDROID=this.isBrowser&&/android/i.test(navigator.userAgent)&&!this.TRIDENT,this.SAFARI=this.isBrowser&&/safari/i.test(navigator.userAgent)&&this.WEBKIT}}return n.\u0275fac=function(e){return new(e||n)(O(fc))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),h7=["color","button","checkbox","date","datetime-local","email","file","hidden","image","month","number","password","radio","range","reset","search","submit","tel","text","time","url","week"];function s2(){if(ng)return ng;if("object"!=typeof document||!document)return ng=new Set(h7);let n=document.createElement("input");return ng=new Set(h7.filter(t=>(n.setAttribute("type",t),n.type===t)))}function za(n){return function(){if(null==kv&&typeof window<"u")try{window.addEventListener("test",null,Object.defineProperty({},"passive",{get:()=>kv=!0}))}finally{kv=kv||!1}return kv}()?n:!!n.capture}function k1(){if(null==wh){if("object"!=typeof document||!document||"function"!=typeof Element||!Element)return wh=!1;if("scrollBehavior"in document.documentElement.style)wh=!0;else{let n=Element.prototype.scrollTo;wh=!!n&&!/\{\s*\[native code\]\s*\}/.test(n.toString())}}return wh}function ig(){if("object"!=typeof document||!document)return 0;if(null==P1){let n=document.createElement("div"),t=n.style;n.dir="rtl",t.width="1px",t.overflow="auto",t.visibility="hidden",t.pointerEvents="none",t.position="absolute";let e=document.createElement("div"),i=e.style;i.width="2px",i.height="1px",n.appendChild(e),document.body.appendChild(n),P1=0,0===n.scrollLeft&&(n.scrollLeft=1,P1=0===n.scrollLeft?1:2),n.remove()}return P1}function Ov(){let n=typeof document<"u"&&document?document.activeElement:null;for(;n&&n.shadowRoot;){let t=n.shadowRoot.activeElement;if(t===n)break;n=t}return n}function bs(n){return n.composedPath?n.composedPath()[0]:n.target}function Fv(){return typeof __karma__<"u"&&!!__karma__||typeof jasmine<"u"&&!!jasmine||typeof jest<"u"&&!!jest||typeof Mocha<"u"&&!!Mocha}function Or(n,...t){return t.length?t.some(e=>n[e]):n.altKey||n.shiftKey||n.ctrlKey||n.metaKey}function vt(n){return null!=n&&"false"!=`${n}`}function mi(n,t=0){return function(n){return!isNaN(parseFloat(n))&&!isNaN(Number(n))}(n)?Number(n):t}function rg(n){return Array.isArray(n)?n:[n]}function qr(n){return null==n?"":"string"==typeof n?n:`${n}px`}function Ua(n){return n instanceof xe?n.nativeElement:n}var ag,g7=(()=>{class n{create(e){return typeof MutationObserver>"u"?null:new MutationObserver(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),z0e=(()=>{class n{constructor(e){this._mutationObserverFactory=e,this._observedElements=new Map}ngOnDestroy(){this._observedElements.forEach((e,i)=>this._cleanupObserver(i))}observe(e){let i=Ua(e);return new Kt(r=>{let a=this._observeElement(i).subscribe(r);return()=>{a.unsubscribe(),this._unobserveElement(i)}})}_observeElement(e){if(this._observedElements.has(e))this._observedElements.get(e).count++;else{let i=new Ee,r=this._mutationObserverFactory.create(o=>i.next(o));r&&r.observe(e,{characterData:!0,childList:!0,subtree:!0}),this._observedElements.set(e,{observer:r,stream:i,count:1})}return this._observedElements.get(e).stream}_unobserveElement(e){this._observedElements.has(e)&&(this._observedElements.get(e).count--,this._observedElements.get(e).count||this._cleanupObserver(e))}_cleanupObserver(e){if(this._observedElements.has(e)){let{observer:i,stream:r}=this._observedElements.get(e);i&&i.disconnect(),r.complete(),this._observedElements.delete(e)}}}return n.\u0275fac=function(e){return new(e||n)(O(g7))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),O1=(()=>{class n{get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e),this._disabled?this._unsubscribe():this._subscribe()}get debounce(){return this._debounce}set debounce(e){this._debounce=mi(e),this._subscribe()}constructor(e,i,r){this._contentObserver=e,this._elementRef=i,this._ngZone=r,this.event=new F,this._disabled=!1,this._currentSubscription=null}ngAfterContentInit(){!this._currentSubscription&&!this.disabled&&this._subscribe()}ngOnDestroy(){this._unsubscribe()}_subscribe(){this._unsubscribe();let e=this._contentObserver.observe(this._elementRef);this._ngZone.runOutsideAngular(()=>{this._currentSubscription=(this.debounce?e.pipe(Cr(this.debounce)):e).subscribe(this.event)})}_unsubscribe(){this._currentSubscription?.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(z0e),C(xe),C(ot))},n.\u0275dir=Me({type:n,selectors:[["","cdkObserveContent",""]],inputs:{disabled:["cdkObserveContentDisabled","disabled"],debounce:"debounce"},outputs:{event:"cdkObserveContent"},exportAs:["cdkObserveContent"]}),n})(),og=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[g7]}),n})(),b7=new Set,U0e=(()=>{class n{constructor(e){this._platform=e,this._matchMedia=this._platform.isBrowser&&window.matchMedia?window.matchMedia.bind(window):G0e}matchMedia(e){return(this._platform.WEBKIT||this._platform.BLINK)&&function(n){if(!b7.has(n))try{ag||((ag=document.createElement("style")).setAttribute("type","text/css"),document.head.appendChild(ag)),ag.sheet&&(ag.sheet.insertRule(`@media ${n} {body{ }}`,0),b7.add(n))}catch(t){console.error(t)}}(e),this._matchMedia(e)}}return n.\u0275fac=function(e){return new(e||n)(O(Vn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function G0e(n){return{matches:"all"===n||""===n,media:n,addListener:()=>{},removeListener:()=>{}}}var Nv=(()=>{class n{constructor(e,i){this._mediaMatcher=e,this._zone=i,this._queries=new Map,this._destroySubject=new Ee}ngOnDestroy(){this._destroySubject.next(),this._destroySubject.complete()}isMatched(e){return v7(rg(e)).some(r=>this._registerQuery(r).mql.matches)}observe(e){let o=In(v7(rg(e)).map(a=>this._registerQuery(a).observable));return o=Kd(o.pipe(Lt(1)),o.pipe(os(1),Cr(0))),o.pipe(q(a=>{let s={matches:!1,breakpoints:{}};return a.forEach(({matches:l,query:c})=>{s.matches=s.matches||l,s.breakpoints[c]=l}),s}))}_registerQuery(e){if(this._queries.has(e))return this._queries.get(e);let i=this._mediaMatcher.matchMedia(e),o={observable:new Kt(a=>{let s=l=>this._zone.run(()=>a.next(l));return i.addListener(s),()=>{i.removeListener(s)}}).pipe(kn(i),q(({matches:a})=>({query:e,matches:a})),it(this._destroySubject)),mql:i};return this._queries.set(e,o),o}}return n.\u0275fac=function(e){return new(e||n)(O(U0e),O(ot))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function v7(n){return n.map(t=>t.split(",")).reduce((t,e)=>t.concat(e)).map(t=>t.trim())}function L1(n,t){return(n.getAttribute(t)||"").match(/\S+/g)||[]}var E7="cdk-describedby-message",F1="cdk-describedby-host",d2=0,T7=(()=>{class n{constructor(e,i){this._platform=i,this._messageRegistry=new Map,this._messagesContainer=null,this._id=""+d2++,this._document=e,this._id=$n($p)+"-"+d2++}describe(e,i,r){if(!this._canBeDescribed(e,i))return;let o=l2(i,r);"string"!=typeof i?(x7(i,this._id),this._messageRegistry.set(o,{messageElement:i,referenceCount:0})):this._messageRegistry.has(o)||this._createMessageElement(i,r),this._isElementDescribedByMessage(e,o)||this._addMessageReference(e,o)}removeDescription(e,i,r){if(!i||!this._isElementNode(e))return;let o=l2(i,r);if(this._isElementDescribedByMessage(e,o)&&this._removeMessageReference(e,o),"string"==typeof i){let a=this._messageRegistry.get(o);a&&0===a.referenceCount&&this._deleteMessageElement(o)}0===this._messagesContainer?.childNodes.length&&(this._messagesContainer.remove(),this._messagesContainer=null)}ngOnDestroy(){let e=this._document.querySelectorAll(`[${F1}="${this._id}"]`);for(let i=0;i<e.length;i++)this._removeCdkDescribedByReferenceIds(e[i]),e[i].removeAttribute(F1);this._messagesContainer?.remove(),this._messagesContainer=null,this._messageRegistry.clear()}_createMessageElement(e,i){let r=this._document.createElement("div");x7(r,this._id),r.textContent=e,i&&r.setAttribute("role",i),this._createMessagesContainer(),this._messagesContainer.appendChild(r),this._messageRegistry.set(l2(e,i),{messageElement:r,referenceCount:0})}_deleteMessageElement(e){this._messageRegistry.get(e)?.messageElement?.remove(),this._messageRegistry.delete(e)}_createMessagesContainer(){if(this._messagesContainer)return;let e="cdk-describedby-message-container",i=this._document.querySelectorAll(`.${e}[platform="server"]`);for(let o=0;o<i.length;o++)i[o].remove();let r=this._document.createElement("div");r.style.visibility="hidden",r.classList.add(e),r.classList.add("cdk-visually-hidden"),this._platform&&!this._platform.isBrowser&&r.setAttribute("platform","server"),this._document.body.appendChild(r),this._messagesContainer=r}_removeCdkDescribedByReferenceIds(e){let i=L1(e,"aria-describedby").filter(r=>0!=r.indexOf(E7));e.setAttribute("aria-describedby",i.join(" "))}_addMessageReference(e,i){let r=this._messageRegistry.get(i);(function(n,t,e){let i=L1(n,t);i.some(r=>r.trim()==e.trim())||(i.push(e.trim()),n.setAttribute(t,i.join(" ")))})(e,"aria-describedby",r.messageElement.id),e.setAttribute(F1,this._id),r.referenceCount++}_removeMessageReference(e,i){let r=this._messageRegistry.get(i);r.referenceCount--,function(n,t,e){let r=L1(n,t).filter(o=>o!=e.trim());r.length?n.setAttribute(t,r.join(" ")):n.removeAttribute(t)}(e,"aria-describedby",r.messageElement.id),e.removeAttribute(F1)}_isElementDescribedByMessage(e,i){let r=L1(e,"aria-describedby"),o=this._messageRegistry.get(i),a=o&&o.messageElement.id;return!!a&&-1!=r.indexOf(a)}_canBeDescribed(e,i){if(!this._isElementNode(e))return!1;if(i&&"object"==typeof i)return!0;let r=null==i?"":`${i}`.trim(),o=e.getAttribute("aria-label");return!(!r||o&&o.trim()===r)}_isElementNode(e){return e.nodeType===this._document.ELEMENT_NODE}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(Vn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function l2(n,t){return"string"==typeof n?`${t||""}/${n}`:n}function x7(n,t){n.id||(n.id=`${E7}-${t}-${d2++}`)}var B1=class{constructor(t){this._items=t,this._activeItemIndex=-1,this._activeItem=null,this._wrap=!1,this._letterKeyStream=new Ee,this._typeaheadSubscription=En.EMPTY,this._vertical=!0,this._allowedModifierKeys=[],this._homeAndEnd=!1,this._pageUpAndDown={enabled:!1,delta:10},this._skipPredicateFn=e=>e.disabled,this._pressedLetters=[],this.tabOut=new Ee,this.change=new Ee,t instanceof Pa&&(this._itemChangesSubscription=t.changes.subscribe(e=>{if(this._activeItem){let r=e.toArray().indexOf(this._activeItem);r>-1&&r!==this._activeItemIndex&&(this._activeItemIndex=r)}}))}skipPredicate(t){return this._skipPredicateFn=t,this}withWrap(t=!0){return this._wrap=t,this}withVerticalOrientation(t=!0){return this._vertical=t,this}withHorizontalOrientation(t){return this._horizontal=t,this}withAllowedModifierKeys(t){return this._allowedModifierKeys=t,this}withTypeAhead(t=200){return this._typeaheadSubscription.unsubscribe(),this._typeaheadSubscription=this._letterKeyStream.pipe(Dt(e=>this._pressedLetters.push(e)),Cr(t),Oe(()=>this._pressedLetters.length>0),q(()=>this._pressedLetters.join(""))).subscribe(e=>{let i=this._getItemsArray();for(let r=1;r<i.length+1;r++){let o=(this._activeItemIndex+r)%i.length,a=i[o];if(!this._skipPredicateFn(a)&&0===a.getLabel().toUpperCase().trim().indexOf(e)){this.setActiveItem(o);break}}this._pressedLetters=[]}),this}cancelTypeahead(){return this._pressedLetters=[],this}withHomeAndEnd(t=!0){return this._homeAndEnd=t,this}withPageUpDown(t=!0,e=10){return this._pageUpAndDown={enabled:t,delta:e},this}setActiveItem(t){let e=this._activeItem;this.updateActiveItem(t),this._activeItem!==e&&this.change.next(this._activeItemIndex)}onKeydown(t){let e=t.keyCode,r=["altKey","ctrlKey","metaKey","shiftKey"].every(o=>!t[o]||this._allowedModifierKeys.indexOf(o)>-1);switch(e){case 9:return void this.tabOut.next();case 40:if(this._vertical&&r){this.setNextItemActive();break}return;case 38:if(this._vertical&&r){this.setPreviousItemActive();break}return;case 39:if(this._horizontal&&r){"rtl"===this._horizontal?this.setPreviousItemActive():this.setNextItemActive();break}return;case 37:if(this._horizontal&&r){"rtl"===this._horizontal?this.setNextItemActive():this.setPreviousItemActive();break}return;case 36:if(this._homeAndEnd&&r){this.setFirstItemActive();break}return;case 35:if(this._homeAndEnd&&r){this.setLastItemActive();break}return;case 33:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex-this._pageUpAndDown.delta;this._setActiveItemByIndex(o>0?o:0,1);break}return;case 34:if(this._pageUpAndDown.enabled&&r){let o=this._activeItemIndex+this._pageUpAndDown.delta,a=this._getItemsArray().length;this._setActiveItemByIndex(o<a?o:a-1,-1);break}return;default:return void((r||Or(t,"shiftKey"))&&(t.key&&1===t.key.length?this._letterKeyStream.next(t.key.toLocaleUpperCase()):(e>=65&&e<=90||e>=48&&e<=57)&&this._letterKeyStream.next(String.fromCharCode(e))))}this._pressedLetters=[],t.preventDefault()}get activeItemIndex(){return this._activeItemIndex}get activeItem(){return this._activeItem}isTyping(){return this._pressedLetters.length>0}setFirstItemActive(){this._setActiveItemByIndex(0,1)}setLastItemActive(){this._setActiveItemByIndex(this._items.length-1,-1)}setNextItemActive(){this._activeItemIndex<0?this.setFirstItemActive():this._setActiveItemByDelta(1)}setPreviousItemActive(){this._activeItemIndex<0&&this._wrap?this.setLastItemActive():this._setActiveItemByDelta(-1)}updateActiveItem(t){let e=this._getItemsArray(),i="number"==typeof t?t:e.indexOf(t);this._activeItem=e[i]??null,this._activeItemIndex=i}destroy(){this._typeaheadSubscription.unsubscribe(),this._itemChangesSubscription?.unsubscribe(),this._letterKeyStream.complete(),this.tabOut.complete(),this.change.complete(),this._pressedLetters=[]}_setActiveItemByDelta(t){this._wrap?this._setActiveInWrapMode(t):this._setActiveInDefaultMode(t)}_setActiveInWrapMode(t){let e=this._getItemsArray();for(let i=1;i<=e.length;i++){let r=(this._activeItemIndex+t*i+e.length)%e.length;if(!this._skipPredicateFn(e[r]))return void this.setActiveItem(r)}}_setActiveInDefaultMode(t){this._setActiveItemByIndex(this._activeItemIndex+t,t)}_setActiveItemByIndex(t,e){let i=this._getItemsArray();if(i[t]){for(;this._skipPredicateFn(i[t]);)if(!i[t+=e])return;this.setActiveItem(t)}}_getItemsArray(){return this._items instanceof Pa?this._items.toArray():this._items}},lg=class extends B1{setActiveItem(t){this.activeItem&&this.activeItem.setInactiveStyles(),super.setActiveItem(t),this.activeItem&&this.activeItem.setActiveStyles()}},ku=class extends B1{constructor(){super(...arguments),this._origin="program"}setFocusOrigin(t){return this._origin=t,this}setActiveItem(t){super.setActiveItem(t),this.activeItem&&this.activeItem.focus(this._origin)}},ug=(()=>{class n{constructor(e){this._platform=e}isDisabled(e){return e.hasAttribute("disabled")}isVisible(e){return function(n){return!!(n.offsetWidth||n.offsetHeight||"function"==typeof n.getClientRects&&n.getClientRects().length)}(e)&&"visible"===getComputedStyle(e).visibility}isTabbable(e){if(!this._platform.isBrowser)return!1;let i=function(n){try{return n.frameElement}catch{return null}}(function(n){return n.ownerDocument&&n.ownerDocument.defaultView||window}(e));if(i&&(-1===C7(i)||!this.isVisible(i)))return!1;let r=e.nodeName.toLowerCase(),o=C7(e);return e.hasAttribute("contenteditable")?-1!==o:!("iframe"===r||"object"===r||this._platform.WEBKIT&&this._platform.IOS&&!function(n){let t=n.nodeName.toLowerCase(),e="input"===t&&n.type;return"text"===e||"password"===e||"select"===t||"textarea"===t}(e))&&("audio"===r?!!e.hasAttribute("controls")&&-1!==o:"video"===r?-1!==o&&(null!==o||this._platform.FIREFOX||e.hasAttribute("controls")):e.tabIndex>=0)}isFocusable(e,i){return function(n){return!function(n){return function(n){return"input"==n.nodeName.toLowerCase()}(n)&&"hidden"==n.type}(n)&&(function(n){let t=n.nodeName.toLowerCase();return"input"===t||"select"===t||"button"===t||"textarea"===t}(n)||function(n){return function(n){return"a"==n.nodeName.toLowerCase()}(n)&&n.hasAttribute("href")}(n)||n.hasAttribute("contenteditable")||D7(n))}(e)&&!this.isDisabled(e)&&(i?.ignoreVisibility||this.isVisible(e))}}return n.\u0275fac=function(e){return new(e||n)(O(Vn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function D7(n){if(!n.hasAttribute("tabindex")||void 0===n.tabIndex)return!1;let t=n.getAttribute("tabindex");return!(!t||isNaN(parseInt(t,10)))}function C7(n){if(!D7(n))return null;let t=parseInt(n.getAttribute("tabindex")||"",10);return isNaN(t)?-1:t}var Lv=(()=>{class n{constructor(e,i,r){this._checker=e,this._ngZone=i,this._document=r}create(e,i=!1){return new class{get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}constructor(t,e,i,r,o=!1){this._element=t,this._checker=e,this._ngZone=i,this._document=r,this._hasAttached=!1,this.startAnchorListener=()=>this.focusLastTabbableElement(),this.endAnchorListener=()=>this.focusFirstTabbableElement(),this._enabled=!0,o||this.attachAnchors()}destroy(){let t=this._startAnchor,e=this._endAnchor;t&&(t.removeEventListener("focus",this.startAnchorListener),t.remove()),e&&(e.removeEventListener("focus",this.endAnchorListener),e.remove()),this._startAnchor=this._endAnchor=null,this._hasAttached=!1}attachAnchors(){return!!this._hasAttached||(this._ngZone.runOutsideAngular(()=>{this._startAnchor||(this._startAnchor=this._createAnchor(),this._startAnchor.addEventListener("focus",this.startAnchorListener)),this._endAnchor||(this._endAnchor=this._createAnchor(),this._endAnchor.addEventListener("focus",this.endAnchorListener))}),this._element.parentNode&&(this._element.parentNode.insertBefore(this._startAnchor,this._element),this._element.parentNode.insertBefore(this._endAnchor,this._element.nextSibling),this._hasAttached=!0),this._hasAttached)}focusInitialElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusInitialElement(t)))})}focusFirstTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusFirstTabbableElement(t)))})}focusLastTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusLastTabbableElement(t)))})}_getRegionBoundary(t){let e=this._element.querySelectorAll(`[cdk-focus-region-${t}], [cdkFocusRegion${t}], [cdk-focus-${t}]`);return"start"==t?e.length?e[0]:this._getFirstTabbableElement(this._element):e.length?e[e.length-1]:this._getLastTabbableElement(this._element)}focusInitialElement(t){let e=this._element.querySelector("[cdk-focus-initial], [cdkFocusInitial]");if(e){if(!this._checker.isFocusable(e)){let i=this._getFirstTabbableElement(e);return i?.focus(t),!!i}return e.focus(t),!0}return this.focusFirstTabbableElement(t)}focusFirstTabbableElement(t){let e=this._getRegionBoundary("start");return e&&e.focus(t),!!e}focusLastTabbableElement(t){let e=this._getRegionBoundary("end");return e&&e.focus(t),!!e}hasAttached(){return this._hasAttached}_getFirstTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=0;i<e.length;i++){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getFirstTabbableElement(e[i]):null;if(r)return r}return null}_getLastTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=e.length-1;i>=0;i--){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getLastTabbableElement(e[i]):null;if(r)return r}return null}_createAnchor(){let t=this._document.createElement("div");return this._toggleAnchorTabIndex(this._enabled,t),t.classList.add("cdk-visually-hidden"),t.classList.add("cdk-focus-trap-anchor"),t.setAttribute("aria-hidden","true"),t}_toggleAnchorTabIndex(t,e){t?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")}toggleAnchors(t){this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}_executeOnStable(t){this._ngZone.isStable?t():this._ngZone.onStable.pipe(Lt(1)).subscribe(t)}}(e,this._checker,this._ngZone,this._document,i)}}return n.\u0275fac=function(e){return new(e||n)(O(ug),O(ot),O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Bv(n){return 0===n.buttons||0===n.offsetX&&0===n.offsetY}function Vv(n){let t=n.touches&&n.touches[0]||n.changedTouches&&n.changedTouches[0];return!(!t||-1!==t.identifier||null!=t.radiusX&&1!==t.radiusX||null!=t.radiusY&&1!==t.radiusY)}new te("FOCUS_TRAP_INERT_STRATEGY");var g_e=new te("cdk-input-modality-detector-options"),__e={ignoreKeys:[18,17,224,91,16]},sg=za({passive:!0,capture:!0}),b_e=(()=>{class n{get mostRecentModality(){return this._modality.value}constructor(e,i,r,o){this._platform=e,this._mostRecentTarget=null,this._modality=new xr(null),this._lastTouchMs=0,this._onKeydown=a=>{this._options?.ignoreKeys?.some(s=>s===a.keyCode)||(this._modality.next("keyboard"),this._mostRecentTarget=bs(a))},this._onMousedown=a=>{Date.now()-this._lastTouchMs<650||(this._modality.next(Bv(a)?"keyboard":"mouse"),this._mostRecentTarget=bs(a))},this._onTouchstart=a=>{Vv(a)?this._modality.next("keyboard"):(this._lastTouchMs=Date.now(),this._modality.next("touch"),this._mostRecentTarget=bs(a))},this._options={...__e,...o},this.modalityDetected=this._modality.pipe(os(1)),this.modalityChanged=this.modalityDetected.pipe(ri()),e.isBrowser&&i.runOutsideAngular(()=>{r.addEventListener("keydown",this._onKeydown,sg),r.addEventListener("mousedown",this._onMousedown,sg),r.addEventListener("touchstart",this._onTouchstart,sg)})}ngOnDestroy(){this._modality.complete(),this._platform.isBrowser&&(document.removeEventListener("keydown",this._onKeydown,sg),document.removeEventListener("mousedown",this._onMousedown,sg),document.removeEventListener("touchstart",this._onTouchstart,sg))}}return n.\u0275fac=function(e){return new(e||n)(O(Vn),O(ot),O(Nt),O(g_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),v_e=new te("liveAnnouncerElement",{providedIn:"root",factory:function(){return null}}),x_e=new te("LIVE_ANNOUNCER_DEFAULT_OPTIONS"),C_e=0,Hv=(()=>{class n{constructor(e,i,r,o){this._ngZone=i,this._defaultOptions=o,this._document=r,this._liveElement=e||this._createLiveElement()}announce(e,...i){let o,a,r=this._defaultOptions;return 1===i.length&&"number"==typeof i[0]?a=i[0]:[o,a]=i,this.clear(),clearTimeout(this._previousTimeout),o||(o=r&&r.politeness?r.politeness:"polite"),null==a&&r&&(a=r.duration),this._liveElement.setAttribute("aria-live",o),this._liveElement.id&&this._exposeAnnouncerToModals(this._liveElement.id),this._ngZone.runOutsideAngular(()=>(this._currentPromise||(this._currentPromise=new Promise(s=>this._currentResolve=s)),clearTimeout(this._previousTimeout),this._previousTimeout=setTimeout(()=>{this._liveElement.textContent=e,"number"==typeof a&&(this._previousTimeout=setTimeout(()=>this.clear(),a)),this._currentResolve(),this._currentPromise=this._currentResolve=void 0},100),this._currentPromise))}clear(){this._liveElement&&(this._liveElement.textContent="")}ngOnDestroy(){clearTimeout(this._previousTimeout),this._liveElement?.remove(),this._liveElement=null,this._currentResolve?.(),this._currentPromise=this._currentResolve=void 0}_createLiveElement(){let e="cdk-live-announcer-element",i=this._document.getElementsByClassName(e),r=this._document.createElement("div");for(let o=0;o<i.length;o++)i[o].remove();return r.classList.add(e),r.classList.add("cdk-visually-hidden"),r.setAttribute("aria-atomic","true"),r.setAttribute("aria-live","polite"),r.id="cdk-live-announcer-"+C_e++,this._document.body.appendChild(r),r}_exposeAnnouncerToModals(e){let i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],a=o.getAttribute("aria-owns");a?-1===a.indexOf(e)&&o.setAttribute("aria-owns",a+" "+e):o.setAttribute("aria-owns",e)}}}return n.\u0275fac=function(e){return new(e||n)(O(v_e,8),O(ot),O(Nt),O(x_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),M_e=new te("cdk-focus-monitor-default-options"),N1=za({passive:!0,capture:!0}),fo=(()=>{class n{constructor(e,i,r,o,a){this._ngZone=e,this._platform=i,this._inputModalityDetector=r,this._origin=null,this._windowFocused=!1,this._originFromTouchInteraction=!1,this._elementInfo=new Map,this._monitoredElementCount=0,this._rootNodeFocusListenerCount=new Map,this._windowFocusListener=()=>{this._windowFocused=!0,this._windowFocusTimeoutId=window.setTimeout(()=>this._windowFocused=!1)},this._stopInputModalityDetector=new Ee,this._rootNodeFocusAndBlurListener=s=>{for(let c=bs(s);c;c=c.parentElement)"focus"===s.type?this._onFocus(s,c):this._onBlur(s,c)},this._document=o,this._detectionMode=a?.detectionMode||0}monitor(e,i=!1){let r=Ua(e);if(!this._platform.isBrowser||1!==r.nodeType)return $t(null);let o=function(n){if(function(){if(null==o2){let n=typeof document<"u"?document.head:null;o2=!(!n||!n.createShadowRoot&&!n.attachShadow)}return o2}()){let t=n.getRootNode?n.getRootNode():null;if(typeof ShadowRoot<"u"&&ShadowRoot&&t instanceof ShadowRoot)return t}return null}(r)||this._getDocument(),a=this._elementInfo.get(r);if(a)return i&&(a.checkChildren=!0),a.subject;let s={checkChildren:i,subject:new Ee,rootNode:o};return this._elementInfo.set(r,s),this._registerGlobalListeners(s),s.subject}stopMonitoring(e){let i=Ua(e),r=this._elementInfo.get(i);r&&(r.subject.complete(),this._setClasses(i),this._elementInfo.delete(i),this._removeGlobalListeners(r))}focusVia(e,i,r){let o=Ua(e);o===this._getDocument().activeElement?this._getClosestElementsInfo(o).forEach(([s,l])=>this._originChanged(s,i,l)):(this._setOrigin(i),"function"==typeof o.focus&&o.focus(r))}ngOnDestroy(){this._elementInfo.forEach((e,i)=>this.stopMonitoring(i))}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_getFocusOrigin(e){return this._origin?this._originFromTouchInteraction?this._shouldBeAttributedToTouch(e)?"touch":"program":this._origin:this._windowFocused&&this._lastFocusOrigin?this._lastFocusOrigin:e&&this._isLastInteractionFromInputLabel(e)?"mouse":"program"}_shouldBeAttributedToTouch(e){return 1===this._detectionMode||!!e?.contains(this._inputModalityDetector._mostRecentTarget)}_setClasses(e,i){e.classList.toggle("cdk-focused",!!i),e.classList.toggle("cdk-touch-focused","touch"===i),e.classList.toggle("cdk-keyboard-focused","keyboard"===i),e.classList.toggle("cdk-mouse-focused","mouse"===i),e.classList.toggle("cdk-program-focused","program"===i)}_setOrigin(e,i=!1){this._ngZone.runOutsideAngular(()=>{this._origin=e,this._originFromTouchInteraction="touch"===e&&i,0===this._detectionMode&&(clearTimeout(this._originTimeoutId),this._originTimeoutId=setTimeout(()=>this._origin=null,this._originFromTouchInteraction?650:1))})}_onFocus(e,i){let r=this._elementInfo.get(i),o=bs(e);!r||!r.checkChildren&&i!==o||this._originChanged(i,this._getFocusOrigin(o),r)}_onBlur(e,i){let r=this._elementInfo.get(i);!r||r.checkChildren&&e.relatedTarget instanceof Node&&i.contains(e.relatedTarget)||(this._setClasses(i),this._emitOrigin(r,null))}_emitOrigin(e,i){e.subject.observers.length&&this._ngZone.run(()=>e.subject.next(i))}_registerGlobalListeners(e){if(!this._platform.isBrowser)return;let i=e.rootNode,r=this._rootNodeFocusListenerCount.get(i)||0;r||this._ngZone.runOutsideAngular(()=>{i.addEventListener("focus",this._rootNodeFocusAndBlurListener,N1),i.addEventListener("blur",this._rootNodeFocusAndBlurListener,N1)}),this._rootNodeFocusListenerCount.set(i,r+1),1==++this._monitoredElementCount&&(this._ngZone.runOutsideAngular(()=>{this._getWindow().addEventListener("focus",this._windowFocusListener)}),this._inputModalityDetector.modalityDetected.pipe(it(this._stopInputModalityDetector)).subscribe(o=>{this._setOrigin(o,!0)}))}_removeGlobalListeners(e){let i=e.rootNode;if(this._rootNodeFocusListenerCount.has(i)){let r=this._rootNodeFocusListenerCount.get(i);r>1?this._rootNodeFocusListenerCount.set(i,r-1):(i.removeEventListener("focus",this._rootNodeFocusAndBlurListener,N1),i.removeEventListener("blur",this._rootNodeFocusAndBlurListener,N1),this._rootNodeFocusListenerCount.delete(i))}--this._monitoredElementCount||(this._getWindow().removeEventListener("focus",this._windowFocusListener),this._stopInputModalityDetector.next(),clearTimeout(this._windowFocusTimeoutId),clearTimeout(this._originTimeoutId))}_originChanged(e,i,r){this._setClasses(e,i),this._emitOrigin(r,i),this._lastFocusOrigin=i}_getClosestElementsInfo(e){let i=[];return this._elementInfo.forEach((r,o)=>{(o===e||r.checkChildren&&o.contains(e))&&i.push([o,r])}),i}_isLastInteractionFromInputLabel(e){let{_mostRecentTarget:i,mostRecentModality:r}=this._inputModalityDetector;if("mouse"!==r||!i||i===e||"INPUT"!==e.nodeName&&"TEXTAREA"!==e.nodeName||e.disabled)return!1;let o=e.labels;if(o)for(let a=0;a<o.length;a++)if(o[a].contains(i))return!0;return!1}}return n.\u0275fac=function(e){return new(e||n)(O(ot),O(Vn),O(b_e),O(Nt,8),O(M_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),A7=(()=>{class n{constructor(e,i){this._elementRef=e,this._focusMonitor=i,this._focusOrigin=null,this.cdkFocusChange=new F}get focusOrigin(){return this._focusOrigin}ngAfterViewInit(){let e=this._elementRef.nativeElement;this._monitorSubscription=this._focusMonitor.monitor(e,1===e.nodeType&&e.hasAttribute("cdkMonitorSubtreeFocus")).subscribe(i=>{this._focusOrigin=i,this.cdkFocusChange.emit(i)})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._monitorSubscription&&this._monitorSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(fo))},n.\u0275dir=Me({type:n,selectors:[["","cdkMonitorElementFocus",""],["","cdkMonitorSubtreeFocus",""]],outputs:{cdkFocusChange:"cdkFocusChange"},exportAs:["cdkMonitorFocus"]}),n})(),M7="cdk-high-contrast-black-on-white",w7="cdk-high-contrast-white-on-black",c2="cdk-high-contrast-active",h2=(()=>{class n{constructor(e,i){this._platform=e,this._document=i,this._breakpointSubscription=$n(Nv).observe("(forced-colors: active)").subscribe(()=>{this._hasCheckedHighContrastMode&&(this._hasCheckedHighContrastMode=!1,this._applyBodyHighContrastModeCssClasses())})}getHighContrastMode(){if(!this._platform.isBrowser)return 0;let e=this._document.createElement("div");e.style.backgroundColor="rgb(1,2,3)",e.style.position="absolute",this._document.body.appendChild(e);let i=this._document.defaultView||window,r=i&&i.getComputedStyle?i.getComputedStyle(e):null,o=(r&&r.backgroundColor||"").replace(/ /g,"");switch(e.remove(),o){case"rgb(0,0,0)":case"rgb(45,50,54)":case"rgb(32,32,32)":return 2;case"rgb(255,255,255)":case"rgb(255,250,239)":return 1}return 0}ngOnDestroy(){this._breakpointSubscription.unsubscribe()}_applyBodyHighContrastModeCssClasses(){if(!this._hasCheckedHighContrastMode&&this._platform.isBrowser&&this._document.body){let e=this._document.body.classList;e.remove(c2,M7,w7),this._hasCheckedHighContrastMode=!0;let i=this.getHighContrastMode();1===i?e.add(c2,M7):2===i&&e.add(c2,w7)}}}return n.\u0275fac=function(e){return new(e||n)(O(Vn),O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),pg=(()=>{class n{constructor(e){e._applyBodyHighContrastModeCssClasses()}}return n.\u0275fac=function(e){return new(e||n)(O(h2))},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[og]}),n})(),w_e=new te("cdk-dir-doc",{providedIn:"root",factory:function(){return $n(Nt)}}),E_e=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i,zi=(()=>{class n{constructor(e){this.value="ltr",this.change=new F,e&&(this.value=function(n){let t=n?.toLowerCase()||"";return"auto"===t&&typeof navigator<"u"&&navigator?.language?E_e.test(navigator.language)?"rtl":"ltr":"rtl"===t?"rtl":"ltr"}((e.body?e.body.dir:null)||(e.documentElement?e.documentElement.dir:null)||"ltr"))}ngOnDestroy(){this.change.complete()}}return n.\u0275fac=function(e){return new(e||n)(O(w_e,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Fu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),D_e=["text"];function I_e(n,t){if(1&n&&k(0,"mat-pseudo-checkbox",6),2&n){let e=w();b("state",e.selected?"checked":"unchecked")("disabled",e.disabled)}}function A_e(n,t){1&n&&k(0,"mat-pseudo-checkbox",7),2&n&&b("disabled",w().disabled)}function R_e(n,t){if(1&n&&(f(0,"span",8),T(1),g()),2&n){let e=w();v(1),Ve("(",e.group.label,")")}}var P_e=[[["mat-icon"]],"*"],k_e=["mat-icon","*"],N7=(new Ml("15.2.9"),(()=>{class n{}return n.STANDARD_CURVE="cubic-bezier(0.4,0.0,0.2,1)",n.DECELERATION_CURVE="cubic-bezier(0.0,0.0,0.2,1)",n.ACCELERATION_CURVE="cubic-bezier(0.4,0.0,1,1)",n.SHARP_CURVE="cubic-bezier(0.4,0.0,0.6,1)",n})()),L7=(()=>{class n{}return n.COMPLEX="375ms",n.ENTERING="225ms",n.EXITING="195ms",n})(),F_e=new te("mat-sanity-checks",{providedIn:"root",factory:function(){return!0}}),dn=(()=>{class n{constructor(e,i,r){this._sanityChecks=i,this._document=r,this._hasDoneGlobalChecks=!1,e._applyBodyHighContrastModeCssClasses(),this._hasDoneGlobalChecks||(this._hasDoneGlobalChecks=!0)}_checkIsEnabled(e){return!Fv()&&("boolean"==typeof this._sanityChecks?this._sanityChecks:!!this._sanityChecks[e])}}return n.\u0275fac=function(e){return new(e||n)(O(h2),O(F_e,8),O(Nt))},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Fu,Fu]}),n})();function ao(n){return class extends n{get disabled(){return this._disabled}set disabled(t){this._disabled=vt(t)}constructor(...t){super(...t),this._disabled=!1}}}function Ko(n,t){return class extends n{get color(){return this._color}set color(e){let i=e||this.defaultColor;i!==this._color&&(this._color&&this._elementRef.nativeElement.classList.remove(`mat-${this._color}`),i&&this._elementRef.nativeElement.classList.add(`mat-${i}`),this._color=i)}constructor(...e){super(...e),this.defaultColor=t,this.color=t}}}function go(n){return class extends n{get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=vt(t)}constructor(...t){super(...t),this._disableRipple=!1}}}function Dc(n,t=0){return class extends n{get tabIndex(){return this.disabled?-1:this._tabIndex}set tabIndex(e){this._tabIndex=null!=e?mi(e):this.defaultTabIndex}constructor(...e){super(...e),this._tabIndex=t,this.defaultTabIndex=t}}}function hg(n){return class extends n{updateErrorState(){let t=this.errorState,o=(this.errorStateMatcher||this._defaultErrorStateMatcher).isErrorState(this.ngControl?this.ngControl.control:null,this._parentFormGroup||this._parentForm);o!==t&&(this.errorState=o,this.stateChanges.next())}constructor(...t){super(...t),this.errorState=!1}}}function H1(n){return class extends n{constructor(...t){super(...t),this._isInitialized=!1,this._pendingSubscribers=[],this.initialized=new Kt(e=>{this._isInitialized?this._notifySubscriber(e):this._pendingSubscribers.push(e)})}_markInitialized(){this._isInitialized=!0,this._pendingSubscribers.forEach(this._notifySubscriber),this._pendingSubscribers=null}_notifySubscriber(t){t.next(),t.complete()}}}new te("MAT_DATE_LOCALE",{providedIn:"root",factory:function(){return $n(ad)}}),new te("mat-date-formats");var Eh=(()=>{class n{isErrorState(e,i){return!!(e&&e.invalid&&(e.touched||i&&i.submitted))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),R7=za({passive:!0,capture:!0}),P7={enterDuration:225,exitDuration:150},k7=za({passive:!0,capture:!0}),O7=["mousedown","touchstart"],F7=["mouseup","mouseleave","touchend","touchcancel"],Sh=class{constructor(t,e,i,r){this._target=t,this._ngZone=e,this._platform=r,this._isPointerDown=!1,this._activeRipples=new Map,this._pointerUpEventsRegistered=!1,r.isBrowser&&(this._containerElement=Ua(i))}fadeInRipple(t,e,i={}){let r=this._containerRect=this._containerRect||this._containerElement.getBoundingClientRect(),o={...P7,...i.animation};i.centered&&(t=r.left+r.width/2,e=r.top+r.height/2);let a=i.radius||function(n,t,e){let i=Math.max(Math.abs(n-e.left),Math.abs(n-e.right)),r=Math.max(Math.abs(t-e.top),Math.abs(t-e.bottom));return Math.sqrt(i*i+r*r)}(t,e,r),s=t-r.left,l=e-r.top,c=o.enterDuration,d=document.createElement("div");d.classList.add("mat-ripple-element"),d.style.left=s-a+"px",d.style.top=l-a+"px",d.style.height=2*a+"px",d.style.width=2*a+"px",null!=i.color&&(d.style.backgroundColor=i.color),d.style.transitionDuration=`${c}ms`,this._containerElement.appendChild(d);let u=window.getComputedStyle(d),h=u.transitionDuration,m="none"===u.transitionProperty||"0s"===h||"0s, 0s"===h||0===r.width&&0===r.height,_=new class{constructor(t,e,i,r=!1){this._renderer=t,this.element=e,this.config=i,this._animationForciblyDisabledThroughCss=r,this.state=3}fadeOut(){this._renderer.fadeOutRipple(this)}}(this,d,i,m);d.style.transform="scale3d(1, 1, 1)",_.state=0,i.persistent||(this._mostRecentTransientRipple=_);let M=null;return!m&&(c||o.exitDuration)&&this._ngZone.runOutsideAngular(()=>{let y=()=>this._finishRippleTransition(_),x=()=>this._destroyRipple(_);d.addEventListener("transitionend",y),d.addEventListener("transitioncancel",x),M={onTransitionEnd:y,onTransitionCancel:x}}),this._activeRipples.set(_,M),(m||!c)&&this._finishRippleTransition(_),_}fadeOutRipple(t){if(2===t.state||3===t.state)return;let e=t.element,i={...P7,...t.config.animation};e.style.transitionDuration=`${i.exitDuration}ms`,e.style.opacity="0",t.state=2,(t._animationForciblyDisabledThroughCss||!i.exitDuration)&&this._finishRippleTransition(t)}fadeOutAll(){this._getActiveRipples().forEach(t=>t.fadeOut())}fadeOutAllNonPersistent(){this._getActiveRipples().forEach(t=>{t.config.persistent||t.fadeOut()})}setupTriggerEvents(t){let e=Ua(t);!this._platform.isBrowser||!e||e===this._triggerElement||(this._removeTriggerEvents(),this._triggerElement=e,O7.forEach(i=>{Sh._eventManager.addHandler(this._ngZone,i,e,this)}))}handleEvent(t){"mousedown"===t.type?this._onMousedown(t):"touchstart"===t.type?this._onTouchStart(t):this._onPointerUp(),this._pointerUpEventsRegistered||(this._ngZone.runOutsideAngular(()=>{F7.forEach(e=>{this._triggerElement.addEventListener(e,this,k7)})}),this._pointerUpEventsRegistered=!0)}_finishRippleTransition(t){0===t.state?this._startFadeOutTransition(t):2===t.state&&this._destroyRipple(t)}_startFadeOutTransition(t){let e=t===this._mostRecentTransientRipple,{persistent:i}=t.config;t.state=1,!i&&(!e||!this._isPointerDown)&&t.fadeOut()}_destroyRipple(t){let e=this._activeRipples.get(t)??null;this._activeRipples.delete(t),this._activeRipples.size||(this._containerRect=null),t===this._mostRecentTransientRipple&&(this._mostRecentTransientRipple=null),t.state=3,null!==e&&(t.element.removeEventListener("transitionend",e.onTransitionEnd),t.element.removeEventListener("transitioncancel",e.onTransitionCancel)),t.element.remove()}_onMousedown(t){let e=Bv(t),i=this._lastTouchStartEvent&&Date.now()<this._lastTouchStartEvent+800;!this._target.rippleDisabled&&!e&&!i&&(this._isPointerDown=!0,this.fadeInRipple(t.clientX,t.clientY,this._target.rippleConfig))}_onTouchStart(t){if(!this._target.rippleDisabled&&!Vv(t)){this._lastTouchStartEvent=Date.now(),this._isPointerDown=!0;let e=t.changedTouches;for(let i=0;i<e.length;i++)this.fadeInRipple(e[i].clientX,e[i].clientY,this._target.rippleConfig)}}_onPointerUp(){!this._isPointerDown||(this._isPointerDown=!1,this._getActiveRipples().forEach(t=>{!t.config.persistent&&(1===t.state||t.config.terminateOnPointerUp&&0===t.state)&&t.fadeOut()}))}_getActiveRipples(){return Array.from(this._activeRipples.keys())}_removeTriggerEvents(){let t=this._triggerElement;t&&(O7.forEach(e=>Sh._eventManager.removeHandler(e,t,this)),this._pointerUpEventsRegistered&&F7.forEach(e=>t.removeEventListener(e,this,k7)))}};Sh._eventManager=new class{constructor(){this._events=new Map,this._delegateEventHandler=t=>{let e=bs(t);e&&this._events.get(t.type)?.forEach((i,r)=>{(r===e||r.contains(e))&&i.forEach(o=>o.handleEvent(t))})}}addHandler(t,e,i,r){let o=this._events.get(e);if(o){let a=o.get(i);a?a.add(r):o.set(i,new Set([r]))}else this._events.set(e,new Map([[i,new Set([r])]])),t.runOutsideAngular(()=>{document.addEventListener(e,this._delegateEventHandler,R7)})}removeHandler(t,e,i){let r=this._events.get(t);if(!r)return;let o=r.get(e);!o||(o.delete(i),0===o.size&&r.delete(e),0===r.size&&(this._events.delete(t),document.removeEventListener(t,this._delegateEventHandler,R7)))}};var Th=new te("mat-ripple-global-options"),Ki=(()=>{class n{get disabled(){return this._disabled}set disabled(e){e&&this.fadeOutAllNonPersistent(),this._disabled=e,this._setupTriggerEventsIfEnabled()}get trigger(){return this._trigger||this._elementRef.nativeElement}set trigger(e){this._trigger=e,this._setupTriggerEventsIfEnabled()}constructor(e,i,r,o,a){this._elementRef=e,this._animationMode=a,this.radius=0,this._disabled=!1,this._isInitialized=!1,this._globalOptions=o||{},this._rippleRenderer=new Sh(this,i,e,r)}ngOnInit(){this._isInitialized=!0,this._setupTriggerEventsIfEnabled()}ngOnDestroy(){this._rippleRenderer._removeTriggerEvents()}fadeOutAll(){this._rippleRenderer.fadeOutAll()}fadeOutAllNonPersistent(){this._rippleRenderer.fadeOutAllNonPersistent()}get rippleConfig(){return{centered:this.centered,radius:this.radius,color:this.color,animation:{...this._globalOptions.animation,..."NoopAnimations"===this._animationMode?{enterDuration:0,exitDuration:0}:{},...this.animation},terminateOnPointerUp:this._globalOptions.terminateOnPointerUp}}get rippleDisabled(){return this.disabled||!!this._globalOptions.disabled}_setupTriggerEventsIfEnabled(){!this.disabled&&this._isInitialized&&this._rippleRenderer.setupTriggerEvents(this.trigger)}launch(e,i=0,r){return"number"==typeof e?this._rippleRenderer.fadeInRipple(e,i,{...this.rippleConfig,...r}):this._rippleRenderer.fadeInRipple(0,0,{...this.rippleConfig,...e})}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ot),C(Vn),C(Th,8),C(pi,8))},n.\u0275dir=Me({type:n,selectors:[["","mat-ripple",""],["","matRipple",""]],hostAttrs:[1,"mat-ripple"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mat-ripple-unbounded",i.unbounded)},inputs:{color:["matRippleColor","color"],unbounded:["matRippleUnbounded","unbounded"],centered:["matRippleCentered","centered"],radius:["matRippleRadius","radius"],animation:["matRippleAnimation","animation"],disabled:["matRippleDisabled","disabled"],trigger:["matRippleTrigger","trigger"]},exportAs:["matRipple"]}),n})(),_a=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,dn]}),n})(),V_e=(()=>{class n{constructor(e){this._animationMode=e,this.state="unchecked",this.disabled=!1,this.appearance="full"}}return n.\u0275fac=function(e){return new(e||n)(C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-pseudo-checkbox"]],hostAttrs:[1,"mat-pseudo-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&nt("mat-pseudo-checkbox-indeterminate","indeterminate"===i.state)("mat-pseudo-checkbox-checked","checked"===i.state)("mat-pseudo-checkbox-disabled",i.disabled)("mat-pseudo-checkbox-minimal","minimal"===i.appearance)("mat-pseudo-checkbox-full","full"===i.appearance)("_mat-animation-noopable","NoopAnimations"===i._animationMode)},inputs:{state:"state",disabled:"disabled",appearance:"appearance"},decls:0,vars:0,template:function(e,i){},styles:['.mat-pseudo-checkbox{border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:"";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{left:1px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{left:1px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}.mat-pseudo-checkbox-full{border:2px solid}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox{width:18px;height:18px}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-checked::after{width:14px;height:6px;transform-origin:center;top:-4.2426406871px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-minimal.mat-pseudo-checkbox-indeterminate::after{top:8px;width:16px}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-checked::after{width:10px;height:4px;transform-origin:center;top:-2.8284271247px;left:0;bottom:0;right:0;margin:auto}.mat-pseudo-checkbox-full.mat-pseudo-checkbox-indeterminate::after{top:6px;width:12px}'],encapsulation:2,changeDetection:0}),n})(),H_e=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn]}),n})(),Uv=new te("MAT_OPTION_PARENT_COMPONENT"),jv=(ao(class{}),new te("MatOptgroup")),z_e=0,zv=class{constructor(t,e=!1){this.source=t,this.isUserInput=e}},U_e=(()=>{class n{get multiple(){return this._parent&&this._parent.multiple}get selected(){return this._selected}get disabled(){return this.group&&this.group.disabled||this._disabled}set disabled(e){this._disabled=vt(e)}get disableRipple(){return!(!this._parent||!this._parent.disableRipple)}get hideSingleSelectionIndicator(){return!(!this._parent||!this._parent.hideSingleSelectionIndicator)}constructor(e,i,r,o){this._element=e,this._changeDetectorRef=i,this._parent=r,this.group=o,this._selected=!1,this._active=!1,this._disabled=!1,this._mostRecentViewValue="",this.id="mat-option-"+z_e++,this.onSelectionChange=new F,this._stateChanges=new Ee}get active(){return this._active}get viewValue(){return(this._text?.nativeElement.textContent||"").trim()}select(){this._selected||(this._selected=!0,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}deselect(){this._selected&&(this._selected=!1,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}focus(e,i){let r=this._getHostElement();"function"==typeof r.focus&&r.focus(i)}setActiveStyles(){this._active||(this._active=!0,this._changeDetectorRef.markForCheck())}setInactiveStyles(){this._active&&(this._active=!1,this._changeDetectorRef.markForCheck())}getLabel(){return this.viewValue}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!Or(e)&&(this._selectViaInteraction(),e.preventDefault())}_selectViaInteraction(){this.disabled||(this._selected=!this.multiple||!this._selected,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent(!0))}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._element.nativeElement}ngAfterViewChecked(){if(this._selected){let e=this.viewValue;e!==this._mostRecentViewValue&&(this._mostRecentViewValue&&this._stateChanges.next(),this._mostRecentViewValue=e)}}ngOnDestroy(){this._stateChanges.complete()}_emitSelectionChangeEvent(e=!1){this.onSelectionChange.emit(new zv(this,e))}}return n.\u0275fac=function(e){cs()},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&Ue(D_e,7),2&e){let r;be(r=ve())&&(i._text=r.first)}},inputs:{value:"value",id:"id",disabled:"disabled"},outputs:{onSelectionChange:"onSelectionChange"}}),n})(),ja=(()=>{class n extends U_e{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(Uv,8),C(jv,8))},n.\u0275cmp=P({type:n,selectors:[["mat-option"]],hostAttrs:["role","option",1,"mat-mdc-option","mdc-list-item"],hostVars:11,hostBindings:function(e,i){1&e&&A("click",function(){return i._selectViaInteraction()})("keydown",function(o){return i._handleKeydown(o)}),2&e&&(wo("id",i.id),Be("aria-selected",i.selected)("aria-disabled",i.disabled.toString()),nt("mdc-list-item--selected",i.selected)("mat-mdc-option-multiple",i.multiple)("mat-mdc-option-active",i.active)("mdc-list-item--disabled",i.disabled))},exportAs:["matOption"],features:[Xe],ngContentSelectors:k_e,decls:8,vars:5,consts:[["class","mat-mdc-option-pseudo-checkbox",3,"state","disabled",4,"ngIf"],[1,"mdc-list-item__primary-text"],["text",""],["class","mat-mdc-option-pseudo-checkbox","state","checked","appearance","minimal",3,"disabled",4,"ngIf"],["class","cdk-visually-hidden",4,"ngIf"],["mat-ripple","",1,"mat-mdc-option-ripple","mat-mdc-focus-indicator",3,"matRippleTrigger","matRippleDisabled"],[1,"mat-mdc-option-pseudo-checkbox",3,"state","disabled"],["state","checked","appearance","minimal",1,"mat-mdc-option-pseudo-checkbox",3,"disabled"],[1,"cdk-visually-hidden"]],template:function(e,i){1&e&&(fn(P_e),S(0,I_e,1,2,"mat-pseudo-checkbox",0),Tt(1),f(2,"span",1,2),Tt(4,1),g(),S(5,A_e,1,1,"mat-pseudo-checkbox",3),S(6,R_e,2,1,"span",4),k(7,"div",5)),2&e&&(b("ngIf",i.multiple),v(5),b("ngIf",!i.multiple&&i.selected&&!i.hideSingleSelectionIndicator),v(1),b("ngIf",i.group&&i.group._inert),v(1),b("matRippleTrigger",i._getHostElement())("matRippleDisabled",i.disabled||i.disableRipple))},dependencies:[Ki,Ne,V_e],styles:['.mat-mdc-option{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);min-height:48px}.mat-mdc-option:focus{outline:none}[dir=rtl] .mat-mdc-option,.mat-mdc-option[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-option.mdc-list-item{align-items:center}.mat-mdc-option.mdc-list-item--disabled{opacity:.38;cursor:default}.mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:32px}[dir=rtl] .mat-mdc-optgroup .mat-mdc-option:not(.mat-mdc-option-multiple){padding-left:16px;padding-right:32px}.mat-mdc-option .mat-icon,.mat-mdc-option .mat-pseudo-checkbox-full{margin-right:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-icon,[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-full{margin-right:0;margin-left:16px}.mat-mdc-option .mat-pseudo-checkbox-minimal{margin-left:16px;flex-shrink:0}[dir=rtl] .mat-mdc-option .mat-pseudo-checkbox-minimal{margin-right:16px;margin-left:0}.mat-mdc-option .mat-mdc-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;font-size:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;font-family:inherit;text-decoration:inherit;text-transform:inherit;margin-right:auto}[dir=rtl] .mat-mdc-option .mdc-list-item__primary-text{margin-right:0;margin-left:auto}.cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{content:"";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-mdc-option.mdc-list-item--selected:not(.mat-mdc-option-multiple)::after{right:auto;left:16px}.mat-mdc-option-active .mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})();function z1(n,t,e){if(e.length){let i=t.toArray(),r=e.toArray(),o=0;for(let a=0;a<n+1;a++)i[a].group&&i[a].group===r[o]&&o++;return o}return 0}function U1(n,t,e,i){return n<e?n:n+t>e+i?Math.max(0,n-i+t):e}var mg=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[_a,De,dn,H_e]}),n})(),B7=["mat-button",""],g2=[[["",8,"material-icons",3,"iconPositionEnd",""],["mat-icon",3,"iconPositionEnd",""],["","matButtonIcon","",3,"iconPositionEnd",""]],"*",[["","iconPositionEnd","",8,"material-icons"],["mat-icon","iconPositionEnd",""],["","matButtonIcon","","iconPositionEnd",""]]],_2=[".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])","*",".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"],b2=".cdk-high-contrast-active .mat-mdc-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-unelevated-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-raised-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-outlined-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-icon-button{outline:solid 1px}",V7=["mat-icon-button",""],G_e=["*"],q_e=[{selector:"mat-button",mdcClasses:["mdc-button","mat-mdc-button"]},{selector:"mat-flat-button",mdcClasses:["mdc-button","mdc-button--unelevated","mat-mdc-unelevated-button"]},{selector:"mat-raised-button",mdcClasses:["mdc-button","mdc-button--raised","mat-mdc-raised-button"]},{selector:"mat-stroked-button",mdcClasses:["mdc-button","mdc-button--outlined","mat-mdc-outlined-button"]},{selector:"mat-fab",mdcClasses:["mdc-fab","mat-mdc-fab"]},{selector:"mat-mini-fab",mdcClasses:["mdc-fab","mdc-fab--mini","mat-mdc-mini-fab"]},{selector:"mat-icon-button",mdcClasses:["mdc-icon-button","mat-mdc-icon-button"]}],X_e=Ko(ao(go(class{constructor(n){this._elementRef=n}}))),v2=(()=>{class n extends X_e{constructor(e,i,r,o){super(e),this._platform=i,this._ngZone=r,this._animationMode=o,this._focusMonitor=$n(fo),this._isFab=!1;let a=e.nativeElement.classList;for(let s of q_e)this._hasHostAttributes(s.selector)&&s.mdcClasses.forEach(l=>{a.add(l)})}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}focus(e="program",i){e?this._focusMonitor.focusVia(this._elementRef.nativeElement,e,i):this._elementRef.nativeElement.focus(i)}_hasHostAttributes(...e){return e.some(i=>this._elementRef.nativeElement.hasAttribute(i))}_isRippleDisabled(){return this.disableRipple||this.disabled}}return n.\u0275fac=function(e){cs()},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&Ue(Ki,5),2&e){let r;be(r=ve())&&(i.ripple=r.first)}},features:[Xe]}),n})(),H7=(()=>{class n extends v2{constructor(e,i,r,o){super(e,i,r,o),this._haltDisabledEvents=a=>{this.disabled&&(a.preventDefault(),a.stopImmediatePropagation())}}ngOnInit(){this._ngZone.runOutsideAngular(()=>{this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)})}ngOnDestroy(){super.ngOnDestroy(),this._elementRef.nativeElement.removeEventListener("click",this._haltDisabledEvents)}}return n.\u0275fac=function(e){cs()},n.\u0275dir=Me({type:n,features:[Xe]}),n})(),ki=(()=>{class n extends v2{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(ot),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["button","mat-button",""],["button","mat-raised-button",""],["button","mat-flat-button",""],["button","mat-stroked-button",""]],hostVars:7,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[Xe],attrs:B7,ngContentSelectors:_2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(fn(g2),k(0,"span",0),Tt(1),f(2,"span",1),Tt(3,1),g(),Tt(4,2),k(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),b("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[Ki],styles:['.mdc-touch-target-wrapper{display:inline}.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button{position:relative;display:inline-flex;align-items:center;justify-content:center;box-sizing:border-box;min-width:64px;border:none;outline:none;line-height:inherit;user-select:none;-webkit-appearance:none;overflow:visible;vertical-align:middle;background:rgba(0,0,0,0)}.mdc-button .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-button::-moz-focus-inner{padding:0;border:0}.mdc-button:active{outline:none}.mdc-button:hover{cursor:pointer}.mdc-button:disabled{cursor:default;pointer-events:none}.mdc-button[hidden]{display:none}.mdc-button .mdc-button__icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top}[dir=rtl] .mdc-button .mdc-button__icon,.mdc-button .mdc-button__icon[dir=rtl]{margin-left:8px;margin-right:0}.mdc-button .mdc-button__progress-indicator{font-size:0;position:absolute;transform:translate(-50%, -50%);top:50%;left:50%;line-height:initial}.mdc-button .mdc-button__label{position:relative}.mdc-button .mdc-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(\n      100% + 4px\n    );width:calc(\n      100% + 4px\n    );display:none}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring{border-color:CanvasText}}.mdc-button .mdc-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring::after{border-color:CanvasText}}@media screen and (forced-colors: active){.mdc-button.mdc-ripple-upgraded--background-focused .mdc-button__focus-ring,.mdc-button:not(.mdc-ripple-upgraded):focus .mdc-button__focus-ring{display:block}}.mdc-button .mdc-button__touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-button__label+.mdc-button__icon{margin-left:8px;margin-right:0}[dir=rtl] .mdc-button__label+.mdc-button__icon,.mdc-button__label+.mdc-button__icon[dir=rtl]{margin-left:0;margin-right:8px}svg.mdc-button__icon{fill:currentColor}.mdc-button--touch{margin-top:6px;margin-bottom:6px}.mdc-button{padding:0 8px 0 8px}.mdc-button--unelevated{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--unelevated.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--unelevated.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--raised{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--raised.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--raised.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--outlined{border-style:solid;transition:border 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button--outlined .mdc-button__ripple{border-style:solid;border-color:rgba(0,0,0,0)}.mat-mdc-button{height:var(--mdc-text-button-container-height, 36px);border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-button:not(:disabled){color:var(--mdc-text-button-label-text-color, inherit)}.mat-mdc-button:disabled{color:var(--mdc-text-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-button .mdc-button__ripple{border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button{height:var(--mdc-filled-button-container-height, 36px);border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button:not(:disabled){background-color:var(--mdc-filled-button-container-color, transparent)}.mat-mdc-unelevated-button:disabled{background-color:var(--mdc-filled-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-unelevated-button:not(:disabled){color:var(--mdc-filled-button-label-text-color, inherit)}.mat-mdc-unelevated-button:disabled{color:var(--mdc-filled-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-unelevated-button .mdc-button__ripple{border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button{height:var(--mdc-protected-button-container-height, 36px);border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px));box-shadow:var(--mdc-protected-button-container-elevation, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){background-color:var(--mdc-protected-button-container-color, transparent)}.mat-mdc-raised-button:disabled{background-color:var(--mdc-protected-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){color:var(--mdc-protected-button-label-text-color, inherit)}.mat-mdc-raised-button:disabled{color:var(--mdc-protected-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-raised-button .mdc-button__ripple{border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button.mdc-ripple-upgraded--background-focused,.mat-mdc-raised-button:not(.mdc-ripple-upgraded):focus{box-shadow:var(--mdc-protected-button-focus-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:hover{box-shadow:var(--mdc-protected-button-hover-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled):active{box-shadow:var(--mdc-protected-button-pressed-container-elevation, 0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:disabled{box-shadow:var(--mdc-protected-button-disabled-container-elevation, 0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button{height:var(--mdc-outlined-button-container-height, 36px);border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px));padding:0 15px 0 15px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button:not(:disabled){color:var(--mdc-outlined-button-label-text-color, inherit)}.mat-mdc-outlined-button:disabled{color:var(--mdc-outlined-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-outlined-button .mdc-button__ripple{border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-outlined-button:not(:disabled){border-color:var(--mdc-outlined-button-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button:disabled{border-color:var(--mdc-outlined-button-disabled-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button.mdc-button--icon-trailing{padding:0 11px 0 15px}.mat-mdc-outlined-button.mdc-button--icon-leading{padding:0 15px 0 11px}.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button .mdc-button__touch{left:calc(-1 * var(--mdc-outlined-button-outline-width, 1px));width:calc(100% + 2 * var(--mdc-outlined-button-outline-width, 1px))}.mat-mdc-button,.mat-mdc-unelevated-button,.mat-mdc-raised-button,.mat-mdc-outlined-button{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-button .mat-mdc-button-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-button .mat-ripple-element,.mat-mdc-unelevated-button .mat-ripple-element,.mat-mdc-raised-button .mat-ripple-element,.mat-mdc-outlined-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-button .mdc-button__label,.mat-mdc-unelevated-button .mdc-button__label,.mat-mdc-raised-button .mdc-button__label,.mat-mdc-outlined-button .mdc-button__label{z-index:1}.mat-mdc-button .mat-mdc-focus-indicator,.mat-mdc-unelevated-button .mat-mdc-focus-indicator,.mat-mdc-raised-button .mat-mdc-focus-indicator,.mat-mdc-outlined-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-unelevated-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-raised-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-outlined-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-button[disabled],.mat-mdc-unelevated-button[disabled],.mat-mdc-raised-button[disabled],.mat-mdc-outlined-button[disabled]{cursor:default;pointer-events:none}.mat-mdc-button .mat-mdc-button-touch-target,.mat-mdc-unelevated-button .mat-mdc-button-touch-target,.mat-mdc-raised-button .mat-mdc-button-touch-target,.mat-mdc-outlined-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mat-mdc-button._mat-animation-noopable,.mat-mdc-unelevated-button._mat-animation-noopable,.mat-mdc-raised-button._mat-animation-noopable,.mat-mdc-outlined-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem}[dir=rtl] .mat-mdc-button>.mat-icon,.mat-mdc-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}.mat-mdc-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-button .mdc-button__label+.mat-icon,.mat-mdc-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-unelevated-button>.mat-icon,.mat-mdc-raised-button>.mat-icon,.mat-mdc-outlined-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem;margin-left:-4px;margin-right:8px}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:-4px}.mat-mdc-unelevated-button .mdc-button__label+.mat-icon,.mat-mdc-raised-button .mdc-button__label+.mat-icon,.mat-mdc-outlined-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:-4px}[dir=rtl] .mat-mdc-unelevated-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-raised-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-outlined-button .mdc-button__label+.mat-icon,.mat-mdc-unelevated-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-raised-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-outlined-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:-4px;margin-right:8px}.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:-1px}.mat-mdc-unelevated-button .mat-mdc-focus-indicator::before,.mat-mdc-raised-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-outlined-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 3px) * -1)}',".cdk-high-contrast-active .mat-mdc-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-unelevated-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-raised-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-outlined-button:not(.mdc-button--outlined),.cdk-high-contrast-active .mat-mdc-icon-button{outline:solid 1px}"],encapsulation:2,changeDetection:0}),n})(),z7=(()=>{class n extends H7{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(ot),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["a","mat-button",""],["a","mat-raised-button",""],["a","mat-flat-button",""],["a","mat-stroked-button",""]],hostVars:9,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null)("tabindex",i.disabled?-1:i.tabIndex)("aria-disabled",i.disabled.toString()),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[Xe],attrs:B7,ngContentSelectors:_2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(fn(g2),k(0,"span",0),Tt(1),f(2,"span",1),Tt(3,1),g(),Tt(4,2),k(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),b("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[Ki],styles:['.mdc-touch-target-wrapper{display:inline}.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button{position:relative;display:inline-flex;align-items:center;justify-content:center;box-sizing:border-box;min-width:64px;border:none;outline:none;line-height:inherit;user-select:none;-webkit-appearance:none;overflow:visible;vertical-align:middle;background:rgba(0,0,0,0)}.mdc-button .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-button::-moz-focus-inner{padding:0;border:0}.mdc-button:active{outline:none}.mdc-button:hover{cursor:pointer}.mdc-button:disabled{cursor:default;pointer-events:none}.mdc-button[hidden]{display:none}.mdc-button .mdc-button__icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top}[dir=rtl] .mdc-button .mdc-button__icon,.mdc-button .mdc-button__icon[dir=rtl]{margin-left:8px;margin-right:0}.mdc-button .mdc-button__progress-indicator{font-size:0;position:absolute;transform:translate(-50%, -50%);top:50%;left:50%;line-height:initial}.mdc-button .mdc-button__label{position:relative}.mdc-button .mdc-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(\n      100% + 4px\n    );width:calc(\n      100% + 4px\n    );display:none}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring{border-color:CanvasText}}.mdc-button .mdc-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-button .mdc-button__focus-ring::after{border-color:CanvasText}}@media screen and (forced-colors: active){.mdc-button.mdc-ripple-upgraded--background-focused .mdc-button__focus-ring,.mdc-button:not(.mdc-ripple-upgraded):focus .mdc-button__focus-ring{display:block}}.mdc-button .mdc-button__touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-button__label+.mdc-button__icon{margin-left:8px;margin-right:0}[dir=rtl] .mdc-button__label+.mdc-button__icon,.mdc-button__label+.mdc-button__icon[dir=rtl]{margin-left:0;margin-right:8px}svg.mdc-button__icon{fill:currentColor}.mdc-button--touch{margin-top:6px;margin-bottom:6px}.mdc-button{padding:0 8px 0 8px}.mdc-button--unelevated{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--unelevated.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--unelevated.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--raised{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);padding:0 16px 0 16px}.mdc-button--raised.mdc-button--icon-trailing{padding:0 12px 0 16px}.mdc-button--raised.mdc-button--icon-leading{padding:0 16px 0 12px}.mdc-button--outlined{border-style:solid;transition:border 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-button--outlined .mdc-button__ripple{border-style:solid;border-color:rgba(0,0,0,0)}.mat-mdc-button{height:var(--mdc-text-button-container-height, 36px);border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-button:not(:disabled){color:var(--mdc-text-button-label-text-color, inherit)}.mat-mdc-button:disabled{color:var(--mdc-text-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-button .mdc-button__ripple{border-radius:var(--mdc-text-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button{height:var(--mdc-filled-button-container-height, 36px);border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-unelevated-button:not(:disabled){background-color:var(--mdc-filled-button-container-color, transparent)}.mat-mdc-unelevated-button:disabled{background-color:var(--mdc-filled-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-unelevated-button:not(:disabled){color:var(--mdc-filled-button-label-text-color, inherit)}.mat-mdc-unelevated-button:disabled{color:var(--mdc-filled-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-unelevated-button .mdc-button__ripple{border-radius:var(--mdc-filled-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button{height:var(--mdc-protected-button-container-height, 36px);border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px));box-shadow:var(--mdc-protected-button-container-elevation, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){background-color:var(--mdc-protected-button-container-color, transparent)}.mat-mdc-raised-button:disabled{background-color:var(--mdc-protected-button-disabled-container-color, rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled){color:var(--mdc-protected-button-label-text-color, inherit)}.mat-mdc-raised-button:disabled{color:var(--mdc-protected-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-raised-button .mdc-button__ripple{border-radius:var(--mdc-protected-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-raised-button.mdc-ripple-upgraded--background-focused,.mat-mdc-raised-button:not(.mdc-ripple-upgraded):focus{box-shadow:var(--mdc-protected-button-focus-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:hover{box-shadow:var(--mdc-protected-button-hover-container-elevation, 0px 2px 4px -1px rgba(0, 0, 0, 0.2), 0px 4px 5px 0px rgba(0, 0, 0, 0.14), 0px 1px 10px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:not(:disabled):active{box-shadow:var(--mdc-protected-button-pressed-container-elevation, 0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14), 0px 3px 14px 2px rgba(0, 0, 0, 0.12))}.mat-mdc-raised-button:disabled{box-shadow:var(--mdc-protected-button-disabled-container-elevation, 0px 0px 0px 0px rgba(0, 0, 0, 0.2), 0px 0px 0px 0px rgba(0, 0, 0, 0.14), 0px 0px 0px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button{height:var(--mdc-outlined-button-container-height, 36px);border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px));padding:0 15px 0 15px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button:not(:disabled){color:var(--mdc-outlined-button-label-text-color, inherit)}.mat-mdc-outlined-button:disabled{color:var(--mdc-outlined-button-disabled-label-text-color, rgba(0, 0, 0, 0.38))}.mat-mdc-outlined-button .mdc-button__ripple{border-radius:var(--mdc-outlined-button-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-outlined-button:not(:disabled){border-color:var(--mdc-outlined-button-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button:disabled{border-color:var(--mdc-outlined-button-disabled-outline-color, rgba(0, 0, 0, 0.12))}.mat-mdc-outlined-button.mdc-button--icon-trailing{padding:0 11px 0 15px}.mat-mdc-outlined-button.mdc-button--icon-leading{padding:0 15px 0 11px}.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:var(--mdc-outlined-button-outline-width, 1px)}.mat-mdc-outlined-button .mdc-button__touch{left:calc(-1 * var(--mdc-outlined-button-outline-width, 1px));width:calc(100% + 2 * var(--mdc-outlined-button-outline-width, 1px))}.mat-mdc-button,.mat-mdc-unelevated-button,.mat-mdc-raised-button,.mat-mdc-outlined-button{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-button .mat-mdc-button-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple,.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-unelevated-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-raised-button .mat-mdc-button-persistent-ripple::before,.mat-mdc-outlined-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-button .mat-ripple-element,.mat-mdc-unelevated-button .mat-ripple-element,.mat-mdc-raised-button .mat-ripple-element,.mat-mdc-outlined-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-button .mdc-button__label,.mat-mdc-unelevated-button .mdc-button__label,.mat-mdc-raised-button .mdc-button__label,.mat-mdc-outlined-button .mdc-button__label{z-index:1}.mat-mdc-button .mat-mdc-focus-indicator,.mat-mdc-unelevated-button .mat-mdc-focus-indicator,.mat-mdc-raised-button .mat-mdc-focus-indicator,.mat-mdc-outlined-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-unelevated-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-raised-button:focus .mat-mdc-focus-indicator::before,.mat-mdc-outlined-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-button[disabled],.mat-mdc-unelevated-button[disabled],.mat-mdc-raised-button[disabled],.mat-mdc-outlined-button[disabled]{cursor:default;pointer-events:none}.mat-mdc-button .mat-mdc-button-touch-target,.mat-mdc-unelevated-button .mat-mdc-button-touch-target,.mat-mdc-raised-button .mat-mdc-button-touch-target,.mat-mdc-outlined-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mat-mdc-button._mat-animation-noopable,.mat-mdc-unelevated-button._mat-animation-noopable,.mat-mdc-raised-button._mat-animation-noopable,.mat-mdc-outlined-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem}[dir=rtl] .mat-mdc-button>.mat-icon,.mat-mdc-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}.mat-mdc-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-button .mdc-button__label+.mat-icon,.mat-mdc-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-unelevated-button>.mat-icon,.mat-mdc-raised-button>.mat-icon,.mat-mdc-outlined-button>.mat-icon{margin-left:0;margin-right:8px;display:inline-block;position:relative;vertical-align:top;font-size:1.125rem;height:1.125rem;width:1.125rem;margin-left:-4px;margin-right:8px}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:0}[dir=rtl] .mat-mdc-unelevated-button>.mat-icon,[dir=rtl] .mat-mdc-raised-button>.mat-icon,[dir=rtl] .mat-mdc-outlined-button>.mat-icon,.mat-mdc-unelevated-button>.mat-icon[dir=rtl],.mat-mdc-raised-button>.mat-icon[dir=rtl],.mat-mdc-outlined-button>.mat-icon[dir=rtl]{margin-left:8px;margin-right:-4px}.mat-mdc-unelevated-button .mdc-button__label+.mat-icon,.mat-mdc-raised-button .mdc-button__label+.mat-icon,.mat-mdc-outlined-button .mdc-button__label+.mat-icon{margin-left:8px;margin-right:-4px}[dir=rtl] .mat-mdc-unelevated-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-raised-button .mdc-button__label+.mat-icon,[dir=rtl] .mat-mdc-outlined-button .mdc-button__label+.mat-icon,.mat-mdc-unelevated-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-raised-button .mdc-button__label+.mat-icon[dir=rtl],.mat-mdc-outlined-button .mdc-button__label+.mat-icon[dir=rtl]{margin-left:-4px;margin-right:8px}.mat-mdc-outlined-button .mat-mdc-button-ripple,.mat-mdc-outlined-button .mdc-button__ripple{top:-1px;left:-1px;bottom:-1px;right:-1px;border-width:-1px}.mat-mdc-unelevated-button .mat-mdc-focus-indicator::before,.mat-mdc-raised-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-outlined-button .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 3px) * -1)}',b2],encapsulation:2,changeDetection:0}),n})();new te("mat-mdc-fab-default-options",{providedIn:"root",factory:function(){return{color:"accent"}}});var Er=(()=>{class n extends v2{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(ot),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["button","mat-icon-button",""]],hostVars:7,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[Xe],attrs:V7,ngContentSelectors:G_e,decls:5,vars:3,consts:[[1,"mat-mdc-button-persistent-ripple","mdc-icon-button__ripple"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(fn(),k(0,"span",0),Tt(1),k(2,"span",1)(3,"span",2)(4,"span",3)),2&e&&(v(3),b("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",!0)("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[Ki],styles:['.mdc-icon-button{font-size:24px;width:48px;height:48px;padding:12px}.mdc-icon-button .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mdc-icon-button svg,.mdc-icon-button img{width:24px;height:24px}.mdc-icon-button{display:inline-block;position:relative;box-sizing:border-box;border:none;outline:none;background-color:rgba(0,0,0,0);fill:currentColor;color:inherit;text-decoration:none;cursor:pointer;user-select:none;z-index:0;overflow:visible}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}@media screen and (forced-colors: active){.mdc-icon-button.mdc-ripple-upgraded--background-focused .mdc-icon-button__focus-ring,.mdc-icon-button:not(.mdc-ripple-upgraded):focus .mdc-icon-button__focus-ring{display:block}}.mdc-icon-button:disabled{cursor:default;pointer-events:none}.mdc-icon-button[hidden]{display:none}.mdc-icon-button--display-flex{align-items:center;display:inline-flex;justify-content:center}.mdc-icon-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%;display:none}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring{border-color:CanvasText}}.mdc-icon-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring::after{border-color:CanvasText}}.mdc-icon-button__icon{display:inline-block}.mdc-icon-button__icon.mdc-icon-button__icon--on{display:none}.mdc-icon-button--on .mdc-icon-button__icon{display:none}.mdc-icon-button--on .mdc-icon-button__icon.mdc-icon-button__icon--on{display:inline-block}.mdc-icon-button__link{height:100%;left:0;outline:none;position:absolute;top:0;width:100%}.mat-mdc-icon-button{height:var(--mdc-icon-button-state-layer-size, 48px);width:var(--mdc-icon-button-state-layer-size, 48px);color:var(--mdc-icon-button-icon-color, inherit);border-radius:50%;flex-shrink:0;text-align:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-icon-button .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button svg,.mat-mdc-icon-button img{width:var(--mdc-icon-button-icon-size, 24px);height:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button:disabled{opacity:var(--mdc-icon-button-disabled-icon-opacity, 0.38)}.mat-mdc-icon-button:disabled{color:var(--mdc-icon-button-disabled-icon-color, #000)}.mat-mdc-icon-button svg{vertical-align:baseline}.mat-mdc-icon-button[disabled]{cursor:default;pointer-events:none;opacity:1}.mat-mdc-icon-button .mat-mdc-button-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-icon-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-icon-button .mdc-button__label{z-index:1}.mat-mdc-icon-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-icon-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-icon-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-icon-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple{border-radius:50%}.mat-mdc-icon-button.mat-unthemed:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-primary:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-accent:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-warn:not(.mdc-ripple-upgraded):focus::before{background:rgba(0,0,0,0);opacity:1}',b2],encapsulation:2,changeDetection:0}),n})(),j7=(()=>{class n extends H7{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(ot),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["a","mat-icon-button",""]],hostVars:9,hostBindings:function(e,i){2&e&&(Be("disabled",i.disabled||null)("tabindex",i.disabled?-1:i.tabIndex)("aria-disabled",i.disabled.toString()),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-unthemed",!i.color)("mat-mdc-button-base",!0))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[Xe],attrs:V7,ngContentSelectors:_2,decls:8,vars:6,consts:[[1,"mat-mdc-button-persistent-ripple"],[1,"mdc-button__label"],[1,"mat-mdc-focus-indicator"],["matRipple","",1,"mat-mdc-button-ripple",3,"matRippleDisabled","matRippleTrigger"],[1,"mat-mdc-button-touch-target"]],template:function(e,i){1&e&&(fn(g2),k(0,"span",0),Tt(1),f(2,"span",1),Tt(3,1),g(),Tt(4,2),k(5,"span",2)(6,"span",3)(7,"span",4)),2&e&&(nt("mdc-button__ripple",!i._isFab)("mdc-fab__ripple",i._isFab),v(6),b("matRippleDisabled",i._isRippleDisabled())("matRippleTrigger",i._elementRef.nativeElement))},dependencies:[Ki],styles:['.mdc-icon-button{font-size:24px;width:48px;height:48px;padding:12px}.mdc-icon-button .mdc-icon-button__focus-ring{max-height:48px;max-width:48px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__ripple{width:40px;height:40px;margin-top:4px;margin-bottom:4px;margin-right:4px;margin-left:4px}.mdc-icon-button.mdc-icon-button--reduced-size .mdc-icon-button__focus-ring{max-height:40px;max-width:40px}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mdc-icon-button svg,.mdc-icon-button img{width:24px;height:24px}.mdc-icon-button{display:inline-block;position:relative;box-sizing:border-box;border:none;outline:none;background-color:rgba(0,0,0,0);fill:currentColor;color:inherit;text-decoration:none;cursor:pointer;user-select:none;z-index:0;overflow:visible}.mdc-icon-button .mdc-icon-button__touch{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}@media screen and (forced-colors: active){.mdc-icon-button.mdc-ripple-upgraded--background-focused .mdc-icon-button__focus-ring,.mdc-icon-button:not(.mdc-ripple-upgraded):focus .mdc-icon-button__focus-ring{display:block}}.mdc-icon-button:disabled{cursor:default;pointer-events:none}.mdc-icon-button[hidden]{display:none}.mdc-icon-button--display-flex{align-items:center;display:inline-flex;justify-content:center}.mdc-icon-button__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%;display:none}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring{border-color:CanvasText}}.mdc-icon-button__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-icon-button__focus-ring::after{border-color:CanvasText}}.mdc-icon-button__icon{display:inline-block}.mdc-icon-button__icon.mdc-icon-button__icon--on{display:none}.mdc-icon-button--on .mdc-icon-button__icon{display:none}.mdc-icon-button--on .mdc-icon-button__icon.mdc-icon-button__icon--on{display:inline-block}.mdc-icon-button__link{height:100%;left:0;outline:none;position:absolute;top:0;width:100%}.mat-mdc-icon-button{height:var(--mdc-icon-button-state-layer-size, 48px);width:var(--mdc-icon-button-state-layer-size, 48px);color:var(--mdc-icon-button-icon-color, inherit);border-radius:50%;flex-shrink:0;text-align:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-icon-button .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button svg,.mat-mdc-icon-button img{width:var(--mdc-icon-button-icon-size, 24px);height:var(--mdc-icon-button-icon-size, 24px)}.mat-mdc-icon-button:disabled{opacity:var(--mdc-icon-button-disabled-icon-opacity, 0.38)}.mat-mdc-icon-button:disabled{color:var(--mdc-icon-button-disabled-icon-color, #000)}.mat-mdc-icon-button svg{vertical-align:baseline}.mat-mdc-icon-button[disabled]{cursor:default;pointer-events:none;opacity:1}.mat-mdc-icon-button .mat-mdc-button-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple,.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple::before{content:"";opacity:0;background-color:var(--mat-mdc-button-persistent-ripple-color)}.mat-mdc-icon-button .mat-ripple-element{background-color:var(--mat-mdc-button-ripple-color)}.mat-mdc-icon-button .mdc-button__label{z-index:1}.mat-mdc-icon-button .mat-mdc-focus-indicator{top:0;left:0;right:0;bottom:0;position:absolute}.mat-mdc-icon-button:focus .mat-mdc-focus-indicator::before{content:""}.mat-mdc-icon-button .mat-mdc-button-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-icon-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mdc-icon-button .mat-mdc-button-persistent-ripple{border-radius:50%}.mat-mdc-icon-button.mat-unthemed:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-primary:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-accent:not(.mdc-ripple-upgraded):focus::before,.mat-mdc-icon-button.mat-warn:not(.mdc-ripple-upgraded):focus::before{background:rgba(0,0,0,0);opacity:1}',b2],encapsulation:2,changeDetection:0}),n})(),Kn=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,_a,dn]}),n})(),Gv=class{attach(t){return this._attachedHost=t,t.attach(this)}detach(){let t=this._attachedHost;null!=t&&(this._attachedHost=null,t.detach())}get isAttached(){return null!=this._attachedHost}setAttachedHost(t){this._attachedHost=t}},Ll=class extends Gv{constructor(t,e,i,r,o){super(),this.component=t,this.viewContainerRef=e,this.injector=i,this.componentFactoryResolver=r,this.projectableNodes=o}},To=class extends Gv{constructor(t,e,i,r){super(),this.templateRef=t,this.viewContainerRef=e,this.context=i,this.injector=r}get origin(){return this.templateRef.elementRef}attach(t,e=this.context){return this.context=e,super.attach(t)}detach(){return this.context=void 0,super.detach()}},y2=class extends Gv{constructor(t){super(),this.element=t instanceof xe?t.nativeElement:t}},Nu=class{constructor(){this._isDisposed=!1,this.attachDomPortal=null}hasAttached(){return!!this._attachedPortal}attach(t){return t instanceof Ll?(this._attachedPortal=t,this.attachComponentPortal(t)):t instanceof To?(this._attachedPortal=t,this.attachTemplatePortal(t)):this.attachDomPortal&&t instanceof y2?(this._attachedPortal=t,this.attachDomPortal(t)):void 0}detach(){this._attachedPortal&&(this._attachedPortal.setAttachedHost(null),this._attachedPortal=null),this._invokeDisposeFn()}dispose(){this.hasAttached()&&this.detach(),this._invokeDisposeFn(),this._isDisposed=!0}setDisposeFn(t){this._disposeFn=t}_invokeDisposeFn(){this._disposeFn&&(this._disposeFn(),this._disposeFn=null)}},Wv=class extends Nu{constructor(t,e,i,r,o){super(),this.outletElement=t,this._componentFactoryResolver=e,this._appRef=i,this._defaultInjector=r,this.attachDomPortal=a=>{let s=a.element,l=this._document.createComment("dom-portal");s.parentNode.insertBefore(l,s),this.outletElement.appendChild(s),this._attachedPortal=a,super.setDisposeFn(()=>{l.parentNode&&l.parentNode.replaceChild(s,l)})},this._document=o}attachComponentPortal(t){let r,i=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component);return t.viewContainerRef?(r=t.viewContainerRef.createComponent(i,t.viewContainerRef.length,t.injector||t.viewContainerRef.injector,t.projectableNodes||void 0),this.setDisposeFn(()=>r.destroy())):(r=i.create(t.injector||this._defaultInjector||wi.NULL),this._appRef.attachView(r.hostView),this.setDisposeFn(()=>{this._appRef.viewCount>0&&this._appRef.detachView(r.hostView),r.destroy()})),this.outletElement.appendChild(this._getComponentRootNode(r)),this._attachedPortal=t,r}attachTemplatePortal(t){let e=t.viewContainerRef,i=e.createEmbeddedView(t.templateRef,t.context,{injector:t.injector});return i.rootNodes.forEach(r=>this.outletElement.appendChild(r)),i.detectChanges(),this.setDisposeFn(()=>{let r=e.indexOf(i);-1!==r&&e.remove(r)}),this._attachedPortal=t,i}dispose(){super.dispose(),this.outletElement.remove()}_getComponentRootNode(t){return t.hostView.rootNodes[0]}},G7=(()=>{class n extends To{constructor(e,i){super(e,i)}}return n.\u0275fac=function(e){return new(e||n)(C(oi),C(ei))},n.\u0275dir=Me({type:n,selectors:[["","cdkPortal",""]],exportAs:["cdkPortal"],features:[Xe]}),n})(),ba=(()=>{class n extends Nu{constructor(e,i,r){super(),this._componentFactoryResolver=e,this._viewContainerRef=i,this._isInitialized=!1,this.attached=new F,this.attachDomPortal=o=>{let a=o.element,s=this._document.createComment("dom-portal");o.setAttachedHost(this),a.parentNode.insertBefore(s,a),this._getRootNode().appendChild(a),this._attachedPortal=o,super.setDisposeFn(()=>{s.parentNode&&s.parentNode.replaceChild(a,s)})},this._document=r}get portal(){return this._attachedPortal}set portal(e){this.hasAttached()&&!e&&!this._isInitialized||(this.hasAttached()&&super.detach(),e&&super.attach(e),this._attachedPortal=e||null)}get attachedRef(){return this._attachedRef}ngOnInit(){this._isInitialized=!0}ngOnDestroy(){super.dispose(),this._attachedRef=this._attachedPortal=null}attachComponentPortal(e){e.setAttachedHost(this);let i=null!=e.viewContainerRef?e.viewContainerRef:this._viewContainerRef,o=(e.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(e.component),a=i.createComponent(o,i.length,e.injector||i.injector,e.projectableNodes||void 0);return i!==this._viewContainerRef&&this._getRootNode().appendChild(a.hostView.rootNodes[0]),super.setDisposeFn(()=>a.destroy()),this._attachedPortal=e,this._attachedRef=a,this.attached.emit(a),a}attachTemplatePortal(e){e.setAttachedHost(this);let i=this._viewContainerRef.createEmbeddedView(e.templateRef,e.context,{injector:e.injector});return super.setDisposeFn(()=>this._viewContainerRef.clear()),this._attachedPortal=e,this._attachedRef=i,this.attached.emit(i),i}_getRootNode(){let e=this._viewContainerRef.element.nativeElement;return e.nodeType===e.ELEMENT_NODE?e:e.parentNode}}return n.\u0275fac=function(e){return new(e||n)(C(ho),C(ei),C(Nt))},n.\u0275dir=Me({type:n,selectors:[["","cdkPortalOutlet",""]],inputs:{portal:["cdkPortalOutlet","portal"]},outputs:{attached:"attached"},exportAs:["cdkPortalOutlet"],features:[Xe]}),n})(),Bl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),x2=class{},G1=class extends x2{constructor(t){super(),this._data=t}connect(){return P_(this._data)?this._data:$t(this._data)}disconnect(){}},W1=class{constructor(){this.viewCacheSize=20,this._viewCache=[]}applyChanges(t,e,i,r,o){t.forEachOperation((a,s,l)=>{let c,d;null==a.previousIndex?(c=this._insertView(()=>i(a,s,l),l,e,r(a)),d=c?1:0):null==l?(this._detachAndCacheView(s,e),d=3):(c=this._moveView(s,l,e,r(a)),d=2),o&&o({context:c?.context,operation:d,record:a})})}detach(){for(let t of this._viewCache)t.destroy();this._viewCache=[]}_insertView(t,e,i,r){let o=this._insertViewFromCache(e,i);if(o)return void(o.context.$implicit=r);let a=t();return i.createEmbeddedView(a.templateRef,a.context,a.index)}_detachAndCacheView(t,e){let i=e.detach(t);this._maybeCacheView(i,e)}_moveView(t,e,i,r){let o=i.get(t);return i.move(o,e),o.context.$implicit=r,o}_maybeCacheView(t,e){if(this._viewCache.length<this.viewCacheSize)this._viewCache.push(t);else{let i=e.indexOf(t);-1===i?t.destroy():e.remove(i)}}_insertViewFromCache(t,e){let i=this._viewCache.pop();return i&&e.insert(i,t),i||null}},fg=class{get selected(){return this._selected||(this._selected=Array.from(this._selection.values())),this._selected}constructor(t=!1,e,i=!0,r){this._multiple=t,this._emitChanges=i,this.compareWith=r,this._selection=new Set,this._deselectedToEmit=[],this._selectedToEmit=[],this.changed=new Ee,e&&e.length&&(t?e.forEach(o=>this._markSelected(o)):this._markSelected(e[0]),this._selectedToEmit.length=0)}select(...t){this._verifyValueAssignment(t),t.forEach(i=>this._markSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}deselect(...t){this._verifyValueAssignment(t),t.forEach(i=>this._unmarkSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}setSelection(...t){this._verifyValueAssignment(t);let e=this.selected,i=new Set(t);t.forEach(o=>this._markSelected(o)),e.filter(o=>!i.has(o)).forEach(o=>this._unmarkSelected(o));let r=this._hasQueuedChanges();return this._emitChangeEvent(),r}toggle(t){return this.isSelected(t)?this.deselect(t):this.select(t)}clear(t=!0){this._unmarkAll();let e=this._hasQueuedChanges();return t&&this._emitChangeEvent(),e}isSelected(t){return this._selection.has(this._getConcreteValue(t))}isEmpty(){return 0===this._selection.size}hasValue(){return!this.isEmpty()}sort(t){this._multiple&&this.selected&&this._selected.sort(t)}isMultipleSelection(){return this._multiple}_emitChangeEvent(){this._selected=null,(this._selectedToEmit.length||this._deselectedToEmit.length)&&(this.changed.next({source:this,added:this._selectedToEmit,removed:this._deselectedToEmit}),this._deselectedToEmit=[],this._selectedToEmit=[])}_markSelected(t){t=this._getConcreteValue(t),this.isSelected(t)||(this._multiple||this._unmarkAll(),this.isSelected(t)||this._selection.add(t),this._emitChanges&&this._selectedToEmit.push(t))}_unmarkSelected(t){t=this._getConcreteValue(t),this.isSelected(t)&&(this._selection.delete(t),this._emitChanges&&this._deselectedToEmit.push(t))}_unmarkAll(){this.isEmpty()||this._selection.forEach(t=>this._unmarkSelected(t))}_verifyValueAssignment(t){}_hasQueuedChanges(){return!(!this._deselectedToEmit.length&&!this._selectedToEmit.length)}_getConcreteValue(t){if(this.compareWith){for(let e of this._selection)if(this.compareWith(t,e))return e;return t}return t}},C2=new te("_ViewRepeater"),Q_e=["contentWrapper"],Z_e=["*"],Y7=new te("VIRTUAL_SCROLL_STRATEGY");function K_e(n){return n._scrollStrategy}var Q7=(()=>{class n{constructor(){this._itemSize=20,this._minBufferPx=100,this._maxBufferPx=200,this._scrollStrategy=new class{constructor(t,e,i){this._scrolledIndexChange=new Ee,this.scrolledIndexChange=this._scrolledIndexChange.pipe(ri()),this._viewport=null,this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i}attach(t){this._viewport=t,this._updateTotalContentSize(),this._updateRenderedRange()}detach(){this._scrolledIndexChange.complete(),this._viewport=null}updateItemAndBufferSize(t,e,i){this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i,this._updateTotalContentSize(),this._updateRenderedRange()}onContentScrolled(){this._updateRenderedRange()}onDataLengthChanged(){this._updateTotalContentSize(),this._updateRenderedRange()}onContentRendered(){}onRenderedOffsetChanged(){}scrollToIndex(t,e){this._viewport&&this._viewport.scrollToOffset(t*this._itemSize,e)}_updateTotalContentSize(){!this._viewport||this._viewport.setTotalContentSize(this._viewport.getDataLength()*this._itemSize)}_updateRenderedRange(){if(!this._viewport)return;let t=this._viewport.getRenderedRange(),e={start:t.start,end:t.end},i=this._viewport.getViewportSize(),r=this._viewport.getDataLength(),o=this._viewport.measureScrollOffset(),a=this._itemSize>0?o/this._itemSize:0;if(e.end>r){let l=Math.ceil(i/this._itemSize),c=Math.max(0,Math.min(a,r-l));a!=c&&(a=c,o=c*this._itemSize,e.start=Math.floor(a)),e.end=Math.max(0,Math.min(r,e.start+l))}let s=o-e.start*this._itemSize;if(s<this._minBufferPx&&0!=e.start){let l=Math.ceil((this._maxBufferPx-s)/this._itemSize);e.start=Math.max(0,e.start-l),e.end=Math.min(r,Math.ceil(a+(i+this._minBufferPx)/this._itemSize))}else{let l=e.end*this._itemSize-(o+i);if(l<this._minBufferPx&&e.end!=r){let c=Math.ceil((this._maxBufferPx-l)/this._itemSize);c>0&&(e.end=Math.min(r,e.end+c),e.start=Math.max(0,Math.floor(a-this._minBufferPx/this._itemSize)))}}this._viewport.setRenderedRange(e),this._viewport.setRenderedContentOffset(this._itemSize*e.start),this._scrolledIndexChange.next(Math.floor(a))}}(this.itemSize,this.minBufferPx,this.maxBufferPx)}get itemSize(){return this._itemSize}set itemSize(e){this._itemSize=mi(e)}get minBufferPx(){return this._minBufferPx}set minBufferPx(e){this._minBufferPx=mi(e)}get maxBufferPx(){return this._maxBufferPx}set maxBufferPx(e){this._maxBufferPx=mi(e)}ngOnChanges(){this._scrollStrategy.updateItemAndBufferSize(this.itemSize,this.minBufferPx,this.maxBufferPx)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["cdk-virtual-scroll-viewport","itemSize",""]],inputs:{itemSize:"itemSize",minBufferPx:"minBufferPx",maxBufferPx:"maxBufferPx"},standalone:!0,features:[Vt([{provide:Y7,useFactory:K_e,deps:[Wn(()=>n)]}]),qt]}),n})(),Lu=(()=>{class n{constructor(e,i,r){this._ngZone=e,this._platform=i,this._scrolled=new Ee,this._globalSubscription=null,this._scrolledCount=0,this.scrollContainers=new Map,this._document=r}register(e){this.scrollContainers.has(e)||this.scrollContainers.set(e,e.elementScrolled().subscribe(()=>this._scrolled.next(e)))}deregister(e){let i=this.scrollContainers.get(e);i&&(i.unsubscribe(),this.scrollContainers.delete(e))}scrolled(e=20){return this._platform.isBrowser?new Kt(i=>{this._globalSubscription||this._addGlobalListener();let r=e>0?this._scrolled.pipe(nc(e)).subscribe(i):this._scrolled.subscribe(i);return this._scrolledCount++,()=>{r.unsubscribe(),this._scrolledCount--,this._scrolledCount||this._removeGlobalListener()}}):$t()}ngOnDestroy(){this._removeGlobalListener(),this.scrollContainers.forEach((e,i)=>this.deregister(i)),this._scrolled.complete()}ancestorScrolled(e,i){let r=this.getAncestorScrollContainers(e);return this.scrolled(i).pipe(Oe(o=>!o||r.indexOf(o)>-1))}getAncestorScrollContainers(e){let i=[];return this.scrollContainers.forEach((r,o)=>{this._scrollableContainsElement(o,e)&&i.push(o)}),i}_getWindow(){return this._document.defaultView||window}_scrollableContainsElement(e,i){let r=Ua(i),o=e.getElementRef().nativeElement;do{if(r==o)return!0}while(r=r.parentElement);return!1}_addGlobalListener(){this._globalSubscription=this._ngZone.runOutsideAngular(()=>Ei(this._getWindow().document,"scroll").subscribe(()=>this._scrolled.next()))}_removeGlobalListener(){this._globalSubscription&&(this._globalSubscription.unsubscribe(),this._globalSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(O(ot),O(Vn),O(Nt,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),xd=(()=>{class n{constructor(e,i,r,o){this.elementRef=e,this.scrollDispatcher=i,this.ngZone=r,this.dir=o,this._destroyed=new Ee,this._elementScrolled=new Kt(a=>this.ngZone.runOutsideAngular(()=>Ei(this.elementRef.nativeElement,"scroll").pipe(it(this._destroyed)).subscribe(a)))}ngOnInit(){this.scrollDispatcher.register(this)}ngOnDestroy(){this.scrollDispatcher.deregister(this),this._destroyed.next(),this._destroyed.complete()}elementScrolled(){return this._elementScrolled}getElementRef(){return this.elementRef}scrollTo(e){let i=this.elementRef.nativeElement,r=this.dir&&"rtl"==this.dir.value;null==e.left&&(e.left=r?e.end:e.start),null==e.right&&(e.right=r?e.start:e.end),null!=e.bottom&&(e.top=i.scrollHeight-i.clientHeight-e.bottom),r&&0!=ig()?(null!=e.left&&(e.right=i.scrollWidth-i.clientWidth-e.left),2==ig()?e.left=e.right:1==ig()&&(e.left=e.right?-e.right:e.right)):null!=e.right&&(e.left=i.scrollWidth-i.clientWidth-e.right),this._applyScrollToOptions(e)}_applyScrollToOptions(e){let i=this.elementRef.nativeElement;k1()?i.scrollTo(e):(null!=e.top&&(i.scrollTop=e.top),null!=e.left&&(i.scrollLeft=e.left))}measureScrollOffset(e){let i="left",r="right",o=this.elementRef.nativeElement;if("top"==e)return o.scrollTop;if("bottom"==e)return o.scrollHeight-o.clientHeight-o.scrollTop;let a=this.dir&&"rtl"==this.dir.value;return"start"==e?e=a?r:i:"end"==e&&(e=a?i:r),a&&2==ig()?e==i?o.scrollWidth-o.clientWidth-o.scrollLeft:o.scrollLeft:a&&1==ig()?e==i?o.scrollLeft+o.scrollWidth-o.clientWidth:-o.scrollLeft:e==i?o.scrollLeft:o.scrollWidth-o.clientWidth-o.scrollLeft}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Lu),C(ot),C(zi,8))},n.\u0275dir=Me({type:n,selectors:[["","cdk-scrollable",""],["","cdkScrollable",""]],standalone:!0}),n})(),Wa=(()=>{class n{constructor(e,i,r){this._platform=e,this._change=new Ee,this._changeListener=o=>{this._change.next(o)},this._document=r,i.runOutsideAngular(()=>{if(e.isBrowser){let o=this._getWindow();o.addEventListener("resize",this._changeListener),o.addEventListener("orientationchange",this._changeListener)}this.change().subscribe(()=>this._viewportSize=null)})}ngOnDestroy(){if(this._platform.isBrowser){let e=this._getWindow();e.removeEventListener("resize",this._changeListener),e.removeEventListener("orientationchange",this._changeListener)}this._change.complete()}getViewportSize(){this._viewportSize||this._updateViewportSize();let e={width:this._viewportSize.width,height:this._viewportSize.height};return this._platform.isBrowser||(this._viewportSize=null),e}getViewportRect(){let e=this.getViewportScrollPosition(),{width:i,height:r}=this.getViewportSize();return{top:e.top,left:e.left,bottom:e.top+r,right:e.left+i,height:r,width:i}}getViewportScrollPosition(){if(!this._platform.isBrowser)return{top:0,left:0};let e=this._document,i=this._getWindow(),r=e.documentElement,o=r.getBoundingClientRect();return{top:-o.top||e.body.scrollTop||i.scrollY||r.scrollTop||0,left:-o.left||e.body.scrollLeft||i.scrollX||r.scrollLeft||0}}change(e=20){return e>0?this._change.pipe(nc(e)):this._change}_getWindow(){return this._document.defaultView||window}_updateViewportSize(){let e=this._getWindow();this._viewportSize=this._platform.isBrowser?{width:e.innerWidth,height:e.innerHeight}:{width:0,height:0}}}return n.\u0275fac=function(e){return new(e||n)(O(Vn),O(ot),O(Nt,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),q7=new te("VIRTUAL_SCROLLABLE"),ebe=(()=>{class n extends xd{constructor(e,i,r,o){super(e,i,r,o)}measureViewportSize(e){let i=this.elementRef.nativeElement;return"horizontal"===e?i.clientWidth:i.clientHeight}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Lu),C(ot),C(zi,8))},n.\u0275dir=Me({type:n,features:[Xe]}),n})(),nbe=typeof requestAnimationFrame<"u"?YA:Nm,gg=(()=>{class n extends ebe{get orientation(){return this._orientation}set orientation(e){this._orientation!==e&&(this._orientation=e,this._calculateSpacerSize())}get appendOnly(){return this._appendOnly}set appendOnly(e){this._appendOnly=vt(e)}constructor(e,i,r,o,a,s,l,c){super(e,s,r,a),this.elementRef=e,this._changeDetectorRef=i,this._scrollStrategy=o,this.scrollable=c,this._platform=$n(Vn),this._detachedSubject=new Ee,this._renderedRangeSubject=new Ee,this._orientation="vertical",this._appendOnly=!1,this.scrolledIndexChange=new Kt(d=>this._scrollStrategy.scrolledIndexChange.subscribe(u=>Promise.resolve().then(()=>this.ngZone.run(()=>d.next(u))))),this.renderedRangeStream=this._renderedRangeSubject,this._totalContentSize=0,this._totalContentWidth="",this._totalContentHeight="",this._renderedRange={start:0,end:0},this._dataLength=0,this._viewportSize=0,this._renderedContentOffset=0,this._renderedContentOffsetNeedsRewrite=!1,this._isChangeDetectionPending=!1,this._runAfterChangeDetection=[],this._viewportChanges=En.EMPTY,this._viewportChanges=l.change().subscribe(()=>{this.checkViewportSize()}),this.scrollable||(this.elementRef.nativeElement.classList.add("cdk-virtual-scrollable"),this.scrollable=this)}ngOnInit(){!this._platform.isBrowser||(this.scrollable===this&&super.ngOnInit(),this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._measureViewportSize(),this._scrollStrategy.attach(this),this.scrollable.elementScrolled().pipe(kn(null),nc(0,nbe)).subscribe(()=>this._scrollStrategy.onContentScrolled()),this._markChangeDetectionNeeded()})))}ngOnDestroy(){this.detach(),this._scrollStrategy.detach(),this._renderedRangeSubject.complete(),this._detachedSubject.complete(),this._viewportChanges.unsubscribe(),super.ngOnDestroy()}attach(e){this.ngZone.runOutsideAngular(()=>{this._forOf=e,this._forOf.dataStream.pipe(it(this._detachedSubject)).subscribe(i=>{let r=i.length;r!==this._dataLength&&(this._dataLength=r,this._scrollStrategy.onDataLengthChanged()),this._doChangeDetection()})})}detach(){this._forOf=null,this._detachedSubject.next()}getDataLength(){return this._dataLength}getViewportSize(){return this._viewportSize}getRenderedRange(){return this._renderedRange}measureBoundingClientRectWithScrollOffset(e){return this.getElementRef().nativeElement.getBoundingClientRect()[e]}setTotalContentSize(e){this._totalContentSize!==e&&(this._totalContentSize=e,this._calculateSpacerSize(),this._markChangeDetectionNeeded())}setRenderedRange(e){(function(n,t){return n.start==t.start&&n.end==t.end})(this._renderedRange,e)||(this.appendOnly&&(e={start:0,end:Math.max(this._renderedRange.end,e.end)}),this._renderedRangeSubject.next(this._renderedRange=e),this._markChangeDetectionNeeded(()=>this._scrollStrategy.onContentRendered()))}getOffsetToRenderedContentStart(){return this._renderedContentOffsetNeedsRewrite?null:this._renderedContentOffset}setRenderedContentOffset(e,i="to-start"){e=this.appendOnly&&"to-start"===i?0:e;let o="horizontal"==this.orientation,a=o?"X":"Y",l=`translate${a}(${Number((o&&this.dir&&"rtl"==this.dir.value?-1:1)*e)}px)`;this._renderedContentOffset=e,"to-end"===i&&(l+=` translate${a}(-100%)`,this._renderedContentOffsetNeedsRewrite=!0),this._renderedContentTransform!=l&&(this._renderedContentTransform=l,this._markChangeDetectionNeeded(()=>{this._renderedContentOffsetNeedsRewrite?(this._renderedContentOffset-=this.measureRenderedContentSize(),this._renderedContentOffsetNeedsRewrite=!1,this.setRenderedContentOffset(this._renderedContentOffset)):this._scrollStrategy.onRenderedOffsetChanged()}))}scrollToOffset(e,i="auto"){let r={behavior:i};"horizontal"===this.orientation?r.start=e:r.top=e,this.scrollable.scrollTo(r)}scrollToIndex(e,i="auto"){this._scrollStrategy.scrollToIndex(e,i)}measureScrollOffset(e){let i;return i=this.scrollable==this?r=>super.measureScrollOffset(r):r=>this.scrollable.measureScrollOffset(r),Math.max(0,i(e??("horizontal"===this.orientation?"start":"top"))-this.measureViewportOffset())}measureViewportOffset(e){let i,r="left",o="right",a="rtl"==this.dir?.value;i="start"==e?a?o:r:"end"==e?a?r:o:e||("horizontal"===this.orientation?"left":"top");let s=this.scrollable.measureBoundingClientRectWithScrollOffset(i);return this.elementRef.nativeElement.getBoundingClientRect()[i]-s}measureRenderedContentSize(){let e=this._contentWrapper.nativeElement;return"horizontal"===this.orientation?e.offsetWidth:e.offsetHeight}measureRangeSize(e){return this._forOf?this._forOf.measureRangeSize(e,this.orientation):0}checkViewportSize(){this._measureViewportSize(),this._scrollStrategy.onDataLengthChanged()}_measureViewportSize(){this._viewportSize=this.scrollable.measureViewportSize(this.orientation)}_markChangeDetectionNeeded(e){e&&this._runAfterChangeDetection.push(e),this._isChangeDetectionPending||(this._isChangeDetectionPending=!0,this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._doChangeDetection()})))}_doChangeDetection(){this._isChangeDetectionPending=!1,this._contentWrapper.nativeElement.style.transform=this._renderedContentTransform,this.ngZone.run(()=>this._changeDetectorRef.markForCheck());let e=this._runAfterChangeDetection;this._runAfterChangeDetection=[];for(let i of e)i()}_calculateSpacerSize(){this._totalContentHeight="horizontal"===this.orientation?"":`${this._totalContentSize}px`,this._totalContentWidth="horizontal"===this.orientation?`${this._totalContentSize}px`:""}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(ot),C(Y7,8),C(zi,8),C(Lu),C(Wa),C(q7,8))},n.\u0275cmp=P({type:n,selectors:[["cdk-virtual-scroll-viewport"]],viewQuery:function(e,i){if(1&e&&Ue(Q_e,7),2&e){let r;be(r=ve())&&(i._contentWrapper=r.first)}},hostAttrs:[1,"cdk-virtual-scroll-viewport"],hostVars:4,hostBindings:function(e,i){2&e&&nt("cdk-virtual-scroll-orientation-horizontal","horizontal"===i.orientation)("cdk-virtual-scroll-orientation-vertical","horizontal"!==i.orientation)},inputs:{orientation:"orientation",appendOnly:"appendOnly"},outputs:{scrolledIndexChange:"scrolledIndexChange"},standalone:!0,features:[Vt([{provide:xd,useFactory:(t,e)=>t||e,deps:[[new ka,new cf(q7)],n]}]),Xe,Ak],ngContentSelectors:Z_e,decls:4,vars:4,consts:[[1,"cdk-virtual-scroll-content-wrapper"],["contentWrapper",""],[1,"cdk-virtual-scroll-spacer"]],template:function(e,i){1&e&&(fn(),f(0,"div",0,1),Tt(2),g(),k(3,"div",2)),2&e&&(v(3),Bt("width",i._totalContentWidth)("height",i._totalContentHeight))},styles:["cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}"],encapsulation:2,changeDetection:0}),n})();function X7(n,t,e){if(!e.getBoundingClientRect)return 0;let r=e.getBoundingClientRect();return"horizontal"===n?"start"===t?r.left:r.right:"start"===t?r.top:r.bottom}var Z7=(()=>{class n{get cdkVirtualForOf(){return this._cdkVirtualForOf}set cdkVirtualForOf(e){this._cdkVirtualForOf=e,function(n){return n&&"function"==typeof n.connect&&!(n instanceof D_)}(e)?this._dataSourceChanges.next(e):this._dataSourceChanges.next(new G1(P_(e)?e:Array.from(e||[])))}get cdkVirtualForTrackBy(){return this._cdkVirtualForTrackBy}set cdkVirtualForTrackBy(e){this._needsUpdate=!0,this._cdkVirtualForTrackBy=e?(i,r)=>e(i+(this._renderedRange?this._renderedRange.start:0),r):void 0}set cdkVirtualForTemplate(e){e&&(this._needsUpdate=!0,this._template=e)}get cdkVirtualForTemplateCacheSize(){return this._viewRepeater.viewCacheSize}set cdkVirtualForTemplateCacheSize(e){this._viewRepeater.viewCacheSize=mi(e)}constructor(e,i,r,o,a,s){this._viewContainerRef=e,this._template=i,this._differs=r,this._viewRepeater=o,this._viewport=a,this.viewChange=new Ee,this._dataSourceChanges=new Ee,this.dataStream=this._dataSourceChanges.pipe(kn(null),Yt((n,t)=>{let e,i=!1;n.subscribe(Ht(t,r=>{let o=e;e=r,i&&t.next([o,r]),i=!0}))}),Jn(([l,c])=>this._changeDataSource(l,c)),Da(1)),this._differ=null,this._needsUpdate=!1,this._destroyed=new Ee,this.dataStream.subscribe(l=>{this._data=l,this._onRenderedDataChange()}),this._viewport.renderedRangeStream.pipe(it(this._destroyed)).subscribe(l=>{this._renderedRange=l,this.viewChange.observers.length&&s.run(()=>this.viewChange.next(this._renderedRange)),this._onRenderedDataChange()}),this._viewport.attach(this)}measureRangeSize(e,i){if(e.start>=e.end)return 0;let a,s,r=e.start-this._renderedRange.start,o=e.end-e.start;for(let l=0;l<o;l++){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){a=s=c.rootNodes[0];break}}for(let l=o-1;l>-1;l--){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){s=c.rootNodes[c.rootNodes.length-1];break}}return a&&s?X7(i,"end",s)-X7(i,"start",a):0}ngDoCheck(){if(this._differ&&this._needsUpdate){let e=this._differ.diff(this._renderedItems);e?this._applyChanges(e):this._updateContext(),this._needsUpdate=!1}}ngOnDestroy(){this._viewport.detach(),this._dataSourceChanges.next(void 0),this._dataSourceChanges.complete(),this.viewChange.complete(),this._destroyed.next(),this._destroyed.complete(),this._viewRepeater.detach()}_onRenderedDataChange(){!this._renderedRange||(this._renderedItems=this._data.slice(this._renderedRange.start,this._renderedRange.end),this._differ||(this._differ=this._differs.find(this._renderedItems).create((e,i)=>this.cdkVirtualForTrackBy?this.cdkVirtualForTrackBy(e,i):i)),this._needsUpdate=!0)}_changeDataSource(e,i){return e&&e.disconnect(this),this._needsUpdate=!0,i?i.connect(this):$t()}_updateContext(){let e=this._data.length,i=this._viewContainerRef.length;for(;i--;){let r=this._viewContainerRef.get(i);r.context.index=this._renderedRange.start+i,r.context.count=e,this._updateComputedContextProperties(r.context),r.detectChanges()}}_applyChanges(e){this._viewRepeater.applyChanges(e,this._viewContainerRef,(o,a,s)=>this._getEmbeddedViewArgs(o,s),o=>o.item),e.forEachIdentityChange(o=>{this._viewContainerRef.get(o.currentIndex).context.$implicit=o.item});let i=this._data.length,r=this._viewContainerRef.length;for(;r--;){let o=this._viewContainerRef.get(r);o.context.index=this._renderedRange.start+r,o.context.count=i,this._updateComputedContextProperties(o.context)}}_updateComputedContextProperties(e){e.first=0===e.index,e.last=e.index===e.count-1,e.even=e.index%2==0,e.odd=!e.even}_getEmbeddedViewArgs(e,i){return{templateRef:this._template,context:{$implicit:e.item,cdkVirtualForOf:this._cdkVirtualForOf,index:-1,count:-1,first:!1,last:!1,odd:!1,even:!1},index:i}}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(oi),C(Tl),C(C2),C(gg,4),C(ot))},n.\u0275dir=Me({type:n,selectors:[["","cdkVirtualFor","","cdkVirtualForOf",""]],inputs:{cdkVirtualForOf:"cdkVirtualForOf",cdkVirtualForTrackBy:"cdkVirtualForTrackBy",cdkVirtualForTemplate:"cdkVirtualForTemplate",cdkVirtualForTemplateCacheSize:"cdkVirtualForTemplateCacheSize"},standalone:!0,features:[Vt([{provide:C2,useClass:W1}])]}),n})(),Ic=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),Cd=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Fu,Ic,gg,Fu,Ic]}),n})(),K7=k1(),q1=class{enable(){}disable(){}attach(){}};function E2(n,t){return t.some(e=>n.bottom<e.top||n.top>e.bottom||n.right<e.left||n.left>e.right)}function J7(n,t){return t.some(e=>n.top<e.top||n.bottom>e.bottom||n.left<e.left||n.right>e.right)}var Ih=class{constructor(t,e,i,r){this._scrollDispatcher=t,this._viewportRuler=e,this._ngZone=i,this._config=r,this._scrollSubscription=null}attach(t){this._overlayRef=t}enable(){this._scrollSubscription||(this._scrollSubscription=this._scrollDispatcher.scrolled(this._config?this._config.scrollThrottle:0).subscribe(()=>{if(this._overlayRef.updatePosition(),this._config&&this._config.autoClose){let e=this._overlayRef.overlayElement.getBoundingClientRect(),{width:i,height:r}=this._viewportRuler.getViewportSize();E2(e,[{width:i,height:r,bottom:r,right:i,top:0,left:0}])&&(this.disable(),this._ngZone.run(()=>this._overlayRef.detach()))}}))}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}},ibe=(()=>{class n{constructor(e,i,r,o){this._scrollDispatcher=e,this._viewportRuler=i,this._ngZone=r,this.noop=()=>new q1,this.close=a=>new class{constructor(t,e,i,r){this._scrollDispatcher=t,this._ngZone=e,this._viewportRuler=i,this._config=r,this._scrollSubscription=null,this._detach=()=>{this.disable(),this._overlayRef.hasAttached()&&this._ngZone.run(()=>this._overlayRef.detach())}}attach(t){this._overlayRef=t}enable(){if(this._scrollSubscription)return;let t=this._scrollDispatcher.scrolled(0).pipe(Oe(e=>!e||!this._overlayRef.overlayElement.contains(e.getElementRef().nativeElement)));this._config&&this._config.threshold&&this._config.threshold>1?(this._initialScrollPosition=this._viewportRuler.getViewportScrollPosition().top,this._scrollSubscription=t.subscribe(()=>{let e=this._viewportRuler.getViewportScrollPosition().top;Math.abs(e-this._initialScrollPosition)>this._config.threshold?this._detach():this._overlayRef.updatePosition()})):this._scrollSubscription=t.subscribe(this._detach)}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}(this._scrollDispatcher,this._ngZone,this._viewportRuler,a),this.block=()=>new class{constructor(t,e){this._viewportRuler=t,this._previousHTMLStyles={top:"",left:""},this._isEnabled=!1,this._document=e}attach(){}enable(){if(this._canBeEnabled()){let t=this._document.documentElement;this._previousScrollPosition=this._viewportRuler.getViewportScrollPosition(),this._previousHTMLStyles.left=t.style.left||"",this._previousHTMLStyles.top=t.style.top||"",t.style.left=qr(-this._previousScrollPosition.left),t.style.top=qr(-this._previousScrollPosition.top),t.classList.add("cdk-global-scrollblock"),this._isEnabled=!0}}disable(){if(this._isEnabled){let t=this._document.documentElement,i=t.style,r=this._document.body.style,o=i.scrollBehavior||"",a=r.scrollBehavior||"";this._isEnabled=!1,i.left=this._previousHTMLStyles.left,i.top=this._previousHTMLStyles.top,t.classList.remove("cdk-global-scrollblock"),K7&&(i.scrollBehavior=r.scrollBehavior="auto"),window.scroll(this._previousScrollPosition.left,this._previousScrollPosition.top),K7&&(i.scrollBehavior=o,r.scrollBehavior=a)}}_canBeEnabled(){if(this._document.documentElement.classList.contains("cdk-global-scrollblock")||this._isEnabled)return!1;let e=this._document.body,i=this._viewportRuler.getViewportSize();return e.scrollHeight>i.height||e.scrollWidth>i.width}}(this._viewportRuler,this._document),this.reposition=a=>new Ih(this._scrollDispatcher,this._viewportRuler,this._ngZone,a),this._document=o}}return n.\u0275fac=function(e){return new(e||n)(O(Lu),O(Wa),O(ot),O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),el=class{constructor(t){if(this.scrollStrategy=new q1,this.panelClass="",this.hasBackdrop=!1,this.backdropClass="cdk-overlay-dark-backdrop",this.disposeOnNavigation=!1,t){let e=Object.keys(t);for(let i of e)void 0!==t[i]&&(this[i]=t[i])}}},i9=(()=>{class n{constructor(e){this._attachedOverlays=[],this._document=e}ngOnDestroy(){this.detach()}add(e){this.remove(e),this._attachedOverlays.push(e)}remove(e){let i=this._attachedOverlays.indexOf(e);i>-1&&this._attachedOverlays.splice(i,1),0===this._attachedOverlays.length&&this.detach()}}return n.\u0275fac=function(e){return new(e||n)(O(Nt))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),rbe=(()=>{class n extends i9{constructor(e,i){super(e),this._ngZone=i,this._keydownListener=r=>{let o=this._attachedOverlays;for(let a=o.length-1;a>-1;a--)if(o[a]._keydownEvents.observers.length>0){let s=o[a]._keydownEvents;this._ngZone?this._ngZone.run(()=>s.next(r)):s.next(r);break}}}add(e){super.add(e),this._isAttached||(this._ngZone?this._ngZone.runOutsideAngular(()=>this._document.body.addEventListener("keydown",this._keydownListener)):this._document.body.addEventListener("keydown",this._keydownListener),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("keydown",this._keydownListener),this._isAttached=!1)}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(ot,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),obe=(()=>{class n extends i9{constructor(e,i,r){super(e),this._platform=i,this._ngZone=r,this._cursorStyleIsSet=!1,this._pointerDownListener=o=>{this._pointerDownEventTarget=bs(o)},this._clickListener=o=>{let a=bs(o),s="click"===o.type&&this._pointerDownEventTarget?this._pointerDownEventTarget:a;this._pointerDownEventTarget=null;let l=this._attachedOverlays.slice();for(let c=l.length-1;c>-1;c--){let d=l[c];if(d._outsidePointerEvents.observers.length<1||!d.hasAttached())continue;if(d.overlayElement.contains(a)||d.overlayElement.contains(s))break;let u=d._outsidePointerEvents;this._ngZone?this._ngZone.run(()=>u.next(o)):u.next(o)}}}add(e){if(super.add(e),!this._isAttached){let i=this._document.body;this._ngZone?this._ngZone.runOutsideAngular(()=>this._addEventListeners(i)):this._addEventListeners(i),this._platform.IOS&&!this._cursorStyleIsSet&&(this._cursorOriginalValue=i.style.cursor,i.style.cursor="pointer",this._cursorStyleIsSet=!0),this._isAttached=!0}}detach(){if(this._isAttached){let e=this._document.body;e.removeEventListener("pointerdown",this._pointerDownListener,!0),e.removeEventListener("click",this._clickListener,!0),e.removeEventListener("auxclick",this._clickListener,!0),e.removeEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&this._cursorStyleIsSet&&(e.style.cursor=this._cursorOriginalValue,this._cursorStyleIsSet=!1),this._isAttached=!1}}_addEventListeners(e){e.addEventListener("pointerdown",this._pointerDownListener,!0),e.addEventListener("click",this._clickListener,!0),e.addEventListener("auxclick",this._clickListener,!0),e.addEventListener("contextmenu",this._clickListener,!0)}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(Vn),O(ot,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),_g=(()=>{class n{constructor(e,i){this._platform=i,this._document=e}ngOnDestroy(){this._containerElement?.remove()}getContainerElement(){return this._containerElement||this._createContainer(),this._containerElement}_createContainer(){let e="cdk-overlay-container";if(this._platform.isBrowser||Fv()){let r=this._document.querySelectorAll(`.${e}[platform="server"], .${e}[platform="test"]`);for(let o=0;o<r.length;o++)r[o].remove()}let i=this._document.createElement("div");i.classList.add(e),Fv()?i.setAttribute("platform","test"):this._platform.isBrowser||i.setAttribute("platform","server"),this._document.body.appendChild(i),this._containerElement=i}}return n.\u0275fac=function(e){return new(e||n)(O(Nt),O(Vn))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ac=class{constructor(t,e,i,r,o,a,s,l,c,d=!1){this._portalOutlet=t,this._host=e,this._pane=i,this._config=r,this._ngZone=o,this._keyboardDispatcher=a,this._document=s,this._location=l,this._outsideClickDispatcher=c,this._animationsDisabled=d,this._backdropElement=null,this._backdropClick=new Ee,this._attachments=new Ee,this._detachments=new Ee,this._locationChanges=En.EMPTY,this._backdropClickHandler=u=>this._backdropClick.next(u),this._backdropTransitionendHandler=u=>{this._disposeBackdrop(u.target)},this._keydownEvents=new Ee,this._outsidePointerEvents=new Ee,r.scrollStrategy&&(this._scrollStrategy=r.scrollStrategy,this._scrollStrategy.attach(this)),this._positionStrategy=r.positionStrategy}get overlayElement(){return this._pane}get backdropElement(){return this._backdropElement}get hostElement(){return this._host}attach(t){!this._host.parentElement&&this._previousHostParent&&this._previousHostParent.appendChild(this._host);let e=this._portalOutlet.attach(t);return this._positionStrategy&&this._positionStrategy.attach(this),this._updateStackingOrder(),this._updateElementSize(),this._updateElementDirection(),this._scrollStrategy&&this._scrollStrategy.enable(),this._ngZone.onStable.pipe(Lt(1)).subscribe(()=>{this.hasAttached()&&this.updatePosition()}),this._togglePointerEvents(!0),this._config.hasBackdrop&&this._attachBackdrop(),this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!0),this._attachments.next(),this._keyboardDispatcher.add(this),this._config.disposeOnNavigation&&(this._locationChanges=this._location.subscribe(()=>this.dispose())),this._outsideClickDispatcher.add(this),"function"==typeof e?.onDestroy&&e.onDestroy(()=>{this.hasAttached()&&this._ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>this.detach()))}),e}detach(){if(!this.hasAttached())return;this.detachBackdrop(),this._togglePointerEvents(!1),this._positionStrategy&&this._positionStrategy.detach&&this._positionStrategy.detach(),this._scrollStrategy&&this._scrollStrategy.disable();let t=this._portalOutlet.detach();return this._detachments.next(),this._keyboardDispatcher.remove(this),this._detachContentWhenStable(),this._locationChanges.unsubscribe(),this._outsideClickDispatcher.remove(this),t}dispose(){let t=this.hasAttached();this._positionStrategy&&this._positionStrategy.dispose(),this._disposeScrollStrategy(),this._disposeBackdrop(this._backdropElement),this._locationChanges.unsubscribe(),this._keyboardDispatcher.remove(this),this._portalOutlet.dispose(),this._attachments.complete(),this._backdropClick.complete(),this._keydownEvents.complete(),this._outsidePointerEvents.complete(),this._outsideClickDispatcher.remove(this),this._host?.remove(),this._previousHostParent=this._pane=this._host=null,t&&this._detachments.next(),this._detachments.complete()}hasAttached(){return this._portalOutlet.hasAttached()}backdropClick(){return this._backdropClick}attachments(){return this._attachments}detachments(){return this._detachments}keydownEvents(){return this._keydownEvents}outsidePointerEvents(){return this._outsidePointerEvents}getConfig(){return this._config}updatePosition(){this._positionStrategy&&this._positionStrategy.apply()}updatePositionStrategy(t){t!==this._positionStrategy&&(this._positionStrategy&&this._positionStrategy.dispose(),this._positionStrategy=t,this.hasAttached()&&(t.attach(this),this.updatePosition()))}updateSize(t){this._config={...this._config,...t},this._updateElementSize()}setDirection(t){this._config={...this._config,direction:t},this._updateElementDirection()}addPanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!0)}removePanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!1)}getDirection(){let t=this._config.direction;return t?"string"==typeof t?t:t.value:"ltr"}updateScrollStrategy(t){t!==this._scrollStrategy&&(this._disposeScrollStrategy(),this._scrollStrategy=t,this.hasAttached()&&(t.attach(this),t.enable()))}_updateElementDirection(){this._host.setAttribute("dir",this.getDirection())}_updateElementSize(){if(!this._pane)return;let t=this._pane.style;t.width=qr(this._config.width),t.height=qr(this._config.height),t.minWidth=qr(this._config.minWidth),t.minHeight=qr(this._config.minHeight),t.maxWidth=qr(this._config.maxWidth),t.maxHeight=qr(this._config.maxHeight)}_togglePointerEvents(t){this._pane.style.pointerEvents=t?"":"none"}_attachBackdrop(){let t="cdk-overlay-backdrop-showing";this._backdropElement=this._document.createElement("div"),this._backdropElement.classList.add("cdk-overlay-backdrop"),this._animationsDisabled&&this._backdropElement.classList.add("cdk-overlay-backdrop-noop-animation"),this._config.backdropClass&&this._toggleClasses(this._backdropElement,this._config.backdropClass,!0),this._host.parentElement.insertBefore(this._backdropElement,this._host),this._backdropElement.addEventListener("click",this._backdropClickHandler),!this._animationsDisabled&&typeof requestAnimationFrame<"u"?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>{this._backdropElement&&this._backdropElement.classList.add(t)})}):this._backdropElement.classList.add(t)}_updateStackingOrder(){this._host.nextSibling&&this._host.parentNode.appendChild(this._host)}detachBackdrop(){let t=this._backdropElement;if(t){if(this._animationsDisabled)return void this._disposeBackdrop(t);t.classList.remove("cdk-overlay-backdrop-showing"),this._ngZone.runOutsideAngular(()=>{t.addEventListener("transitionend",this._backdropTransitionendHandler)}),t.style.pointerEvents="none",this._backdropTimeout=this._ngZone.runOutsideAngular(()=>setTimeout(()=>{this._disposeBackdrop(t)},500))}}_toggleClasses(t,e,i){let r=rg(e||[]).filter(o=>!!o);r.length&&(i?t.classList.add(...r):t.classList.remove(...r))}_detachContentWhenStable(){this._ngZone.runOutsideAngular(()=>{let t=this._ngZone.onStable.pipe(it(tn(this._attachments,this._detachments))).subscribe(()=>{(!this._pane||!this._host||0===this._pane.children.length)&&(this._pane&&this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!1),this._host&&this._host.parentElement&&(this._previousHostParent=this._host.parentElement,this._host.remove()),t.unsubscribe())})})}_disposeScrollStrategy(){let t=this._scrollStrategy;t&&(t.disable(),t.detach&&t.detach())}_disposeBackdrop(t){t&&(t.removeEventListener("click",this._backdropClickHandler),t.removeEventListener("transitionend",this._backdropTransitionendHandler),t.remove(),this._backdropElement===t&&(this._backdropElement=null)),this._backdropTimeout&&(clearTimeout(this._backdropTimeout),this._backdropTimeout=void 0)}},$7="cdk-overlay-connected-position-bounding-box",abe=/([A-Za-z%]+)$/;function Dh(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[e]=t[e]);return n}function e9(n){if("number"!=typeof n&&null!=n){let[t,e]=n.split(abe);return e&&"px"!==e?null:parseFloat(t)}return n||null}function t9(n){return{top:Math.floor(n.top),right:Math.floor(n.right),bottom:Math.floor(n.bottom),left:Math.floor(n.left),width:Math.floor(n.width),height:Math.floor(n.height)}}var n9="cdk-global-overlay-wrapper",sbe=(()=>{class n{constructor(e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o}global(){return new class{constructor(){this._cssPosition="static",this._topOffset="",this._bottomOffset="",this._alignItems="",this._xPosition="",this._xOffset="",this._width="",this._height="",this._isDisposed=!1}attach(t){let e=t.getConfig();this._overlayRef=t,this._width&&!e.width&&t.updateSize({width:this._width}),this._height&&!e.height&&t.updateSize({height:this._height}),t.hostElement.classList.add(n9),this._isDisposed=!1}top(t=""){return this._bottomOffset="",this._topOffset=t,this._alignItems="flex-start",this}left(t=""){return this._xOffset=t,this._xPosition="left",this}bottom(t=""){return this._topOffset="",this._bottomOffset=t,this._alignItems="flex-end",this}right(t=""){return this._xOffset=t,this._xPosition="right",this}start(t=""){return this._xOffset=t,this._xPosition="start",this}end(t=""){return this._xOffset=t,this._xPosition="end",this}width(t=""){return this._overlayRef?this._overlayRef.updateSize({width:t}):this._width=t,this}height(t=""){return this._overlayRef?this._overlayRef.updateSize({height:t}):this._height=t,this}centerHorizontally(t=""){return this.left(t),this._xPosition="center",this}centerVertically(t=""){return this.top(t),this._alignItems="center",this}apply(){if(!this._overlayRef||!this._overlayRef.hasAttached())return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement.style,i=this._overlayRef.getConfig(),{width:r,height:o,maxWidth:a,maxHeight:s}=i,l=!("100%"!==r&&"100vw"!==r||a&&"100%"!==a&&"100vw"!==a),c=!("100%"!==o&&"100vh"!==o||s&&"100%"!==s&&"100vh"!==s),d=this._xPosition,u=this._xOffset,p="rtl"===this._overlayRef.getConfig().direction,h="",m="",_="";l?_="flex-start":"center"===d?(_="center",p?m=u:h=u):p?"left"===d||"end"===d?(_="flex-end",h=u):("right"===d||"start"===d)&&(_="flex-start",m=u):"left"===d||"start"===d?(_="flex-start",h=u):("right"===d||"end"===d)&&(_="flex-end",m=u),t.position=this._cssPosition,t.marginLeft=l?"0":h,t.marginTop=c?"0":this._topOffset,t.marginBottom=this._bottomOffset,t.marginRight=l?"0":m,e.justifyContent=_,e.alignItems=c?"flex-start":this._alignItems}dispose(){if(this._isDisposed||!this._overlayRef)return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement,i=e.style;e.classList.remove(n9),i.justifyContent=i.alignItems=t.marginTop=t.marginBottom=t.marginLeft=t.marginRight=t.position="",this._overlayRef=null,this._isDisposed=!0}}}flexibleConnectedTo(e){return new class{get positions(){return this._preferredPositions}constructor(t,e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o,this._lastBoundingBoxSize={width:0,height:0},this._isPushed=!1,this._canPush=!0,this._growAfterOpen=!1,this._hasFlexibleDimensions=!0,this._positionLocked=!1,this._viewportMargin=0,this._scrollables=[],this._preferredPositions=[],this._positionChanges=new Ee,this._resizeSubscription=En.EMPTY,this._offsetX=0,this._offsetY=0,this._appliedPanelClasses=[],this.positionChanges=this._positionChanges,this.setOrigin(t)}attach(t){this._validatePositions(),t.hostElement.classList.add($7),this._overlayRef=t,this._boundingBox=t.hostElement,this._pane=t.overlayElement,this._isDisposed=!1,this._isInitialRender=!0,this._lastPosition=null,this._resizeSubscription.unsubscribe(),this._resizeSubscription=this._viewportRuler.change().subscribe(()=>{this._isInitialRender=!0,this.apply()})}apply(){if(this._isDisposed||!this._platform.isBrowser)return;if(!this._isInitialRender&&this._positionLocked&&this._lastPosition)return void this.reapplyLastPosition();this._clearPanelClasses(),this._resetOverlayElementStyles(),this._resetBoundingBoxStyles(),this._viewportRect=this._getNarrowedViewportRect(),this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let a,t=this._originRect,e=this._overlayRect,i=this._viewportRect,r=this._containerRect,o=[];for(let s of this._preferredPositions){let l=this._getOriginPoint(t,r,s),c=this._getOverlayPoint(l,e,s),d=this._getOverlayFit(c,e,i,s);if(d.isCompletelyWithinViewport)return this._isPushed=!1,void this._applyPosition(s,l);this._canFitWithFlexibleDimensions(d,c,i)?o.push({position:s,origin:l,overlayRect:e,boundingBoxRect:this._calculateBoundingBoxRect(l,s)}):(!a||a.overlayFit.visibleArea<d.visibleArea)&&(a={overlayFit:d,overlayPoint:c,originPoint:l,position:s,overlayRect:e})}if(o.length){let s=null,l=-1;for(let c of o){let d=c.boundingBoxRect.width*c.boundingBoxRect.height*(c.position.weight||1);d>l&&(l=d,s=c)}return this._isPushed=!1,void this._applyPosition(s.position,s.origin)}if(this._canPush)return this._isPushed=!0,void this._applyPosition(a.position,a.originPoint);this._applyPosition(a.position,a.originPoint)}detach(){this._clearPanelClasses(),this._lastPosition=null,this._previousPushAmount=null,this._resizeSubscription.unsubscribe()}dispose(){this._isDisposed||(this._boundingBox&&Dh(this._boundingBox.style,{top:"",left:"",right:"",bottom:"",height:"",width:"",alignItems:"",justifyContent:""}),this._pane&&this._resetOverlayElementStyles(),this._overlayRef&&this._overlayRef.hostElement.classList.remove($7),this.detach(),this._positionChanges.complete(),this._overlayRef=this._boundingBox=null,this._isDisposed=!0)}reapplyLastPosition(){if(this._isDisposed||!this._platform.isBrowser)return;let t=this._lastPosition;if(t){this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._viewportRect=this._getNarrowedViewportRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let e=this._getOriginPoint(this._originRect,this._containerRect,t);this._applyPosition(t,e)}else this.apply()}withScrollableContainers(t){return this._scrollables=t,this}withPositions(t){return this._preferredPositions=t,-1===t.indexOf(this._lastPosition)&&(this._lastPosition=null),this._validatePositions(),this}withViewportMargin(t){return this._viewportMargin=t,this}withFlexibleDimensions(t=!0){return this._hasFlexibleDimensions=t,this}withGrowAfterOpen(t=!0){return this._growAfterOpen=t,this}withPush(t=!0){return this._canPush=t,this}withLockedPosition(t=!0){return this._positionLocked=t,this}setOrigin(t){return this._origin=t,this}withDefaultOffsetX(t){return this._offsetX=t,this}withDefaultOffsetY(t){return this._offsetY=t,this}withTransformOriginOn(t){return this._transformOriginSelector=t,this}_getOriginPoint(t,e,i){let r,o;if("center"==i.originX)r=t.left+t.width/2;else{let a=this._isRtl()?t.right:t.left,s=this._isRtl()?t.left:t.right;r="start"==i.originX?a:s}return e.left<0&&(r-=e.left),o="center"==i.originY?t.top+t.height/2:"top"==i.originY?t.top:t.bottom,e.top<0&&(o-=e.top),{x:r,y:o}}_getOverlayPoint(t,e,i){let r,o;return r="center"==i.overlayX?-e.width/2:"start"===i.overlayX?this._isRtl()?-e.width:0:this._isRtl()?0:-e.width,o="center"==i.overlayY?-e.height/2:"top"==i.overlayY?0:-e.height,{x:t.x+r,y:t.y+o}}_getOverlayFit(t,e,i,r){let o=t9(e),{x:a,y:s}=t,l=this._getOffset(r,"x"),c=this._getOffset(r,"y");l&&(a+=l),c&&(s+=c);let p=0-s,h=s+o.height-i.height,m=this._subtractOverflows(o.width,0-a,a+o.width-i.width),_=this._subtractOverflows(o.height,p,h),M=m*_;return{visibleArea:M,isCompletelyWithinViewport:o.width*o.height===M,fitsInViewportVertically:_===o.height,fitsInViewportHorizontally:m==o.width}}_canFitWithFlexibleDimensions(t,e,i){if(this._hasFlexibleDimensions){let r=i.bottom-e.y,o=i.right-e.x,a=e9(this._overlayRef.getConfig().minHeight),s=e9(this._overlayRef.getConfig().minWidth);return(t.fitsInViewportVertically||null!=a&&a<=r)&&(t.fitsInViewportHorizontally||null!=s&&s<=o)}return!1}_pushOverlayOnScreen(t,e,i){if(this._previousPushAmount&&this._positionLocked)return{x:t.x+this._previousPushAmount.x,y:t.y+this._previousPushAmount.y};let r=t9(e),o=this._viewportRect,a=Math.max(t.x+r.width-o.width,0),s=Math.max(t.y+r.height-o.height,0),l=Math.max(o.top-i.top-t.y,0),c=Math.max(o.left-i.left-t.x,0),d=0,u=0;return d=r.width<=o.width?c||-a:t.x<this._viewportMargin?o.left-i.left-t.x:0,u=r.height<=o.height?l||-s:t.y<this._viewportMargin?o.top-i.top-t.y:0,this._previousPushAmount={x:d,y:u},{x:t.x+d,y:t.y+u}}_applyPosition(t,e){if(this._setTransformOrigin(t),this._setOverlayElementStyles(e,t),this._setBoundingBoxStyles(e,t),t.panelClass&&this._addPanelClasses(t.panelClass),this._lastPosition=t,this._positionChanges.observers.length){let i=this._getScrollVisibility(),r=new class{constructor(t,e){this.connectionPair=t,this.scrollableViewProperties=e}}(t,i);this._positionChanges.next(r)}this._isInitialRender=!1}_setTransformOrigin(t){if(!this._transformOriginSelector)return;let i,e=this._boundingBox.querySelectorAll(this._transformOriginSelector),r=t.overlayY;i="center"===t.overlayX?"center":this._isRtl()?"start"===t.overlayX?"right":"left":"start"===t.overlayX?"left":"right";for(let o=0;o<e.length;o++)e[o].style.transformOrigin=`${i} ${r}`}_calculateBoundingBoxRect(t,e){let o,a,s,d,u,p,i=this._viewportRect,r=this._isRtl();if("top"===e.overlayY)a=t.y,o=i.height-a+this._viewportMargin;else if("bottom"===e.overlayY)s=i.height-t.y+2*this._viewportMargin,o=i.height-s+this._viewportMargin;else{let h=Math.min(i.bottom-t.y+i.top,t.y),m=this._lastBoundingBoxSize.height;o=2*h,a=t.y-h,o>m&&!this._isInitialRender&&!this._growAfterOpen&&(a=t.y-m/2)}if("end"===e.overlayX&&!r||"start"===e.overlayX&&r)p=i.width-t.x+this._viewportMargin,d=t.x-this._viewportMargin;else if("start"===e.overlayX&&!r||"end"===e.overlayX&&r)u=t.x,d=i.right-t.x;else{let h=Math.min(i.right-t.x+i.left,t.x),m=this._lastBoundingBoxSize.width;d=2*h,u=t.x-h,d>m&&!this._isInitialRender&&!this._growAfterOpen&&(u=t.x-m/2)}return{top:a,left:u,bottom:s,right:p,width:d,height:o}}_setBoundingBoxStyles(t,e){let i=this._calculateBoundingBoxRect(t,e);!this._isInitialRender&&!this._growAfterOpen&&(i.height=Math.min(i.height,this._lastBoundingBoxSize.height),i.width=Math.min(i.width,this._lastBoundingBoxSize.width));let r={};if(this._hasExactPosition())r.top=r.left="0",r.bottom=r.right=r.maxHeight=r.maxWidth="",r.width=r.height="100%";else{let o=this._overlayRef.getConfig().maxHeight,a=this._overlayRef.getConfig().maxWidth;r.height=qr(i.height),r.top=qr(i.top),r.bottom=qr(i.bottom),r.width=qr(i.width),r.left=qr(i.left),r.right=qr(i.right),r.alignItems="center"===e.overlayX?"center":"end"===e.overlayX?"flex-end":"flex-start",r.justifyContent="center"===e.overlayY?"center":"bottom"===e.overlayY?"flex-end":"flex-start",o&&(r.maxHeight=qr(o)),a&&(r.maxWidth=qr(a))}this._lastBoundingBoxSize=i,Dh(this._boundingBox.style,r)}_resetBoundingBoxStyles(){Dh(this._boundingBox.style,{top:"0",left:"0",right:"0",bottom:"0",height:"",width:"",alignItems:"",justifyContent:""})}_resetOverlayElementStyles(){Dh(this._pane.style,{top:"",left:"",bottom:"",right:"",position:"",transform:""})}_setOverlayElementStyles(t,e){let i={},r=this._hasExactPosition(),o=this._hasFlexibleDimensions,a=this._overlayRef.getConfig();if(r){let d=this._viewportRuler.getViewportScrollPosition();Dh(i,this._getExactOverlayY(e,t,d)),Dh(i,this._getExactOverlayX(e,t,d))}else i.position="static";let s="",l=this._getOffset(e,"x"),c=this._getOffset(e,"y");l&&(s+=`translateX(${l}px) `),c&&(s+=`translateY(${c}px)`),i.transform=s.trim(),a.maxHeight&&(r?i.maxHeight=qr(a.maxHeight):o&&(i.maxHeight="")),a.maxWidth&&(r?i.maxWidth=qr(a.maxWidth):o&&(i.maxWidth="")),Dh(this._pane.style,i)}_getExactOverlayY(t,e,i){let r={top:"",bottom:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),"bottom"===t.overlayY?r.bottom=this._document.documentElement.clientHeight-(o.y+this._overlayRect.height)+"px":r.top=qr(o.y),r}_getExactOverlayX(t,e,i){let a,r={left:"",right:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),a=this._isRtl()?"end"===t.overlayX?"left":"right":"end"===t.overlayX?"right":"left","right"===a?r.right=this._document.documentElement.clientWidth-(o.x+this._overlayRect.width)+"px":r.left=qr(o.x),r}_getScrollVisibility(){let t=this._getOriginRect(),e=this._pane.getBoundingClientRect(),i=this._scrollables.map(r=>r.getElementRef().nativeElement.getBoundingClientRect());return{isOriginClipped:J7(t,i),isOriginOutsideView:E2(t,i),isOverlayClipped:J7(e,i),isOverlayOutsideView:E2(e,i)}}_subtractOverflows(t,...e){return e.reduce((i,r)=>i-Math.max(r,0),t)}_getNarrowedViewportRect(){let t=this._document.documentElement.clientWidth,e=this._document.documentElement.clientHeight,i=this._viewportRuler.getViewportScrollPosition();return{top:i.top+this._viewportMargin,left:i.left+this._viewportMargin,right:i.left+t-this._viewportMargin,bottom:i.top+e-this._viewportMargin,width:t-2*this._viewportMargin,height:e-2*this._viewportMargin}}_isRtl(){return"rtl"===this._overlayRef.getDirection()}_hasExactPosition(){return!this._hasFlexibleDimensions||this._isPushed}_getOffset(t,e){return"x"===e?null==t.offsetX?this._offsetX:t.offsetX:null==t.offsetY?this._offsetY:t.offsetY}_validatePositions(){}_addPanelClasses(t){this._pane&&rg(t).forEach(e=>{""!==e&&-1===this._appliedPanelClasses.indexOf(e)&&(this._appliedPanelClasses.push(e),this._pane.classList.add(e))})}_clearPanelClasses(){this._pane&&(this._appliedPanelClasses.forEach(t=>{this._pane.classList.remove(t)}),this._appliedPanelClasses=[])}_getOriginRect(){let t=this._origin;if(t instanceof xe)return t.nativeElement.getBoundingClientRect();if(t instanceof Element)return t.getBoundingClientRect();let e=t.width||0,i=t.height||0;return{top:t.y,bottom:t.y+i,left:t.x,right:t.x+e,height:i,width:e}}}(e,this._viewportRuler,this._document,this._platform,this._overlayContainer)}}return n.\u0275fac=function(e){return new(e||n)(O(Wa),O(Nt),O(Vn),O(_g))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),lbe=0,Oi=(()=>{class n{constructor(e,i,r,o,a,s,l,c,d,u,p,h){this.scrollStrategies=e,this._overlayContainer=i,this._componentFactoryResolver=r,this._positionBuilder=o,this._keyboardDispatcher=a,this._injector=s,this._ngZone=l,this._document=c,this._directionality=d,this._location=u,this._outsideClickDispatcher=p,this._animationsModuleType=h}create(e){let i=this._createHostElement(),r=this._createPaneElement(i),o=this._createPortalOutlet(r),a=new el(e);return a.direction=a.direction||this._directionality.value,new Ac(o,i,r,a,this._ngZone,this._keyboardDispatcher,this._document,this._location,this._outsideClickDispatcher,"NoopAnimations"===this._animationsModuleType)}position(){return this._positionBuilder}_createPaneElement(e){let i=this._document.createElement("div");return i.id="cdk-overlay-"+lbe++,i.classList.add("cdk-overlay-pane"),e.appendChild(i),i}_createHostElement(){let e=this._document.createElement("div");return this._overlayContainer.getContainerElement().appendChild(e),e}_createPortalOutlet(e){return this._appRef||(this._appRef=this._injector.get(gc)),new Wv(e,this._componentFactoryResolver,this._appRef,this._injector,this._document)}}return n.\u0275fac=function(e){return new(e||n)(O(ibe),O(_g),O(ho),O(sbe),O(rbe),O(wi),O(ot),O(Nt),O(zi),O(Db),O(obe),O(pi,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),cbe=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom"},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],r9=new te("cdk-connected-overlay-scroll-strategy"),Md=(()=>{class n{constructor(e){this.elementRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275dir=Me({type:n,selectors:[["","cdk-overlay-origin",""],["","overlay-origin",""],["","cdkOverlayOrigin",""]],exportAs:["cdkOverlayOrigin"],standalone:!0}),n})(),Vu=(()=>{class n{get offsetX(){return this._offsetX}set offsetX(e){this._offsetX=e,this._position&&this._updatePositionStrategy(this._position)}get offsetY(){return this._offsetY}set offsetY(e){this._offsetY=e,this._position&&this._updatePositionStrategy(this._position)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=vt(e)}get lockPosition(){return this._lockPosition}set lockPosition(e){this._lockPosition=vt(e)}get flexibleDimensions(){return this._flexibleDimensions}set flexibleDimensions(e){this._flexibleDimensions=vt(e)}get growAfterOpen(){return this._growAfterOpen}set growAfterOpen(e){this._growAfterOpen=vt(e)}get push(){return this._push}set push(e){this._push=vt(e)}constructor(e,i,r,o,a){this._overlay=e,this._dir=a,this._hasBackdrop=!1,this._lockPosition=!1,this._growAfterOpen=!1,this._flexibleDimensions=!1,this._push=!1,this._backdropSubscription=En.EMPTY,this._attachSubscription=En.EMPTY,this._detachSubscription=En.EMPTY,this._positionSubscription=En.EMPTY,this.viewportMargin=0,this.open=!1,this.disableClose=!1,this.backdropClick=new F,this.positionChange=new F,this.attach=new F,this.detach=new F,this.overlayKeydown=new F,this.overlayOutsideClick=new F,this._templatePortal=new To(i,r),this._scrollStrategyFactory=o,this.scrollStrategy=this._scrollStrategyFactory()}get overlayRef(){return this._overlayRef}get dir(){return this._dir?this._dir.value:"ltr"}ngOnDestroy(){this._attachSubscription.unsubscribe(),this._detachSubscription.unsubscribe(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this._overlayRef&&this._overlayRef.dispose()}ngOnChanges(e){this._position&&(this._updatePositionStrategy(this._position),this._overlayRef.updateSize({width:this.width,minWidth:this.minWidth,height:this.height,minHeight:this.minHeight}),e.origin&&this.open&&this._position.apply()),e.open&&(this.open?this._attachOverlay():this._detachOverlay())}_createOverlay(){(!this.positions||!this.positions.length)&&(this.positions=cbe);let e=this._overlayRef=this._overlay.create(this._buildConfig());this._attachSubscription=e.attachments().subscribe(()=>this.attach.emit()),this._detachSubscription=e.detachments().subscribe(()=>this.detach.emit()),e.keydownEvents().subscribe(i=>{this.overlayKeydown.next(i),27===i.keyCode&&!this.disableClose&&!Or(i)&&(i.preventDefault(),this._detachOverlay())}),this._overlayRef.outsidePointerEvents().subscribe(i=>{this.overlayOutsideClick.next(i)})}_buildConfig(){let e=this._position=this.positionStrategy||this._createPositionStrategy(),i=new el({direction:this._dir,positionStrategy:e,scrollStrategy:this.scrollStrategy,hasBackdrop:this.hasBackdrop});return(this.width||0===this.width)&&(i.width=this.width),(this.height||0===this.height)&&(i.height=this.height),(this.minWidth||0===this.minWidth)&&(i.minWidth=this.minWidth),(this.minHeight||0===this.minHeight)&&(i.minHeight=this.minHeight),this.backdropClass&&(i.backdropClass=this.backdropClass),this.panelClass&&(i.panelClass=this.panelClass),i}_updatePositionStrategy(e){let i=this.positions.map(r=>({originX:r.originX,originY:r.originY,overlayX:r.overlayX,overlayY:r.overlayY,offsetX:r.offsetX||this.offsetX,offsetY:r.offsetY||this.offsetY,panelClass:r.panelClass||void 0}));return e.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin()).withPositions(i).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector)}_createPositionStrategy(){let e=this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());return this._updatePositionStrategy(e),e}_getFlexibleConnectedPositionStrategyOrigin(){return this.origin instanceof Md?this.origin.elementRef:this.origin}_attachOverlay(){this._overlayRef?this._overlayRef.getConfig().hasBackdrop=this.hasBackdrop:this._createOverlay(),this._overlayRef.hasAttached()||this._overlayRef.attach(this._templatePortal),this.hasBackdrop?this._backdropSubscription=this._overlayRef.backdropClick().subscribe(e=>{this.backdropClick.emit(e)}):this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this.positionChange.observers.length>0&&(this._positionSubscription=this._position.positionChanges.pipe(O_(()=>this.positionChange.observers.length>0)).subscribe(e=>{this.positionChange.emit(e),0===this.positionChange.observers.length&&this._positionSubscription.unsubscribe()}))}_detachOverlay(){this._overlayRef&&this._overlayRef.detach(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(oi),C(ei),C(r9),C(zi,8))},n.\u0275dir=Me({type:n,selectors:[["","cdk-connected-overlay",""],["","connected-overlay",""],["","cdkConnectedOverlay",""]],inputs:{origin:["cdkConnectedOverlayOrigin","origin"],positions:["cdkConnectedOverlayPositions","positions"],positionStrategy:["cdkConnectedOverlayPositionStrategy","positionStrategy"],offsetX:["cdkConnectedOverlayOffsetX","offsetX"],offsetY:["cdkConnectedOverlayOffsetY","offsetY"],width:["cdkConnectedOverlayWidth","width"],height:["cdkConnectedOverlayHeight","height"],minWidth:["cdkConnectedOverlayMinWidth","minWidth"],minHeight:["cdkConnectedOverlayMinHeight","minHeight"],backdropClass:["cdkConnectedOverlayBackdropClass","backdropClass"],panelClass:["cdkConnectedOverlayPanelClass","panelClass"],viewportMargin:["cdkConnectedOverlayViewportMargin","viewportMargin"],scrollStrategy:["cdkConnectedOverlayScrollStrategy","scrollStrategy"],open:["cdkConnectedOverlayOpen","open"],disableClose:["cdkConnectedOverlayDisableClose","disableClose"],transformOriginSelector:["cdkConnectedOverlayTransformOriginOn","transformOriginSelector"],hasBackdrop:["cdkConnectedOverlayHasBackdrop","hasBackdrop"],lockPosition:["cdkConnectedOverlayLockPosition","lockPosition"],flexibleDimensions:["cdkConnectedOverlayFlexibleDimensions","flexibleDimensions"],growAfterOpen:["cdkConnectedOverlayGrowAfterOpen","growAfterOpen"],push:["cdkConnectedOverlayPush","push"]},outputs:{backdropClick:"backdropClick",positionChange:"positionChange",attach:"attach",detach:"detach",overlayKeydown:"overlayKeydown",overlayOutsideClick:"overlayOutsideClick"},exportAs:["cdkConnectedOverlay"],standalone:!0,features:[qt]}),n})(),ube={provide:r9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},Do=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Oi,ube],imports:[Fu,Bl,Cd,Cd]}),n})();function pbe(n,t){if(1&n){let e=Te();f(0,"div",2)(1,"button",3),A("click",function(){return ne(e),ie(w().action())}),T(2),g()()}if(2&n){let e=w();v(2),Ve(" ",e.data.action," ")}}var hbe=["label"];function mbe(n,t){}var fbe=Math.pow(2,31)-1,Ah=class{constructor(t,e){this._overlayRef=e,this._afterDismissed=new Ee,this._afterOpened=new Ee,this._onAction=new Ee,this._dismissedByAction=!1,this.containerInstance=t,t._onExit.subscribe(()=>this._finishDismiss())}dismiss(){this._afterDismissed.closed||this.containerInstance.exit(),clearTimeout(this._durationTimeoutId)}dismissWithAction(){this._onAction.closed||(this._dismissedByAction=!0,this._onAction.next(),this._onAction.complete(),this.dismiss()),clearTimeout(this._durationTimeoutId)}closeWithAction(){this.dismissWithAction()}_dismissAfter(t){this._durationTimeoutId=setTimeout(()=>this.dismiss(),Math.min(t,fbe))}_open(){this._afterOpened.closed||(this._afterOpened.next(),this._afterOpened.complete())}_finishDismiss(){this._overlayRef.dispose(),this._onAction.closed||this._onAction.complete(),this._afterDismissed.next({dismissedByAction:this._dismissedByAction}),this._afterDismissed.complete(),this._dismissedByAction=!1}afterDismissed(){return this._afterDismissed}afterOpened(){return this.containerInstance._onEnter}onAction(){return this._onAction}},X1=new te("MatSnackBarData"),bg=class{constructor(){this.politeness="assertive",this.announcementMessage="",this.duration=0,this.data=null,this.horizontalPosition="center",this.verticalPosition="bottom"}},gbe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","matSnackBarLabel",""]],hostAttrs:[1,"mat-mdc-snack-bar-label","mdc-snackbar__label"]}),n})(),_be=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","matSnackBarActions",""]],hostAttrs:[1,"mat-mdc-snack-bar-actions","mdc-snackbar__actions"]}),n})(),bbe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","matSnackBarAction",""]],hostAttrs:[1,"mat-mdc-snack-bar-action","mdc-snackbar__action"]}),n})(),vbe=(()=>{class n{constructor(e,i){this.snackBarRef=e,this.data=i}action(){this.snackBarRef.dismissWithAction()}get hasAction(){return!!this.data.action}}return n.\u0275fac=function(e){return new(e||n)(C(Ah),C(X1))},n.\u0275cmp=P({type:n,selectors:[["simple-snack-bar"]],hostAttrs:[1,"mat-mdc-simple-snack-bar"],exportAs:["matSnackBar"],decls:3,vars:2,consts:[["matSnackBarLabel",""],["matSnackBarActions","",4,"ngIf"],["matSnackBarActions",""],["mat-button","","matSnackBarAction","",3,"click"]],template:function(e,i){1&e&&(f(0,"div",0),T(1),g(),S(2,pbe,3,1,"div",1)),2&e&&(v(1),Ve(" ",i.data.message,"\n"),v(1),b("ngIf",i.hasAction))},dependencies:[Ne,ki,gbe,_be,bbe],styles:[".mat-mdc-simple-snack-bar{display:flex}"],encapsulation:2,changeDetection:0}),n})(),ybe={snackBarState:fr("state",[Si("void, hidden",rn({transform:"scale(0.8)",opacity:0})),Si("visible",rn({transform:"scale(1)",opacity:1})),bi("* => visible",Mi("150ms cubic-bezier(0, 0, 0.2, 1)")),bi("* => void, * => hidden",Mi("75ms cubic-bezier(0.4, 0.0, 1, 1)",rn({opacity:0})))])},xbe=0,Cbe=(()=>{class n extends Nu{constructor(e,i,r,o,a){super(),this._ngZone=e,this._elementRef=i,this._changeDetectorRef=r,this._platform=o,this.snackBarConfig=a,this._document=$n(Nt),this._trackedModals=new Set,this._announceDelay=150,this._destroyed=!1,this._onAnnounce=new Ee,this._onExit=new Ee,this._onEnter=new Ee,this._animationState="void",this._liveElementId="mat-snack-bar-container-live-"+xbe++,this.attachDomPortal=s=>{this._assertNotAttached();let l=this._portalOutlet.attachDomPortal(s);return this._afterPortalAttached(),l},this._live="assertive"!==a.politeness||a.announcementMessage?"off"===a.politeness?"off":"polite":"assertive",this._platform.FIREFOX&&("polite"===this._live&&(this._role="status"),"assertive"===this._live&&(this._role="alert"))}attachComponentPortal(e){this._assertNotAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._afterPortalAttached(),i}attachTemplatePortal(e){this._assertNotAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._afterPortalAttached(),i}onAnimationEnd(e){let{fromState:i,toState:r}=e;if(("void"===r&&"void"!==i||"hidden"===r)&&this._completeExit(),"visible"===r){let o=this._onEnter;this._ngZone.run(()=>{o.next(),o.complete()})}}enter(){this._destroyed||(this._animationState="visible",this._changeDetectorRef.detectChanges(),this._screenReaderAnnounce())}exit(){return this._ngZone.run(()=>{this._animationState="hidden",this._elementRef.nativeElement.setAttribute("mat-exit",""),clearTimeout(this._announceTimeoutId)}),this._onExit}ngOnDestroy(){this._destroyed=!0,this._clearFromModals(),this._completeExit()}_completeExit(){this._ngZone.onMicrotaskEmpty.pipe(Lt(1)).subscribe(()=>{this._ngZone.run(()=>{this._onExit.next(),this._onExit.complete()})})}_afterPortalAttached(){let e=this._elementRef.nativeElement,i=this.snackBarConfig.panelClass;i&&(Array.isArray(i)?i.forEach(r=>e.classList.add(r)):e.classList.add(i)),this._exposeToModals()}_exposeToModals(){let e=this._liveElementId,i=this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');for(let r=0;r<i.length;r++){let o=i[r],a=o.getAttribute("aria-owns");this._trackedModals.add(o),a?-1===a.indexOf(e)&&o.setAttribute("aria-owns",a+" "+e):o.setAttribute("aria-owns",e)}}_clearFromModals(){this._trackedModals.forEach(e=>{let i=e.getAttribute("aria-owns");if(i){let r=i.replace(this._liveElementId,"").trim();r.length>0?e.setAttribute("aria-owns",r):e.removeAttribute("aria-owns")}}),this._trackedModals.clear()}_assertNotAttached(){this._portalOutlet.hasAttached()}_screenReaderAnnounce(){this._announceTimeoutId||this._ngZone.runOutsideAngular(()=>{this._announceTimeoutId=setTimeout(()=>{let e=this._elementRef.nativeElement.querySelector("[aria-hidden]"),i=this._elementRef.nativeElement.querySelector("[aria-live]");if(e&&i){let r=null;this._platform.isBrowser&&document.activeElement instanceof HTMLElement&&e.contains(document.activeElement)&&(r=document.activeElement),e.removeAttribute("aria-hidden"),i.appendChild(e),r?.focus(),this._onAnnounce.next(),this._onAnnounce.complete()}},this._announceDelay)})}}return n.\u0275fac=function(e){return new(e||n)(C(ot),C(xe),C(Qt),C(Vn),C(bg))},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&Ue(ba,7),2&e){let r;be(r=ve())&&(i._portalOutlet=r.first)}},features:[Xe]}),n})(),Mbe=(()=>{class n extends Cbe{_afterPortalAttached(){super._afterPortalAttached();let e=this._label.nativeElement,i="mdc-snackbar__label";e.classList.toggle(i,!e.querySelector(`.${i}`))}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-snack-bar-container"]],viewQuery:function(e,i){if(1&e&&Ue(hbe,7),2&e){let r;be(r=ve())&&(i._label=r.first)}},hostAttrs:[1,"mdc-snackbar","mat-mdc-snack-bar-container","mdc-snackbar--open"],hostVars:1,hostBindings:function(e,i){1&e&&UM("@state.done",function(o){return i.onAnimationEnd(o)}),2&e&&WM("@state",i._animationState)},features:[Xe],decls:6,vars:3,consts:[[1,"mdc-snackbar__surface"],[1,"mat-mdc-snack-bar-label"],["label",""],["aria-hidden","true"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1,2)(3,"div",3),S(4,mbe,0,0,"ng-template",4),g(),k(5,"div"),g()()),2&e&&(v(5),Be("aria-live",i._live)("role",i._role)("id",i._liveElementId))},dependencies:[ba],styles:['.mdc-snackbar{display:none;position:fixed;right:0;bottom:0;left:0;align-items:center;justify-content:center;box-sizing:border-box;pointer-events:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mdc-snackbar--opening,.mdc-snackbar--open,.mdc-snackbar--closing{display:flex}.mdc-snackbar--open .mdc-snackbar__label,.mdc-snackbar--open .mdc-snackbar__actions{visibility:visible}.mdc-snackbar__surface{padding-left:0;padding-right:8px;display:flex;align-items:center;justify-content:flex-start;box-sizing:border-box;transform:scale(0.8);opacity:0}.mdc-snackbar__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-snackbar__surface::before{border-color:CanvasText}}[dir=rtl] .mdc-snackbar__surface,.mdc-snackbar__surface[dir=rtl]{padding-left:8px;padding-right:0}.mdc-snackbar--open .mdc-snackbar__surface{transform:scale(1);opacity:1;pointer-events:auto}.mdc-snackbar--closing .mdc-snackbar__surface{transform:scale(1)}.mdc-snackbar__label{padding-left:16px;padding-right:8px;width:100%;flex-grow:1;box-sizing:border-box;margin:0;visibility:hidden;padding-top:14px;padding-bottom:14px}[dir=rtl] .mdc-snackbar__label,.mdc-snackbar__label[dir=rtl]{padding-left:8px;padding-right:16px}.mdc-snackbar__label::before{display:inline;content:attr(data-mdc-snackbar-label-text)}.mdc-snackbar__actions{display:flex;flex-shrink:0;align-items:center;box-sizing:border-box;visibility:hidden}.mdc-snackbar__action+.mdc-snackbar__dismiss{margin-left:8px;margin-right:0}[dir=rtl] .mdc-snackbar__action+.mdc-snackbar__dismiss,.mdc-snackbar__action+.mdc-snackbar__dismiss[dir=rtl]{margin-left:0;margin-right:8px}.mat-mdc-snack-bar-container{margin:8px;position:static}.mat-mdc-snack-bar-container .mdc-snackbar__surface{min-width:344px}@media(max-width: 480px),(max-width: 344px){.mat-mdc-snack-bar-container .mdc-snackbar__surface{min-width:100%}}@media(max-width: 480px),(max-width: 344px){.mat-mdc-snack-bar-container{width:100vw}}.mat-mdc-snack-bar-container .mdc-snackbar__surface{max-width:672px}.mat-mdc-snack-bar-container .mdc-snackbar__surface{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2), 0px 6px 10px 0px rgba(0, 0, 0, 0.14), 0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-mdc-snack-bar-container .mdc-snackbar__dismiss .mdc-button__icon{font-size:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px))}.mat-mdc-snack-bar-container .mdc-snackbar__dismiss svg,.mat-mdc-snack-bar-container .mdc-snackbar__dismiss img{width:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px));height:var(--mdc-icon-button-icon-size, var(--mdc-snackbar-icon-size, 24px))}.mat-mdc-snack-bar-container .mdc-snackbar__surface{background-color:var(--mdc-snackbar-container-color, inherit)}.mat-mdc-snack-bar-container .mdc-snackbar__surface{border-radius:var(--mdc-snackbar-container-shape, var(--mdc-shape-small, 4px))}.mat-mdc-snack-bar-container .mdc-snackbar__label{color:var(--mdc-snackbar-supporting-text-color, inherit)}.mat-mdc-snack-bar-container .mdc-snackbar__label{font-size:var(--mdc-snackbar-supporting-text-size, inherit);font-family:var(--mdc-snackbar-supporting-text-font, inherit);font-weight:var(--mdc-snackbar-supporting-text-weight, inherit);line-height:var(--mdc-snackbar-supporting-text-line-height, inherit)}.mat-mdc-snack-bar-container .mat-mdc-button.mat-mdc-snack-bar-action:not(:disabled){color:var(--mat-mdc-snack-bar-button-color, transparent);--mat-mdc-button-persistent-ripple-color: currentColor}.mat-mdc-snack-bar-container .mat-mdc-button.mat-mdc-snack-bar-action:not(:disabled) .mat-ripple-element{background-color:currentColor;opacity:.1}.mat-mdc-snack-bar-container .mdc-snackbar__label::before{display:none}.mat-mdc-snack-bar-handset,.mat-mdc-snack-bar-container,.mat-mdc-snack-bar-label{flex:1 1 auto}.mat-mdc-snack-bar-handset .mdc-snackbar__surface{width:100%}'],encapsulation:2,data:{animation:[ybe.snackBarState]}}),n})(),A2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Do,Bl,De,Kn,dn,dn]}),n})(),o9=new te("mat-snack-bar-default-options",{providedIn:"root",factory:function(){return new bg}}),Sbe=(()=>{class n{get _openedSnackBarRef(){let e=this._parentSnackBar;return e?e._openedSnackBarRef:this._snackBarRefAtThisLevel}set _openedSnackBarRef(e){this._parentSnackBar?this._parentSnackBar._openedSnackBarRef=e:this._snackBarRefAtThisLevel=e}constructor(e,i,r,o,a,s){this._overlay=e,this._live=i,this._injector=r,this._breakpointObserver=o,this._parentSnackBar=a,this._defaultConfig=s,this._snackBarRefAtThisLevel=null}openFromComponent(e,i){return this._attach(e,i)}openFromTemplate(e,i){return this._attach(e,i)}open(e,i="",r){let o={...this._defaultConfig,...r};return o.data={message:e,action:i},o.announcementMessage===e&&(o.announcementMessage=void 0),this.openFromComponent(this.simpleSnackBarComponent,o)}dismiss(){this._openedSnackBarRef&&this._openedSnackBarRef.dismiss()}ngOnDestroy(){this._snackBarRefAtThisLevel&&this._snackBarRefAtThisLevel.dismiss()}_attachSnackBarContainer(e,i){let o=wi.create({parent:i&&i.viewContainerRef&&i.viewContainerRef.injector||this._injector,providers:[{provide:bg,useValue:i}]}),a=new Ll(this.snackBarContainerComponent,i.viewContainerRef,o),s=e.attach(a);return s.instance.snackBarConfig=i,s.instance}_attach(e,i){let r={...new bg,...this._defaultConfig,...i},o=this._createOverlay(r),a=this._attachSnackBarContainer(o,r),s=new Ah(a,o);if(e instanceof oi){let l=new To(e,null,{$implicit:r.data,snackBarRef:s});s.instance=a.attachTemplatePortal(l)}else{let l=this._createInjector(r,s),c=new Ll(e,void 0,l),d=a.attachComponentPortal(c);s.instance=d.instance}return this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait)").pipe(it(o.detachments())).subscribe(l=>{o.overlayElement.classList.toggle(this.handsetCssClass,l.matches)}),r.announcementMessage&&a._onAnnounce.subscribe(()=>{this._live.announce(r.announcementMessage,r.politeness)}),this._animateSnackBar(s,r),this._openedSnackBarRef=s,this._openedSnackBarRef}_animateSnackBar(e,i){e.afterDismissed().subscribe(()=>{this._openedSnackBarRef==e&&(this._openedSnackBarRef=null),i.announcementMessage&&this._live.clear()}),this._openedSnackBarRef?(this._openedSnackBarRef.afterDismissed().subscribe(()=>{e.containerInstance.enter()}),this._openedSnackBarRef.dismiss()):e.containerInstance.enter(),i.duration&&i.duration>0&&e.afterOpened().subscribe(()=>e._dismissAfter(i.duration))}_createOverlay(e){let i=new el;i.direction=e.direction;let r=this._overlay.position().global(),o="rtl"===e.direction,a="left"===e.horizontalPosition||"start"===e.horizontalPosition&&!o||"end"===e.horizontalPosition&&o,s=!a&&"center"!==e.horizontalPosition;return a?r.left("0"):s?r.right("0"):r.centerHorizontally(),"top"===e.verticalPosition?r.top("0"):r.bottom("0"),i.positionStrategy=r,this._overlay.create(i)}_createInjector(e,i){return wi.create({parent:e&&e.viewContainerRef&&e.viewContainerRef.injector||this._injector,providers:[{provide:Ah,useValue:i},{provide:X1,useValue:e.data}]})}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(Hv),O(wi),O(Nv),O(n,12),O(o9))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),a9=(()=>{class n extends Sbe{constructor(e,i,r,o,a,s){super(e,i,r,o,a,s),this.simpleSnackBarComponent=vbe,this.snackBarContainerComponent=Mbe,this.handsetCssClass="mat-mdc-snack-bar-handset"}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(Hv),O(wi),O(Nv),O(n,12),O(o9))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:A2}),n})(),Ebe=/[\\^$.*+?()[\]{}|]/g,l9="\\u0000-\\u0020\\u007f-\\u009f",Dbe=new RegExp("(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s"+l9+'"]{2,}[^\\s'+l9+"\"')}\\],:;.!?]","gu");function d9(n){return function(n,t){t.flags.includes("g")||(t=new RegExp(t,t.flags+"g"));let e=[],i=0;for(let r of n.matchAll(t)){let o=r.index,a=r[0];o>i&&e.push({index:i,text:n.substring(i,o),matchesRegex:!1}),e.push({index:o,text:a,matchesRegex:!0}),i=o+a.length}return n.length>i&&e.push({index:i,text:n.substring(i,n.length),matchesRegex:!1}),e}(n,Dbe).map(({matchesRegex:t,text:e})=>({isURL:t,text:e}))}function Ibe(n,t){if(1&n&&(Gt(0),T(1),Wt()),2&n){let e=w().$implicit;v(1),Ve(" ",e.text," ")}}function Abe(n,t){if(1&n&&(f(0,"a",7),T(1),g()),2&n){let e=w().$implicit;Zi("href",e.text,Vs),v(1),kt(e.text)}}function Rbe(n,t){if(1&n&&(Gt(0),S(1,Ibe,2,1,"ng-container",5),S(2,Abe,2,2,"ng-template",null,6,jt),Wt()),2&n){let e=t.$implicit,i=st(3);v(1),b("ngIf",!e.isURL)("ngIfElse",i)}}function Pbe(n,t){if(1&n){let e=Te();f(0,"button",8),A("click",function(){return ne(e),ie(w().onActionButtonClicked())}),T(1),g()}if(2&n){let e=w();v(1),Ve(" ",e.alert.followupAction.localizedLabel," ")}}var u9=(()=>{class n{constructor(e,i,r){this.snackBarRef=e,this.unknownData=i,this.store=r,this.splitByURL=d9,this.alert=i}async onActionButtonClicked(){this.snackBarRef.dismiss();let e=await this.alert.followupAction.getFollowupAction();this.store.dispatch(e)}onCloseButtonClicked(){this.snackBarRef.dismiss()}}return n.\u0275fac=function(e){return new(e||n)(C(Ah),C(X1),C(Ie))},n.\u0275cmp=P({type:n,selectors:[["alert-display-snackbar"]],decls:6,vars:2,consts:function(){let t;return t=$localize`:A button to close the snackbar message␟ea4d9fe61420a3fce81cf54c4c615e3c19c646a6␟1536087519743707362:Dismiss`,[[1,"message"],[4,"ngFor","ngForOf"],[1,"controls"],["mat-button","","class","followup-button",3,"click",4,"ngIf"],["mat-button","","aria-label",t,1,"dismiss-button",3,"click"],[4,"ngIf","ngIfElse"],["linkPiece",""],["rel","noreferrer noopener","target","_blank",3,"href"],["mat-button","",1,"followup-button",3,"click"]]},template:function(e,i){1&e&&(f(0,"div",0),S(1,Rbe,4,2,"ng-container",1),g(),f(2,"div",2),S(3,Pbe,2,1,"button",3),f(4,"button",4),A("click",function(){return i.onCloseButtonClicked()}),T(5," Dismiss "),g()()),2&e&&(v(1),b("ngForOf",i.splitByURL(i.alert.localizedMessage)),v(2),b("ngIf",i.alert.followupAction))},dependencies:[nn,Ne,ki],styles:["[_nghost-%COMP%]{display:flex;flex-wrap:wrap}.message[_ngcontent-%COMP%]{font-size:14px;align-self:center;margin:5px 0;word-break:break-word}.message[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{color:inherit}.controls[_ngcontent-%COMP%]{white-space:nowrap;margin-left:auto}button.mat-mdc-button[_ngcontent-%COMP%]{color:inherit;text-transform:uppercase}"],changeDetection:0}),n})(),p9=(()=>{class n{constructor(e,i){this.store=e,this.snackBar=i,this.ngUnsubscribe=new Ee}ngOnInit(){this.store.select(eW).pipe(it(this.ngUnsubscribe),Oe(e=>Boolean(e))).subscribe(e=>{this.showAlert(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}showAlert(e){this.snackBar.openFromComponent(u9,{duration:5e3,horizontalPosition:"start",verticalPosition:"bottom",data:e})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(a9))},n.\u0275cmp=P({type:n,selectors:[["alert-snackbar"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Y1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Kn,A2]}),n})(),Q1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Cc,Y1,wr.forFeature("alerts",p7),to.forFeature([u7])]}),n})();function Obe(n,t){}var Rh=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.closeOnNavigation=!0,this.closeOnDestroy=!0,this.closeOnOverlayDetachments=!0}},P2=(()=>{class n extends Nu{constructor(e,i,r,o,a,s,l,c){super(),this._elementRef=e,this._focusTrapFactory=i,this._config=o,this._interactivityChecker=a,this._ngZone=s,this._overlayRef=l,this._focusMonitor=c,this._elementFocusedBeforeDialogWasOpened=null,this._closeInteractionType=null,this.attachDomPortal=d=>{this._portalOutlet.hasAttached();let u=this._portalOutlet.attachDomPortal(d);return this._contentAttached(),u},this._ariaLabelledBy=this._config.ariaLabelledBy||null,this._document=r}_contentAttached(){this._initializeFocusTrap(),this._handleBackdropClicks(),this._captureInitialFocus()}_captureInitialFocus(){this._trapFocus()}ngOnDestroy(){this._restoreFocus()}attachComponentPortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._contentAttached(),i}attachTemplatePortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._contentAttached(),i}_recaptureFocus(){this._containsFocus()||this._trapFocus()}_forceFocus(e,i){this._interactivityChecker.isFocusable(e)||(e.tabIndex=-1,this._ngZone.runOutsideAngular(()=>{let r=()=>{e.removeEventListener("blur",r),e.removeEventListener("mousedown",r),e.removeAttribute("tabindex")};e.addEventListener("blur",r),e.addEventListener("mousedown",r)})),e.focus(i)}_focusByCssSelector(e,i){let r=this._elementRef.nativeElement.querySelector(e);r&&this._forceFocus(r,i)}_trapFocus(){let e=this._elementRef.nativeElement;switch(this._config.autoFocus){case!1:case"dialog":this._containsFocus()||e.focus();break;case!0:case"first-tabbable":this._focusTrap.focusInitialElementWhenReady().then(i=>{i||this._focusDialogContainer()});break;case"first-heading":this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role="heading"]');break;default:this._focusByCssSelector(this._config.autoFocus)}}_restoreFocus(){let e=this._config.restoreFocus,i=null;if("string"==typeof e?i=this._document.querySelector(e):"boolean"==typeof e?i=e?this._elementFocusedBeforeDialogWasOpened:null:e&&(i=e),this._config.restoreFocus&&i&&"function"==typeof i.focus){let r=Ov(),o=this._elementRef.nativeElement;(!r||r===this._document.body||r===o||o.contains(r))&&(this._focusMonitor?(this._focusMonitor.focusVia(i,this._closeInteractionType),this._closeInteractionType=null):i.focus())}this._focusTrap&&this._focusTrap.destroy()}_focusDialogContainer(){this._elementRef.nativeElement.focus&&this._elementRef.nativeElement.focus()}_containsFocus(){let e=this._elementRef.nativeElement,i=Ov();return e===i||e.contains(i)}_initializeFocusTrap(){this._focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement),this._document&&(this._elementFocusedBeforeDialogWasOpened=Ov())}_handleBackdropClicks(){this._overlayRef.backdropClick().subscribe(()=>{this._config.disableClose&&this._recaptureFocus()})}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Lv),C(Nt,8),C(Rh),C(ug),C(ot),C(Ac),C(fo))},n.\u0275cmp=P({type:n,selectors:[["cdk-dialog-container"]],viewQuery:function(e,i){if(1&e&&Ue(ba,7),2&e){let r;be(r=ve())&&(i._portalOutlet=r.first)}},hostAttrs:["tabindex","-1",1,"cdk-dialog-container"],hostVars:6,hostBindings:function(e,i){2&e&&Be("id",i._config.id||null)("role",i._config.role)("aria-modal",i._config.ariaModal)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null)},features:[Xe],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&S(0,Obe,0,0,"ng-template",0)},dependencies:[ba],styles:[".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}"],encapsulation:2}),n})(),qv=class{constructor(t,e){this.overlayRef=t,this.config=e,this.closed=new Ee,this.disableClose=e.disableClose,this.backdropClick=t.backdropClick(),this.keydownEvents=t.keydownEvents(),this.outsidePointerEvents=t.outsidePointerEvents(),this.id=e.id,this.keydownEvents.subscribe(i=>{27===i.keyCode&&!this.disableClose&&!Or(i)&&(i.preventDefault(),this.close(void 0,{focusOrigin:"keyboard"}))}),this.backdropClick.subscribe(()=>{this.disableClose||this.close(void 0,{focusOrigin:"mouse"})}),this._detachSubscription=t.detachments().subscribe(()=>{!1!==e.closeOnOverlayDetachments&&this.close()})}close(t,e){if(this.containerInstance){let i=this.closed;this.containerInstance._closeInteractionType=e?.focusOrigin||"program",this._detachSubscription.unsubscribe(),this.overlayRef.dispose(),i.next(t),i.complete(),this.componentInstance=this.containerInstance=null}}updatePosition(){return this.overlayRef.updatePosition(),this}updateSize(t="",e=""){return this.overlayRef.updateSize({width:t,height:e}),this}addPanelClass(t){return this.overlayRef.addPanelClass(t),this}removePanelClass(t){return this.overlayRef.removePanelClass(t),this}},h9=new te("DialogScrollStrategy"),Fbe=new te("DialogData"),Nbe=new te("DefaultDialogConfig"),Bbe={provide:h9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.block()}},Vbe=0,k2=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}constructor(e,i,r,o,a,s){this._overlay=e,this._injector=i,this._defaultOptions=r,this._parentDialog=o,this._overlayContainer=a,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ee,this._afterOpenedAtThisLevel=new Ee,this._ariaHiddenElements=new Map,this.afterAllClosed=is(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(kn(void 0))),this._scrollStrategy=s}open(e,i){(i={...this._defaultOptions||new Rh,...i}).id=i.id||"cdk-dialog-"+Vbe++,i.id&&this.getDialogById(i.id);let o=this._getOverlayConfig(i),a=this._overlay.create(o),s=new qv(a,i),l=this._attachContainer(a,s,i);return s.containerInstance=l,this._attachDialogContent(e,s,l,i),this.openDialogs.length||this._hideNonDialogContentFromAssistiveTechnology(),this.openDialogs.push(s),s.closed.subscribe(()=>this._removeOpenDialog(s,!0)),this.afterOpened.next(s),s}closeAll(){R2(this.openDialogs,e=>e.close())}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){R2(this._openDialogsAtThisLevel,e=>{!1===e.config.closeOnDestroy&&this._removeOpenDialog(e,!1)}),R2(this._openDialogsAtThisLevel,e=>e.close()),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete(),this._openDialogsAtThisLevel=[]}_getOverlayConfig(e){let i=new el({positionStrategy:e.positionStrategy||this._overlay.position().global().centerHorizontally().centerVertically(),scrollStrategy:e.scrollStrategy||this._scrollStrategy(),panelClass:e.panelClass,hasBackdrop:e.hasBackdrop,direction:e.direction,minWidth:e.minWidth,minHeight:e.minHeight,maxWidth:e.maxWidth,maxHeight:e.maxHeight,width:e.width,height:e.height,disposeOnNavigation:e.closeOnNavigation});return e.backdropClass&&(i.backdropClass=e.backdropClass),i}_attachContainer(e,i,r){let s,o=r.injector||r.viewContainerRef?.injector,a=[{provide:Rh,useValue:r},{provide:qv,useValue:i},{provide:Ac,useValue:e}];r.container?"function"==typeof r.container?s=r.container:(s=r.container.type,a.push(...r.container.providers(r))):s=P2;let l=new Ll(s,r.viewContainerRef,wi.create({parent:o||this._injector,providers:a}),r.componentFactoryResolver);return e.attach(l).instance}_attachDialogContent(e,i,r,o){if(e instanceof oi){let a=this._createInjector(o,i,r,void 0),s={$implicit:o.data,dialogRef:i};o.templateContext&&(s={...s,..."function"==typeof o.templateContext?o.templateContext():o.templateContext}),r.attachTemplatePortal(new To(e,null,s,a))}else{let a=this._createInjector(o,i,r,this._injector),s=r.attachComponentPortal(new Ll(e,o.viewContainerRef,a,o.componentFactoryResolver));i.componentInstance=s.instance}}_createInjector(e,i,r,o){let a=e.injector||e.viewContainerRef?.injector,s=[{provide:Fbe,useValue:e.data},{provide:qv,useValue:i}];return e.providers&&("function"==typeof e.providers?s.push(...e.providers(i,e,r)):s.push(...e.providers)),e.direction&&(!a||!a.get(zi,null,{optional:!0}))&&s.push({provide:zi,useValue:{value:e.direction,change:$t()}}),wi.create({parent:a||o,providers:s})}_removeOpenDialog(e,i){let r=this.openDialogs.indexOf(e);r>-1&&(this.openDialogs.splice(r,1),this.openDialogs.length||(this._ariaHiddenElements.forEach((o,a)=>{o?a.setAttribute("aria-hidden",o):a.removeAttribute("aria-hidden")}),this._ariaHiddenElements.clear(),i&&this._getAfterAllClosed().next()))}_hideNonDialogContentFromAssistiveTechnology(){let e=this._overlayContainer.getContainerElement();if(e.parentElement){let i=e.parentElement.children;for(let r=i.length-1;r>-1;r--){let o=i[r];o!==e&&"SCRIPT"!==o.nodeName&&"STYLE"!==o.nodeName&&!o.hasAttribute("aria-live")&&(this._ariaHiddenElements.set(o,o.getAttribute("aria-hidden")),o.setAttribute("aria-hidden","true"))}}}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(wi),O(Nbe,8),O(n,12),O(_g),O(h9))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})();function R2(n,t){let e=n.length;for(;e--;)t(n[e])}var m9=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[k2,Bbe],imports:[Do,Bl,pg,Bl]}),n})();function Hbe(n,t){}var vg=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.maxWidth="80vw",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.delayFocusTrap=!0,this.closeOnNavigation=!0}},O2="mdc-dialog--open",f9="mdc-dialog--opening",g9="mdc-dialog--closing",jbe=(()=>{class n extends P2{constructor(e,i,r,o,a,s,l,c){super(e,i,r,o,a,s,l,c),this._animationStateChanged=new F}_captureInitialFocus(){this._config.delayFocusTrap||this._trapFocus()}_openAnimationDone(e){this._config.delayFocusTrap&&this._trapFocus(),this._animationStateChanged.next({state:"opened",totalTime:e})}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Lv),C(Nt,8),C(vg),C(ug),C(ot),C(Ac),C(fo))},n.\u0275cmp=P({type:n,selectors:[["ng-component"]],features:[Xe],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),_9="--mat-dialog-transition-duration";function b9(n){return null==n?null:"number"==typeof n?n:n.endsWith("ms")?mi(n.substring(0,n.length-2)):n.endsWith("s")?1e3*mi(n.substring(0,n.length-1)):"0"===n?0:null}var Gbe=(()=>{class n extends jbe{constructor(e,i,r,o,a,s,l,c,d){super(e,i,r,o,a,s,l,d),this._animationMode=c,this._animationsEnabled="NoopAnimations"!==this._animationMode,this._hostElement=this._elementRef.nativeElement,this._openAnimationDuration=this._animationsEnabled?b9(this._config.enterAnimationDuration)??150:0,this._closeAnimationDuration=this._animationsEnabled?b9(this._config.exitAnimationDuration)??75:0,this._animationTimer=null,this._finishDialogOpen=()=>{this._clearAnimationClasses(),this._openAnimationDone(this._openAnimationDuration)},this._finishDialogClose=()=>{this._clearAnimationClasses(),this._animationStateChanged.emit({state:"closed",totalTime:this._closeAnimationDuration})}}_contentAttached(){super._contentAttached(),this._startOpenAnimation()}ngOnDestroy(){super.ngOnDestroy(),null!==this._animationTimer&&clearTimeout(this._animationTimer)}_startOpenAnimation(){this._animationStateChanged.emit({state:"opening",totalTime:this._openAnimationDuration}),this._animationsEnabled?(this._hostElement.style.setProperty(_9,`${this._openAnimationDuration}ms`),this._requestAnimationFrame(()=>this._hostElement.classList.add(f9,O2)),this._waitForAnimationToComplete(this._openAnimationDuration,this._finishDialogOpen)):(this._hostElement.classList.add(O2),Promise.resolve().then(()=>this._finishDialogOpen()))}_startExitAnimation(){this._animationStateChanged.emit({state:"closing",totalTime:this._closeAnimationDuration}),this._hostElement.classList.remove(O2),this._animationsEnabled?(this._hostElement.style.setProperty(_9,`${this._openAnimationDuration}ms`),this._requestAnimationFrame(()=>this._hostElement.classList.add(g9)),this._waitForAnimationToComplete(this._closeAnimationDuration,this._finishDialogClose)):Promise.resolve().then(()=>this._finishDialogClose())}_clearAnimationClasses(){this._hostElement.classList.remove(f9,g9)}_waitForAnimationToComplete(e,i){null!==this._animationTimer&&clearTimeout(this._animationTimer),this._animationTimer=setTimeout(i,e)}_requestAnimationFrame(e){this._ngZone.runOutsideAngular(()=>{"function"==typeof requestAnimationFrame?requestAnimationFrame(e):e()})}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Lv),C(Nt,8),C(vg),C(ug),C(ot),C(Ac),C(pi,8),C(fo))},n.\u0275cmp=P({type:n,selectors:[["mat-dialog-container"]],hostAttrs:["tabindex","-1",1,"mat-mdc-dialog-container","mdc-dialog"],hostVars:8,hostBindings:function(e,i){2&e&&(wo("id",i._config.id),Be("aria-modal",i._config.ariaModal)("role",i._config.role)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null),nt("_mat-animation-noopable",!i._animationsEnabled))},features:[Xe],decls:3,vars:0,consts:[[1,"mdc-dialog__container"],[1,"mat-mdc-dialog-surface","mdc-dialog__surface"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1),S(2,Hbe,0,0,"ng-template",2),g()())},dependencies:[ba],styles:['.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-dialog,.mdc-dialog__scrim{position:fixed;top:0;left:0;align-items:center;justify-content:center;box-sizing:border-box;width:100%;height:100%}.mdc-dialog{display:none;z-index:var(--mdc-dialog-z-index, 7)}.mdc-dialog .mdc-dialog__content{padding:20px 24px 20px 24px}.mdc-dialog .mdc-dialog__surface{min-width:280px}@media(max-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:calc(100vw - 32px)}}@media(min-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:560px}}.mdc-dialog .mdc-dialog__surface{max-height:calc(100% - 32px)}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-width:none}@media(max-width: 960px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px;width:560px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:calc(100vw - 112px)}}@media(max-width: 720px)and (min-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:560px}}@media(max-width: 720px)and (max-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:calc(100vh - 160px)}}@media(max-width: 720px)and (min-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px}}@media(max-width: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-height: 400px),(max-width: 600px),(min-width: 720px)and (max-height: 400px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{height:100%;max-height:100vh;max-width:100vw;width:100vw;border-radius:0}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{order:-1;left:-12px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__header{padding:0 16px 9px;justify-content:flex-start}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__title{margin-left:calc(16px - 2 * 12px)}}@media(min-width: 960px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{width:calc(100vw - 400px)}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}.mdc-dialog.mdc-dialog__scrim--hidden .mdc-dialog__scrim{opacity:0}.mdc-dialog__scrim{opacity:0;z-index:-1}.mdc-dialog__container{display:flex;flex-direction:row;align-items:center;justify-content:space-around;box-sizing:border-box;height:100%;transform:scale(0.8);opacity:0;pointer-events:none}.mdc-dialog__surface{position:relative;display:flex;flex-direction:column;flex-grow:0;flex-shrink:0;box-sizing:border-box;max-width:100%;max-height:100%;pointer-events:auto;overflow-y:auto}.mdc-dialog__surface .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}[dir=rtl] .mdc-dialog__surface,.mdc-dialog__surface[dir=rtl]{text-align:right}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-dialog__surface{outline:2px solid windowText}}.mdc-dialog__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:2px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-dialog__surface::before{border-color:CanvasText}}@media screen and (-ms-high-contrast: active),screen and (-ms-high-contrast: none){.mdc-dialog__surface::before{content:none}}.mdc-dialog__title{display:block;margin-top:0;position:relative;flex-shrink:0;box-sizing:border-box;margin:0 0 1px;padding:0 24px 9px}.mdc-dialog__title::before{display:inline-block;width:0;height:40px;content:"";vertical-align:0}[dir=rtl] .mdc-dialog__title,.mdc-dialog__title[dir=rtl]{text-align:right}.mdc-dialog--scrollable .mdc-dialog__title{margin-bottom:1px;padding-bottom:15px}.mdc-dialog--fullscreen .mdc-dialog__header{align-items:baseline;border-bottom:1px solid rgba(0,0,0,0);display:inline-flex;justify-content:space-between;padding:0 24px 9px;z-index:1}@media screen and (forced-colors: active){.mdc-dialog--fullscreen .mdc-dialog__header{border-bottom-color:CanvasText}}.mdc-dialog--fullscreen .mdc-dialog__header .mdc-dialog__close{right:-12px}.mdc-dialog--fullscreen .mdc-dialog__title{margin-bottom:0;padding:0;border-bottom:0}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__title{border-bottom:0;margin-bottom:0}.mdc-dialog--fullscreen .mdc-dialog__close{top:5px}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__actions{border-top:1px solid rgba(0,0,0,0)}@media screen and (forced-colors: active){.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__actions{border-top-color:CanvasText}}.mdc-dialog--fullscreen--titleless .mdc-dialog__close{margin-top:4px}.mdc-dialog--fullscreen--titleless.mdc-dialog--scrollable .mdc-dialog__close{margin-top:0}.mdc-dialog__content{flex-grow:1;box-sizing:border-box;margin:0;overflow:auto}.mdc-dialog__content>:first-child{margin-top:0}.mdc-dialog__content>:last-child{margin-bottom:0}.mdc-dialog__title+.mdc-dialog__content,.mdc-dialog__header+.mdc-dialog__content{padding-top:0}.mdc-dialog--scrollable .mdc-dialog__title+.mdc-dialog__content{padding-top:8px;padding-bottom:8px}.mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:6px 0 0}.mdc-dialog--scrollable .mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:0}.mdc-dialog__actions{display:flex;position:relative;flex-shrink:0;flex-wrap:wrap;align-items:center;justify-content:flex-end;box-sizing:border-box;min-height:52px;margin:0;padding:8px;border-top:1px solid rgba(0,0,0,0)}@media screen and (forced-colors: active){.mdc-dialog__actions{border-top-color:CanvasText}}.mdc-dialog--stacked .mdc-dialog__actions{flex-direction:column;align-items:flex-end}.mdc-dialog__button{margin-left:8px;margin-right:0;max-width:100%;text-align:right}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{margin-left:0;margin-right:8px}.mdc-dialog__button:first-child{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button:first-child,.mdc-dialog__button:first-child[dir=rtl]{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{text-align:left}.mdc-dialog--stacked .mdc-dialog__button:not(:first-child){margin-top:12px}.mdc-dialog--open,.mdc-dialog--opening,.mdc-dialog--closing{display:flex}.mdc-dialog--opening .mdc-dialog__scrim{transition:opacity 150ms linear}.mdc-dialog--opening .mdc-dialog__container{transition:opacity 75ms linear,transform 150ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-dialog--closing .mdc-dialog__scrim,.mdc-dialog--closing .mdc-dialog__container{transition:opacity 75ms linear}.mdc-dialog--closing .mdc-dialog__container{transform:none}.mdc-dialog--open .mdc-dialog__scrim{opacity:1}.mdc-dialog--open .mdc-dialog__container{transform:none;opacity:1}.mdc-dialog--open.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim{opacity:1}.mdc-dialog--open.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{transition:opacity 75ms linear}.mdc-dialog--open.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim{transition:opacity 150ms linear}.mdc-dialog__surface-scrim{display:none;opacity:0;position:absolute;width:100%;height:100%;z-index:1}.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{display:block}.mdc-dialog-scroll-lock{overflow:hidden}.mdc-dialog--no-content-padding .mdc-dialog__content{padding:0}.mdc-dialog--sheet .mdc-dialog__close{right:12px;top:9px;position:absolute;z-index:1}.mdc-dialog__scrim--removed{pointer-events:none}.mdc-dialog__scrim--removed .mdc-dialog__scrim,.mdc-dialog__scrim--removed .mdc-dialog__surface-scrim{display:none}.mat-mdc-dialog-content{max-height:65vh}.mat-mdc-dialog-container{position:static;display:block}.mat-mdc-dialog-container,.mat-mdc-dialog-container .mdc-dialog__container,.mat-mdc-dialog-container .mdc-dialog__surface{max-height:inherit;min-height:inherit;min-width:inherit;max-width:inherit}.mat-mdc-dialog-container .mdc-dialog__surface{display:block;width:100%;height:100%}.mat-mdc-dialog-container{outline:0}.mat-mdc-dialog-container .mdc-dialog__surface{background-color:var(--mdc-dialog-container-color, white)}.mat-mdc-dialog-container .mdc-dialog__surface{box-shadow:var(--mdc-dialog-container-elevation, 0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12))}.mat-mdc-dialog-container .mdc-dialog__surface{border-radius:var(--mdc-dialog-container-shape, var(--mdc-shape-medium, 4px))}.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__title,.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__actions,.mat-mdc-dialog-container.mdc-dialog--scrollable.mdc-dialog-scroll-divider-footer .mdc-dialog__actions{border-color:var(--mdc-dialog-with-divider-divider-color, black)}.mat-mdc-dialog-container.mdc-dialog--scrollable .mdc-dialog__title{border-bottom-color:var(--mdc-dialog-with-divider-divider-color, black)}.mat-mdc-dialog-container .mdc-dialog__title{font-family:var(--mdc-dialog-subhead-font, "Arial");line-height:var(--mdc-dialog-subhead-line-height, 14px);font-size:var(--mdc-dialog-subhead-size, 14px);font-weight:var(--mdc-dialog-subhead-weight, 500);letter-spacing:var(--mdc-dialog-subhead-tracking, 1px)}.mat-mdc-dialog-container .mdc-dialog__title{color:var(--mdc-dialog-subhead-color, black)}.mat-mdc-dialog-container .mdc-dialog__content{font-family:var(--mdc-dialog-supporting-text-font, "Arial");line-height:var(--mdc-dialog-supporting-text-line-height, 14px);font-size:var(--mdc-dialog-supporting-text-size, 14px);font-weight:var(--mdc-dialog-supporting-text-weight, 500);letter-spacing:var(--mdc-dialog-supporting-text-tracking, 1px)}.mat-mdc-dialog-container .mdc-dialog__content{color:var(--mdc-dialog-supporting-text-color, black)}.mat-mdc-dialog-container .mdc-dialog__container{transition-duration:var(--mat-dialog-transition-duration, 0ms)}.mat-mdc-dialog-container._mat-animation-noopable .mdc-dialog__container{transition:none}.mat-mdc-dialog-content{display:block}.mat-mdc-dialog-actions{justify-content:start}.mat-mdc-dialog-actions.mat-mdc-dialog-actions-align-center,.mat-mdc-dialog-actions[align=center]{justify-content:center}.mat-mdc-dialog-actions.mat-mdc-dialog-actions-align-end,.mat-mdc-dialog-actions[align=end]{justify-content:flex-end}.mat-mdc-dialog-actions .mat-button-base+.mat-button-base,.mat-mdc-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-mdc-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-mdc-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}'],encapsulation:2}),n})(),Vl=class{constructor(t,e,i){this._ref=t,this._containerInstance=i,this._afterOpened=new Ee,this._beforeClosed=new Ee,this._state=0,this.disableClose=e.disableClose,this.id=t.id,i._animationStateChanged.pipe(Oe(r=>"opened"===r.state),Lt(1)).subscribe(()=>{this._afterOpened.next(),this._afterOpened.complete()}),i._animationStateChanged.pipe(Oe(r=>"closed"===r.state),Lt(1)).subscribe(()=>{clearTimeout(this._closeFallbackTimeout),this._finishDialogClose()}),t.overlayRef.detachments().subscribe(()=>{this._beforeClosed.next(this._result),this._beforeClosed.complete(),this._finishDialogClose()}),tn(this.backdropClick(),this.keydownEvents().pipe(Oe(r=>27===r.keyCode&&!this.disableClose&&!Or(r)))).subscribe(r=>{this.disableClose||(r.preventDefault(),y9(this,"keydown"===r.type?"keyboard":"mouse"))})}close(t){this._result=t,this._containerInstance._animationStateChanged.pipe(Oe(e=>"closing"===e.state),Lt(1)).subscribe(e=>{this._beforeClosed.next(t),this._beforeClosed.complete(),this._ref.overlayRef.detachBackdrop(),this._closeFallbackTimeout=setTimeout(()=>this._finishDialogClose(),e.totalTime+100)}),this._state=1,this._containerInstance._startExitAnimation()}afterOpened(){return this._afterOpened}afterClosed(){return this._ref.closed}beforeClosed(){return this._beforeClosed}backdropClick(){return this._ref.backdropClick}keydownEvents(){return this._ref.keydownEvents}updatePosition(t){let e=this._ref.config.positionStrategy;return t&&(t.left||t.right)?t.left?e.left(t.left):e.right(t.right):e.centerHorizontally(),t&&(t.top||t.bottom)?t.top?e.top(t.top):e.bottom(t.bottom):e.centerVertically(),this._ref.updatePosition(),this}updateSize(t="",e=""){return this._ref.updateSize(t,e),this}addPanelClass(t){return this._ref.addPanelClass(t),this}removePanelClass(t){return this._ref.removePanelClass(t),this}getState(){return this._state}_finishDialogClose(){this._state=2,this._ref.close(this._result,{focusOrigin:this._closeInteractionType}),this.componentInstance=null}};function y9(n,t,e){return n._closeInteractionType=t,n.close(e)}var Xv=new te("MatMdcDialogData"),Wbe=new te("mat-mdc-dialog-default-options"),x9=new te("mat-mdc-dialog-scroll-strategy"),Xbe={provide:x9,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.block()}},Ybe=0,Qbe=(()=>{class n{get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}constructor(e,i,r,o,a,s,l,c,d,u){this._overlay=e,this._defaultOptions=r,this._parentDialog=o,this._dialogRefConstructor=l,this._dialogContainerType=c,this._dialogDataToken=d,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new Ee,this._afterOpenedAtThisLevel=new Ee,this._idPrefix="mat-dialog-",this.dialogConfigClass=vg,this.afterAllClosed=is(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(kn(void 0))),this._scrollStrategy=s,this._dialog=i.get(k2)}open(e,i){let r;(i={...this._defaultOptions||new vg,...i}).id=i.id||`${this._idPrefix}${Ybe++}`,i.scrollStrategy=i.scrollStrategy||this._scrollStrategy();let o=this._dialog.open(e,{...i,positionStrategy:this._overlay.position().global().centerHorizontally().centerVertically(),disableClose:!0,closeOnDestroy:!1,closeOnOverlayDetachments:!1,container:{type:this._dialogContainerType,providers:()=>[{provide:this.dialogConfigClass,useValue:i},{provide:Rh,useValue:i}]},templateContext:()=>({dialogRef:r}),providers:(a,s,l)=>(r=new this._dialogRefConstructor(a,i,l),r.updatePosition(i?.position),[{provide:this._dialogContainerType,useValue:l},{provide:this._dialogDataToken,useValue:s.data},{provide:this._dialogRefConstructor,useValue:r}])});return r.componentInstance=o.componentInstance,this.openDialogs.push(r),this.afterOpened.next(r),r.afterClosed().subscribe(()=>{let a=this.openDialogs.indexOf(r);a>-1&&(this.openDialogs.splice(a,1),this.openDialogs.length||this._getAfterAllClosed().next())}),r}closeAll(){this._closeDialogs(this.openDialogs)}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){this._closeDialogs(this._openDialogsAtThisLevel),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete()}_closeDialogs(e){let i=e.length;for(;i--;)e[i].close()}}return n.\u0275fac=function(e){cs()},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),ys=(()=>{class n extends Qbe{constructor(e,i,r,o,a,s,l,c){super(e,i,o,s,l,a,Vl,Gbe,Xv,c),this._idPrefix="mat-mdc-dialog-"}}return n.\u0275fac=function(e){return new(e||n)(O(Oi),O(wi),O(Db,8),O(Wbe,8),O(x9),O(n,12),O(_g),O(pi,8))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Zbe=0,Z1=(()=>{class n{constructor(e,i,r){this.dialogRef=e,this._elementRef=i,this._dialog=r,this.type="button"}ngOnInit(){this.dialogRef||(this.dialogRef=M9(this._elementRef,this._dialog.openDialogs))}ngOnChanges(e){let i=e._matDialogClose||e._matDialogCloseResult;i&&(this.dialogResult=i.currentValue)}_onButtonClick(e){y9(this.dialogRef,0===e.screenX&&0===e.screenY?"keyboard":"mouse",this.dialogResult)}}return n.\u0275fac=function(e){return new(e||n)(C(Vl,8),C(xe),C(ys))},n.\u0275dir=Me({type:n,selectors:[["","mat-dialog-close",""],["","matDialogClose",""]],hostVars:2,hostBindings:function(e,i){1&e&&A("click",function(o){return i._onButtonClick(o)}),2&e&&Be("aria-label",i.ariaLabel||null)("type",i.type)},inputs:{ariaLabel:["aria-label","ariaLabel"],type:"type",dialogResult:["mat-dialog-close","dialogResult"],_matDialogClose:["matDialogClose","_matDialogClose"]},exportAs:["matDialogClose"],features:[qt]}),n})(),C9=(()=>{class n{constructor(e,i,r){this._dialogRef=e,this._elementRef=i,this._dialog=r,this.id="mat-mdc-dialog-title-"+Zbe++}ngOnInit(){this._dialogRef||(this._dialogRef=M9(this._elementRef,this._dialog.openDialogs)),this._dialogRef&&Promise.resolve().then(()=>{let e=this._dialogRef._containerInstance;e&&!e._ariaLabelledBy&&(e._ariaLabelledBy=this.id)})}}return n.\u0275fac=function(e){return new(e||n)(C(Vl,8),C(xe),C(ys))},n.\u0275dir=Me({type:n,selectors:[["","mat-dialog-title",""],["","matDialogTitle",""]],hostAttrs:[1,"mat-mdc-dialog-title","mdc-dialog__title"],hostVars:1,hostBindings:function(e,i){2&e&&wo("id",i.id)},inputs:{id:"id"},exportAs:["matDialogTitle"]}),n})(),K1=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","mat-dialog-content",""],["mat-dialog-content"],["","matDialogContent",""]],hostAttrs:[1,"mat-mdc-dialog-content","mdc-dialog__content"]}),n})(),J1=(()=>{class n{constructor(){this.align="start"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","mat-dialog-actions",""],["mat-dialog-actions"],["","matDialogActions",""]],hostAttrs:[1,"mat-mdc-dialog-actions","mdc-dialog__actions"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-mdc-dialog-actions-align-center","center"===i.align)("mat-mdc-dialog-actions-align-end","end"===i.align)},inputs:{align:"align"}}),n})();function M9(n,t){let e=n.nativeElement.parentElement;for(;e&&!e.classList.contains("mat-mdc-dialog-container");)e=e.parentElement;return e?t.find(i=>i.id===e.id):null}var Hu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[ys,Xbe],imports:[m9,Do,Bl,dn,dn]}),n})(),v9={params:{enterAnimationDuration:"150ms",exitAnimationDuration:"75ms"}},Kbe=(fr("dialogContainer",[Si("void, exit",rn({opacity:0,transform:"scale(0.7)"})),Si("enter",rn({transform:"none"})),bi("* => enter",Lb([Mi("{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)",rn({transform:"none",opacity:1})),rh("@*",ih(),{optional:!0})]),v9),bi("* => void, * => exit",Lb([Mi("{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)",rn({opacity:0})),rh("@*",ih(),{optional:!0})]),v9)]),["matFormFieldNotchedOutline",""]),Jbe=["*"],$be=["textField"],eve=["iconPrefixContainer"],tve=["textPrefixContainer"];function nve(n,t){1&n&&k(0,"span",19)}function ive(n,t){if(1&n){let e=Te();f(0,"label",17),A("cdkObserveContent",function(){return ne(e),ie(w(2)._refreshOutlineNotchWidth())}),Tt(1,1),S(2,nve,1,0,"span",18),g()}if(2&n){let e=w(2);b("floating",e._shouldLabelFloat())("cdkObserveContentDisabled",!e._hasOutline())("id",e._labelId),Be("for",e._control.id)("aria-owns",e._control.id),v(2),b("ngIf",!e.hideRequiredMarker&&e._control.required)}}function rve(n,t){1&n&&S(0,ive,3,6,"label",16),2&n&&b("ngIf",w()._hasFloatingLabel())}function ove(n,t){1&n&&k(0,"div",20)}function ave(n,t){}function sve(n,t){1&n&&S(0,ave,0,0,"ng-template",22),2&n&&(w(2),b("ngTemplateOutlet",st(1)))}function lve(n,t){if(1&n&&(f(0,"div",21),S(1,sve,1,1,"ng-template",9),g()),2&n){let e=w();b("matFormFieldNotchedOutlineOpen",e._shouldLabelFloat())("matFormFieldNotchedOutlineLabelWidth",e._labelWidth),v(1),b("ngIf",!e._forceDisplayInfixLabel())}}function cve(n,t){1&n&&(f(0,"div",23,24),Tt(2,2),g())}function dve(n,t){1&n&&(f(0,"div",25,26),Tt(2,3),g())}function uve(n,t){}function pve(n,t){1&n&&S(0,uve,0,0,"ng-template",22),2&n&&(w(),b("ngTemplateOutlet",st(1)))}function hve(n,t){1&n&&(f(0,"div",27),Tt(1,4),g())}function mve(n,t){1&n&&(f(0,"div",28),Tt(1,5),g())}function fve(n,t){1&n&&k(0,"div",29)}function gve(n,t){1&n&&(f(0,"div",30),Tt(1,6),g()),2&n&&b("@transitionMessages",w()._subscriptAnimationState)}function _ve(n,t){if(1&n&&(f(0,"mat-hint",34),T(1),g()),2&n){let e=w(2);b("id",e._hintLabelId),v(1),kt(e.hintLabel)}}function bve(n,t){if(1&n&&(f(0,"div",31),S(1,_ve,2,2,"mat-hint",32),Tt(2,7),k(3,"div",33),Tt(4,8),g()),2&n){let e=w();b("@transitionMessages",e._subscriptAnimationState),v(1),b("ngIf",e.hintLabel)}}var vve=["*",[["mat-label"]],[["","matPrefix",""],["","matIconPrefix",""]],[["","matTextPrefix",""]],[["","matTextSuffix",""]],[["","matSuffix",""],["","matIconSuffix",""]],[["mat-error"],["","matError",""]],[["mat-hint",3,"align","end"]],[["mat-hint","align","end"]]],yve=["*","mat-label","[matPrefix], [matIconPrefix]","[matTextPrefix]","[matTextSuffix]","[matSuffix], [matIconSuffix]","mat-error, [matError]","mat-hint:not([align='end'])","mat-hint[align='end']"],nl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["mat-label"]]}),n})(),xve=0,P9=new te("MatError"),k9=(()=>{class n{constructor(e,i){this.id="mat-mdc-error-"+xve++,e||i.nativeElement.setAttribute("aria-live","polite")}}return n.\u0275fac=function(e){return new(e||n)(Mo("aria-live"),C(xe))},n.\u0275dir=Me({type:n,selectors:[["mat-error"],["","matError",""]],hostAttrs:["aria-atomic","true",1,"mat-mdc-form-field-error","mat-mdc-form-field-bottom-align"],hostVars:1,hostBindings:function(e,i){2&e&&wo("id",i.id)},inputs:{id:"id"},features:[Vt([{provide:P9,useExisting:n}])]}),n})(),Cve=0,w9=(()=>{class n{constructor(){this.align="start",this.id="mat-mdc-hint-"+Cve++}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["mat-hint"]],hostAttrs:[1,"mat-mdc-form-field-hint","mat-mdc-form-field-bottom-align"],hostVars:4,hostBindings:function(e,i){2&e&&(wo("id",i.id),Be("align",null),nt("mat-mdc-form-field-hint-end","end"===i.align))},inputs:{align:"align",id:"id"}}),n})(),O9=new te("MatPrefix"),F9=(()=>{class n{constructor(){this._isText=!1}set _isTextSelector(e){this._isText=!0}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","matPrefix",""],["","matIconPrefix",""],["","matTextPrefix",""]],inputs:{_isTextSelector:["matTextPrefix","_isTextSelector"]},features:[Vt([{provide:O9,useExisting:n}])]}),n})(),Mve=new te("MatSuffix"),S9=(()=>{class n{constructor(e){this._elementRef=e,this.floating=!1}getWidth(){return function(n){if(null!==n.offsetParent)return n.scrollWidth;let e=n.cloneNode(!0);e.style.setProperty("position","absolute"),e.style.setProperty("transform","translate(-9999px, -9999px)"),document.documentElement.appendChild(e);let i=e.scrollWidth;return e.remove(),i}(this._elementRef.nativeElement)}get element(){return this._elementRef.nativeElement}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275dir=Me({type:n,selectors:[["label","matFormFieldFloatingLabel",""]],hostAttrs:[1,"mdc-floating-label","mat-mdc-floating-label"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mdc-floating-label--float-above",i.floating)},inputs:{floating:"floating"}}),n})(),E9="mdc-line-ripple--active",$1="mdc-line-ripple--deactivating",T9=(()=>{class n{constructor(e,i){this._elementRef=e,this._handleTransitionEnd=r=>{let o=this._elementRef.nativeElement.classList,a=o.contains($1);"opacity"===r.propertyName&&a&&o.remove(E9,$1)},i.runOutsideAngular(()=>{e.nativeElement.addEventListener("transitionend",this._handleTransitionEnd)})}activate(){let e=this._elementRef.nativeElement.classList;e.remove($1),e.add(E9)}deactivate(){this._elementRef.nativeElement.classList.add($1)}ngOnDestroy(){this._elementRef.nativeElement.removeEventListener("transitionend",this._handleTransitionEnd)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ot))},n.\u0275dir=Me({type:n,selectors:[["div","matFormFieldLineRipple",""]],hostAttrs:[1,"mdc-line-ripple"]}),n})(),D9=(()=>{class n{constructor(e,i){this._elementRef=e,this._ngZone=i,this.labelWidth=0,this.open=!1}ngAfterViewInit(){let e=this._elementRef.nativeElement.querySelector(".mdc-floating-label");e?(this._elementRef.nativeElement.classList.add("mdc-notched-outline--upgraded"),"function"==typeof requestAnimationFrame&&(e.style.transitionDuration="0s",this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>e.style.transitionDuration="")}))):this._elementRef.nativeElement.classList.add("mdc-notched-outline--no-label")}_getNotchWidth(){return this.open?this.labelWidth>0?`calc(${this.labelWidth}px * var(--mat-mdc-form-field-floating-label-scale, 0.75) + 9px)`:"0px":null}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ot))},n.\u0275cmp=P({type:n,selectors:[["div","matFormFieldNotchedOutline",""]],hostAttrs:[1,"mdc-notched-outline"],hostVars:2,hostBindings:function(e,i){2&e&&nt("mdc-notched-outline--notched",i.open)},inputs:{labelWidth:["matFormFieldNotchedOutlineLabelWidth","labelWidth"],open:["matFormFieldNotchedOutlineOpen","open"]},attrs:Kbe,ngContentSelectors:Jbe,decls:4,vars:2,consts:[[1,"mdc-notched-outline__leading"],[1,"mdc-notched-outline__notch"],[1,"mdc-notched-outline__trailing"]],template:function(e,i){1&e&&(fn(),k(0,"div",0),f(1,"div",1),Tt(2),g(),k(3,"div",2)),2&e&&(v(1),Bt("width",i._getNotchWidth()))},encapsulation:2,changeDetection:0}),n})(),Sve={transitionMessages:fr("transitionMessages",[Si("enter",rn({opacity:1,transform:"translateY(0%)"})),bi("void => enter",[rn({opacity:0,transform:"translateY(-5px)"}),Mi("300ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},Yv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n}),n})(),Ph=new te("MatFormField"),Eve=new te("MAT_FORM_FIELD_DEFAULT_OPTIONS"),I9=0,Pc=(()=>{class n{get hideRequiredMarker(){return this._hideRequiredMarker}set hideRequiredMarker(e){this._hideRequiredMarker=vt(e)}get floatLabel(){return this._floatLabel||this._defaults?.floatLabel||"auto"}set floatLabel(e){e!==this._floatLabel&&(this._floatLabel=e,this._changeDetectorRef.markForCheck())}get appearance(){return this._appearance}set appearance(e){let i=this._appearance;this._appearance=e||this._defaults?.appearance||"fill","outline"===this._appearance&&this._appearance!==i&&(this._refreshOutlineNotchWidth(),this._needsOutlineLabelOffsetUpdateOnStable=!0)}get subscriptSizing(){return this._subscriptSizing||this._defaults?.subscriptSizing||"fixed"}set subscriptSizing(e){this._subscriptSizing=e||this._defaults?.subscriptSizing||"fixed"}get hintLabel(){return this._hintLabel}set hintLabel(e){this._hintLabel=e,this._processHints()}get _control(){return this._explicitFormFieldControl||this._formFieldControl}set _control(e){this._explicitFormFieldControl=e}constructor(e,i,r,o,a,s,l,c){this._elementRef=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=o,this._platform=a,this._defaults=s,this._animationMode=l,this._document=c,this._hideRequiredMarker=!1,this.color="primary",this._appearance="fill",this._subscriptSizing=null,this._hintLabel="",this._hasIconPrefix=!1,this._hasTextPrefix=!1,this._hasIconSuffix=!1,this._hasTextSuffix=!1,this._labelId="mat-mdc-form-field-label-"+I9++,this._hintLabelId="mat-mdc-hint-"+I9++,this._subscriptAnimationState="",this._labelWidth=0,this._destroyed=new Ee,this._isFocused=null,this._needsOutlineLabelOffsetUpdateOnStable=!1,s&&(s.appearance&&(this.appearance=s.appearance),this._hideRequiredMarker=Boolean(s?.hideRequiredMarker),s.color&&(this.color=s.color))}ngAfterViewInit(){this._updateFocusState(),this._refreshOutlineNotchWidth(),this._document?.fonts?.ready?this._document.fonts.ready.then(()=>{this._refreshOutlineNotchWidth(),this._changeDetectorRef.markForCheck()}):setTimeout(()=>this._refreshOutlineNotchWidth(),100),this._subscriptAnimationState="enter",this._changeDetectorRef.detectChanges()}ngAfterContentInit(){this._assertFormFieldControl(),this._initializeControl(),this._initializeSubscript(),this._initializePrefixAndSuffix(),this._initializeOutlineLabelOffsetSubscriptions()}ngAfterContentChecked(){this._assertFormFieldControl()}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}getLabelId(){return this._hasFloatingLabel()?this._labelId:null}getConnectedOverlayOrigin(){return this._textField||this._elementRef}_animateAndLockLabel(){this._hasFloatingLabel()&&(this.floatLabel="always")}_initializeControl(){let e=this._control;e.controlType&&this._elementRef.nativeElement.classList.add(`mat-mdc-form-field-type-${e.controlType}`),e.stateChanges.subscribe(()=>{this._updateFocusState(),this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),e.ngControl&&e.ngControl.valueChanges&&e.ngControl.valueChanges.pipe(it(this._destroyed)).subscribe(()=>this._changeDetectorRef.markForCheck())}_checkPrefixAndSuffixTypes(){this._hasIconPrefix=!!this._prefixChildren.find(e=>!e._isText),this._hasTextPrefix=!!this._prefixChildren.find(e=>e._isText),this._hasIconSuffix=!!this._suffixChildren.find(e=>!e._isText),this._hasTextSuffix=!!this._suffixChildren.find(e=>e._isText)}_initializePrefixAndSuffix(){this._checkPrefixAndSuffixTypes(),tn(this._prefixChildren.changes,this._suffixChildren.changes).subscribe(()=>{this._checkPrefixAndSuffixTypes(),this._changeDetectorRef.markForCheck()})}_initializeSubscript(){this._hintChildren.changes.subscribe(()=>{this._processHints(),this._changeDetectorRef.markForCheck()}),this._errorChildren.changes.subscribe(()=>{this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),this._validateHints(),this._syncDescribedByIds()}_assertFormFieldControl(){}_updateFocusState(){this._control.focused&&!this._isFocused?(this._isFocused=!0,this._lineRipple?.activate()):!this._control.focused&&(this._isFocused||null===this._isFocused)&&(this._isFocused=!1,this._lineRipple?.deactivate()),this._textField?.nativeElement.classList.toggle("mdc-text-field--focused",this._control.focused)}_initializeOutlineLabelOffsetSubscriptions(){this._prefixChildren.changes.subscribe(()=>this._needsOutlineLabelOffsetUpdateOnStable=!0),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.pipe(it(this._destroyed)).subscribe(()=>{this._needsOutlineLabelOffsetUpdateOnStable&&(this._needsOutlineLabelOffsetUpdateOnStable=!1,this._updateOutlineLabelOffset())})}),this._dir.change.pipe(it(this._destroyed)).subscribe(()=>this._needsOutlineLabelOffsetUpdateOnStable=!0)}_shouldAlwaysFloat(){return"always"===this.floatLabel}_hasOutline(){return"outline"===this.appearance}_forceDisplayInfixLabel(){return!this._platform.isBrowser&&this._prefixChildren.length&&!this._shouldLabelFloat()}_hasFloatingLabel(){return!!this._labelChildNonStatic||!!this._labelChildStatic}_shouldLabelFloat(){return this._control.shouldLabelFloat||this._shouldAlwaysFloat()}_shouldForward(e){let i=this._control?this._control.ngControl:null;return i&&i[e]}_getDisplayedMessages(){return this._errorChildren&&this._errorChildren.length>0&&this._control.errorState?"error":"hint"}_refreshOutlineNotchWidth(){!this._hasOutline()||!this._floatingLabel||(this._labelWidth=this._floatingLabel.getWidth())}_processHints(){this._validateHints(),this._syncDescribedByIds()}_validateHints(){}_syncDescribedByIds(){if(this._control){let e=[];if(this._control.userAriaDescribedBy&&"string"==typeof this._control.userAriaDescribedBy&&e.push(...this._control.userAriaDescribedBy.split(" ")),"hint"===this._getDisplayedMessages()){let i=this._hintChildren?this._hintChildren.find(o=>"start"===o.align):null,r=this._hintChildren?this._hintChildren.find(o=>"end"===o.align):null;i?e.push(i.id):this._hintLabel&&e.push(this._hintLabelId),r&&e.push(r.id)}else this._errorChildren&&e.push(...this._errorChildren.map(i=>i.id));this._control.setDescribedByIds(e)}}_updateOutlineLabelOffset(){if(!this._platform.isBrowser||!this._hasOutline()||!this._floatingLabel)return;let e=this._floatingLabel.element;if(!this._iconPrefixContainer&&!this._textPrefixContainer)return void(e.style.transform="");if(!this._isAttachedToDom())return void(this._needsOutlineLabelOffsetUpdateOnStable=!0);let i=this._iconPrefixContainer?.nativeElement,r=this._textPrefixContainer?.nativeElement,o=i?.getBoundingClientRect().width??0,a=r?.getBoundingClientRect().width??0;e.style.transform=`var(\n        --mat-mdc-form-field-label-transform,\n        translateY(-50%) translateX(calc(${"rtl"===this._dir.value?"-1":"1"} * (${o+a}px + var(--mat-mdc-form-field-label-offset-x, 0px))))\n    )`}_isAttachedToDom(){let e=this._elementRef.nativeElement;if(e.getRootNode){let i=e.getRootNode();return i&&i!==e}return document.documentElement.contains(e)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(ot),C(zi),C(Vn),C(Eve,8),C(pi,8),C(Nt))},n.\u0275cmp=P({type:n,selectors:[["mat-form-field"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,nl,5),Bn(r,nl,7),Bn(r,Yv,5),Bn(r,O9,5),Bn(r,Mve,5),Bn(r,P9,5),Bn(r,w9,5)),2&e){let o;be(o=ve())&&(i._labelChildNonStatic=o.first),be(o=ve())&&(i._labelChildStatic=o.first),be(o=ve())&&(i._formFieldControl=o.first),be(o=ve())&&(i._prefixChildren=o),be(o=ve())&&(i._suffixChildren=o),be(o=ve())&&(i._errorChildren=o),be(o=ve())&&(i._hintChildren=o)}},viewQuery:function(e,i){if(1&e&&(Ue($be,5),Ue(eve,5),Ue(tve,5),Ue(S9,5),Ue(D9,5),Ue(T9,5)),2&e){let r;be(r=ve())&&(i._textField=r.first),be(r=ve())&&(i._iconPrefixContainer=r.first),be(r=ve())&&(i._textPrefixContainer=r.first),be(r=ve())&&(i._floatingLabel=r.first),be(r=ve())&&(i._notchedOutline=r.first),be(r=ve())&&(i._lineRipple=r.first)}},hostAttrs:[1,"mat-mdc-form-field"],hostVars:42,hostBindings:function(e,i){2&e&&nt("mat-mdc-form-field-label-always-float",i._shouldAlwaysFloat())("mat-mdc-form-field-has-icon-prefix",i._hasIconPrefix)("mat-mdc-form-field-has-icon-suffix",i._hasIconSuffix)("mat-form-field-invalid",i._control.errorState)("mat-form-field-disabled",i._control.disabled)("mat-form-field-autofilled",i._control.autofilled)("mat-form-field-no-animations","NoopAnimations"===i._animationMode)("mat-form-field-appearance-fill","fill"==i.appearance)("mat-form-field-appearance-outline","outline"==i.appearance)("mat-form-field-hide-placeholder",i._hasFloatingLabel()&&!i._shouldLabelFloat())("mat-focused",i._control.focused)("mat-primary","accent"!==i.color&&"warn"!==i.color)("mat-accent","accent"===i.color)("mat-warn","warn"===i.color)("ng-untouched",i._shouldForward("untouched"))("ng-touched",i._shouldForward("touched"))("ng-pristine",i._shouldForward("pristine"))("ng-dirty",i._shouldForward("dirty"))("ng-valid",i._shouldForward("valid"))("ng-invalid",i._shouldForward("invalid"))("ng-pending",i._shouldForward("pending"))},inputs:{hideRequiredMarker:"hideRequiredMarker",color:"color",floatLabel:"floatLabel",appearance:"appearance",subscriptSizing:"subscriptSizing",hintLabel:"hintLabel"},exportAs:["matFormField"],features:[Vt([{provide:Ph,useExisting:n}])],ngContentSelectors:yve,decls:18,vars:23,consts:[["labelTemplate",""],[1,"mat-mdc-text-field-wrapper","mdc-text-field",3,"click"],["textField",""],["class","mat-mdc-form-field-focus-overlay",4,"ngIf"],[1,"mat-mdc-form-field-flex"],["matFormFieldNotchedOutline","",3,"matFormFieldNotchedOutlineOpen","matFormFieldNotchedOutlineLabelWidth",4,"ngIf"],["class","mat-mdc-form-field-icon-prefix",4,"ngIf"],["class","mat-mdc-form-field-text-prefix",4,"ngIf"],[1,"mat-mdc-form-field-infix"],[3,"ngIf"],["class","mat-mdc-form-field-text-suffix",4,"ngIf"],["class","mat-mdc-form-field-icon-suffix",4,"ngIf"],["matFormFieldLineRipple","",4,"ngIf"],[1,"mat-mdc-form-field-subscript-wrapper","mat-mdc-form-field-bottom-align",3,"ngSwitch"],["class","mat-mdc-form-field-error-wrapper",4,"ngSwitchCase"],["class","mat-mdc-form-field-hint-wrapper",4,"ngSwitchCase"],["matFormFieldFloatingLabel","",3,"floating","cdkObserveContentDisabled","id","cdkObserveContent",4,"ngIf"],["matFormFieldFloatingLabel","",3,"floating","cdkObserveContentDisabled","id","cdkObserveContent"],["aria-hidden","true","class","mat-mdc-form-field-required-marker mdc-floating-label--required",4,"ngIf"],["aria-hidden","true",1,"mat-mdc-form-field-required-marker","mdc-floating-label--required"],[1,"mat-mdc-form-field-focus-overlay"],["matFormFieldNotchedOutline","",3,"matFormFieldNotchedOutlineOpen","matFormFieldNotchedOutlineLabelWidth"],[3,"ngTemplateOutlet"],[1,"mat-mdc-form-field-icon-prefix"],["iconPrefixContainer",""],[1,"mat-mdc-form-field-text-prefix"],["textPrefixContainer",""],[1,"mat-mdc-form-field-text-suffix"],[1,"mat-mdc-form-field-icon-suffix"],["matFormFieldLineRipple",""],[1,"mat-mdc-form-field-error-wrapper"],[1,"mat-mdc-form-field-hint-wrapper"],[3,"id",4,"ngIf"],[1,"mat-mdc-form-field-hint-spacer"],[3,"id"]],template:function(e,i){1&e&&(fn(vve),S(0,rve,1,1,"ng-template",null,0,jt),f(2,"div",1,2),A("click",function(o){return i._control.onContainerClick&&i._control.onContainerClick(o)}),S(4,ove,1,0,"div",3),f(5,"div",4),S(6,lve,2,3,"div",5),S(7,cve,3,0,"div",6),S(8,dve,3,0,"div",7),f(9,"div",8),S(10,pve,1,1,"ng-template",9),Tt(11),g(),S(12,hve,2,0,"div",10),S(13,mve,2,0,"div",11),g(),S(14,fve,1,0,"div",12),g(),f(15,"div",13),S(16,gve,2,1,"div",14),S(17,bve,5,2,"div",15),g()),2&e&&(v(2),nt("mdc-text-field--filled",!i._hasOutline())("mdc-text-field--outlined",i._hasOutline())("mdc-text-field--no-label",!i._hasFloatingLabel())("mdc-text-field--disabled",i._control.disabled)("mdc-text-field--invalid",i._control.errorState),v(2),b("ngIf",!i._hasOutline()&&!i._control.disabled),v(2),b("ngIf",i._hasOutline()),v(1),b("ngIf",i._hasIconPrefix),v(1),b("ngIf",i._hasTextPrefix),v(2),b("ngIf",!i._hasOutline()||i._forceDisplayInfixLabel()),v(2),b("ngIf",i._hasTextSuffix),v(1),b("ngIf",i._hasIconSuffix),v(1),b("ngIf",!i._hasOutline()),v(1),nt("mat-mdc-form-field-subscript-dynamic-size","dynamic"===i.subscriptSizing),b("ngSwitch",i._getDisplayedMessages()),v(1),b("ngSwitchCase","error"),v(1),b("ngSwitchCase","hint"))},dependencies:[Ne,eo,mr,kr,O1,w9,S9,D9,T9],styles:['.mdc-text-field{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:0;border-bottom-left-radius:0;display:inline-flex;align-items:baseline;padding:0 16px;position:relative;box-sizing:border-box;overflow:hidden;will-change:opacity,transform,color}.mdc-text-field .mdc-floating-label{top:50%;transform:translateY(-50%);pointer-events:none}.mdc-text-field__input{height:28px;width:100%;min-width:0;border:none;border-radius:0;background:none;appearance:none;padding:0}.mdc-text-field__input::-ms-clear{display:none}.mdc-text-field__input::-webkit-calendar-picker-indicator{display:none}.mdc-text-field__input:focus{outline:none}.mdc-text-field__input:invalid{box-shadow:none}@media all{.mdc-text-field__input::placeholder{opacity:0}}@media all{.mdc-text-field__input:-ms-input-placeholder{opacity:0}}@media all{.mdc-text-field--no-label .mdc-text-field__input::placeholder,.mdc-text-field--focused .mdc-text-field__input::placeholder{opacity:1}}@media all{.mdc-text-field--no-label .mdc-text-field__input:-ms-input-placeholder,.mdc-text-field--focused .mdc-text-field__input:-ms-input-placeholder{opacity:1}}.mdc-text-field__affix{height:28px;opacity:0;white-space:nowrap}.mdc-text-field--label-floating .mdc-text-field__affix,.mdc-text-field--no-label .mdc-text-field__affix{opacity:1}@supports(-webkit-hyphens: none){.mdc-text-field--outlined .mdc-text-field__affix{align-items:center;align-self:center;display:inline-flex;height:100%}}.mdc-text-field__affix--prefix{padding-left:0;padding-right:2px}[dir=rtl] .mdc-text-field__affix--prefix,.mdc-text-field__affix--prefix[dir=rtl]{padding-left:2px;padding-right:0}.mdc-text-field--end-aligned .mdc-text-field__affix--prefix{padding-left:0;padding-right:12px}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__affix--prefix,.mdc-text-field--end-aligned .mdc-text-field__affix--prefix[dir=rtl]{padding-left:12px;padding-right:0}.mdc-text-field__affix--suffix{padding-left:12px;padding-right:0}[dir=rtl] .mdc-text-field__affix--suffix,.mdc-text-field__affix--suffix[dir=rtl]{padding-left:0;padding-right:12px}.mdc-text-field--end-aligned .mdc-text-field__affix--suffix{padding-left:2px;padding-right:0}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__affix--suffix,.mdc-text-field--end-aligned .mdc-text-field__affix--suffix[dir=rtl]{padding-left:0;padding-right:2px}.mdc-text-field--filled{height:56px}.mdc-text-field--filled::before{display:inline-block;width:0;height:40px;content:"";vertical-align:0}.mdc-text-field--filled .mdc-floating-label{left:16px;right:initial}[dir=rtl] .mdc-text-field--filled .mdc-floating-label,.mdc-text-field--filled .mdc-floating-label[dir=rtl]{left:initial;right:16px}.mdc-text-field--filled .mdc-floating-label--float-above{transform:translateY(-106%) scale(0.75)}.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__input{height:100%}.mdc-text-field--filled.mdc-text-field--no-label .mdc-floating-label{display:none}.mdc-text-field--filled.mdc-text-field--no-label::before{display:none}@supports(-webkit-hyphens: none){.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__affix{align-items:center;align-self:center;display:inline-flex;height:100%}}.mdc-text-field--outlined{height:56px;overflow:visible}.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-37.25px) scale(1)}.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-34.75px) scale(0.75)}.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--outlined .mdc-text-field__input{height:100%}.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:var(--mdc-shape-small, 4px)}[dir=rtl] .mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading,.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading[dir=rtl]{border-top-left-radius:0;border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:var(--mdc-shape-small, 4px);border-bottom-left-radius:0}@supports(top: max(0%)){.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__leading{width:max(12px, var(--mdc-shape-small, 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__notch{max-width:calc(100% - max(12px, var(--mdc-shape-small, 4px))*2)}}.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing{border-top-left-radius:0;border-top-right-radius:var(--mdc-shape-small, 4px);border-bottom-right-radius:var(--mdc-shape-small, 4px);border-bottom-left-radius:0}[dir=rtl] .mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing,.mdc-text-field--outlined .mdc-notched-outline .mdc-notched-outline__trailing[dir=rtl]{border-top-left-radius:var(--mdc-shape-small, 4px);border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:var(--mdc-shape-small, 4px)}@supports(top: max(0%)){.mdc-text-field--outlined{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined{padding-right:max(16px, var(--mdc-shape-small, 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined+.mdc-text-field-helper-line{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}@supports(top: max(0%)){.mdc-text-field--outlined+.mdc-text-field-helper-line{padding-right:max(16px, var(--mdc-shape-small, 4px))}}.mdc-text-field--outlined.mdc-text-field--with-leading-icon{padding-left:0}@supports(top: max(0%)){.mdc-text-field--outlined.mdc-text-field--with-leading-icon{padding-right:max(16px, var(--mdc-shape-small, 4px))}}[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-leading-icon,.mdc-text-field--outlined.mdc-text-field--with-leading-icon[dir=rtl]{padding-right:0}@supports(top: max(0%)){[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-leading-icon,.mdc-text-field--outlined.mdc-text-field--with-leading-icon[dir=rtl]{padding-left:max(16px, var(--mdc-shape-small, 4px))}}.mdc-text-field--outlined.mdc-text-field--with-trailing-icon{padding-right:0}@supports(top: max(0%)){.mdc-text-field--outlined.mdc-text-field--with-trailing-icon{padding-left:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-trailing-icon,.mdc-text-field--outlined.mdc-text-field--with-trailing-icon[dir=rtl]{padding-left:0}@supports(top: max(0%)){[dir=rtl] .mdc-text-field--outlined.mdc-text-field--with-trailing-icon,.mdc-text-field--outlined.mdc-text-field--with-trailing-icon[dir=rtl]{padding-right:max(16px, calc(var(--mdc-shape-small, 4px) + 4px))}}.mdc-text-field--outlined.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon{padding-left:0;padding-right:0}.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:1px}.mdc-text-field--outlined .mdc-floating-label{left:4px;right:initial}[dir=rtl] .mdc-text-field--outlined .mdc-floating-label,.mdc-text-field--outlined .mdc-floating-label[dir=rtl]{left:initial;right:4px}.mdc-text-field--outlined .mdc-text-field__input{display:flex;border:none !important;background-color:rgba(0,0,0,0)}.mdc-text-field--outlined .mdc-notched-outline{z-index:1}.mdc-text-field--textarea{flex-direction:column;align-items:center;width:auto;height:auto;padding:0}.mdc-text-field--textarea .mdc-floating-label{top:19px}.mdc-text-field--textarea .mdc-floating-label:not(.mdc-floating-label--float-above){transform:none}.mdc-text-field--textarea .mdc-text-field__input{flex-grow:1;height:auto;min-height:1.5rem;overflow-x:hidden;overflow-y:auto;box-sizing:border-box;resize:none;padding:0 16px}.mdc-text-field--textarea.mdc-text-field--filled::before{display:none}.mdc-text-field--textarea.mdc-text-field--filled .mdc-floating-label--float-above{transform:translateY(-10.25px) scale(0.75)}.mdc-text-field--textarea.mdc-text-field--filled .mdc-text-field__input{margin-top:23px;margin-bottom:9px}.mdc-text-field--textarea.mdc-text-field--filled.mdc-text-field--no-label .mdc-text-field__input{margin-top:16px;margin-bottom:16px}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:0}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-27.25px) scale(1)}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--textarea.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-24.75px) scale(0.75)}.mdc-text-field--textarea.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--textarea.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-text-field__input{margin-top:16px;margin-bottom:16px}.mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label{top:18px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field__input{margin-bottom:2px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter{align-self:flex-end;padding:0 16px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter::after{display:inline-block;width:0;height:16px;content:"";vertical-align:-16px}.mdc-text-field--textarea.mdc-text-field--with-internal-counter .mdc-text-field-character-counter::before{display:none}.mdc-text-field__resizer{align-self:stretch;display:inline-flex;flex-direction:column;flex-grow:1;max-height:100%;max-width:100%;min-height:56px;min-width:fit-content;min-width:-moz-available;min-width:-webkit-fill-available;overflow:hidden;resize:both}.mdc-text-field--filled .mdc-text-field__resizer{transform:translateY(-1px)}.mdc-text-field--filled .mdc-text-field__resizer .mdc-text-field__input,.mdc-text-field--filled .mdc-text-field__resizer .mdc-text-field-character-counter{transform:translateY(1px)}.mdc-text-field--outlined .mdc-text-field__resizer{transform:translateX(-1px) translateY(-1px)}[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer,.mdc-text-field--outlined .mdc-text-field__resizer[dir=rtl]{transform:translateX(1px) translateY(-1px)}.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input,.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter{transform:translateX(1px) translateY(1px)}[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input,[dir=rtl] .mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter,.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field__input[dir=rtl],.mdc-text-field--outlined .mdc-text-field__resizer .mdc-text-field-character-counter[dir=rtl]{transform:translateX(-1px) translateY(1px)}.mdc-text-field--with-leading-icon{padding-left:0;padding-right:16px}[dir=rtl] .mdc-text-field--with-leading-icon,.mdc-text-field--with-leading-icon[dir=rtl]{padding-left:16px;padding-right:0}.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 48px);left:48px;right:initial}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label,.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label[dir=rtl]{left:initial;right:48px}.mdc-text-field--with-leading-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 64px / 0.75)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label{left:36px;right:initial}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label[dir=rtl]{left:initial;right:36px}.mdc-text-field--with-leading-icon.mdc-text-field--outlined :not(.mdc-notched-outline--notched) .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above{transform:translateY(-37.25px) translateX(-32px) scale(1)}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above[dir=rtl]{transform:translateY(-37.25px) translateX(32px) scale(1)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--float-above{font-size:.75rem}.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{transform:translateY(-34.75px) translateX(-32px) scale(0.75)}[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,[dir=rtl] .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above[dir=rtl],.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above[dir=rtl]{transform:translateY(-34.75px) translateX(32px) scale(0.75)}.mdc-text-field--with-leading-icon.mdc-text-field--outlined.mdc-notched-outline--upgraded .mdc-floating-label--float-above,.mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-notched-outline--upgraded .mdc-floating-label--float-above{font-size:1rem}.mdc-text-field--with-trailing-icon{padding-left:16px;padding-right:0}[dir=rtl] .mdc-text-field--with-trailing-icon,.mdc-text-field--with-trailing-icon[dir=rtl]{padding-left:0;padding-right:16px}.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 64px)}.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 64px / 0.75)}.mdc-text-field--with-trailing-icon.mdc-text-field--outlined :not(.mdc-notched-outline--notched) .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon{padding-left:0;padding-right:0}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label{max-width:calc(100% - 96px)}.mdc-text-field--with-leading-icon.mdc-text-field--with-trailing-icon.mdc-text-field--filled .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 96px / 0.75)}.mdc-text-field-helper-line{display:flex;justify-content:space-between;box-sizing:border-box}.mdc-text-field+.mdc-text-field-helper-line{padding-right:16px;padding-left:16px}.mdc-form-field>.mdc-text-field+label{align-self:flex-start}.mdc-text-field--focused .mdc-notched-outline__leading,.mdc-text-field--focused .mdc-notched-outline__notch,.mdc-text-field--focused .mdc-notched-outline__trailing{border-width:2px}.mdc-text-field--focused+.mdc-text-field-helper-line .mdc-text-field-helper-text:not(.mdc-text-field-helper-text--validation-msg){opacity:1}.mdc-text-field--focused.mdc-text-field--outlined .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:2px}.mdc-text-field--focused.mdc-text-field--outlined.mdc-text-field--textarea .mdc-notched-outline--notched .mdc-notched-outline__notch{padding-top:0}.mdc-text-field--invalid+.mdc-text-field-helper-line .mdc-text-field-helper-text--validation-msg{opacity:1}.mdc-text-field--disabled{pointer-events:none}@media screen and (forced-colors: active){.mdc-text-field--disabled .mdc-text-field__input{background-color:Window}.mdc-text-field--disabled .mdc-floating-label{z-index:1}}.mdc-text-field--disabled .mdc-floating-label{cursor:default}.mdc-text-field--disabled.mdc-text-field--filled .mdc-text-field__ripple{display:none}.mdc-text-field--disabled .mdc-text-field__input{pointer-events:auto}.mdc-text-field--end-aligned .mdc-text-field__input{text-align:right}[dir=rtl] .mdc-text-field--end-aligned .mdc-text-field__input,.mdc-text-field--end-aligned .mdc-text-field__input[dir=rtl]{text-align:left}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__input,[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__input,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix{direction:ltr}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--prefix{padding-left:0;padding-right:2px}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--suffix{padding-left:12px;padding-right:0}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__icon--leading,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__icon--leading{order:1}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--suffix{order:2}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__input,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__input{order:3}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__affix--prefix{order:4}[dir=rtl] .mdc-text-field--ltr-text .mdc-text-field__icon--trailing,.mdc-text-field--ltr-text[dir=rtl] .mdc-text-field__icon--trailing{order:5}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__input,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__input{text-align:right}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__affix--prefix,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__affix--prefix{padding-right:12px}[dir=rtl] .mdc-text-field--ltr-text.mdc-text-field--end-aligned .mdc-text-field__affix--suffix,.mdc-text-field--ltr-text.mdc-text-field--end-aligned[dir=rtl] .mdc-text-field__affix--suffix{padding-left:2px}.mdc-floating-label{position:absolute;left:0;-webkit-transform-origin:left top;transform-origin:left top;line-height:1.15rem;text-align:left;text-overflow:ellipsis;white-space:nowrap;cursor:text;overflow:hidden;will-change:transform}[dir=rtl] .mdc-floating-label,.mdc-floating-label[dir=rtl]{right:0;left:auto;-webkit-transform-origin:right top;transform-origin:right top;text-align:right}.mdc-floating-label--float-above{cursor:auto}.mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)::after{margin-left:1px;margin-right:0px;content:"*"}[dir=rtl] .mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)::after,.mdc-floating-label--required:not(.mdc-floating-label--hide-required-marker)[dir=rtl]::after{margin-left:0;margin-right:1px}.mdc-floating-label--float-above{transform:translateY(-106%) scale(0.75)}.mdc-notched-outline{display:flex;position:absolute;top:0;right:0;left:0;box-sizing:border-box;width:100%;max-width:100%;height:100%;text-align:left;pointer-events:none}[dir=rtl] .mdc-notched-outline,.mdc-notched-outline[dir=rtl]{text-align:right}.mdc-notched-outline__leading,.mdc-notched-outline__notch,.mdc-notched-outline__trailing{box-sizing:border-box;height:100%;border-top:1px solid;border-bottom:1px solid;pointer-events:none}.mdc-notched-outline__leading{border-left:1px solid;border-right:none;width:12px}[dir=rtl] .mdc-notched-outline__leading,.mdc-notched-outline__leading[dir=rtl]{border-left:none;border-right:1px solid}.mdc-notched-outline__trailing{border-left:none;border-right:1px solid;flex-grow:1}[dir=rtl] .mdc-notched-outline__trailing,.mdc-notched-outline__trailing[dir=rtl]{border-left:1px solid;border-right:none}.mdc-notched-outline__notch{flex:0 0 auto;width:auto;max-width:calc(100% - 12px * 2)}.mdc-notched-outline .mdc-floating-label{display:inline-block;position:relative;max-width:100%}.mdc-notched-outline .mdc-floating-label--float-above{text-overflow:clip}.mdc-notched-outline--upgraded .mdc-floating-label--float-above{max-width:133.3333333333%}.mdc-notched-outline--notched .mdc-notched-outline__notch{padding-left:0;padding-right:8px;border-top:none}[dir=rtl] .mdc-notched-outline--notched .mdc-notched-outline__notch,.mdc-notched-outline--notched .mdc-notched-outline__notch[dir=rtl]{padding-left:8px;padding-right:0}.mdc-notched-outline--no-label .mdc-notched-outline__notch{display:none}.mdc-line-ripple::before,.mdc-line-ripple::after{position:absolute;bottom:0;left:0;width:100%;border-bottom-style:solid;content:""}.mdc-line-ripple::before{border-bottom-width:1px}.mdc-line-ripple::after{border-bottom-width:2px}.mdc-line-ripple::before{z-index:1}.mdc-line-ripple::after{transform:scaleX(0);opacity:0;z-index:2}.mdc-line-ripple--active::after{transform:scaleX(1);opacity:1}.mdc-line-ripple--deactivating::after{opacity:0}.mat-mdc-form-field-textarea-control{vertical-align:middle;resize:vertical;box-sizing:border-box;height:auto;margin:0;padding:0;border:none;overflow:auto}.mat-mdc-form-field-input-control.mat-mdc-form-field-input-control{font:inherit;letter-spacing:inherit;text-decoration:inherit;text-transform:inherit;border:none}.mat-mdc-form-field .mat-mdc-floating-label.mdc-floating-label{line-height:normal;pointer-events:all}.mdc-text-field--no-label:not(.mdc-text-field--textarea) .mat-mdc-form-field-input-control.mdc-text-field__input,.mat-mdc-text-field-wrapper .mat-mdc-form-field-input-control{height:auto}.mat-mdc-text-field-wrapper .mat-mdc-form-field-input-control.mdc-text-field__input[type=color]{height:23px}.mat-mdc-text-field-wrapper{height:auto;flex:auto}.mat-mdc-form-field-has-icon-prefix .mat-mdc-text-field-wrapper{padding-left:0;--mat-mdc-form-field-label-offset-x: -16px}.mat-mdc-form-field-has-icon-suffix .mat-mdc-text-field-wrapper{padding-right:0}[dir=rtl] .mat-mdc-text-field-wrapper{padding-left:16px;padding-right:16px}[dir=rtl] .mat-mdc-form-field-has-icon-suffix .mat-mdc-text-field-wrapper{padding-left:0}[dir=rtl] .mat-mdc-form-field-has-icon-prefix .mat-mdc-text-field-wrapper{padding-right:0}.mat-mdc-form-field-label-always-float .mdc-text-field__input::placeholder{transition-delay:40ms;transition-duration:110ms;opacity:1}.mat-mdc-text-field-wrapper .mat-mdc-form-field-infix .mat-mdc-floating-label{left:auto;right:auto}.mat-mdc-text-field-wrapper.mdc-text-field--outlined .mdc-text-field__input{display:inline-block}.mat-mdc-form-field .mat-mdc-text-field-wrapper.mdc-text-field .mdc-notched-outline__notch{padding-top:0}.mat-mdc-text-field-wrapper::before{content:none}.mat-mdc-form-field-subscript-wrapper{box-sizing:border-box;width:100%;position:relative}.mat-mdc-form-field-hint-wrapper,.mat-mdc-form-field-error-wrapper{position:absolute;top:0;left:0;right:0;padding:0 16px}.mat-mdc-form-field-subscript-dynamic-size .mat-mdc-form-field-hint-wrapper,.mat-mdc-form-field-subscript-dynamic-size .mat-mdc-form-field-error-wrapper{position:static}.mat-mdc-form-field-bottom-align::before{content:"";display:inline-block;height:16px}.mat-mdc-form-field-bottom-align.mat-mdc-form-field-subscript-dynamic-size::before{content:unset}.mat-mdc-form-field-hint-end{order:1}.mat-mdc-form-field-hint-wrapper{display:flex}.mat-mdc-form-field-hint-spacer{flex:1 0 1em}.mat-mdc-form-field-error{display:block}.mat-mdc-form-field-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;opacity:0;pointer-events:none}select.mat-mdc-form-field-input-control{-moz-appearance:none;-webkit-appearance:none;background-color:rgba(0,0,0,0);display:inline-flex;box-sizing:border-box}select.mat-mdc-form-field-input-control:not(:disabled){cursor:pointer}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{content:"";width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;position:absolute;right:0;top:50%;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-infix::after{right:auto;left:0}.mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-input-control{padding-right:15px}[dir=rtl] .mat-mdc-form-field-type-mat-native-select .mat-mdc-form-field-input-control{padding-right:0;padding-left:15px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-mdc-text-field-wrapper{outline:solid 1px}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-mdc-text-field-wrapper{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-mdc-text-field-wrapper{outline:dashed 3px}.cdk-high-contrast-active .mat-mdc-form-field.mat-focused .mdc-notched-outline{border:dashed 3px}.mat-mdc-form-field-input-control[type=date],.mat-mdc-form-field-input-control[type=datetime],.mat-mdc-form-field-input-control[type=datetime-local],.mat-mdc-form-field-input-control[type=month],.mat-mdc-form-field-input-control[type=week],.mat-mdc-form-field-input-control[type=time]{line-height:1}.mat-mdc-form-field-input-control::-webkit-datetime-edit{line-height:1;padding:0;margin-bottom:-2px}.mat-mdc-form-field{--mat-mdc-form-field-floating-label-scale: 0.75;display:inline-flex;flex-direction:column;min-width:0;text-align:left}[dir=rtl] .mat-mdc-form-field{text-align:right}.mat-mdc-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-mdc-text-field-wrapper{width:100%}.mat-mdc-form-field-icon-prefix,.mat-mdc-form-field-icon-suffix{align-self:center;line-height:0;pointer-events:auto}.mat-mdc-form-field-icon-prefix,[dir=rtl] .mat-mdc-form-field-icon-suffix{padding:0 4px 0 0}.mat-mdc-form-field-icon-suffix,[dir=rtl] .mat-mdc-form-field-icon-prefix{padding:0 0 0 4px}.mat-mdc-form-field-icon-prefix>.mat-icon,.mat-mdc-form-field-icon-suffix>.mat-icon{padding:12px;box-sizing:content-box}.mat-mdc-form-field-subscript-wrapper .mat-icon,.mat-mdc-form-field label .mat-icon{width:1em;height:1em;font-size:inherit}.mat-mdc-form-field-infix{flex:auto;min-width:0;width:180px;position:relative;box-sizing:border-box}.mat-mdc-form-field .mdc-notched-outline__notch{margin-left:-1px;-webkit-clip-path:inset(-9em -999em -9em 1px);clip-path:inset(-9em -999em -9em 1px)}[dir=rtl] .mat-mdc-form-field .mdc-notched-outline__notch{margin-left:0;margin-right:-1px;-webkit-clip-path:inset(-9em 1px -9em -999em);clip-path:inset(-9em 1px -9em -999em)}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input{transition:opacity 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}@media all{.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder{transition:opacity 67ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}}@media all{.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder{transition:opacity 67ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}}@media all{.mdc-text-field--no-label .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder,.mdc-text-field--focused .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input::placeholder{transition-delay:40ms;transition-duration:110ms}}@media all{.mdc-text-field--no-label .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder,.mdc-text-field--focused .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__input:-ms-input-placeholder{transition-delay:40ms;transition-duration:110ms}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field__affix{transition:opacity 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--filled.mdc-ripple-upgraded--background-focused .mdc-text-field__ripple::before,.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--filled:not(.mdc-ripple-upgraded):focus .mdc-text-field__ripple::before{transition-duration:75ms}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined{0%{transform:translateX(calc(0 - 0%)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-34.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea{transition:none}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea.mdc-text-field--filled .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-textarea-filled 250ms 1}@keyframes mdc-floating-label-shake-float-above-textarea-filled{0%{transform:translateX(calc(0 - 0%)) translateY(-10.25px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-10.25px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-10.25px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-10.25px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--textarea.mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-textarea-outlined 250ms 1}@keyframes mdc-floating-label-shake-float-above-textarea-outlined{0%{transform:translateX(calc(0 - 0%)) translateY(-24.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-24.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-24.75px) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-24.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined-leading-icon 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined-leading-icon{0%{transform:translateX(calc(0 - 32px)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 32px)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 32px)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - 32px)) translateY(-34.75px) scale(0.75)}}[dir=rtl] .mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined .mdc-floating-label--shake,.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-text-field--with-leading-icon.mdc-text-field--outlined[dir=rtl] .mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-text-field-outlined-leading-icon 250ms 1}@keyframes mdc-floating-label-shake-float-above-text-field-outlined-leading-icon-rtl{0%{transform:translateX(calc(0 - -32px)) translateY(-34.75px) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - -32px)) translateY(-34.75px) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - -32px)) translateY(-34.75px) scale(0.75)}100%{transform:translateX(calc(0 - -32px)) translateY(-34.75px) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-floating-label{transition:transform 150ms cubic-bezier(0.4, 0, 0.2, 1),color 150ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-floating-label--shake{animation:mdc-floating-label-shake-float-above-standard 250ms 1}@keyframes mdc-floating-label-shake-float-above-standard{0%{transform:translateX(calc(0 - 0%)) translateY(-106%) scale(0.75)}33%{animation-timing-function:cubic-bezier(0.5, 0, 0.701732, 0.495819);transform:translateX(calc(4% - 0%)) translateY(-106%) scale(0.75)}66%{animation-timing-function:cubic-bezier(0.302435, 0.381352, 0.55, 0.956352);transform:translateX(calc(-4% - 0%)) translateY(-106%) scale(0.75)}100%{transform:translateX(calc(0 - 0%)) translateY(-106%) scale(0.75)}}.mat-mdc-form-field:not(.mat-form-field-no-animations) .mdc-line-ripple::after{transition:transform 180ms cubic-bezier(0.4, 0, 0.2, 1),opacity 180ms cubic-bezier(0.4, 0, 0.2, 1)}'],encapsulation:2,data:{animation:[Sve.transitionMessages]},changeDetection:0}),n})(),Qv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,De,og,dn]}),n})(),j9=(()=>{class n{constructor(e,i){this._renderer=e,this._elementRef=i,this.onChange=r=>{},this.onTouched=()=>{}}setProperty(e,i){this._renderer.setProperty(this._elementRef.nativeElement,e,i)}registerOnTouched(e){this.onTouched=e}registerOnChange(e){this.onChange=e}setDisabledState(e){this.setProperty("disabled",e)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(xe))},n.\u0275dir=Me({type:n}),n})(),kh=(()=>{class n extends j9{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,features:[Xe]}),n})(),Xr=new te("NgValueAccessor"),Ive={provide:Xr,useExisting:Wn(()=>Ave),multi:!0},Ave=(()=>{class n extends kh{writeValue(e){this.setProperty("checked",e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","checkbox","formControlName",""],["input","type","checkbox","formControl",""],["input","type","checkbox","ngModel",""]],hostBindings:function(e,i){1&e&&A("change",function(o){return i.onChange(o.target.checked)})("blur",function(){return i.onTouched()})},features:[Vt([Ive]),Xe]}),n})(),Rve={provide:Xr,useExisting:Wn(()=>Uu),multi:!0},kve=new te("CompositionEventMode"),Uu=(()=>{class n extends j9{constructor(e,i,r){super(e,i),this._compositionMode=r,this._composing=!1,null==this._compositionMode&&(this._compositionMode=!function(){let n=Al()?Al().getUserAgent():"";return/android (\d+)/.test(n.toLowerCase())}())}writeValue(e){this.setProperty("value",e??"")}_handleInput(e){(!this._compositionMode||this._compositionMode&&!this._composing)&&this.onChange(e)}_compositionStart(){this._composing=!0}_compositionEnd(e){this._composing=!1,this._compositionMode&&this.onChange(e)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(xe),C(kve,8))},n.\u0275dir=Me({type:n,selectors:[["input","formControlName","",3,"type","checkbox"],["textarea","formControlName",""],["input","formControl","",3,"type","checkbox"],["textarea","formControl",""],["input","ngModel","",3,"type","checkbox"],["textarea","ngModel",""],["","ngDefaultControl",""]],hostBindings:function(e,i){1&e&&A("input",function(o){return i._handleInput(o.target.value)})("blur",function(){return i.onTouched()})("compositionstart",function(){return i._compositionStart()})("compositionend",function(o){return i._compositionEnd(o.target.value)})},features:[Vt([Rve]),Xe]}),n})(),Ove=!1;function zu(n){return null==n||("string"==typeof n||Array.isArray(n))&&0===n.length}function G9(n){return null!=n&&"number"==typeof n.length}var Io=new te("NgValidators"),ju=new te("NgAsyncValidators"),Fve=/^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,il=class{static min(t){return W9(t)}static max(t){return q9(t)}static required(t){return X9(t)}static requiredTrue(t){return Y9(t)}static email(t){return Q9(t)}static minLength(t){return Z9(t)}static maxLength(t){return K9(t)}static pattern(t){return J9(t)}static nullValidator(t){return null}static compose(t){return rq(t)}static composeAsync(t){return oq(t)}};function W9(n){return t=>{if(zu(t.value)||zu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e<n?{min:{min:n,actual:t.value}}:null}}function q9(n){return t=>{if(zu(t.value)||zu(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e>n?{max:{max:n,actual:t.value}}:null}}function X9(n){return zu(n.value)?{required:!0}:null}function Y9(n){return!0===n.value?null:{required:!0}}function Q9(n){return zu(n.value)||Fve.test(n.value)?null:{email:!0}}function Z9(n){return t=>zu(t.value)||!G9(t.value)?null:t.value.length<n?{minlength:{requiredLength:n,actualLength:t.value.length}}:null}function K9(n){return t=>G9(t.value)&&t.value.length>n?{maxlength:{requiredLength:n,actualLength:t.value.length}}:null}function J9(n){if(!n)return tE;let t,e;return"string"==typeof n?(e="","^"!==n.charAt(0)&&(e+="^"),e+=n,"$"!==n.charAt(n.length-1)&&(e+="$"),t=new RegExp(e)):(e=n.toString(),t=n),i=>{if(zu(i.value))return null;let r=i.value;return t.test(r)?null:{pattern:{requiredPattern:e,actualValue:r}}}}function tE(n){return null}function $9(n){return null!=n}function eq(n){let t=Cf(n)?Jr(n):n;if(Ove&&!Ik(t)){let e="Expected async validator to return Promise or Observable.";throw"object"==typeof n&&(e+=" Are you using a synchronous validator where an async validator is expected?"),new xt(-1101,e)}return t}function tq(n){let t={};return n.forEach(e=>{t=null!=e?{...t,...e}:t}),0===Object.keys(t).length?null:t}function nq(n,t){return t.map(e=>e(n))}function iq(n){return n.map(t=>function(n){return!n.validate}(t)?t:e=>t.validate(e))}function rq(n){if(!n)return null;let t=n.filter($9);return 0==t.length?null:function(e){return tq(nq(e,t))}}function B2(n){return null!=n?rq(iq(n)):null}function oq(n){if(!n)return null;let t=n.filter($9);return 0==t.length?null:function(e){return Co(nq(e,t).map(eq)).pipe(q(tq))}}function V2(n){return null!=n?oq(iq(n)):null}function N9(n,t){return null===n?[t]:Array.isArray(n)?[...n,t]:[n,t]}function aq(n){return n._rawValidators}function sq(n){return n._rawAsyncValidators}function F2(n){return n?Array.isArray(n)?n:[n]:[]}function nE(n,t){return Array.isArray(n)?n.includes(t):n===t}function L9(n,t){let e=F2(t);return F2(n).forEach(r=>{nE(e,r)||e.push(r)}),e}function B9(n,t){return F2(t).filter(e=>!nE(n,e))}var iE=class{constructor(){this._rawValidators=[],this._rawAsyncValidators=[],this._onDestroyCallbacks=[]}get value(){return this.control?this.control.value:null}get valid(){return this.control?this.control.valid:null}get invalid(){return this.control?this.control.invalid:null}get pending(){return this.control?this.control.pending:null}get disabled(){return this.control?this.control.disabled:null}get enabled(){return this.control?this.control.enabled:null}get errors(){return this.control?this.control.errors:null}get pristine(){return this.control?this.control.pristine:null}get dirty(){return this.control?this.control.dirty:null}get touched(){return this.control?this.control.touched:null}get status(){return this.control?this.control.status:null}get untouched(){return this.control?this.control.untouched:null}get statusChanges(){return this.control?this.control.statusChanges:null}get valueChanges(){return this.control?this.control.valueChanges:null}get path(){return null}_setValidators(t){this._rawValidators=t||[],this._composedValidatorFn=B2(this._rawValidators)}_setAsyncValidators(t){this._rawAsyncValidators=t||[],this._composedAsyncValidatorFn=V2(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn||null}get asyncValidator(){return this._composedAsyncValidatorFn||null}_registerOnDestroy(t){this._onDestroyCallbacks.push(t)}_invokeOnDestroyCallbacks(){this._onDestroyCallbacks.forEach(t=>t()),this._onDestroyCallbacks=[]}reset(t){this.control&&this.control.reset(t)}hasError(t,e){return!!this.control&&this.control.hasError(t,e)}getError(t,e){return this.control?this.control.getError(t,e):null}},Jo=class extends iE{get formDirective(){return null}get path(){return null}},qa=class extends iE{constructor(){super(...arguments),this._parent=null,this.name=null,this.valueAccessor=null}},N2=class{constructor(t){this._cd=t}get isTouched(){return!!this._cd?.control?.touched}get isUntouched(){return!!this._cd?.control?.untouched}get isPristine(){return!!this._cd?.control?.pristine}get isDirty(){return!!this._cd?.control?.dirty}get isValid(){return!!this._cd?.control?.valid}get isInvalid(){return!!this._cd?.control?.invalid}get isPending(){return!!this._cd?.control?.pending}get isSubmitted(){return!!this._cd?.submitted}},xg=(()=>{class n extends N2{constructor(e){super(e)}}return n.\u0275fac=function(e){return new(e||n)(C(qa,2))},n.\u0275dir=Me({type:n,selectors:[["","formControlName",""],["","ngModel",""],["","formControl",""]],hostVars:14,hostBindings:function(e,i){2&e&&nt("ng-untouched",i.isUntouched)("ng-touched",i.isTouched)("ng-pristine",i.isPristine)("ng-dirty",i.isDirty)("ng-valid",i.isValid)("ng-invalid",i.isInvalid)("ng-pending",i.isPending)},features:[Xe]}),n})();function lq(n,t){return n?`with name: '${t}'`:`at index: ${t}`}var L2=!1,Kv="VALID",eE="INVALID",yg="PENDING",Jv="DISABLED";function cq(n){return(cE(n)?n.validators:n)||null}function dq(n,t){return(cE(t)?t.asyncValidators:n)||null}function cE(n){return null!=n&&!Array.isArray(n)&&"object"==typeof n}var rE=class{constructor(t,e){this._pendingDirty=!1,this._hasOwnPendingAsyncValidator=!1,this._pendingTouched=!1,this._onCollectionChange=()=>{},this._parent=null,this.pristine=!0,this.touched=!1,this._onDisabledChange=[],this._assignValidators(t),this._assignAsyncValidators(e)}get validator(){return this._composedValidatorFn}set validator(t){this._rawValidators=this._composedValidatorFn=t}get asyncValidator(){return this._composedAsyncValidatorFn}set asyncValidator(t){this._rawAsyncValidators=this._composedAsyncValidatorFn=t}get parent(){return this._parent}get valid(){return this.status===Kv}get invalid(){return this.status===eE}get pending(){return this.status==yg}get disabled(){return this.status===Jv}get enabled(){return this.status!==Jv}get dirty(){return!this.pristine}get untouched(){return!this.touched}get updateOn(){return this._updateOn?this._updateOn:this.parent?this.parent.updateOn:"change"}setValidators(t){this._assignValidators(t)}setAsyncValidators(t){this._assignAsyncValidators(t)}addValidators(t){this.setValidators(L9(t,this._rawValidators))}addAsyncValidators(t){this.setAsyncValidators(L9(t,this._rawAsyncValidators))}removeValidators(t){this.setValidators(B9(t,this._rawValidators))}removeAsyncValidators(t){this.setAsyncValidators(B9(t,this._rawAsyncValidators))}hasValidator(t){return nE(this._rawValidators,t)}hasAsyncValidator(t){return nE(this._rawAsyncValidators,t)}clearValidators(){this.validator=null}clearAsyncValidators(){this.asyncValidator=null}markAsTouched(t={}){this.touched=!0,this._parent&&!t.onlySelf&&this._parent.markAsTouched(t)}markAllAsTouched(){this.markAsTouched({onlySelf:!0}),this._forEachChild(t=>t.markAllAsTouched())}markAsUntouched(t={}){this.touched=!1,this._pendingTouched=!1,this._forEachChild(e=>{e.markAsUntouched({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}markAsDirty(t={}){this.pristine=!1,this._parent&&!t.onlySelf&&this._parent.markAsDirty(t)}markAsPristine(t={}){this.pristine=!0,this._pendingDirty=!1,this._forEachChild(e=>{e.markAsPristine({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}markAsPending(t={}){this.status=yg,!1!==t.emitEvent&&this.statusChanges.emit(this.status),this._parent&&!t.onlySelf&&this._parent.markAsPending(t)}disable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=Jv,this.errors=null,this._forEachChild(i=>{i.disable({...t,onlySelf:!0})}),this._updateValue(),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!0))}enable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=Kv,this._forEachChild(i=>{i.enable({...t,onlySelf:!0})}),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent}),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!1))}_updateAncestors(t){this._parent&&!t.onlySelf&&(this._parent.updateValueAndValidity(t),t.skipPristineCheck||this._parent._updatePristine(),this._parent._updateTouched())}setParent(t){this._parent=t}getRawValue(){return this.value}updateValueAndValidity(t={}){this._setInitialStatus(),this._updateValue(),this.enabled&&(this._cancelExistingSubscription(),this.errors=this._runValidator(),this.status=this._calculateStatus(),(this.status===Kv||this.status===yg)&&this._runAsyncValidator(t.emitEvent)),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._parent&&!t.onlySelf&&this._parent.updateValueAndValidity(t)}_updateTreeValidity(t={emitEvent:!0}){this._forEachChild(e=>e._updateTreeValidity(t)),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent})}_setInitialStatus(){this.status=this._allControlsDisabled()?Jv:Kv}_runValidator(){return this.validator?this.validator(this):null}_runAsyncValidator(t){if(this.asyncValidator){this.status=yg,this._hasOwnPendingAsyncValidator=!0;let e=eq(this.asyncValidator(this));this._asyncValidationSubscription=e.subscribe(i=>{this._hasOwnPendingAsyncValidator=!1,this.setErrors(i,{emitEvent:t})})}}_cancelExistingSubscription(){this._asyncValidationSubscription&&(this._asyncValidationSubscription.unsubscribe(),this._hasOwnPendingAsyncValidator=!1)}setErrors(t,e={}){this.errors=t,this._updateControlsErrors(!1!==e.emitEvent)}get(t){let e=t;return null==e||(Array.isArray(e)||(e=e.split(".")),0===e.length)?null:e.reduce((i,r)=>i&&i._find(r),this)}getError(t,e){let i=e?this.get(e):this;return i&&i.errors?i.errors[t]:null}hasError(t,e){return!!this.getError(t,e)}get root(){let t=this;for(;t._parent;)t=t._parent;return t}_updateControlsErrors(t){this.status=this._calculateStatus(),t&&this.statusChanges.emit(this.status),this._parent&&this._parent._updateControlsErrors(t)}_initObservables(){this.valueChanges=new F,this.statusChanges=new F}_calculateStatus(){return this._allControlsDisabled()?Jv:this.errors?eE:this._hasOwnPendingAsyncValidator||this._anyControlsHaveStatus(yg)?yg:this._anyControlsHaveStatus(eE)?eE:Kv}_anyControlsHaveStatus(t){return this._anyControls(e=>e.status===t)}_anyControlsDirty(){return this._anyControls(t=>t.dirty)}_anyControlsTouched(){return this._anyControls(t=>t.touched)}_updatePristine(t={}){this.pristine=!this._anyControlsDirty(),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}_updateTouched(t={}){this.touched=this._anyControlsTouched(),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}_registerOnCollectionChange(t){this._onCollectionChange=t}_setUpdateStrategy(t){cE(t)&&null!=t.updateOn&&(this._updateOn=t.updateOn)}_parentMarkedDirty(t){return!t&&!(!this._parent||!this._parent.dirty)&&!this._parent._anyControlsDirty()}_find(t){return null}_assignValidators(t){this._rawValidators=Array.isArray(t)?t.slice():t,this._composedValidatorFn=function(n){return Array.isArray(n)?B2(n):n||null}(this._rawValidators)}_assignAsyncValidators(t){this._rawAsyncValidators=Array.isArray(t)?t.slice():t,this._composedAsyncValidatorFn=function(n){return Array.isArray(n)?V2(n):n||null}(this._rawAsyncValidators)}},oE=class extends rE{constructor(t,e,i){super(cq(e),dq(i,e)),this.controls=t,this._initObservables(),this._setUpdateStrategy(e),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator})}registerControl(t,e){return this.controls[t]?this.controls[t]:(this.controls[t]=e,e.setParent(this),e._registerOnCollectionChange(this._onCollectionChange),e)}addControl(t,e,i={}){this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}removeControl(t,e={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],this.updateValueAndValidity({emitEvent:e.emitEvent}),this._onCollectionChange()}setControl(t,e,i={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],e&&this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}contains(t){return this.controls.hasOwnProperty(t)&&this.controls[t].enabled}setValue(t,e={}){(function(n,t,e){n._forEachChild((i,r)=>{if(void 0===e[r])throw new xt(1002,L2?function(n,t){return`Must supply a value for form control ${lq(n,t)}`}(t,r):"")})})(this,!0,t),Object.keys(t).forEach(i=>{(function(n,t,e){let i=n.controls;if(!(t?Object.keys(i):i).length)throw new xt(1e3,L2?function(n){return`\n    There are no form controls registered with this ${n?"group":"array"} yet. If you're using ngModel,\n    you may want to check next tick (e.g. use setTimeout).\n  `}(t):"");if(!i[e])throw new xt(1001,L2?function(n,t){return`Cannot find form control ${lq(n,t)}`}(t,e):"")})(this,!0,i),this.controls[i].setValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e)}patchValue(t,e={}){null!=t&&(Object.keys(t).forEach(i=>{let r=this.controls[i];r&&r.patchValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e))}reset(t={},e={}){this._forEachChild((i,r)=>{i.reset(t[r],{onlySelf:!0,emitEvent:e.emitEvent})}),this._updatePristine(e),this._updateTouched(e),this.updateValueAndValidity(e)}getRawValue(){return this._reduceChildren({},(t,e,i)=>(t[i]=e.getRawValue(),t))}_syncPendingControls(){let t=this._reduceChildren(!1,(e,i)=>!!i._syncPendingControls()||e);return t&&this.updateValueAndValidity({onlySelf:!0}),t}_forEachChild(t){Object.keys(this.controls).forEach(e=>{let i=this.controls[e];i&&t(i,e)})}_setUpControls(){this._forEachChild(t=>{t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)})}_updateValue(){this.value=this._reduceValue()}_anyControls(t){for(let[e,i]of Object.entries(this.controls))if(this.contains(e)&&t(i))return!0;return!1}_reduceValue(){return this._reduceChildren({},(e,i,r)=>((i.enabled||this.disabled)&&(e[r]=i.value),e))}_reduceChildren(t,e){let i=t;return this._forEachChild((r,o)=>{i=e(i,r,o)}),i}_allControlsDisabled(){for(let t of Object.keys(this.controls))if(this.controls[t].enabled)return!1;return Object.keys(this.controls).length>0||this.disabled}_find(t){return this.controls.hasOwnProperty(t)?this.controls[t]:null}},Oh=new te("CallSetDisabledState",{providedIn:"root",factory:()=>ty}),ty="always";function dE(n,t){return[...t.path,n]}function ey(n,t,e=ty){H2(n,t),t.valueAccessor.writeValue(n.value),(n.disabled||"always"===e)&&t.valueAccessor.setDisabledState?.(n.disabled),function(n,t){t.valueAccessor.registerOnChange(e=>{n._pendingValue=e,n._pendingChange=!0,n._pendingDirty=!0,"change"===n.updateOn&&uq(n,t)})}(n,t),function(n,t){let e=(i,r)=>{t.valueAccessor.writeValue(i),r&&t.viewToModelUpdate(i)};n.registerOnChange(e),t._registerOnDestroy(()=>{n._unregisterOnChange(e)})}(n,t),function(n,t){t.valueAccessor.registerOnTouched(()=>{n._pendingTouched=!0,"blur"===n.updateOn&&n._pendingChange&&uq(n,t),"submit"!==n.updateOn&&n.markAsTouched()})}(n,t),function(n,t){if(t.valueAccessor.setDisabledState){let e=i=>{t.valueAccessor.setDisabledState(i)};n.registerOnDisabledChange(e),t._registerOnDestroy(()=>{n._unregisterOnDisabledChange(e)})}}(n,t)}function aE(n,t,e=!0){let i=()=>{};t.valueAccessor&&(t.valueAccessor.registerOnChange(i),t.valueAccessor.registerOnTouched(i)),lE(n,t),n&&(t._invokeOnDestroyCallbacks(),n._registerOnCollectionChange(()=>{}))}function sE(n,t){n.forEach(e=>{e.registerOnValidatorChange&&e.registerOnValidatorChange(t)})}function H2(n,t){let e=aq(n);null!==t.validator?n.setValidators(N9(e,t.validator)):"function"==typeof e&&n.setValidators([e]);let i=sq(n);null!==t.asyncValidator?n.setAsyncValidators(N9(i,t.asyncValidator)):"function"==typeof i&&n.setAsyncValidators([i]);let r=()=>n.updateValueAndValidity();sE(t._rawValidators,r),sE(t._rawAsyncValidators,r)}function lE(n,t){let e=!1;if(null!==n){if(null!==t.validator){let r=aq(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(a=>a!==t.validator);o.length!==r.length&&(e=!0,n.setValidators(o))}}if(null!==t.asyncValidator){let r=sq(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(a=>a!==t.asyncValidator);o.length!==r.length&&(e=!0,n.setAsyncValidators(o))}}}let i=()=>{};return sE(t._rawValidators,i),sE(t._rawAsyncValidators,i),e}function uq(n,t){n._pendingDirty&&n.markAsDirty(),n.setValue(n._pendingValue,{emitModelToViewChange:!1}),t.viewToModelUpdate(n._pendingValue),n._pendingChange=!1}function pq(n,t){H2(n,t)}function z2(n,t){if(!n.hasOwnProperty("model"))return!1;let e=n.model;return!!e.isFirstChange()||!Object.is(t,e.currentValue)}function hq(n,t){n._syncPendingControls(),t.forEach(e=>{let i=e.control;"submit"===i.updateOn&&i._pendingChange&&(e.viewToModelUpdate(i._pendingValue),i._pendingChange=!1)})}function U2(n,t){if(!t)return null;let e,i,r;return Array.isArray(t),t.forEach(o=>{o.constructor===Uu?e=o:function(n){return Object.getPrototypeOf(n.constructor)===kh}(o)?i=o:r=o}),r||i||e||null}var Jve={provide:Jo,useExisting:Wn(()=>Cg)},$v=Promise.resolve(),Cg=(()=>{class n extends Jo{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._directives=new Set,this.ngSubmit=new F,this.form=new oE({},B2(e),V2(i))}ngAfterViewInit(){this._setUpdateStrategy()}get formDirective(){return this}get control(){return this.form}get path(){return[]}get controls(){return this.form.controls}addControl(e){$v.then(()=>{let i=this._findContainer(e.path);e.control=i.registerControl(e.name,e.control),ey(e.control,e,this.callSetDisabledState),e.control.updateValueAndValidity({emitEvent:!1}),this._directives.add(e)})}getControl(e){return this.form.get(e.path)}removeControl(e){$v.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name),this._directives.delete(e)})}addFormGroup(e){$v.then(()=>{let i=this._findContainer(e.path),r=new oE({});pq(r,e),i.registerControl(e.name,r),r.updateValueAndValidity({emitEvent:!1})})}removeFormGroup(e){$v.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name)})}getFormGroup(e){return this.form.get(e.path)}updateModel(e,i){$v.then(()=>{this.form.get(e.path).setValue(i)})}setValue(e){this.control.setValue(e)}onSubmit(e){return this.submitted=!0,hq(this.form,this._directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.form._updateOn=this.options.updateOn)}_findContainer(e){return e.pop(),e.length?this.form.get(e):this.form}}return n.\u0275fac=function(e){return new(e||n)(C(Io,10),C(ju,10),C(Oh,8))},n.\u0275dir=Me({type:n,selectors:[["form",3,"ngNoForm","",3,"formGroup",""],["ng-form"],["","ngForm",""]],hostBindings:function(e,i){1&e&&A("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{options:["ngFormOptions","options"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Vt([Jve]),Xe]}),n})();function V9(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}function H9(n){return"object"==typeof n&&null!==n&&2===Object.keys(n).length&&"value"in n&&"disabled"in n}var ny=class extends rE{constructor(t=null,e,i){super(cq(e),dq(i,e)),this.defaultValue=null,this._onChange=[],this._pendingChange=!1,this._applyFormState(t),this._setUpdateStrategy(e),this._initObservables(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator}),cE(e)&&(e.nonNullable||e.initialValueIsDefault)&&(this.defaultValue=H9(t)?t.value:t)}setValue(t,e={}){this.value=this._pendingValue=t,this._onChange.length&&!1!==e.emitModelToViewChange&&this._onChange.forEach(i=>i(this.value,!1!==e.emitViewToModelChange)),this.updateValueAndValidity(e)}patchValue(t,e={}){this.setValue(t,e)}reset(t=this.defaultValue,e={}){this._applyFormState(t),this.markAsPristine(e),this.markAsUntouched(e),this.setValue(this.value,e),this._pendingChange=!1}_updateValue(){}_anyControls(t){return!1}_allControlsDisabled(){return this.disabled}registerOnChange(t){this._onChange.push(t)}_unregisterOnChange(t){V9(this._onChange,t)}registerOnDisabledChange(t){this._onDisabledChange.push(t)}_unregisterOnDisabledChange(t){V9(this._onDisabledChange,t)}_forEachChild(t){}_syncPendingControls(){return!("submit"!==this.updateOn||(this._pendingDirty&&this.markAsDirty(),this._pendingTouched&&this.markAsTouched(),!this._pendingChange)||(this.setValue(this._pendingValue,{onlySelf:!0,emitModelToViewChange:!1}),0))}_applyFormState(t){H9(t)?(this.value=this._pendingValue=t.value,t.disabled?this.disable({onlySelf:!0,emitEvent:!1}):this.enable({onlySelf:!0,emitEvent:!1})):this.value=this._pendingValue=t}},mq=(()=>{class n extends Jo{ngOnInit(){this._checkParentType(),this.formDirective.addFormGroup(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormGroup(this)}get control(){return this.formDirective.getFormGroup(this)}get path(){return dE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,features:[Xe]}),n})(),eye={provide:Jo,useExisting:Wn(()=>tye)},tye=(()=>{class n extends mq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){}}return n.\u0275fac=function(e){return new(e||n)(C(Jo,5),C(Io,10),C(ju,10))},n.\u0275dir=Me({type:n,selectors:[["","ngModelGroup",""]],inputs:{name:["ngModelGroup","name"]},exportAs:["ngModelGroup"],features:[Vt([eye]),Xe]}),n})(),nye={provide:qa,useExisting:Wn(()=>iy)},z9=Promise.resolve(),iy=(()=>{class n extends qa{constructor(e,i,r,o,a,s){super(),this._changeDetectorRef=a,this.callSetDisabledState=s,this.control=new ny,this._registered=!1,this.update=new F,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=U2(0,o)}ngOnChanges(e){if(this._checkForErrors(),!this._registered||"name"in e){if(this._registered&&(this._checkName(),this.formDirective)){let i=e.name.previousValue;this.formDirective.removeControl({name:i,path:this._getPath(i)})}this._setUpControl()}"isDisabled"in e&&this._updateDisabled(e),z2(e,this.viewModel)&&(this._updateValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}get path(){return this._getPath(this.name)}get formDirective(){return this._parent?this._parent.formDirective:null}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_setUpControl(){this._setUpdateStrategy(),this._isStandalone()?this._setUpStandalone():this.formDirective.addControl(this),this._registered=!0}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.control._updateOn=this.options.updateOn)}_isStandalone(){return!this._parent||!(!this.options||!this.options.standalone)}_setUpStandalone(){ey(this.control,this,this.callSetDisabledState),this.control.updateValueAndValidity({emitEvent:!1})}_checkForErrors(){this._isStandalone()||this._checkParentType(),this._checkName()}_checkParentType(){}_checkName(){this.options&&this.options.name&&(this.name=this.options.name),this._isStandalone()}_updateValue(e){z9.then(()=>{this.control.setValue(e,{emitViewToModelChange:!1}),this._changeDetectorRef?.markForCheck()})}_updateDisabled(e){let i=e.isDisabled.currentValue,r=0!==i&&ew(i);z9.then(()=>{r&&!this.control.disabled?this.control.disable():!r&&this.control.disabled&&this.control.enable(),this._changeDetectorRef?.markForCheck()})}_getPath(e){return this._parent?dE(e,this._parent):[e]}}return n.\u0275fac=function(e){return new(e||n)(C(Jo,9),C(Io,10),C(ju,10),C(Xr,10),C(Qt,8),C(Oh,8))},n.\u0275dir=Me({type:n,selectors:[["","ngModel","",3,"formControlName","",3,"formControl",""]],inputs:{name:"name",isDisabled:["disabled","isDisabled"],model:["ngModel","model"],options:["ngModelOptions","options"]},outputs:{update:"ngModelChange"},exportAs:["ngModel"],features:[Vt([nye]),Xe,qt]}),n})(),iye={provide:Xr,useExisting:Wn(()=>j2),multi:!0},j2=(()=>{class n extends kh{writeValue(e){this.setProperty("value",e??"")}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","number","formControlName",""],["input","type","number","formControl",""],["input","type","number","ngModel",""]],hostBindings:function(e,i){1&e&&A("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Vt([iye]),Xe]}),n})(),rye={provide:Xr,useExisting:Wn(()=>aye),multi:!0},fq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),oye=(()=>{class n{constructor(){this._accessors=[]}add(e,i){this._accessors.push([e,i])}remove(e){for(let i=this._accessors.length-1;i>=0;--i)if(this._accessors[i][1]===e)return void this._accessors.splice(i,1)}select(e){this._accessors.forEach(i=>{this._isSameGroup(i,e)&&i[1]!==e&&i[1].fireUncheck(e.value)})}_isSameGroup(e,i){return!!e[0].control&&e[0]._parent===i._control._parent&&e[1].name===i.name}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:fq}),n})(),aye=(()=>{class n extends kh{constructor(e,i,r,o){super(e,i),this._registry=r,this._injector=o,this.setDisabledStateFired=!1,this.onChange=()=>{},this.callSetDisabledState=$n(Oh,{optional:!0})??ty}ngOnInit(){this._control=this._injector.get(qa),this._checkName(),this._registry.add(this._control,this)}ngOnDestroy(){this._registry.remove(this)}writeValue(e){this._state=e===this.value,this.setProperty("checked",this._state)}registerOnChange(e){this._fn=e,this.onChange=()=>{e(this.value),this._registry.select(this)}}setDisabledState(e){(this.setDisabledStateFired||e||"whenDisabledForLegacyCode"===this.callSetDisabledState)&&this.setProperty("disabled",e),this.setDisabledStateFired=!0}fireUncheck(e){this.writeValue(e)}_checkName(){!this.name&&this.formControlName&&(this.name=this.formControlName)}}return n.\u0275fac=function(e){return new(e||n)(C(dc),C(xe),C(oye),C(wi))},n.\u0275dir=Me({type:n,selectors:[["input","type","radio","formControlName",""],["input","type","radio","formControl",""],["input","type","radio","ngModel",""]],hostBindings:function(e,i){1&e&&A("change",function(){return i.onChange()})("blur",function(){return i.onTouched()})},inputs:{name:"name",formControlName:"formControlName",value:"value"},features:[Vt([rye]),Xe]}),n})(),sye={provide:Xr,useExisting:Wn(()=>lye),multi:!0},lye=(()=>{class n extends kh{writeValue(e){this.setProperty("value",parseFloat(e))}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","range","formControlName",""],["input","type","range","formControl",""],["input","type","range","ngModel",""]],hostBindings:function(e,i){1&e&&A("change",function(o){return i.onChange(o.target.value)})("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[Vt([sye]),Xe]}),n})(),G2=new te("NgModelWithFormControlWarning"),cye={provide:qa,useExisting:Wn(()=>W2)},W2=(()=>{class n extends qa{set isDisabled(e){}constructor(e,i,r,o,a){super(),this._ngModelWarningConfig=o,this.callSetDisabledState=a,this.update=new F,this._ngModelWarningSent=!1,this._setValidators(e),this._setAsyncValidators(i),this.valueAccessor=U2(0,r)}ngOnChanges(e){if(this._isControlChanged(e)){let i=e.form.previousValue;i&&aE(i,this,!1),ey(this.form,this,this.callSetDisabledState),this.form.updateValueAndValidity({emitEvent:!1})}z2(e,this.viewModel)&&(this.form.setValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.form&&aE(this.form,this,!1)}get path(){return[]}get control(){return this.form}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_isControlChanged(e){return e.hasOwnProperty("form")}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C(Io,10),C(ju,10),C(Xr,10),C(G2,8),C(Oh,8))},n.\u0275dir=Me({type:n,selectors:[["","formControl",""]],inputs:{form:["formControl","form"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},exportAs:["ngForm"],features:[Vt([cye]),Xe,qt]}),n})(),dye={provide:Jo,useExisting:Wn(()=>Mg)},Mg=(()=>{class n extends Jo{constructor(e,i,r){super(),this.callSetDisabledState=r,this.submitted=!1,this._onCollectionChange=()=>this._updateDomValue(),this.directives=[],this.form=null,this.ngSubmit=new F,this._setValidators(e),this._setAsyncValidators(i)}ngOnChanges(e){this._checkFormPresent(),e.hasOwnProperty("form")&&(this._updateValidators(),this._updateDomValue(),this._updateRegistrations(),this._oldForm=this.form)}ngOnDestroy(){this.form&&(lE(this.form,this),this.form._onCollectionChange===this._onCollectionChange&&this.form._registerOnCollectionChange(()=>{}))}get formDirective(){return this}get control(){return this.form}get path(){return[]}addControl(e){let i=this.form.get(e.path);return ey(i,e,this.callSetDisabledState),i.updateValueAndValidity({emitEvent:!1}),this.directives.push(e),i}getControl(e){return this.form.get(e.path)}removeControl(e){aE(e.control||null,e,!1),function(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}(this.directives,e)}addFormGroup(e){this._setUpFormContainer(e)}removeFormGroup(e){this._cleanUpFormContainer(e)}getFormGroup(e){return this.form.get(e.path)}addFormArray(e){this._setUpFormContainer(e)}removeFormArray(e){this._cleanUpFormContainer(e)}getFormArray(e){return this.form.get(e.path)}updateModel(e,i){this.form.get(e.path).setValue(i)}onSubmit(e){return this.submitted=!0,hq(this.form,this.directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_updateDomValue(){this.directives.forEach(e=>{let i=e.control,r=this.form.get(e.path);i!==r&&(aE(i||null,e),(n=>n instanceof ny)(r)&&(ey(r,e,this.callSetDisabledState),e.control=r))}),this.form._updateTreeValidity({emitEvent:!1})}_setUpFormContainer(e){let i=this.form.get(e.path);pq(i,e),i.updateValueAndValidity({emitEvent:!1})}_cleanUpFormContainer(e){if(this.form){let i=this.form.get(e.path);i&&function(n,t){return lE(n,t)}(i,e)&&i.updateValueAndValidity({emitEvent:!1})}}_updateRegistrations(){this.form._registerOnCollectionChange(this._onCollectionChange),this._oldForm&&this._oldForm._registerOnCollectionChange(()=>{})}_updateValidators(){H2(this.form,this),this._oldForm&&lE(this._oldForm,this)}_checkFormPresent(){}}return n.\u0275fac=function(e){return new(e||n)(C(Io,10),C(ju,10),C(Oh,8))},n.\u0275dir=Me({type:n,selectors:[["","formGroup",""]],hostBindings:function(e,i){1&e&&A("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{form:["formGroup","form"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Vt([dye]),Xe,qt]}),n})(),uye={provide:Jo,useExisting:Wn(()=>gq)},gq=(()=>{class n extends mq{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){bq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C(Jo,13),C(Io,10),C(ju,10))},n.\u0275dir=Me({type:n,selectors:[["","formGroupName",""]],inputs:{name:["formGroupName","name"]},features:[Vt([uye]),Xe]}),n})(),pye={provide:Jo,useExisting:Wn(()=>_q)},_q=(()=>{class n extends Jo{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}ngOnInit(){this._checkParentType(),this.formDirective.addFormArray(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormArray(this)}get control(){return this.formDirective.getFormArray(this)}get formDirective(){return this._parent?this._parent.formDirective:null}get path(){return dE(null==this.name?this.name:this.name.toString(),this._parent)}_checkParentType(){bq(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(C(Jo,13),C(Io,10),C(ju,10))},n.\u0275dir=Me({type:n,selectors:[["","formArrayName",""]],inputs:{name:["formArrayName","name"]},features:[Vt([pye]),Xe]}),n})();function bq(n){return!(n instanceof gq||n instanceof Mg||n instanceof _q)}var hye={provide:qa,useExisting:Wn(()=>mye)},mye=(()=>{class n extends qa{set isDisabled(e){}constructor(e,i,r,o,a){super(),this._ngModelWarningConfig=a,this._added=!1,this.update=new F,this._ngModelWarningSent=!1,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=U2(0,o)}ngOnChanges(e){this._added||this._setUpControl(),z2(e,this.viewModel)&&(this.viewModel=this.model,this.formDirective.updateModel(this,this.model))}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}get path(){return dE(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}_setUpControl(){this._checkParentType(),this.control=this.formDirective.addControl(this),this._added=!0}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(C(Jo,13),C(Io,10),C(ju,10),C(Xr,10),C(G2,8))},n.\u0275dir=Me({type:n,selectors:[["","formControlName",""]],inputs:{name:["formControlName","name"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},features:[Vt([hye]),Xe,qt]}),n})(),fye={provide:Xr,useExisting:Wn(()=>yq),multi:!0};function vq(n,t){return null==n?`${t}`:(t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var yq=(()=>{class n extends kh{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){this.value=e;let r=vq(this._getOptionId(e),e);this.setProperty("value",r)}registerOnChange(e){this.onChange=i=>{this.value=this._getOptionValue(i),e(this.value)}}_registerOption(){return(this._idCounter++).toString()}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i),e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i):e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["select","formControlName","",3,"multiple",""],["select","formControl","",3,"multiple",""],["select","ngModel","",3,"multiple",""]],hostBindings:function(e,i){1&e&&A("change",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Vt([fye]),Xe]}),n})(),xq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption())}set ngValue(e){null!=this._select&&(this._select._optionMap.set(this.id,e),this._setElementValue(vq(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._setElementValue(e),this._select&&this._select.writeValue(this._select.value)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(dc),C(yq,9))},n.\u0275dir=Me({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})(),_ye={provide:Xr,useExisting:Wn(()=>Cq),multi:!0};function U9(n,t){return null==n?`${t}`:("string"==typeof t&&(t=`'${t}'`),t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var Cq=(()=>{class n extends kh{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){let i;if(this.value=e,Array.isArray(e)){let r=e.map(o=>this._getOptionId(o));i=(o,a)=>{o._setSelected(r.indexOf(a.toString())>-1)}}else i=(r,o)=>{r._setSelected(!1)};this._optionMap.forEach(i)}registerOnChange(e){this.onChange=i=>{let r=[],o=i.selectedOptions;if(void 0!==o){let a=o;for(let s=0;s<a.length;s++){let c=this._getOptionValue(a[s].value);r.push(c)}}else{let a=i.options;for(let s=0;s<a.length;s++){let l=a[s];if(l.selected){let c=this._getOptionValue(l.value);r.push(c)}}}this.value=r,e(r)}}_registerOption(e){let i=(this._idCounter++).toString();return this._optionMap.set(i,e),i}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i)._value,e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i)._value:e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["select","multiple","","formControlName",""],["select","multiple","","formControl",""],["select","multiple","","ngModel",""]],hostBindings:function(e,i){1&e&&A("change",function(o){return i.onChange(o.target)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[Vt([_ye]),Xe]}),n})(),Mq=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption(this))}set ngValue(e){null!=this._select&&(this._value=e,this._setElementValue(U9(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._select?(this._value=e,this._setElementValue(U9(this.id,e)),this._select.writeValue(this._select.value)):this._setElementValue(e)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}_setSelected(e){this._renderer.setProperty(this._element.nativeElement,"selected",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(dc),C(Cq,9))},n.\u0275dir=Me({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})();function wq(n){return"number"==typeof n?n:parseInt(n,10)}function Sq(n){return"number"==typeof n?n:parseFloat(n)}var Fh=(()=>{class n{constructor(){this._validator=tE}ngOnChanges(e){if(this.inputName in e){let i=this.normalizeInput(e[this.inputName].currentValue);this._enabled=this.enabled(i),this._validator=this._enabled?this.createValidator(i):tE,this._onChange&&this._onChange()}}validate(e){return this._validator(e)}registerOnValidatorChange(e){this._onChange=e}enabled(e){return null!=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,features:[qt]}),n})(),vye={provide:Io,useExisting:Wn(()=>yye),multi:!0},yye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="max",this.normalizeInput=e=>Sq(e),this.createValidator=e=>q9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","number","max","","formControlName",""],["input","type","number","max","","formControl",""],["input","type","number","max","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("max",i._enabled?i.max:null)},inputs:{max:"max"},features:[Vt([vye]),Xe]}),n})(),xye={provide:Io,useExisting:Wn(()=>Cye),multi:!0},Cye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="min",this.normalizeInput=e=>Sq(e),this.createValidator=e=>W9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","number","min","","formControlName",""],["input","type","number","min","","formControl",""],["input","type","number","min","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("min",i._enabled?i.min:null)},inputs:{min:"min"},features:[Vt([xye]),Xe]}),n})(),Mye={provide:Io,useExisting:Wn(()=>Eq),multi:!0},wye={provide:Io,useExisting:Wn(()=>q2),multi:!0},Eq=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="required",this.normalizeInput=ew,this.createValidator=e=>X9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","required","","formControlName","",3,"type","checkbox"],["","required","","formControl","",3,"type","checkbox"],["","required","","ngModel","",3,"type","checkbox"]],hostVars:1,hostBindings:function(e,i){2&e&&Be("required",i._enabled?"":null)},inputs:{required:"required"},features:[Vt([Mye]),Xe]}),n})(),q2=(()=>{class n extends Eq{constructor(){super(...arguments),this.createValidator=e=>Y9}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","type","checkbox","required","","formControlName",""],["input","type","checkbox","required","","formControl",""],["input","type","checkbox","required","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("required",i._enabled?"":null)},features:[Vt([wye]),Xe]}),n})(),Sye={provide:Io,useExisting:Wn(()=>Eye),multi:!0},Eye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="email",this.normalizeInput=ew,this.createValidator=e=>Q9}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","email","","formControlName",""],["","email","","formControl",""],["","email","","ngModel",""]],inputs:{email:"email"},features:[Vt([Sye]),Xe]}),n})(),Tye={provide:Io,useExisting:Wn(()=>Dye),multi:!0},Dye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="minlength",this.normalizeInput=e=>wq(e),this.createValidator=e=>Z9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","minlength","","formControlName",""],["","minlength","","formControl",""],["","minlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("minlength",i._enabled?i.minlength:null)},inputs:{minlength:"minlength"},features:[Vt([Tye]),Xe]}),n})(),Iye={provide:Io,useExisting:Wn(()=>Aye),multi:!0},Aye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="maxlength",this.normalizeInput=e=>wq(e),this.createValidator=e=>K9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","maxlength","","formControlName",""],["","maxlength","","formControl",""],["","maxlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("maxlength",i._enabled?i.maxlength:null)},inputs:{maxlength:"maxlength"},features:[Vt([Iye]),Xe]}),n})(),Rye={provide:Io,useExisting:Wn(()=>Pye),multi:!0},Pye=(()=>{class n extends Fh{constructor(){super(...arguments),this.inputName="pattern",this.normalizeInput=e=>e,this.createValidator=e=>J9(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","pattern","","formControlName",""],["","pattern","","formControl",""],["","pattern","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&Be("pattern",i._enabled?i.pattern:null)},inputs:{pattern:"pattern"},features:[Vt([Rye]),Xe]}),n})(),Tq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[fq]}),n})(),Gu=(new Ml("15.2.9"),(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:Oh,useValue:e.callSetDisabledState??ty}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Tq]}),n})()),uE=(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:G2,useValue:e.warnOnNgModelWithFormControl??"always"},{provide:Oh,useValue:e.callSetDisabledState??ty}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Tq]}),n})(),kye=["trigger"],Oye=["panel"];function Fye(n,t){if(1&n&&(f(0,"span",10),T(1),g()),2&n){let e=w();v(1),kt(e.placeholder)}}function Nye(n,t){if(1&n&&(f(0,"span",14),T(1),g()),2&n){let e=w(2);v(1),kt(e.triggerValue)}}function Lye(n,t){1&n&&Tt(0,0,["*ngSwitchCase","true"])}function Bye(n,t){1&n&&(f(0,"span",11),S(1,Nye,2,1,"span",12),S(2,Lye,1,0,"ng-content",13),g()),2&n&&(b("ngSwitch",!!w().customTrigger),v(2),b("ngSwitchCase",!0))}function Vye(n,t){if(1&n){let e=Te();qn(),ua(),f(0,"div",15,16),A("@transformPanel.done",function(r){return ne(e),ie(w()._panelDoneAnimatingStream.next(r.toState))})("keydown",function(r){return ne(e),ie(w()._handleKeydown(r))}),Tt(2,1),g()}if(2&n){let e=w();bb("mat-mdc-select-panel mdc-menu-surface mdc-menu-surface--open ",e._getPanelTheme(),""),b("ngClass",e.panelClass)("@transformPanel","showing"),Be("id",e.id+"-panel")("aria-multiselectable",e.multiple)("aria-label",e.ariaLabel||null)("aria-labelledby",e._getPanelAriaLabelledby())}}var Hye=[[["mat-select-trigger"]],"*"],zye=["mat-select-trigger","*"],Uye={transformPanelWrap:fr("transformPanelWrap",[bi("* => void",rh("@transformPanel",[ih()],{optional:!0}))]),transformPanel:fr("transformPanel",[Si("void",rn({opacity:0,transform:"scale(1, 0.8)"})),bi("void => showing",Mi("120ms cubic-bezier(0, 0, 0.2, 1)",rn({opacity:1,transform:"scale(1, 1)"}))),bi("* => void",Mi("100ms linear",rn({opacity:0})))])},Dq=0,Iq=new te("mat-select-scroll-strategy"),Gye=new te("MAT_SELECT_CONFIG"),Wye={provide:Iq,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},qye=new te("MatSelectTrigger"),Xye=go(Dc(ao(hg(class{constructor(n,t,e,i,r){this._elementRef=n,this._defaultErrorStateMatcher=t,this._parentForm=e,this._parentFormGroup=i,this.ngControl=r,this.stateChanges=new Ee}})))),Yye=(()=>{class n extends Xye{get focused(){return this._focused||this._panelOpen}get placeholder(){return this._placeholder}set placeholder(e){this._placeholder=e,this.stateChanges.next()}get required(){return this._required??this.ngControl?.control?.hasValidator(il.required)??!1}set required(e){this._required=vt(e),this.stateChanges.next()}get multiple(){return this._multiple}set multiple(e){this._multiple=vt(e)}get disableOptionCentering(){return this._disableOptionCentering}set disableOptionCentering(e){this._disableOptionCentering=vt(e)}get compareWith(){return this._compareWith}set compareWith(e){this._compareWith=e,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(e){this._assignValue(e)&&this._onChange(e)}get typeaheadDebounceInterval(){return this._typeaheadDebounceInterval}set typeaheadDebounceInterval(e){this._typeaheadDebounceInterval=mi(e)}get id(){return this._id}set id(e){this._id=e||this._uid,this.stateChanges.next()}constructor(e,i,r,o,a,s,l,c,d,u,p,h,m,_){super(a,o,l,c,u),this._viewportRuler=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=s,this._parentFormField=d,this._liveAnnouncer=m,this._defaultOptions=_,this._panelOpen=!1,this._compareWith=(M,y)=>M===y,this._uid="mat-select-"+Dq++,this._triggerAriaLabelledBy=null,this._destroy=new Ee,this._onChange=()=>{},this._onTouched=()=>{},this._valueId="mat-select-value-"+Dq++,this._panelDoneAnimatingStream=new Ee,this._overlayPanelClass=this._defaultOptions?.overlayPanelClass||"",this._focused=!1,this.controlType="mat-select",this._multiple=!1,this._disableOptionCentering=this._defaultOptions?.disableOptionCentering??!1,this.ariaLabel="",this.optionSelectionChanges=is(()=>{let M=this.options;return M?M.changes.pipe(kn(M),Jn(()=>tn(...M.map(y=>y.onSelectionChange)))):this._ngZone.onStable.pipe(Lt(1),Jn(()=>this.optionSelectionChanges))}),this.openedChange=new F,this._openedStream=this.openedChange.pipe(Oe(M=>M),q(()=>{})),this._closedStream=this.openedChange.pipe(Oe(M=>!M),q(()=>{})),this.selectionChange=new F,this.valueChange=new F,this.ngControl&&(this.ngControl.valueAccessor=this),null!=_?.typeaheadDebounceInterval&&(this._typeaheadDebounceInterval=_.typeaheadDebounceInterval),this._scrollStrategyFactory=h,this._scrollStrategy=this._scrollStrategyFactory(),this.tabIndex=parseInt(p)||0,this.id=this.id}ngOnInit(){this._selectionModel=new fg(this.multiple),this.stateChanges.next(),this._panelDoneAnimatingStream.pipe(ri(),it(this._destroy)).subscribe(()=>this._panelDoneAnimating(this.panelOpen))}ngAfterContentInit(){this._initKeyManager(),this._selectionModel.changed.pipe(it(this._destroy)).subscribe(e=>{e.added.forEach(i=>i.select()),e.removed.forEach(i=>i.deselect())}),this.options.changes.pipe(kn(null),it(this._destroy)).subscribe(()=>{this._resetOptions(),this._initializeSelection()})}ngDoCheck(){let e=this._getTriggerAriaLabelledby(),i=this.ngControl;if(e!==this._triggerAriaLabelledBy){let r=this._elementRef.nativeElement;this._triggerAriaLabelledBy=e,e?r.setAttribute("aria-labelledby",e):r.removeAttribute("aria-labelledby")}i&&(this._previousControl!==i.control&&(void 0!==this._previousControl&&null!==i.disabled&&i.disabled!==this.disabled&&(this.disabled=i.disabled),this._previousControl=i.control),this.updateErrorState())}ngOnChanges(e){(e.disabled||e.userAriaDescribedBy)&&this.stateChanges.next(),e.typeaheadDebounceInterval&&this._keyManager&&this._keyManager.withTypeAhead(this._typeaheadDebounceInterval)}ngOnDestroy(){this._keyManager?.destroy(),this._destroy.next(),this._destroy.complete(),this.stateChanges.complete()}toggle(){this.panelOpen?this.close():this.open()}open(){this._canOpen()&&(this._panelOpen=!0,this._keyManager.withHorizontalOrientation(null),this._highlightCorrectOption(),this._changeDetectorRef.markForCheck())}close(){this._panelOpen&&(this._panelOpen=!1,this._keyManager.withHorizontalOrientation(this._isRtl()?"rtl":"ltr"),this._changeDetectorRef.markForCheck(),this._onTouched())}writeValue(e){this._assignValue(e)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this._changeDetectorRef.markForCheck(),this.stateChanges.next()}get panelOpen(){return this._panelOpen}get selected(){return this.multiple?this._selectionModel?.selected||[]:this._selectionModel?.selected[0]}get triggerValue(){if(this.empty)return"";if(this._multiple){let e=this._selectionModel.selected.map(i=>i.viewValue);return this._isRtl()&&e.reverse(),e.join(", ")}return this._selectionModel.selected[0].viewValue}_isRtl(){return!!this._dir&&"rtl"===this._dir.value}_handleKeydown(e){this.disabled||(this.panelOpen?this._handleOpenKeydown(e):this._handleClosedKeydown(e))}_handleClosedKeydown(e){let i=e.keyCode,r=40===i||38===i||37===i||39===i,o=13===i||32===i,a=this._keyManager;if(!a.isTyping()&&o&&!Or(e)||(this.multiple||e.altKey)&&r)e.preventDefault(),this.open();else if(!this.multiple){let s=this.selected;a.onKeydown(e);let l=this.selected;l&&s!==l&&this._liveAnnouncer.announce(l.viewValue,1e4)}}_handleOpenKeydown(e){let i=this._keyManager,r=e.keyCode,o=40===r||38===r,a=i.isTyping();if(o&&e.altKey)e.preventDefault(),this.close();else if(a||13!==r&&32!==r||!i.activeItem||Or(e))if(!a&&this._multiple&&65===r&&e.ctrlKey){e.preventDefault();let s=this.options.some(l=>!l.disabled&&!l.selected);this.options.forEach(l=>{l.disabled||(s?l.select():l.deselect())})}else{let s=i.activeItemIndex;i.onKeydown(e),this._multiple&&o&&e.shiftKey&&i.activeItem&&i.activeItemIndex!==s&&i.activeItem._selectViaInteraction()}else e.preventDefault(),i.activeItem._selectViaInteraction()}_onFocus(){this.disabled||(this._focused=!0,this.stateChanges.next())}_onBlur(){this._focused=!1,this._keyManager?.cancelTypeahead(),!this.disabled&&!this.panelOpen&&(this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next())}_onAttached(){this._overlayDir.positionChange.pipe(Lt(1)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this._positioningSettled()})}_getPanelTheme(){return this._parentFormField?`mat-${this._parentFormField.color}`:""}get empty(){return!this._selectionModel||this._selectionModel.isEmpty()}_initializeSelection(){Promise.resolve().then(()=>{this.ngControl&&(this._value=this.ngControl.value),this._setSelectionByValue(this._value),this.stateChanges.next()})}_setSelectionByValue(e){if(this.options.forEach(i=>i.setInactiveStyles()),this._selectionModel.clear(),this.multiple&&e)Array.isArray(e),e.forEach(i=>this._selectOptionByValue(i)),this._sortValues();else{let i=this._selectOptionByValue(e);i?this._keyManager.updateActiveItem(i):this.panelOpen||this._keyManager.updateActiveItem(-1)}this._changeDetectorRef.markForCheck()}_selectOptionByValue(e){let i=this.options.find(r=>{if(this._selectionModel.isSelected(r))return!1;try{return null!=r.value&&this._compareWith(r.value,e)}catch{return!1}});return i&&this._selectionModel.select(i),i}_assignValue(e){return!!(e!==this._value||this._multiple&&Array.isArray(e))&&(this.options&&this._setSelectionByValue(e),this._value=e,!0)}_initKeyManager(){this._keyManager=new lg(this.options).withTypeAhead(this._typeaheadDebounceInterval).withVerticalOrientation().withHorizontalOrientation(this._isRtl()?"rtl":"ltr").withHomeAndEnd().withPageUpDown().withAllowedModifierKeys(["shiftKey"]),this._keyManager.tabOut.subscribe(()=>{this.panelOpen&&(!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction(),this.focus(),this.close())}),this._keyManager.change.subscribe(()=>{this._panelOpen&&this.panel?this._scrollOptionIntoView(this._keyManager.activeItemIndex||0):!this._panelOpen&&!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction()})}_resetOptions(){let e=tn(this.options.changes,this._destroy);this.optionSelectionChanges.pipe(it(e)).subscribe(i=>{this._onSelect(i.source,i.isUserInput),i.isUserInput&&!this.multiple&&this._panelOpen&&(this.close(),this.focus())}),tn(...this.options.map(i=>i._stateChanges)).pipe(it(e)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this.stateChanges.next()})}_onSelect(e,i){let r=this._selectionModel.isSelected(e);null!=e.value||this._multiple?(r!==e.selected&&(e.selected?this._selectionModel.select(e):this._selectionModel.deselect(e)),i&&this._keyManager.setActiveItem(e),this.multiple&&(this._sortValues(),i&&this.focus())):(e.deselect(),this._selectionModel.clear(),null!=this.value&&this._propagateChanges(e.value)),r!==this._selectionModel.isSelected(e)&&this._propagateChanges(),this.stateChanges.next()}_sortValues(){if(this.multiple){let e=this.options.toArray();this._selectionModel.sort((i,r)=>this.sortComparator?this.sortComparator(i,r,e):e.indexOf(i)-e.indexOf(r)),this.stateChanges.next()}}_propagateChanges(e){let i=null;i=this.multiple?this.selected.map(r=>r.value):this.selected?this.selected.value:e,this._value=i,this.valueChange.emit(i),this._onChange(i),this.selectionChange.emit(this._getChangeEvent(i)),this._changeDetectorRef.markForCheck()}_highlightCorrectOption(){this._keyManager&&(this.empty?this._keyManager.setFirstItemActive():this._keyManager.setActiveItem(this._selectionModel.selected[0]))}_canOpen(){return!this._panelOpen&&!this.disabled&&this.options?.length>0}focus(e){this._elementRef.nativeElement.focus(e)}_getPanelAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId();return this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_getAriaActiveDescendant(){return this.panelOpen&&this._keyManager&&this._keyManager.activeItem?this._keyManager.activeItem.id:null}_getTriggerAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId(),i=(e?e+" ":"")+this._valueId;return this.ariaLabelledby&&(i+=" "+this.ariaLabelledby),i}_panelDoneAnimating(e){this.openedChange.emit(e)}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focus(),this.open()}get shouldLabelFloat(){return this._panelOpen||!this.empty||this._focused&&!!this._placeholder}}return n.\u0275fac=function(e){return new(e||n)(C(Wa),C(Qt),C(ot),C(Eh),C(xe),C(zi,8),C(Cg,8),C(Mg,8),C(Ph,8),C(qa,10),Mo("tabindex"),C(Iq),C(Hv),C(Gye,8))},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&(Ue(kye,5),Ue(Oye,5),Ue(Vu,5)),2&e){let r;be(r=ve())&&(i.trigger=r.first),be(r=ve())&&(i.panel=r.first),be(r=ve())&&(i._overlayDir=r.first)}},inputs:{userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],panelClass:"panelClass",placeholder:"placeholder",required:"required",multiple:"multiple",disableOptionCentering:"disableOptionCentering",compareWith:"compareWith",value:"value",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],errorStateMatcher:"errorStateMatcher",typeaheadDebounceInterval:"typeaheadDebounceInterval",sortComparator:"sortComparator",id:"id"},outputs:{openedChange:"openedChange",_openedStream:"opened",_closedStream:"closed",selectionChange:"selectionChange",valueChange:"valueChange"},features:[Xe,qt]}),n})(),Wu=(()=>{class n extends Yye{constructor(){super(...arguments),this._positions=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:"mat-mdc-select-panel-above"}],this._hideSingleSelectionIndicator=this._defaultOptions?.hideSingleSelectionIndicator??!1}get shouldLabelFloat(){return this.panelOpen||!this.empty||this.focused&&!!this.placeholder}ngOnInit(){super.ngOnInit(),this._viewportRuler.change().pipe(it(this._destroy)).subscribe(()=>{this.panelOpen&&(this._overlayWidth=this._getOverlayWidth(),this._changeDetectorRef.detectChanges())})}ngAfterViewInit(){this._parentFormField&&(this._preferredOverlayOrigin=this._parentFormField.getConnectedOverlayOrigin())}open(){this._overlayWidth=this._getOverlayWidth(),super.open(),this.stateChanges.next()}close(){super.close(),this.stateChanges.next()}_scrollOptionIntoView(e){let i=this.options.toArray()[e];if(i){let r=this.panel.nativeElement,o=z1(e,this.options,this.optionGroups),a=i._getHostElement();r.scrollTop=0===e&&1===o?0:U1(a.offsetTop,a.offsetHeight,r.scrollTop,r.offsetHeight)}}_positioningSettled(){this._scrollOptionIntoView(this._keyManager.activeItemIndex||0)}_getChangeEvent(e){return new class{constructor(t,e){this.source=t,this.value=e}}(this,e)}_getOverlayWidth(){return(this._preferredOverlayOrigin instanceof Md?this._preferredOverlayOrigin.elementRef:this._preferredOverlayOrigin||this._elementRef).nativeElement.getBoundingClientRect().width}get hideSingleSelectionIndicator(){return this._hideSingleSelectionIndicator}set hideSingleSelectionIndicator(e){this._hideSingleSelectionIndicator=vt(e),this._syncParentProperties()}_syncParentProperties(){if(this.options)for(let e of this.options)e._changeDetectorRef.markForCheck()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-select"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,qye,5),Bn(r,ja,5),Bn(r,jv,5)),2&e){let o;be(o=ve())&&(i.customTrigger=o.first),be(o=ve())&&(i.options=o),be(o=ve())&&(i.optionGroups=o)}},hostAttrs:["role","combobox","aria-autocomplete","none","aria-haspopup","listbox",1,"mat-mdc-select"],hostVars:19,hostBindings:function(e,i){1&e&&A("keydown",function(o){return i._handleKeydown(o)})("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()}),2&e&&(Be("id",i.id)("tabindex",i.tabIndex)("aria-controls",i.panelOpen?i.id+"-panel":null)("aria-expanded",i.panelOpen)("aria-label",i.ariaLabel||null)("aria-required",i.required.toString())("aria-disabled",i.disabled.toString())("aria-invalid",i.errorState)("aria-activedescendant",i._getAriaActiveDescendant()),nt("mat-mdc-select-disabled",i.disabled)("mat-mdc-select-invalid",i.errorState)("mat-mdc-select-required",i.required)("mat-mdc-select-empty",i.empty)("mat-mdc-select-multiple",i.multiple))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex",hideSingleSelectionIndicator:"hideSingleSelectionIndicator"},exportAs:["matSelect"],features:[Vt([{provide:Yv,useExisting:n},{provide:Uv,useExisting:n}]),Xe],ngContentSelectors:zye,decls:11,vars:11,consts:[["cdk-overlay-origin","",1,"mat-mdc-select-trigger",3,"click"],["fallbackOverlayOrigin","cdkOverlayOrigin","trigger",""],[1,"mat-mdc-select-value",3,"ngSwitch"],["class","mat-mdc-select-placeholder mat-mdc-select-min-line",4,"ngSwitchCase"],["class","mat-mdc-select-value-text",3,"ngSwitch",4,"ngSwitchCase"],[1,"mat-mdc-select-arrow-wrapper"],[1,"mat-mdc-select-arrow"],["viewBox","0 0 24 24","width","24px","height","24px","focusable","false"],["d","M7 10l5 5 5-5z"],["cdk-connected-overlay","","cdkConnectedOverlayLockPosition","","cdkConnectedOverlayHasBackdrop","","cdkConnectedOverlayBackdropClass","cdk-overlay-transparent-backdrop",3,"cdkConnectedOverlayPanelClass","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayWidth","backdropClick","attach","detach"],[1,"mat-mdc-select-placeholder","mat-mdc-select-min-line"],[1,"mat-mdc-select-value-text",3,"ngSwitch"],["class","mat-mdc-select-min-line",4,"ngSwitchDefault"],[4,"ngSwitchCase"],[1,"mat-mdc-select-min-line"],["role","listbox","tabindex","-1",3,"ngClass","keydown"],["panel",""]],template:function(e,i){if(1&e&&(fn(Hye),f(0,"div",0,1),A("click",function(){return i.toggle()}),f(3,"div",2),S(4,Fye,2,1,"span",3),S(5,Bye,3,2,"span",4),g(),f(6,"div",5)(7,"div",6),qn(),f(8,"svg",7),k(9,"path",8),g()()()(),S(10,Vye,3,9,"ng-template",9),A("backdropClick",function(){return i.close()})("attach",function(){return i._onAttached()})("detach",function(){return i.close()})),2&e){let r=st(1);Be("aria-owns",i.panelOpen?i.id+"-panel":null),v(3),b("ngSwitch",i.empty),Be("id",i._valueId),v(1),b("ngSwitchCase",!0),v(1),b("ngSwitchCase",!1),v(5),b("cdkConnectedOverlayPanelClass",i._overlayPanelClass)("cdkConnectedOverlayScrollStrategy",i._scrollStrategy)("cdkConnectedOverlayOrigin",i._preferredOverlayOrigin||r)("cdkConnectedOverlayOpen",i.panelOpen)("cdkConnectedOverlayPositions",i._positions)("cdkConnectedOverlayWidth",i._overlayWidth)}},dependencies:[wn,mr,kr,du,Vu,Md],styles:['.mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mat-mdc-select{display:inline-block;width:100%;outline:none}.mat-mdc-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-mdc-select-disabled .mat-mdc-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-mdc-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-mdc-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-mdc-select-arrow-wrapper{height:24px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-mdc-select-arrow-wrapper{transform:translateY(-8px)}.mat-form-field-appearance-fill .mdc-text-field--no-label .mat-mdc-select-arrow-wrapper{transform:none}.mat-mdc-select-arrow{width:10px;height:5px;position:relative}.mat-mdc-select-arrow svg{fill:currentColor;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%)}.cdk-high-contrast-active .mat-mdc-select-arrow svg{fill:CanvasText}.mat-mdc-select-disabled .cdk-high-contrast-active .mat-mdc-select-arrow svg{fill:GrayText}.mdc-menu-surface.mat-mdc-select-panel{width:100%;max-height:275px;position:static;outline:0;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-select-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-select-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-select-panel-above) .mdc-menu-surface.mat-mdc-select-panel{border-top-left-radius:0;border-top-right-radius:0;transform-origin:top center}.mat-mdc-select-panel-above .mdc-menu-surface.mat-mdc-select-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:bottom center}.mat-mdc-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-mdc-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-mdc-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-fill .mat-mdc-floating-label{max-width:calc(100% - 18px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-fill .mdc-floating-label--float-above{max-width:calc(100% / 0.75 - 24px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-outline .mdc-notched-outline__notch{max-width:calc(100% - 60px)}.mat-mdc-form-field-type-mat-select.mat-form-field-appearance-outline .mdc-text-field--label-floating .mdc-notched-outline__notch{max-width:calc(100% - 24px)}.mat-mdc-select-min-line:empty::before{content:" ";white-space:pre;width:1px;display:inline-block;visibility:hidden}'],encapsulation:2,data:{animation:[Uye.transformPanel]},changeDetection:0}),n})(),Xa=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Wye],imports:[De,Do,mg,dn,Ic,Qv,mg,dn]}),n})();function Qye(n,t){1&n&&(Gt(0),f(1,"div",1),T(2," There is a difference between Default - (Enabled/Disabled) and (Enabled/Disabled) "),g(),f(3,"div",1),T(4," Only flags with non default values are sent to the backend. "),g(),Wt())}function Zye(n,t){if(1&n&&(Gt(0),f(1,"div",1),T(2),g(),Wt()),2&n){let e=w();v(2),Ve(' Feature Flags are filtered to only show features containing "',e.showFlagsFilter,'" ')}}function Kye(n,t){1&n&&(f(0,"sup",11),T(1,"1"),g())}function Jye(n,t){1&n&&hi(0)}function $ye(n,t){if(1&n){let e=Te();f(0,"mat-select",12),A("selectionChange",function(r){ne(e);let o=w().$implicit;return ie(w().flagChanged.emit({flag:o.flag,status:r.value}))}),f(1,"mat-option",13),T(2),g(),f(3,"mat-option",14),T(4,"Enabled"),g(),f(5,"mat-option",15),T(6,"Disabled"),g()()}if(2&n){let e=w().$implicit,i=w();b("value",e.status),v(2),Ve(" Default ",i.formatFlagValue(e.defaultValue)," ")}}function exe(n,t){if(1&n&&(f(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w();v(1),Ve("Unsupported By UI ",i.formatFlagValue(e.value),"")}}function txe(n,t){if(1&n&&(Gt(0),f(1,"tr")(2,"td")(3,"div"),T(4),S(5,Kye,2,0,"sup",7),g()(),S(6,Jye,1,0,"ng-container",8),S(7,$ye,7,2,"ng-template",null,9,jt),S(9,exe,2,1,"ng-template",null,10,jt),g(),Wt()),2&n){let e=t.$implicit,i=st(8),r=st(10),o=w();v(4),Ve(" ",e.flag," "),v(1),b("ngIf",e.sendToServerWhenOverridden),v(1),b("ngIf",o.isEditable(e))("ngIfThen",i)("ngIfElse",r)}}function nxe(n,t){1&n&&(f(0,"div",11),T(1," 1. Sent to server when overridden "),g())}var hE,Aq=(()=>{class n{constructor(){this.hasFlagsSentToServer=!1,this.flagChanged=new F,this.allFlagsReset=new F}serializeFlagValue(e){return!0===e?"Enabled":!1===e?"Disabled":null==e?"null":Array.isArray(e)?JSON.stringify(e):e.toString()}isEditable(e){return"boolean"==typeof e.defaultValue}formatFlagValue(e){let i=this.serializeFlagValue(e);return 0===i.length?"":`- ${i}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["feature-flag-dialog-component"]],inputs:{featureFlagStatuses:"featureFlagStatuses",hasFlagsSentToServer:"hasFlagsSentToServer",showFlagsFilter:"showFlagsFilter"},outputs:{flagChanged:"flagChanged",allFlagsReset:"allFlagsReset"},decls:12,vars:4,consts:[[1,"scrolling-page"],[1,"message"],[1,"warning"],[4,"ngIf"],[1,"feature-flag-table"],[4,"ngFor","ngForOf"],["mat-button","",3,"click"],["class","note-1",4,"ngIf"],[4,"ngIf","ngIfThen","ngIfElse"],["selectBlock",""],["unsupportedBlock",""],[1,"note-1"],[3,"value","selectionChange"],["value","default"],["value","enabled"],["value","disabled"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1)(2,"h2",2),T(3,"WARNING: EXPERIMENTAL FEATURES AHEAD!"),g(),T(4," By enabling these features, you could put the application in an unusable state or expose yourself to untested features or potential bugs. "),g(),S(5,Qye,5,0,"ng-container",3),S(6,Zye,3,1,"ng-container",3),f(7,"table",4),S(8,txe,11,5,"ng-container",5),g(),f(9,"button",6),A("click",function(){return i.allFlagsReset.emit()}),T(10,"Reset All"),g(),S(11,nxe,2,0,"div",7),g()),2&e&&(v(5),b("ngIf",i.hasFlagsSentToServer),v(1),b("ngIf",i.showFlagsFilter),v(2),b("ngForOf",i.featureFlagStatuses),v(3),b("ngIf",i.hasFlagsSentToServer))},dependencies:[nn,Ne,ki,Wu,ja],styles:[".message[_ngcontent-%COMP%]{margin-bottom:16px}.message[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#f44336}.note-1[_ngcontent-%COMP%]{color:#ff9800}.scrolling-page[_ngcontent-%COMP%]{max-height:90vh}.feature-flag-table[_ngcontent-%COMP%]{width:100%}"]}),n})(),Rq=(()=>{class n{constructor(e){this.store=e,this.showFlagsFilter$=this.store.select(sv).pipe(q(i=>i.showFlags?.toLowerCase())),this.hasFlagsSentToServer$=this.store.select(fh).pipe(q(i=>Object.values(i).some(r=>r.sendToServerWhenOverridden))),this.featureFlags$=this.store.select(sv).pipe(It(this.store.select(C6),this.store.select(fh),this.showFlagsFilter$),q(([i,r,o,a])=>Object.entries(r).filter(([s])=>!a||s.toLowerCase().includes(a)).map(([s,l])=>{let c=function(n,t){return void 0===t[n]?"default":t[n]?"enabled":"disabled"}(s,i);return{flag:s,defaultValue:l,status:c,sendToServerWhenOverridden:o[s].sendToServerWhenOverridden}})))}onFlagChanged({flag:e,status:i}){switch(i){case"default":this.store.dispatch(xu({flags:[e]}));break;case"enabled":this.store.dispatch(yh({flags:{[e]:!0}}));break;case"disabled":this.store.dispatch(yh({flags:{[e]:!1}}));break;default:throw new Error("Flag changed to invalid status")}}onAllFlagsReset(){this.store.dispatch(Qf())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["feature-flag-dialog"]],decls:4,vars:9,consts:[[3,"featureFlagStatuses","hasFlagsSentToServer","showFlagsFilter","flagChanged","allFlagsReset"]],template:function(e,i){1&e&&(f(0,"feature-flag-dialog-component",0),A("flagChanged",function(o){return i.onFlagChanged(o)})("allFlagsReset",function(){return i.onAllFlagsReset()}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("featureFlagStatuses",G(1,3,i.featureFlags$))("hasFlagsSentToServer",G(2,5,i.hasFlagsSentToServer$))("showFlagsFilter",G(3,7,i.showFlagsFilter$))},dependencies:[Aq,ct],encapsulation:2}),n})(),Pq=(()=>{class n{constructor(e,i){this.store=e,this.dialog=i,this.featureFlagDialogType=Rq,this.showFeatureFlags$=this.store.select(E6),this.ngUnsubscribe=new Ee}ngOnInit(){this.showFeatureFlags$.pipe(it(this.ngUnsubscribe)).subscribe(e=>{if(e)return this.featureFlagsDialog=this.dialog.open(this.featureFlagDialogType),void this.featureFlagsDialog.afterClosed().pipe(it(this.ngUnsubscribe)).subscribe(()=>{this.store.dispatch(xu({flags:["showFlags"]})),setTimeout(()=>{window.location.reload()},1)})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(ys))},n.\u0275cmp=P({type:n,selectors:[["feature-flag-modal-trigger"]],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),sxe=["routeContainer"],kq=(()=>{class n{constructor(e){this.componentFactoryResolver=e}ngOnChanges(e){let i=e.activeNgComponent;if(i&&(this.routeContainer.clear(),i.currentValue)){let r=this.componentFactoryResolver.resolveComponentFactory(i.currentValue);this.routeContainer.createComponent(r)}}}return n.\u0275fac=function(e){return new(e||n)(C(ho))},n.\u0275cmp=P({type:n,selectors:[["router-outlet-component"]],viewQuery:function(e,i){if(1&e&&Ue(sxe,7,ei),2&e){let r;be(r=ve())&&(i.routeContainer=r.first)}},inputs:{activeNgComponent:"activeNgComponent"},features:[qt],decls:2,vars:0,consts:[["routeContainer",""]],template:function(e,i){1&e&&hi(0,null,0)},encapsulation:2,changeDetection:0}),n})(),Oq=(()=>{class n{constructor(e,i){this.store=e,this.registry=i,this.activeNgComponent$=In([this.store.select(Ho),this.store.select(Q8)]).pipe(q(([r,o])=>r&&(null===o||Vo(r,o))?this.registry.getNgComponentByRouteKind(r.routeKind):null))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(Rl))},n.\u0275cmp=P({type:n,selectors:[["router-outlet"]],decls:2,vars:3,consts:[[3,"activeNgComponent"]],template:function(e,i){1&e&&(k(0,"router-outlet-component",0),U(1,"async")),2&e&&b("activeNgComponent",G(1,1,i.activeNgComponent$))},dependencies:[kq,ct],encapsulation:2,changeDetection:0}),n})(),Fq=(()=>{class n{constructor(e){e.select(Pl).subscribe(i=>{document.body.classList.toggle("dark-mode",i)})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["dark-mode-supporter"]],decls:0,vars:0,template:function(e,i){},styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),Sg=(()=>(function(n){n[n.ACTIVE_PLUGIN=0]="ACTIVE_PLUGIN"}(Sg||(Sg={})),Sg))(),Nq=(()=>{class n{constructor(e){this.deepLinker=e,this.onValueChange=new F,this.ngUnsubscribe=new Ee,this.onHashChange=Ei(window,"popstate",{passive:!0}).pipe(it(this.ngUnsubscribe))}ngOnInit(){this.onHashChange.subscribe(()=>{let e=this.deepLinker.getPluginId();e!==this.activePluginId&&this.onValueChange.emit({prop:Sg.ACTIVE_PLUGIN,value:e})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.activePluginId){let i=e.activePluginId;this.deepLinker.setPluginId(null===i.currentValue?"":i.currentValue,{defaultValue:"",useLocationReplace:null===i.previousValue||i.firstChange})}}}return n.\u0275fac=function(e){return new(e||n)(C(gu))},n.\u0275cmp=P({type:n,selectors:[["hash-storage-component"]],inputs:{activePluginId:"activePluginId"},outputs:{onValueChange:"onValueChange"},features:[qt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Lq=(()=>{class n{constructor(e){this.store=e,this.activePluginId$=this.store.pipe(un(Zo))}onValueChanged(e){e.prop===Sg.ACTIVE_PLUGIN&&this.store.dispatch(hS({plugin:e.value}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["hash-storage"]],decls:2,vars:3,consts:[[3,"activePluginId","onValueChange"]],template:function(e,i){1&e&&(f(0,"hash-storage-component",0),A("onValueChange",function(o){return i.onValueChanged(o)}),U(1,"async"),g()),2&e&&b("activePluginId",G(1,1,i.activePluginId$))},dependencies:[Nq,ct],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),hxe=["*"];function ry(n){return function(){if(void 0===hE&&(hE=null,typeof window<"u")){let n=window;void 0!==n.trustedTypes&&(hE=n.trustedTypes.createPolicy("angular#components",{createHTML:t=>t}))}return hE}()?.createHTML(n)||n}function Bq(n){return Error(`Unable to find icon with the name "${n}"`)}function Vq(n){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${n}".`)}function Hq(n){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${n}".`)}var Sd=class{constructor(t,e,i){this.url=t,this.svgText=e,this.options=i}},Eg=(()=>{class n{constructor(e,i,r,o){this._httpClient=e,this._sanitizer=i,this._errorHandler=o,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._resolvers=[],this._defaultFontSetClass=["material-icons","mat-ligature-font"],this._document=r}addSvgIcon(e,i,r){return this.addSvgIconInNamespace("",e,i,r)}addSvgIconLiteral(e,i,r){return this.addSvgIconLiteralInNamespace("",e,i,r)}addSvgIconInNamespace(e,i,r,o){return this._addSvgIconConfig(e,i,new Sd(r,null,o))}addSvgIconResolver(e){return this._resolvers.push(e),this}addSvgIconLiteralInNamespace(e,i,r,o){let a=this._sanitizer.sanitize(Ur.HTML,r);if(!a)throw Hq(r);let s=ry(a);return this._addSvgIconConfig(e,i,new Sd("",s,o))}addSvgIconSet(e,i){return this.addSvgIconSetInNamespace("",e,i)}addSvgIconSetLiteral(e,i){return this.addSvgIconSetLiteralInNamespace("",e,i)}addSvgIconSetInNamespace(e,i,r){return this._addSvgIconSetConfig(e,new Sd(i,null,r))}addSvgIconSetLiteralInNamespace(e,i,r){let o=this._sanitizer.sanitize(Ur.HTML,i);if(!o)throw Hq(i);let a=ry(o);return this._addSvgIconSetConfig(e,new Sd("",a,r))}registerFontClassAlias(e,i=e){return this._fontCssClassesByAlias.set(e,i),this}classNameForFontAlias(e){return this._fontCssClassesByAlias.get(e)||e}setDefaultFontSetClass(...e){return this._defaultFontSetClass=e,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(e){let i=this._sanitizer.sanitize(Ur.RESOURCE_URL,e);if(!i)throw Vq(e);let r=this._cachedIconsByUrl.get(i);return r?$t(mE(r)):this._loadSvgIconFromConfig(new Sd(e,null)).pipe(Dt(o=>this._cachedIconsByUrl.set(i,o)),q(o=>mE(o)))}getNamedSvgIcon(e,i=""){let r=zq(i,e),o=this._svgIconConfigs.get(r);if(o)return this._getSvgFromConfig(o);if(o=this._getIconConfigFromResolvers(i,e),o)return this._svgIconConfigs.set(r,o),this._getSvgFromConfig(o);let a=this._iconSetConfigs.get(i);return a?this._getSvgFromIconSetConfigs(e,a):_l(Bq(r))}ngOnDestroy(){this._resolvers=[],this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(e){return e.svgText?$t(mE(this._svgElementFromConfig(e))):this._loadSvgIconFromConfig(e).pipe(q(i=>mE(i)))}_getSvgFromIconSetConfigs(e,i){let r=this._extractIconWithNameFromAnySet(e,i);return r?$t(r):Co(i.filter(a=>!a.svgText).map(a=>this._loadSvgIconSetFromConfig(a).pipe(co(s=>{let c=`Loading icon set URL: ${this._sanitizer.sanitize(Ur.RESOURCE_URL,a.url)} failed: ${s.message}`;return this._errorHandler.handleError(new Error(c)),$t(null)})))).pipe(q(()=>{let a=this._extractIconWithNameFromAnySet(e,i);if(!a)throw Bq(e);return a}))}_extractIconWithNameFromAnySet(e,i){for(let r=i.length-1;r>=0;r--){let o=i[r];if(o.svgText&&o.svgText.toString().indexOf(e)>-1){let a=this._svgElementFromConfig(o),s=this._extractSvgIconFromSet(a,e,o.options);if(s)return s}}return null}_loadSvgIconFromConfig(e){return this._fetchIcon(e).pipe(Dt(i=>e.svgText=i),q(()=>this._svgElementFromConfig(e)))}_loadSvgIconSetFromConfig(e){return e.svgText?$t(null):this._fetchIcon(e).pipe(Dt(i=>e.svgText=i))}_extractSvgIconFromSet(e,i,r){let o=e.querySelector(`[id="${i}"]`);if(!o)return null;let a=o.cloneNode(!0);if(a.removeAttribute("id"),"svg"===a.nodeName.toLowerCase())return this._setSvgAttributes(a,r);if("symbol"===a.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(a),r);let s=this._svgElementFromString(ry("<svg></svg>"));return s.appendChild(a),this._setSvgAttributes(s,r)}_svgElementFromString(e){let i=this._document.createElement("DIV");i.innerHTML=e;let r=i.querySelector("svg");if(!r)throw Error("<svg> tag not found");return r}_toSvgElement(e){let i=this._svgElementFromString(ry("<svg></svg>")),r=e.attributes;for(let o=0;o<r.length;o++){let{name:a,value:s}=r[o];"id"!==a&&i.setAttribute(a,s)}for(let o=0;o<e.childNodes.length;o++)e.childNodes[o].nodeType===this._document.ELEMENT_NODE&&i.appendChild(e.childNodes[o].cloneNode(!0));return i}_setSvgAttributes(e,i){return e.setAttribute("fit",""),e.setAttribute("height","100%"),e.setAttribute("width","100%"),e.setAttribute("preserveAspectRatio","xMidYMid meet"),e.setAttribute("focusable","false"),i&&i.viewBox&&e.setAttribute("viewBox",i.viewBox),e}_fetchIcon(e){let{url:i,options:r}=e,o=r?.withCredentials??!1;if(!this._httpClient)throw Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.");if(null==i)throw Error(`Cannot fetch icon from URL "${i}".`);let a=this._sanitizer.sanitize(Ur.RESOURCE_URL,i);if(!a)throw Vq(i);let s=this._inProgressUrlFetches.get(a);if(s)return s;let l=this._httpClient.get(a,{responseType:"text",withCredentials:o}).pipe(q(c=>ry(c)),function(n){return Yt((t,e)=>{try{t.subscribe(e)}finally{e.add(n)}})}(()=>this._inProgressUrlFetches.delete(a)),Ta());return this._inProgressUrlFetches.set(a,l),l}_addSvgIconConfig(e,i,r){return this._svgIconConfigs.set(zq(e,i),r),this}_addSvgIconSetConfig(e,i){let r=this._iconSetConfigs.get(e);return r?r.push(i):this._iconSetConfigs.set(e,[i]),this}_svgElementFromConfig(e){if(!e.svgElement){let i=this._svgElementFromString(e.svgText);this._setSvgAttributes(i,e.options),e.svgElement=i}return e.svgElement}_getIconConfigFromResolvers(e,i){for(let r=0;r<this._resolvers.length;r++){let o=this._resolvers[r](i,e);if(o)return _xe(o)?new Sd(o.url,null,o.options):new Sd(o,null)}}}return n.\u0275fac=function(e){return new(e||n)(O(mh,8),O(nh),O(Nt,8),O(la))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function mE(n){return n.cloneNode(!0)}function zq(n,t){return n+":"+t}function _xe(n){return!(!n.url||!n.options)}new ka,new id,new ka,new ka;var bxe=Ko(class{constructor(n){this._elementRef=n}}),vxe=new te("MAT_ICON_DEFAULT_OPTIONS"),yxe=new te("mat-icon-location",{providedIn:"root",factory:function(){let n=$n(Nt),t=n?n.location:null;return{getPathname:()=>t?t.pathname+t.search:""}}}),Uq=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],Cxe=Uq.map(n=>`[${n}]`).join(", "),Mxe=/^url\(['"]?#(.*?)['"]?\)$/,bn=(()=>{class n extends bxe{get inline(){return this._inline}set inline(e){this._inline=vt(e)}get svgIcon(){return this._svgIcon}set svgIcon(e){e!==this._svgIcon&&(e?this._updateSvgIcon(e):this._svgIcon&&this._clearSvgElement(),this._svgIcon=e)}get fontSet(){return this._fontSet}set fontSet(e){let i=this._cleanupFontValue(e);i!==this._fontSet&&(this._fontSet=i,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(e){let i=this._cleanupFontValue(e);i!==this._fontIcon&&(this._fontIcon=i,this._updateFontIconClasses())}constructor(e,i,r,o,a,s){super(e),this._iconRegistry=i,this._location=o,this._errorHandler=a,this._inline=!1,this._previousFontSetClass=[],this._currentIconFetch=En.EMPTY,s&&(s.color&&(this.color=this.defaultColor=s.color),s.fontSet&&(this.fontSet=s.fontSet)),r||e.nativeElement.setAttribute("aria-hidden","true")}_splitIconName(e){if(!e)return["",""];let i=e.split(":");switch(i.length){case 1:return["",i[0]];case 2:return i;default:throw Error(`Invalid icon name: "${e}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){let e=this._elementsWithExternalReferences;if(e&&e.size){let i=this._location.getPathname();i!==this._previousPath&&(this._previousPath=i,this._prependPathToReferences(i))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(e){this._clearSvgElement();let i=this._location.getPathname();this._previousPath=i,this._cacheChildrenWithExternalReferences(e),this._prependPathToReferences(i),this._elementRef.nativeElement.appendChild(e)}_clearSvgElement(){let e=this._elementRef.nativeElement,i=e.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();i--;){let r=e.childNodes[i];(1!==r.nodeType||"svg"===r.nodeName.toLowerCase())&&r.remove()}}_updateFontIconClasses(){if(!this._usingFontIcon())return;let e=this._elementRef.nativeElement,i=(this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/):this._iconRegistry.getDefaultFontSetClass()).filter(r=>r.length>0);this._previousFontSetClass.forEach(r=>e.classList.remove(r)),i.forEach(r=>e.classList.add(r)),this._previousFontSetClass=i,this.fontIcon!==this._previousFontIconClass&&!i.includes("mat-ligature-font")&&(this._previousFontIconClass&&e.classList.remove(this._previousFontIconClass),this.fontIcon&&e.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(e){return"string"==typeof e?e.trim().split(" ")[0]:e}_prependPathToReferences(e){let i=this._elementsWithExternalReferences;i&&i.forEach((r,o)=>{r.forEach(a=>{o.setAttribute(a.name,`url('${e}#${a.value}')`)})})}_cacheChildrenWithExternalReferences(e){let i=e.querySelectorAll(Cxe),r=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let o=0;o<i.length;o++)Uq.forEach(a=>{let s=i[o],l=s.getAttribute(a),c=l?l.match(Mxe):null;if(c){let d=r.get(s);d||(d=[],r.set(s,d)),d.push({name:a,value:c[1]})}})}_updateSvgIcon(e){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),e){let[i,r]=this._splitIconName(e);i&&(this._svgNamespace=i),r&&(this._svgName=r),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(r,i).pipe(Lt(1)).subscribe(o=>this._setSvgElement(o),o=>{this._errorHandler.handleError(new Error(`Error retrieving icon ${i}:${r}! ${o.message}`))})}}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Eg),Mo("aria-hidden"),C(yxe),C(la),C(vxe,8))},n.\u0275cmp=P({type:n,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:8,hostBindings:function(e,i){2&e&&(Be("data-mat-icon-type",i._usingFontIcon()?"font":"svg")("data-mat-icon-name",i._svgName||i.fontIcon)("data-mat-icon-namespace",i._svgNamespace||i.fontSet)("fontIcon",i._usingFontIcon()?i.fontIcon:null),nt("mat-icon-inline",i.inline)("mat-icon-no-color","primary"!==i.color&&"accent"!==i.color&&"warn"!==i.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[Xe],ngContentSelectors:hxe,decls:1,vars:0,template:function(e,i){1&e&&(fn(),Tt(0))},styles:[".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}"],encapsulation:2,changeDetection:0}),n})(),ai=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,dn]}),n})(),wxe=["*",[["mat-toolbar-row"]]],Sxe=["*","mat-toolbar-row"],Exe=Ko(class{constructor(n){this._elementRef=n}}),Txe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["mat-toolbar-row"]],hostAttrs:[1,"mat-toolbar-row"],exportAs:["matToolbarRow"]}),n})(),jq=(()=>{class n extends Exe{constructor(e,i,r){super(e),this._platform=i,this._document=r}ngAfterViewInit(){this._platform.isBrowser&&(this._checkToolbarMixedModes(),this._toolbarRows.changes.subscribe(()=>this._checkToolbarMixedModes()))}_checkToolbarMixedModes(){}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(Nt))},n.\u0275cmp=P({type:n,selectors:[["mat-toolbar"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,Txe,5),2&e){let o;be(o=ve())&&(i._toolbarRows=o)}},hostAttrs:[1,"mat-toolbar"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-toolbar-multiple-rows",i._toolbarRows.length>0)("mat-toolbar-single-row",0===i._toolbarRows.length)},inputs:{color:"color"},exportAs:["matToolbar"],features:[Xe],ngContentSelectors:Sxe,decls:2,vars:0,template:function(e,i){1&e&&(fn(wxe),Tt(0),Tt(1,1))},styles:[".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar .mat-mdc-button-base.mat-unthemed{--mdc-text-button-label-text-color: inherit;--mdc-outlined-button-label-text-color: inherit}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}"],encapsulation:2,changeDetection:0}),n})(),Gq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,dn]}),n})();function Y2(n){return n.state!==Re.NOT_LOADED&&n.state!==Re.LOADING}var Ixe=gr(i7,ye(x1,n=>Y2(n)?{...n,settings:{...n.settings,reloadEnabled:!n.settings.reloadEnabled}}:n),ye(C1,(n,{periodInMs:t})=>{if(!Y2(n))return n;let e=t>=3e4?t:n.settings.reloadPeriodInMs;return{...n,settings:{...n.settings,reloadPeriodInMs:e}}}),ye(M1,(n,{size:t})=>{if(!Y2(n))return n;let e=t>0?t:n.settings.pageSize;return{...n,settings:{...n.settings,pageSize:e}}}),ye(hs,(n,{partialSettings:t})=>{let e={};return Number.isFinite(t.pageSize)&&t.pageSize>0&&(e.pageSize=Number(t.pageSize)),"boolean"==typeof t.autoReload&&(e.reloadEnabled=t.autoReload),Number.isFinite(t.autoReloadPeriodInMs)&&t.autoReloadPeriodInMs>3e4&&(e.reloadPeriodInMs=Number(t.autoReloadPeriodInMs)),{...n,settings:{...n.settings,...e}}}));function Wq(n,t){return Ixe(n,t)}var Axe=["input"],Rxe=["label"],Pxe=["*"],Z2=new te("mat-checkbox-default-options",{providedIn:"root",factory:function(){return{color:"accent",clickAction:"check-indeterminate"}}});var kxe={provide:Xr,useExisting:Wn(()=>xs),multi:!0},Oxe=0,qq={color:"accent",clickAction:"check-indeterminate"},Fxe=Dc(Ko(go(ao(class{constructor(n){this._elementRef=n}})))),Nxe=(()=>{class n extends Fxe{get inputId(){return`${this.id||this._uniqueId}-input`}get required(){return this._required}set required(e){this._required=vt(e)}constructor(e,i,r,o,a,s,l){super(i),this._changeDetectorRef=r,this._ngZone=o,this._animationMode=s,this._options=l,this.ariaLabel="",this.ariaLabelledby=null,this.labelPosition="after",this.name=null,this.change=new F,this.indeterminateChange=new F,this._onTouched=()=>{},this._currentAnimationClass="",this._currentCheckState=0,this._controlValueAccessorChangeFn=()=>{},this._checked=!1,this._disabled=!1,this._indeterminate=!1,this._options=this._options||qq,this.color=this.defaultColor=this._options.color||qq.color,this.tabIndex=parseInt(a)||0,this.id=this._uniqueId=`${e}${++Oxe}`}ngAfterViewInit(){this._syncIndeterminate(this._indeterminate)}get checked(){return this._checked}set checked(e){let i=vt(e);i!=this.checked&&(this._checked=i,this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled}set disabled(e){let i=vt(e);i!==this.disabled&&(this._disabled=i,this._changeDetectorRef.markForCheck())}get indeterminate(){return this._indeterminate}set indeterminate(e){let i=e!=this._indeterminate;this._indeterminate=vt(e),i&&(this._transitionCheckState(this._indeterminate?3:this.checked?1:2),this.indeterminateChange.emit(this._indeterminate)),this._syncIndeterminate(this._indeterminate)}_isRippleDisabled(){return this.disableRipple||this.disabled}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}writeValue(e){this.checked=!!e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_transitionCheckState(e){let i=this._currentCheckState,r=this._getAnimationTargetElement();if(i!==e&&r&&(this._currentAnimationClass&&r.classList.remove(this._currentAnimationClass),this._currentAnimationClass=this._getAnimationClassForCheckStateTransition(i,e),this._currentCheckState=e,this._currentAnimationClass.length>0)){r.classList.add(this._currentAnimationClass);let o=this._currentAnimationClass;this._ngZone.runOutsideAngular(()=>{setTimeout(()=>{r.classList.remove(o)},1e3)})}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.checked),this.change.emit(this._createChangeEvent(this.checked)),this._inputElement&&(this._inputElement.nativeElement.checked=this.checked)}toggle(){this.checked=!this.checked,this._controlValueAccessorChangeFn(this.checked)}_handleInputClick(){let e=this._options?.clickAction;this.disabled||"noop"===e?!this.disabled&&"noop"===e&&(this._inputElement.nativeElement.checked=this.checked,this._inputElement.nativeElement.indeterminate=this.indeterminate):(this.indeterminate&&"check"!==e&&Promise.resolve().then(()=>{this._indeterminate=!1,this.indeterminateChange.emit(this._indeterminate)}),this._checked=!this._checked,this._transitionCheckState(this._checked?1:2),this._emitChangeEvent())}_onInteractionEvent(e){e.stopPropagation()}_onBlur(){Promise.resolve().then(()=>{this._onTouched(),this._changeDetectorRef.markForCheck()})}_getAnimationClassForCheckStateTransition(e,i){if("NoopAnimations"===this._animationMode)return"";switch(e){case 0:if(1===i)return this._animationClasses.uncheckedToChecked;if(3==i)return this._checked?this._animationClasses.checkedToIndeterminate:this._animationClasses.uncheckedToIndeterminate;break;case 2:return 1===i?this._animationClasses.uncheckedToChecked:this._animationClasses.uncheckedToIndeterminate;case 1:return 2===i?this._animationClasses.checkedToUnchecked:this._animationClasses.checkedToIndeterminate;case 3:return 1===i?this._animationClasses.indeterminateToChecked:this._animationClasses.indeterminateToUnchecked}return""}_syncIndeterminate(e){let i=this._inputElement;i&&(i.nativeElement.indeterminate=e)}}return n.\u0275fac=function(e){cs()},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&(Ue(Axe,5),Ue(Rxe,5),Ue(Ki,5)),2&e){let r;be(r=ve())&&(i._inputElement=r.first),be(r=ve())&&(i._labelElement=r.first),be(r=ve())&&(i.ripple=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],id:"id",required:"required",labelPosition:"labelPosition",name:"name",value:"value",checked:"checked",disabled:"disabled",indeterminate:"indeterminate"},outputs:{change:"change",indeterminateChange:"indeterminateChange"},features:[Xe]}),n})(),xs=(()=>{class n extends Nxe{constructor(e,i,r,o,a,s){super("mat-mdc-checkbox-",e,i,r,o,a,s),this._animationClasses={uncheckedToChecked:"mdc-checkbox--anim-unchecked-checked",uncheckedToIndeterminate:"mdc-checkbox--anim-unchecked-indeterminate",checkedToUnchecked:"mdc-checkbox--anim-checked-unchecked",checkedToIndeterminate:"mdc-checkbox--anim-checked-indeterminate",indeterminateToChecked:"mdc-checkbox--anim-indeterminate-checked",indeterminateToUnchecked:"mdc-checkbox--anim-indeterminate-unchecked"}}focus(){this._inputElement.nativeElement.focus()}_createChangeEvent(e){let i=new class{};return i.source=this,i.checked=e,i}_getAnimationTargetElement(){return this._inputElement?.nativeElement}_onInputClick(){super._handleInputClick()}_onTouchTargetClick(){super._handleInputClick(),this.disabled||this._inputElement.nativeElement.focus()}_preventBubblingFromLabel(e){e.target&&this._labelElement.nativeElement.contains(e.target)&&e.stopPropagation()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(ot),Mo("tabindex"),C(pi,8),C(Z2,8))},n.\u0275cmp=P({type:n,selectors:[["mat-checkbox"]],hostAttrs:[1,"mat-mdc-checkbox"],hostVars:12,hostBindings:function(e,i){2&e&&(wo("id",i.id),Be("tabindex",null)("aria-label",null)("aria-labelledby",null),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mdc-checkbox--disabled",i.disabled)("mat-mdc-checkbox-disabled",i.disabled)("mat-mdc-checkbox-checked",i.checked))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matCheckbox"],features:[Vt([kxe]),Xe],ngContentSelectors:Pxe,decls:15,vars:19,consts:[[1,"mdc-form-field",3,"click"],[1,"mdc-checkbox"],["checkbox",""],[1,"mat-mdc-checkbox-touch-target",3,"click"],["type","checkbox",1,"mdc-checkbox__native-control",3,"checked","indeterminate","disabled","id","required","tabIndex","blur","click","change"],["input",""],[1,"mdc-checkbox__ripple"],[1,"mdc-checkbox__background"],["focusable","false","viewBox","0 0 24 24","aria-hidden","true",1,"mdc-checkbox__checkmark"],["fill","none","d","M1.73,12.91 8.1,19.28 22.79,4.59",1,"mdc-checkbox__checkmark-path"],[1,"mdc-checkbox__mixedmark"],["mat-ripple","",1,"mat-mdc-checkbox-ripple","mat-mdc-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleCentered"],[3,"for"],["label",""]],template:function(e,i){if(1&e&&(fn(),f(0,"div",0),A("click",function(o){return i._preventBubblingFromLabel(o)}),f(1,"div",1,2)(3,"div",3),A("click",function(){return i._onTouchTargetClick()}),g(),f(4,"input",4,5),A("blur",function(){return i._onBlur()})("click",function(){return i._onInputClick()})("change",function(o){return i._onInteractionEvent(o)}),g(),k(6,"div",6),f(7,"div",7),qn(),f(8,"svg",8),k(9,"path",9),g(),ua(),k(10,"div",10),g(),k(11,"div",11),g(),f(12,"label",12,13),Tt(14),g()()),2&e){let r=st(2);nt("mdc-form-field--align-end","before"==i.labelPosition),v(4),nt("mdc-checkbox--selected",i.checked),b("checked",i.checked)("indeterminate",i.indeterminate)("disabled",i.disabled)("id",i.inputId)("required",i.required)("tabIndex",i.tabIndex),Be("aria-label",i.ariaLabel||null)("aria-labelledby",i.ariaLabelledby)("aria-describedby",i.ariaDescribedby)("name",i.name)("value",i.value),v(7),b("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)("matRippleCentered",!0),v(1),b("for",i.inputId)}},dependencies:[Ki],styles:['.mdc-touch-target-wrapper{display:inline}@keyframes mdc-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:29.7833385}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 1)}100%{stroke-dashoffset:0}}@keyframes mdc-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mdc-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);opacity:1;stroke-dashoffset:0}to{opacity:0;stroke-dashoffset:-29.7833385}}@keyframes mdc-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(45deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(45deg);opacity:0}to{transform:rotate(360deg);opacity:1}}@keyframes mdc-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:mdc-animation-deceleration-curve-timing-function;transform:rotate(-45deg);opacity:0}to{transform:rotate(0deg);opacity:1}}@keyframes mdc-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);transform:rotate(0deg);opacity:1}to{transform:rotate(315deg);opacity:0}}@keyframes mdc-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;transform:scaleX(1);opacity:1}32.8%,100%{transform:scaleX(0);opacity:0}}.mdc-checkbox{display:inline-block;position:relative;flex:0 0 18px;box-sizing:content-box;width:18px;height:18px;line-height:0;white-space:nowrap;cursor:pointer;vertical-align:bottom}.mdc-checkbox[hidden]{display:none}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{pointer-events:none;border:2px solid rgba(0,0,0,0);border-radius:6px;box-sizing:content-box;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:100%;width:100%}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring{border-color:CanvasText}}.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{content:"";border:2px solid rgba(0,0,0,0);border-radius:8px;display:block;position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);height:calc(100% + 4px);width:calc(100% + 4px)}@media screen and (forced-colors: active){.mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__focus-ring::after,.mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__focus-ring::after{border-color:CanvasText}}@media all and (-ms-high-contrast: none){.mdc-checkbox .mdc-checkbox__focus-ring{display:none}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mdc-checkbox__mixedmark{margin:0 1px}}.mdc-checkbox--disabled{cursor:default;pointer-events:none}.mdc-checkbox__background{display:inline-flex;position:absolute;align-items:center;justify-content:center;box-sizing:border-box;width:18px;height:18px;border:2px solid currentColor;border-radius:2px;background-color:rgba(0,0,0,0);pointer-events:none;will-change:background-color,border-color;transition:background-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),border-color 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__checkmark{position:absolute;top:0;right:0;bottom:0;left:0;width:100%;opacity:0;transition:opacity 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--upgraded .mdc-checkbox__checkmark{opacity:1}.mdc-checkbox__checkmark-path{transition:stroke-dashoffset 180ms 0ms cubic-bezier(0.4, 0, 0.6, 1);stroke:currentColor;stroke-width:3.12px;stroke-dashoffset:29.7833385;stroke-dasharray:29.7833385}.mdc-checkbox__mixedmark{width:100%;height:0;transform:scaleX(0) rotate(0deg);border-width:1px;border-style:solid;opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__background,.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__background,.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__background,.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__background{animation-duration:180ms;animation-timing-function:linear}.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-unchecked-checked-checkmark-path 180ms linear 0s;transition:none}.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-unchecked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__checkmark-path{animation:mdc-checkbox-checked-unchecked-checkmark-path 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__checkmark{animation:mdc-checkbox-checked-indeterminate-checkmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-checked-indeterminate .mdc-checkbox__mixedmark{animation:mdc-checkbox-checked-indeterminate-mixedmark 90ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__checkmark{animation:mdc-checkbox-indeterminate-checked-checkmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-checked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-checked-mixedmark 500ms linear 0s;transition:none}.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__mixedmark{animation:mdc-checkbox-indeterminate-unchecked-mixedmark 300ms linear 0s;transition:none}.mdc-checkbox__native-control:checked~.mdc-checkbox__background,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background{transition:border-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1),background-color 90ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark-path,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark-path{stroke-dashoffset:0}.mdc-checkbox__native-control{position:absolute;margin:0;padding:0;opacity:0;cursor:inherit}.mdc-checkbox__native-control:disabled{cursor:default;pointer-events:none}.mdc-checkbox--touch{margin:calc((var(--mdc-checkbox-state-layer-size, 48px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mdc-checkbox--touch .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 48px)) / 2);width:var(--mdc-checkbox-state-layer-size, 48px);height:var(--mdc-checkbox-state-layer-size, 48px)}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__checkmark{transition:opacity 180ms 0ms cubic-bezier(0, 0, 0.2, 1),transform 180ms 0ms cubic-bezier(0, 0, 0.2, 1);opacity:1}.mdc-checkbox__native-control:checked~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(-45deg)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__checkmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__checkmark{transform:rotate(45deg);opacity:0;transition:opacity 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1),transform 90ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-checkbox__native-control:indeterminate~.mdc-checkbox__background .mdc-checkbox__mixedmark,.mdc-checkbox__native-control[data-indeterminate=true]~.mdc-checkbox__background .mdc-checkbox__mixedmark{transform:scaleX(1) rotate(0deg);opacity:1}.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__background,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__checkmark-path,.mdc-checkbox.mdc-checkbox--upgraded .mdc-checkbox__mixedmark{transition:none}.mdc-form-field{display:inline-flex;align-items:center;vertical-align:middle}.mdc-form-field[hidden]{display:none}.mdc-form-field>label{margin-left:0;margin-right:auto;padding-left:4px;padding-right:0;order:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{margin-left:auto;margin-right:0}[dir=rtl] .mdc-form-field>label,.mdc-form-field>label[dir=rtl]{padding-left:0;padding-right:4px}.mdc-form-field--nowrap>label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.mdc-form-field--align-end>label{margin-left:auto;margin-right:0;padding-left:0;padding-right:4px;order:-1}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{margin-left:0;margin-right:auto}[dir=rtl] .mdc-form-field--align-end>label,.mdc-form-field--align-end>label[dir=rtl]{padding-left:4px;padding-right:0}.mdc-form-field--space-between{justify-content:space-between}.mdc-form-field--space-between>label{margin:0}[dir=rtl] .mdc-form-field--space-between>label,.mdc-form-field--space-between>label[dir=rtl]{margin:0}.mat-mdc-checkbox{display:inline-block;position:relative;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-checkbox .mdc-checkbox{padding:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);margin:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-disabled-unselected-icon-color, rgba(0, 0, 0, 0.38));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[disabled]:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true][disabled]~.mdc-checkbox__background{border-color:transparent;background-color:var(--mdc-checkbox-disabled-selected-icon-color, rgba(0, 0, 0, 0.38))}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__checkmark{color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:disabled~.mdc-checkbox__background .mdc-checkbox__mixedmark{border-color:var(--mdc-checkbox-disabled-selected-checkmark-color, #fff)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-hover-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-hover-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:hover.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-focus-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-focus-icon-color, var(--mdc-theme-secondary, #018786));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox.mdc-ripple-upgraded--background-focused.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(.mdc-ripple-upgraded):focus.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-FF018786FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:checked~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control:enabled:indeterminate~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active .mdc-checkbox__native-control[data-indeterminate=true]:enabled~.mdc-checkbox__background{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}@keyframes mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786{0%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}50%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}}@keyframes mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786{0%,80%{border-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786));background-color:var(--mdc-checkbox-selected-pressed-icon-color, var(--mdc-theme-secondary, #018786))}100%{border-color:var(--mdc-checkbox-unselected-pressed-icon-color, rgba(0, 0, 0, 0.54));background-color:transparent}}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-checked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-unchecked-indeterminate .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-in-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-checked-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background,.mat-mdc-checkbox .mdc-checkbox:not(:disabled):active.mdc-checkbox--anim-indeterminate-unchecked .mdc-checkbox__native-control:enabled~.mdc-checkbox__background{animation-name:mdc-checkbox-fade-out-background-8A000000FF01878600000000FF018786}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__background{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - 18px) / 2)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control{top:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);right:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);left:calc((var(--mdc-checkbox-state-layer-size, 40px) - var(--mdc-checkbox-state-layer-size, 40px)) / 2);width:var(--mdc-checkbox-state-layer-size, 40px);height:var(--mdc-checkbox-state-layer-size, 40px)}.mat-mdc-checkbox .mdc-checkbox:hover .mdc-checkbox__native-control:not([disabled])~.mdc-checkbox__ripple{opacity:.04;transform:scale(1);transition:opacity 80ms 0 cubic-bezier(0, 0, 0.2, 1),transform 80ms 0 cubic-bezier(0, 0, 0.2, 1)}.mat-mdc-checkbox .mdc-checkbox .mdc-checkbox__native-control:not([disabled]):focus~.mdc-checkbox__ripple{opacity:.16}.mat-mdc-checkbox .mdc-checkbox__background{-webkit-print-color-adjust:exact;color-adjust:exact}.mat-mdc-checkbox._mat-animation-noopable *,.mat-mdc-checkbox._mat-animation-noopable *::before{transition:none !important;animation:none !important}.mat-mdc-checkbox label{cursor:pointer}.mat-mdc-checkbox.mat-mdc-checkbox-disabled label{cursor:default}.mat-mdc-checkbox label:empty{display:none}.mat-mdc-checkbox .mdc-checkbox__native-control:focus:enabled:not(:checked):not(:indeterminate):not([data-indeterminate=true])~.mdc-checkbox__background{border-color:var(--mdc-checkbox-unselected-focus-icon-color, black)}.cdk-high-contrast-active .mat-mdc-checkbox.mat-mdc-checkbox-disabled{opacity:.5}.cdk-high-contrast-active .mat-mdc-checkbox .mdc-checkbox__checkmark{--mdc-checkbox-selected-checkmark-color: CanvasText;--mdc-checkbox-disabled-selected-checkmark-color: CanvasText}.mat-mdc-checkbox .mdc-checkbox__ripple{opacity:0}.mat-mdc-checkbox-ripple,.mdc-checkbox__ripple{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:50%;pointer-events:none}.mat-mdc-checkbox-ripple:not(:empty),.mdc-checkbox__ripple:not(:empty){transform:translateZ(0)}.mat-mdc-checkbox-touch-target{position:absolute;top:50%;height:48px;left:50%;width:48px;transform:translate(-50%, -50%)}.mat-mdc-checkbox-ripple::before{border-radius:50%}.mdc-checkbox__native-control:focus~.mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),Lxe={provide:Io,useExisting:Wn(()=>Bxe),multi:!0},Bxe=(()=>{class n extends q2{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["mat-checkbox","required","","formControlName",""],["mat-checkbox","required","","formControl",""],["mat-checkbox","required","","ngModel",""]],features:[Vt([Lxe]),Xe]}),n})(),Xq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),kc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,_a,Xq,dn,Xq]}),n})(),Qq=za({passive:!0}),Zq=(()=>{class n{constructor(e,i){this._platform=e,this._ngZone=i,this._monitoredElements=new Map}monitor(e){if(!this._platform.isBrowser)return Kr;let i=Ua(e),r=this._monitoredElements.get(i);if(r)return r.subject;let o=new Ee,a="cdk-text-field-autofilled",s=l=>{"cdk-text-field-autofill-start"!==l.animationName||i.classList.contains(a)?"cdk-text-field-autofill-end"===l.animationName&&i.classList.contains(a)&&(i.classList.remove(a),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!1}))):(i.classList.add(a),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!0})))};return this._ngZone.runOutsideAngular(()=>{i.addEventListener("animationstart",s,Qq),i.classList.add("cdk-text-field-autofill-monitored")}),this._monitoredElements.set(i,{subject:o,unlisten:()=>{i.removeEventListener("animationstart",s,Qq)}}),o}stopMonitoring(e){let i=Ua(e),r=this._monitoredElements.get(i);r&&(r.unlisten(),r.subject.complete(),i.classList.remove("cdk-text-field-autofill-monitored"),i.classList.remove("cdk-text-field-autofilled"),this._monitoredElements.delete(i))}ngOnDestroy(){this._monitoredElements.forEach((e,i)=>this.stopMonitoring(i))}}return n.\u0275fac=function(e){return new(e||n)(O(Vn),O(ot))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Kq=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),Hxe=new te("MAT_INPUT_VALUE_ACCESSOR"),zxe=["button","checkbox","file","hidden","image","radio","range","reset","submit"],Uxe=0,jxe=hg(class{constructor(n,t,e,i){this._defaultErrorStateMatcher=n,this._parentForm=t,this._parentFormGroup=e,this.ngControl=i,this.stateChanges=new Ee}}),qu=(()=>{class n extends jxe{get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e),this.focused&&(this.focused=!1,this.stateChanges.next())}get id(){return this._id}set id(e){this._id=e||this._uid}get required(){return this._required??this.ngControl?.control?.hasValidator(il.required)??!1}set required(e){this._required=vt(e)}get type(){return this._type}set type(e){this._type=e||"text",this._validateType(),!this._isTextarea&&s2().has(this._type)&&(this._elementRef.nativeElement.type=this._type)}get value(){return this._inputValueAccessor.value}set value(e){e!==this.value&&(this._inputValueAccessor.value=e,this.stateChanges.next())}get readonly(){return this._readonly}set readonly(e){this._readonly=vt(e)}constructor(e,i,r,o,a,s,l,c,d,u){super(s,o,a,r),this._elementRef=e,this._platform=i,this._autofillMonitor=c,this._formField=u,this._uid="mat-input-"+Uxe++,this.focused=!1,this.stateChanges=new Ee,this.controlType="mat-input",this.autofilled=!1,this._disabled=!1,this._type="text",this._readonly=!1,this._neverEmptyInputTypes=["date","datetime","datetime-local","month","time","week"].filter(m=>s2().has(m)),this._iOSKeyupListener=m=>{let _=m.target;!_.value&&0===_.selectionStart&&0===_.selectionEnd&&(_.setSelectionRange(1,1),_.setSelectionRange(0,0))};let p=this._elementRef.nativeElement,h=p.nodeName.toLowerCase();this._inputValueAccessor=l||p,this._previousNativeValue=this.value,this.id=this.id,i.IOS&&d.runOutsideAngular(()=>{e.nativeElement.addEventListener("keyup",this._iOSKeyupListener)}),this._isServer=!this._platform.isBrowser,this._isNativeSelect="select"===h,this._isTextarea="textarea"===h,this._isInFormField=!!u,this._isNativeSelect&&(this.controlType=p.multiple?"mat-native-select-multiple":"mat-native-select")}ngAfterViewInit(){this._platform.isBrowser&&this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(e=>{this.autofilled=e.isAutofilled,this.stateChanges.next()})}ngOnChanges(){this.stateChanges.next()}ngOnDestroy(){this.stateChanges.complete(),this._platform.isBrowser&&this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement),this._platform.IOS&&this._elementRef.nativeElement.removeEventListener("keyup",this._iOSKeyupListener)}ngDoCheck(){this.ngControl&&(this.updateErrorState(),null!==this.ngControl.disabled&&this.ngControl.disabled!==this.disabled&&(this.disabled=this.ngControl.disabled,this.stateChanges.next())),this._dirtyCheckNativeValue(),this._dirtyCheckPlaceholder()}focus(e){this._elementRef.nativeElement.focus(e)}_focusChanged(e){e!==this.focused&&(this.focused=e,this.stateChanges.next())}_onInput(){}_dirtyCheckNativeValue(){let e=this._elementRef.nativeElement.value;this._previousNativeValue!==e&&(this._previousNativeValue=e,this.stateChanges.next())}_dirtyCheckPlaceholder(){let e=this._getPlaceholder();if(e!==this._previousPlaceholder){let i=this._elementRef.nativeElement;this._previousPlaceholder=e,e?i.setAttribute("placeholder",e):i.removeAttribute("placeholder")}}_getPlaceholder(){return this.placeholder||null}_validateType(){zxe.indexOf(this._type)}_isNeverEmpty(){return this._neverEmptyInputTypes.indexOf(this._type)>-1}_isBadInput(){let e=this._elementRef.nativeElement.validity;return e&&e.badInput}get empty(){return!(this._isNeverEmpty()||this._elementRef.nativeElement.value||this._isBadInput()||this.autofilled)}get shouldLabelFloat(){if(this._isNativeSelect){let e=this._elementRef.nativeElement,i=e.options[0];return this.focused||e.multiple||!this.empty||!!(e.selectedIndex>-1&&i&&i.label)}return this.focused||!this.empty}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focused||this.focus()}_isInlineSelect(){let e=this._elementRef.nativeElement;return this._isNativeSelect&&(e.multiple||e.size>1)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Vn),C(qa,10),C(Cg,8),C(Mg,8),C(Eh),C(Hxe,10),C(Zq),C(ot),C(Ph,8))},n.\u0275dir=Me({type:n,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-mdc-input-element"],hostVars:18,hostBindings:function(e,i){1&e&&A("focus",function(){return i._focusChanged(!0)})("blur",function(){return i._focusChanged(!1)})("input",function(){return i._onInput()}),2&e&&(wo("id",i.id)("disabled",i.disabled)("required",i.required),Be("name",i.name||null)("readonly",i.readonly&&!i._isNativeSelect||null)("aria-invalid",i.empty&&i.required?null:i.errorState)("aria-required",i.required)("id",i.id),nt("mat-input-server",i._isServer)("mat-mdc-form-field-textarea-control",i._isInFormField&&i._isTextarea)("mat-mdc-form-field-input-control",i._isInFormField)("mdc-text-field__input",i._isInFormField)("mat-mdc-native-select-inline",i._isInlineSelect()))},inputs:{disabled:"disabled",id:"id",placeholder:"placeholder",name:"name",required:"required",type:"type",errorStateMatcher:"errorStateMatcher",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],value:"value",readonly:"readonly"},exportAs:["matInput"],features:[Vt([{provide:Yv,useExisting:n}]),Xe,qt]}),n})(),rl=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,Qv,Qv,Kq,dn]}),n})();function Gxe(n,t){if(1&n&&(f(0,"mat-error"),T(1),g()),2&n){let e=w();v(1),Ve(" Reload period has to be minimum of ",e.MIN_RELOAD_PERIOD_IN_S," seconds. ")}}function Wxe(n,t){1&n&&(f(0,"mat-error"),T(1," Page size has to be a positive integer. "),g())}var Jq=(()=>{class n{constructor(){this.reloadToggled=new F,this.reloadPeriodInMsChanged=new F,this.pageSizeChanged=new F,this.MIN_RELOAD_PERIOD_IN_S=30,this.reloadPeriodControl=new ny(this.MIN_RELOAD_PERIOD_IN_S,[il.required,il.min(this.MIN_RELOAD_PERIOD_IN_S)]),this.paginationControl=new ny(1,[il.required,il.min(1),n=>{let t=Number(n.value);return Math.round(t)===n.value?null:{integer:{value:n.value}}}]),this.ngUnsubscribe=new Ee}ngOnInit(){this.reloadPeriodControl.valueChanges.pipe(it(this.ngUnsubscribe),Cr(500),Oe(()=>this.reloadPeriodControl.valid)).subscribe(()=>{this.reloadPeriodControl.valid&&this.reloadPeriodInMsChanged.emit(1e3*this.reloadPeriodControl.value)}),this.paginationControl.valueChanges.pipe(it(this.ngUnsubscribe),Cr(500),Oe(()=>this.paginationControl.valid)).subscribe(()=>{this.pageSizeChanged.emit(this.paginationControl.value)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.reloadPeriodInMs){let i=e.reloadPeriodInMs;i.previousValue!==i.currentValue&&this.reloadPeriodControl.setValue(i.currentValue/1e3)}if(e.reloadEnabled&&(e.reloadEnabled.currentValue?this.reloadPeriodControl.enable():this.reloadPeriodControl.disable()),e.pageSize){let i=e.pageSize;i.previousValue!==i.currentValue&&this.paginationControl.setValue(i.currentValue)}}onReloadToggle(){this.reloadToggled.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["settings-dialog-component"]],inputs:{reloadEnabled:"reloadEnabled",reloadPeriodInMs:"reloadPeriodInMs",pageSize:"pageSize"},outputs:{reloadToggled:"reloadToggled",reloadPeriodInMsChanged:"reloadPeriodInMsChanged",pageSizeChanged:"pageSizeChanged"},features:[qt],decls:18,vars:5,consts:[[1,"reload-toggle"],[3,"checked","change"],["matInput","","type","number",1,"reload-period",3,"formControl"],[4,"ngIf"],["subscriptSizing","dynamic"],["matInput","","type","number",1,"page-size",3,"formControl"]],template:function(e,i){1&e&&(f(0,"h3"),T(1,"Settings"),g(),f(2,"div")(3,"div",0)(4,"mat-checkbox",1),A("change",function(){return i.onReloadToggle()}),T(5,"Reload data"),g()(),f(6,"div")(7,"mat-form-field")(8,"mat-label"),T(9,"Reload Period (seconds)"),g(),k(10,"input",2),g(),S(11,Gxe,2,1,"mat-error",3),g()(),f(12,"div")(13,"mat-form-field",4)(14,"mat-label"),T(15,"Pagination Limit"),g(),k(16,"input",5),g(),S(17,Wxe,2,0,"mat-error",3),g()),2&e&&(v(4),b("checked",i.reloadEnabled),v(6),b("formControl",i.reloadPeriodControl),v(1),b("ngIf",i.reloadPeriodControl.hasError("min")||i.reloadPeriodControl.hasError("required")),v(5),b("formControl",i.paginationControl),v(1),b("ngIf",i.paginationControl.invalid))},dependencies:[Ne,Uu,j2,xg,W2,xs,qu,Pc,nl,k9],styles:["[_nghost-%COMP%] {\n  font-size: 15px;\n}\n\n[_nghost-%COMP%]    > div[_ngcontent-%COMP%] {\n  margin: 16px 0;\n}\n\nh3[_ngcontent-%COMP%] {\n  font-size: 20px;\n  margin: 0;\n}\n\n.reload-toggle[_ngcontent-%COMP%] {\n  margin-bottom: 16px;\n}\n\nmat-form-field[_ngcontent-%COMP%] {\n  width: 100%;\n}"]}),n})(),$q=(()=>{class n{constructor(e){this.store=e,this.reloadEnabled$=this.store.select(Av),this.reloadPeriodInMs$=this.store.select(Rv),this.pageSize$=this.store.select(Mh)}onReloadToggled(){this.store.dispatch(x1())}onReloadPeriodInMsChanged(e){this.store.dispatch(C1({periodInMs:e}))}onPageSizeChanged(e){this.store.dispatch(M1({size:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["settings-dialog"]],decls:4,vars:9,consts:[[3,"reloadEnabled","reloadPeriodInMs","pageSize","reloadToggled","reloadPeriodInMsChanged","pageSizeChanged"]],template:function(e,i){1&e&&(f(0,"settings-dialog-component",0),A("reloadToggled",function(){return i.onReloadToggled()})("reloadPeriodInMsChanged",function(o){return i.onReloadPeriodInMsChanged(o)})("pageSizeChanged",function(o){return i.onPageSizeChanged(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("reloadEnabled",G(1,3,i.reloadEnabled$))("reloadPeriodInMs",G(2,5,i.reloadPeriodInMs$))("pageSize",G(3,7,i.pageSize$))},dependencies:[Jq,ct],encapsulation:2}),n})(),eX=(()=>{class n{constructor(e){this.dialog=e}isButtonDisabled(){return this.settingsLoadState===Re.NOT_LOADED||this.settingsLoadState===Re.LOADING}openDialog(){this.dialog.open($q,{width:"400px"})}}return n.\u0275fac=function(e){return new(e||n)(C(ys))},n.\u0275cmp=P({type:n,selectors:[["settings-button-component"]],inputs:{settingsLoadState:"settingsLoadState"},decls:2,vars:1,consts:[["mat-icon-button","",3,"disabled","click"],["svgIcon","settings_24px"]],template:function(e,i){1&e&&(f(0,"button",0),A("click",function(){return i.openDialog()}),k(1,"mat-icon",1),g()),2&e&&b("disabled",i.isButtonDisabled())},dependencies:[Er,bn],encapsulation:2}),n})(),tX=(()=>{class n{constructor(e){this.store=e,this.settingsLoadState$=this.store.select(i2)}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["settings-button"]],decls:2,vars:3,consts:[[3,"settingsLoadState"]],template:function(e,i){1&e&&(k(0,"settings-button-component",0),U(1,"async")),2&e&&b("settingsLoadState",G(1,1,i.settingsLoadState$))},dependencies:[eX,ct],encapsulation:2}),n})(),Zxe=["mat-menu-item",""];function Kxe(n,t){1&n&&(qn(),f(0,"svg",3),k(1,"polygon",4),g())}var Jxe=[[["mat-icon"],["","matMenuItemIcon",""]],"*"],$xe=["mat-icon, [matMenuItemIcon]","*"];function eCe(n,t){if(1&n){let e=Te();f(0,"div",0),A("keydown",function(r){return ne(e),ie(w()._handleKeydown(r))})("click",function(){return ne(e),ie(w().closed.emit("click"))})("@transformMenu.start",function(r){return ne(e),ie(w()._onAnimationStart(r))})("@transformMenu.done",function(r){return ne(e),ie(w()._onAnimationDone(r))}),f(1,"div",1),Tt(2),g()()}if(2&n){let e=w();b("id",e.panelId)("ngClass",e._classList)("@transformMenu",e._panelAnimationState),Be("aria-label",e.ariaLabel||null)("aria-labelledby",e.ariaLabelledby||null)("aria-describedby",e.ariaDescribedby||null)}}var tCe=["*"],K2=new te("MAT_MENU_PANEL"),nCe=go(ao(class{})),Ed=(()=>{class n extends nCe{constructor(e,i,r,o,a){super(),this._elementRef=e,this._document=i,this._focusMonitor=r,this._parentMenu=o,this._changeDetectorRef=a,this.role="menuitem",this._hovered=new Ee,this._focused=new Ee,this._highlighted=!1,this._triggersSubmenu=!1,o?.addItem?.(this)}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i),this._focused.next(this)}ngAfterViewInit(){this._focusMonitor&&this._focusMonitor.monitor(this._elementRef,!1)}ngOnDestroy(){this._focusMonitor&&this._focusMonitor.stopMonitoring(this._elementRef),this._parentMenu&&this._parentMenu.removeItem&&this._parentMenu.removeItem(this),this._hovered.complete(),this._focused.complete()}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._elementRef.nativeElement}_checkDisabled(e){this.disabled&&(e.preventDefault(),e.stopPropagation())}_handleMouseEnter(){this._hovered.next(this)}getLabel(){let e=this._elementRef.nativeElement.cloneNode(!0),i=e.querySelectorAll("mat-icon, .material-icons");for(let r=0;r<i.length;r++)i[r].remove();return e.textContent?.trim()||""}_setHighlighted(e){this._highlighted=e,this._changeDetectorRef?.markForCheck()}_setTriggersSubmenu(e){this._triggersSubmenu=e,this._changeDetectorRef?.markForCheck()}_hasFocus(){return this._document&&this._document.activeElement===this._getHostElement()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Nt),C(fo),C(K2,8),C(Qt))},n.\u0275cmp=P({type:n,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-mdc-menu-item","mat-mdc-focus-indicator","mdc-list-item"],hostVars:8,hostBindings:function(e,i){1&e&&A("click",function(o){return i._checkDisabled(o)})("mouseenter",function(){return i._handleMouseEnter()}),2&e&&(Be("role",i.role)("tabindex",i._getTabIndex())("aria-disabled",i.disabled)("disabled",i.disabled||null),nt("mat-mdc-menu-item-highlighted",i._highlighted)("mat-mdc-menu-item-submenu-trigger",i._triggersSubmenu))},inputs:{disabled:"disabled",disableRipple:"disableRipple",role:"role"},exportAs:["matMenuItem"],features:[Xe],attrs:Zxe,ngContentSelectors:$xe,decls:5,vars:3,consts:[[1,"mdc-list-item__primary-text"],["matRipple","",1,"mat-mdc-menu-ripple",3,"matRippleDisabled","matRippleTrigger"],["class","mat-mdc-menu-submenu-icon","viewBox","0 0 5 10","focusable","false",4,"ngIf"],["viewBox","0 0 5 10","focusable","false",1,"mat-mdc-menu-submenu-icon"],["points","0,0 5,5 0,10"]],template:function(e,i){1&e&&(fn(Jxe),Tt(0),f(1,"span",0),Tt(2,1),g(),k(3,"div",1),S(4,Kxe,2,0,"svg",2)),2&e&&(v(3),b("matRippleDisabled",i.disableRipple||i.disabled)("matRippleTrigger",i._getHostElement()),v(1),b("ngIf",i._triggersSubmenu))},dependencies:[Ne,Ki],encapsulation:2,changeDetection:0}),n})(),iCe=new te("MatMenuContent"),_E={transformMenu:fr("transformMenu",[Si("void",rn({opacity:0,transform:"scale(0.8)"})),bi("void => enter",Mi("120ms cubic-bezier(0, 0, 0.2, 1)",rn({opacity:1,transform:"scale(1)"}))),bi("* => void",Mi("100ms 25ms linear",rn({opacity:0})))]),fadeInItems:fr("fadeInItems",[Si("showing",rn({opacity:1})),bi("void => *",[rn({opacity:0}),Mi("400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},rCe=0,iX=new te("mat-menu-default-options",{providedIn:"root",factory:function(){return{overlapTrigger:!1,xPosition:"after",yPosition:"below",backdropClass:"cdk-overlay-transparent-backdrop"}}}),oy=(()=>{class n{get xPosition(){return this._xPosition}set xPosition(e){this._xPosition=e,this.setPositionClasses()}get yPosition(){return this._yPosition}set yPosition(e){this._yPosition=e,this.setPositionClasses()}get overlapTrigger(){return this._overlapTrigger}set overlapTrigger(e){this._overlapTrigger=vt(e)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=vt(e)}set panelClass(e){let i=this._previousPanelClass;i&&i.length&&i.split(" ").forEach(r=>{this._classList[r]=!1}),this._previousPanelClass=e,e&&e.length&&(e.split(" ").forEach(r=>{this._classList[r]=!0}),this._elementRef.nativeElement.className="")}get classList(){return this.panelClass}set classList(e){this.panelClass=e}constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._defaultOptions=r,this._changeDetectorRef=o,this._xPosition=this._defaultOptions.xPosition,this._yPosition=this._defaultOptions.yPosition,this._directDescendantItems=new Pa,this._classList={},this._panelAnimationState="void",this._animationDone=new Ee,this.overlayPanelClass=this._defaultOptions.overlayPanelClass||"",this.backdropClass=this._defaultOptions.backdropClass,this._overlapTrigger=this._defaultOptions.overlapTrigger,this._hasBackdrop=this._defaultOptions.hasBackdrop,this.closed=new F,this.close=this.closed,this.panelId="mat-menu-panel-"+rCe++}ngOnInit(){this.setPositionClasses()}ngAfterContentInit(){this._updateDirectDescendants(),this._keyManager=new ku(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd(),this._keyManager.tabOut.subscribe(()=>this.closed.emit("tab")),this._directDescendantItems.changes.pipe(kn(this._directDescendantItems),Jn(e=>tn(...e.map(i=>i._focused)))).subscribe(e=>this._keyManager.updateActiveItem(e)),this._directDescendantItems.changes.subscribe(e=>{let i=this._keyManager;if("enter"===this._panelAnimationState&&i.activeItem?._hasFocus()){let r=e.toArray(),o=Math.max(0,Math.min(r.length-1,i.activeItemIndex||0));r[o]&&!r[o].disabled?i.setActiveItem(o):i.setNextItemActive()}})}ngOnDestroy(){this._keyManager?.destroy(),this._directDescendantItems.destroy(),this.closed.complete(),this._firstItemFocusSubscription?.unsubscribe()}_hovered(){return this._directDescendantItems.changes.pipe(kn(this._directDescendantItems),Jn(i=>tn(...i.map(r=>r._hovered))))}addItem(e){}removeItem(e){}_handleKeydown(e){let i=e.keyCode,r=this._keyManager;switch(i){case 27:Or(e)||(e.preventDefault(),this.closed.emit("keydown"));break;case 37:this.parentMenu&&"ltr"===this.direction&&this.closed.emit("keydown");break;case 39:this.parentMenu&&"rtl"===this.direction&&this.closed.emit("keydown");break;default:return(38===i||40===i)&&r.setFocusOrigin("keyboard"),void r.onKeydown(e)}e.stopPropagation()}focusFirstItem(e="program"){this._firstItemFocusSubscription?.unsubscribe(),this._firstItemFocusSubscription=this._ngZone.onStable.pipe(Lt(1)).subscribe(()=>{let i=null;if(this._directDescendantItems.length&&(i=this._directDescendantItems.first._getHostElement().closest('[role="menu"]')),!i||!i.contains(document.activeElement)){let r=this._keyManager;r.setFocusOrigin(e).setFirstItemActive(),!r.activeItem&&i&&i.focus()}})}resetActiveItem(){this._keyManager.setActiveItem(-1)}setElevation(e){let i=Math.min(this._baseElevation+e,24),r=`${this._elevationPrefix}${i}`,o=Object.keys(this._classList).find(a=>a.startsWith(this._elevationPrefix));(!o||o===this._previousElevation)&&(this._previousElevation&&(this._classList[this._previousElevation]=!1),this._classList[r]=!0,this._previousElevation=r)}setPositionClasses(e=this.xPosition,i=this.yPosition){let r=this._classList;r["mat-menu-before"]="before"===e,r["mat-menu-after"]="after"===e,r["mat-menu-above"]="above"===i,r["mat-menu-below"]="below"===i,this._changeDetectorRef?.markForCheck()}_startAnimation(){this._panelAnimationState="enter"}_resetAnimation(){this._panelAnimationState="void"}_onAnimationDone(e){this._animationDone.next(e),this._isAnimating=!1}_onAnimationStart(e){this._isAnimating=!0,"enter"===e.toState&&0===this._keyManager.activeItemIndex&&(e.element.scrollTop=0)}_updateDirectDescendants(){this._allItems.changes.pipe(kn(this._allItems)).subscribe(e=>{this._directDescendantItems.reset(e.filter(i=>i._parentMenu===this)),this._directDescendantItems.notifyOnChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ot),C(iX),C(Qt))},n.\u0275dir=Me({type:n,contentQueries:function(e,i,r){if(1&e&&(Bn(r,iCe,5),Bn(r,Ed,5),Bn(r,Ed,4)),2&e){let o;be(o=ve())&&(i.lazyContent=o.first),be(o=ve())&&(i._allItems=o),be(o=ve())&&(i.items=o)}},viewQuery:function(e,i){if(1&e&&Ue(oi,5),2&e){let r;be(r=ve())&&(i.templateRef=r.first)}},inputs:{backdropClass:"backdropClass",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],xPosition:"xPosition",yPosition:"yPosition",overlapTrigger:"overlapTrigger",hasBackdrop:"hasBackdrop",panelClass:["class","panelClass"],classList:"classList"},outputs:{closed:"closed",close:"close"}}),n})(),Xu=(()=>{class n extends oy{constructor(e,i,r,o){super(e,i,r,o),this._elevationPrefix="mat-elevation-z",this._baseElevation=8}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ot),C(iX),C(Qt))},n.\u0275cmp=P({type:n,selectors:[["mat-menu"]],hostVars:3,hostBindings:function(e,i){2&e&&Be("aria-label",null)("aria-labelledby",null)("aria-describedby",null)},exportAs:["matMenu"],features:[Vt([{provide:K2,useExisting:n}]),Xe],ngContentSelectors:tCe,decls:1,vars:0,consts:[["tabindex","-1","role","menu",1,"mat-mdc-menu-panel","mdc-menu-surface","mdc-menu-surface--open","mat-mdc-elevation-specific",3,"id","ngClass","keydown","click"],[1,"mat-mdc-menu-content","mdc-list"]],template:function(e,i){1&e&&(fn(),S(0,eCe,3,6,"ng-template"))},dependencies:[wn],styles:['.mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;list-style-type:none}.mat-mdc-menu-content:focus{outline:none}.mat-mdc-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-mdc-menu-panel{outline:solid 1px}.mat-mdc-menu-panel.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;position:relative}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;padding-left:16px;padding-right:16px;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px}.mat-mdc-menu-item:focus{outline:none}[dir=rtl] .mat-mdc-menu-item,.mat-mdc-menu-item[dir=rtl]{padding-left:16px;padding-right:16px}.mat-mdc-menu-item::-moz-focus-inner{border:0}.mat-mdc-menu-item.mdc-list-item{align-items:center}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item .mat-icon{margin-right:16px}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:16px}.mat-mdc-menu-item .mdc-list-item__primary-text{white-space:normal}.mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-mdc-menu-item.mat-mdc-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.cdk-high-contrast-active .mat-mdc-menu-item{margin-top:1px}.mat-mdc-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-mdc-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-mdc-menu-submenu-icon{fill:CanvasText}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}'],encapsulation:2,data:{animation:[_E.transformMenu,_E.fadeInItems]},changeDetection:0}),n})(),rX=new te("mat-menu-scroll-strategy"),sCe={provide:rX,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},nX=za({passive:!0}),lCe=(()=>{class n{get _deprecatedMatMenuTriggerFor(){return this.menu}set _deprecatedMatMenuTriggerFor(e){this.menu=e}get menu(){return this._menu}set menu(e){e!==this._menu&&(this._menu=e,this._menuCloseSubscription.unsubscribe(),e&&(this._menuCloseSubscription=e.close.subscribe(i=>{this._destroyMenu(i),("click"===i||"tab"===i)&&this._parentMaterialMenu&&this._parentMaterialMenu.closed.emit(i)})),this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu()))}constructor(e,i,r,o,a,s,l,c,d){this._overlay=e,this._element=i,this._viewContainerRef=r,this._menuItemInstance=s,this._dir=l,this._focusMonitor=c,this._ngZone=d,this._overlayRef=null,this._menuOpen=!1,this._closingActionsSubscription=En.EMPTY,this._hoverSubscription=En.EMPTY,this._menuCloseSubscription=En.EMPTY,this._changeDetectorRef=$n(Qt),this._handleTouchStart=u=>{Vv(u)||(this._openedBy="touch")},this._openedBy=void 0,this.restoreFocus=!0,this.menuOpened=new F,this.onMenuOpen=this.menuOpened,this.menuClosed=new F,this.onMenuClose=this.menuClosed,this._scrollStrategy=o,this._parentMaterialMenu=a instanceof oy?a:void 0,i.nativeElement.addEventListener("touchstart",this._handleTouchStart,nX)}ngAfterContentInit(){this._handleHover()}ngOnDestroy(){this._overlayRef&&(this._overlayRef.dispose(),this._overlayRef=null),this._element.nativeElement.removeEventListener("touchstart",this._handleTouchStart,nX),this._menuCloseSubscription.unsubscribe(),this._closingActionsSubscription.unsubscribe(),this._hoverSubscription.unsubscribe()}get menuOpen(){return this._menuOpen}get dir(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}triggersSubmenu(){return!!(this._menuItemInstance&&this._parentMaterialMenu&&this.menu)}toggleMenu(){return this._menuOpen?this.closeMenu():this.openMenu()}openMenu(){let e=this.menu;if(this._menuOpen||!e)return;let i=this._createOverlay(e),r=i.getConfig(),o=r.positionStrategy;this._setPosition(e,o),r.hasBackdrop=null==e.hasBackdrop?!this.triggersSubmenu():e.hasBackdrop,i.attach(this._getPortal(e)),e.lazyContent&&e.lazyContent.attach(this.menuData),this._closingActionsSubscription=this._menuClosingActions().subscribe(()=>this.closeMenu()),this._initMenu(e),e instanceof oy&&(e._startAnimation(),e._directDescendantItems.changes.pipe(it(e.close)).subscribe(()=>{o.withLockedPosition(!1).reapplyLastPosition(),o.withLockedPosition(!0)}))}closeMenu(){this.menu?.close.emit()}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._element,e,i):this._element.nativeElement.focus(i)}updatePosition(){this._overlayRef?.updatePosition()}_destroyMenu(e){if(!this._overlayRef||!this.menuOpen)return;let i=this.menu;this._closingActionsSubscription.unsubscribe(),this._overlayRef.detach(),this.restoreFocus&&("keydown"===e||!this._openedBy||!this.triggersSubmenu())&&this.focus(this._openedBy),this._openedBy=void 0,i instanceof oy?(i._resetAnimation(),i.lazyContent?i._animationDone.pipe(Oe(r=>"void"===r.toState),Lt(1),it(i.lazyContent._attached)).subscribe({next:()=>i.lazyContent.detach(),complete:()=>this._setIsMenuOpen(!1)}):this._setIsMenuOpen(!1)):(this._setIsMenuOpen(!1),i?.lazyContent?.detach())}_initMenu(e){e.parentMenu=this.triggersSubmenu()?this._parentMaterialMenu:void 0,e.direction=this.dir,this._setMenuElevation(e),e.focusFirstItem(this._openedBy||"program"),this._setIsMenuOpen(!0)}_setMenuElevation(e){if(e.setElevation){let i=0,r=e.parentMenu;for(;r;)i++,r=r.parentMenu;e.setElevation(i)}}_setIsMenuOpen(e){e!==this._menuOpen&&(this._menuOpen=e,this._menuOpen?this.menuOpened.emit():this.menuClosed.emit(),this.triggersSubmenu()&&this._menuItemInstance._setHighlighted(e),this._changeDetectorRef.markForCheck())}_createOverlay(e){if(!this._overlayRef){let i=this._getOverlayConfig(e);this._subscribeToPositions(e,i.positionStrategy),this._overlayRef=this._overlay.create(i),this._overlayRef.keydownEvents().subscribe()}return this._overlayRef}_getOverlayConfig(e){return new el({positionStrategy:this._overlay.position().flexibleConnectedTo(this._element).withLockedPosition().withGrowAfterOpen().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),backdropClass:e.backdropClass||"cdk-overlay-transparent-backdrop",panelClass:e.overlayPanelClass,scrollStrategy:this._scrollStrategy(),direction:this._dir})}_subscribeToPositions(e,i){e.setPositionClasses&&i.positionChanges.subscribe(r=>{let o="start"===r.connectionPair.overlayX?"after":"before",a="top"===r.connectionPair.overlayY?"below":"above";this._ngZone?this._ngZone.run(()=>e.setPositionClasses(o,a)):e.setPositionClasses(o,a)})}_setPosition(e,i){let[r,o]="before"===e.xPosition?["end","start"]:["start","end"],[a,s]="above"===e.yPosition?["bottom","top"]:["top","bottom"],[l,c]=[a,s],[d,u]=[r,o],p=0;if(this.triggersSubmenu()){if(u=r="before"===e.xPosition?"start":"end",o=d="end"===r?"start":"end",this._parentMaterialMenu){if(null==this._parentInnerPadding){let h=this._parentMaterialMenu.items.first;this._parentInnerPadding=h?h._getHostElement().offsetTop:0}p="bottom"===a?this._parentInnerPadding:-this._parentInnerPadding}}else e.overlapTrigger||(l="top"===a?"bottom":"top",c="top"===s?"bottom":"top");i.withPositions([{originX:r,originY:l,overlayX:d,overlayY:a,offsetY:p},{originX:o,originY:l,overlayX:u,overlayY:a,offsetY:p},{originX:r,originY:c,overlayX:d,overlayY:s,offsetY:-p},{originX:o,originY:c,overlayX:u,overlayY:s,offsetY:-p}])}_menuClosingActions(){let e=this._overlayRef.backdropClick(),i=this._overlayRef.detachments();return tn(e,this._parentMaterialMenu?this._parentMaterialMenu.closed:$t(),this._parentMaterialMenu?this._parentMaterialMenu._hovered().pipe(Oe(a=>a!==this._menuItemInstance),Oe(()=>this._menuOpen)):$t(),i)}_handleMousedown(e){Bv(e)||(this._openedBy=0===e.button?"mouse":void 0,this.triggersSubmenu()&&e.preventDefault())}_handleKeydown(e){let i=e.keyCode;(13===i||32===i)&&(this._openedBy="keyboard"),this.triggersSubmenu()&&(39===i&&"ltr"===this.dir||37===i&&"rtl"===this.dir)&&(this._openedBy="keyboard",this.openMenu())}_handleClick(e){this.triggersSubmenu()?(e.stopPropagation(),this.openMenu()):this.toggleMenu()}_handleHover(){!this.triggersSubmenu()||!this._parentMaterialMenu||(this._hoverSubscription=this._parentMaterialMenu._hovered().pipe(Oe(e=>e===this._menuItemInstance&&!e.disabled),Rs(0,Nm)).subscribe(()=>{this._openedBy="mouse",this.menu instanceof oy&&this.menu._isAnimating?this.menu._animationDone.pipe(Lt(1),Rs(0,Nm),it(this._parentMaterialMenu._hovered())).subscribe(()=>this.openMenu()):this.openMenu()}))}_getPortal(e){return(!this._portal||this._portal.templateRef!==e.templateRef)&&(this._portal=new To(e.templateRef,this._viewContainerRef)),this._portal}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(xe),C(ei),C(rX),C(K2,8),C(Ed,10),C(zi,8),C(fo),C(ot))},n.\u0275dir=Me({type:n,hostVars:3,hostBindings:function(e,i){1&e&&A("click",function(o){return i._handleClick(o)})("mousedown",function(o){return i._handleMousedown(o)})("keydown",function(o){return i._handleKeydown(o)}),2&e&&Be("aria-haspopup",i.menu?"menu":null)("aria-expanded",i.menuOpen)("aria-controls",i.menuOpen?i.menu.panelId:null)},inputs:{_deprecatedMatMenuTriggerFor:["mat-menu-trigger-for","_deprecatedMatMenuTriggerFor"],menu:["matMenuTriggerFor","menu"],menuData:["matMenuTriggerData","menuData"],restoreFocus:["matMenuTriggerRestoreFocus","restoreFocus"]},outputs:{menuOpened:"menuOpened",onMenuOpen:"onMenuOpen",menuClosed:"menuClosed",onMenuClose:"onMenuClose"}}),n})(),Yu=(()=>{class n extends lCe{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","mat-menu-trigger-for",""],["","matMenuTriggerFor",""]],hostAttrs:[1,"mat-mdc-menu-trigger"],exportAs:["matMenuTrigger"],features:[Xe]}),n})(),Qu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[sCe],imports:[De,_a,dn,Do,Ic,dn]}),n})();function cCe(n,t){1&n&&k(0,"mat-icon",8)}function dCe(n,t){1&n&&k(0,"mat-icon",9)}function uCe(n,t){1&n&&k(0,"mat-icon",10)}var Ya=(()=>(function(n){n[n.DEFAULT=0]="DEFAULT",n[n.DARK_MODE_ON=1]="DARK_MODE_ON",n[n.DARK_MODE_OFF=2]="DARK_MODE_OFF"}(Ya||(Ya={})),Ya))(),oX=(()=>{class n{constructor(){this.DarkModeOverride=Ya,this.onOverrideChanged=new F}getButtonTitle(){let e;switch(this.darkModeOverride){case Ya.DEFAULT:e="Browser default";break;case Ya.DARK_MODE_ON:e="Dark mode";break;case Ya.DARK_MODE_OFF:e="Light mode"}return`Current mode: [${e}]. Switch between browser default, light, or dark theme.`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["app-header-dark-mode-toggle-component"]],inputs:{darkModeOverride:"darkModeOverride"},outputs:{onOverrideChanged:"onOverrideChanged"},decls:15,vars:6,consts:[["mat-icon-button","","aria-label","Menu for changing light or dark theme",3,"matMenuTriggerFor","ngSwitch","title"],["svgIcon","brightness_6_24px",4,"ngSwitchCase"],["svgIcon","light_mode_24px",4,"ngSwitchCase"],["svgIcon","dark_mode_24px",4,"ngSwitchCase"],["menu","matMenu"],["mat-menu-item","","title","Set the theme to match the default mode in the browser.",3,"click"],["mat-menu-item","","title","Force light TensorBoard theme.",3,"click"],["mat-menu-item","","title","Force dark TensorBoard theme.",3,"click"],["svgIcon","brightness_6_24px"],["svgIcon","light_mode_24px"],["svgIcon","dark_mode_24px"]],template:function(e,i){1&e&&(f(0,"button",0),S(1,cCe,1,0,"mat-icon",1),S(2,dCe,1,0,"mat-icon",2),S(3,uCe,1,0,"mat-icon",3),g(),f(4,"mat-menu",null,4)(6,"button",5),A("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DEFAULT)}),f(7,"label"),T(8,"Browser default"),g()(),f(9,"button",6),A("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_OFF)}),f(10,"label"),T(11,"Light"),g()(),f(12,"button",7),A("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_ON)}),f(13,"label"),T(14,"Dark"),g()()()),2&e&&(b("matMenuTriggerFor",st(5))("ngSwitch",i.darkModeOverride)("title",i.getButtonTitle()),v(1),b("ngSwitchCase",i.DarkModeOverride.DEFAULT),v(1),b("ngSwitchCase",i.DarkModeOverride.DARK_MODE_OFF),v(1),b("ngSwitchCase",i.DarkModeOverride.DARK_MODE_ON))},dependencies:[Er,bn,Xu,Ed,Yu,mr,kr],encapsulation:2}),n})(),aX=(()=>{class n{constructor(e){this.store=e,this.darkModeOverride$=this.store.select(cS).pipe(q(i=>null===i?Ya.DEFAULT:i?Ya.DARK_MODE_ON:Ya.DARK_MODE_OFF))}changeDarkMode(e){let i=null;switch(e){case Ya.DEFAULT:i=null;break;case Ya.DARK_MODE_OFF:i=!1;break;case Ya.DARK_MODE_ON:i=!0}this.store.dispatch(ZS({enableDarkMode:i}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["app-header-dark-mode-toggle"]],decls:2,vars:3,consts:[[3,"darkModeOverride","onOverrideChanged"]],template:function(e,i){1&e&&(f(0,"app-header-dark-mode-toggle-component",0),A("onOverrideChanged",function(o){return i.changeDarkMode(o)}),U(1,"async"),g()),2&e&&b("darkModeOverride",G(1,1,i.darkModeOverride$))},dependencies:[oX,ct],encapsulation:2}),n})();function mCe(n,t){}var fCe=function(n){return{animationDuration:n}},gCe=function(n,t){return{value:n,params:t}};function _Ce(n,t){1&n&&Tt(0)}var cX=["*"],bCe=["tabListContainer"],vCe=["tabList"],yCe=["tabListInner"],xCe=["nextPaginator"],CCe=["previousPaginator"],MCe=["tabBodyWrapper"],wCe=["tabHeader"];function SCe(n,t){}function ECe(n,t){1&n&&S(0,SCe,0,0,"ng-template",14),2&n&&b("cdkPortalOutlet",w().$implicit.templateLabel)}function TCe(n,t){1&n&&T(0),2&n&&kt(w().$implicit.textLabel)}function DCe(n,t){if(1&n){let e=Te();f(0,"div",6,7),A("click",function(){let r=ne(e),o=r.$implicit,a=r.index,s=w(),l=st(1);return ie(s._handleClick(o,l,a))})("cdkFocusChange",function(r){let a=ne(e).index;return ie(w()._tabFocusChanged(r,a))}),k(2,"span",8)(3,"div",9),f(4,"span",10)(5,"span",11),S(6,ECe,1,1,"ng-template",12),S(7,TCe,1,1,"ng-template",null,13,jt),g()()()}if(2&n){let e=t.$implicit,i=t.index,r=st(1),o=st(8),a=w();nt("mdc-tab--active",a.selectedIndex===i),b("id",a._getTabLabelId(i))("ngClass",e.labelClass)("disabled",e.disabled)("fitInkBarToContent",a.fitInkBarToContent),Be("tabIndex",a._getTabIndex(i))("aria-posinset",i+1)("aria-setsize",a._tabs.length)("aria-controls",a._getTabContentId(i))("aria-selected",a.selectedIndex===i)("aria-label",e.ariaLabel||null)("aria-labelledby",!e.ariaLabel&&e.ariaLabelledby?e.ariaLabelledby:null),v(3),b("matRippleTrigger",r)("matRippleDisabled",e.disabled||a.disableRipple),v(3),b("ngIf",e.templateLabel)("ngIfElse",o)}}function ICe(n,t){if(1&n){let e=Te();f(0,"mat-tab-body",15),A("_onCentered",function(){return ne(e),ie(w()._removeTabBodyWrapperHeight())})("_onCentering",function(r){return ne(e),ie(w()._setTabBodyWrapperHeight(r))}),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();nt("mat-mdc-tab-body-active",r.selectedIndex===i),b("id",r._getTabContentId(i))("ngClass",e.bodyClass)("content",e.content)("position",e.position)("origin",e.origin)("animationDuration",r.animationDuration)("preserveContent",r.preserveContent),Be("tabindex",null!=r.contentTabIndex&&r.selectedIndex===i?r.contentTabIndex:null)("aria-labelledby",r._getTabLabelId(i))}}var ACe={translateTab:fr("translateTab",[Si("center, void, left-origin-center, right-origin-center",rn({transform:"none"})),Si("left",rn({transform:"translate3d(-100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),Si("right",rn({transform:"translate3d(100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),bi("* => left, * => right, left => center, right => center",Mi("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")),bi("void => left-origin-center",[rn({transform:"translate3d(-100%, 0, 0)",visibility:"hidden"}),Mi("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")]),bi("void => right-origin-center",[rn({transform:"translate3d(100%, 0, 0)",visibility:"hidden"}),Mi("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")])])},RCe=(()=>{class n extends ba{constructor(e,i,r,o){super(e,i,o),this._host=r,this._centeringSub=En.EMPTY,this._leavingSub=En.EMPTY}ngOnInit(){super.ngOnInit(),this._centeringSub=this._host._beforeCentering.pipe(kn(this._host._isCenterPosition(this._host._position))).subscribe(e=>{e&&!this.hasAttached()&&this.attach(this._host._content)}),this._leavingSub=this._host._afterLeavingCenter.subscribe(()=>{this._host.preserveContent||this.detach()})}ngOnDestroy(){super.ngOnDestroy(),this._centeringSub.unsubscribe(),this._leavingSub.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(ho),C(ei),C(Wn(()=>dX)),C(Nt))},n.\u0275dir=Me({type:n,selectors:[["","matTabBodyHost",""]],features:[Xe]}),n})(),PCe=(()=>{class n{set position(e){this._positionIndex=e,this._computePositionAnimationState()}constructor(e,i,r){this._elementRef=e,this._dir=i,this._dirChangeSubscription=En.EMPTY,this._translateTabComplete=new Ee,this._onCentering=new F,this._beforeCentering=new F,this._afterLeavingCenter=new F,this._onCentered=new F(!0),this.animationDuration="500ms",this.preserveContent=!1,i&&(this._dirChangeSubscription=i.change.subscribe(o=>{this._computePositionAnimationState(o),r.markForCheck()})),this._translateTabComplete.pipe(ri((o,a)=>o.fromState===a.fromState&&o.toState===a.toState)).subscribe(o=>{this._isCenterPosition(o.toState)&&this._isCenterPosition(this._position)&&this._onCentered.emit(),this._isCenterPosition(o.fromState)&&!this._isCenterPosition(this._position)&&this._afterLeavingCenter.emit()})}ngOnInit(){"center"==this._position&&null!=this.origin&&(this._position=this._computePositionFromOrigin(this.origin))}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._translateTabComplete.complete()}_onTranslateTabStarted(e){let i=this._isCenterPosition(e.toState);this._beforeCentering.emit(i),i&&this._onCentering.emit(this._elementRef.nativeElement.clientHeight)}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_isCenterPosition(e){return"center"==e||"left-origin-center"==e||"right-origin-center"==e}_computePositionAnimationState(e=this._getLayoutDirection()){this._position=this._positionIndex<0?"ltr"==e?"left":"right":this._positionIndex>0?"ltr"==e?"right":"left":"center"}_computePositionFromOrigin(e){let i=this._getLayoutDirection();return"ltr"==i&&e<=0||"rtl"==i&&e>0?"left-origin-center":"right-origin-center"}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(zi,8),C(Qt))},n.\u0275dir=Me({type:n,inputs:{_content:["content","_content"],origin:"origin",animationDuration:"animationDuration",preserveContent:"preserveContent",position:"position"},outputs:{_onCentering:"_onCentering",_beforeCentering:"_beforeCentering",_afterLeavingCenter:"_afterLeavingCenter",_onCentered:"_onCentered"}}),n})(),dX=(()=>{class n extends PCe{constructor(e,i,r){super(e,i,r)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(zi,8),C(Qt))},n.\u0275cmp=P({type:n,selectors:[["mat-tab-body"]],viewQuery:function(e,i){if(1&e&&Ue(ba,5),2&e){let r;be(r=ve())&&(i._portalHost=r.first)}},hostAttrs:[1,"mat-mdc-tab-body"],features:[Xe],decls:3,vars:6,consts:[["cdkScrollable","",1,"mat-mdc-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function(e,i){1&e&&(f(0,"div",0,1),A("@translateTab.start",function(o){return i._onTranslateTabStarted(o)})("@translateTab.done",function(o){return i._translateTabComplete.next(o)}),S(2,mCe,0,0,"ng-template",2),g()),2&e&&b("@translateTab",So(3,gCe,i._position,Un(1,fCe,i.animationDuration)))},dependencies:[RCe],styles:['.mat-mdc-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;outline:0;flex-basis:100%}.mat-mdc-tab-body.mat-mdc-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-mdc-tab-group.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body.mat-mdc-tab-body-active{overflow-y:hidden}.mat-mdc-tab-body-content{height:100%;overflow:auto}.mat-mdc-tab-group-dynamic-height .mat-mdc-tab-body-content{overflow:hidden}.mat-mdc-tab-body-content[style*="visibility: hidden"]{display:none}'],encapsulation:2,data:{animation:[ACe.translateTab]}}),n})(),kCe=new te("MatTabContent"),OCe=(()=>{class n{constructor(e){this.template=e}}return n.\u0275fac=function(e){return new(e||n)(C(oi))},n.\u0275dir=Me({type:n,selectors:[["","matTabContent",""]],features:[Vt([{provide:kCe,useExisting:n}])]}),n})(),FCe=new te("MatTabLabel"),uX=new te("MAT_TAB"),tN=(()=>{class n extends G7{constructor(e,i,r){super(e,i),this._closestTab=r}}return n.\u0275fac=function(e){return new(e||n)(C(oi),C(ei),C(uX,8))},n.\u0275dir=Me({type:n,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[Vt([{provide:FCe,useExisting:n}]),Xe]}),n})(),J2="mdc-tab-indicator--active",sX="mdc-tab-indicator--no-transition";function pX(n){return class extends n{constructor(...t){super(...t),this._fitToContent=!1}get fitInkBarToContent(){return this._fitToContent}set fitInkBarToContent(t){let e=vt(t);this._fitToContent!==e&&(this._fitToContent=e,this._inkBarElement&&this._appendInkBarElement())}activateInkBar(t){let e=this.elementRef.nativeElement;if(!t||!e.getBoundingClientRect||!this._inkBarContentElement)return void e.classList.add(J2);let i=e.getBoundingClientRect(),r=t.width/i.width,o=t.left-i.left;e.classList.add(sX),this._inkBarContentElement.style.setProperty("transform",`translateX(${o}px) scaleX(${r})`),e.getBoundingClientRect(),e.classList.remove(sX),e.classList.add(J2),this._inkBarContentElement.style.setProperty("transform","")}deactivateInkBar(){this.elementRef.nativeElement.classList.remove(J2)}ngOnInit(){this._createInkBarElement()}ngOnDestroy(){this._inkBarElement?.remove(),this._inkBarElement=this._inkBarContentElement=null}_createInkBarElement(){let t=this.elementRef.nativeElement.ownerDocument||document;this._inkBarElement=t.createElement("span"),this._inkBarContentElement=t.createElement("span"),this._inkBarElement.className="mdc-tab-indicator",this._inkBarContentElement.className="mdc-tab-indicator__content mdc-tab-indicator__content--underline",this._inkBarElement.appendChild(this._inkBarContentElement),this._appendInkBarElement()}_appendInkBarElement(){(this._fitToContent?this.elementRef.nativeElement.querySelector(".mdc-tab__content"):this.elementRef.nativeElement).appendChild(this._inkBarElement)}}}new te("MatInkBarPositioner",{providedIn:"root",factory:function(){return t=>({left:t?(t.offsetLeft||0)+"px":"0",width:t?(t.offsetWidth||0)+"px":"0"})}});var LCe=ao(class{}),BCe=(()=>{class n extends LCe{constructor(e){super(),this.elementRef=e}focus(){this.elementRef.nativeElement.focus()}getOffsetLeft(){return this.elementRef.nativeElement.offsetLeft}getOffsetWidth(){return this.elementRef.nativeElement.offsetWidth}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275dir=Me({type:n,features:[Xe]}),n})(),VCe=pX(BCe),hX=(()=>{class n extends VCe{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","matTabLabelWrapper",""]],hostVars:3,hostBindings:function(e,i){2&e&&(Be("aria-disabled",!!i.disabled),nt("mat-mdc-tab-disabled",i.disabled))},inputs:{disabled:"disabled",fitInkBarToContent:"fitInkBarToContent"},features:[Xe]}),n})(),HCe=ao(class{}),mX=new te("MAT_TAB_GROUP"),zCe=(()=>{class n extends HCe{get content(){return this._contentPortal}constructor(e,i){super(),this._viewContainerRef=e,this._closestTabGroup=i,this.textLabel="",this._contentPortal=null,this._stateChanges=new Ee,this.position=null,this.origin=null,this.isActive=!1}ngOnChanges(e){(e.hasOwnProperty("textLabel")||e.hasOwnProperty("disabled"))&&this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}ngOnInit(){this._contentPortal=new To(this._explicitContent||this._implicitContent,this._viewContainerRef)}_setTemplateLabelInput(e){e&&e._closestTab===this&&(this._templateLabel=e)}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(mX,8))},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&Ue(oi,7),2&e){let r;be(r=ve())&&(i._implicitContent=r.first)}},inputs:{textLabel:["label","textLabel"],ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],labelClass:"labelClass",bodyClass:"bodyClass"},features:[Xe,qt]}),n})(),ay=(()=>{class n extends zCe{get templateLabel(){return this._templateLabel}set templateLabel(e){this._setTemplateLabelInput(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-tab"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,OCe,7,oi),Bn(r,tN,5)),2&e){let o;be(o=ve())&&(i._explicitContent=o.first),be(o=ve())&&(i.templateLabel=o.first)}},inputs:{disabled:"disabled"},exportAs:["matTab"],features:[Vt([{provide:uX,useExisting:n}]),Xe],ngContentSelectors:cX,decls:1,vars:0,template:function(e,i){1&e&&(fn(),S(0,_Ce,1,0,"ng-template"))},encapsulation:2}),n})(),lX=za({passive:!0}),fX=(()=>{class n{get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=vt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){e=mi(e),this._selectedIndex!=e&&(this._selectedIndexChanged=!0,this._selectedIndex=e,this._keyManager&&this._keyManager.updateActiveItem(e))}constructor(e,i,r,o,a,s,l){this._elementRef=e,this._changeDetectorRef=i,this._viewportRuler=r,this._dir=o,this._ngZone=a,this._platform=s,this._animationMode=l,this._scrollDistance=0,this._selectedIndexChanged=!1,this._destroyed=new Ee,this._showPaginationControls=!1,this._disableScrollAfter=!0,this._disableScrollBefore=!0,this._stopScrolling=new Ee,this._disablePagination=!1,this._selectedIndex=0,this.selectFocusedIndex=new F,this.indexFocused=new F,a.runOutsideAngular(()=>{Ei(e.nativeElement,"mouseleave").pipe(it(this._destroyed)).subscribe(()=>{this._stopInterval()})})}ngAfterViewInit(){Ei(this._previousPaginator.nativeElement,"touchstart",lX).pipe(it(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("before")}),Ei(this._nextPaginator.nativeElement,"touchstart",lX).pipe(it(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("after")})}ngAfterContentInit(){let e=this._dir?this._dir.change:$t("ltr"),i=this._viewportRuler.change(150),r=()=>{this.updatePagination(),this._alignInkBarToSelectedTab()};this._keyManager=new ku(this._items).withHorizontalOrientation(this._getLayoutDirection()).withHomeAndEnd().withWrap().skipPredicate(()=>!1),this._keyManager.updateActiveItem(this._selectedIndex),this._ngZone.onStable.pipe(Lt(1)).subscribe(r),tn(e,i,this._items.changes,this._itemsResized()).pipe(it(this._destroyed)).subscribe(()=>{this._ngZone.run(()=>{Promise.resolve().then(()=>{this._scrollDistance=Math.max(0,Math.min(this._getMaxScrollDistance(),this._scrollDistance)),r()})}),this._keyManager.withHorizontalOrientation(this._getLayoutDirection())}),this._keyManager.change.subscribe(o=>{this.indexFocused.emit(o),this._setTabFocus(o)})}_itemsResized(){return"function"!=typeof ResizeObserver?Kr:this._items.changes.pipe(kn(this._items),Jn(e=>new Kt(i=>this._ngZone.runOutsideAngular(()=>{let r=new ResizeObserver(o=>i.next(o));return e.forEach(o=>r.observe(o.elementRef.nativeElement)),()=>{r.disconnect()}}))),os(1),Oe(e=>e.some(i=>i.contentRect.width>0&&i.contentRect.height>0)))}ngAfterContentChecked(){this._tabLabelCount!=this._items.length&&(this.updatePagination(),this._tabLabelCount=this._items.length,this._changeDetectorRef.markForCheck()),this._selectedIndexChanged&&(this._scrollToLabel(this._selectedIndex),this._checkScrollingControls(),this._alignInkBarToSelectedTab(),this._selectedIndexChanged=!1,this._changeDetectorRef.markForCheck()),this._scrollDistanceChanged&&(this._updateTabScrollPosition(),this._scrollDistanceChanged=!1,this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._keyManager?.destroy(),this._destroyed.next(),this._destroyed.complete(),this._stopScrolling.complete()}_handleKeydown(e){if(!Or(e))switch(e.keyCode){case 13:case 32:if(this.focusIndex!==this.selectedIndex){let i=this._items.get(this.focusIndex);i&&!i.disabled&&(this.selectFocusedIndex.emit(this.focusIndex),this._itemSelected(e))}break;default:this._keyManager.onKeydown(e)}}_onContentChanges(){let e=this._elementRef.nativeElement.textContent;e!==this._currentTextContent&&(this._currentTextContent=e||"",this._ngZone.run(()=>{this.updatePagination(),this._alignInkBarToSelectedTab(),this._changeDetectorRef.markForCheck()}))}updatePagination(){this._checkPaginationEnabled(),this._checkScrollingControls(),this._updateTabScrollPosition()}get focusIndex(){return this._keyManager?this._keyManager.activeItemIndex:0}set focusIndex(e){!this._isValidIndex(e)||this.focusIndex===e||!this._keyManager||this._keyManager.setActiveItem(e)}_isValidIndex(e){return!this._items||!!this._items.toArray()[e]}_setTabFocus(e){if(this._showPaginationControls&&this._scrollToLabel(e),this._items&&this._items.length){this._items.toArray()[e].focus();let i=this._tabListContainer.nativeElement;i.scrollLeft="ltr"==this._getLayoutDirection()?0:i.scrollWidth-i.offsetWidth}}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_updateTabScrollPosition(){if(this.disablePagination)return;let e=this.scrollDistance,i="ltr"===this._getLayoutDirection()?-e:e;this._tabList.nativeElement.style.transform=`translateX(${Math.round(i)}px)`,(this._platform.TRIDENT||this._platform.EDGE)&&(this._tabListContainer.nativeElement.scrollLeft=0)}get scrollDistance(){return this._scrollDistance}set scrollDistance(e){this._scrollTo(e)}_scrollHeader(e){return this._scrollTo(this._scrollDistance+("before"==e?-1:1)*this._tabListContainer.nativeElement.offsetWidth/3)}_handlePaginatorClick(e){this._stopInterval(),this._scrollHeader(e)}_scrollToLabel(e){if(this.disablePagination)return;let i=this._items?this._items.toArray()[e]:null;if(!i)return;let s,l,r=this._tabListContainer.nativeElement.offsetWidth,{offsetLeft:o,offsetWidth:a}=i.elementRef.nativeElement;"ltr"==this._getLayoutDirection()?(s=o,l=s+a):(l=this._tabListInner.nativeElement.offsetWidth-o,s=l-a);let c=this.scrollDistance,d=this.scrollDistance+r;s<c?this.scrollDistance-=c-s:l>d&&(this.scrollDistance+=Math.min(l-d,s-c))}_checkPaginationEnabled(){if(this.disablePagination)this._showPaginationControls=!1;else{let e=this._tabListInner.nativeElement.scrollWidth>this._elementRef.nativeElement.offsetWidth;e||(this.scrollDistance=0),e!==this._showPaginationControls&&this._changeDetectorRef.markForCheck(),this._showPaginationControls=e}}_checkScrollingControls(){this.disablePagination?this._disableScrollAfter=this._disableScrollBefore=!0:(this._disableScrollBefore=0==this.scrollDistance,this._disableScrollAfter=this.scrollDistance==this._getMaxScrollDistance(),this._changeDetectorRef.markForCheck())}_getMaxScrollDistance(){return this._tabListInner.nativeElement.scrollWidth-this._tabListContainer.nativeElement.offsetWidth||0}_alignInkBarToSelectedTab(){let e=this._items&&this._items.length?this._items.toArray()[this.selectedIndex]:null,i=e?e.elementRef.nativeElement:null;i?this._inkBar.alignToElement(i):this._inkBar.hide()}_stopInterval(){this._stopScrolling.next()}_handlePaginatorPress(e,i){i&&null!=i.button&&0!==i.button||(this._stopInterval(),rs(650,100).pipe(it(tn(this._stopScrolling,this._destroyed))).subscribe(()=>{let{maxScrollDistance:r,distance:o}=this._scrollHeader(e);(0===o||o>=r)&&this._stopInterval()}))}_scrollTo(e){if(this.disablePagination)return{maxScrollDistance:0,distance:0};let i=this._getMaxScrollDistance();return this._scrollDistance=Math.max(0,Math.min(i,e)),this._scrollDistanceChanged=!0,this._checkScrollingControls(),{maxScrollDistance:i,distance:this._scrollDistance}}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(Wa),C(zi,8),C(ot),C(Vn),C(pi,8))},n.\u0275dir=Me({type:n,inputs:{disablePagination:"disablePagination"}}),n})(),GCe=(()=>{class n extends fX{get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=vt(e)}constructor(e,i,r,o,a,s,l){super(e,i,r,o,a,s,l),this._disableRipple=!1}_itemSelected(e){e.preventDefault()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(Wa),C(zi,8),C(ot),C(Vn),C(pi,8))},n.\u0275dir=Me({type:n,inputs:{disableRipple:"disableRipple"},features:[Xe]}),n})(),WCe=(()=>{class n extends GCe{constructor(e,i,r,o,a,s,l){super(e,i,r,o,a,s,l)}ngAfterContentInit(){this._inkBar=new class{constructor(t){this._items=t}hide(){this._items.forEach(t=>t.deactivateInkBar())}alignToElement(t){let e=this._items.find(r=>r.elementRef.nativeElement===t),i=this._currentItem;if(i?.deactivateInkBar(),e){let r=i?.elementRef.nativeElement.getBoundingClientRect?.();e.activateInkBar(r),this._currentItem=e}}}(this._items),super.ngAfterContentInit()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(Wa),C(zi,8),C(ot),C(Vn),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-tab-header"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,hX,4),2&e){let o;be(o=ve())&&(i._items=o)}},viewQuery:function(e,i){if(1&e&&(Ue(bCe,7),Ue(vCe,7),Ue(yCe,7),Ue(xCe,5),Ue(CCe,5)),2&e){let r;be(r=ve())&&(i._tabListContainer=r.first),be(r=ve())&&(i._tabList=r.first),be(r=ve())&&(i._tabListInner=r.first),be(r=ve())&&(i._nextPaginator=r.first),be(r=ve())&&(i._previousPaginator=r.first)}},hostAttrs:[1,"mat-mdc-tab-header"],hostVars:4,hostBindings:function(e,i){2&e&&nt("mat-mdc-tab-header-pagination-controls-enabled",i._showPaginationControls)("mat-mdc-tab-header-rtl","rtl"==i._getLayoutDirection())},inputs:{selectedIndex:"selectedIndex"},outputs:{selectFocusedIndex:"selectFocusedIndex",indexFocused:"indexFocused"},features:[Xe],ngContentSelectors:cX,decls:13,vars:10,consts:[["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-mdc-tab-header-pagination","mat-mdc-tab-header-pagination-before",3,"matRippleDisabled","disabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-mdc-tab-header-pagination-chevron"],[1,"mat-mdc-tab-label-container",3,"keydown"],["tabListContainer",""],["role","tablist",1,"mat-mdc-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-mdc-tab-labels"],["tabListInner",""],["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-mdc-tab-header-pagination","mat-mdc-tab-header-pagination-after",3,"matRippleDisabled","disabled","mousedown","click","touchend"],["nextPaginator",""]],template:function(e,i){1&e&&(fn(),f(0,"button",0,1),A("click",function(){return i._handlePaginatorClick("before")})("mousedown",function(o){return i._handlePaginatorPress("before",o)})("touchend",function(){return i._stopInterval()}),k(2,"div",2),g(),f(3,"div",3,4),A("keydown",function(o){return i._handleKeydown(o)}),f(5,"div",5,6),A("cdkObserveContent",function(){return i._onContentChanges()}),f(7,"div",7,8),Tt(9),g()()(),f(10,"button",9,10),A("mousedown",function(o){return i._handlePaginatorPress("after",o)})("click",function(){return i._handlePaginatorClick("after")})("touchend",function(){return i._stopInterval()}),k(12,"div",2),g()),2&e&&(nt("mat-mdc-tab-header-pagination-disabled",i._disableScrollBefore),b("matRippleDisabled",i._disableScrollBefore||i.disableRipple)("disabled",i._disableScrollBefore||null),v(3),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode),v(7),nt("mat-mdc-tab-header-pagination-disabled",i._disableScrollAfter),b("matRippleDisabled",i._disableScrollAfter||i.disableRipple)("disabled",i._disableScrollAfter||null))},dependencies:[Ki,O1],styles:[".mat-mdc-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-mdc-tab-header-pagination{-webkit-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0);touch-action:none;box-sizing:content-box;background:none;border:none;outline:0;padding:0}.mat-mdc-tab-header-pagination::-moz-focus-inner{border:0}.mat-mdc-tab-header-pagination .mat-ripple-element{opacity:.12}.mat-mdc-tab-header-pagination-controls-enabled .mat-mdc-tab-header-pagination{display:flex}.mat-mdc-tab-header-pagination-before,.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-after{padding-left:4px}.mat-mdc-tab-header-pagination-before .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-after .mat-mdc-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-before,.mat-mdc-tab-header-pagination-after{padding-right:4px}.mat-mdc-tab-header-rtl .mat-mdc-tab-header-pagination-before .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-header-pagination-after .mat-mdc-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-mdc-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;height:8px;width:8px}.mat-mdc-tab-header-pagination-disabled{box-shadow:none;cursor:default;pointer-events:none}.mat-mdc-tab-header-pagination-disabled .mat-mdc-tab-header-pagination-chevron{opacity:.4}.mat-mdc-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-mdc-tab-list{transition:none}._mat-animation-noopable span.mdc-tab-indicator__content,._mat-animation-noopable span.mdc-tab__text-label{transition:none}.mat-mdc-tab-label-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}.mat-mdc-tab-labels{display:flex;flex:1 0 auto}[mat-align-tabs=center]>.mat-mdc-tab-header .mat-mdc-tab-labels{justify-content:center}[mat-align-tabs=end]>.mat-mdc-tab-header .mat-mdc-tab-labels{justify-content:flex-end}.mat-mdc-tab::before{margin:5px}.cdk-high-contrast-active .mat-mdc-tab[aria-disabled=true]{color:GrayText}"],encapsulation:2}),n})(),gX=new te("MAT_TABS_CONFIG"),qCe=0,XCe=Ko(go(class{constructor(n){this._elementRef=n}}),"primary"),YCe=(()=>{class n extends XCe{get dynamicHeight(){return this._dynamicHeight}set dynamicHeight(e){this._dynamicHeight=vt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){this._indexToSelect=mi(e,null)}get animationDuration(){return this._animationDuration}set animationDuration(e){this._animationDuration=/^\d+$/.test(e+"")?e+"ms":e}get contentTabIndex(){return this._contentTabIndex}set contentTabIndex(e){this._contentTabIndex=mi(e,null)}get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=vt(e)}get preserveContent(){return this._preserveContent}set preserveContent(e){this._preserveContent=vt(e)}get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}constructor(e,i,r,o){super(e),this._changeDetectorRef=i,this._animationMode=o,this._tabs=new Pa,this._indexToSelect=0,this._lastFocusedTabIndex=null,this._tabBodyWrapperHeight=0,this._tabsSubscription=En.EMPTY,this._tabLabelSubscription=En.EMPTY,this._dynamicHeight=!1,this._selectedIndex=null,this.headerPosition="above",this._disablePagination=!1,this._preserveContent=!1,this.selectedIndexChange=new F,this.focusChange=new F,this.animationDone=new F,this.selectedTabChange=new F(!0),this._groupId=qCe++,this.animationDuration=r&&r.animationDuration?r.animationDuration:"500ms",this.disablePagination=!(!r||null==r.disablePagination)&&r.disablePagination,this.dynamicHeight=!(!r||null==r.dynamicHeight)&&r.dynamicHeight,this.contentTabIndex=r?.contentTabIndex??null,this.preserveContent=!!r?.preserveContent}ngAfterContentChecked(){let e=this._indexToSelect=this._clampTabIndex(this._indexToSelect);if(this._selectedIndex!=e){let i=null==this._selectedIndex;if(!i){this.selectedTabChange.emit(this._createChangeEvent(e));let r=this._tabBodyWrapper.nativeElement;r.style.minHeight=r.clientHeight+"px"}Promise.resolve().then(()=>{this._tabs.forEach((r,o)=>r.isActive=o===e),i||(this.selectedIndexChange.emit(e),this._tabBodyWrapper.nativeElement.style.minHeight="")})}this._tabs.forEach((i,r)=>{i.position=r-e,null!=this._selectedIndex&&0==i.position&&!i.origin&&(i.origin=e-this._selectedIndex)}),this._selectedIndex!==e&&(this._selectedIndex=e,this._lastFocusedTabIndex=null,this._changeDetectorRef.markForCheck())}ngAfterContentInit(){this._subscribeToAllTabChanges(),this._subscribeToTabLabels(),this._tabsSubscription=this._tabs.changes.subscribe(()=>{let e=this._clampTabIndex(this._indexToSelect);if(e===this._selectedIndex){let r,i=this._tabs.toArray();for(let o=0;o<i.length;o++)if(i[o].isActive){this._indexToSelect=this._selectedIndex=o,this._lastFocusedTabIndex=null,r=i[o];break}!r&&i[e]&&Promise.resolve().then(()=>{i[e].isActive=!0,this.selectedTabChange.emit(this._createChangeEvent(e))})}this._changeDetectorRef.markForCheck()})}_subscribeToAllTabChanges(){this._allTabs.changes.pipe(kn(this._allTabs)).subscribe(e=>{this._tabs.reset(e.filter(i=>i._closestTabGroup===this||!i._closestTabGroup)),this._tabs.notifyOnChanges()})}ngOnDestroy(){this._tabs.destroy(),this._tabsSubscription.unsubscribe(),this._tabLabelSubscription.unsubscribe()}realignInkBar(){this._tabHeader&&this._tabHeader._alignInkBarToSelectedTab()}updatePagination(){this._tabHeader&&this._tabHeader.updatePagination()}focusTab(e){let i=this._tabHeader;i&&(i.focusIndex=e)}_focusChanged(e){this._lastFocusedTabIndex=e,this.focusChange.emit(this._createChangeEvent(e))}_createChangeEvent(e){let i=new eN;return i.index=e,this._tabs&&this._tabs.length&&(i.tab=this._tabs.toArray()[e]),i}_subscribeToTabLabels(){this._tabLabelSubscription&&this._tabLabelSubscription.unsubscribe(),this._tabLabelSubscription=tn(...this._tabs.map(e=>e._stateChanges)).subscribe(()=>this._changeDetectorRef.markForCheck())}_clampTabIndex(e){return Math.min(this._tabs.length-1,Math.max(e||0,0))}_getTabLabelId(e){return`mat-tab-label-${this._groupId}-${e}`}_getTabContentId(e){return`mat-tab-content-${this._groupId}-${e}`}_setTabBodyWrapperHeight(e){if(!this._dynamicHeight||!this._tabBodyWrapperHeight)return;let i=this._tabBodyWrapper.nativeElement;i.style.height=this._tabBodyWrapperHeight+"px",this._tabBodyWrapper.nativeElement.offsetHeight&&(i.style.height=e+"px")}_removeTabBodyWrapperHeight(){let e=this._tabBodyWrapper.nativeElement;this._tabBodyWrapperHeight=e.clientHeight,e.style.height="",this.animationDone.emit()}_handleClick(e,i,r){i.focusIndex=r,e.disabled||(this.selectedIndex=r)}_getTabIndex(e){return e===(this._lastFocusedTabIndex??this.selectedIndex)?0:-1}_tabFocusChanged(e,i){e&&"mouse"!==e&&"touch"!==e&&(this._tabHeader.focusIndex=i)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(gX,8),C(pi,8))},n.\u0275dir=Me({type:n,inputs:{dynamicHeight:"dynamicHeight",selectedIndex:"selectedIndex",headerPosition:"headerPosition",animationDuration:"animationDuration",contentTabIndex:"contentTabIndex",disablePagination:"disablePagination",preserveContent:"preserveContent",backgroundColor:"backgroundColor"},outputs:{selectedIndexChange:"selectedIndexChange",focusChange:"focusChange",animationDone:"animationDone",selectedTabChange:"selectedTabChange"},features:[Xe]}),n})(),vE=(()=>{class n extends YCe{get fitInkBarToContent(){return this._fitInkBarToContent}set fitInkBarToContent(e){this._fitInkBarToContent=vt(e),this._changeDetectorRef.markForCheck()}get stretchTabs(){return this._stretchTabs}set stretchTabs(e){this._stretchTabs=vt(e)}constructor(e,i,r,o){super(e,i,r,o),this._fitInkBarToContent=!1,this._stretchTabs=!0,this.fitInkBarToContent=!(!r||null==r.fitInkBarToContent)&&r.fitInkBarToContent}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(gX,8),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-tab-group"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,ay,5),2&e){let o;be(o=ve())&&(i._allTabs=o)}},viewQuery:function(e,i){if(1&e&&(Ue(MCe,5),Ue(wCe,5)),2&e){let r;be(r=ve())&&(i._tabBodyWrapper=r.first),be(r=ve())&&(i._tabHeader=r.first)}},hostAttrs:[1,"mat-mdc-tab-group"],hostVars:6,hostBindings:function(e,i){2&e&&nt("mat-mdc-tab-group-dynamic-height",i.dynamicHeight)("mat-mdc-tab-group-inverted-header","below"===i.headerPosition)("mat-mdc-tab-group-stretch-tabs",i.stretchTabs)},inputs:{color:"color",disableRipple:"disableRipple",fitInkBarToContent:"fitInkBarToContent",stretchTabs:["mat-stretch-tabs","stretchTabs"]},exportAs:["matTabGroup"],features:[Vt([{provide:mX,useExisting:n}]),Xe],decls:6,vars:7,consts:[[3,"selectedIndex","disableRipple","disablePagination","indexFocused","selectFocusedIndex"],["tabHeader",""],["class","mdc-tab mat-mdc-tab mat-mdc-focus-indicator","role","tab","matTabLabelWrapper","","cdkMonitorElementFocus","",3,"id","mdc-tab--active","ngClass","disabled","fitInkBarToContent","click","cdkFocusChange",4,"ngFor","ngForOf"],[1,"mat-mdc-tab-body-wrapper"],["tabBodyWrapper",""],["role","tabpanel",3,"id","mat-mdc-tab-body-active","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering",4,"ngFor","ngForOf"],["role","tab","matTabLabelWrapper","","cdkMonitorElementFocus","",1,"mdc-tab","mat-mdc-tab","mat-mdc-focus-indicator",3,"id","ngClass","disabled","fitInkBarToContent","click","cdkFocusChange"],["tabNode",""],[1,"mdc-tab__ripple"],["mat-ripple","",1,"mat-mdc-tab-ripple",3,"matRippleTrigger","matRippleDisabled"],[1,"mdc-tab__content"],[1,"mdc-tab__text-label"],[3,"ngIf","ngIfElse"],["tabTextLabel",""],[3,"cdkPortalOutlet"],["role","tabpanel",3,"id","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering"]],template:function(e,i){1&e&&(f(0,"mat-tab-header",0,1),A("indexFocused",function(o){return i._focusChanged(o)})("selectFocusedIndex",function(o){return i.selectedIndex=o}),S(2,DCe,9,17,"div",2),g(),f(3,"div",3,4),S(5,ICe,1,11,"mat-tab-body",5),g()),2&e&&(b("selectedIndex",i.selectedIndex||0)("disableRipple",i.disableRipple)("disablePagination",i.disablePagination),v(2),b("ngForOf",i._tabs),v(1),nt("_mat-animation-noopable","NoopAnimations"===i._animationMode),v(2),b("ngForOf",i._tabs))},dependencies:[wn,nn,Ne,ba,Ki,A7,dX,hX,WCe],styles:['.mdc-tab{min-width:90px;padding-right:24px;padding-left:24px;display:flex;flex:1 0 auto;justify-content:center;box-sizing:border-box;margin:0;padding-top:0;padding-bottom:0;border:none;outline:none;text-align:center;white-space:nowrap;cursor:pointer;-webkit-appearance:none;z-index:1}.mdc-tab::-moz-focus-inner{padding:0;border:0}.mdc-tab[hidden]{display:none}.mdc-tab--min-width{flex:0 1 auto}.mdc-tab__content{display:flex;align-items:center;justify-content:center;height:inherit;pointer-events:none}.mdc-tab__text-label{transition:150ms color linear;display:inline-block;line-height:1;z-index:2}.mdc-tab__icon{transition:150ms color linear;z-index:2}.mdc-tab--stacked .mdc-tab__content{flex-direction:column;align-items:center;justify-content:center}.mdc-tab--stacked .mdc-tab__text-label{padding-top:6px;padding-bottom:4px}.mdc-tab--active .mdc-tab__text-label,.mdc-tab--active .mdc-tab__icon{transition-delay:100ms}.mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label{padding-left:8px;padding-right:0}[dir=rtl] .mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label,.mdc-tab:not(.mdc-tab--stacked) .mdc-tab__icon+.mdc-tab__text-label[dir=rtl]{padding-left:0;padding-right:8px}.mdc-tab-indicator .mdc-tab-indicator__content--underline{border-top-width:2px}.mdc-tab-indicator .mdc-tab-indicator__content--icon{height:34px;font-size:34px}.mdc-tab-indicator{display:flex;position:absolute;top:0;left:0;justify-content:center;width:100%;height:100%;pointer-events:none;z-index:1}.mdc-tab-indicator__content{transform-origin:left;opacity:0}.mdc-tab-indicator__content--underline{align-self:flex-end;box-sizing:border-box;width:100%;border-top-style:solid}.mdc-tab-indicator__content--icon{align-self:center;margin:0 auto}.mdc-tab-indicator--active .mdc-tab-indicator__content{opacity:1}.mdc-tab-indicator .mdc-tab-indicator__content{transition:250ms transform cubic-bezier(0.4, 0, 0.2, 1)}.mdc-tab-indicator--no-transition .mdc-tab-indicator__content{transition:none}.mdc-tab-indicator--fade .mdc-tab-indicator__content{transition:150ms opacity linear}.mdc-tab-indicator--active.mdc-tab-indicator--fade .mdc-tab-indicator__content{transition-delay:100ms}.mat-mdc-tab-ripple{position:absolute;top:0;left:0;bottom:0;right:0;pointer-events:none}.mat-mdc-tab{-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-tab.mdc-tab{height:48px;flex-grow:0}.mat-mdc-tab .mdc-tab__ripple::before{content:"";display:block;position:absolute;top:0;left:0;right:0;bottom:0;opacity:0;pointer-events:none}.mat-mdc-tab .mdc-tab__text-label{display:inline-flex;align-items:center}.mat-mdc-tab .mdc-tab__content{position:relative;pointer-events:auto}.mat-mdc-tab:hover .mdc-tab__ripple::before{opacity:.04}.mat-mdc-tab.cdk-program-focused .mdc-tab__ripple::before,.mat-mdc-tab.cdk-keyboard-focused .mdc-tab__ripple::before{opacity:.12}.mat-mdc-tab .mat-ripple-element{opacity:.12}.mat-mdc-tab-group.mat-mdc-tab-group-stretch-tabs>.mat-mdc-tab-header .mat-mdc-tab{flex-grow:1}.mat-mdc-tab-disabled{opacity:.4}.mat-mdc-tab-group{display:flex;flex-direction:column;max-width:100%}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination{background-color:var(--mat-mdc-tab-header-with-background-background-color, transparent)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab .mdc-tab__text-label,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-link .mdc-tab__text-label{color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mdc-tab-indicator__content--underline,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-focus-indicator::before{border-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-ripple-element,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mdc-tab__ripple::before,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mat-ripple-element,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mdc-tab__ripple::before{background-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header .mat-mdc-tab-header-pagination-chevron,.mat-mdc-tab-group.mat-tabs-with-background>.mat-mdc-tab-header-pagination .mat-mdc-tab-header-pagination-chevron{border-color:var(--mat-mdc-tab-header-with-background-foreground-color, inherit)}.mat-mdc-tab-group.mat-mdc-tab-group-inverted-header{flex-direction:column-reverse}.mat-mdc-tab-group.mat-mdc-tab-group-inverted-header .mdc-tab-indicator__content--underline{align-self:flex-start}.mat-mdc-tab-body-wrapper{position:relative;overflow:hidden;display:flex;transition:height 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-mdc-tab-body-wrapper._mat-animation-noopable{transition:none !important;animation:none !important}'],encapsulation:2}),n})(),eN=class{},QCe=0,ZCe=(()=>{class n extends fX{get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement.classList;i.remove("mat-tabs-with-background",`mat-background-${this.backgroundColor}`),e&&i.add("mat-tabs-with-background",`mat-background-${e}`),this._backgroundColor=e}get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=vt(e)}constructor(e,i,r,o,a,s,l){super(e,o,a,i,r,s,l),this._disableRipple=!1,this.color="primary"}_itemSelected(){}ngAfterContentInit(){this._items.changes.pipe(kn(null),it(this._destroyed)).subscribe(()=>{this.updateActiveLink()}),super.ngAfterContentInit()}updateActiveLink(){if(!this._items)return;let e=this._items.toArray();for(let i=0;i<e.length;i++)if(e[i].active)return this.selectedIndex=i,this._changeDetectorRef.markForCheck(),void(this.tabPanel&&(this.tabPanel._activeTabId=e[i].id));this.selectedIndex=-1,this._inkBar.hide()}_getRole(){return this.tabPanel?"tablist":this._elementRef.nativeElement.getAttribute("role")}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(zi,8),C(ot),C(Qt),C(Wa),C(Vn),C(pi,8))},n.\u0275dir=Me({type:n,inputs:{backgroundColor:"backgroundColor",disableRipple:"disableRipple",color:"color",tabPanel:"tabPanel"},features:[Xe]}),n})(),KCe=Dc(go(ao(class{}))),JCe=(()=>{class n extends KCe{get active(){return this._isActive}set active(e){let i=vt(e);i!==this._isActive&&(this._isActive=i,this._tabNavBar.updateActiveLink())}get rippleDisabled(){return this.disabled||this.disableRipple||this._tabNavBar.disableRipple||!!this.rippleConfig.disabled}constructor(e,i,r,o,a,s){super(),this._tabNavBar=e,this.elementRef=i,this._focusMonitor=a,this._isActive=!1,this.id="mat-tab-link-"+QCe++,this.rippleConfig=r||{},this.tabIndex=parseInt(o)||0,"NoopAnimations"===s&&(this.rippleConfig.animation={enterDuration:0,exitDuration:0})}focus(){this.elementRef.nativeElement.focus()}ngAfterViewInit(){this._focusMonitor.monitor(this.elementRef)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this.elementRef)}_handleFocus(){this._tabNavBar.focusIndex=this._tabNavBar._items.toArray().indexOf(this)}_handleKeydown(e){this._tabNavBar.tabPanel&&32===e.keyCode&&this.elementRef.nativeElement.click()}_getAriaControls(){return this._tabNavBar.tabPanel?this._tabNavBar.tabPanel?.id:this.elementRef.nativeElement.getAttribute("aria-controls")}_getAriaSelected(){return this._tabNavBar.tabPanel?this.active?"true":"false":this.elementRef.nativeElement.getAttribute("aria-selected")}_getAriaCurrent(){return this.active&&!this._tabNavBar.tabPanel?"page":null}_getRole(){return this._tabNavBar.tabPanel?"tab":this.elementRef.nativeElement.getAttribute("role")}_getTabIndex(){return this._tabNavBar.tabPanel?this._isActive&&!this.disabled?0:-1:this.tabIndex}}return n.\u0275fac=function(e){return new(e||n)(C(ZCe),C(xe),C(Th,8),Mo("tabindex"),C(fo),C(pi,8))},n.\u0275dir=Me({type:n,inputs:{active:"active",id:"id"},features:[Xe]}),n})(),yE=(pX(JCe),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,dn,Bl,_a,og,pg,dn]}),n})());function $Ce(n,t){if(1&n){let e=Te();f(0,"span",5),A("click",function(r){ne(e);let o=w().$implicit;return ie(w().onActivePluginSelection(r,o.id))}),T(1),g()}if(2&n){let e=w().$implicit;Be("data-plugin-id",e.id),v(1),Ve(" ",e.tab_name," ")}}function eMe(n,t){1&n&&(f(0,"mat-tab",3),S(1,$Ce,2,2,"ng-template",4),g()),2&n&&b("disabled",!t.$implicit.enabled)}function tMe(n,t){if(1&n&&(f(0,"mat-option",9),T(1),g()),2&n){let e=t.$implicit;b("value",e.id),Be("data-plugin-id",e.id),v(1),Ve(" ",e.tab_name," ")}}function nMe(n,t){if(1&n){let e=Te();f(0,"mat-form-field",6)(1,"mat-label"),T(2,"Inactive"),g(),f(3,"mat-select",7),A("selectionChange",function(r){return ne(e),ie(w().onDisabledPluginSelectionChanged(r))}),S(4,tMe,2,3,"mat-option",8),g()()}if(2&n){let e=w();v(3),b("value",e.selectedPlugin)("hideSingleSelectionIndicator",!0),v(1),b("ngForOf",e.disabledPlugins)}}var bX=(()=>{class n{constructor(){this.onPluginSelectionChanged=new F}getActivePluginIndex(){return this.activePlugins.findIndex(({id:e})=>e===this.selectedPlugin)}onActivePluginSelection(e,i){e.stopPropagation(),this.onPluginSelectionChanged.emit(i)}onDisabledPluginSelectionChanged(e){this.onPluginSelectionChanged.emit(e.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["plugin-selector-component"]],inputs:{activePlugins:"activePlugins",disabledPlugins:"disabledPlugins",selectedPlugin:"selectedPlugin"},outputs:{onPluginSelectionChanged:"onPluginSelectionChanged"},decls:3,vars:3,consts:[["mat-stretch-tabs","false","animationDuration","100ms",1,"active-plugin-list",3,"selectedIndex"],[3,"disabled",4,"ngFor","ngForOf"],["floatLabel","never","subscriptSizing","dynamic",4,"ngIf"],[3,"disabled"],["mat-tab-label",""],[1,"plugin-name",3,"click"],["floatLabel","never","subscriptSizing","dynamic"],[3,"value","hideSingleSelectionIndicator","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"]],template:function(e,i){1&e&&(f(0,"mat-tab-group",0),S(1,eMe,2,1,"mat-tab",1),g(),S(2,nMe,5,3,"mat-form-field",2)),2&e&&(b("selectedIndex",i.getActivePluginIndex()),v(1),b("ngForOf",i.activePlugins),v(1),b("ngIf",i.disabledPlugins.length>0))},dependencies:[tN,ay,vE,Pc,nl,Wu,ja,nn,Ne],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]    {width:144px}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field{background-color:#f57c00;padding:0 4px}body.dark-mode   [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field{background-color:#ef6c00}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     label.mdc-floating-label.mat-mdc-floating-label, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select-value, [_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mat-mdc-select-arrow{color:inherit}[_nghost-%COMP%]   mat-form-field[_ngcontent-%COMP%]     .mdc-text-field--filled:not(.mdc-text-field--disabled) .mdc-line-ripple::before{border-color:inherit}mat-label[_ngcontent-%COMP%], mat-select[_ngcontent-%COMP%], mat-option[_ngcontent-%COMP%]{font-size:14px;font-weight:500;text-transform:uppercase}.active-plugin-list[_ngcontent-%COMP%]{align-self:stretch;flex:1 1 auto;overflow:hidden}.plugin-name[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:100%;justify-content:center;padding:0 12px;width:100%}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab-indicator__content--underline{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled) .mdc-tab__text-label{color:inherit;opacity:.7}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab:not(.mat-mdc-tab-disabled).mdc-tab--active .mdc-tab__text-label{color:inherit;opacity:1}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination{color:inherit}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination-chevron{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header-pagination-disabled{visibility:hidden}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-disabled{display:none}[_nghost-%COMP%]     .active-plugin-list mat-mdc-tab-list, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-labels, [_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab-header .mat-mdc-tab, [_nghost-%COMP%]     .active-plugin-list .mdc-tab__text-label{height:100%}[_nghost-%COMP%]     .active-plugin-list .mat-mdc-tab{letter-spacing:.25px;min-width:48px;padding:0;text-transform:uppercase}[_nghost-%COMP%]     .active-plugin-list mat-tab-header .mat-mdc-tab-list{padding:0 36px}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child{bottom:0;position:absolute;top:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container{left:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-label-container{right:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-header-pagination{background-color:#f57c00}body.dark-mode   [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-mdc-tab-header-pagination{background-color:#ef6c00}"]}),n})(),vX=W(Gf,n=>Object.keys(n).map(t=>Object.assign({},{id:t},n[t]))),rMe=W(vX,n=>n.filter(t=>!t.enabled)),yX=(()=>{class n{constructor(e){this.store=e,this.activePlugin$=this.store.pipe(un(Zo)),this.plugins$=this.store.pipe(un(vX)),this.disabledPlugins$=this.store.pipe(un(rMe))}onPluginSelectionChange(e){this.store.dispatch(yc({plugin:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["plugin-selector"]],decls:4,vars:9,consts:[[3,"activePlugins","disabledPlugins","selectedPlugin","onPluginSelectionChanged"]],template:function(e,i){1&e&&(f(0,"plugin-selector-component",0),A("onPluginSelectionChanged",function(o){return i.onPluginSelectionChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("activePlugins",G(1,3,i.plugins$))("disabledPlugins",G(2,5,i.disabledPlugins$))("selectedPlugin",G(3,7,i.activePlugin$))},dependencies:[bX,ct],encapsulation:2}),n})(),aMe=W(Gf,Zo,(n,t)=>!(!t||!n[t])&&n[t].disable_reload),xX=(()=>{class n{constructor(e){this.store=e,this.reloadDisabled$=this.store.select(aMe),this.isReloading$=this.store.select(L6).pipe(Vi(this.reloadDisabled$),q(([i,r])=>!r&&i===Re.LOADING)),this.lastLoadedTimeInMs$=this.store.select(jf)}triggerReload(){this.store.dispatch(Ba())}getReloadTitle(e){return e?`Last Updated: ${e}`:"Loading..."}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["app-header-reload"]],decls:6,vars:13,consts:[["mat-icon-button","",1,"reload-button",3,"title","disabled","click"],["svgIcon","refresh_24px",1,"refresh-icon"]],template:function(e,i){1&e&&(f(0,"button",0),A("click",function(){return i.triggerReload()}),U(1,"async"),U(2,"date"),U(3,"async"),U(4,"async"),k(5,"mat-icon",1),g()),2&e&&(nt("loading",G(1,4,i.isReloading$)),b("title",i.getReloadTitle(Jp(2,6,G(3,9,i.lastLoadedTimeInMs$),"medium")))("disabled",G(4,11,i.reloadDisabled$)))},dependencies:[Er,bn,ct,wf],styles:[".reload-button[_ngcontent-%COMP%], .refresh-icon[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        justify-content: center;\n      }\n\n      .reload-button.loading[_ngcontent-%COMP%] {\n        animation: _ngcontent-%COMP%_rotate 2s linear infinite;\n      }\n\n      @keyframes _ngcontent-%COMP%_rotate {\n        0% {\n          transform: rotate(0deg);\n        }\n        50% {\n          transform: rotate(180deg);\n        }\n        100% {\n          transform: rotate(360deg);\n        }\n      }"]}),n})(),CX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["app-header"]],decls:9,vars:0,consts:[[1,"brand"],[1,"plugins"],["mat-icon-button","","href","https://github.com/tensorflow/tensorboard/blob/master/README.md","rel","noopener noreferrer","target","_blank","aria-label","Help",1,"readme"],["svgIcon","help_outline_24px"]],template:function(e,i){1&e&&(f(0,"mat-toolbar")(1,"span",0),T(2,"TensorBoard"),g(),k(3,"plugin-selector",1)(4,"app-header-dark-mode-toggle")(5,"app-header-reload")(6,"settings-button"),f(7,"a",2),k(8,"mat-icon",3),g()())},dependencies:[j7,bn,jq,tX,aX,yX,xX],styles:["mat-toolbar[_ngcontent-%COMP%]{align-items:center;color:#fff;display:flex;height:64px;overflow:hidden;width:100%}.brand[_ngcontent-%COMP%], .readme[_ngcontent-%COMP%], app-header-reload[_ngcontent-%COMP%], settings-button[_ngcontent-%COMP%]{flex:0 0 auto}.brand[_ngcontent-%COMP%]{letter-spacing:-0.025em;margin-left:10px;text-rendering:optimizeLegibility}.plugins[_ngcontent-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}"]}),n})(),dMe_setDocumentTitle=function(n){document.title=n},MX=(()=>{class n{ngOnChanges(e){e.title&&dMe_setDocumentTitle(e.title.currentValue)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["page-title-component"]],inputs:{title:"title"},features:[qt],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),wX="TensorBoard",SX=(()=>{class n{constructor(e,i){this.store=e,this.customBrandName=i,this.getExperimentId$=this.store.select(or).pipe(q(r=>r?.[0])),this.experimentName$=this.getExperimentId$.pipe(Oe(Boolean),xn(r=>this.store.select(US,{experimentId:r})),q(r=>r?r.name:null)),this.title$=this.store.select(CS).pipe(Vi(this.store.select(Ws),this.experimentName$),q(([r,o,a])=>{let s=this.customBrandName||wX;return r.window_title?r.window_title:o===Cn.EXPERIMENT&&a?`${a} - ${s}`:s}),kn(this.customBrandName||wX),ri())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(I6,8))},n.\u0275cmp=P({type:n,selectors:[["page-title"]],decls:2,vars:3,consts:[[3,"title"]],template:function(e,i){1&e&&(k(0,"page-title-component",0),U(1,"async")),2&e&&b("title",G(1,1,i.title$))},dependencies:[MX,ct],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),EX=(()=>{class n{constructor(e){this.store=e,this.ngUnsubscribe=new Ee,this.getPageSize$=this.store.pipe(un(Mh)),this.paginatedViewStore=document.createElement("tf-paginated-view-store").tf_paginated_view}ngOnInit(){this.getPageSize$.pipe(it(this.ngUnsubscribe),ri()).subscribe(e=>{this.paginatedViewStore.setLimit(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["settings-polymer-interop"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),TX=(()=>{class n{constructor(e){this.vcRef=e}}return n.\u0275fac=function(e){return new(e||n)(C(ei))},n.\u0275cmp=P({type:n,selectors:[["tb-webapp"]],decls:9,vars:0,template:function(e,i){1&e&&(k(0,"app-header"),f(1,"main"),k(2,"router-outlet"),g(),k(3,"alert-snackbar")(4,"hash-storage")(5,"page-title")(6,"settings-polymer-interop")(7,"dark-mode-supporter")(8,"feature-flag-modal-trigger"))},dependencies:[Pq,Oq,p9,Fq,Lq,CX,SX,EX],styles:["html[_ngcontent-%COMP%], body[_ngcontent-%COMP%]{font-family:Roboto,sans-serif;height:100%;margin:0;padding:0}[_nghost-%COMP%]{background:#f5f5f5;display:flex;flex-direction:column;height:100%}app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(0,0,0,.25);flex:0 0;z-index:1}body.dark-mode[_nghost-%COMP%]   app-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(255,255,255,.1)}main[_ngcontent-%COMP%]{flex-grow:1;overflow:auto}"]}),n})(),DX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,kf,Pf,Rl]}),n})(),IX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),AX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:gu,useClass:n6}]}),n})(),RX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,AX]}),n})(),PX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),kX={id:Qw,name:"",start_time:0},fMe=gr({experimentMap:{[kX.id]:kX}});function OX(n,t){return ch({data:fMe})(n,t)}var FX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[wr.forFeature(zS,OX)]}),n})(),NX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Kn,Xa]}),n})(),LX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,NX]}),n})(),BX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Gu,uE,Kn,kc,Hu,ai,rl]}),n})();function gMe(){return W(Av,n=>({autoReload:n}))}function _Me(){return W(Rv,n=>({autoReloadPeriodInMs:n}))}function bMe(){return W(Mh,n=>({pageSize:n}))}var xE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[wr.forFeature(w1,Wq),Ri.defineGlobalSetting(gMe),Ri.defineGlobalSetting(_Me),Ri.defineGlobalSetting(bMe),BX]}),n})(),VX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Kn,ai,yE,Gq,Xa,Qu,De,Qs,xE]}),n})(),HX=(()=>{class n{constructor(e,i){let r=e.bypassSecurityTrustResourceUrl("./icon_bundle.svg");i.addSvgIconSet(r)}}return n.\u0275fac=function(e){return new(e||n)(O(nh),O(Eg))},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[ai]}),n})(),nN=new te("[plugins] Plugin registry config"),zX=new Map,Oc=(()=>{class n{constructor(e){if(!e)return;let i=new Set(e.map(r=>r.pluginName));console.assert(i.size===e.length,"Cannot register the same plugin multiple times.");for(let r of e){let{pluginName:o,componentClass:a}=r;zX.set(o,a)}}static forPlugin(e,i){return{ngModule:n,providers:[{provide:nN,multi:!0,useValue:{pluginName:e,componentClass:i}}]}}getComponent(e){return zX.get(e)||null}}return n.\u0275fac=function(e){return new(e||n)(O(nN,8))},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),CE=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/debugger-v2"}fetchRuns(){return this.http.get(this.httpPathPrefix+"/runs")}fetchExecutionDigests(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchExecutionData(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionDigests(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionDigests() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionData(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionData() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphOpInfo(e,i,r){return this.http.get(this.httpPathPrefix+"/graphs/op_info",{params:{run:e,graph_id:i,op_name:r}})}fetchSourceFileList(e){return this.http.get(this.httpPathPrefix+"/source_files/list",{params:{run:e}})}fetchSourceFile(e,i){return this.http.get(this.httpPathPrefix+"/source_files/file",{params:{run:e,index:String(i)}})}fetchStackFrames(e,i){return this.http.get(this.httpPathPrefix+"/stack_frames/stack_frames",{params:{run:e,stack_frame_ids:i.join(",")}}).pipe(q(r=>({stack_frames:r.stack_frames.map(o=>function(n){return{host_name:n[0],file_path:n[1],lineno:n[2],function_name:n[3]}}(o))})))}fetchAlerts(e,i,r,o){let a={run:e,begin:String(i),end:String(r)};return void 0!==o&&(a.alert_type=o),this.http.get(this.httpPathPrefix+"/alerts",{params:a})}}return n.\u0275fac=function(e){return new(e||n)(O(Xs))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),UX=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[CE],imports:[zf]}),n})(),ME=fe("[Debugger] Debugger Loaded"),wE=fe("[Debugger] Debugger Unloaded"),sy=fe("[Debugger] A New Debugger Data Polling Event Begins"),SE=fe("[Debugger] Debugger Runs Requested"),EE=fe("[Debugger] Debugger Runs Loaded",{_as:"props",_p:void 0}),jX=fe("[Debugger] Debugger Runs Request Failed"),ly=fe("[Debugger] Number and Breakdown of Alerts Requested"),TE=fe("[Debugger] Number and Breakdown of Alerts Loaded",{_as:"props",_p:void 0}),DE=fe("[Debugger] Alerts Data of an AlertType Is Loaded",{_as:"props",_p:void 0}),Dg=fe("[Debugger] Alert Type Focus Toggled",{_as:"props",_p:void 0}),IE=fe("[Debugger] Number of Top-Level Executions Requested"),AE=fe("[Debugger] Number of Top-Level Executions Loaded",{_as:"props",_p:void 0}),RE=fe("[Debugger] ExecutionDigests Requested",{_as:"props",_p:void 0}),PE=fe("[Debugger] ExecutionDigests Loaded",{_as:"props",_p:void 0}),Ig=fe("[Debugger] Scroll Leftward on the Execution Timeline"),Ag=fe("[Debugger] Scroll Rightward on the Execution Timeline"),Rg=fe("[Debugger] Scroll the Execution Timeline to Given Index",{_as:"props",_p:void 0}),Pg=fe("[Debugger] Execution Data Objects Being Focused On",{_as:"props",_p:void 0}),kE=fe("[Debugger] Execution Data Objects Loaded",{_as:"props",_p:void 0}),OE=fe("[Debugger] Number of Intra-Graph Executions Requested"),FE=fe("[Debugger] Number of Intra-Graph Executions Loaded",{_as:"props",_p:void 0}),NE=fe("[Debugger] Intra-Graph Execution Data Requested",{_as:"props",_p:void 0}),LE=fe("[Debugger] Intra-Graph Execution Data Loaded",{_as:"props",_p:void 0}),kg=fe("[Debugger] Scroll Intra-Graph Execution List to Given Index",{_as:"props",_p:void 0}),Og=fe("[Debugger] Graph Execution is Focused On",{_as:"props",_p:void 0}),Fg=fe("[Debugger] Graph Op Is Focused On",{_as:"props",_p:void 0}),BE=fe("[Debugger] Graph Op Info Requested",{_as:"props",_p:void 0}),VE=fe("[Debugger] Graph Op Info Loaded",{_as:"props",_p:void 0}),HE=fe("[Debugger] Source File List Requested."),zE=fe("[Debugger] Source File List Loaded",{_as:"props",_p:void 0}),Ng=fe("[Debugger] Source File Line Is Focused on",{_as:"props",_p:void 0}),UE=fe("[Debugger] Source File Requested",{_as:"props",_p:void 0}),jE=fe("[Debugger] Source File Loaded",{_as:"props",_p:void 0}),cy=fe("[Debugger] A Set of Stack Frames Have Been Loaded",{_as:"props",_p:void 0}),dy="debugger",Ao=(()=>(function(n){n[n.UNSPECIFIED=0]="UNSPECIFIED",n[n.NO_TENSOR=1]="NO_TENSOR",n[n.CURT_HEALTH=2]="CURT_HEALTH",n[n.CONCISE_HEALTH=3]="CONCISE_HEALTH",n[n.FULL_HEALTH=4]="FULL_HEALTH",n[n.SHAPE=5]="SHAPE",n[n.FULL_NUMERICS=6]="FULL_NUMERICS",n[n.FULL_TENSOR=7]="FULL_TENSOR",n[n.REDUCE_INF_NAN_THREE_SLOTS=8]="REDUCE_INF_NAN_THREE_SLOTS"}(Ao||(Ao={})),Ao))(),Fc=(()=>(function(n){n.FUNCTION_RECOMPILE_ALERT="FunctionRecompilesAlert",n.INF_NAN_ALERT="InfNanAlert",n.TENSOR_SHAPE_ALERT="TensorShapeAlert"}(Fc||(Fc={})),Fc))(),zo=(()=>(function(n){n[n.EXECUTION=0]="EXECUTION",n[n.GRAPH_OP_CREATION=1]="GRAPH_OP_CREATION"}(zo||(zo={})),zo))();function Lg(n){if(null===n.codeLocationFocusType)return null;let t=[];if(n.codeLocationFocusType===zo.EXECUTION){let{focusIndex:i,executionData:r}=n.executions;if(null===i||void 0===r[i])return null;t=r[i].stack_frame_ids}else{if(null===n.graphs.focusedOp)return null;let{graphId:i,opName:r}=n.graphs.focusedOp;if(void 0===n.graphs.ops[i]||!n.graphs.ops[i].has(r))return null;t=n.graphs.ops[i].get(r).stack_frame_ids}let e=[];for(let i of t){if(null==n.stackFrames[i])return null;e.push(n.stackFrames[i])}return e}function uy(n,t){return n.findIndex(e=>e.host_name===t.host_name&&e.file_path===t.file_path)}function rN(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return n.findIndex(i=>i.begin===t&&i.end===e)}function GE(n){let t=n.sourceCode.focusLineSpec;if(!n.stickToBottommostFrameInFocusedFile)return t;let e=Lg(n);if(null===e)return t;let i=function(n,t){if(null===t)return null;for(let e=n.length-1;e>=0;--e){let i=n[e],{host_name:r,file_path:o}=i;if(r===t.host_name&&o===t.file_path)return i}return null}(e,t);return null===i?t:i}var AMe=gr({runs:{},runsLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},activeRunId:null,lastDataPollOnsetTimeMs:-1,lastNonEmptyPollDataTimeMs:1,alerts:{alertsLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},numAlerts:0,alertsBreakdown:{},alerts:{},executionIndices:{},graphExecutionIndices:{},focusType:null},executions:{numExecutionsLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:50,pageSize:100,scrollBeginIndex:0,focusIndex:null,executionDigests:{},executionData:{}},graphExecutions:{numExecutionsLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:100,pageSize:200,scrollBeginIndex:0,focusIndex:null,graphExecutionDigests:{},graphExecutionDataLoadingPages:[],graphExecutionDataPageLoadedSizes:{},graphExecutionData:{}},graphs:{ops:{},loadingOps:{},focusedOp:null},stackFrames:{},codeLocationFocusType:null,stickToBottommostFrameInFocusedFile:!1,sourceCode:{sourceFileListLoaded:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},sourceFileList:[],fileContents:[],focusLineSpec:null}},ye(SE,n=>({...n,runsLoaded:{...n.runsLoaded,state:Re.LOADING}})),ye(jX,n=>({...n,runsLoaded:{...n.runsLoaded,state:Re.FAILED}})),ye(EE,(n,{runs:t})=>{let e=Object.keys(t),i=e.length>0&&null===n.activeRunId;return{...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,runs:t,runsLoaded:{state:Re.LOADED,lastLoadedTimeInMs:Date.now()},activeRunId:e.length>0?e[0]:null}}),ye(sy,n=>({...n,lastDataPollOnsetTimeMs:Date.now()})),ye(ly,n=>null===n.activeRunId?n:{...n,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Re.LOADING}}}),ye(TE,(n,{numAlerts:t,alertsBreakdown:e})=>{if(null===n.activeRunId)return n;let r=t>n.alerts.numAlerts;return{...n,lastNonEmptyPollDataTimeMs:r?Date.now():n.lastNonEmptyPollDataTimeMs,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Re.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e}}}),ye(DE,(n,{numAlerts:t,alertsBreakdown:e,alertType:i,begin:r,alerts:o})=>{if(null===n.activeRunId)return n;let s={},l=n.alerts.executionIndices[i]?n.alerts.executionIndices[i].slice():[],c=n.alerts.graphExecutionIndices[i]?n.alerts.graphExecutionIndices[i].slice():[];for(let p=0;p<o.length;++p){let h=r+p,m=o[p];if(s[h]=m,m.alert_type===Fc.INF_NAN_ALERT){let _=m;l[h]=_.execution_index,null!==_.graph_execution_trace_index&&(c[h]=_.graph_execution_trace_index)}}void 0!==n.alerts.alerts[i]&&Object.assign(s,n.alerts.alerts[i]);let d=n.executions.scrollBeginIndex,u=n.graphExecutions.focusIndex;if(i===Fc.INF_NAN_ALERT&&0===r){let p=o[0];d=Math.max(0,p.execution_index-Math.floor(n.executions.displayCount/2)),null!==p.graph_execution_trace_index&&(u=p.graph_execution_trace_index)}return{...n,executions:{...n.executions,scrollBeginIndex:d},graphExecutions:{...n.graphExecutions,focusIndex:u},alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Re.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e,alerts:{...n.alerts.alerts,[i]:s},executionIndices:{...n.alerts.executionIndices,[i]:l},graphExecutionIndices:{...n.alerts.graphExecutionIndices,[i]:c}}}}),ye(Dg,(n,{alertType:t})=>{let e={...n,alerts:{...n.alerts,focusType:n.alerts.focusType===t?null:t}},i=e.alerts.focusType;if(null!==i){let r=e.alerts.executionIndices[i]||[];void 0!==r[0]&&(e.executions={...e.executions,scrollBeginIndex:Math.max(0,Number(r[0])-Math.floor(e.executions.displayCount/2))})}return e}),ye(IE,n=>null===n.activeRunId?n:{...n,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Re.LOADING}}}),ye(AE,(n,{numExecutions:t})=>{if(null===n.activeRunId)return n;let i=t>n.executions.executionDigestsLoaded.numExecutions,r={...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Re.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.executions.focusIndex&&(r.executions.focusIndex=0),r}),ye(RE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges];return-1===rN(i,t.begin,t.end)&&i.push({begin:t.begin,end:t.end}),{...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,loadingRanges:i}}}}),ye(PE,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges],r=rN(i,t.begin,t.end);-1!==r&&i.splice(r,1);let o={...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t.num_digests,loadingRanges:i},executionDigests:{...n.executions.executionDigests}}};for(let a=t.begin;a<t.end;++a)o.executions.executionDigests[a]=t.execution_digests[a-t.begin];return t.end>t.begin&&(o.executions.executionDigestsLoaded.pageLoadedSizes={...o.executions.executionDigestsLoaded.pageLoadedSizes,[t.begin/n.executions.pageSize]:t.end-t.begin}),o}),ye(Ig,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e>0&&e--,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),ye(Ag,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e+n.executions.displayCount+1<=n.executions.executionDigestsLoaded.numExecutions&&e++,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),ye(Rg,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer execution index (${t.index})`);let{displayCount:e}=n.executions,{numExecutions:i}=n.executions.executionDigestsLoaded;if(t.index>Math.max(0,i-e))throw new Error(`Attempt to scroll to execution index (${t.index}), which exceeds maximum allowed index (numExecutions=${i}; displayCount=${e})`);return{...n,executions:{...n.executions,scrollBeginIndex:t.index}}}),ye(Pg,(n,t)=>{let e={...n,executions:{...n.executions,focusIndex:n.executions.scrollBeginIndex+t.displayIndex},codeLocationFocusType:zo.EXECUTION,sourceCode:{...n.sourceCode}};return e.sourceCode.focusLineSpec=GE(e),e}),ye(kE,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,executions:{...n.executions,executionData:{...n.executions.executionData}}};for(let r=t.begin;r<t.end;++r)i.executions.executionData[r]=t.executions[r-t.begin];return i}),ye(OE,n=>null===n.activeRunId?n:{...n,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Re.LOADING}}}),ye(FE,(n,{numGraphExecutions:t})=>{if(null===n.activeRunId)return n;let e=t>n.graphExecutions.executionDigestsLoaded.numExecutions,i={...n,lastNonEmptyPollDataTimeMs:e?Date.now():n.lastNonEmptyPollDataTimeMs,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Re.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.graphExecutions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.graphExecutions.focusIndex&&(i.graphExecutions.focusIndex=0),i}),ye(NE,(n,{pageIndex:t})=>{if(null===n.activeRunId)return n;let e=n.graphExecutions.graphExecutionDataLoadingPages.slice();return-1===e.indexOf(t)&&e.push(t),{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:e}}}),ye(LE,(n,t)=>{if(null===n.activeRunId)return n;let{pageSize:e}=n.graphExecutions,i=n.graphExecutions.graphExecutionDataLoadingPages.slice(),r={...n.graphExecutions.graphExecutionDataPageLoadedSizes},o={...n.graphExecutions.graphExecutionData};for(let a=t.begin;a<t.end;++a){let s=Math.floor(a/e);-1!==i.indexOf(s)&&i.splice(i.indexOf(s),1),void 0===r[s]&&(r[s]=0),void 0===o[a]&&r[s]++,o[a]=t.graph_executions[a-t.begin]}return{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:i,graphExecutionDataPageLoadedSizes:r,graphExecutionData:o}}}),ye(kg,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer graph-execution index (${t.index})`);return{...n,graphExecutions:{...n.graphExecutions,scrollBeginIndex:t.index}}}),ye(Og,(n,t)=>qX(n,t.graph_id,t.op_name,t.index)),ye(Fg,(n,t)=>qX(n,t.graph_id,t.op_name)),ye(BE,(n,t)=>{let{graph_id:e,op_name:i}=t,r={...n,graphs:{...n.graphs,loadingOps:{...n.graphs.loadingOps}}};return void 0===r.graphs.loadingOps[e]&&(r.graphs.loadingOps[e]=new Map),r.graphs.loadingOps[e].has(i)||r.graphs.loadingOps[e].set(i,Re.LOADING),r}),ye(VE,(n,t)=>{let{graphOpInfoResponse:e}=t,{graph_ids:i}=e,r=i[i.length-1],o={...n,graphs:{...n.graphs,ops:{...n.graphs.ops,[r]:new Map(n.graphs.ops[r])},loadingOps:{...n.graphs.loadingOps,[r]:new Map(n.graphs.loadingOps[r])}}};for(let a of e.inputs)!a.data||o.graphs.ops[r].set(a.op_name,a.data);for(let a=0;a<e.consumers.length;++a)for(let s of e.consumers[a])!s.data||o.graphs.ops[r].set(s.op_name,s.data);return o.graphs.ops[r].set(e.op_name,{...e,inputs:e.inputs.map(a=>({op_name:a.op_name,output_slot:a.output_slot})),consumers:e.consumers.map(a=>a.map(s=>({op_name:s.op_name,input_slot:s.input_slot})))}),o.graphs.loadingOps[r].set(e.op_name,Re.LOADED),o}),ye(HE,n=>({...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Re.LOADING}}})),ye(zE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Re.LOADED,lastLoadedTimeInMs:Date.now()},sourceFileList:t.sourceFiles,fileContents:n.sourceCode.fileContents.slice()}},i=t.sourceFiles.length,{fileContents:r}=e.sourceCode;for(let o=0;o<i;++o)r[o]=n.sourceCode.fileContents[o]??{loadState:Re.NOT_LOADED,lines:null};return e}),ye(Ng,(n,t)=>{let e=Lg(n),i={...n,sourceCode:{...n.sourceCode,focusLineSpec:t.stackFrame}};return null!==e&&(i.stickToBottommostFrameInFocusedFile=function(n,t){let e=-1,i=-1;if(n.forEach(({file_path:r,lineno:o},a)=>{r===t.file_path&&(i=a,o===t.lineno&&(e=a))}),-1===e)throw new Error(`Stack frame ${JSON.stringify(t)} is not found.`);return e===i}(e,t.stackFrame)),i}),ye(UE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=uy(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{...e.sourceCode.fileContents[i],loadState:Re.LOADING}),e}),ye(jE,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=uy(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{loadState:Re.LOADED,lines:t.lines}),e}),ye(cy,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,stackFrames:{...n.stackFrames,...t.stackFrames},sourceCode:{...n.sourceCode}};return i.sourceCode.focusLineSpec=GE(i),i}));function qX(n,t,e,i){let r={...n,graphs:{...n.graphs,focusedOp:{graphId:t,opName:e}},codeLocationFocusType:zo.GRAPH_OP_CREATION,sourceCode:{...n.sourceCode}};return r.sourceCode.focusLineSpec=GE(r),void 0!==i&&(r.graphExecutions={...n.graphExecutions,focusIndex:i}),r}function XX(n,t){return AMe(n,t)}var Ro=Mr(dy),Nh=W(Ro,n=>n.runs),oN=W(Ro,n=>n.runsLoaded),$o=W(Ro,n=>n.activeRunId),YX=W(Ro,n=>n.lastDataPollOnsetTimeMs-n.lastNonEmptyPollDataTimeMs),Bg=W(Ro,n=>n.alerts),aN=W(Bg,n=>n.alertsLoaded),QX=W(Bg,n=>n.numAlerts),WE=W(Bg,n=>n.focusType),ZX=W(Bg,n=>null===n.focusType?0:n.alertsBreakdown[n.focusType]||0),KX=W(Bg,n=>null===n.focusType||void 0===n.alerts[n.focusType]?null:n.alerts[n.focusType]),JX=W(Bg,n=>n.alertsBreakdown),Lh=W(Ro,n=>n.executions),qE=W(Lh,n=>n.numExecutionsLoaded),py=W(Lh,n=>n.executionDigestsLoaded),Zu=W(Lh,n=>n.executionDigestsLoaded.numExecutions),hy=W(Lh,n=>n.scrollBeginIndex),Vg=W(Lh,n=>n.pageSize),Hg=W(Lh,n=>n.displayCount),$X=W(Lh,n=>{let t=[];for(let e=n.scrollBeginIndex;e<n.scrollBeginIndex+n.displayCount;++e)t.push(e in n.executionDigests?n.executionDigests[e]:null);return t}),Ku=W(Ro,n=>n.graphExecutions),eY=W(Ku,n=>n.numExecutionsLoaded),my=W(Ro,n=>n.graphExecutions.executionDigestsLoaded.numExecutions),tY=W(Ku,n=>n.scrollBeginIndex),nY=W(Ku,n=>n.displayCount),iY=W(Ku,n=>n.pageSize),rY=W(Ku,n=>n.graphExecutionDataLoadingPages),oY=W(Ku,n=>n.graphExecutionDataPageLoadedSizes),sN=W(Ku,n=>n.graphExecutionData),lN=W(Ku,n=>n.focusIndex),cN=W(Ro,n=>n.graphs),dN=W(cN,n=>{let{focusedOp:t,ops:e}=n;return null===t||void 0===e[t.graphId]?null:e[t.graphId].get(t.opName)||null}),uN=W(cN,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{inputs:r}=i.get(t.opName);return r.map(o=>{let a={...o};return i.has(o.op_name)&&(a.data=i.get(o.op_name)),a})}}),aY=W(lN,sN,uN,(n,t,e)=>{if(null===n||null===e)return null;let i=e.map(s=>!1),r=[];if(0===e.length)return r;let o=t[n].graph_id,a=Math.max(0,n-200);for(let s=n-1;s>=a;--s)if(void 0!==t[s])for(let l=0;l<e.length&&(i[l]||t[s].graph_id!==o||t[s].op_name!==e[l].op_name||t[s].output_slot!==e[l].output_slot||(r.push(s),i[l]=!0,r.length!==e.length));++l);return r}),sY=W(cN,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{consumers:r}=i.get(t.opName);return r.map(o=>o.map(a=>{let s={...a};return i.has(a.op_name)&&(s.data=i.get(a.op_name)),s}))}}),lY=W(Ro,n=>{let t=n.executions.scrollBeginIndex,e=n.executions.scrollBeginIndex+n.executions.displayCount,i=new Array(e-t).fill(null),r=n.alerts.focusType;if(null===r)return i;let o=n.alerts.executionIndices[r];if(void 0===o)return i;for(let a=t;a<e;++a)o.includes(a)&&(i[a-t]=n.alerts.focusType);return i}),XE=W(Ro,n=>n.executions),pN=W(XE,n=>n.focusIndex),cY=W(XE,n=>{if(null===n.focusIndex)return null;let{focusIndex:t,scrollBeginIndex:e,displayCount:i}=n;return t<e||t>=e+i?null:t-e}),hN=W(XE,n=>n.executionData),dY=W(Ro,n=>n.graphs.loadingOps),mN=W(Ro,n=>n.stackFrames),Bh=W(XE,n=>{let{focusIndex:t,executionData:e}=n;return null===t||void 0===e[t]?null:e[t]}),fy=W(Ro,pN,Bh,dN,(n,t,e,i)=>{let{codeLocationFocusType:r}=n;return null===r?null:r===zo.EXECUTION?null===t||null===e?null:{codeLocationType:zo.EXECUTION,opType:e.op_type,executionIndex:t}:null===i?null:{codeLocationType:zo.GRAPH_OP_CREATION,opType:i.op_type,opName:i.op_name}}),uY=W(Ro,Lg),YE=W(Ro,n=>n.sourceCode),pY=W(YE,n=>n.sourceFileListLoaded),fN=(W(YE,n=>n.sourceFileList),W(YE,n=>{let{sourceFileList:t,focusLineSpec:e}=n;return null===e?-1:uy(t,e)})),QE=W(YE,fN,(n,t)=>-1===t?null:n.fileContents[t]||null),ZE=W(Ro,n=>n.sourceCode.focusLineSpec),hY=W(Ro,n=>n.stickToBottommostFrameInFocusedFile),mY=function(n){return[n]};function PMe(n,t){if(1&n){let e=Te();f(0,"div",7),A("click",function(){let o=ne(e).$implicit;return ie(w().onToggleFocusType.emit(o.type))}),f(1,"div",8),T(2),g(),f(3,"div",9),T(4),g(),k(5,"div"),g()}if(2&n){let e=t.$implicit,i=w();b("ngClass",Un(4,mY,e.type===i.focusType?"focus":"")),v(2),kt(e.displayName),v(2),lu(" ",e.displaySymbol,": ",e.count," ")}}var fY=(()=>{class n{constructor(){this.numAlerts=0,this.alertsBreakdown=[],this.focusType=null,this.onToggleFocusType=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["alerts-component"]],inputs:{numAlerts:"numAlerts",alertsBreakdown:"alertsBreakdown",focusType:"focusType"},outputs:{onToggleFocusType:"onToggleFocusType"},decls:10,vars:5,consts:[[1,"alerts-container"],[1,"debugging-title"],[1,"num-alerts-container"],[1,"num-alerts-label"],[1,"num-alerts-value",3,"ngClass"],[1,"alerts-breakdown-container"],["class","alerts-breakdown-type",3,"ngClass","click",4,"ngFor","ngForOf"],[1,"alerts-breakdown-type",3,"ngClass","click"],[1,"alert-type-name"],[1,"alert-type-count"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1),T(2,"Debugging"),g(),f(3,"div",2)(4,"div",3),T(5,"Alerts"),g(),f(6,"div",4),T(7),g()(),f(8,"div",5),S(9,PMe,6,6,"div",6),g()()),2&e&&(v(6),b("ngClass",Un(3,mY,i.numAlerts>0?"non-zero":"")),v(1),Ve(" ",i.numAlerts," "),v(2),b("ngForOf",i.alertsBreakdown))},dependencies:[wn,nn],styles:[".alerts-breakdown-container[_ngcontent-%COMP%] {\n  font-size: 13px;\n  padding: 10px 10px 10px;\n  position: relative;\n}\n\n.alerts-breakdown-type[_ngcontent-%COMP%] {\n  border-radius: 0 10px 10px 0;\n  cursor: pointer;\n  display: flex;\n  padding: 6px 0 6px 50px;\n  vertical-align: middle;\n}\n\n.alerts-breakdown-type.focus[_ngcontent-%COMP%] {\n  background-color: #ffeee0;\n}\n\n.alerts-container[_ngcontent-%COMP%] {\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n}\n\n.alert-type-count[_ngcontent-%COMP%] {\n  \n  background-color: #e52592;\n  border-radius: 3px;\n  color: #fff;\n  display: inline-block;\n  padding: 3px;\n  position: absolute;\n  right: 20px;\n  vertical-align: middle;\n}\n\n.alert-type-name[_ngcontent-%COMP%] {\n  display: inline-block;\n  padding: 3px;\n  vertical-align: middle;\n}\n\n.debugging-title[_ngcontent-%COMP%] {\n  font-size: 18px;\n}\n\n.num-alerts-container[_ngcontent-%COMP%] {\n  font-weight: bold;\n  padding: 10px 10px 10px 30px;\n  position: relative;\n}\n\n.num-alerts-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-size: 13px;\n}\n\n.num-alerts-value[_ngcontent-%COMP%] {\n  border-radius: 12px;\n  display: inline-block;\n  font-size: 13px;\n  font-weight: normal;\n  line-height: 24px;\n  position: absolute;\n  right: 20px;\n  text-align: center;\n  vertical-align: middle;\n  width: 24px;\n}\n\n.num-alerts-value.non-zero[_ngcontent-%COMP%] {\n  background-color: #ffb780;\n  font-weight: bold;\n}"]}),n})(),OMe={[Fc.FUNCTION_RECOMPILE_ALERT]:{displayName:"Function recompiles",displaySymbol:"C"},[Fc.INF_NAN_ALERT]:{displayName:"NaN/\u221e",displaySymbol:"\u221e"},[Fc.TENSOR_SHAPE_ALERT]:{displayName:"Tensor shape",displaySymbol:"\u25a0"}},gY=(()=>{class n{constructor(e){this.store=e,this.numAlerts$=this.store.pipe(un(QX)),this.alertsBreakdown$=this.store.pipe(un(W(JX,i=>{let r=Object.keys(i);return r.sort(),r.map(o=>({type:o,...OMe[o],count:i[o]}))}))),this.focusType$=this.store.pipe(un(WE))}onToggleFocusType(e){this.store.dispatch(Dg({alertType:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-alerts"]],decls:4,vars:9,consts:[[3,"numAlerts","alertsBreakdown","focusType","onToggleFocusType"]],template:function(e,i){1&e&&(f(0,"alerts-component",0),A("onToggleFocusType",function(o){return i.onToggleFocusType(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("numAlerts",G(1,3,i.numAlerts$))("alertsBreakdown",G(2,5,i.alertsBreakdown$))("focusType",G(3,7,i.focusType$))},dependencies:[fY,ct],encapsulation:2,changeDetection:0}),n})(),gy={19:"float16",1:"float32",2:"float64",3:"int32",4:"uint8",17:"uint16",22:"uint32",23:"uint64",5:"int16",6:"int8",7:"string",8:"complex64",18:"complex128",9:"int64",10:"bool",11:"qint8",12:"quint8",15:"qint16",16:"quint16",13:"qint32",14:"bfloat16",20:"resource",21:"variant",119:"float16_ref",101:"float32_ref",102:"float64_ref",103:"int32_ref",122:"uint32_ref",104:"uint8_ref",117:"uint16_ref",105:"int16_ref",106:"int8_ref",107:"string_ref",108:"complex64_ref",118:"complex128_ref",109:"int64_ref",123:"uint64_ref",110:"bool_ref",111:"qint8_ref",112:"quint8_ref",115:"qint16_ref",116:"quint16_ref",113:"qint32_ref",114:"bfloat16_ref",120:"resource_ref",121:"variant_ref"};function KE(n){let{tensorDebugMode:t,array:e}=n;switch(t){case Ao.NO_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under NO_TENSOR mode");return{};case Ao.CURT_HEALTH:if(null===e||2!==e.length)throw new Error(`Under CURT_HEALTH mode, expected debug-tensor-value array to have length 2, but got ${JSON.stringify(e)}`);return{hasInfOrNaN:Boolean(e[1])};case Ao.CONCISE_HEALTH:{if(null===e||5!==e.length)throw new Error(`Under CONCISE_HEALTH mode, expected debug-tensor-value array to have length 5, but got ${JSON.stringify(e)}`);let i={size:e[1]};return e[2]>0&&(i.numNegativeInfs=e[2]),e[3]>0&&(i.numPositiveInfs=e[3]),e[4]>0&&(i.numNaNs=e[4]),i}case Ao.SHAPE:{if(null===e||10!==e.length)throw new Error(`Under SHAPE mode, expected debug-tensor-value array to have length 10, but got ${JSON.stringify(e)}`);let i=e[2],r=e.slice(4,Math.min(4+i,e.length));return r.length<i&&(r=new Array(i-r.length).concat(r)),{dtype:gy[e[1]],rank:i,size:e[3],shape:r}}case Ao.FULL_HEALTH:{if(null===e||11!==e.length)throw new Error(`Under FULL_HEALTH mode, expected debug-tensor-value array to have length 11, but got ${JSON.stringify(e)}`);let r={dtype:gy[e[2]],rank:e[3],size:e[4]};return e[5]>0&&(r.numNegativeInfs=e[5]),e[6]>0&&(r.numPositiveInfs=e[6]),e[7]>0&&(r.numNaNs=e[7]),e[8]>0&&(r.numNegativeFinites=e[8]),e[9]>0&&(r.numZeros=e[9]),e[10]>0&&(r.numPositiveFinites=e[10]),r}case Ao.FULL_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under FULL_TENSOR mode");return{};default:throw new Error(`Unrecognized tensorDebugMode: ${t}`)}}var gN="[_nghost-%COMP%] {\n    background-color: #e3e5e8;\n    border: 1px solid #c0c0c0;\n    border-radius: 4px;\n    font-family: 'Roboto Mono', monospace;\n    height: 14px;\n    line-height: 14px;\n    margin: 0 2px;\n    padding: 1px 3px;\n    width: max-content;\n  }";function NMe(n,t){1&n&&k(0,"div",4)}function LMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",8),T(2,"NaN"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numNaNs,"")}}function BMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",8),T(2,"-\u221e"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numNegativeInfs,"")}}function VMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",8),T(2,"+\u221e"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numPositiveInfs,"")}}function HMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",10),T(2,"-"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numNegativeFinites,"")}}function zMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",10),T(2,"0"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numZeros,"")}}function UMe(n,t){if(1&n&&(f(0,"div",7)(1,"span",10),T(2,"+"),g(),f(3,"span",9),T(4),g()()),2&n){let e=w(2);v(4),Ve("\xd7",e.numPositiveFinites,"")}}function jMe(n,t){if(1&n&&(f(0,"div",5),S(1,LMe,5,1,"div",6),S(2,BMe,5,1,"div",6),S(3,VMe,5,1,"div",6),S(4,HMe,5,1,"div",6),S(5,zMe,5,1,"div",6),S(6,UMe,5,1,"div",6),g()),2&n){let e=w();v(1),b("ngIf",void 0!==e.numNaNs&&e.numNaNs>0),v(1),b("ngIf",void 0!==e.numNegativeInfs&&e.numNegativeInfs>0),v(1),b("ngIf",void 0!==e.numPositiveInfs&&e.numPositiveInfs>0),v(1),b("ngIf",void 0!==e.numNegativeFinites&&e.numNegativeFinites>0),v(1),b("ngIf",void 0!==e.numZeros&&e.numZeros>0),v(1),b("ngIf",void 0!==e.numPositiveFinites&&e.numPositiveFinites>0)}}var GMe=function(n){return["container",n]};function WMe(n,t){1&n&&k(0,"debug-tensor-dtype",5),2&n&&b("dtype",w().debugTensorValue.dtype)}function qMe(n,t){1&n&&k(0,"debug-tensor-rank",6),2&n&&b("rank",w().debugTensorValue.rank)}function XMe(n,t){1&n&&k(0,"debug-tensor-shape",7),2&n&&b("shape",w().debugTensorValue.shape)}function YMe(n,t){1&n&&k(0,"debug-tensor-has-inf-or-nan",8),2&n&&b("hasInfOrNaN",w().debugTensorValue.hasInfOrNaN)}function QMe(n,t){if(1&n&&k(0,"debug-tensor-numeric-breakdown",9),2&n){let e=w();Zi("size",e.debugTensorValue.size),b("numNegativeInfs",e.debugTensorValue.numNegativeInfs)("numPositiveInfs",e.debugTensorValue.numPositiveInfs)("numNaNs",e.debugTensorValue.numNaNs)("numNegativeFinites",e.debugTensorValue.numNegativeFinites)("numZeros",e.debugTensorValue.numZeros)("numPositiveFinites",e.debugTensorValue.numPositiveFinites)}}var ZMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-dtype"]],inputs:{dtype:"dtype"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&Ve(" ",i.dtype," ")},styles:[gN]}),n})(),KMe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-rank"]],inputs:{rank:"rank"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&Ve(" ",i.rank,"D ")},styles:[gN]}),n})(),JMe=(()=>{class n{get shapeString(){return"["+this.shape.map(e=>void 0===e?"?":String(e)).join(",")+"]"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-shape"]],inputs:{shape:"shape"},decls:1,vars:1,template:function(e,i){1&e&&T(0),2&e&&Ve(" shape:",i.shapeString," ")},styles:[gN]}),n})(),$Me=(()=>{class n{get breakdownExists(){return void 0!==this.numNaNs||void 0!==this.numNegativeInfs||void 0!==this.numPositiveInfs||void 0!==this.numNegativeFinites||void 0!==this.numZeros||void 0!==this.numPositiveFinites}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-numeric-breakdown"]],inputs:{size:"size",numNaNs:"numNaNs",numNegativeInfs:"numNegativeInfs",numPositiveInfs:"numPositiveInfs",numNegativeFinites:"numNegativeFinites",numZeros:"numZeros",numPositiveFinites:"numPositiveFinites"},decls:7,vars:3,consts:[[1,"size"],[1,"size-value"],["class","break",4,"ngIf"],["class","breakdown",4,"ngIf"],[1,"break"],[1,"breakdown"],["class","category",4,"ngIf"],[1,"category"],[1,"category-tag","infinite"],[1,"category-count"],[1,"category-tag","finite"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"span"),T(2,"size:"),g(),f(3,"span",1),T(4),g()(),S(5,NMe,1,0,"div",2),S(6,jMe,7,6,"div",3)),2&e&&(v(4),kt(i.size),v(1),b("ngIf",i.breakdownExists),v(1),b("ngIf",i.breakdownExists))},dependencies:[Ne],styles:["[_nghost-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        font-family: 'Roboto Mono', monospace;\n        font-size: 10px;\n        margin: 0 2px;\n        padding: 1px;\n      }\n      .break[_ngcontent-%COMP%] {\n        flex-basis: 100%;\n        width: 0;\n      }\n      .size[_ngcontent-%COMP%] {\n        display: block;\n        height: 11px;\n        line-height: 11px;\n        margin: 0 3px;\n        vertical-align: middle;\n      }\n      .breakdown[_ngcontent-%COMP%] {\n        border-top: 1px solid rgba(0, 0, 0, 0.12);\n        display: flex;\n        height: 11px;\n        line-height: 11px;\n        padding: 2px;\n        vertical-align: middle;\n      }\n      .category[_ngcontent-%COMP%] {\n        margin-bottom: 2px;\n        margin-left: 4px;\n        margin-top: 2px;\n        heigth: 100%;\n        width: max-content;\n      }\n      .category-tag[_ngcontent-%COMP%] {\n        border-radius: 2px;\n        padding: 0 2px;\n      }\n      .finite[_ngcontent-%COMP%] {\n        background-color: #aaa;\n        color: #fefefe;\n      }\n      .infinite[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),ewe=(()=>{class n{get infoString(){return this.hasInfOrNaN?"Has \u221e/NaN":"No \u221e/NaN"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-has-inf-or-nan"]],inputs:{hasInfOrNaN:"hasInfOrNaN"},decls:2,vars:4,consts:[[3,"ngClass"]],template:function(e,i){1&e&&(f(0,"div",0),T(1),g()),2&e&&(b("ngClass",Un(2,GMe,i.hasInfOrNaN?"has-inf-or-nan":"")),v(1),Ve(" ",i.infoString," "))},dependencies:[wn],styles:[".container[_ngcontent-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        color: #666666;\n        font-family: 'Roboto Mono', monospace;\n        height: 14px;\n        line-height: 14px;\n        margin: 0 2px;\n        padding: 1px 3px;\n        width: max-content;\n      }\n      .has-inf-or-nan[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),JE=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debug-tensor-value"]],inputs:{debugTensorValue:"debugTensorValue"},decls:5,vars:5,consts:[[3,"dtype",4,"ngIf"],[3,"rank",4,"ngIf"],[3,"shape",4,"ngIf"],[3,"hasInfOrNaN",4,"ngIf"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites",4,"ngIf"],[3,"dtype"],[3,"rank"],[3,"shape"],[3,"hasInfOrNaN"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites"]],template:function(e,i){1&e&&(S(0,WMe,1,1,"debug-tensor-dtype",0),S(1,qMe,1,1,"debug-tensor-rank",1),S(2,XMe,1,1,"debug-tensor-shape",2),S(3,YMe,1,1,"debug-tensor-has-inf-or-nan",3),S(4,QMe,1,7,"debug-tensor-numeric-breakdown",4)),2&e&&(b("ngIf",void 0!==i.debugTensorValue.dtype),v(1),b("ngIf",void 0!==i.debugTensorValue.rank),v(1),b("ngIf",void 0!==i.debugTensorValue.shape),v(1),b("ngIf",void 0!==i.debugTensorValue.hasInfOrNaN),v(1),b("ngIf",void 0!==i.debugTensorValue.size))},dependencies:[Ne,ZMe,ewe,$Me,KMe,JMe],styles:["[_nghost-%COMP%] {\n        align-items: flex-start;\n        display: flex;\n        flex-wrap: nowrap;\n        overflow: hidden;\n        vertical-align: top;\n      }\n      debug-tensor-numeric-breakdown[_ngcontent-%COMP%] {\n        display: inline-block;\n      }"]}),n})();function twe(n,t){1&n&&(f(0,"div",12),T(1,"\u25b6"),g())}var nwe=function(n,t){return{tensorDebugMode:n,array:t}};function iwe(n,t){if(1&n&&k(0,"debug-tensor-value",17),2&n){let e=w(2).$implicit,i=w(2);b("debugTensorValue",i.parseDebugTensorValue(So(1,nwe,i.graphExecutionData[e].tensor_debug_mode,i.graphExecutionData[e].debug_tensor_value)))}}function rwe(n,t){if(1&n){let e=Te();f(0,"div")(1,"div",13)(2,"button",14),A("click",function(){ne(e);let r=w().$implicit,o=w(2);return ie(o.onTensorNameClick.emit({index:r,graph_id:o.graphExecutionData[r].graph_id,op_name:o.graphExecutionData[r].op_name}))}),T(3),g(),f(4,"div",15),T(5),g()(),S(6,iwe,1,4,"debug-tensor-value",16),g()}if(2&n){let e=w().$implicit,i=w(2);v(2),Zi("title",i.getTensorName(e)),v(1),Ve(" ",i.getTensorName(e)," "),v(2),kt(i.graphExecutionData[e].op_type),v(1),b("ngIf",null!==i.graphExecutionData[e].debug_tensor_value)}}function owe(n,t){1&n&&(f(0,"div",18),T(1," Loading... "),g())}var awe=function(n){return{"input-of-focus":n}};function swe(n,t){if(1&n&&(f(0,"div",5)(1,"div",6)(2,"div",7),S(3,twe,2,0,"div",8),T(4),g(),S(5,rwe,7,4,"div",9),S(6,owe,2,0,"ng-template",10,11,jt),g()()),2&n){let e=t.$implicit,i=st(7),r=w(2);v(1),b("ngClass",Un(5,awe,r.isInputOfFocus(e))),v(2),b("ngIf",e===r.focusIndex),v(1),Ve(" ",e," "),v(1),b("ngIf",r.graphExecutionData[e])("ngIfElse",i)}}function lwe(n,t){if(1&n){let e=Te();f(0,"cdk-virtual-scroll-viewport",3),A("scrolledIndexChange",function(r){return ne(e),ie(w().onScrolledIndexChange.emit(r))}),S(1,swe,8,7,"div",4),g()}if(2&n){let e=w();v(1),b("cdkVirtualForOf",e.graphExecutionIndices)}}var bY=(()=>{class n{constructor(){this.onScrolledIndexChange=new F,this.onTensorNameClick=new F,this.parseDebugTensorValue=KE,this.TEST_ONLY={getViewPort:()=>this.viewPort}}ngOnChanges(e){if(this.viewPort&&e.focusIndex&&null!==e.focusIndex.currentValue){let i=this.viewPort.getRenderedRange(),r=e.focusIndex.currentValue,o=Math.round((i.end-i.start)/3),a=Math.max(r-o,0);this.viewPort.scrollToIndex(a,r>=i.start&&r<i.end?"smooth":void 0)}}getTensorName(e){return`${this.graphExecutionData[e].op_name}:${this.graphExecutionData[e].output_slot}`}isInputOfFocus(e){return null!==this.focusInputIndices&&this.focusInputIndices.includes(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["graph-executions-component"]],viewQuery:function(e,i){if(1&e&&Ue(gg,5),2&e){let r;be(r=ve())&&(i.viewPort=r.first)}},inputs:{numGraphExecutions:"numGraphExecutions",graphExecutionData:"graphExecutionData",graphExecutionIndices:"graphExecutionIndices",focusIndex:"focusIndex",focusInputIndices:"focusInputIndices"},outputs:{onScrolledIndexChange:"onScrolledIndexChange",onTensorNameClick:"onTensorNameClick"},features:[qt],decls:4,vars:2,consts:[[1,"graph-executions-container"],[1,"graph-executions-title"],["itemSize","38","class","graph-executions-viewport",3,"scrolledIndexChange",4,"ngIf"],["itemSize","38",1,"graph-executions-viewport",3,"scrolledIndexChange"],["class","tensor-container",4,"cdkVirtualFor","cdkVirtualForOf"],[1,"tensor-container"],[1,"tensor-item",3,"ngClass"],[1,"graph-execution-index"],["class","graph-execution-focus",4,"ngIf"],[4,"ngIf","ngIfElse"],["class","tensor-item"],["dataLoading",""],[1,"graph-execution-focus"],[1,"tensor-name-and-op-type"],[1,"tensor-name",3,"title","click"],[1,"op-type"],[3,"debugTensorValue",4,"ngIf"],[3,"debugTensorValue"],[1,"loading-spinner"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1),T(2),g(),S(3,lwe,2,1,"cdk-virtual-scroll-viewport",2),g()),2&e&&(v(2),Ve(" Graph Executions (",i.numGraphExecutions,") "),v(1),b("ngIf",null!==i.numGraphExecutions&&i.numGraphExecutions>0))},dependencies:[wn,Ne,JE,Q7,Z7,gg],styles:['.graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;display:flex;flex-direction:column;height:100%;margin-left:8px;padding-left:10px}body.dark-mode[_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #555}.graph-execution-focus[_ngcontent-%COMP%]{display:inline-block}.graph-execution-index[_ngcontent-%COMP%]{color:#616161;display:inline-block;padding-right:4px;text-align:right;width:40px}body.dark-mode[_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.graph-executions-title[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:5px}.graph-executions-viewport[_ngcontent-%COMP%]{flex-grow:1;font-size:12px;width:100%;overflow-x:hidden}.input-of-focus[_ngcontent-%COMP%]{background-color:#fff099}body.dark-mode[_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%]{background-color:#e65100}.loading-spinner[_ngcontent-%COMP%]{display:inline-block}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;direction:rtl;display:block}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.tensor-container[_ngcontent-%COMP%]{width:100%}.tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;flex-wrap:nowrap;height:38px;line-height:38px;text-align:left;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #555}.tensor-name[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);border:none;box-sizing:border-box;color:inherit;cursor:pointer;direction:rtl;display:block;height:16px;line-height:16px;margin:2px 0 1px;max-width:calc(100% - 2px);overflow:hidden;padding:0 2px;text-align:right;text-decoration:underline;text-overflow:ellipsis;white-space:nowrap}.tensor-name[_ngcontent-%COMP%]:focus{outline:1px solid #c6cad1}.tensor-name-and-op-type[_ngcontent-%COMP%]{direction:rtl;display:inline-block;overflow:hidden;padding-right:8px;text-align:right;width:240px}debug-tensor-value[_ngcontent-%COMP%]{display:inline-block;margin:2px 0}'],changeDetection:0}),n})(),vY=(()=>{class n{onScrolledIndexChange(e){this.store.dispatch(kg({index:e}))}onTensorNameClick(e){this.store.dispatch(Og(e))}constructor(e){this.store=e,this.numGraphExecutions$=this.store.pipe(un(my)),this.graphExecutionData$=this.store.pipe(un(sN)),this.graphExecutionIndices$=this.store.pipe(un(W(my,i=>0===i?null:Array.from({length:i}).map((r,o)=>o)))),this.focusIndex$=this.store.pipe(un(lN)),this.focusInputIndices$=this.store.pipe(un(aY))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-graph-executions"]],decls:6,vars:15,consts:[[3,"numGraphExecutions","graphExecutionData","graphExecutionIndices","focusIndex","focusInputIndices","onScrolledIndexChange","onTensorNameClick"]],template:function(e,i){1&e&&(f(0,"graph-executions-component",0),A("onScrolledIndexChange",function(o){return i.onScrolledIndexChange(o)})("onTensorNameClick",function(o){return i.onTensorNameClick(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),g()),2&e&&b("numGraphExecutions",G(1,5,i.numGraphExecutions$))("graphExecutionData",G(2,7,i.graphExecutionData$))("graphExecutionIndices",G(3,9,i.graphExecutionIndices$))("focusIndex",G(4,11,i.focusIndex$))("focusInputIndices",G(5,13,i.focusInputIndices$))},dependencies:[bY,ct],encapsulation:2}),n})();function uwe(n,t){1&n&&(f(0,"span"),T(1," Output "),g())}function pwe(n,t){1&n&&(f(0,"span"),T(1," Input "),g())}function hwe(n,t){if(1&n&&(f(0,"div",6)(1,"span",7),S(2,uwe,2,0,"span",8),S(3,pwe,2,0,"span",8),g(),T(4),g()),2&n){let e=w();v(1),b("ngSwitch",e.kind),v(1),b("ngSwitchCase","input"),v(1),b("ngSwitchCase","consumer"),v(1),Ve(" slot: ",e.slot," ")}}function mwe(n,t){if(1&n&&(f(0,"div",9),T(1),g()),2&n){let e=w();v(1),Ve(" ",e.opData.op_type," ")}}function fwe(n,t){1&n&&(f(0,"span",10),T(1," (Op info unavailable.) "),g())}var gwe=function(n){return[n]},yY=(()=>{class n{constructor(){this.onOpNameClick=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["graph-op"]],inputs:{kind:"kind",opName:"opName",slot:"slot",opData:"opData"},outputs:{onOpNameClick:"onOpNameClick"},decls:9,vars:7,consts:[[1,"op-container"],[1,"input-tensor-name"],[1,"op-name",3,"ngClass","click"],["class","slot",4,"ngIf"],["class","op-type",4,"ngIf","ngIfElse"],["opInfoMissing",""],[1,"slot"],[3,"ngSwitch"],[4,"ngSwitchCase"],[1,"op-type"],[1,"op-info-missing"]],template:function(e,i){if(1&e&&(f(0,"button",0)(1,"div",1)(2,"button",2),A("click",function(){return i.onOpNameClick.emit({op_name:i.opName})}),f(3,"span"),T(4),g()(),S(5,hwe,5,4,"div",3),g(),S(6,mwe,2,1,"div",4),S(7,fwe,2,0,"ng-template",null,5,jt),g()),2&e){let r=st(8);v(2),b("ngClass",Un(5,gwe,"self"===i.kind?"self-op-name":"")),v(2),kt(i.opName),v(1),b("ngIf","self"!==i.kind),v(1),b("ngIf",void 0!==i.opData)("ngIfElse",r)}},dependencies:[wn,Ne,mr,kr],styles:['.op-container[_ngcontent-%COMP%], .op-name[_ngcontent-%COMP%]{color:inherit;background-color:inherit}.op-container[_ngcontent-%COMP%]{border:2px solid #ebebeb;border-radius:4px;box-shadow:1px 3px #eee;cursor:pointer;margin:0 5px 0 0;padding:2px 6px;text-align:right;width:200px}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{border:2px solid #555}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{box-shadow:1px 3px #757575}.op-container[_ngcontent-%COMP%]:focus{outline:0}.op-container[_ngcontent-%COMP%]:hover{border:2px solid #ffd3b2}.op-info-missing[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{border:none;cursor:pointer;display:inline-block;overflow-wrap:anywhere;padding:0;text-align:right;text-decoration:underline;white-space:pre-wrap}.op-name[_ngcontent-%COMP%]:focus{outline:0}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;display:inline-block;margin-top:3px}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.self-op-name[_ngcontent-%COMP%]{font-weight:bold;text-decoration:none}.slot[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .slot[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slot[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}']}),n})();function bwe(n,t){if(1&n){let e=Te();f(0,"div",13)(1,"div",14),T(2),g(),f(3,"graph-op",15),A("onOpNameClick",function(r){ne(e);let o=w(3);return ie(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit,i=t.index;v(2),Ve("Input slot ",i,":"),v(1),b("kind","input")("opName",e.op_name)("slot",e.output_slot)("opData",e.data)}}function vwe(n,t){if(1&n&&(f(0,"div",11)(1,"div"),S(2,bwe,4,5,"div",12),g()()),2&n){let e=w(2);v(2),b("ngForOf",e.inputOps)}}function ywe(n,t){1&n&&(f(0,"div",16),T(1," (This op has no input tensor.) "),g())}function xwe(n,t){if(1&n){let e=Te();f(0,"div",23)(1,"graph-op",15),A("onOpNameClick",function(r){ne(e);let o=w(4);return ie(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()()}if(2&n){let e=t.$implicit;v(1),b("kind","consumer")("opName",e.op_name)("slot",e.input_slot)("opData",e.data)}}function Cwe(n,t){if(1&n&&(f(0,"div",19)(1,"div",20),T(2),f(3,"span"),XM(4,21),g(),T(5,") "),g(),S(6,xwe,2,4,"div",22),g()),2&n){let e=t.$implicit,i=t.index;v(2),lu(" Output slot ",i,": (",e.length," "),v(2),vb(e.length),YM(4),v(2),b("ngForOf",e)}}function Mwe(n,t){if(1&n&&(f(0,"div",17)(1,"div"),S(2,Cwe,7,4,"div",18),g()()),2&n){let e=w(2);v(2),b("ngForOf",e.consumerOps)}}function wwe(n,t){if(1&n&&(f(0,"div",24),T(1),f(2,"span"),XM(3,25),g(),T(4," and no consumer.) "),g()),2&n){let e=w(2);v(1),Ve(" (This op has ",e.opInfo.consumers.length," output "),v(2),vb(e.opInfo.consumers.length),YM(3)}}function Swe(n,t){if(1&n){let e=Te();f(0,"div"),S(1,vwe,3,1,"div",4),S(2,ywe,2,0,"ng-template",null,5,jt),f(4,"div",6)(5,"div",7),T(6,"Op:"),g(),f(7,"graph-op",8),A("onOpNameClick",function(r){ne(e);let o=w();return ie(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),g()(),S(8,Mwe,3,1,"div",9),S(9,wwe,5,2,"ng-template",null,10,jt),g()}if(2&n){let e=st(3),i=st(10),r=w();v(1),b("ngIf",r.inputOps.length>0)("ngIfElse",e),v(6),b("kind","self")("opName",r.opInfo.op_name)("opData",r.opInfo),v(1),b("ngIf",r.totalNumConsumers>0)("ngIfElse",i)}}function Ewe(n,t){1&n&&(f(0,"span",26),T(1," (Op info unavailable.) "),g())}function Twe(n,t){1&n&&(f(0,"div",27),T(1," No graph op selected. Click a tensor name in the Graph Executions table to view the neighborhood of the tensor's op in its graph. "),g())}var xY=(()=>{class n{constructor(){this.onGraphOpNavigate=new F}get graphId(){return this.opInfo.graph_ids[this.opInfo.graph_ids.length-1]}get totalNumConsumers(){return this.consumerOps.reduce((e,i)=>e+i.length,0)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["graph-component"]],inputs:{opInfo:"opInfo",inputOps:"inputOps",consumerOps:"consumerOps"},outputs:{onGraphOpNavigate:"onGraphOpNavigate"},decls:9,vars:2,consts:function(){let t,e,i,r;return t=$localize`:␟fe55f9b193ea20aae5b5635e68d9386503847746␟4955133740841299851:{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}`,t=QM(t,{VAR_PLURAL:"\ufffd0\ufffd"}),e=$localize`:␟baa460e2f2b857e26292b246fc18ae0ea9b5e537␟5556340343850165516: ${t}:ICU:`,i=$localize`:␟6aa75f627e0dc16150ef448464e0c857aaa0dc18␟5156712935150586878:{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}`,i=QM(i,{VAR_PLURAL:"\ufffd0\ufffd"}),r=$localize`:␟893476c2c421cee47663c9732fa41a750d3a73df␟246067053735162634: ${i}:ICU:`,[[1,"graph-structure-container"],[4,"ngIf","ngIfElse"],["opInfoMissing",""],["noOpFocused",""],["class","inputs-container",4,"ngIf","ngIfElse"],["noInputs",""],[1,"self-op-container"],[1,"self-op-header"],[3,"kind","opName","opData","onOpNameClick"],["class","consumers-container",4,"ngIf","ngIfElse"],["noConsumers",""],[1,"inputs-container"],["class","input-op-section",4,"ngFor","ngForOf"],[1,"input-op-section"],[1,"input-slot-header"],[3,"kind","opName","slot","opData","onOpNameClick"],[1,"inputs-container","no-inputs-indicator"],[1,"consumers-container"],["class","slot-consumers-container",4,"ngFor","ngForOf"],[1,"slot-consumers-container"],[1,"slot-consumers-header"],e,["class","consumer-section",4,"ngFor","ngForOf"],[1,"consumer-section"],[1,"op-consumers-container"],r,[1,"op-info-missing"],[1,"no-op-focused"]]},template:function(e,i){if(1&e&&(f(0,"div")(1,"div"),T(2,"Graph Structure"),g(),f(3,"div",0),S(4,Swe,11,7,"div",1),g(),S(5,Ewe,2,0,"ng-template",null,2,jt),S(7,Twe,2,0,"ng-template",null,3,jt),g()),2&e){let r=st(8);v(4),b("ngIf",null!=i.opInfo)("ngIfElse",r)}},dependencies:[nn,Ne,yY],styles:['[_nghost-%COMP%]{overflow-y:auto}.consumers-container[_ngcontent-%COMP%]{padding-bottom:5px;overflow-x:auto;white-space:nowrap}.consumer-section[_ngcontent-%COMP%]{display:block;margin:5px 0}.graph-structure-container[_ngcontent-%COMP%]{font-size:12px;overflow-y:auto;white-space:nowrap}.inputs-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);margin-top:5px;overflow-x:auto;padding-bottom:0;white-space:nowrap}.input-op-section[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-bottom:5px}.input-slot-header[_ngcontent-%COMP%]{background-color:#fff099;margin-bottom:5px}body.dark-mode[_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%]{background-color:#e65100}.input-tensor-name[_ngcontent-%COMP%]{display:block;white-space:nowrap}.no-op-focused[_ngcontent-%COMP%]{color:gray;font-family:"Roboto",Arial,Helvetica,sans-serif;font-size:13px;white-space:normal}.self-op-header[_ngcontent-%COMP%]{font-weight:bold;margin-bottom:5px}.self-op-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);padding-bottom:5px}.slot-consumers-container[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-top:5px;vertical-align:top}.slot-consumers-header[_ngcontent-%COMP%]{white-space:nowrap}'],changeDetection:0}),n})(),CY=(()=>{class n{onGraphOpNavigate(e){this.store.dispatch(Fg(e))}constructor(e){this.store=e,this.opInfo$=this.store.pipe(un(dN)),this.inputOps$=this.store.pipe(un(uN)),this.consumerOps$=this.store.pipe(un(sY))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-graph"]],decls:4,vars:9,consts:[[3,"opInfo","inputOps","consumerOps","onGraphOpNavigate"]],template:function(e,i){1&e&&(f(0,"graph-component",0),A("onGraphOpNavigate",function(o){return i.onGraphOpNavigate(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("opInfo",G(1,3,i.opInfo$))("inputOps",G(2,5,i.inputOps$))("consumerOps",G(3,7,i.consumerOps$))},dependencies:[xY,ct],encapsulation:2}),n})(),MY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["inactive-component"]],decls:54,vars:0,consts:[[1,"container"],[1,"title"],[1,"code"],[1,"arg"],[1,"exhibits-container"],[1,"exhibit"],[1,"screenshot"],["src","data:image/png;base64,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"],[1,"description"],["src","data:image/png;base64,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"],["src","data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAATYAAAE2CAYAAADrvL6pAABKonpUWHRSYXcgcHJvZmlsZSB0eXBlIGV4aWYAAHjarZ1tluW4rWX/axRvCBK/ORzxQ2v1DHr4vTcjs1xVtl/7rW6XqyIz4sa9EgkcnAMC0LX/9//6rv/6r/96SmvhSrm20ku5+V/qqYeXP7T753/9/Pe50/nv+V8sv/70/PX71x8/CHyNvvLnB/X9+fq8fD//4xd+f8Yz/vr9q/36SWi/3ujXD3jjnyvwk/3z+vNF8v3w8/0n/Xqjvn/+UHqrf77U8euN5q8Xnkv59W/647J+vvj36y/fqKzSynxQDGHHJ97nv+nnCuLPvy//1vPfwOueGPnzE9t1vvy+JRbkL7f3++t9/3mB/rLIv/90/X31//jT3xY/vL++H/+2luXXGt3lX//gyX/7fvzjY8JfzOGPKwp//cEY6Z9v59e/37fa9+2fu3tTYUXLL4s6i/38fhteOFjyeH6t8E/l38yf6/mn80+733uy5eue9+Cf+fQnsCvf9aRnPe/zPft8nc/kElPYofI1hBni+V6LNfQwo/uU/Of5Qo09rtjYyxn2xfalGP64lud8bj+fN5/GJ6+Hl4aHN3v4lX/7z/Xf/fB/8s/1fdMleu72x1pxXUG75jLcOf/Lq9iD5/u1b/ks8O9/fm3//Sf7wVTZwXyWuXGD7z1+3mLk5x+2Fc8+R16X+fqzyc9V1683YIn47MzFPJEduMsT81Oeu4ZQn4d1bGzQy5WHmMJgB56cw+IiQ4qxhKuGFvxsfqc+57UhhxL8NtjERuRY8K3GDr1sVkoZ+6mpYUNvjjnlnEuuuV2557fEkkoupdQiyL011lRzLbXWVnt9W2yp5VZaba319vbQIxiYe+m1t977+4br5YNe3uvl9S/fGWHEkUYeZdTRRh/vxHxmmnmWWWebfb4rrLiAiVVWXW319e7n2iDFTjvvsutuu+/3w9a++KUvf+WrX/v69/6xa7929Z/++R/s2vNr18LZKV9X/9g1vnvV+vstHuEku2fsWEgPO17dAQw6uGd3e1IK7px7dveAU+TARWb35lqPO8YWpv2E/D1/7N0/du4/2rcrt/9o38L/becut+7/x85dbN0/79u/2LVlnJtnx3680DW9I97Ha97AFX1jffy1xC+/8avj27NuYdIf/+c/vV7vZ7/14V7Lu+pTc0ilvWxuHJ3LGHPiV2lEL2W/iZeMHdLXWny5g9nWM+89rjBnHLu2J+86dsxfe4G6b+y1V54Je9qTz1q132vt8XAfM+93jTVCGnzuE/oMqV5P460m64X13XvXmQY2sL+Y7/58Ne368LOY573mHp3tHPUeT8pjs2OA/8suYlTXTKLVs+aqL8Qkx014fdfLOnQuMeTBnlbWJ4zSAfY3z/qNVN/wLSxrfiXOXEe6IDV13ixGbQmD7kSZ3sv3sMFf3SzGHPxxxa/NL9xcnv4zoCF18q6xzoBzzq9dbeWS0mKdZr5HuVsP7PscQH7fq4U1S1xhrPtL+VsY0Fz4QY95rxpq3yWwESmXq7SHPflq5uaMN+u72YzO69zYf7P5z8yrcTHAQSz9u0cq1zDgxbuUtQawwq2FuPEjDBOzjWsUtjlyKXPE/PIJBcd/B5+846hcyoMh8GvXGMeq/juL+xc/m6WMWPaY8cOp92zfFdYqHfeOibDOPWMbKUxXpsc2V/bW1j63+XwvYP/HW2MtIbAhRPr2fBeh/QF9FmCCKfW5ucf+xlAx4meXwXKX8RU+vRR88yPCYyftTfebWnt5T8x9rnW18uUJiH3HnMqLDX7/7gq+fvPir6Vvx/pxQTGNsHtboOP1soP8tXwRAMK7uUpQDN8HFUbnfnMAScSs2OV+77NebCAaBRf/5o9X769eUh4uvtfvid/Z/f01XeFli2rBWp5Zguay84QmLjxk8/6sIeyGT320lTBhtYSTxIckPQx3/Paj5w5saoRnvPVjK7j+Y5cdMK6wBRcu1dbfL/LhkXe4NlG6l8aODugSK1RT+bBjXjlHL9t7XvyhFZakh6fnG2sLKQfub7/S77rG816pjFWed/IpgGtvBAKwGON/8lvzR+BvNU7wlL/OAz4zpxb3yCzMfjTHcWNU18M9VZz0TbM27h5He9dREJm9lI7JLlLA10JgJf+dyV7/uT0/XvHKGw4XJjfNBRciT+cepDU3xjeBVTxaOlpDwTKJrvUtGyNs7y7lG4DAgpDlcvfRimvERY9KGJ1VTHoHV9QzVDEBppOQprkWPrTzyg1uwnn4//eyirENYJKV4p750zD2ATvsyVpPv8rTdLWONQJQfOJu8dCuzXs9hC8CYkxExMdPGRu8igRVImkpsd0E8/RiGvta/U45go+dncenS8ZQHlyrPx18YJ9m5BcqccZPWqW+Xwt7EjIn/sRvbaIAcY37wFrZ5kBEXunexM/+eNsviAOyDdB114JoWkDDA0ZhMc/gd0dq/T7sG++5QOFkVDWCDYJc21Xkxei+AtBkQhPocE+C/iD+s7J1Pjvi9x3GUx9Dzq45XWPi7vEREMDYxkJy+bzlnAT+GrmiMcqzuM3b0AQRgOh8HSwB/iN+GSArfO9K8SU8chv8zSUhqmC65dkpG8bAJVZ/84tn8TGLlgFrIxW/jzklsAEyEa+RFosOQI6axShoFPzq/naAOsC29odYLQNCRdQjXozAHcAiqmja0iIcf5N1uzZOCIZFSEeqwD6UY0lCptYDjESQsS8iTSG4VjCsNL6uvZ8JfMSVhbEvvVdJa98gwd73Owi3kWCeXuw8Ay8f7/HtYpC5U2ElZ9vIcbAK/0OLsVvYPpztJkC+hOQbupd0pzuvtUIm3L7bCwUESsz5WblBHOuHS3PRmMKQJRLSYDEfsBHYNRy+lwx29lstBbziQRvCxwdjfdAUGCAxzUWFxLVaCOFjA9DgxQfdZHMJJRe6zHCCzRPeIUh4N5fP4sP1QHZ43s0NsU4pDaImdnALBjKn/v5cFjeW4xUyRGi+HXLYC/6CxAKVcCP8jhshqOZnvwTmsDb2nEDViTMQZe/aiX7YKJav8IvQxg5m94F5YEz3B9oAG4mL78Aw9Kjg3UR0dh4EZ3XenNhZ3pdbxWT73ntdS35BNAoYd4sDz3g7LvpJA/AaKBZvgBMX1n29WMmcHdbRcyCYJSVW5Xd6vfSeRPgI8BtC9audwCgmuA6lI/7cB/WQBkAMZBK+WN5QFwqh5AFY1c6PBm/UePls3nXiVrEMpCB0no1DX1eMIxvneoNJggELrc6aakubVXlYl4VlBQIkbMrNTc0dRcekGghoqIc2c+t54okTMwAuQAbee2E1i1D6QMYC0gCqSeRYF8yumSKAjqUqHiBIcA55GVEwsZRQpDk/sG+xIYSrCU0BR3ZuWgpsYcL52DXAvGvKPUaiAwIKlwWpWHPzPfwWVBNkjtAwTCOWb75gnot+QhWvwKnrvnrCm9YL2zTyPTUAzIQL4DJkdAWXDgqhPkCYZ23eHRwBaNxq2GrqOAg7eoPZgAh4DuJqhvdTjTNqsBcJXTDCRHR92MDpZwgON2E7w8pBawIzDloD4HoB5HCLUDJ49QbWCxTiAon+yADs5e2wi/KCnEQXjHb35x4vCxzBUoIIW8rWoUWgr0Qb/HONpBWj/1ixTuBhY++pz550GysERtxw5p4jITdOIhiUAEJ8A/IQrSeVhYYJQjs77H2+cCQuGX8kHBC8OziFHG0hJcIsYVMgLtgvUqUSP9UMF0Qpju8uHx6sWgnzYzHnU8Hkr+cKxzdSATyTDYIkTrbugTACPBWTfrGrhG9eL9HKP6JM+RNGUJP+6y91biXBs7iqgJ4C1AHLhQRCVgSkTJQ9Yke4LNQPvIkdJoCOilI5CdGAk9UXhI4EKZx8+8GGOt8XqpbCy9oDU5CKypK1WceFfUwYwrcCohX93RMsEH7oTsAE0bm8AQgwCMPpUbRB0I3FL6QEnIa0sMt3vdAk30NchKGypHDaJjXet1IbU+qTi9k9ZJgf9Pg1jHkFEzKGG6KF77Ih1wnhR6j1piDjjSUOoNINFBprByGO/+BZesz75c51FRTlBolbIOJl/BpJx1ZeEcv+jI13l4+CwoEY9LK2REVeyJ0vTN0PYVMJFx2TawgxgjOYixHtPICkC7cYH+8P4n1LTf69N06vjgTmUmhgC4uHw4Eo2CTOAgED6iBVnwuGRY/8tgs0jHshBFAFDfcNmEr2cxC4i+BuKqyz6gMn7qAQwZNojnc11SvmGHC8uHERXgkMbsxG5MiGYQJQfkt6ANe34VHNnWcNDiD1k1ZE435vOzFp4jAD4cfHshMJwhJg5TAFFuf81gA8MCeDUdsGIly5JxOaIxLp2DswCskMnsB8LvgAfJx9NwoMwPreIN3NvRC7MeMXO4bETpYfPv6Cg1wFi8V11wTregsb2Ua4ZHMgBaoeiWsuFaNJXLM8pBNp9tEomMeICeD7yrGzl6VlKTE/SDZLP5EQgAvk+NXjl2ZG4AdloBO4SCVSwfiIIZV/v/5EMzRIiUeXJmpOBd4IY8zrTRg8kQW+zW9XWGE0RTJCx4eJEgAgdwHyfFN5XzES1P49sFzo33oEQZYlXy0Z7DGL73O7IjIcTcl6vQCIv04UbkZofiWPD1I+EySBeAPHbfzpXQiJHS50YM69w2vL/gy6BPPKVvxaDhcjEYhQib2bgIACszhPTTdRqbG1yAQWtJlhf/g73xXHS5ABbKQs1o6jCOyAUiozebAwETVfRg36SYg3KG3JN+vNG7XwBNjd4HKI+MAPcaki5HBtDDej+9gzjGKYMMTJiAAg2534XFkN/CGGhcVdE0veCk6k5bciK/1zQdyElyTqHa725UGYQDHzuZG/onpB5YrSfRCTfUNGYdY3nHPIZAJyD/6cXzwKBonPcSPAFZrPe4ZVwjjGqMXwSiR8NPDOxSCzqvD5r5aVgIiYRJMURD5e8b4qPvi7F5MC70cobxgpkpArYi+hKYqLpd8k4iN3+mHpkKqgZsm5hHPklXlv+IqZtI478T2E229bv/7pQhAeKPBzJgFSYY6sCOxtC3h3AKID2ijeRllW+8GLHiRRuvhl6TucK+JVhIYMOUIOQDUKZP8LLMhmlXBsyDAhyjwml7/+tjvX93tzcNEcDjvmDbihnROOj/aRfkc2CyZ1CGDbkDFwFxSqK5vUK19ZF/rmIRwT7LxTj2ZMFWf2Fib/nZM5KBwoQHjd3BZs9g9z/cdFsUbbK68ZK/lu1E8wzO+h60K8wGz8DVnReK8lr0VaxNdML6Ru93Gb6UWWhnjBfFOrpsrUZVkUhXGEof39q08mZki1TX+iLYAa+XJ9uKJ9m9tmHWCFHbqyZiDWoLiAfCzHCAdYYqcmvBFQD3+Dt2bsGV4HqQan0KkQ9g4TO4mntyJCS/w3V8IK6LGxwjhYrFANf8p+IBUyeRGuCtETMYVA8JR2m0MC89+B/X51w+agKOwOkfdO5uKWymigBAvqLGgK4M51n8v4/uyof76Qjz0G9pCxjShC7MYPwR+2FOWNr/D+cPTSG8CGVmgNJXt/BVYG+0PBhyGhBNw7ITPBAGWqRP/xqo0gaZgY4P7eADikATVy7eeFtu6t9oJOQc4FFRg6vPrF1MGeXT/E+gPqpg9WhtSFgAO+CIeZ3IsKxF7QQeL1czwjm3ssCMiCeqvTo5S4hzkn2Q1vnDo6HVokhqsLwTTC2AMD2RehnsWAM3So2wfthyZAGD535Xn5VaQlwmumwm0QNMCFCD3CNcvu7DMeDUyOZj77hx7h5NgHUtIs2DsViIbKbCoaVp0CMah5jAP3fTFLeBUEligHP+SSL/UulkzQ3rfHHJAOUCx6qty0cykAersXkyUTGBz/GgavhGQ+ZwPlHFinQ//QO/DBV/kHcGWcAdnU4G4gazDB4Q7yljBbrjdr/3g/P2L1kW9msBASY6FYRM134ZKYDfsiAQEvCSd8CjsPi3if20TIRGs8xOzrg/3ihqBPWDCLYWoMANvb7BbLSpyG1SCQQF5AGCdpGyf/zLmiTJ/2Fc+uIFq/TvmFrMdfOBnxyWVLW7DviVEikeDxA1WFm0XshHUB5zBrNMGE1m6PMwhRYE0zw5nQHezaDVjeIBNvjA757p8U74RjLPOk3Pd4bu+fUBRZ+vTGcvklv8o9InBP6A+pJJvhkVhBIxdThBDegxBQNqJkIAiGj//4nTtj8N++VLrfCbXw54VBBROiGwGA5bNlvC1vTOAJCizTcYZ0ogIB7mNlZQ4vtg8egYVQQS4+eKbNdiDcCasDBzRN5BF9N+WJVumHPRV+BMi8T/mMfql51C0befdEWw+wrnkwAy0E4wlhDxwTi0DTWH4w3EvoYz/ZHRV2B7wzeI2wN+nrYkTPr5Q9ipXF/zKMinj/IgMBXWxptiZv73jjo/GCaWyfKQK2c0ETL6wNIbonuxXDAJmO3GkRhtFudriaakVJ85Y38SSZRMdAuFzIU3xuXm+eZ14maj0BwyaA/cwOssqmGEBSLn1gGbeHmhNGUQMBCUbKy7iU0RVjNcCSAngEarksmdXAIVj3CnSjDJI/xcyBTGQzO6I8B52R1dy4aGguK3dAGkBo/WLVokeqss9sDu4xVyAPUGW+z8R+sfR1ksEpn3OuAFA0z4V0jqmSe+KBEai/0oV1YFfLB+eDPYMWw6QFwQd2jIwbgNs34FqLHYMIRYTvs8dkj+HR14KNNc2dT9CbH8wo9C946NWM/+IsscnrJKBDLwLXNF5onmeBhIZBnOrJzOiRzgM6RhDk39iJc0hoEx13rHC8WabWvW+cBTh7MiTZ/DrxIRHKsDdCdoNY8RVHKADz9qzQQ8e5IANQ/O+clj4BGYB8RI48ARTngrEn3ByFjRDbrPiFq+UYAWhCTZldowwv8cjM2F43l2C++b6Jt81cXs9nfYgoA0YIPgLsQNp3efztSTBG0HCb6aHWLJ5wuki7Rs+8AbSHT4WDZUTpjScXeYfpXT4cWCxgNpu1c4QVEsC5a6ydpRv6gjowPmq8knEJNADg4nnBB1OQqd0InIDYAsm/q58jMNg0PgjHwO88qnjjS+wJUB8wCg7XIJVQHUDQOLl2nh0HnazfnHxa7dZE+KXiZMEcjwoc3v6kKkX6CBALFh1MsWWuAlT99ovp4AbfIpRg21gX6Hvl0nNJrYsBH/x+mUgz5nxoHogVLGsS3yswhgxhdSqLFE50ckssBYBA1+fiM/OTQCTIDPjJdXsYiD29tb1cUoQbwuXPgcOQy6AFcytmg7cnuR9Wh6yLvBG8CRabMpH9PWwHO5dQB5T9F5I6KmMdkxg/CZuYHavJHsN70LYYo6xmsmvfnc08YKFpHAT4ILEsFR/VNvEPs/9kh6wKOrOhPzPW4WFDfWDxeDnsk8VO7gX6EwaSYWa+cUlR8XtzSWAqXA4XGcrewd3k7nEQ77mQ0O93kt+s/cVGJpOkkf801haVQcSIriEOzJ5ixCw8zGMcdc7mBvVSvNELj9iNC/Mp2NEDS9kfYQLW0IEmNIeqHl4UjKTbsybQtN14WItYK38DqTIbWGckJmQzOJc6enq4bV1TzPLiDjRX7NwETUoJO0LachmIfFnFkqFGkwOtsxz3SoUPvgjdcAsUyklDwTAwNy7VE0+WMJ6DG+Jsgw1zf6sQusfN9d+fmsLjzGzKflzKQcB/Qy9gJ7D3iea2kqYAcuFQAhz3y6YoP09cf30l3DeLT27Yygt3voJOnY39hI5Ugp8FyuQP6s77wiLxB4H+eVjogo/ib3w1iJuPBLOJV1h28Iv5WyI7saiuTrA+BRiyvmaxgWyWWIbQRgghzl5p5VgQmmXUAsshiVfPppotZyjz3mb5ZGKygQQ/AhMAX0Se/s5tTEIHEWcrNWGPOW00H0HrC9fHvWYiDBbvMXD7zVluS49+cRYs8JAWv/6mLYh5/Izl/34Y0OV5EJdrjUzGVq2AyIqQLnFqP5UR6Bze3+NpfAU4+/WDX99mO/jBZdVqOnUGeEo3kfewycSjYKkSzrJY0YDdAOlw5KVT+xPjnZw6QQuQ3OkCQaLRk9jmAcNM2XIlwjYUtv2cSSSDAzH8sW4l+doJnnvuFst4T6VJwtegTSVsXq2cYy8NRdwfF2/QQgdmeAgumM38RejJhKVHVwl7+9QpiAbzkIsYIOhEM/taEuoGSME9VOsep7LNg40IrAXhXm4FkrHqnqxtDBz9BB6h9EHC4AnIUj19oSVjGwoCvGietd0VrujB7Cs30E/efFsTgT5CT8YxPYLuUGbc4gVyI+ov/Nb6ZiwJZ4MYWcw4xWaVIjwhn+NwZCfil0jbQXYo97pYfggk5AnUJuKBDoVYAHsYagresHl+DiyW5scBeFhwSajTG3OFE8wP0vaua91cEiIdcK4pvqaMMYLCBsCX2P3jJADL10XmAMgRCDcRgsuHfSWJ2gIuLgt7IKe3CJCe13wjvjbUCp4aqhLZyjpZJjYeQNMeu0kEzwq4dzZ1LewI4ZVbgoRYVQbP3dCW5f2gQRcXkzyIAwdxV/QM1MlUTAgnSnbPkvBsDDxcxIluLugG/kCNeJLjryI/IBpZvVcjmM3ggkyTI4VzNvmybcCFrKSyINfRd6g1BFEqT0qYx4Cdm3j1vByuZCGJlHatDwGRcFHrbKZVXNGjQeyJv18eFM7igfXLCyuYg5582FwQFvkLuTWBg0IpaXJ/cIt8vx60bj0zG9O7SdfruSXjaE9M7+3qcGT9nntCLKzVYg8CbxPuUaflY00rGpiAFRgEBTggai7Aj5TCViX252Y9DSXE7IZy5BfhJ54xEm2I1NE1h7EHawLwjAIp+F7vBv5aLjaPxSdAh6cvrMLjuV86z2RpRet8eg8MDPa8CHCsARjSIA4xntShZSPzMtewPlQCWDgtlUisMk6VwZNQLC+BuRPA8ps8IwCNR3ri1ug9o0Jye2yd+2XVmjU70CPIQmFhkXgxwm1aLO7IPOVRrDu8FDK4grC05b78g6S2/qL171IZnmz6tKpkekqHCsEisPbaMiCD7xKT8WoY0IhGGSL+YzURTIRVg4vw29fDj6As0NEGu1+o9KP9PzyYy3yQc317wKWdNeQTsodIIiMR13F/lCoWvK8ydrvNaYEGXPCG0zZPX96Ap2Yr1mBmWBp0ylMmgiZuisQGKwZ3+p1jPmwcqIWAFCBn4DSSK1HZPIWnaQ+h4UPyWU7SMP/k0WgldOHuOxdUB3t/d0jAvE42B/fS4MDZLxD4Jlpye7KN8WYgk4iAmv3wKIgr8dwCCfYiW511EzoeNNpF8J4PSJHQ0F5kxKPjB85jDAnRAuN59cJDY15PgXB9hMs85YHEGeBC2LhqhfmD+Oz7SqwvhJT1jE+c3708Wue9EadVs4JhGdC+U1h1kty9KOx19CtCMVXEpZtiydY2A4gm1vsA7Voat/k24ezTxhvG3ixXwi8JZMNyO24nXEQf1L5HL+YfeVt8InDNCOfQBuuZVSjd0+iZwk8d2wxAyMO2z4gfHZHbMEhCCtzHYgFYTFvN0mNC1SL2ViUOuLIHjNrikw1fSwZiYt0H0CowuYHArRGwYBEBsnvyleaMuZzHcl9WelqISxytw0zHnrn/8JZkaYFHIOM7osjDTHD5ZERY0fMVDv2NMHIA2YiMh218YD5s62RnWMnztcJ34K2Q5GDRHero5w2aqvpwEWIFHCT8/ODP34ZXEwweZDi0LCNFE2w7Aeg3WEaABPII++iXB9CKyYNKXNyTSciJuRTEZxjwNYvZiZZEbiBZo0k/nCmz3595SFPXVuATYqEDEMgW8Q8zw5D/uAiY4ZX5VigTdmoRT8Aipb2gKy44ZuaKCHMA6iufH0b7YvEOYe9Fz2GcgMHOlinwTlCA5d4Qc9NX3l09+QVDCQDxarCohk5A7vKGj3mKlw/HeODlnk9+fgpy5z0V3HC9YgUMuBWhLVkjBBgGeIQNV9ADUWPJiQ5H+MxQ0UWc/zwnhPdgHcXcRRECiTFrYXgEqRuHRvPixlcNnjKhBIgzsmIQGJwwc5gsvHzhiMP1gLv4ZZ38BTc39/ZI5yRHalwW6GZMHOWwMnaDGOJtlfyYJh6I54lrnm9ks1c1Hck7X15iEaHJ3L4TF36xmyxky3B7AJWwV4CQDM+zBo8QoFKKCCIP8r9dz2k6oihZMotVgFGvRRnzQp6475mwljaMoignPdv4uvKdLQHKSucjUrf20vqSGy3AlQHjA5pkzuZNOG30HV+PejeuT3TyyJ7w00MFo2AcjU1m//kKApv3BdS9KStVLJf0iCBf+SlWVuLVZhCx53mDqAU/gYdbQW7efptOWNXaM6v2Tf4s+SrUCmqQiIDzgpWWbXEZsSyKDp2VG3wGYT6ZjK9f5dVdhWNtwcZM0SKobnhvDB4AwpFDvN5H/4GeI+zFSU90XWggTSpHeAkh5Bt05h1domqlFtwUiEP3YaHqjVQv0yLFnpUveoZrwhhv+1DB8OwMsC57ixDq32uldit4bJFoKTFmy8SIOU2yeOpcLRxJ1oyqWZDVqkZW633MoirdcOBs0cBjwkOrT5/tDnyG9SoQjXhJaV+2We8CmFs3tXBbV2dxhpWPeLF5SnMY1VDHdqNMsaF9J6QJEheXbNjRSbhmONtU7rJ5sDri4/QkZXlYhfhA5QH9w3wVovSzFSF8CvlqQodXjMs6lTZOq48x1Co/UM6KGqTwub/NlXODy2agRBhv5i3R/jaNQFbOr5d2HUjr1sT09/EM/xRXnaQjMRD+1QjgXHALnu/BsORtuBDrV6ymzycfcpdL/yDG4ZVJbc/VECp9O242ZQFg5IddsR6MOIeEYYkw6BiyroQvhJMrujywxgC2x6ZFaZUs9kV+cuGbWBHb9ybPuoq8W8e77ZRBEcJEVOoCAJd03d9J9AKEHlwPP1VFCKS+ZgJhaUHLt3j4sW1v2wBRoJHYP4uBuXm+/qzLE1l3ik0BvDpo10zNQDRv6ycaPNaTwGLhHgSYSMa/CDNo2XrVcYX3gnddDZ5PIMSIXuvhez5H0uhnqHCsyzwvJvwN3rPewSKf21REVkfekH6C/3oAuwsz2gVCYS8EiwrqYALZJPO4t1k2cBM1iHwHYS1X9zT121BY1mY/HkStFye+bmzhtlp2veVWb4b2eULwJQtQ9osUjB9eCGUKcACbH9gQc4anIMncaJSlXAt2+LzQGmEyWvEHkPYOVyESY49JNfxpBzAW5TB6hLvCUV8EnGkspGSDRJy4D79FBJU5UeIstvmbEuAejb2vpupNMlqTXC13xzqgU4QFlvQJ1dOSuS/LJInFmEUlDIAUcHvTW3Vwz7n3WlgskNgiD6IfEey9TxUzqqtY3yYvhAZciN+fbkwreTEn8QEweHswo3MbgLcFmhmiTgRAsYBnA15k9AFfXGnwZVlWbUkZ8ftU8yK4CWkKqSetU3eAIIHQsjAT1Q2J8KgjDfRMh52752wyCAjPPtX0liTeNxodadV3ttihDo3NIum0jDK5SneFJVu82t8yTdd/nmr6t5kmIDKnC+PIp4p+3h7YWc5a2o0/P2huv/Haj/x//3r9Jy/EQL+mtA67bos3Qdx49hescuNmey/uD6WPClD0gRI5qq4JZcGMwekHGqvUo1ZPqRpEQ+h3j1Hvtqfs50NCwJyzZ9+QzWl5/pQ02+FQoRkV/PMwbs3XukELOOp9ihyN17CQ5Fnua8fWZSmeaFttASlTkYYrRQ81KsIhvxWqASEAg1BdHgiikpDWuGDDXwlhfruni/hb9ylQtGTWg7nyU1aR0KwZNg0rTs02mvshUBDFTO5a8E+4Gqj5tO27aVff2gost7HpS4K1QZ6A5xxbh8pCPsx/VGLPT0Z5ekhyjrb5UJQmSic/VwalrLt6rFIDAP5hPNjUL/OBmmlAftWANJ/8VwHxpOvfCAh8b2Hf4AuIZGFEBlDuczxukyA+rEJ8gkSmTUjRxY5i5x5927kQZCWteyjXIEUGzmrYGzZ/efB+E2qIw/3e7Gu0H+WzyaLe14ZzxeGh2puh5zgs4d3DD5s7oh1gFja1IiGC0sL4tgbIUsIUIViJuwdw7cy0zhDmmKxlJwxoRejVIxIMTy/kiIV8vmL8Ak6gVwaFdH+IZhDr5/SXXcvaDsDLioI79oFHGZtZHytxNhwEjIJC8tbbVuO1LH38ioMKCOLpNaV+3ed0+g74QrTO9AUouWUTGPaCTItNi8eGq4GH2KbcFPHoYehLkLDJG1VaL8u8xvshnTz5Nmca33daS5TNisrgp81LrMOw2C16V4QLnDd5/tenDRlpXj8V56lmy7rY7h1gCcNOEH4X/4QUPfOwJa8M9vjaHORZSNVO7ZPO/Hhd/IdtvKsnnuFWAVb7v4LntDJcXBmw9uhVCRc8rbfXgMAy8eUMsFuqkPMFtVXzArCsd7E0IwR71BIXxMojQSe/xtvi4zDL560QiI5rNu0hxg99wEaNq2cCucK5n46B/mpAo2WPKm7dKU575lFBH4T/FVc2Fu0pebwJoqeWFZpD7EetQBrSY43x6f+ImCCKFp5vTY0o5XkXvLopqgDzz2pKYjMqS1UH2MuPhLpvnPwot9HwopowDuLaOZ14BSC2FKKBayxgDS4MH8M+JWFQoKdB5uBHZZ5ySmJ8ZmM8XmLFYLxsOpojtPHefMcQDkLcLg9AcXumImSo2c5XSz2naYFlUSMBBaOTQWer0EGK0WXnqX+b+95owzsE9bklJDMah8xc4ybXSgRl7g3ebDkaZlTa5w5Pu07ZOKT6d5vwXaaNMD3COYrfPjU+PdSfvFHxXMQSGsnptlLHXM2rXn4tnER6oGme6nExGtOaYDSNxVbvuonXYNwgSAIy12N5VLRaPxN1YGxQLSwrvKb4PQc1tI14Tqfk72AGLm9DH26CqViY5pnClc/Fwspv00eBNUfcN/jzY+DxXJLbQmTY9xTPedfckGnrTtGZYDx0z2kCl6mdnQ6PMNtdT4KnmOF5f51M/SXD853WQfH5B50PNjsL5PpTfucHtX/yOz/ZnZPbsTTnj+zO7xwOQeeP1I7iD6eVeuIUixV5bZn/ULjI7Z0lqF8LlmEZidNtZ+YtswkSSMW7ZwLEPJHhQuh7BIA2twSAnQsmw3MFym0kiWzTGsBGPN3FMl37kirxLRMI8bTaPW0cF5QLXqXYRzB+tp/cMtD53tY6vTavIpJZPxQoQoYrgCl7OpWG4iKAra0C8dd0ZU99iF04t5oUrwhWLthsADYQEoqdLQ2Zc0/zRVtTWqza8OApYLoQdhQuJNagggyGo4SIiJ6jHWmBUPPUsyTBRCQhZEG1V8RD8frcT8+/fTL1gsmiYvC3k+MiimWPdj0IFVCt9a0b338LgsPurWHRHCrVE+/bOHATir8XcdxNTrKiqIaAZxe49ldqBpG5eJj1Mn9IrGuv9SPdcoA2rfCyRWUoXb6RG6LGPlLP80aB6VtDliwv+ObtMRq+vORCaOFTIzm9ZX6KrMdaoKE21BGhQr7QrURiODhLEk9uGCQYd7YRFCTBYfkQC/Q9s7MSiAV98Va4GLaEUWzbqEu92GHoU7cYHCH+JqjEAqqEZpyYz5As+2nwejPab3DKQiJYRz0xPuVUbrFrX7adDSnWLUfFNYj2pdslAJswhrMRHms0ecyK/LD5SS392pDnlXRFt39hk8mSHmSMKQM7ZK1obTbp3gdJ8/3HV6z6Bp0hL/jeHZ5oDcG8L3Yci9z394y1IT5rQ7FwtiOCWUyTJJWL+CyNeH4T4mCbSDt0eKav8WaoI/j3p0DKJsjMZSQ4hb2+mCpAsCwz6m9VZ25DVJvWXZsVreEzbMUPLnDZ1736GCYIhqzNXmYYL3zZytLkoYKtFXqSLc3ECADHmlxrkjC3uLlJFrusZU9LLBkVuosFB7jSyW6CjfZzdohVwe/tBOr7HtawoxIeK7ZCLmYPiO4Xq2Mu1KRK9jiGTcPCh0mfaobZTnXL16ENxfQ9/AoDYXfhNXg0G/VY8diu0/qS2Tv7p9EqWBC3ZXdVuAfExWKtGN7q+ZLua9ebdS+IbMikWcqkpoWN7OUpaDShS4z7qfgb0NOD2KPGO3Qp42N3poY92dFpCjQCsMmZS8D+wPt/uiTZu060YC9YeVuH4PO+2tBDlAPWQ7enoEO3hiX7G55rdFH1E1b7ZQUc3gWu4ogf8NXttQn2COGnYIcja9gRZPuw9RV7wFAklieKz9cGeRih3avIaHS04ahCMhbaN30eS8cBVTp5LHvOiBgILWLGwBpqq/CciY9wkZ8Wf9mXh7MDb8qLhBoHZjxVtD0ZAnjbBo0CZxsAxmE5ClSHBbuf+/ToRGM4lp1huBqN80FKtuEADdR+8o+LqIqoQFnclkx3xV52RsrCPtijU6ZsUe5T9mUhZTRxiynXE+y38rz20+KEW0Nj2VjCYvY8sv35L8NhWZ+Ca6XLGkkLDgPB1JzebSV0hRtvDzGsEbTvPiePFk/N4unRt+3JUssxwy42+0BGocovsY8oBLCds/IbzmEnyNL2uEeW08khhVU3EftuAAT/tkevyuEQwd0yxuHBIvYR7twqBMCT+fgkG3rs5g/8PxFYHP0wjVeYSzLp9UXAAujj93DyC5rOj9wASFP7wC9iRMI4t+VXHXO38OJ97jQVivKwc+CDLTlOAWM0y9HWhSLHJgnpnpt9Nt22Eu7XI2g/2KJp2xUgJXaqCqSPR7p2OCdoKVKjgaXhueyGx5kxnuerg7j3vd+pow0TUbB4jySBJOSjZZ+bALvMPUHogKJ5ivPx74bwe/NyHlh7fiZ5gKrA6YAwnTadapU2v4VfPxjuRJTA3+0pOt237Nxp4Brj8iIdJWEdQn6IYg4mwR75tIDWA67i+ozcINxI7CJXIAm0svBUoTm8AKO6TlUQH/C6St30pbNiGiyDhZX/elZhJTGLx4IE5x6wU55W5Rv5Z+maJyKXfTABLOtWcMGS0Z3oPkSgxRiwTlQ3DDE61aMN96h6hAPgj2dpQDY1QdjCFZuNY8l45kgnGaCDJrTcRwVaT64R48ckrSz781/k3GAzpvLWCwI9ZRtQZDzgBkAgr7YXY6NWwUvmMzpG1p+T1Q/NA7HHRoDaRJLGngWH3/FDa3uJHsRKLTBCn5Ndss8P3qzbngyL4IIVAYXwLsOxpwmeOg0c/bv+jI5QSGTJzbJMA2qyNADu9J0gl85Qg5utugW2fWaACFWvRwH9UhR8AWFzGr/6GgRdC9miZ32YdSK8YUDIU3PFJpWwQbuBTnExftQ2TmBf9sOqOBrkCMM/raOJRrPGOJpF1g+03eJeGFSxzhIz8Kwev6xHkTlKJUlkUfVnJ4d53gkzt17HAzxEsH2QxV5cawq3KNIeR8l4oAJFA+gfMLu+Z4oI4GLHbLRp1riYPVG6k45sif+fcbHx42Xzr4HNQmTs8bsiUJmsl+H6oYjddPSRcpYd3wLnPoTcZlJLm93/ZYVrqnzOy1XaYbbjhbDG+sYngOpJnn+ritf3TBMrsI3HDnmEYBqnZUiCN5Ehj7KnwKB7hmperKAzZj7LWuAcx5Bem0msj0AWlQpW22GTmkIyTZtlTpE0DNuKXmtPU3NkIWygyVN1o3qa07ICgKtsZ54OQIEkKFbrmKt0lk0wjJ4pQhFotT2+XizG+OxbrQtUYDXsrVmwhmDbO9u1gaVqjSnfXBGGUx3Y0rFR8G85EMVVTRCtaSryjOqxhONMAbqjfcof9L3ZRbOkyY1Lg/TBqW7Lfx9l1ynYu60OOrtm9SqanHu1drVVm2KRXonvITtmb6cfFJbSNrGIq3jXT66wnuEhppDudYHwd7YB9kW9tpoJO9u5QsPXeL6uBII9IIoejNyhAMsUEOwbFsHW3vdJZeEiP6MVuGtUiAXMdzInAmdp44dax7/XP/yr8ofrf1z/AH5aOGQZO3bNxRIdH5uXnRATPUi9ZTXbimrzDcsTd/TdAhJqslEXM/FkDnchdjvKxsk5YZ5E0/1c5/TaOszuSJLQGsQ7Gy/53G3lanDwTbWHAlcfiu9RFpbZi50t3SiBWA5XsElaiZQ/HLyaEicQI/BOSMbVb49RktVQNsecmT5IZM+Jam+YJyLWZNiFgWBiu34d47JcnTASTd3OBVXDVzxChpJVhw0sPqNnC8nPIFD9+H5snrN7FST2YoZVOtgzr3JYxy0ldBpB98DZQThHvYP1EV3LdRMZ+KkdydmESLmKszXgnugxjDoHlF+HeEGQuhMucLsVz/TD10WqT7JPMHuAwGus5jwdiS+WjUqr4yHaFPSD1RB24Xy1IgkscJq2Xzu8IJyY+k0/1cl/0p6RceQ62AVLzwF+y7yJcnwiW9BtWPyQDOq+ACEytW391jQLjZmAvixikl9NW7ZsH0CuV8d/neFUL1j+TRu92NwP7o09mR07dbb3Z4t2RBSjM4vVZc+ZRQDlRfzNcdmRBbWxlfO0QrWfwXNIWd4gvuxcEjG+3EU9JJ1C2uzptHJKQhSVCM3hd6DNuKXXZufAAVsuABTe3x5OIgnsdlqxlxzgYF1B1bWJxOaVIbU2AF1l8Olcm2UaJXJ9dbP/7H7C0LupC9MNT7cshNWp9s89Fg4oKr/KfgCohPirEXmbLd4murViGyedaTo9RbJPffwa7mH7DPAMS7FEXrE0zsgR1NM4M1lgyrejRCp4R6gwGWHVxvT8uhLWqi2H6BtH3jiJYlrniZscopgywYKYM6/37rzagQhOauGusPeq8s9mw+61SiUo1QQdt3venGMhyGKU4ZEmhAfk+3K4bkvdLIjZ0abK95yLz27wNYsL+/PYDkFDOPO08lSgckfVRYd5RuvdUKSXc4lQlIuAg3iAN5xCcSs+X+gAShjL6l4JKApff5TXwYKjKm3y3F9hNePFO8O77Gx0yoVDNMvHhUAA8PXFx8Enp2OAyntS8Cwia2dFryPvHNXG31AT4NFW4kDzl7yOEDXUk+akAu5z6hE9MNsqyY26syi1v90jV/zb7hdE2k3sP+2uNdmz224z5OKMKQGP6i0QKkQ4O0KSs8KSUyzDZ+HEMzdE1apS/eVaezmvACOHwryZC24QEHAA112W6eJdkHA7WeP4GXlkSXyw6rbaAEuYQzsL/k4JGStsxzQgvmxPsFt62WBu3S50VciqGyrwgWbN2X6wgd4tcWBX4Bb7JmQDsDdx8Sxss14dU/CuMFuYnK3ejvcszZYvQLNzg47UO3Uh+hwqE7eDZ79ndqmd/bAvq+mxHJQX/o/Lopo7n2FnfJlIs1jOXLPIWw52Nm+h0plel1PgLIh+oYJwAxTx+IgcLwp1OavFgGFyxhPmYpR4i3XJaaNlx5k0Z4FXypc+mexaaSdXx35Us3Zap6MyW9WhlmnKdUYIWtD7hM+IYSP48tAc5QHPtn8mBieDfB66no6MWw6JqF3OnH3sxc24DB5p3QyMZzYHXkA9UwIR7Z/tF9q2m54man+Clnq2OmvmlM50BwQkSwNNRW5HXjoExghJRLJRHRo/laQ4LSQxerpR7JDEe+6GfHqJK8EaWOk3N3R7KZ99RqfkvpjfxDbQ5Ny8Qz+uFu/tdJdKGFzO7JCkTYfueYRp28c0LXyfYtyK2OGNq/OMnK4QPT64tzHgsgESIZswYtTga6/5s7mZynI0S/UdHQsYsBHTuTSdKBRMvzwqDXCUiOI0pGtGu0YtOB23g8LEHYdRsMUOQam8u/lKLOzGgZFKEKBoCgkKmKEheqHocFk8bL+UfgNLm9tGMkdLwR6xk96zhcNeR7fu0x45ZxjlJDsBu0R+s2jX/1NLzoZiz1fzchJz9ADjzOODHSED0iMvzWM5GcB2QPgu24cm6hkbCedIedllk08+tSckrXO0VhNBbX970U7JZv9zWo8avJXNBaACX97XYiSrdo1VtsVAdXrNZ+oALkJIcm7HerIt7cXZQexNi+uzwRAPFmWylA5cl9eZsLASewDfgJk7bTfEtVn1Ot5o+lIytvdjUf3KYIB15RCFbncLhKfp2UoEi5nSizVlt6Jx/wFgK9Bni9j4O7HKo+/HUvV6cq3Bocr2cxS0PIji4Bau6JwqoAGiudO7m8qzhp0ddw4eDMxBY3g8kY+Y1q3OMjtn/qfHc2FeRDN97/DIMTMh0Pl4tfbrcfII8qzeVgDcQPHJ85g5KI4Daf9hMcv1+w98NG72RaUOXBDT7y9ah8vbrPeYaHPHB5UzVTOY33QjUC/wxM9BAade/u4OhSVsOhHr6U67O+dW2AoB1SPHIySywwCyrjf/ii0J5m/bCQRinvGoe6xpetKqeZTWZ8uv9AXFDlNAHHY1iD3s9puACflM5QXx6uXs8edMMYCPDYJRse+1nlE3ds1uaF6AkiTnNcBibidxva7/GbNilsfx1+1CN4TTAWDnUbQ9c/vBXgxbo70NJ1+zSO8w7WLxbHewXieunuoaXBf/1fu3vYgOob2nk4sc6fXZxIw9gOdFeEMxDKCsORjqM1Lb/P0R9wh6jr7zeLWj8sqpKt72oiCWnLlcFYNgVmgeTFhatM6Arhbwp+bsQ2uKAIDPCvz+1Mvo8jqHpXoV1qIUD/1wNccdjXbKy2EOCYWxPfMmJiArpsWNnvTfZ7z3Gy6o2D+hURpK0L9qyhczQ76J0KzhGW7WXYoJO33x5suFcwTV4/gjO2mKQyT3GVnt/DnIvPUzUuZhvaPdOZK/gbdOq/8QRQ5yQWUTl92kZe8Ea2nCDS98AXLH2EXVpS104TQvTRObMCMH+U5Fp3l4q2autwHJAWtIDrRGFhabRAh6zlotHltuhwE4woaVczj27zqVw8XBDlPrBWBDdA1FaPSQyfqQGRyMLQ5XuN1YDjEujoSdiddt1pPdW6ZxP5DW53aY5r6cE1ych+c0RMzZ05pwL2ASos/lpDMvdYGf6RyR8gc4+TINzmdmS7kJ7c9jybCeaHcrK2qgsrkPicj2eNv8BJoBBwnm9jwucJZo6dGRHiwglMUsuI8FWZaneI560ruZbzg1BDq0CrRtWpjwOpjN/C4XHdwSIOWxNGQ648GpV+uKEDIfrYG2QpBOOx2mJTvNUYLWu6O3y+ePcMCiuL2d+CAkL+iCrUMEDJh/+dgkDxCczSBb3PlRvFsDAX0O9ZSiOsn67bcnqtnxVB2uPZJjm0GbZY3xhds/s2Qkq7MWIcT3GeNbYch5b/mPO2W1lmePVg7dDhMJ02Ebc8p6IRbluTw2i07A4z4rfNRBjkGVH50zb9YgrQ7vMVUMt0JEJ8hF6iCb9SKITWhbSemaLp1HdpAKzziqh+jBI8xzybxNUg47TM2TdWxEPhyMvg7ZcdZnXJC9iwXMGX70dsftoT6RMuhah7o5E+AI4tcyWBaDn5mJPKV1Dnq5XysEir0FnSuKZ74HRLPYrU0g9shXd+O3+4yCw7IkJwcf42Eq0tL0PTE/bOHB2eZ+y3VsbuO0hzHx4a3ZruxgOEzbTm3r5m+VdbKs3+Il5zTCVI7saM7NnnnZwfJ5EjRO9iKAQwTZDWKxWl93wuFg/4ad5cFaxDO47MOOihVwzsg8R+/zqi3rjzbNgdXRmmREaY2n6PuFSjgnSfYQzomOfeQYBKLMrvkzwc7O8Zwvx+6f4fYPBEnceCVKz6lWTaYrm22pcTRLEdA92qv1Mc5UuCHa2/72BRsBLB12AK6IHpPLxrPf5BxcB0bZeBftFLGUzEcB5FdetU32EBfL3Rxfibq6APIUrb602T6fKdKQvAAvY43t5q02ycV5YOqgXPusDDWr9VqN8JX96/ki2ITVUD7UYVoXoPTnsj3/btyCjcYj+RqcyzqNxy4beeXjmMnbU2Wg4xqKr/sdUX2KQK02rseyp7x3EJ+RCC9fQKvl5B+RfG3HndsRlAa3QwAImV1LJvee4uhlQkRG77wJKZfsCK3zOQfUZyqmwzBtV0qENLYWuFymdqqjVsDswj3sEuwtNlnotCKz/U6fHUsmDOdeGofzs3ed5s6ndar7DGQMW0leiLQ+gcNR2FxoHR0Ae+CIQL6HScV4Dx+YE2ZekakYFrIKsicLbAZgG7TtRL7OI4GsBHpQ0Q6i9jERnUh4SmlN9cVfqfx7QueQDi94VQnEDooMTtXalSDDGtnPCoIQ0VlsA7WH/289Y5ws4flr6HYic2tSAKDwTHzGA9As1ynutCop+cwIT/BRbaue2RZOInJ8qVxPmntOWJxJjiJbBVVxjuCQZqiCy7ZrZ0+YPYlORAyEYPSiFLt1/gVcxzl3sTXkOZO4nM1ol/QZLsRrPM+/wnQuHIDCIjpubluJvz5BzJ76hB63NNKZXO8r6xvdY4Jkd5BJq+K0brt8tmM/SnWosMODMDE04HJi3F2Dx4XP8rEv5u8dwuNQLtMP3T6+nKxbCcN+hivDb/OZieuAGQdOZP2IG95o1fc8pMqSptPbrfJTgAYfKGNvkvORt08bmRf20W1tsLTyS+Ep43ac4nO6/Z1Ivu0wR7XE6uxi/NmSaf6+7QJ87GiS5TiuGJbkdUrHipO2TjshPtuztU1WPEVkxmsjkGcsHta4zK9jpGAxXDkhZV9WhLPQY0hCQfZYnC9vnslGD0enTo8NLSs2eLCgtiELFkQPMBq/Qk3EdKESB9x3OGG/Oqzbc+U7O/QMEmp9ozM5YXVO7Qke3TksIU4fIwM9ZINZmzHqZRdet34ZWUU0HQSax0IAEB1OjHkR8fFC3OXn+VUzNbOwTnM2geTI7GXdnNPPVtWj9+1J8nmETsse1TTsOYmiqZzJzt1CUjbEkllIghJrnmdbFQdLXeM8mCG+CCs73Vs8PU59ntH0HiwFj+3nuT0rN62EhqciqOepsbFXQWRCiwyu3cdVCIPgzHSKl9UVhA/7jXyaFVx3nyFxzucbEuFDageCEfRpxrKLGMcG1ec8xoVFC5ZMrs/2UgLHZ8NdPsOassY/HOASpJy9rQcdhc/scxh5WRT9AlkejBIC2FrHrfLSRcCP8uUWwmknTE6OV2DY4FOrJg6dradH8CvXqxc/ngwAzM2nXZSNpGvyhGaCgqBKWJ4wlBMUXrMaPlfDM905LbnkXUu5HBy1bt4hoImcQ/QYmjxrH5AdbsWZyCU5Bs4HjHmUO8/MhmzruMhkw+ALhwTmpJrrg1TpH181TLNyMSAfIYTrNn+EJYR0Coo9wfKwa5xnRtgwNCqRFnri0HmHPUrhcv2iU1ocg2/eHvNn+3BcZzKkdUoxXgLkZhcMlOq4M0z74k1ZM0cqP7aGmvZXgHm4pENx0305TeFk+e4zsvR9bSgbU/VOjEdsFwwy3za2n2eZfOYZ4Juw5mBvG07xRMf7Q2xYRCdeWpwRg8fjzuD0ESLTm8MjrwotdEhlQ+ZDf15PU6EhzYnh32mEdcKMFd3bigUnp8X71NF/tjlLM1gOpCjUaJuHRHR/Z043GGC3yLf9n8nQnREMHi6fKv79yUBAtMUF31a4qbqLbIS1U7tvHMXiV+dOOtLD6hNYKiE/zuDJOD+NMjZ7Ps9P18/IH2wEsL+cYgSXxtijE8EsNTwtzq8A/d22xz/2CHT2xOYWJCOOC2EGX+4/qsaJ/Q7bQQBZoYcGulWu1eovrNE5rtspR58YbMUL7KA6o/h965lruTBM1NYGN88AnDtgA8FhmQjN6SDoBeZDBLOPBbDjHELwVd5cfYmOtpUCTQI32mdI0hfSZW1vP4/VIapDxl6k9nvLABOoKfKuM7NCPLCjvyK1ROqebc947AhSt9/XuO2UKI+jMnwCDjQu2+4EPKlWNNtn2vIyvEkvdqTEpQ4Njt07z/0g4NjCMB2+DnTDmBD0Tsf3IVBzgNvQ6/YzhlNarrpSlUGfu+fFzQHF88Ug48etoWA8gB/wMzvMaznV/A7wtqrq7s6Uen12hF1QvNdtIVpYBMkJ06sFTMRRL7O4lhU2s8CB2HYGaEqwT/XfaYHycMix+X34kMJMJB0OnLc40rZrKfgHrXFWg6jN+/u4HMT64c/bKGeWDQJjgYxj7506higkDFnFA4KmeVt5DFe8QBYY9Ld6IM5j8HbTzPEN060d8wUoPXEkfi0PPQikQP7y2Qjs2mzB/FVKlnvYHx58OA9s3PySTUfuR8F1LA83CVi4MwdL329wYpWx3j6+n/KoauMprNbusn6e8TMOhXXWPQr9cQd9LBDs0UknZpnt04A9qKzY4ona8azTqdd5Xs4w7aazQIwkFCDpABAgwrmcr+c0spXZzItmuBsRoDoUGg2f5DanYdE5EdFILmqdgvBmdtDxdMNX1WoNvQ9uEQibdaDJPDXrLULb/DDHeSbaew1jwuNkfvjiyatbtGdBuPXDyNH7V5nc58D+4PS1BwL5Fojh6ZE5U7QxyN5fH5PnU8hYTZ8QUcyrByKoTdYBH+4PwYnI5qMeszOybSa1NspsMSCTnMd+fUKyU358IpUPEwiOkrWb/NThY1CFNVbk2FPsOB3ErJVqb/I5KpaPyKzLNZ1Ac0odo49uyEFQxq8QCfeZxDzETZ9T1qWzDnTcHqC9fFr0jM0n6OwFrQlODSv2fSVrVsrphMVJUNdnyCCY0IFMI96Q2Jw83j7Pl4yOWK8RefLBIZ/wtXxSHjaUm+oZ77QrJWPxXE5xUCwK1AesbKOSTfGOfPm6RPnMgcV6zNUSwy2sHiXaO0v4SIMXOeQSNDxJ0tP4fabaqfFh/staJAICv/Y4bzt9VxYpJFUO0XYuTzq5/nkou/HA1OxJLHv2vJ20B7Np5rPGMvBxXyxFgvotDw6XB+jFbs+5+liO3LfQGedIp+resrG57ujc3Y3dOsYfY+/evoO178vBEneyBAMi5EAR9bQdLuO0cym9zzRVrMsDTsNgRm56G/bQmCY7QYPFvsEW3pwLJFZ9TkaWIjhzxEfvQWKcAu/4cXjVNgfpWSFrXWdBqvuAh4odXwg6foXP5PqwG+xoBnz6tIRbtM8iOaSpOffUsbmOknjOuIzpufAcyrfw5ssRryyJFPPXs9MwyGkTuM86eTE+YNb5z44r8fzEdoTPyAv4PU5XmV124OgCq3duMLnIbCto+8gFAFmk1Dqzo3zonOyLBeRmpaMeRcFJzT6ZPvuei41nS57XGu3guY/TWQBTKHeFV69tTZkH+yomi2zOc9ueHcbnQx/0Fx+O1a/3TCi11MhOYGIHrLH7bCerstlDJ8dVJ+h6zOfDPRwlkp05WnwKTPIuTd1cI7pXzzPyT5leNlw63gJG9qAClHCPLftQis8ChjPPzw4561EcVplfR/Ze2IlPnYOaxAwn83gZcIgoC/T6yVqDbPY8nKddzWov+sNKB4PR8/j4Fy5s+rA7a3F8opZ1mymcZFx03Nupt/YxdP0tUH689R1nWpWHNuwKMuWR0QMHM67ru0/5KfvzhVVOVt/SN5DUJ8Q5UMaHPVhqNMyUmOqLxB+WmY/3sYcIe7a2XY6XdiiibW44689MZGwaxvu5JyOcxzjsbf/TY17fMjubCyCbzmm4mweb4zqRO/lYYehw8rGPy9Qw6H6ysdsH1+K257A22hZjh2UxkxN9hA8MEZeE+DprbNkskaMP8+0+oc7RTEfwLivGiIReCnbh8YHsvpsycJw6EIsf5VPSc5lWULf6YLvnHGDYeK0cRJ7ATx7iBcyL3fRJIw4/xPM9KX0j7lrsuzlnlldDyviIhec2LY25fPFMBw/LTr5gfYRThwg2xAe22tkE6OzhU+HWcv64o+S0o21foMmje5xHe5bwFJ+rMQFlx1h9BHMf+uRjHGBR+deoqfv0z5iYPX4MHjkSx/NqWGUj2G2HDDrgKxNpYXHdZpXiQ5kLuOCcsmbwRQIaXyyz8DPfeom86Vc/I4rqtawfNeq0Uj2A3bI4x0c32bnsQ17sQD1PubKpGNsw7zz2RbSYRhWHnpqt4rctmyZ8EoAmxBb5ZrqbkB3nMx5baXwixOcjHh3DiTpsFugCls2uMqtwy7bSBDn3sDh8EgBPwPhTTyPB5PndnV7FEvv/eZ8xh7N97CKMSCGfAFsJRh6bnTGrYzq5PXusWZ2CGIfPd4IF/r3hkdW4tkd4Pn7rkYGbqHLeEO8C6zBYE2nETZOgTjqRQTsICXeK2eecdsc6xLauU1WrBZitOgPba21OF/SQzvG3VkxguXtGB5WdpyCdVv7uWCYTUyLseC4HWFrtYMtKdAoQisQJ6+NzNCvY8ZyRKw48xQCha8gcOKNZVCuKgk8pfXzCQFXKrvA5E98O2ezjB6r9vijf5TN/G+K1OPy6O8oSUnI7Gr9De7F8I+DsnmWj9T2fxyiLHIoFgI+68J574SxO3a7L58P4bJ0A/r3qpSRB/EzxeRqRfQITxhiAVpjFmD7cbJu29Rjfkv0zXu07Bx+O5xC+fW5WPumoecoYEV8Acrv2PLNMkGfwRVZKUMSJsyUiHjHG19mHqTu+3x6THs6zSaBewIfD+ooPdA72HH+VuxzWJ9mpBut3jHy2rQzF3CroamIfmLudMMCNQdRsr/A5j5s3w2BZvevMASk/lcSOLDzPJ4WOL+NGsRlyqDzfXj21Dz42OPtoicfkcbSmfJ2z24ulHo7E5iqQihakTx+TGpDeMz1C2Uf4zB315fNULPW52+NjqZ97+1ynYBHU4yNTnTRzpjeic30Gefl5xtgpH/LJAsQY47wdaWCVA4JWcTTpMN3twTT/smu7V8+++C7rADkE9x7HCVhw8npg7IOpHXXo8xp9qOOp/vFhyL4Yk37U09FBkzbH3agDBxuwWt24Oka1NWAlj0IRFD6zaZYGeXriOcC3WJ/lrcuWu+887ayfrv7hgaXj8py+VyJmd5qHIc2WrjjMwGMgKBfU2No8y+Ur0vi+cVuj8+V4g20Bk0+sw4Y9huXCiUGOTXfqGpTZJyF5+j5fn7smf9v24zqx/wT4uupVPHIgNHgW5IFuP7M9voRLfdVHD8GIAffsAcR9GveTD0AbBdmHA3yPeeEXLdKGm4r7oZ7PXEf8BCJvnRqv9xmNVt1GHw59hp1jH8RtK1Usi2FlfYbtDD6pwnz7zhHEc5zzrqdQDBamhSzp55nzZasZvoE5Lgnk4ZTJs1vlfEnTcXzz1JdEH5xmkiDyBq9D8rFjbIcFl/LOxfWbg7QmyhHWDwSBz74/bqf7nGOs6vU0wQfNARnOrLtt5ahq6/c8xWPeOTncs0WTfFYr3R4ppzOgTzzBRy6rnACE88y0Jw2WMqmni+N9baaxe8CGfomCwwLs/fg8ezYVPBxkritagWCTggczPTvE34duJp+imB2wdSr1X2vZAEFj6DeAzWKaxIdwPzA3u3kiouM6D1JKX5qefMtKudJlhpto2H1MwZudtwXEquec8wuasWOArGO+67Qji+W+Ph9/+4qTFiW0DiB6SNKG0/htz0W4wpi2Rl83u5ES8gPdyfZ4PoiRGbviZbmlNYaWfFoliLBYpjSfd3YF4OuEFLuX1vDJu2vY8u2D6t/2ZWQIdu5Um3wVC9W6c+Rt8bPZGmdjyZ3YxBrbMXtb7vn6CHEcw/P56pAVbKlZOkC45IrS9VkMdduUZ8NEsN3ktkN3wbbl7GBpQwC2ng0+noo48jiar8dj7LUAZv8PPPfvEa6O0U4AAAGDaUNDUElDQyBwcm9maWxlAAB4nH2RPUjDQBzFX1OlohUFO4g4ZKhOFkRFHLUKRagQaoVWHUwu/YImDUmKi6PgWnDwY7Hq4OKsq4OrIAh+gDg5Oim6SIn/SwotYjw47se7e4+7d4BQLzPN6hgHNN02U4m4mMmuiqFXhCCgHz0IyMwy5iQpCd/xdY8AX+9iPMv/3J+jV81ZDAiIxLPMMG3iDeLpTdvgvE8cYUVZJT4nHjPpgsSPXFc8fuNccFngmREznZonjhCLhTZW2pgVTY14ijiqajrlCxmPVc5bnLVylTXvyV8Yzukry1ynOYwEFrEECSIUVFFCGTZitOqkWEjRftzHP+T6JXIp5CqBkWMBFWiQXT/4H/zu1spPTnhJ4TjQ+eI4HyNAaBdo1Bzn+9hxGidA8Bm40lv+Sh2Y+SS91tKiR0DfNnBx3dKUPeByBxh8MmRTdqUgTSGfB97P6JuywMAt0L3m9dbcx+kDkKaukjfAwSEwWqDsdZ93d7X39u+ZZn8/xrtyYvDRfG8AAAAGYktHRAD/AP8A/6C9p5MAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfkBwIREg+sh0OqAAAgAElEQVR42uxdd3gU1d5+z2zLpveEkIRiCC0QaghdOqGINBFEUcEGIoIFpPhhuV7Acm3X3pArKgoiICAivYl0EkpCSO9le5vZmfP9sTvD7GZDUUTU/T3PPJvdzcyeOXPmnffXCaUUfvntYrPZUF5ejurqatTW1kKn00Gv18NkMsFsNsNiscBms8Fms8HhcMDhcIBlWbAsC47jwHEcnE6ntPE8L73yPA9BEOR/E0EQIN8opeIroZRC3AAQ71cAoJQS99ClV6/PSF5eXlxUVFQTjUYTp1Ao4hiGiWEYJooQEgkgAkAoISQUQBCAQABaAGr3pgDAuI8nAOABsO7NBsAKwEIpNQIwUkr1lNJ6Smkdz/O1HMdV2e326oqKior09PRq93GobGvwnhDi/Z34GQBQQkiDV9lGGYYBIQQMw0AQBKjVajAMA4ZhqEKhgEKhAMMwEP9WKpXSq7ipVCqoVCqo1Wqo1WpoNBpoNBpotVpotVoEBQUhODgYISEhCA8PR0REBKKjoxEbG4uEhARotVr/zXQdhfiB7bcJy7IoLy9HZWUlamtrUV9fD71eD6PRKAGa1WqF3W6H3W6/IqDJwUy+CYJARIDzAjMPIBPBSQ5S3oAlf19dXZ0aHBycolQqb2EYpiUhpDkhpBmAZgACbpJptgMoppQWCYJQyPN8AcuyF3U6XX6zZs0ueAEcvQzgNQBAEfgIIR5ARymlSqVSBDYJ0OQgJ9/k4NYYwAUEBCAgIACBgYESwIWGhiI8PByRkZGIjo5GfHw8EhISoFar/TeXH9j+HCkpKUFlZSVqampQV1cHnU4Ho9EIk8kkAZrNZrssoHEcJ7Ezb1DzBWYiKxOBTbx2PoDM431eXl5sQkJCB5VK1UGhULQnhLQH0BaA5q98DXied5SWlp5NSko643Q6z9hstpzc3NycHj161LqZohzUBDdT82B23kAnApsIaCKbuxLIiaCmUCigUqkuC3BarVYCuJCQEISGhiIiIgJRUVGIiYlBfHw8kpKS/DeZH9hunFRVVTVQOw0Gg6R2ygHNbrc3ALQrsDQiqp1egEYaYWUNGNnEiRMVH330UfeAgIBuCoWiKyGkC4DUv+O14HkepaWlaNasmfdXeYIgHOM47rjRaDx2xx13HNu9e7cgAzsJ9AghgjejcwNbAzbHMAz1AXBQKBT0SuxNDnAiexMBTlRPw8LCGqincXFx/pvOD2x/nBgMBpSVlUkszZfa6cuOxnEcWJaVGJoPOxqR29F8MDPiw14msjLyxBNPKJYuXdpHo9H0ZBimFyGkJ4Dgf8I1uQyweYuZUnrI6XQeMplMh2fOnHlozZo1Th9AJ4jA5gY06sMuR72ZnJf9jXrb30QGp1arJYBrzP4mV09F9ta0aVOEhYX5b0I/sF0/4TgOJSUlHixNr9dLLO1q7Gi+nAMioHmxM0nNlDEyyIGMUsrU19e3Cw4OvlWhUPQjhPQH8I9c9dcAbA2eU4Ig7OU4bl9VVdW+5s2bn3ODWwNWJ2d0InuT/y06GOQgJwJcY86FK9nfRPYWHh7uwd6SkpKgUqn8N6Uf2H6fVFZWorS0tIFzQK52iqAmsjSRoV0toPE8L6mZgiA0CmZWq3WAWq0ezDDMYAAd/FfndwGbt2Q7nc4dRqNxV3R09D64vLiCN9g1BnIMw0jqqkKhoFcLcCKDE9mbCG5y9dTbuZCYmIj4+Hj/xfcD27WLxWJBcXExysvLUVVV5dM5cKXwDS+1k3g5BuTsjHgxNAnMbDZbllqtziKEZAFo6r8yN0TKeJ7/0WQybY+MjNyOS+EqPkFOpq56qKoii/PyoNIrsTdv9dTbuRAXF4eEhAQkJycjKCjIf7X8wHZ1UlJSIrE0uS3Nl3PA25bmg6VdCdCIt83MYrEM1Gg0txFCRvnB7KYAuS16vX5LTEyMyOQ8QM6bxclArlGAUyqVjQKcnL15Oxe8bW+JiYl+76kf2C4vJpMJRUVFKCsr82BpBoPBIybtKoNsiah6iurmZdgZo9Pp0oKDg8cyDHM7gHb+JXlTylmWZTeWl5dvbtmy5RkZwPEykKOy1wYsTq6muoGNXk1wrzz2TfSciuytadOmaNasGUJCQvxXyA9sDVma6CDw5fFsLIRDBDVfgCbPEpADmghmmzZtChg8ePBEpVI5gRAyzL8M/zoiCMI2q9W64a233tq4aNEiGwCnHORkLE4Q2Zu3muoVHuIBcCK4NRYa4u05FR0LfvbmBzYAgNVqRUFBQQMHgcjSzGazZEu7QubA5QCNyNVOvV7fISgoaBLDMJMA+FfiX/yZyHHc2pKSkvUpKSlnZaoq762qygCOXgngLhfYq9VqERwcLLE3b8dCixYtEBgY6L8y/1Rgq6iokFTP6upqDwfBleLSZKDmE9DcAbUe6qbVas1Sq9WTCSET/Uvub8ni1un1+rXR0dE73AxODnC8LzVVFibSAOAas735insTVdPY2FhJNW3SpMk//poo/0kny/M88vPzUVxcjIqKCiklymAwwGg0wmKxSKDmcDh8Zg+IgCazo/kEtLvvvlvx0Ucf3a1UKu8G0Md/+/99hWGYcZGRkeN4nt9vsVi+Hjx48NrDhw87RZCjlDbwrPI8TwVBoGLiPc/zVB4S5HQ6qTxcSNQQ5KYQ8aErPoStVivMZjNMJhNuueUWKBSKfy5jKyws/EecqNFo9AloosdTrnZezo7mS+WUsTOyadOmkNatW9+rUCimwR9z9o8USmm2w+H4cv369WsWLFhgJITwMibXQE2VsThvBndZ+5tcPRUDe8Wc0yZNmiA5ORmhoaH/TGDjOO5vf5JlZWUoLCyUvJ5iBoG36tlYGIeX2klkaU8SqGVnZ0e0bNnyfoVCcT+AFP/t7RcA+Xa7fdWmTZu+njJlis5LTeXd4CapqO5gXyrPQfVWT32FhXinZEVHR0te0+bNm6Np039e5NDf2sZGKUVubi6KioqkgNvLeT29MwgaUTtFLydDKSUnT54Mbdu27QyFQjEDwC3+e9kvPuSizWb7/Kuvvvpy+vTphssBHCFEkCXde2cuUF8ZC415TcWA3mbNmiE1NRXubAk/sP2VxWQy4cKFC5L6WV1dLXk95QG3jeR5Eu9UKC9PJ7NkyRLFkiVLHlQoFA/CH3/ml6t70J61Wq0r77jjjtVbtmxh3QAnqagygBPkHlTv1CyVSkUbyzeVq6WRkZGIjY2V1NKUlJR/TMzb3xLYqqqqkJ+fj5KSElRUVDQI5fBOXpfb1LxYmodjQPRy2u32O1Uq1SMAevhvV7/8BoA7bDQaPwsPD99ICOG8AM6bwVFZBgP1Zm/eMW/eAb1iSEiTJk2QlJSEW2655R9RDulv5xUtLCzExYsXPeLT5Lme3snrcpYmOgrkaqfMjsZYrdaBarV6pjvlyS9++W1sgpCMsLCwDJ7nR1VXV3/WpEmTA3KA8/ai8jxP3QJBEKhX/T7xPXx5UUWziuhFtdvtsNlsaN68uR/Y/ir2tPPnz+PixYuNOgkuU9m2AUuTq5319fWpoaGhswghD/tvS79cL2EYZkR8fPwIlmU/ysnJ+bxz5875MoATw0R4AIIgCILY38K9UTFlTw5u3iAnOsC8wc1ut6N169Z/W7vb3wLYbDYbzp8/7+H5lMenNWZP82ZpblCT1M57771X8cEHH8xWKBSPAUj034p++SNEpVLN6NSpU5bFYnm/b9++nx8/fpwFwLnZGyOqqJRSqRim24FF5cUVvAHOu1qzHOBYlpXA7e/YSOYvD2w6nQ65ubkoLCyUCkLKq3L4KgbpforJQU3O0hhKKbFarUM1Gs3jAAb5bz2/3ABpGhgY+Pyvv/46oLq6+qMmTZrsJYSwMvWU4FJOKvVicHKAo76aAvlST8UogNTUVERERPiB7WaRqqoqj3AOMYndV4VbWSgHEem5D5bGlJaWxsfFxT3OMMxc/73mlz9BPR0QHx8/wOFw/HfHjh2fZmVlVbrVU0YOcK4K5kRojL3JVFVcjZqampr6t3Iq/GWBraSkBHl5eSgqKpLCOeTNVXw5CbxZGs/zcpbG2O32CSqVam7pueNdyx3ByEhvdVOdc319PWpra5GamupHgL+A6PV6bNq0CQ6HA4MGDbomg71arZ41bNiwXnV1de9HRUVtIYQo3OopJ7O9Ebn9TQ5wLMsSlmUbtb15MziO41BTUwOz2QwAiIiIQOvWrX838SgoKAAAxMfHX9X5V1RUwOFw/G7nBtPoN6wenyx7EoP7ZyIjsz8eWfgqykzOm2LB5Ofn48yZMx5xapfYmg7FF87g2JFfkZ2dg8LiMlhsdjgcDiICnDs1igiCwAiCoKisrEx2Op2vqVSq/wHouvo/83DPwnduinM9fPgw3nzzTQDAkSNH8Nprr/2pY/g9wnEcBg0aBIPB8KeN4XrL2bNnYbfbG3zudDoxYcIEFBUVITAwEFar9ZqPTQjpHBkZ+R7Lsot37NjRjFIaQCnVwNWYWkUpVVBKFYIgKARBYHieJ06nk7AsC5PJBKPRSEQvqDyP1GAwSFWiKyoqUFxcjAsXLuDQoUP4+OOP8fbbb//mdfbSSy/hzJkzAICCggKsW7cOK1aswKpVq65qPWzZssXn/17remgU2LZ98Cxe/HQ3Rk5/Bv+34D7k/fgeHnn24z99IZ07dw5nz55Ffn6+R7Vbka1VFechv6QaysBQhAQHgHNYSH29noiMzc3UiCAIIksbFx0d/RUhZObN+NT/8ssvkZGR8bcYg0qlwvvvv/+bui7dDPPgS+bMmYOSkpIGn+fl5YEQgkWLFmHy5Mlo167d75m3B/r37//fEydOZAHQwtUTVgQ3pRvgGBHc3L00CM/zcDgcxG63ExHcLBYLTCYTTp48iYKCAtTU1Ej9PViWxZgxYzBw4MDfNE6TyYTdu3ejTZs2AIDMzEysWLECt9122w1fD40CW1FREUhEc0yZNAYjb78XLy9/EcO6JMEJQF94FHPvn4CMjEzcNvkh7D5XBQA4uv5NDM+6F3k2AHDixYdG4uFlX7p5+UlMyhqOd7/YiDlTb0dmRiY+213oYmCHvsc944YiI6MXpj76HPJrHSJtxNZPlmP0gL7I7DsYDy54BafPnUNBQYHUDs+7J0FFeTXAqBAaFACVWkvUSgWo4HSBmtNJOI5lnE4n02PAiPBv9p15QaVSfQmg24Fv38Tw/r0w8LZ7cLjQJKeuHmNY8uYaOG7QTWM0GnH27Fn06HEpDthqtWLevHno378/HnvsMTgcrtGYzWY89dRTGDp0KCZNmoRTp04BAL744gs8+uijGDBgABYvXoysrCzMmTNHbLqMtWvXYuTIkcjKyvL5pPQ1hl9++QXjx4/H4MGDsWTJEthsNgBAbW0tZs+ejaysLIwfPx6//PKLtM9dd92FkSNHYs6cOZK6I8qnn36K4cOHY8iQIXjttdfgHTTuPYbvv/8e7733nvT96dOnsWDBAokpLVu2DEOHDsXYsWOlMZjNZkyfPh2vv/46hgwZgokTJ6KoqAgA8MILL2D//v3S8VavXo3Vq1df9trs2bMHEydORGlpKebOnYuJEydi586dAICnn34aTzzxBCoqKjBx4kRMnDgRLMte9njr16/H66+/jhkzZqBfv35YunSpNA/Lly/HqFGjuixcuPCDXbt2zf3www+jKaUBADSUUhWlVCkIgpLneUbc3MBGDAYDamtrUVtbS2w2G3Q6HU6fPg2j0Yjs7Gxs27YNR48eRWVlJcrKylBQUIDi4mLU1dVJv5+Xl4d77rkHgiBI4509ezaOHj3qcQ4bN27EqFGjwDDMFdf25dbDuXPnMGHCBAwYMACffvrpFdfkhQsXMHPmTDzwwAPo378/Fi5cCMh0c4+t8sQG9GjfEp16jcDSV97B6RLXiVLegFkjOqH7sGn4btN6zJpwK1r3mIASO8Wuj+ejRYs+OGmmoJTDI4NSMGz2W679qvehS4sWaNm6E2bMm49F85/E3nwz+LoTGNC+JUY/+Cw2rF+N0T3bYtTjrn1OrFuGli3aYv7rK/HK0jlIiolC1rQnMH/+fEyfPh3jxo3D4MGDkZmZiY4dOyI1NRUaBQFRahAZGUlCQkKIVqslarWaUSqVCuKyKapXrfl28OIHR//Ysm0feqyao47SPbRrSgs69qGldP3alXRYt1TaesTjlFJKT6xbRlu2aEufeet/dO2nK2inlJZ02boT9EbIqlWr6Ntvvy29//HHH2n//v1pWVkZdTgc9M4776Rr166llFK6YMEC+q9//YsKgkAPHz5Me/ToQa1WK3399dfpf/7zH3rkyBE6dOhQynEc7dWrF62traUHDx6kI0eOpHq9nur1ejpkyBB68uTJy45Bp9PR7t2707Nnz1Ke5+nChQvpG2+8QSml9P3336eff/45pZTSQ4cO0X79+kn7mUwmajQaaXp6OjUYDNLn58+fp/369aMWi4VaLBY6ZcoU+ssvv1x2DDU1NbR3796U4zhKKaVLliyha9asoZRS+vrrr9Onn36aOp1OevbsWZqZmUntdjs1GAw0JSWFHjhwgFJK6YoVK+j8+fOleZ05c6Z0/GHDhtHCwsKrukZDhgyhubm5DT4/ceIEHTNmzFVf648//pjedtttVKfTUbPZTAcOHEh//fVXSimlNpuNGo1GOmPGDPrjjz9Snud/KiwsnACgGYAmAKIIIWEAggAEMAyjJoQoCSEKtVrNBAQEEAAkLCyMxMfHIzk5GQEBAWjevDkyMzMxePBgjBs3DtOnT8f8+fPx0EMPYeDAgTh+/DhYlgWlFGPGjMHOnTtBKcW5c+fQt29fOJ1OD8wYN24cysrKGmDJp59+iueff97jM7eqjPT0dBgMBunzjz/+GGPHjoXZbEZVVRUyMzORnZ3tse+qVavw9ttvS+9Pnz6Nrl27oqysDFarFRMnTmycscWlj8bWrd/jvqwO2P/NexgzeAg++fkchOID2HHWgIkPPo3bR47BosfuBlt9FLtP1l8VCxn16HJ8+OoyvLjsZfRpGYSCg7tRaGUwfd4ijB4zGW+8+wFmjuvtegJ8vwE0LAF8xRnkFBkQoHDi9PGjUpyad0iHzWYDTykg8B6qp8vrKTAUUMx+Y9PDUyeOX7lk/syhGnsZtu3ORf6vh1DPB+DBp5/BmHH3YGCXhEtPoe83ABFJSFAYUWULRGIEg1279t0QxrZ27VqMGzfO47M2bdogISEBarUa3bp1Q0VFBQDgp59+wowZM0AIQffu3ZGcnIwTJ04AgFR1NSQkBEqlEkFBQWBZFps3b0aTJk2wdu1arF27FjExMTh06NBlx3D48GF06NABbdq0AcMwWLBgAcaPHw8AmDFjBhISEvD2229j586dqKmpkfYTf987IDQuLg4qlQrvvPMOTp8+jZUrVzZQMbzHEB0djS5dumD37t1gWRa7d+/GqFGuZJAffvgBISEhWLlyJQ4cOACGYXD+/HlpDD179gQAZGRkoKrKpWkMHDgQOTk50Ol0OHnyJOLi4q5HW79rlu7duyM8PBxBQUFo3749KisrAQABAQEICQmR6qsxDDO4WbNmb3zzzTdT3KppgKiaAhBVUwUARsyeIYQQtyON2O128DwPu90uqaZ6vR51dXVSYLvRaERubi5OnToFu92OGTNm4PPPPwcAfPXVV7jnnns86r3l5uYiJCQECQkJV3Wuja0HAOjcuTOCgoIQGxuLYcOGeTD/xu6LhIQEJCQkQKvV4q677moM2FhsW/MZ9hcyeGzxMmzbsxe3d1Dhldfed3lQAGg0ruatKvcrx/LufQXIGGsDCfeKl2E5BwAFNBqXg7ZFeh9k9e3sopwmCzibHhfOn0dhYRHCk1IRG6K8XPcoQkEIpYJUO83p5Bie55nivO0JvVq2eC1Aq30DQIJSo4YCAMez4Jw8AAWUmoZOYrvNDiXDo6ayEpWV1eiSNQVZvdreEFtieHj4ZauhMgwjqQscx0Gj0UjfabXaK6o/NpsNoaGh0jZ27Fj06dPnsmPgOA5qtVp6HxISIpXFee2117B+/Xr06NEDI0aMuKrzDAsLw8aNG5GamopvvvkGw4YNQ1lZ2RXnYerUqfj222+xfft2DBo0SAoytdlsiIyMlM5p7ty5PudQPndKpRLjx4/H999/j3Xr1uGuu+760213hBBcIY87Qa1WvzRz5sxnNm3alCiqpjKAE4GNcduTIQgCcQfnEkEQiMPh8HAq6PV66d6yWCwoLCyUwK1v377Iz8/HuXPnsG3bNkyaNMljMGvWrMGECROu+zyo1WrIS6tdzX2h0WgaAzYljv+4Ek8teBZ7T+ajtLQQerPrxlE064ZO0Sr8sO5/KCwtxaovNwCBLdGtYwziY+IA1OGXg9nIP7kLF6r5Kw68ZZcMRChYbPpmHcpK8/DYuEz0vudFmEwmNEm+BZbaKgih8bilZTMoBRYBakWDODV3xVvCsiwUhABUICzLEZ7nGUGgzNCHX+3XpHnmh5ntw2bu2rgG54pL8e2qNbCQEGR0aY1bOnREICxYv2odCs8fxcm8Oml8fXr3BKfXISEjCw8/OA1t4sOQkdHlD1/Ya9aswR133HFNT/stW7ZIbvbs7Gx07NjxivtUVVVhzJgxmDBhAlq3bu2xYHyNoXPnzjh69Cj0er30Px988IHktR03bhy6d+8uqQlXkl27duHll1/GbbfdhldeeQVt27bFwYMHrzgP3bt3R2lpKVauXIkpU6ZIn2dkZIBlWUyYMAETJkxAQkLCVQWfTpo0CevXr8fhw4evyXiu1WpRV1f3p4Bfeno6jh49OqNXr14vFRQU9PDlWACgEASBEdmb6DWllMKXU0HM1rHZbFIJ/by8PJw9exaTJk3Co48+iqFDh3pUCeE4Drt27cLQoUOvy3kVFhaCUgqHw4Hdu3ejQ4cOV1wPOp1Osjf/9NNPjcWxMXjspf+iev5CzBg3BBwFolt2wcsvz4FS3QTLXv8XZs57HgP7rYI6rCmeeeVtpIUCGHwnRqV9g+UP34ZPW/dDi6Zh0F3hJDTJ/fHK0gfx1L8Xoe+7HKKad8VzC6fg9OnTiO44BJmtL+Dnbz4D6+Sh0IagZYoGAXB6x6hJ8WlQKAgRBCIIPAHADJ74yNTX/+/hZwjRpix4+XUUPTIPI27tB0VABO5b+hqGttICGIolDw7Bsx8+jR9Xx6J9wqWqo8Mffh6Plz6BNx6fguU8EN2qK17qPxlA+B+2YFmWxZ49eySD+NXI0qVLMXPmTGzatAkVFRVYunTpFW/o8ePH4/Tp08jKykJMTAwUCoXk5m9sDAkJCZg7dy4mTJiAmJgYAJDc7jNmzMDChQsRGxuL2NhYCIIAg8GAsLAwjBs3DvX19TCZTBg1ahSCgoKwZcsWZGZmYvXq1RgzZozrwalQSDfI5eaBEIKJEydiy5YtSEm5VNdz4cKFePTRRzF27FhQStGuXbur8qaKPQNatWoFpfLqwzunTp2KOXPmoHnz5hg9ejSmTp163dfD888/jx07dqC2thbHjh3DSy+9hPfffx+tW7fG1KlTMWrUqIFxcXHNBg0a9NbPP/+80Z2GJa/szAMApVRwx25CoVBQkRCo1WoaHx8Ps9mMU6dOSWzxs88+Q/v27TFy5EgIgoA2bdqguLgY9957r8f4fv75Z/Tt29eDyQPAhg0b8Nprr8FkMsHpdOLnn3/GI488gkmTJjW6HkSQGjt2LPR6PXr06CGZDy63HhwOB+69914p9OaKZYtYhwlWB4PwUK/O04IT9Xo9gkOjofZYBwL09XoER0ZeU/SvwDqgN9sABjibk+MRzlFdXYXaeh0cNluDbAI5qMmyCJhpd09VLP/PfxdEhwctgkcgsmt82uBwaNSehNVm0QPKYGh9qKSswwKjjUd0+B9favns2bM4cuQI7r777mvet66uDqGhoVCpVFe9j81mA8dxHmWkrzQGlmVhNpsRGRnZYIHZbDaEh18b8JtMJhBCEBwcfF3mwWAwQK1W/+48yClTpjSIu9u4caOH50/skXGlcy4uLsYjjzzi8Vn79u2xYsWK3zy+mpoaaLVaMAyDf/3rX87ExMTX3nvvvY9OnTpld6dkce7N6a7zJhBCBHkhS41GA7VaTcXabmLpI7FoZVRUFOLj42E0GpGTk4NVq1Z5nOunn36KPn36oFWr6xfQLibry0NBGlsP2dnZWLhwIb777jvo9XpERkbeXPXYdDodcrxATXQSiM1W5N2jZKAmr5vGVFZWJkVFRT1DCJkBv/jlbyqCIODuu+9G06ZNwfM8Tp06ha+//hohISErd+zY8eHw4cNLCSEOL3DjvcBNKj0ugpu8G5YIbqWlpSgoKMCsWbPQp08ftG/f/qbJLxWBbcOGDZcY/c0CbHJQKykp8QA1ecMVH0xNTI1iBEEgJpOpm1arXeivmeaXfwq4ZWdnw263Iz09XXIg8Ty/JTc397127dqdBuCQsTenu7kM7+6xIIiNY+TgJpYcF72XYg23lJQUqWDlzQJuVqsVhYWFHkHQNwWw6fV6ZGdn+wQ1kan5Uj9lWQSEUsrYbLZharV6EfyVbf3iF1BKD5eXl7+TmJi41wvcODe4SczNXX68Abg1ppaK4JaWlnbNZocbIX96ErzBYPDJ1HQ6nc8KHV7qpwRqDodjslKpXASglX9J+8Uvrkq9CQkJkbW1tW9FR0dvppQyxBU4RiilHNxOBcGdUuAmORQuxwP1AZS+fgNpaWm/KS3qbwtsJpPJp01NBLXLqZ9yUGNZ9mGFQrEYQIx/OfvFLx7AkxIVFbVYr9cHh4eHf+Mud0S8NTYR3JxOp09wawzUxK1Dhw43VaMY5s/6YYvF0qijwEcTY9IYqHEc95RCoVjuB7XG7Q/33XffTTWmwsJC/NUadb/88svo3bs3hg4dKqUaTZ48GZMnT8b06dOv++/t378f17Hnb0xYWNgSs9l8LwCtLJhXnqkgZSk4nU7irlpJR7QAACAASURBVNMmJdDbbDaPQN66ujopeT4/Px85OTmwWCw4e/aslNHhLfPmzZMyZRqTzZs3SxkOfzlgs9vt1+L9JPIOUqJN7Z133lFxHPcswzAvwpVS4hcfwvM8jhw5clON6cUXX4TFYpHeG41GzJ49+6adw5MnT2LLli346aefsG3bNnTq1AkqlQqvvPIKnnvuues+vzU1NVi+fPk1hez4kosXL+K5554T3wYEBQUtrKysfEij0QQ1Am4KQRCIvPyRu9KuBG4WiwVGo7FRcHviiSc8Uq3kcurUKalgQmNSWVkpFSf4S6miHMdd1vvpZVMTcz4hL8fy66+/Bqenpy9iGObJvyMYHThwAM2bN8f+/fsRFxeHvn37Sjl1ZrMZ27dvBwD06dMH0dHR0n7l5eXYt28fIiMjMXDgQJ9VFk6dOgWNRiMVEaytrcXOnTsRGBiIfv36eagTR48eRV5eHvr164fc3Fzceuutklqyb98+lJeXo3fv3khMvNQOoqysDPv27UNoaCgGDhzokeYFuLIiampq0L59ewBATk4Ozp49i927d2Pbtm0AgL59+0rxZ8XFxThw4ACSk5PRq1cvCQgvXLiAmJgY7N+/H6mpqejSpcsVx0Apxd69e1FRUYGePXsiOTlZ2icnJwdRUVEoLS1Fbm4u+vXrh8TEROzcuROHDh1CREQE9u3bB7VaLc1D06ZNYTKZGmWlhw4dQlJSEnr16gVCCI4dO4bU1FRotVqcPn0anTp1woULFxAYGOiRY7lu3TqMHTv2iuvh+PHjiI6ORlJSEgBIebODBg3CsWPHcPToUezatUsKcB06dCi0Wu3c1q1bq4cNG/bRyy+/rHerlKLdzelWS3l3qXxRLYXD4SCCIFCj0Qi1Wo3ExEQPVZQQgpKSEgQEBHjY28Tr56ts09GjR5Gbm4tu3bp5xMAJgoAdO3agvr4eQ4YMkY73yy+/oE2bNggLCwPLsjhw4IB0Lex2O7Zt2walUol27drdWMZGKfUANXkyu3fTFVlvAg9QO3/+fER6evrSvyuoAa4yOk8++ST0ej2WLVsmZQPodDrcdtttKC0tRWFhIUaPHo3a2loAwLFjxzBp0iTo9Xps3rwZDzzwQIPjbtmyBfPnz5fA8OLFi5g4caKU/D1mzBgpLWX16tV4+umnYTQasWjRIjz99NMeKsXXX38No9GIKVOmIDs7GwBw/Phx3H333TAajdi5cycmT57cwDazbt06jwTmuro6lJaWQhAEFBUVoaioSLTzYOfOnXjggQdgsVjw7rvvSoGspaWlmDVrFt544w3odDrMmjULu3btuuIY5s2bhy+++AImkwlTp071KFW0atUqTJ8+He+++y5ycnJQX+8q6lBSUoKamhrYbDYUFRWhtLT0itdv586duO+++2CxWPDRRx9JkfIbN27EkSNHcPbsWTzxxBMAgPfff99DPaOU4vvvv8ftt99+xfVw/vx5PP/889L/bd26FZ9//jkYhkF1dTUqKyvBsqw0r6KwLDvL4XA8PHHixGgAYvFKFQClIAgKAApKKWFZVlJLTSYTqqqqYLFYUF1djZycHA/mVlVVha1bt6Jdu3bIyckBpRRnzpzB+PHjUV1djc8//9xj7l599VW8/vrrsFqteOSRR7Bjxw7puw0bNuDo0aM4ffo0xowZI7H75cuXSyYMo9GIJ598UgLCqVOnYvv27cjPz3dlfzRWtuiP2E6fPo1vv/0Wr7zyCubNm4epU6di5MiR6NOnDzp16oTU1FQkJSUhNjYW4eHhJCgoiGg0GkapVCoUCoWysLAwThCEN+nfXIYPH06zs7MppZSWlpbSDh06UKfTSWtra+mxY8copZSyLEtnzJhBt2zZQiml9P7776ebNm2i7tLQdMGCBVSn01Gj0UjT0tLo1q1b6ZAhQ2hVVZX0O6WlpfTMmTPS8bKysujp06cppZT2799fGkN5eTnt3r07pZTS48eP0xEjRlBXNWpKv/nmG/rUU09RSin99NNP6ezZs6nT6ZS+s9ls0u8JgkCzsrKoTqfzON+amhratWvXBvMwePBgaQwWi4V27tyZOhwOmpOTQwcNGiSN4YMPPqDPPffcZcdw5swZeuutt1KxR+euXbvo+PHjpd+aP38+ff75531ej02bNtFZs2b5/M5oNNKOHTt6fDZq1Ch6+PBhSimlHMfRnj170vz8fPrdd9/Rd955h3744Yd04MCBtLKyko4dO9Zjjo4cOdLgtxpbD3a7nWZkZNDi4mJKKaV33nkn3bFjx2VLJxkMBpqWlkY5jqN2u/2D2bNnZwBoASABQBSAUEJIIMMwGgBKhmEUGo2GIYSQwMBAEhsbi4SEBDAMg06dOqFPnz4YOXIkJk+ejCZNmmDFihX49ttvpRp5H3/8sXT/9+vXD/n5+aisrERGRgbsdjsopTh48CCmTJkilS1atGiRtM/06dOxfv16UEoxduxYnDhxApRS1NTUoGvXrqCU4pdffsGIESMgssy33nrrxqmi586dw4ULFyT1U97zU7SpNRJ8KzG15OTkRYSQ2fgHiJiv2LRpUzAMA6PRiJCQEKxevRorVqxAaGgocnJypCd7YWGhpF4SQvDvf/8bgMvzbLfbMX/+fPTs2VPK7wRcpWOef/55WCwWBAcHo6KiAjzPS6xIPJ7c1pObm4vy8nKMHDlSsuG1beuqdjJ58mQUFRVh2LBhSE1NxbRp0xAQcMn8eeTIEaSkpFxV3BPP88jPz8dTTz3lMV4x+V6r1UrqeXBwsFTJpLExFBQUoG3btpJ6npaWJtXjF+V6pQRdvHhRUr2USiXatGmDwsJCpKenY+fOnXA4HJg6dSoOHjwIpVLpMUeNJXn7Wg8RERGYOnUqVq1ahcmTJ6Ompgb9+/e/qrXl3h4YN24c9u7d+8GJEyfqvbUrd84oL+aX8jxPWZYV+//BZrNJamh5eTliY2NRXV0NlUoFhUKB06dPS+Wk5OsoPz8fFotFUrcFQfBYE3LzRWpqqke1F19SVlbm0SNVpVLdGGDLz8/3CWo+KnQ0COkQbWotWrT4x4CaXIxGI1iWRXBwMLZs2QKj0Ygvv3RVJX700Uel/4uOjkZFRYWUEL5nzx50797d5SFiGGzevBnz5s3De++9J+Urrl69GomJiViyZAkAeKg/UVFRqKys9LCfiZ+3bdvWZ4XZvLw8PPzww3j22Wdx7NgxPPjgg9i2bRuioqIue9MSQjyqswKAQqFAeHg4PvzwQ6kskiii+u1LGhtDTEyMxw1SVlbmAfLXU8TfEpvuiL/VvHlzVFZWIjAwEIMGDcLixYs9GqZYLBYcP35ceihdaT0AriT8ESNGgGVZTJs2zcOu6mtevUWtVj/Qpk0bYdSoUe+/+OKLaAzcRADiOE4KBREdAYQQXLx4Ed26dUNtbS0UCoXkQDh+/Dh69+4tHU9cQ9HR0di0aZNPO7B8zOXl5cjMzBTHKj3A5CaOqKioBur8Hw5sJSUlUtMVb6bmbVPzFdLxzjvvqNyOgjn/JEB77733MGXKFKxatQojRoyASqVCbGysVA+ruLgYu3btkkrsTJs2TfKk5ebm4quvvsKGDRvgdDqhVquRkJCAt956C7fffjvatWuH/v37IyYmBlu3bsWOHTtw4sQJnDlzRrKxTZo0CQsXLsSDDz7okYPXt29fvPLKK3j11VfRv39/7NixA0lJSZg8eTKOHDmCbdu2Yc6cOaipqYFarZaevmLliOXLlzc41/DwcCgUCnz11Vdo0qQJ2rVrh5iYGDzwwAOYM2cO5s2bh7q6OmzZsgX//e9/LztvjY2ha9euIITg7bffRkZGBpYtW9agSsW1eps3bNgAu90OjuPw3XffITQ0FIMGDcL999+PJUuW4Mknn8TevXsRFhaGtLQ0EEIQGBiItm3bIjk5GUVFRR79ADZv3ozhw4f7vNl9rQfA1U1q8ODB2LBhA/bt8yyAmpSUhOLiYvzwww8ICAiQAMJbFArFQwsXLnTu3Lnz/f379zewi7rf84IgSHFulFLicDgoIQTypuN6vV4CttTUVLz77ruIjIyEzWZDcXExAKB169Zo3rw5Fi1ahPHjx+PYsWOwWCyYO3euNA9du3aFyWTC/v37sXjxYgBA165d8fnnn8PhcOCHH36QxpeZmYn/+7//w3vvvYdWrVphzZo1UCxduvQPuzmrqqpwzt2jQN7M2GAweBSI9E6TkseprV+/fgnDMAv+SaD2xRdfYNSoUTh48CBatGiBuXPnQqVSITExEYmJidi3bx/i4+MxYcIEREVFITExEa1atUJSUpKrFpVSiRdeeEHyLCoUCnTv3h1BQUHo0aMHzpw5g/T0dLRr1w4qlQqHDh1CWloahg4dioSEBMTExCAjIwNWqxVHjhxBt27dcOjQIUyfPh0KhQK33XYbcnNzcfToUbRp0wYTJkwAwzBIT09HUFAQdu7cCYvFgsWLF0u9KtetW4cmTZpIHjq5MAyDXr16Yd++faioqEBaWhpCQ0OlirKi+jZr1iyJqQQGBnrU6YqLi0OLFi0aHQMhBCNHjkR2djaOHz+OiRMnNmgy0rJlS8TGxvq8JlFRUQ08d9u3b4fFYkG3bt1gMBjgdDqRnp6O9PR0hIWFYfv27YiKisKzzz4rlfSJiIhAt27dEB0djejoaGRmZkqe6Oeeew6PP/54gyj+xtaDnDw0b94cAwYM8NhPq9WiY8eO2LNnD3Q6HTp16oSAgAAoFAp069ZN+r+wsDB07Ngx484777S/9NJLp2WMT0Q4KqqccianVCqJ6NQKCQnxqKRCKUVkZCSaNWuGEydOICkpCVlZWUhLS4NWq0VWVhaqq6tx8OBBxMbG4t5775XU7d69eyMvLw9lZWV49tlnJe91t27dUFpaipycHEyaNAmxsbHo2rWrVOrq8OHDqKqqQnx8/B+XK6rT6ZCdne3B1ryzCrzDOuRxamLwrTtOzS9+8csNELPZ/O+QkJD/AbC5K4M4ALCQVQYRc0uVSiV1M2Iq5pWKSfMRERFSXmlycjJSUlKQlpZ2w5Lm/xBV1GazSR3aKyoqUFtbK7XHu5z6yfM85GlSDMMs9i81v/jlxklwcPBcnU5njYiIWOdmZhTuWDav9CvqInXElaNFCGUYBgzDgBAC8W+lUgmVSgV3cj06duz4u2vk/SnARinF+fPnUVhY6KF+yqt0iB5QeZFIt6uWERPa3bmf/owCv/jlxkpAeHj4Y1VVVZa4uLit1JVc6m1vg7uHguB0OkXPqAhyIIRIdjZxEwFOo9EgPT3dZxOXmxrY5KAmNjIWHQUWi+WylW8FQSA2m22Yu0qHP/fTL375cyQmJiZmZkFBgbFFixYHvJgbBUAFQRC9o5ABGhGLV4qbHNREYAsICJCaKv8lgK2wsBAXL15EWVmZT0eB3W5vkFUgC+tgTCZTN3c9NX/pIb/45U8UQkhKcnLyQ8ePH9d37tw5x83cRJWUin0RRNYGmYNBVEW9GZtSqYRarYZarZb6mv5Rct28olVVVZJdrby83KddrTEPqFjOOzQ09CVCyED/svKLX24KcGsaExMT2qlTp9Nff/21zQ1ekqcUPmq2uVVS8W/555B/Loa+yHtcXFfGdj1ah5nNZpw5c0Zia2IOqHebPIfD4eEBFdXPu+66SwHgmfr6en85b7/45eaS4ZmZmTUpKSmvXbhwQZAxN1f6gfsP9yvcWQnEnUIH+eZ0OqXNXTUE7dq1+0PATfl7az5RSpGXl4fi4mJUVFQ0sKs1VtLb7SwgAJhly5YtcDqdN6TxithT0bvqxJXEYrEgMFALQhj/UvfLP4253b1169bqlJSUz904JsjBjRARxwTK8zzhOI66aRsVvaRyFdXbY9q+ffvr7kxQBgUF/q4D5OXloba2Bnq9DmazCVarBXa7pHLKKnQ4iRidLPeA1tbWTHU7C26I8LwTTiePaz1vnU6HyMiIa+o5aTAYERIS7DOS3C9++StJUFDgnPz8C5W33JKyFYA3c5P+TxAEged5OJ1OKBQM4TiOKpVKiaHZ7TZYrRaYzSbo9TrU1tagoqL8urbuAwDltdyo3lJWVoaysnJUV9egvl4Hg8EIs7lBjwI3uEmgRtxUldTW1vQNCAh4BjewLpzraSHgt5y3aAC9WjGZTAgLC8XvmWO/+OUmEWV8fPzDx48fq+zcucsxX8zN/UoEQQDP85TjnGAYzivkQwmVSg21WgONJgBabSCCgoIRGhraICf4dw22sWqXV5LS8jIcP3sBOndGgcFwKandbLbAbLWBvQRsIlsjvCAQKlCmqKgwISgoaD6AlBtLqxkpzuZaVW55cu8ftc8fIfpje6BoloGQqBsTFkg5O6w19VBGREOjVQNwomLrJthsgKppGyRltPlb3Om/ZV5thTmwOKMRnRLXyH/YUbXjMCJv7QeVm+g7ik6j7Fg+AILYQaMRHMpcx7FEIDol4Wp3uaV169b3r1y5snzatGnlAMRAXfGVip5SnufhDtqVQkAueUct7tAPtbsTlhbBwUEICwu7pqYwjtJcGIxaxLZLanBOymtWk6gViz7YgP1F5SB1ZSivqUfXuFAoLSZYLGaUlJWhsN4MwtkgCECIEsTpdMLJccTBOQngsqu9k2t++rn4+CHkT1iQlOKa1UMxP+5a9vst+/wRUvLZcgRN/gxhvQP/8N+q2/YZDr/yJbTNWsBRVoBm899Fm/5JUAUEwnJuN84dqEKzzHZ/C2D7LfNqOLAGhfpMxKaObIznI/+9zxDY91Zo3ESfUWqg1gbg4tsvQJ1+G0LDG66nyu8/RsDtaQiL8RxLwftLoez1GJI6RDbYx3ziR5QYOiM2NfFaNJ4B48aNK5w2bdpbMtYmyFgb4Ipzg1slpQzDEIWCoQ6HAkqlaxMzEdTqS23+goOD0bFjx6smApbjm3H2VBLi05o1OKdrBzao0T+tDXo2DUFhoRq79pZi7zkdukcoYNbX4WKdFYnhgeDtQEV1HTErlVAITnCuCGVCAMZSm//QyDf2zMzJTEXHG5xbIDdi/jY1lvnD9wEEUDBw6qvA0SAERnh6jSgEEDCwV5VD0IQjMPzSYrZXlYJXhiIoKvTSDqwdoATOumoImjAEhHqmtDiNdbAZHQiMi4dC9dtBmC/dj/2LV6LH2o1o0iwUEGyw1nNgGA3iB49AMFOO/AKLj/kQ4KipBscpEJQQA8+HHQ9beQUEVTACY8I9vqMOK8xVtdDExEGt1dxk8+r7nAjPgToFUKsBNgsQHBfhOT5nDPp++xmIbI60zdqhebN2qPxoCYCGa5c6nWj/3CoQZcPPzacOQNlqOogQDiiV0jio4ET87fMQL/vs0jA4WMsrwETGISBQ02Ct8EbHfVUVVYVxTeLWA+B9qaSCIAiEEOp0OsEwBA4bJYQw1KXBKKFUutOsVGoEaNRQOOzQKLUIDQ1129sE2CrLQQMiPa4DAHC6KnAkBETgQJ28NB/yc1JeqzeioqIeak6PkqpK1NXVgzhZ2MwmWNQq1OoMIAoCcC67moJQcCwLEEqoq6Y6sVhM/ZTOuvkco0SwkoCQGw1slwDutzC2a9nvt+wDAOefmYiLuSowSiWEyosIvn0h+s4d7frSeArr+z+DpGExqDylA8w6dPjkJzRLMuLQfVNRZ42EylIGkjYRt746GyoGoE4OhW/NR7FKAXvBGcTPXoHud7kKEhb+51Gc3FSCiOYRMF6oQ8Z3GxErPdwdOPnkTKgGzUK7rC5XXhs/rIeq+wQkNHerE4pABMnyRwgVQHnBaz6qsXPweLAxLaGCASZdKPqu+hCRMRpQUzH2TLkH9tCWUAs62BMGIutVV0k+/e7PsWfRJwhtmwJ72UUkP/kJ2g1sfpPMa+PnBIGH8eeV2H7gKzCWMqD1nRj4xiwoAVSu+y9OfbkD+mN1GHxmLyK9sZrjAHiuJ/bsz9j9/EewnP4Vrd/ei7a3NnGpZMc2Yd/LX8CSUwJS8DjKP9Ei+rZH0GVyPwBlOHD3k9AVnkfI7YvR/+lLpdrtuXuwe9YiME1agS3MQ9xDL6HbXX19rZWH9xzILuzXK+2YSxWlAkAEUS11u0kJz7Jw2u1USQjsOh346Hg3a1OC6MtQ9QuLWpUdQepgXFT+iIB3XkCgvQx5zzwHNrQZUH8RQUPnovcT40Ag4OJrs3FyYyHCYjXgWAdIm2T3fHie0zUBm9VqlcI6amvroK+vxvHCSsQFh7rac9nsILwAo9EGo8NJFFQAFSihDAhDwIxbsiL8kTU7n6qv0ydMGz8YKeo/QxH9bcD2e/a7ZhDlnXBG9sKoj54CMeXhh8zxqJgyAgnxShevqDkFReZmjF7eEQALJ6tE1eo3UaXqh9HfL4bCacCuIZnI2zMO7QckArwTyrQsDH5uCpzle7F+wBK0GrcLEYHVOPfhXmTsOoWEOABOFjwjf9gIMJw6Ak173VWdg+XCBQQn92z8f6kAwekNbBHos3471CEu6p73whSc+WoX+j42HOYDP6A+bDDGfeEqhMmzrLRv4ecfoNnTn6HTGNfTnWeFK47xxs1r4+cEgYcVyRj77ZtQCwbsHNQD+YfuQJuesWgyfg6ajB+LH9pMdAOY1/idHEA9gU3TbjCGfjUYR+7qBtBLay2w62gM/Wo0jt/fG6o730La0GTZkRLR58uvUPL+Y7hQT2XHs+LIY3OQsOBrdBzcGoLpPDb3m4H6MXsRFdJgrTRhqWLasmX/Lliw4BmBUgiEQIDMY0opBQUEyiig0AZQFZzEXFtDtaGBUCjsICwLc1014oePRGyLJoiLjkZtRQV2/udVJI18GcNnDQGcOuwYOACl40aiqfoQjn5yAUMPb0V4kIDj9w9GlfSg9Dyna3LXFRQUoKzMnQNaX4uDJ87AoQpCssIJs9kOjmUhcAKc1EnAS4ntEAQQQaDEkdzpybn92w2tLzmPV7cfwajUEYhTwS8+JLZPL1ennZBWiGkD1J8qR0K8e3FqUnHL6I6SaUCpBnQnTyKu75NQAIAyDE16t0f16dPAAJf9JK6nq4qpMqE7oqIuoj7fjogOkYjvGYkjD0xD8pB+iB84DPHt5faWQPT/6dQffKYMqje+g9zvdsNmtoOtLkKIu5y0Nq0rmFMPYNccB+J6dEXyyJEIUrvnp2cvHPjXLDjPjkBUj35IHtDlJppXZaPnBABRmZlQMwCYMMR3b4X67Gyg502QcGPKRXW2DYq93+DYQZdqTp2l0BWYEdXR51oZOHv27LMLFjzzsVsl5b3sbdSN0JTneTAqBgLlic3OUqVCAcJycAZGQCAsjEYjNBoNAmsKUH+sCHz0ehyr/wUUAOt0oD6nBBGqM2DSMhAexABgEN+3J6rONLaqrtZQWlKC0tJSVFdXoa6uFkdOnEKJQ4HWoUrY7a5qHVQQIHAcGMJAzQC8QAlACaWUmfb8f8ZNHdrn6Z7N4zGybx+05wqxrdDiR7BG6cVlvtMG4fdFkBD3lVei80fb0HvxdKi5MuwfPxR5x2p+81GDWjaHsaD4mvax7F+Jgx+fRJd3/oeRW7ag6/1D3doMoEzsgdH7fkLKkE4w7VqFH25/DKx7v6YPvIwRX65AeHwAzi+5B4fe33HTzOvlzsnnXoziJll0AqCKRPzILCRmZSEpayR6fLoWTW8JbHStBAYGziopKe4LVyUeDaVUDVf4loJSqqAAQyl19yrlwQPgOBYs64CD48BBgNVqhclkhsFgQF2dDjqOAduqLUiXLkjKykKXN/+HlF7XFgpyVcBmMpk8eoAeP3UKZ4wUHaI0YO022O0OsKwDCgCUtROHK2aNUEEgBGCqqkqTQgPVTxTVGlzTZzegxEIQHOCP72pMqvcecBkrTHmoOQdEdry8Sz4ivQOq9u4FDwBOAyr25yBSVmG26uBel/G3/FfU6VohqkUAABasRUBURj+0m/csUvrFwpgv7+LNIuf/5uD89qtjbQmjx4HdtxplBQb3fWKFpdpwye0UGQm2rAROuXmjrAwBrdIRHhMECBaU/bT3kqHaZALC4pA4agK6v7YUypJzsLp3Zk0mBN3SCSn3PoxOD94G/bm8m2ZeL3dOAFC3bx9YwXW8yl/zENkh7ercdpHhsFyhsYm3KDUasHX1V/fPIW0Q29oGqykcsd26IrZbV4S3aAZVEHPZtdK0adN7v/lmTRMR3ABI4AaAoQLPuOxtTsITQHByhGU5ODgnWN4Jm80VtOsCNw60aSDKCqtgiwiHtnUqolq3hDokEEGdOoBmH4beIgBwonLvwcbP+2rO15XY7i4YWVOKA3mVsLF27Cm3QWDtgAAkBCnhpCAqxtW9BtRVh44BmKiouHmPjuzd7YFvN+LokRjoa2uR0LEnRiRp/AjWiChqD+LHcXeAr76I0AdecNuBGpf4Ox9H3A934ocRJ6CylYGkPYRW/S+pldzJLdg6cSvsBWfQfMlbcDmaqrFr2FjwCalQox5G8y0YOFQeisGhctM3UMcOR+vBHa98EyX3R79/T8H+2/sjoEULOEqLkfLSanQY6nImaLqMRKuWX2F9t97QdBmB0R8sQtSgSVC/dRe2TDwKxlaPgOhLDgDzwf/h58VfIqJNC9gKziB65gKEuafh7II7UHRRi5AYNXS51ej6weM3zbwKlzknANAqyvHT7ePAWMrAdHoMt2REAdDh4D33QFfvgNFQgQPjRkOpbYE+a9+E2MK69dz52PnYOOQvDUb7l79Eq54JyFvxKPL2FMGaWw1Sci8KX9Mibfn/kNzetVfyPQ9j1xOPoOyTEMTd+TQypg9G7dZ3cPjtLWArL8LB/YrN+1eiyX0L0Xl8T3R783XsfnAqSt5LgZKrhdmSgCE/fYzgy6wVQkjnUaNG3QHgvzKVlHfTVIFSSgWnkwoAVSrVcDqd4DiOEJ6nnEBht9vdwbuuyh9RPQegavtKbDz+E3IiAxBlDUPfDd8jJr4vuj7QEj8PG47QWC14qnE1DAQanBOhGmnQgQAAIABJREFUVLiiCiomuJeWiuWI6qDXG3x1mXInuHOE5wVCKVXY7baJKpXqfy7rL4dygwUabRCitH+Oca26uhosyyEx8dqobXZ2DlJTW0m16/+ofQDg7FOjYem6FB2HJYITghEUFXTV+7rCEkIQFNUw0NFRUwkhIBTakEAP9cNWWQknVAiOj8H1cOdQ1gpzeTVUMfEICLqKeB6Bham4EurYBGgClV5fWWGprIUqIhYBIZ7HYg01cBgcCExIhEJ5k83rZc4JAHhLHWxmxivc42YRAdbyUlBNBIKiQq56rZSVlc1NTEzaBcACV2lxO6WUJYRw7rLivHdJca1Wi8DAQAQFBSEkJATh4WGIjIxCbGws4kID0axZK3TunYnkpEtBuGxdFZxMMAIjgn4bY7NYLCgtLUVVlby2mgkWi9WdD3opbcrplHJBiSC4gnBLS0viVSrV3EuPSxUSIsPhl6sTdUQc1Ne4T0Bc48GWmph4n9YIbXzCdR03UQci5FpqbTFqhDRPbuSrQIQk+/5OHRYDddhNOq+XOScAUARFITjoZl15DAITkq95rSQkJEz79NNPcu67734eAA9QibXhUoFKMZeUKhQKwrIsdWUkKKBSKWGxqKTOYoGBWhhYO8pKSxEVGYmgINeEqaOufP0ua2O71ITF1TJPBDVXaW8HHA4WHOeRMiV6QgmllMTFxT0OoKsfoq5NEmf8H1JuTfFPhH9e/1JCCOl0xx13THDb2TSUQu5IYERckGUlgOM4wnEsHA4WdrsDNpsNFovVnSSvR11dLSorK6XWfVdtW2zsi8rKSq/y3iaYzRbYbFYPpsaynFRjSRB4KcHdarUMZRhmrv9yX7uEtO7mnwT/vP4lJTAw8MHc3PNHU1NbHwbgdDG3S7Y2SInyUroVWJaDQsFKSfI2mwpms9qdJK9DUFAQQkNDERERgfj4+KvknD6E4zgvFdRVW81ms8Jms7u9oKxU2luuglJKyb33TlNoNJrH/ZfZL37550nLli2npKSkyD2kKjeJYuAO/xAEMQTECafTSTiOA8uKrM0Om80Ks9kMg8GI+vp6VFVVo7S0FFdbP9InsLlCO6rcKqhBqrNms8mZGuvRAdpdJZNQSpkPPvhgNoBB/kt87VJdXY3S0jL/RPjlLysKhaL/4cO/jBaBjVKqEsGNUqqglDLu6tlylVTCFYfDBW6X6rYZ3CppFUpKSn4bsBkMBnfPghrodHqYTK62eWLLPHmNNaeTI/IuUwBIfX1dqkKheMx/ef3il3+uRERETNuyZXOSF7hJsW0AiCAIMtbGSazNVZDS7ra3WWAyGaHT6VFbW4Py8nIYDIZrBzZ5hylXeW8LrFZPUDOazKg1mKA3WWFjObnDgBE466xXNuxMXLBuL/aWmS4d2GnHN7sP4cmvtuHf20+gykH9V/96i9OC2tPnXcGkv1MqVr+Ag+9vu+5D5Ct/xY7Zyz3GaDi2HceWzMe+2XNx5ru9EH7XLwjQn9iP8x++gxNvroTD67uqrStxcPZjOPLKh7BaZb/krMO++2fC5E+GuV7S9NZbb73dDWweQbsia/N0JHgyNxHcrFYbzGYLjEaXSlpdXY2yqwhS9gC2qqoqVFZWuhLc3XFqLhXUJrOr2WGw2MEQVyEPwckRpytmjVgNFQNnf7T5YS4qESNb/j975x0fRZ3//+fMluxm03s2gSQkhBYgGCDSIQKCoKACIvYGnOW8s5evDU85z3Lqz3YqlkNREbFgpBcFRKQHCM2QhPReN9tnfn/sJtkUUhCU03k9zAOzm5n5zOfzmfe86+tt4KH3vuFAvWsLf5T+HUtzbMwdMYjg2jxuXvHzr9zACtrAdJQt1z7aVHb0q2RkXRmWytqzPsTjLz1L8MUz8SwiyvliJX7DJxE3YxTZj99M5obcX3GFKjJfeIXqzD1kvvpxi7mo3vw2P/zja6LnXoe2aCOb7nu1ucJKHUzMEC0H3t+g7KOzBJ1Od0Nm5uHBHlrb6aKkLbS2lv62xqoEl0laXl5BcXExJSUlXRdshYWuZizV1VUtTFCr1YLN1ijYJPy9tYJWFBAFBNFVxi8AYuHJ7NuP+MVy/6jejEm+gLkJAiv2FwBWNhwu4dZJIxkaE8H8S0dgP3aUg2Zl8c8Wir5ewv6XluKoO8nhxYvZv/h5qiqkRilF1pvPs/2OO9n78hIaTF17pch1hRxa/Ajb732Egox8T6lH9jsvsf2OO9n90pKWmk+HgvcIx9aaiJvcp8XHg595g4RLJxI1cRaRKSGYCot/xUwEM/Kj5aTefw2tKzCzP1xK7MKH6TFqGIMWPYL9u/9S5mHVRM2+nOL/vodFeeOeNfTu3ftKWgYRNB7maKPW1lRL6hlIsNmsWK0tTdLq6irKysooLCzqmmDLy3MVuLeOgrpMUFdah0eT4+aAgSuCK1os5rnHy6unJ0SE4Gyo51SdlcSIEI6XVgFOHJKMSuW+nKhCJddzstKurPxZgk//YYSNGYKoCSI4LY2wtLHo9a75PvH0Ao7uqSH+tlvR5G9kw90vdklbLlrxGeoh04idEMdP18yjvMIBOMi4ew6/ZDpJWDAfH/MeNv713106X93PP2BPHI7fabIri5ctIju3F/0uH3YOZshC9dE8/PsnUn/yGDavRAIiyqnJanaXiBEpBIl7Kc6yKRvqLEGtVl+cn583mqbctmZfW2NDJzedeItAgku42d35bW2jpKWlJeTl5Xcs2Gw2G8XFrlrQ6upqtwna4BEFPU16h9MpyLIs3vHQYyqNRvMXs82Gt1bFp2vWcs2Kn9Fr1NTaHYA3I+KDWPFjBmX1Dazduo9cWcBsdSgrf5bg23sQxmFJiLoAIlJTMaamovMGKCN75S6SHn2ciORkBi56FOe65VTUd35O/6lX03fKKKKm30b8MCc5GzKQS3dybKOToYvuIigxkfi770XcsYKqhs7PV3vyJIbomHa/a9i/gm2v7SNt+RL8fM8FlboJmxlUmmK2TBxLZnouaj046jzNBh98YnTUZRUrG+osIjIycnZKSorOrbW1CSQ0mqXtpX+4tLbGKGmD2yStpry8nOLiImy29l9CapcJWtiiH6ir/rOxZKpZW2tMxHU6na42dpIkCIIgvPL0Y/OBVL1WS4PJydXTL+ESp5q9Ozfjp3HVhN42YwrWtTu5fWkWA/v0ZXzQCbwVdo9zD0c1DdX+eIe51STvUPS+1VgqgU761Bo8kiH1xkjKK8txlNZitRSy69Ybm9R9r6QksAKdUP/LOOA0NOkVO7YRcPFsAkPPFVe8Aa0enPYIJv60D01IED8sBrWvvu2fSk5l35xFiKI4bM2a1ZNDQ8O+BezuHwduWnFcybuCuy9pk5zx1Nq0WlcgQadzBRKqqhpN0kJi2ynfU5vN5iY6IlctqGeT45b5ag6HQ3ALNcHucAm1jAP7/VQq1XyAPqGB/HK0HNFrMKHA8eJyEnu4OhJpvQO45/KL3S6aQiZs8+X+UIVl8uzuIAFBcrakHFMH4B1QQ0OpDeK0YCrDXBeALqgLOo6Hr8tcWIR+sBF1mAEvQzyjPv4UQzffS36RcZg3tJ+HFDTxWpJsoe0bkSX54B2IzvfXFFfqCOjfg5rM4+guGAamDKpLwxgQ79vCXG0oMBESF9nuGJxafwyBvso+OxPPZ3Dw7Eceefj7Z59dbAPssiw73AwgTrfW1qJ1n9sylJujpDZ3lLTRJK2hosIVSAgPD0evb/mCEpvoiKoa2+c1eDQ8tjbWguJwNPrWHNhsDgABWRb21DhuXbb/VH+A2L596Vebw/PbT7Bl/14+zZKZlewqHi46lctHe06w6eAx/r50E4MuHEqcItfOslISg6/6BJnvfUHeug00mABCib1iGIee+QfFGfs5+MRiVJPnEOzT+elq1n7M0TXbKfj2HbL2aOg5sT9CWCp9xtr48f7nKd6fQdHmNex+4Z0upZj4jRiJkLkHUzseiMpNKzm+ene7x+25dgzbX17V5Wko+vYjjny+Aae9nKwPPiR7+yEAel13PTlvPEPu9zs58PizaKZcS6hHEb1ccYBy0yAi+rTVGg/cMYXvn12u7LEzhCAIfe+7775JtK1G8Ez9aJG063A0+vWbTVKLxVVLWldX585tK283kKCaO/cqj9y1Kmpra9ppemzFZnOFYp0ORxN7xyPvfRak9vZ53Spqg4ZHB4HKi7R+URw4lkVGpZM7Lx3HMHefQ6fNwpbMbPaX1DIwaTAPjInn9+ANNZlMOJ0Sfn5+3TqutLSM4ODgbvUIPZNjznR8rt3jjXHShZiOHqQhvwjDwAvRewsEj5mMquwweau3IMaOZPijf0HbhX4TweMmYzuwlpLMWgY+/U/CY/wAkfApM1CVHiQvfQO1hbUEjxxLUFxk55RH+kjsGUup8R5DWK+WLC+StQF1WCxBca1qAaViDv/zbYx3PEZYbNeYYap+2kRDrZaw4QMRGkyIfj0J7m1EF3cBIVF2TqWvRYgezfBHFqDVNI+66JPXaOg1ncQx7fc99RswjOD4SEVKnanOrNMZNRrN+k2bNltx1482UokLgtDYWd6zk5wgigKiqHL/iO4OVyp3lys1Wq0Wnc6LoKCgFvRgwjfffO3Ry6BRuNW6mTwak3PNWCyNXGsOwel0irIsizab9V6VSvXs/9Lknu98bGc6vv8V2LI2sPHpH5n8weNderHZMr5g1SM/M+Pb5zinHllHBVuu+AuDPvyUoEBRkULnCNXV1f8KDAxaiYuzzSQIQgMuD61NEASHIAiSSqWSGjnbdDovWafT4+2tx2Aw4OPji5+fH0FBgYSGhhEVZSQuLo7+/fsTHx/fbIp6BgzcZJGNGhp2u8OtEjoFd3pHU+nUnj27fVUq1c3KUinoDrTxE5naRaEGoE2aweVfLeach5nUwYz/Zrki1M4x/P39r7z//vt8G81Rd4RURatSK3duGw6HK1Jqtzuw2eweUVJXbltjIKG0tJSGhubQvOgqcq9vZXq2zFlrj2tt4MCBNwIKuZWCcwtRjahWhM0fyNcW/+CDD05wC7Z2fW2tOdva5rZZWwQSXEXyrkBC07ZpWeTemK/WNhLqZu4QAOG6665VqVSqG5RlUqBAQXcRFBQ0o1evXtp2tDaxUWvzqEhoyp1tDiR4klI2Fsm70j8sFotLsLm0NVeReztCzZOSqElbe/fdd68DBipLdPbhItVTUgoU/KG1tgHbtm0d0xWtrX3NrVG4NRbJt0z/ABBbpnfYWvjWnE6nO2+tmRkXENVq9XXK8pxLweanTISCPzTCw8OnuQVao9amphUZZWM1QqMMaulrs502/cPhcKBurAdt1NYa89WaKwyafGu4Kb+nAqOra2upsYtEBfrQrgvEKYOqdQKAk6KqOgzevvh5qZTVPQ2K13xKVbEVMaQXfaaP6dIxtvwjlBSK9Bjep8vXsRcfIWvNz8hA+MQrCIo+V5qihORoW00qqNVnpStWiytV5ZKzt4xeF3WDBrwun2NfbEQCAlMvJqJf1+inK7avRtV7HAFh3l2+VMXWdEqzyhF04cTPncLZSuWUGioo3LINq0nEeOml6HW/3X41ndhNrTWUyKSYLh8jiuKI48ePJbspxBuL4+1urc3pNkebNDan04nDZsFUX49Tq4XQSLy8vFrVkTZqbSWIrnrQ5goDD22tTcAAELRq29V3/fsDpr31LX//6EtGv7SCHaWN9XZWnvvoC0Y+9R8SFi3Hs0TVYapg/isfseCzzVz64lI+PFKmSLDTQOVlQFNzhD2vfN7lYxr2fcu+D9Z2zyQQtWgMBoo/eZHCzKpzdj+n3nmYlSlDWZmSzCfGaD4fMpSVKUPZ+MRHv+q8+R8t5siGIy1fnQW7+PmF/3bvRKIajcFA5doPyf7xeJcPy37jMYoOVXfvUl56tGI5+596nbNXau9g902X8MumQ5hLy5HOITvJwYduoriw5QUqNy0j88td3T5XbGzsRE9ztFWEVGgdSHA6nThlGWt1OfWVdU0VCWazpUlrc9WRliE2UhJ5CjV3hYFn0ABZloXq6qqBgko7e8GsmWx/YB4r776OB/p7sWjDwcZHkskjL2TVgoto/e5f9f2P1PUczDcLL2flNUN5+avtVCj0MO0idMKl9JqcenrtrKKE2lOFONuZP2dDHXX5pbSh8ZRsmE7lYDFZmj5Sh8UTP3sWgVG+p31gGvJPUV9Sxa+hBe1523PMOrCfWQdW4ecdyKi1+5l1YD8Tn7q2eXiSS7Mz5edgqbN0rqE4HJiOHaDmVDmSw0Gb9riSjbqcfOy2LmwyQwS9Zs8iNPE0reUcNkz5pzBVtM/cai0txFzT0M5a1FCbk99inQKHpxE/4yJOF+iVLCZqc3KwNli6OLsSkiOfsn0iSYsepP9fbsDgoUA6TRXUncpvd6/IAA4LdTk5XZonyeGgeucWTDU215y3u/eK2zK9uK9hbWhZcqLRaC7buHFDDw+NrckcbfK1uVsOuIQagujtDRoVDmdjLakHtVFdDaU52RRk56H2TO9oLpty4nRKSFKzxgaIBoPhKhBJ8ujg3jPIH0tJI/2QmiG9oqAmp80U7sgqZMJFYwEIjulFP8dWdpY5uSRcMUm7Y9LtvGoMZeZIvH0lqrMbSH3/E6L6uJru2g6vZs2szWiowqwfxuRPnkevBfOxLWye/yAqYyLW7ONE3P4vhl8/rsMryXW5bJk9D4tvL7RyJZaoSUx7pbk/j+3YJrYuWk7yG28R7P8r7+rIl3yy4HMSetVRViRhr3Iwev1aLJ/ew/HSkVz02CzAwpaR/Yj9OJsYzQ7W/e1FLCcOYjc8RfV3ARhGzmHMPXPc5mgWW66bi62unupSPyavX0HAGVrZ9hPrWHXN0/j27oVUfhIpbjoXvfEgWrdgyn71XnLVKizZmUTe/RKp148HJE698wi7l/yEf3wQtfl2Rn64jPDYjgdRvfl9Nj/4Lv79E7AUZBHz4FIGTIzr8Ji89/7B4W92UltTxE/z5qJWBzDs/XcJ9oWC9x7hpze2ERAXSHWujZGffUpknGuxCpfcz4GdEmL2Lpwab6z+ycz85J+ndQ2Ur/sPu99eQ122mYp7ruaEQUXP+U/Rf/IAAMz7vmb9tcuRKn5B6nMNU9++FxVQvWM5P9z9PPo+fTEd+4XEf7zbdAzA8OGpY4FTbq3NBrINBBWy7JRlWZRAlpxOWRBE1GqX5iZLMoLkbJH+0VBygr0rviQy2kiJ1IC6tW+t0VHn0taaTdBvv/1WJ4riVS1X3cR7O7OYM+myTraHlbI6ByP8RF74bA3Jo0cR7gNltWYI91HkVdcNGYa8uwatr+sBKfrgEfa/s5KoF25xzXK1lqlrv8Sgs7H7qlFkfr2flNmJ7P7r34h+7DMGTeyDVHeM78beSsXlWwnu4Dmr355OVfAUrvj4MdfbuBU9jLOulIr9h7CdJXtKPrGHwBc2kzrcCA4LTqDwdCZ09AimrFjB8SfmUhX3d1JvbKndSqUmBq79mmB/kd1XDSf3+ywCpsefmVsgagSX/rgVjRrAwrYpQ8ndPZ/ew10vE+3gS5n41DwchVv5asJjJM7agiF7NTv/c4yLN2/Cz1ek/Itn+On595n+esetQLKXvkvcox+QPKM3IOHsghbV4+bH6XHzKVYlXM3IFSsIasxkrsvg53+uZ/S2rYSH6ch//W52Pfc+l73V/HKq2nmUSzatIyBYh9Ni6dDfGTJ5AVMmL2DrhDiiXv2cXr1bpkybHUYu/+Y51JYc0gfNpKziXiJ8C9l5+z9IWrqRXkmh2PO38PXMp4ibuBw3VSA+PoZp8+bNW7Fs2TKryxxFIyDbZRAFwfWf4CKzxel0yk6nU5AlWRacTnctqbsBjCGA6NmziIwMp2fPCNSNUVCXGer0SPFo6V+bOHHibKC5z7xk5/UvVuNISGVB/+CuenUw6DRoREGRUWeImu0ryfw4HVNFHY7qEqS+ze8aQ8poDDoALSGjh3H8wCGYAqWHzKi2fs7eHSAjITvyqcquJ3jQ6V8q+qQUxIzb2HK3lfDUFHpOm4bBozJMP3Qucw7PPXs3FnMhvYa7TUG17lfVEavikwj2dz14huhI6qqrz/hcgmjhxPOLyd95ALtVwpxTS0BlDeASbOEjRrmGbBxGcPBJKrMsmHdvA2/IevlZVwv0yhPUHPTC6XYenQ5hI0by4zN34DhyCcGpY+k54YIzHrflWAbmqGGEhbmiCBFjx1C7NL3FGAImziTAXcut0v26aENgyhBXdYguAkNIDZZacJbvorzGi6Av/0PVl4BkRqzMpKYK9M0iI/r55/+VumzZss2N5qjsMkcdIDtlGcnlb5NkSXK20tg8oqRaM8U/baGipp4CjRfqRhPU6Wyd4tGckAuIarVqlsf7mk9XrWarGMf7U/vTeV64F6G+aspqnfxlxkVAA/+ph1A/vSKpOrY8W7oqTq5jy6PLGffFfwmLDabq6xfZ8rWtIwXPdRJNEBHTpuLjXqgeU6fjG+/d4bXU0alcum09RVu3UvjNUtLfWcvMzW+hPUe3KuoNp9lHUtO/chd5SQVPB1Y3ihbae91mv/oQ+aUpjF22CJ23mt3XDUOW5NOfwX09r5jBRE2d6v58Kj1vDmgxlPauFXXb81yStp+irT9x7LHrKbzuVUYtSDtn20vrc/aeP0E8TdGbfzRRU6c2lcT1mDa7jVsgLCwsDdjWytfmmbAru1I/XJRGsowgOJ2yS2a53GhVmYdBNjJgShrRPYyIzcm4zvbSO5BlWaiqqkwSBOHiRn9Z+vr1fFYXwjtXpjSplJ1tmZGJRjYfywagLPckx9SRpIYq/rXTzlhwCOryXEwecsteVIQc2Zfg2GDAQd66lo1HTHu2UW8BsFG+bRehAweBb1/C+phpqAsgbGgKYUNTCIiLQWNoXjhtSAh1BS0bqDjq6sA/nOjpsxj20pOo847i6fu1ZW1l+10PU1l37ubAKyCABjf9s7P4AJVFLcmR1HoDlsrys/eghwRhOtWSbrqhoICAIcPQeatxVhyiaGdLPrmSHVtd81W4i4qq3gTH6QgZPhpr1iH0/YY0zbmfMahZmBmC0DqKMVW1lNS2ujoM8ckk3LiQ5PmXUX30xBnfi67PIHQFuygtdQUhin/Yil/y4F/NqKP21WMr71oEXRU3jBBysRpim+chLgpNq7ejWq1O27BhfY92BJuq0WJslEeSJCEL4LDZWnS2spgaEPz9cTit1Jdno24Uam2rDJqCBoKPj8/lzcZ0CYs3ZVGr8yLtWVeoXRvai+0LJwDw5NsfkF5so87mYMaiJSQNHsaHMwYxfcwovntnFZe9eZKaqlr+evk0gpUSwNMLtrARDJ4ZwuoLR6A2pnDxt6+hHzYVI2+zeuZctGIduqCQloIgSOKHWZejpgqL70QmzxgEwNBXX+b7+deS91YCans59SYjk9YvaSLQ7XXLPWy6+T6+fF9H3N9fJPnKodTv+IiN//cJgX3jMGdnEnL7Q/h7vJSd5SfJ/uwrYh5bTNA5Sn8LmXgFqn/OIX3mT6j9ItGFtNRzjJdfz9FbH+Kb1a/gN/56xj967a+6XvTcBZyYN5+VI98k4pqHGHnHNGKuuZX1CxZQt3EglhrQJ7RkXbEfWM2a2WuwZGcS+9j/I8AbGDCV1Ju2s37COPz7xWI+lY3fpQ8y9p5L3U9yTwbfdxFb00ag8othTPoKgn3gyENzyD2pxzdUS9XxUlLe/tuZ34zvIFIfupjt0yfjHx9MdbaNkZ8s+tVrknDTQrbfPZNf/A3E3P0SA6cndfCmMJL62kNsvWkKJ+L7IleVYglKZfpHi9oI2GHDhqUCuZ7CTZZlu+CKkEqyILjNUQmVlw7JVE9VtglbYDjaWC904UZqM38iq/wkJYIOYfDgwe7+BmYsFotgtVqx2+2Cw+EQ3CFXldPp2AP0Pxu2VUlVPXqDAT/t76Otne+0RZ3DgSk/H1VgBDpDW7+Is6GOhloLPhGhrcwdiYbCfGSvQAzBXZNEkq0BU3E5msAwdL6632W9ZJuJ+tI6vKMj+L30e2dDHQ2lNXj3jEbVzsvYWlaMpPND79vSvJcsJkylFXiFRaDVdW0P2GrKsNZY8TZGozoLlCZOUw0NFSa8o43tjv23canYMOUXI/qHoPdvP5lZluWjoqi6A6gH6nBRGpkBi4BgF0TBKQiCpFarZY1GI3t5eaHT6WS9Xo+3t7eL0shbj49WT1jPHi6NrdkEbdbYcCfImUz1aWdHqLkcHuGBSrnQrzQGMETHnl799/bF19u33bn3Nvbs3mppvfHt2fN3vVtBa8A32vC7jkHl7YtvB6kaXqHtVyqIOgO+Pbs3dq1/KFr/szh2gz++Bv/fd8uKWgyd7CNBEPoePJjRd+DAQfvbmKPITmQkQRAESXJpbY2BBM86UockI2nV2GwWxMbGLM25a83+NUDw8vK6TBEmChQoONeIj48f0coUbc34QXOZlYSn7PIskLdabYgevjXB7VsTPBx2oiAI05UpV6BAwbmGXq9Po7n6oN0Wfa4fqZH5Q2ihsTV1trI1amySR+DApakBgtncMBWIUqZcgQIFvwGMR48eGUjL8qpGxo/G1DNBkjyL45s1t2b2jybB1oZzzeXe0GqnKnP926K0tJT8/AJlIhT8KRETEzPMU2Nzm6OqVuZoC642N4V4C61NdAcMmlS7xgPdZqgi2BQoUPCbQafTjW+lrbVnjraQWa0DCXa7HdHTDG3U1AChocE0oX0z1MnOjMMsWrmBe5dv4v19uR70KzJZeXl8um0vr248SK3HUQ5rA9sPHeetjTtZnlmirOBviEP3XcGJHcXnwUgkfr56PAWn/jhzayvNpbqw4gyPrmPbZZdS2qXDbVRlHMJ+FhhxajctYcMTS8/qPMgNFZQeyW3z+c/XjCUvp3vmaEbGgT4eWlsLja3xpyVXm9QmQiq2MkPxMEMntr836/hqbyF9YmPEzRKUAAAgAElEQVS4tH8Um7ds4PEfGkdu5r31ezhSXMJbP2S2EGyleTm8szeb/b+c5ItjimD7LWEtK8Butp0HIxGJnrcQv8A/kOtg1SvsWbL+jAW9pSAPR1e6TVPOjqtvpNp8Fl4vpkoays4u/56U+wMb/vpim88teTnY7d07V69evZI9NbbTmKN4mqPNWptLsKmbo6GNTB4uM1QUxfYFmxjA4hsnNf0a2FDGX/bnwthYwJtnbp4JNTl8c3BnSzGc0J8PEvqzesNaPqhThM25QPXOdI4vX48dDQEjp9H/yvFNSbq24qPse+x1zFZfEv92NyFGX8BC3rIPKdp7FLtdTfCkWfSZnooAVP+cTmWlnoY9G6ipFIm76XaMSe4idUcd2e+/Q+H+k3jFD6H/wpvw9u44+9N06AdOrNoOohbv0a0Eb85+Mpd8gqnaiiF+CH0X3tA5A+xpxlCzdw1FBf70vXQEAJWbV1IlJRJ/URJl6z6iQW2kcnM6FmcwCfPvIDTW3/2wl3L8nXeoyCrBkDSO/rdciVbdqI2UceK99yg7UoBXz0QSbr6VAP9qMl9+n4o9GdTVlbF/cTZCZDKDb3R5bxwVWRx990OqT9USMPYy+l2V5k4wtpH30Vuc2nmSgLTJdEUBq/x+Bad+3I/ZVMOJFxZToBWJnLOQ8Hh/1/mWvUvejqOojQkkzp/fVNjesQJYzbGXn6U8u4rIWTfTa0y/Js0w//P3yPvhEKqIRBIXdn6+3A9eovLgAeTiXPYtXoygCqT33xY2kSaYT+xk95JPsXtFM+Ceu/Fzl7BY8jM49s7H1FU7CJ16NYlThiIA3t7eI4DPWpuijeYosiQ5JUnA6UQlqmVJIwlOu0021dRgkyQsXt6IjVLPnZSLLCNUVlb0p4vNWo6UlpNoDFGkyu8MuWQnG+Y/T+jMa+lz3RUI5poWRIAnl39F6CWzCdBls/XB15pMoZpCO1Gzr6P3vGkUvXI7B9ccA6BmVzo7/vY4mpRpxE7owY6rr6WiRgIcZNw9h18ynSQsmI+PeQ8b//rvTh9QTXgsYWmjKfn8VVqSbTSw86brcfa5mH7zb8Q/QMLa6Rv+9GPw6zuIwlfv48TuQmxZW/nh4f8QMCjRpfOs/4wdD7xI4OS5GBMdbLn2TswOlxWy85oZlJmMJN52Ixz9jB+eW95kofw07zIKCn1JuG0+4b28qM2tBLUvwePS8E8MQxvdl7C0NMKHJrpvKZ8tM+fQEJBCn9uuov7bZ9n9wXYASj59ll2fHiLuphsR9q2krLDzyn5d3EDC0lJRa70IHJNGWNp4fIJcnIiFSx5j16cZxN50MwGak6yfd1+XmHnr1n1KQ+SFxM8cyaE7ryL3mItEM+u5v7B/VTaxN80nNKyUzdc91On5/IeOIWRYEvhGEJ6WRti4C900Ty6tNGdFOsZZ16At3cJPzy9zObRK97Nu5i2IgybRZ95lFL58B4c3ZQGuZi+rV38X2Z6fDVkWZARBEAQQaHKjOe1WnKjRBIeiDdChbl3wjqs2dHxXHqZT2Yd587CTd+7sp0iW39t71VCJw6FHb4wmJD6CkOSW38dddyfRI/ojR11NxuUfYAO0hDLgrzdRsX8/5mob/oPiKN91EKa4+iYEXHwNfaaMAkYRt+I9cjcdI2hUJcc2Opm46y58NBB0971kpV5LVcO9BHdA/a8N7Ykx1MgvbTQ7K5ZqK4FhYQQMSCJ4YHLnQrx0ZwdjMDLytadZc8tt5Bhq6fviRwSHNpczRc5bSOyYYTBmMLkfDiB/bxUx6vXklvdn5r1XowL8772Dr2e8juXROYgZq8kpTuDKr253MZskN9dGhqemYj8UQZk2HmNqMydc1frl1BinMf6Gi5GBQXfdyKpFXzH8xlHkrlhJ779+jfGCOIz97+fEh1d2er/ePfvg3dMXjUZHSGoqoYZmoZG94iv6PvQ9xgsiIPkJcpZeQMGJl4jr3XEJl+aCS0m+Kg0B6DfzM3LTfyAmfjBHluwiedOPhIaokfvfT+7SERRlOYiJP319V0DSMHxV+QiGvBbz0IjeC/+OcWgggfZZrHrOVV9e8Pn7aMbfSv9po5GAgQuuYMfydJLSXJx1KSkp/YE8T3NUEISmZF0EQUAUZUHEpZhpvND5anA6rNgFL5dga+zu3vijUqnGdjbZFUU5LPj8AItumEmiQalm/72hipvEyHsyOHDnHH4otGK85u+MeGBuU32lV6Cr5F3QaREcDiTAWZHJ+hk34T1yKgER/jQU1yP5NFNSe0eENv2/PjSM6soSHKXlWC2F7Lr1xiYaHq+kJLAC3mcy8kCGvfoM+199mC/+nkfAiMsY8cqT+HawpxylRR2OQddnPDGJizheMJjxo1o2GNGHNdJ/a/E2+tNQXk2DsxipMoNtN9zYPKoB8UiAtbAYTUx8t+ia6ovzcRzdw5YbmvsnBPce7jpfaR1BYWFuVSwCQ8CvKQg1Yyk1o2u0mMRADGFgq6wDOuZI1IVFNbkpdMYwGrIqoaYIs9nMoXtv5WjTm+ACVNjc8uXM/KrqQJdTVaVRIVutrpEXFWD68Qibb9jcrPkNaS5yCggISAY2eGhrrh8BAVkWJKdTkJ2SIIoqJEmSHeZaoabUKht8fBF0trYa27333qsSBKFD3ui6igJu+Wgbd86dwbgIb0WqnBdQ0/OWB+l5y4PYSjNYN242RdfOJdrYge9m4wocQ25g7L9uB+D4E7vwDFg2FDc33DGXleJ1YTjqMA1ehnhGffwpBvXZGXngmFlMGDML2VLFjnmTOf7dHFJmn541Qh0W2eEYyr95kdzqIcT3+oWfX9/AqDua3cXm4kIgBbDRUFhDZEgA3uoIVJGpTPjstTaF9jZjBPbcndgkmujAPSEIAnKr7ik+EdF4pYQy8b2H2wqUcH/MpaVAHFiKMVU7uiwgBFFq1dtBjy5Mj6WwHHpHgFSFqRSMXaBbsZQWILs1GUthKd4RQeAfjt7gz5C3lhEeeAbKSje6yOgjjfhfNJOJT7fPyKLRaEYMHjxIc+BARqtEXUF06WuCgCzhtNuRNGrsZgsan2B0Yf7ovHWoW5mhPPnkE6OB01fN2uu4c0k6uug+VBZks7QAVPoA5iW7ily3HzjEyYpyrE4zX27PICE8kqkJoUgN1Sw7cIrDp6optUks3QGpA/qR6KdRZNJZgC1rO0c2FRCZOgBH/k6s2hh8AjoxcaJ60LAnnYKfR0PxLo59uw/99EuagxFrP+bomkH4Og6Rvc/A+Ff6IPhL9Blr48f7n2fgDRcjVxVSsCePIffd1iH7RtX+7ZhqrJhNTip3bkF9youQ1BHodKUc/NcKgsaNREsl9aV2gmPCOxy3EJZ62jE4s7az7R9rGfXNN4T4lrF+yhxOpPan91CXhC/65C1yUiMQsldTYr+QYRcEohWn0tP3RbY/s4Q+l6biKDxGSbbEBX+ZjXbQVGIj/s32/3uD/nPHYsvdgxw5iZ7u8/nH96Xqg684OTQIbWgM0cP7EThpDj4vXM7Pb/Ymbkwi5qxDVJvCGDRvIjFzrmTbq4sJCbmdqq/eoL6rco0QAmIcnHhzKdbkSAJSRuMbrCNu1kx+evFJAnwXUr/pA2oiphHVu3P90r43nX2fXYwxooYj3xxlyKfjQe1Lv5sGsvuuh0n+6zWo7eUUbdpPwmP30BmBvyo6Hn3BMxz6fBX+gUGEjx/VFHxpD1Gzb+TAJX8ho38IxgFG6o7uxOqTTN9LhjUpcO+9936vlJSUQzQ3U1YJICIIIrLsREZAFGRZlpFFAbu5FluDBrm6FJVarRbcibkCID711JNXi6J4eh+bZKfKpiLcoMFid2CxO7CKWoZHBwFwLPcUeVY1Q2NDweFArfclKcwX2VrPD9ll+PgH0i/IG4vdQVR4BBH635aMxmQy4XRK3W5KXFpaRnBwMCqV6pwec6bjQ3BStWs7RZs2U1sqMHDR04Qam7ejb78UDIHu6JYmgLBh/dH1HExgUA05X67BjJGk22Zj6JFAYFw4NbvSccRchL5sD6XHTQx8+p+E9/AFRMKnzEBVepC89A3UFtYSPHIsQXGRHXLml61bSdXxfHyTUhFrCzEXlOBzQSo6LzBnHaBo0ybKDucQfcujJI5N6FR7Od0YyrdvJnT2XzD2jUDQBhA5oi8VhwsJGRhPxfpP0I2di+PgJqrKfEh57gn8A3QgeBF12UxsR7eTv+4HTFV2wsaOwz8qBAQvoi+bgT17J/lrf8DqCMA4YQQ6b9dTq40dTEiUQPXh41jMWsIH9waNHz1nTKLu580UbNyK1aolYux4fMN8MQwYga+YT+43m9GNmU1MSi+Chg7Fq1NZJBI+MQ1b1iHq8/LRxSVjCNLhe8E4fOQCTq1aj80Qz/BnH8bg3bkqbRiehlfBz+T/nEXC/c8Sk+wS1EGjL8FHKCIv/Tuqsorxu2A0Yf1iOici9gonamw/ajIOYS6sxn94Co3MZAHJI9C7DTvBN5ywQQmIhkhiLxlBxZY1FG77CYcYTOTY0XgHNFuAer0+67nnnjuBq9+oHXAI4ACcgCQIoiyqRFkQBNReOlSSE6nBgtoQiKDT6URP7jWHw/6NIAiT/qiazfnOx3am4zvbyH39drJNkxj/wOV/mLU/cv+lmFKeZOjcFEXF/x+Aw+HYotFon6WZo61eEAQTYBUEwSYIzRxtWq2Lo83Ly8XRJroTcpFlWZg9e5ZKEIQRypQq8AqLwyci6A91T7qYRLxDFJ/w/4zXWK0eGhMT0xw4aNlMWWx0n7mSdRt/XKlras80j3fffXcYoPTDU0DE7PuJ+IPdU9ydLyoL+78Fn2XLPu45atToYzT3QBDdaR+NpVWCLMuyLDfn40qS1KyxAeh0uqHKXCpQoOB8Qe/evXu5hZpn2kejYKOlxubq1SJJUsvCUpVKpTgfziLCwkK7FTgAMBgM+Pn5KpOnQAHg7+/fp5UZKnr8CK00NyTJRWmk9qApEgRBuECZyrMp2MK6fYzBYFAmToECNzQaTRJtfWyNxfBNTB+eRfGeGhsnThwPAxK7esHq2lpyK+pxnC4nz9m2qazVbCa3rBqzQ1ZWTIECBZ1CEISEF1543qelYJNbm6NCcz6uR/AAEIxGY5eK3pHqueuVFey1awn3clJo1/Pv66cxIkwPWHnuo2/5OqucUimALU9dRbT7sPdXruSNzDp6BHiRV2VhwRWXcOuAMGXlFChQ0CEmTZpkBCpoIpxEFAQED80NaPa1ybKEutFG1Wi0XRNsooYFs2aS1MOV1r7yu1Us2nCQ1fOGAyomj7yQWyeamfjmnhaHjUgdxTUzw9GKkH90D5NXbOPyAVd0UtGmQIGCPzuioqJ6ApluQdaicxVtoqMu4Sa6JZ2gUokDunYZryahBtAzyB9LE8+MmiG9ogjWt8187hsV3lRrFxbkh+iwY5WURVOgQEHH8PHxifMQaq1b8jXlsrk7WCFJktCU5CYIwoBuX9Fu4r2dWcxJ7duNg2Q+2XqQYcOTMCqkIAoUKOgEGo0moZVQa+Fja52oK8tyUwmYAHSPVE2y8/oXq3EkpLKgf9cNyh0/b+Xjcj9emDRAWTEFChR0ClEU+3hoaW6hJnuao9AigOASbEJpaUki4NX1Szn5dNVqtopxvDK1P11VvA5m7OKxn2p557o0ghVSDwUKFHQNXitXfhHiIdxEWaYFh6RnAEGWXeke+Pj4JHT9GjLp69fzWV0I71yZgr6LUu3E8QP8fVMBb9w0hRhvxQZVoEBB19G3b99QTp+k6yHUXOaoGhDUanV8l69gLmHxpixqdV6kPeui+dWG9mL7wgkAPPn2B6QX26izOZixaAlJg4fx4YxB/Gf1DgorRa55+UP3ifS8d988BuqVRVOgQEHHCAkJDW9rjrbU2jzMUVkQBEHvcNhfFkVx/p9hgn5L2iIFChScHZjN5mXe3oaluOiL6oA6N4WRBbALguAQRVFSq9WyRqORRQBBEGKVqVOgQMH5Co1GE+nWysTTmKKeaR+uLwRBiFGmToECBecrVCpV9GmEmuAh3AAZkJu+VASbAgUKzlsIgtCjlcYmyHKLlA939QHIMognThwPB3TK1ClQoOA8hu7f/37Jp3ONzWWOisHBwZHKnClQoOB8x8CBA/08BFmbdI9GoSbLMqKXl1f4mVzkTGiLzOYGcsuqMdn/PLRFsuRAkpSiWAUKfi0iIiL8TqOttf5BrVKpuifYzpC26KOvVvLmURPhvloKK03cOGMqCwf9wZXFwk0sT74eVY8IZJsFr7gUhr/4EhG9Oy9BM+3+mgPbHYy8+0plRytQAPj7+7fW2E5nigqiKIqh3Tq7m7Zo+wPzWHn3dTzQ34tFGw66v3TRFq1acBGtya2vnDqd7Q9dx8o7riL92qG8+s1PVPwZVsMrkUl7djP74H76DnGw/f/+X4uvHTVl1OYXI7XQ8iTsxdmUHvwFydE9jU8GcFioy8nBbpPc53N9Z6sqo760ps0x9poyak/l47ApmqWC8xfe3t5+pxFqTdTgjaVValEUu0mJ5kVSj+ay0p5B/lhKWtIWUZPT5ii9R0dYCVCrxA4b7P7xoCZseAqWzUdxAiosHHv6Lg5vyMM/VENtbRATPltCQGAdO+ffRsWJHBrKJNbN3QUBSUx490m8KCS97+UM37OTUANUfrmYbesNXPbGX10K4pL7ObBTQszehVPjjdU/mZmf/JO9N6VSIQxBNlXTcDSDiL+/xYibxwKQ/cJC9n2TS2BsELW/lHPhqrWEN+0IC/v/vgD1RXeRNF3p86Pg94VWq+3Ux+bW2FALgnDmzSMbaYsmXdalP/9pzy5e3ZXNyQor/5h3KUF/htWQ6ijetIlqSw0nX/uCuGueQgVUb3iPjB0aLtu4Bi815Lw8n31vrWLCw5dz4bsrqPnuVTZ/ZWXK2/d363JVO49yyaZ1BATrcFosTauu6TeVCQ/OwLJ7GV/eu4zhN49FRSlHl/zIhVsyMIYDDhvOFmW8EjWH9uE1sFp5qhT8/qqBWu1Hx741oVmNgMAze2C7T1s0sG8/njLGsG3vHl7duJ+Lbh3PH751iVRL8apvEYqPUaMfyuQbJgJQtn07GkQyF/8DCbDnVlBlPQT8us7rARNnEhDsyt5R6ZqzeMKGDAZAFx2NWF2NHVARRMSIIHbfdgM9J40lIu1iIgZEeyr/jFufoTxRCs4LqFSqdkxRGRCE1g4ZEfDr/iXOjLbIYPChd2QYN00djV/+MX6s+BNER9VRJP/7JcZ+sopekcfY9Vp60+QbklKJmjqVHlOn0mvhI4x9/JauSMrm5WsnJK31aZ9VQFC7V0lsaR4PeXcdo/7vFrT2ArZfOZkTe8uUJ0jBeQlRFH1o41trWVLl/gxREIRuCrYzoS2SKKoxNf1WWVpMnkNLoO7P5GUT6Xf/A5QseZ7KGonQUSOpzTyBf3IKYUNTCBs6GENQs/6q9jVgL6+kpejyxcunlobCBpfWt2/PrxyTDZtJInj4WPrf8zgJY8OozSpp8f3hJ+7m2AZFa1Pw+0MQBJ9OTNAmXjY1dNMaPCPaor68svQztpt1hOpFcitMzJl+EUP/ZC00NbFp9B3/LAf/k864B24lacfdpI+bTECvcOpzfyHqjpdIuWqES7tNmUokN/LNuIloIlK46LPn0OFL7+snsXPWxRxLCEdrEMHn14yolC0XX47TmIiWSmrr40mb3N/jezvF336ONmwKfSYOUp4sBb+3YDPQsui9TaoHzRJOKgCMv8XATA0mKiwOgn19MWh+H7LJ8422yGmqoaGqDn2YEbW2a3NiLStE0gWg9/U+CyOQMBcX40CDT0TonyxSreB/DEWCIC4ETLioi2qBekEQzIBVEAS7IAhOlUolqYHfjOrR4G3A4K2sjidUBn98Df7dOsYr9Gy+h0T0EUZlIRT8L0DXgRnqAVfwQGFOVKBAwf8CWsuqdg0MWUYRbAoUKPifEmxtAgbtCbhG/nAFChQoON+h6kBjayHgGssSFJwDHDp0GJvNpkyEAgVnB2JHWlp7f6hAgQIF/wsQOvkdQBCBblI6ONmZcZhFKzdw7/JNvL8vl2adRCYrL49Pt+3l1Y0HqW3vcIeJ9zf+xJb8GmWJOoKtmMx/PUfe/tzf5fK/vHQv6ZdMYvnoG2g4h9cxZ6STPv1SVg4fwtHv83/XKa/POoSpRtGwz2N0WVaJgLN7p67jq72F9ImN4dL+UWzesoHHf8hp3Ka8t34PR4pLeOuHzHYF2+ot23jjxwy2FNQqy9TRQ7bjaw59sJT9//nyd7l+wj0vMu2T5xGrKjmXhW/6QdOY9u0qeiV547D+vrRJJ55ZQPbOYmXznb9wnkZba6O1qQEboOm6lRvA4hsnNf0a2FDGX/bnwthYwJtnbp4JNTl8c3Bnm0Nri7NZWujD7Djvc6oF/BGQt3oNve59iPyXP6bW9jf8uhC7rt6ZzvHl67GjIWDkNPpfOb5pxU1HtnNs2TeYayX8L7yYfldPRIWFvGUfUrT3KHa7muBJs+gzPbXTJN2K7avIXf0jDVUmfAeNoe9Ns2lkparbu47SmiC8Sn4id+tRfMZcweC5aWf8gi75binZa3eBXxTxtywkNNbF2SA3lHLs7XcoP1GElzGGXjcsJDjaxQJoOryVIx+uxGoV8Rk0lv63zOhwg1uzdnFk+QZKjpYjrngTxx4//EZeSq9xSU3nO7b0K8xWLVFzbyQ2tQ8AhV+8g2wcROl3KzFbfUn8292EGF1jsObsJ3PJJ5iqrRjih9B34Q3odR3fE5g48fpSgqdcSM6SpVgcvvT52/0EGw3KA+G2Y7qjsf0q3ftIaTmJxpAu7FEbz337MwunDsNLSW/vZK6qyF+XTeTUOUQmlpDfBS1CLtnJhvnPEzrzWvpcdwWCuaZJ07IcWcOaeQ+gG3oxfW6ag1DW6D6oo6bQTtTs6+g9bxpFr9zOwTXHOr1WXVYugWnT6bfgeqTMz/jhmY+av9u3nr33/Y1T2V7EzJqJ2lF3xhpf9YbX+OHZdKLm3kxknJMtV95ErfuNePzZ28kvDKTv7QuJHNIDS6W7FtmWz/fz7sI7bQ59b5mLHhOOTq6jDooiLC0N7xADPoMuJCwtDf+48Oa5u/5RfNJmknDFOI7eez3ZB6sAKPrmXXY+9yGhl8wmQJfN1gdfc5+xgZ03XY+zz8X0m38j/gESVnvn9wQmsl57kR//7zX8R15M9KgELOV1yvNwesEmt/q3hcZm5gypi05lH+bNw07eubNfp3/7884dVPdIZmyoln3KAnUIa8ZGKnxSCTdqkdLGcGTtOvqPub5jWdhQicOhR2+MJiQ+gpDk5u9ylr5N6HWP0n+GS3MKSR7m/iaUAX+9iYr9+zFX2/AfFEf5roMwpU+H14q9/nZqj+ynpqAc/6T+HFuxG7i2+W2ZkMaIh29DAKJ/xTzkLl9B3O0v0WPEBTBiEIUrB5H3Uz4D0qKxVlaiiQrBL74vIQOSPLZ+NVaTCl1YBIGD4ggeNKzT66gCjRhTjZSE6NEkDsGY2rN57t7/D2E3PESvscOQgb6zh5Gdvom4gS7K9rjr7iR6RH/kqKvJuPwDbIAWK5ZqK4FhYQQMSCJ4YHKX7sn1iJrpc+9zxA8NVh6EtrB0R2M7I6uwoiiHBZ8fYNENU0k0dBJctVXwj43ZDA3XsP7wSU7W2MkrLOZQhUlZqnZQuG4tGr2Fo6+/QUVePWVr12Lt7OGMm8TIe8Zz4M45LB+cyrZ/fdrkkDAXFOAbF9fWYVGRydq0NDJXrKfq0GEaiuuRHJ3tHRO7r7+YH5/9L5X7D1OXXYRks7V4ZfomJp6VmlNLZSXeIWFN72B9WCCW0nIA+jzwAl55X/PtiKF8fcm1FJ5wE837JDHypds4+eQCvhiQzKYHXsbqOPMxmEoKKfvyTbbccCPf33Ajv/xYjk9ws2noFehiIRB0WgSHw+3dDmTYq89Q/s7DfDEwmXW3Pk6dSer0nlwLGYJvvCLU2rVKZNncjnbWnkEgq3EVlHYLdRUF3PLRNu6cO4NxEV0o/pRVjB0YS27uKXKB7Ho79tJSTlTEkhSs+A9av5Ty128lfMK9qAxaVH1HEpD+TwoOmug1sKO5UtPzlgfpecuD2EozWDduNkXXziXaCPoeUZRkZwMtNevKjStwDLmBsf+63WXePbGLUy2kpRrR4Wixc+T8HZw4HMGVe15GC9RueI3DOzJddH+Nb8szSCIS1CqkRnvNDV1QEA3lpUBPwIG5tAq/MJfbwyv2Ai5862PAQdbiBex/awXGFxcAEH7ZQsIvW4izJp8t0yaQs/cG+gzvolHSqr+EIdxI5Oh7GHHbmG7dT+CYWUwYMwvZUsWOeZM5/t0cUmYndXhPdDJ/topibA4vfMID/6yCzeQhzDr0cKhlWa4VhG68X+113LkkHV10HyoLsllaACp9APOSXer79gOHOFlRjtVp5svtGSSERzI1IZT7ZoxvOsUrH+dTlTCIyxNDFTnWWovK/5HC3J5Mve+2poCBfPAr8jd+T6+Bl5xeKc7azpFNBUSmDsCRvxOrNgafALfpeM18Ds97isx4HWFxvpR+n0HcXbfgHdWDhj3pFPw8Gop3cezbfeine1zDpxehsUVkvPAhEX0iMU6djC4wCm/zQbLW7SDYYOLwqx8DQ371fYemjmDXf1/BIE3Cf9CFhMSF0nPOLDY8+S/C4x5CylpNflEiF1/oMtmyP3gVoecwfEM1VJzIwyf5KrcpcYgDy/YQPiYFoSaLBpMvvl10vvv1TuDY8nfxFcfiHTeI0N4RxN6wgMM3PMbRyCcJ6elH9d4fEHvPoNeouA7OVMrBf60gaNxItFRSX2onOMbls+vonjrDL09eT2bpSGZ99uSfVbDVd6CttRB2qieeeOJKQRASu+7YtlNlUxFu0GCxO7DYHVhFLcOjXR0MjuWeIs+qZmhsKDgcqPW+JIX5tjlNdHg4sX6/fbcOsiwAACAASURBVAN6k8mE0ynh59c9fs3S0jKCg4NRqVTn9BhrQSHqvsPokRzf9Jl3lBGHXUNo/9gOVB4nVbu2U7RpM7WlAgMXPU2o0WUmqUMTiBk3gJK16RT/fAh971TCB8bi1XMwgUE15Hy5BjNGkm6bjaFHAoFxjR0ZNRgvvgjzsQwsJSYChqag9Q7FmBpLwcovqcqtp99dt+MdHkV4crP56RUZ73GOrsE3eQw+YiW1WbmoIxPxjwxA32sYoUYbp75Kx1QfxJB/LiIo1EVG46jMpWjTZkp+3IchdS7Jt16CSgREgdqMHRRt2UTlL1UkPvg00f3CuqZlDRuP2lxM3S854BdFYGwY6rAEYsb0pnhNOsU/HUDwjcU4bjg6gyvO6tsvBUOgex9rAggb5mKUNmcdoGjTJsoO5xB9y6Mkjk0A6PCeXNASNGwoWnX7YzT0HkzogNg/50vf6Tz69NP/+BlXEMHa+K8gCHbAKQiCJAiCLAiCLDidjo9EUbzmzzI5vyUf27nicFOg4E/ppLFYVur13v+lLR9bAy342ERJlGW5UpkyBQoUnO9wOBy1HianfHpfm4Aoy3KFMmUKFCg432G1WhvLlVoLtDYCTnQ6neXKlClQoOB8R0NDQx0tk3JPGx0V7XZ7iTJl5wZhYaHdChwoUKDg9Kiurj6dKdok7BozPESLxVKqTNm5EmxhimBToOAsoaioqK61QBOENmVVsiCAWFRUXHRG0rO2ltyKehynI2RwttIQJRmHU2r6kaQ/z4LI7nx0uR3WldMVuzV9LikbWoECgIyMg/XuR0NqFm5CO4+PgHrw4MGlkuS04OoA0zmkeu56ZQV77VrCvZwU2vX8+/ppjAjTA1ae++hbvs4qp1QKYMtTVzXVCn61bjWP7CjAz52gM/rCUbxwUeIffzVq9vDFpH8z4+cnSB9wD5MOr2pq5Jq/5B5O1kygn/EAB44kMPGpuU2HbZuQROyHhyi8J5nQp3fTq59a2dkK/syw3H///Q0dmKIt/G2NT8spoGtSRtSwYNZMknq40tpXfreKRRsOsnrecEDF5JEXcutEMxPfbNulfOqECbw4PkFZIgUKFHTP6pHlvFYCTPLQ3Frqa4KA6DpG7gZNq1eTUAPoGeSPpanGT82QXlEE69vXLqqrq9hyJIfsGsufaEkEVF5egIhKr29RHC6qvBC1IoJKhdgq1VzU60EE0Uvv4jlWoOBPDKfTWdBKqLXytQmyIAg0Bg/UgCxJUs4ZObntJt7bmcWcSZd1+qcaLx32knJW7S9h6/J1TJ8yhcc96GH+sPC/gMu3LgHg0t3LW3xlvHExrlbF02hNxTjqu10A9Ph4h7KrFfzpYbPZitrR2NpN+RAEQVYDstPpzO62YJPsvP7FahwJqSzo3znNyrQJaUxz/39Z7mEmvLed6y/oSaxGWTQFChR0jPr6+qJ2TNDT+tlEtzQ82U3FkE9XrWarGMcrU/t3u9VVaHQkUY56Tin84AoUKOgCSktLy+iCj63RHBUBuaqqKqvrl5BJX7+ez+pCeOfKFPRi146prDc3/ZZ17CQF+mD6+CgLpkCBgs6RmZlZ4SHMpE5MUQRBELwBrSQ5iwGvTq9gLmb0oi+o1XnhJbocddrQXmxfOAGAJ9/+gPRiG1VmB/56L5IGD+PDGQO475X32OPwwV8jkVcrce/sqczrE/KbT9Bvye6hQIGCswKrIIjX4mpjUI+L2aNOEIR692c2QRAcoig6VSpR1mg0siAIgt4t2LYAyedubBJl1fWYnQLhAb54/U4J+YpgU6DgfwuSJGWoVOpFuNoYeAo2k4dgc7oEm0rWaDRyY46BLElSpiiK51CwiYQG+CmrpECBgm7BZrNl0da31trHJnuYoYiCIMiA7HA4MpUpVKBAwfmGurq63HYEWpOPrXUOW1PwAJDNZvNhZQoVKFBwvuHUqVMFrQSak9OkfDQKucaYpnz8+AlFsClQoOC8w9q160rcgsvpIdTapHs0maGi4Ko8AOTU1NRySXKeAHr/pqN+59K2n11wNaTMU1ZUgYI/OWRZ/uXRRx81tzZD3XRFnpqah3ATm4rgZUCSJGmvKIq9/8gT5VWTi6owE6q715TW79QpRMcJUCssGwoU/Faw2eyH2zVDZSQEWQJBRpZBlmRBlhGcIDjkpuABgGy32/d1fiknOzMOs2jlBu5dvon39+Via5avZOXl8em2vby68SC1rW3l/Bye+XIj963YzEeZhX+6RSrft5mxT37R4rOT275l+r9Wt/v3P65ZwejZd5E861H21nh84ahl0ZP/YNAVd3PJ4q9/25twFHPtTQ8y9IqFXPvGD10+7IUnH+G/e6u6dall/3mN0df+negZz3A22VC/W7n6/7N37nFR1fn/f54zF4ZhGEYYYERERFJDREMyJDUzc83MzFxzy8y1sjIz13Vba11z/fU1t227mGtmdjMz18zMTM1YNDPXyszIC5kRIRIiIgzDMMzlfH5/zIUZwGvqVs778TgPZc7l8znn8zmv876+PpzR7HM3sKuolBMtKL/mjZfJGTWZnmP/ScV5e/Au9u0rxtaMn2/5i08z5/1vz+hKBatfp++46aRd+wd2285hFxUbU6bP44D93JEIHrfaDrZihgb72PCTTUpIyFJT8AB/ZNRqte46defrWLOrnC6pHbghox2bt+Qza2uJb2cDL3/4BfsrjrBo674QYDtWdoDfvbqNuLbJDL00GdnlvuiAze2op/RobchvsR0yuOvqLq0cXcfsf77HzPlPsnvV/5Ed07Sn/LOPeLk8gZ2rn2X9wzde2JtQW1j2yt+ZNyqLGrvr9EH9aCVWu+eMmrr1nslsWzgJda2Vc/Gq5G94j4IDxziw5xuq7ceZ//Jaqk5nGtpLGX7/i7S6OIi9mBkvFrJs6bPsXvZHLOftwdcycdJcipoR41irq6mud53RlQaOvJ1tS/9CkqvuxESxZyGFm9ayr00WnfXnjo6mqPjQD820tWAfm5D84OYDOF+qh1AH26mjR9+ya/PmAhtw4mIn2cTj468N/NnGfpT7dv8A/VMBPf83YQTUlrD2609DTluxbRfXDRrIvblJFxWYOY4f5smX11Jcr2Voui7kC7zstbcosipYLs0OOWfntv+w5stvKax2s3rlW2xTRTLxzptJibSz+MV32LX3axxVGuY8t4zYjplMG9bzZ3GvblsVi1fms/v7ChSdkdE33cDgjPgmcCv9hofmvIlNn8CU34+ga5y30MV+/DAL3tjInnIbmbl9mTq8F6dKg1YajrNo2Xvs+P4YsYmJjBs9guy2+pO/0AOuYtnKtbz8SSFblDU8NP4mzKfwLGz5YB35XxdjrT/ME88tQ4/MrWPHkNFGJv/9tWzZ8y1ljgaWvPQmel0c0+6+DtMJr9bI0tc3UeOq5qA9gaGdnKz8/BjT77+djDgNuz//hBUFeyivbSDt0h5MHXM1Jg3s/u9mVu08SIm9nkWLlmHRSAy94UbyUg0+Bb6KJxcsZs9RGD/2twy4pM1PGEQ7y99Yw6ZvjmDpeAlTbxuKxQdUZUW7eWLFRyhtkhmeFY8jthPDe7QLWHKL/l3ArVOfDrHuVix/B2Nqe9Z/8Cm6xI5M//31WHx1mDUl+1m230mO9keWFBSR0OkyZk64Cj0u1q9ex6ovfrC9sWHrkWZamgdQhNcc9VODC0lCKIqCrcGDrdGF7HO6CUD56KOPFCHEjjN5Dvsrq+icdKrSKBd7S2uJEce5c/Fb3PryBj74oeZi8BAwfdpsDuq7MGlYNsveyQ/apyI7pyddtUdZlB+aQpjcIZ0hud0wSRHk5WYzJK87Rg2Aht69LyOvcyIGcyJDrsym/6VtT9oD66EDzFn4JrObbZuKzv3iZM7qCqq1CYy/ZThj+7Vn6oN/YXtVk5a25J0tDBo2hNyoHxnyhxexAzQcZdSER6mM6cyUW6+hZNPrTP/316dsa8n8p1h/JJppd9zI0O4JVB1vOOU5xQf2s+OHOpLj40nQOdj0yd4Wpl1zSet8KUN6X4JOY6T/ldkMubInCTrvi5ne9VKG5KSj0xkYeGU2gy/vcgoa6kaWvvImcqfelH+8nMV7teRGVfDEu18BcLCkgpwr85g2dggcKGDMs5sASErpxJArM4jVaOjdO5shV15GSpsm6F+97j+k9erLsI6C0X95iZ/CLfHqM/9gfmE9E28dRuyPXzD4ryu86lFtMUMnzScl9ypG9zIybfZ8Vn8ZZNDbfmDTgSj6dosOAbZVb77BjNc/Z/So64it3MnIuU2uk5ofipj95HPM/28NI6+/ilSdCwdQsHwJU979jtt+e90XTpdbacUE9ZuhiiKEkPDqbY1uBY1GTYxeG4iKBsDN7Xbv0Gg0g07nIZR+v5fn93p4cfKlp/oMYHO5Wb/vCM+PGYat/BsmvLaRjg+N4ddMDq5U7GXF93HseWkgFhlm3t6fUR/4H7dMRrcM5MO74fvQ8yztO2Bpr8OgiSCnVwaZAa1CQ88eGajLd2Moj6RvdsapLUeNlgRzSx3CoDn3NW36lEymD6/hs2++wyZMZCQ4+GxfNXn9vVrbmNt+y+DsS6DnHbz81n1sOTyJ1D0F7Evsw6rRVyADc+4cSsbTW5l/S/eTtlV93Iq+bQxpqR3o2SXttPonGyzMe+Q+Xp77DENm3AdF3yOfwmpK6diJlDg3Wm00udkZIaZmaqdLSI2pRxcRTV52xkk0teDvWRyD+l2K80MzSq/LGOCpZ9UX3o/MqN/eRPG3Byn6sZbMrqnMX1cEDCahXQoJ7fQYNVqyszPIaaaYDhx2HSP7ZMDl0cxeOI8SJ2ScVeVfDUvX72fmq4+Ql6Ihr9M4lvSfy277rcgff4IzaxDTh3itgwlXf0hh8EftxzLKYxJIaUUDvvfO2+nfPYb+KWNY+JtFFD96E2m+4+yGNBbPHOM1EfMAFJa//zFTJj/HZR21e1oxQz2AR5K84CYEICH8a7qo1SoiIyJQ+3I/hPcgIerq6j6LjY095SM49mMJ97z1FXPuGEHnqFPZ1Gr0ahjW+zJSjZFgzKJP1HY+K7f/qoHNWVOLrU0cZt/jscTGAxd2UTA5QofF3NI0MepPHd1dtuBJZq7dD8g88dx8RneJPPmHblc+g2a+y5BBuSREqamye3C4m/w/yWbfvJKNWGJcVNY0IldWYj34DSMfPBQ4rnfHS1HgpHRY995/P48sWEH2sNfRJXZk/v+bysCOJy/ZS+vUAYAhN19PEmDs2vHCTwpZjVoGWaVC1khoZRX2RgE0MHPKI2wRqQzqZoHjVThcpxeBNxt9961WoVa5UcRZ+xKorDVgMftIEiNNJETZKD8O6toaLOYmWv+E2JjQjzigyFIrF9WQlOA7NiaWBMlKpR3SfF1O7pjczO/VSEVVI0MsJg6UfFvcGqgF+9eEd0OSZbQo1Dc4sNkdhPjYAGXSpPt3rFjxZi0Qc6L7rzt2mDuXbWPymBu5yqI/jSemoWOiAZfbHXgMLo+ERv51L02njTVhPH6MKgUsMlRUHb3wPr7qo6z/6PMWzvchplQy20af9Nyxk6czdvIJ7k2jxuEKDQasemcDIydOZd6IToCL4i3vhOwvq6oCzKBYqajVkRQbQXJCAglZbdj41NgTaDgqZLenRUTS1L4zC/8+C/CwbP4/mPnaFrbPHn5az6RrtzPMaJIlZMVzxgEMm7WWKrsg1XIautyPe1n4TRylHzyIASjZ+jZPfFESdIAE0pmv7ua02yg/3khyuziakc+jVSk4godQbSAhxkZFlQtSNGCvobLeQFIb0JnjKd3WFPMtqzgKQd8RXWI8CccrKVcgTQ51Q5UfqYEUE9RWUymMmIMgQ24BhhFYzBGUV9TUPvr4M2UnALWQkirZV3EQqdPSRqsRGhVejS1IxMqVK93Ll7/xsSzLw1p3l9Ux+aX30SV3ofrw97x+GFSRJm7t6aX5/uSrPRQfq6LR08A7nxSSntiW69LjubHXpUwo+C89jTnUHz7I54qFv7aL+FUDm5yQwa3px5jxwmYmX2HisTc+hoS+XsCpPcq2fYcpPfAj9qNq8v+7G1NCMjmdzi2Vk6lTdxb/rfs5v7es7t0oeukdFmfpSU1uz+AeHUhpl8CKrVvY2VVi38cfsP4HJUQjX/nG2wxOGU3lp+9T2qEffdvK6E0DSVv0CNNea8etV6RQWVLMHnsbHhqZ4z0pqh0D2h9jzvMbGNzJzMCBlxOrhlX/XgXtutLZrGbn95WkZ15z/gZSn0hXdRkLVnxEXtsoci7P4XS+5xvfXMyYdR5s78049RJwMfEkOb5j2Ud7yNE7eOKlDwnNlTeR0d7DoqUbqexmJiMri7Q2p7Y3Cze9zeVzd/HtZ88SuoxSDP17RPHUorcp72UhL68PyQYT44ZeymPPLiX2zv5sW/Umuv5X01MPcr9+JD89k+mvpZATWcWrnx4hN3hwjekM7ljL9qIG0jJCNftFLy8jM/I3bF+1kuRrB5B+UkVU5tbr+3HP8y99evD78mAz1B0CbsK/MqWvRlQo1DsEkiSjuD2o1Gq1JIRACCH5tH/54YcfTlCr1a372RQXx50qEqM0OFxuHC43jbKW3sleM+ObH0o51KgmJzUe3G7UkdFkJkRjTkyim76RDV//wI9KJA+P6Ecngxp2vdmyjbbdIan7eZmjjdXlKHVH0ev1Z3RebW0t0dHRyPKZhLJVDOiXw4GdO/jP/qPcccswOqUkkdu5LbaKUlZ+vIdaKZoeSVGUVlRh15rI7hgMbFp6ZXcmqhUNPyougZyO8f8z0NaZUxjc1cgXRT9Qr4mhd3oiGd2zEOUHePujQqIu7cu913SkU3pnUtp4P2DXX3U5/8nfzA9SIgv+fCuJkSrQRHHzb3L49ssvWffJV1Q6tQzscxkd4vQBN8Y1A3L48btiSqoa6NGjC9FqsNdUsOmTXeR/foCU7EHMvjWXiPO16I2k4zf9u1F8sJji8mOkXZpBfGTQoGgM9OmRSmvva3xSCld1Twkyq1X06JFOJJDcsRPJMVp0JjOXXZLG4Oy2rFu/lc/LGnhgwk20izfTr1v7wAt/Vb9eVJV8z7eHj5KYkk57k9YXXOhIekJUYM7kZHch2DsUbbYwoNclNHck9L3yCuorSvjux+Okde1Ggl6iZ+/e6Ku/Z+XmL9EkZ7LgwZuI1kigMXLToCwOfF1Ejb49/RIaOGrqyg3dLYH7ShBVLNhVz219OgaCByvffI8bxo5ie/4WGi0ZLHjgBqI0Tc9OZzLTOz00SaZj957EWg+98872vYcAJ9AIOHz/OgGXH+BUsqyoJAm1SkZRBE63B6ciIel0OtntdktCCFkIoRJCaEtKvu+ekpKy7YK8IRe4pKr2289xl+8jLu7MKg9KS0tJSkpCHa48CMtFKkXffEdqp06once59fd/ZOjMpxnfPchj5aph1L1PMefZ2WQYZMDJqBvGMXbRCkacGf0h7+Rvv2/kH+b9SCgHm02CeiQaJSSnJOGRJElRy7LQqmURodUQEaER/uCBkCQJ4Y0vCEBJTe1YpCiePUBmeDjDEpawAGz9cA3jZpehSJEMHTWJcd2bueE1Jla9NCfEL5jetROxZ7hgkyLEvpF/mHesmRnqpmW6h5B8OWz+IKhKklHJEmpZlgnyswXAze12F6jV6l8dsLkjYnDHpkFC4pmZsLUSIj4VNOFltcJyccrEOS8w8QzPmffaW2fcTr2t/tMT+NY8SJIX1CQEkoQky94Is1qLSqNF1kYgR+gC6R5IkuRT2ryIaLVat8TGxk75tQ2OR2fCJUdBwpnpxo2VLkT8JRCmBg9LWM6rfFO6cx+haR5uwCNJUpDGJiFJspBkFZJKg6zRImt1yFodqgh9k8bWLJ9NMZvjtymK5zDQ7rzeRfbvWv7Wtnt4dMMSlotQhBDll1/eu7SZCerffJRFUghrrizLgU2lUqFSyV5gk2VZeDyeYFNUAB6Px/OBSqWacF7vJMy7FpawhMUnDQ0NW1vT1oK2EB42WZaFH8O8wOYFN7k1jc2PjHV1tvwTdaDGauWHY7YTswN4QtOfFUXB7QndfvWiVLNi8SIWLVrE+u1Fv7rbqykvYvWK5SxfdyEC6E4KVq+m0nERvN2OKtbnf3bC3fu2b6SwNLTWeveWNRRVtF4lWlm8k5XLl7Nmy+5m89PJZwVrWb5sGXtKm7h4PitYT5Xzf3PrBw9+91UzUHMD7lAzlBYaWxOgqVCp1F5g828Q4DYSgBIbG5sPHA59GDYeePpVrl+0jj8se4e+T63iv5X+AuRG/r7sbfL+9gLpc1ZSFjjJxUP/eo2+83zb4y9z6cwlfFQjfuUzVMZgMFC64y0Wrt7xi+u9u2QLo6c81fpO6x4G5V3P9qJSKiprOP+fKTtPTHuQwouAO2HdM39i/b4TE6WtX/wwq7eXhfy28dW/s+2AtSVGlmwid+Cd7Ckto7I69OGtnfd77n3ibcrKK7Dam2o7bHvWMH3+xv+JGdqjR4/vfeDV3AxtKqXyFYYGY5cX0Jo2tU+Fk5rSPiQhSShCCAVQPB7PBpVKdVfTu6rhnlEjyGzvLRNZvf495uR/zYZbewMqBuflctegBgY9/0VQlzU8+cDvA3+VF33JyM3H6WOSfuW4ZmLYrWPRVX9CYckJtJ7KMmrcOlKbM6QoTspKy5ANZpLMoTWQDls15ZVWzEnJGHXnKa9OUXDUlLFp+1e43W6QZdT+5GRFwVq0k1LLQObNnO6dWKd1TUAGe00VlTZITW66Z6e9hrIKK0mpKeiCL+Z2UFJWiSXlDJduVJyUlZajj7UQa9SFdKKyrBS33kxSrOH0AN5hpcoGllgtZeU1JCVbmu7XN046cxJmQ2g71RXlWJ1qUlIsIc9HARS7lbIqG8kpSaGJvc5S5i3ZycLdr7R4eBWlpejMLWm/FLeb6Us+Qa2WW1hJxTt2YOh7C7OmT0OW1SHnbN++g3FTNjN5cGh+5sDxk5ia/QClU4aQcgFjZXa7fcsJfGueIP+aAgEfW8AM9WtsarUKtVqN2mePEmyS+sKjCuCpqanZEBcX1wRsRJDZvqkUKiU2BscRf6GzmsvS2kFtyUlv4K2dexmWfTUXdXxRsTF3/A28WugmRV9DlbEvG9c8j0UH9rIdDB50G7r0nsjWMmL738+Kx8YBsOXVv3DX3PVkZaZQeuAAM5Z/zqgswznv3hOTh7N+5w/YDlQxaMh1qOVEFq5dRmcdPDZxCJt2H6bmYA1DhlyHnHoVG5fMPCW4je/dBn3/CWzN34JedjBgygs8MSGPtfMfZOqCrWR0NlNU2sira9bTN82IrXQ7gwb9Dl16Fg6Hi5ogjqExmZGMWtXAqK5Qs2MJXad+SsWOFwE4sG0po8c/SmznLJxVJQya9iKzx/TGXr6L0SNuo8qYBlUHSB3xKMtnjz1pv8fntqXEnEvprs/omtsHa/FX9Jz4AgsmDaRy3yZGjrkfbXIGNQf3MXD68zw5cRBQwcisflQmdCaWGg5Um1i5/m2yLDo2PnM3j6w9QiyN2KuKcGbcyfYVswLvQknBKio6/4aQIXVWMWnENWyrScCEA7etmsFDfIpz4TpGTnuWol3bmL78W6YOSfadVMWUkb9j58EDFFfKDBmyGUvuLSx77C5Kty5jwpzXKNpVjqH8NtY9pWPcrJcY199bFomxJ4M7l7OqoIRpQ1Iv2Cuxb9/+L09ihgZpbKFBgyYT1GuGqtVqSE5uh9lslqKjo6WIiAhZrVarZFnWSJIUKUmSUZKkBCGUfUIoosXmrBP3PfOSWLj3aOjvNcWi56w3xaFWznHVHRJ5s5eK/Q2tXO8CbEeOVIhDhw6d8Xlff/21aGx0nFWbHz53j7j+jy+H/PbDB0+KxF63iFqPIoRwiD9ff6l48IWtQghF/Oe5e8XV9y0MHBvc7u2XxYhXPrf6/naKxkb3Sdv+8aPFom1iokhstj36xmen7HfD18tFTK87Wt13/POXReKV95zRc7ijV5S45r5nhMt//Qa7qP1qlUjseJX4vtZ7H1+8MUP0un2uEEIRz97dR/zu8TXe9r5aIWKkRPHhj95zb+kWId7a7+vLfxeLxCvu9LbjKhNXt48Xr3xS5mvXLY4drxFCKOLRm7uL+57N9x1XJW7s1k68+6395H2+IlG8td8pXvvz9eL2f6wRxz5ZIrr9do4QwiZ+f3k78ff39wghFOGp3SN6tb9UfFHrHc/a2qbrvvbn68TtvvvY8PSdol2/e0W9UIRoOCh6tWknPj7a1N5bf7tF3Pjw0pA+fPHGI6LjtdNEo1CEaCgVV7XTiEffLAw55s/XdxBPbyhtOW/fnCV63PFEq/f2x+s7iOc+LG913+sP3yhu+dvKC/ZeKoqnCBgNDAcGAblANyBVkqQEHxZFyrKsUavVqoiICDk6Oloym81ScnI70tPTycrKok+fPlx77bWoZVnljyhIsiwLRVEkXxDBb456nE7ne1qtNpR0TXHxr7c34E6/gnsyTr88advO/cRf2pWuOi5q2bXrS3r2vQajDKBlwOA8Htu5Gyb2JbN3fw7M/TPj5RL65vVl5Mih+ImkBgzsy5y7buTAyOvoO2goQ/NOzslm6X8X5RV3/Wx8jmPGjg2YXjqdjh3bClD0sGjuX7zTqqqIPbt0KMCunXsYOMFLGmDKGkBP86kNXveBbXwm92ZtXlKgzViTEahky9YDxJo/YMaMD706jdtB4e4Shqd3PckV9RgMajAaMBliMRjtOOw2sO5jy247csHrzNjqNRWd7lL2HLSRna1jx6onWbjiQyqtDmoqikkddXPgij1ze6MH0CWRmlBDVQ3gs8qrq6swJYeygRTu/pK8AXd6tTpdMgPz0s+7T9MYa6Kq7MI5NGtqarbQstIgxBSVJEkJrBsaEg0N8q2p1Wg0Gq8p2swcFVJTtq4CeMrLy9enpqY+FBTyZMV7G/hY7sgr12Vw2rXHSiMrsSOgpAAAIABJREFUdxYzcsRFluJxhsXZCb3HsG93LgX5Baxe+jeeXLGdfWvnIgMTnnyX/ru2UbBlCzNG9WP3wo94ZMSJC0Qqd6xg8L1/b/H7uNmvMW1E1oUPphhbkg9Y0noxYoR/7YYbGTU59pSPzOvV8zrtFEVpetFPeqKeAUNvoneC968RI24kJT3l9AZP9jFEeOETUFC0ZgaPvJEU2X+9m0nrrKd8y0ImLPiC/I3v0TXBwPon72R+RRMUqeUT+0WNJhNWq7WVPsgXdKRsVismk+GCtbd168dfNQM110nMUBGatxbkW/MBm+xPaGsCtwBVeCA6mpbWaZ+iKJt8sQve//BD/l1n5sWbexF5Bs/76A/f8ImnLcPTDBcVrlli21JcXBLylc3Ovozd2/6DVQFwsmXjdnJyegYmlSEhlRG3TmDxMw9TsW8/Dp8D2Wq1k57dn4nTZvHQ+L7s2XfgpG2bs4ezft17rGu23TW46yn7rdXpUKqrfH08fVn2xBTmLs0/rWOz+w6k6sBXJGX2Jjc3l9zcXNJ8QYXs3J4UbPGmktQUbmFXVVNHYs1GSku8kcEd23YEnq06vS+9lc9YGYgaKtTUWIEEBvRP5mCFM9BOdkbnVoH29FSaTAZm2Cm1xgaul5mehtEgU1FaSkLXXnRNMIBiY+26gtO+bE52L/btCaWKz86+jO1btnlXg3OUkb/94Pn3d+3ZQ052zgV5P9xu9+YRI0YcCwI2Fy0Tc4Ny16SQZNxg35pGo0ar1aJWq9V+UPNFR2UhSQrNzVG7vWGtwRA1mIYjPF7wHVZdBAPn7ve+APFpfHLv1QDMXvwq71c4qXO6uXHOS2T2uJzXbvRqBm9/vp9+vXphki8qXCNz+ATyXr6JtK5vkTX0PtY+NZmUQROZsvx9cnKuIkVnpcrYn43jvGbXZytmM/GZj8nsmkJx4W4mPfKS13TBzUPDe7BLSSfJ6KSwxM3y9YNPrm9o9SQln93LK6cPZGrvZ8nJugyjIZVlBe/Q9TQutWPTW+xO78wj407NMG/MGsHiSR8xsGd3umamU1VykK6j/sarM0dx1yN/Z+Xg3zFg64s43YLkIFN03MS7GTq+H5uyOmMxRyDjW/tBncSi5f9gzLirWNY1E6WqjEFTn2fmmN48NP8Vxo68nZzlyVi0Dg6WCZZt3UrOWVHg6Zn36kuMHnMDa5/qis5ZSamtHfk7V5E1dDzmJ64nb/Cn6OxVWBLSTvuq6YNGYph2Gwcdj+Ff+ydr1BSGLb2GnLxriZVdKOYmmp+XZ9/By/nFFO+rQFdyE6se0zNj4XsMyzKe/YS1H2DjLiPLl6VfkPfj0KGyT1oxQV0nMEOFJMlB0dAmTc2vrWm1WqRu3brR0NBAQ0MDjY0OqbHRicvlkhRFkRVFkYUQakD7f//3mPHhhx/eBrT/JYNMZWUlTqeL5OQzqxTbs2cvnTtfgvYc14rWVJVjdWtJsYS+XU67lfLKakwJSZj02hbnVNtlUpItqH8lHwm3w0Z5RRWxliQMOm3wDsrKqkhISUbb7F5tVeXYMGIxt2IBKE7KS8vRmS3EGkIdutUVpTjQY7GYz4GBp1BRVgq6WCzBaTmKk9KScoyWZEz6M0vJWT7rJnanPcwT43uHtFNZXobOlHRatO4/RbYvmcaTpTmsnnP+XUZCiLKbbhr553fffddOE0WRDbBJkmTHy8PmlCTJLcuyIsuyotFoRESElogInYiMjCQyMpKoqCgMBgNGo5HY2DZIPXr0wG6309DQgMPhkBobG3G5XFIzjjYNoGtsdDyi0WimhoEtLGE5f6JYi1m6qYTxowb+T9ovWPUq6UPGkWI4/19Nq9X6UkyM6QOggVDutXpJkhoAhyRJLkmSvNxrarXwAlsEOp0X2PR6PVFRUURHRxMTE0NcXJzXFPWboyqVSqhUKsnj8QhZlvB4RHCJlfvQoUNr0tLSpoanXlh+PVLD8oXLqG7Fj2jJ7MuoARd+zVbZmMb4UWn/sycycNT4C9bW5s1bdjXzrZ3QvybLkvCbnz6sCjJB1Wi1GiIiIoiM1PmBTUWQr80XHZXxxkYD0VElPf2S/W63a7UsyyPDL0RYfh1i4tZJk8OP4X8gjY2N60aMGFFFqF/NBbgkSQqweRCoDQ1l8QjGLr9vTaeLIDJSj6zRaAIHBKd+BBfG+wIJHryVCG+HhyQsYQnLT5WioqJPWtHWgoMGntYoipqneGg0GjQaLVptBDqdDr0+AGyaQLjUr+KpVLJozvYBeMzm+AIhxCfhYQlLWMJytuLxeHb07HnZ9yfR1lqweahUTWaoF6vUqNWaFtqawRCFWqvVoNF4bVSXy4uAbrcbb0WCgqIoAXATQngAd319/b/dinJlrUumXRtD65E5jwBVsyJ3j4vy4zYiogzERYYptn/OsrtgNTsOVIIuiXHjh6MPP5KwnEM5dKjsPyfR1vyMuUposbsqxAT145bft6bTeQMJ0dHRqLVaLRqNFrXa2UoQwd1ioRfAk9Il8+1LH5w7MTHCk1nuiuTpcdfTJyESL23ROt79ropKxcSWv92CvyT3yKFvGb9sG3GWeI5XHqVzrzz+OagLcniMW5XyHTBnCyya8b9pX6vTY5ArmfrQG4wIA1tYzqEoirKvX7++e1rX1pqW1sO/YIskCVmWWgka+E1Qv7YWicEQhdEYgxwREYFXa/OapE3gJvu0NjmQrOsHtuPlh9z5D9z05uoHb+ehjAjm5H/t67KXtui9e66h+Rrjb2z9lO55V7Ps98N4d9K1fLp5O181XCQD6fvXWgVlFaH77DVQXErISueKArZy2LoL3G7OaPVvBe9UKSkGuzO0A7bqlu2fSDLyhjB29FBOFPF3O6wUF5dgd7bsXE1lGSWl5bTYpTgpKymmvMoafrsvYqmsrNxYVnY4GNScBNYLDSmhUkK1teCggd8EbdLWoqK82lqbNibkiAgdWm2EzwHXlMGrUqmFvyIhKIjgawz38uXLVwLfpcTG4GgMpS2Ki2yZQGjQalH5l7OXALUWg+riGMj+Fpj2EOQNguGDYIGvOG3xDOjZH6ZMgKzeUFTt/f2hMTBuNpRsgSFDYPAY8O0i1wy7fRyEe1ZAz7FN7eQvgAFjYHAujBkL2SO8v88YCUNGwsgxMCgbJi/8iWbq2mfo3LkXU6bcQ9fOPVi5o9S3x8mTE6+h79A7mDr59/TMHo5/j71sB30zLmX85D8xfuS1jJm5NPyGX4QihCieNevRL09hhrYoePeVTYng9A4vsEUQEaHzJekaiImJITY2FnVkpI6GBq8653RqfL42dfMIabBJ6gE8d9890Xrb6BGvv/zpd7NHXzv8lDd0x3XX8MDrmxhfvJfqYzXcOfpaLrlYcl3dEtWxgj0+ZmaHA4rXw2NboXAXmNSwdi489BSsfQyeXAkH18CIFZC/4sya2rkNdu6GDLO3ncCHJRNWzYGaHZA6EZ6ZBGeVv65UMm3S/+Oxtd9wa7aZfatmM2DaY4zYvhhtzW4WrLKypepzUmVQnM6AtrpjzVK0A/9E/sJ7vRDodIbf8otQjh49+t6LL77Y2Jq2JkmS3wz10ET/LUIjocGgpiUiQktkpC6grZlMJszmeOTISD06nY4mX5uGZkm7wekfIakfk2b+37/d6VcUnw5t0ZbPvqBSZ+Geq7K55/J2vJG/kwA/5a9dZMGtQZqVTgfbtoAemDcTZsyAjbthT+FPb6rnUC+o+dvxS56vOseUArpqb3r32Tn/Cim0ZzAg29tIxsBBqAs/p1QBjOn0T69kzLDbmfvMInaX1QTAM7N3fw6seZzxk2ewZPk6bIo6/JZffNra90888cQXzUAtWGNrkeLRHNRa+tZ0vkioIVB1YLEkIkdF6dHpIvH62rT4o6ShqR8qEQRqCt4IqfuV+c8c//uAjktPHQBoZOWn33LbtVfSJ9XC9f360s1VwqaS+osE2MBoaOkLS+kJI0Z4t3HTYNUTZ+azU9wt9xlPUPscYMo5n9EaOZal2/cyf/otyBW7GNz7craWeTUzLxXTR4zI68zWpX8jb/RMlPC7frFpa2v/+c+nHM1MUL+21uoSe8EYFFxh4NXWWvrWzGYzarUa2WAwoNdHhmhtTUm76ta42nzgJnkkSXKvWbniTSHE/pPfkgpDhIofqmq9L6SjlkP1EgbdxfvV7j8ADhRC1xzIzfVuKUF18HojWCtDgwoACUYo9THybPvsPHfSYMbsLqekOqgXSZlk6fexZVcVAPsK8nFnXe7lJHPasLr19B44jBnzFjIi3UFRiVc3PDEVU1guEm3tm9mzZ+9sBdScQf61VlI8ZEJLp0K1Nb0+spm25mU+UUdHG6mrq6O+3o7D0UBjYyNOpxaNxoXL5UKtVgu32y15PB6heMNzQggUEIoQeCZMuLP2hTrLazumXDcPTkxbNPn6K7l71Xt8sTOemqoqkrL6MDRo7YSLTdKGwsytkJMFmeneKObQh2DuOB9+5Hr5kbOywJAEGzdCLDBhItw1CBZ2BbMBOJ/UdupUZs8ayq09u6A3pbFi+4dkGiw8teCvjBrZh+WZaezZV86C5e972V1rCumfezvmjCzkmhJqEsYwL9fL/XtiKqawXAzy448/rn3++UWn8q2FJOQG0RKJlqAWEWD1iI420qZNG+Lj49H5/C/Sa6+9SmlpKRUVRzh2rIqamlrq6qzYbPWny/qhve66Ifp169atkiSp90nvzuOivLaeiMio/1mC7s+N3cNhg4pqsFhAd5qXrq4ERQdm4/9uorodNsoqqkhITkEfnKGtOKmoKMetNpGcEEpxfTIqprD8ekVRlJ2Zmd2f2r9/vwMvi0e9b7MBdh+Lh/N0WDwMBi+QmUwxxMWZsVgSSUlJ4ZJLLqFHjx7o9d7PpbpNmzbU1NRQV2fDbq+nocFBY2MEWq0Tl8sbIVWrVcLt9rN+yHg8nkCyLuDZsGGj02q1vhoTE3NyYFNpSIo1hUc6SHQGSD1DrSs24X/fb7XOQGprHZe1WJJSWz1HqzeSmmoMD/pFJsXFxe/v37/fzakjoQpNq7v7tLXmvrUIH4OHV1szGr3aWkJCQgDUAGSz2YzJZCI62oBeH0VkpI6IiAifr611f1tQ1CKw+ILJ1OY9RVHWh4cxLGEJi19cLteHl1zSeX8zQDulb601v5pGow3QEun1UURHG3zpHeaAby0AbAkJicTGxmI0xmAwROFN/4igqSJB7UsBUYkgCvGQEiu8iy64KisrXw0PZVjCEha/fPnll5sITcYNAJtPW3OfXFvTNKsHbSp0Nxq9ybgJCYlERUWFAltSUlvMZjNt2piIjo4mNP0jIkhr0zSPkrbQ2tq2TdrucrmWhIczLGEJS319/fIrrsg91AzUGk+krfmX1GteNuWnJDpRekdSUtuWHpHIyEgsFgtxcXHExMTgTf/wJu1GRGh9KSABczS4zEo0qyF1S5Lk2rt371Lg8K9tkDIzu4VpwcMSltMUIcThNWvWbG1NU2umrYXkrbUWCfVXGPi51pqnd0RGRrYENoCkpCTi4+Np06YNRqORqKgo9PpIIiL84KY5bV/bZZdlf2e3218ID21YwnLxSmVl5cqxY28/3kxTO6G2diLfmtcE1RIR4c1ZCw4YxMfHk5SU1Gr73nXItVosFq9J6g0kRKPX6wOBBK02IlhzE4oQON0e4fYoQhFNrB9+dO7aI3vps/mFm0M4HNwO3vpoB9NXbOLx/N0caRTh0Q9LWH6F4na7P87Jyfn8NLS1kKX1/NUFvlQPXyVURFDAILge1IzF0vaEVlQgAal9+2T8gYSYGCMGgwF/HWmw1qbRyDjdoNZoUKlUIATC1zk/uB06eMC5YMN/lwQD27L31/N6iZMxfbKIsx5iwqrPwiU1YQnLr1AKCwvfLys73Ly6oBFoDAY1H6ApwTWhTVHQJm0ttB7UGAgYtG+ffMI+hFQOJiW1JT4+HpOpDdHRXpM0MtJrkjZpbTrMbaKFITKCCK1GqFSy8GJbwFb2SBKug0/d97HL6fyX98qN5O89wl3X5pHTwcLEG/rg+qaIrxvCkyAsYfk1idVqfbVXr5wSH3gFg1pwwXtzvjWftqZqRVvThVQYmEx+E7TtSfsRAmyJiYlYLBbM5jhMphifSeoFN52uyRz1RUmFWq1GBNGLNGltkhtwbisoeEUI8SV4cCsClcrXnKxCJWwUV7vCMyEsYfmViKIoXz3//KLmAYOAb02SJCet+9Z8JqhGNGlrTWVT3py1aEymGMxmb8AgMTHx9IENoF27diQkJPhy24wYDFGBInk/A4g/kAAKipBQa9QBIkpJCjBgusddN7Ti+PHjL4CePp1iWbW9kKM2Ox98/CU/CImGRnd4NoQlLL8S+fbbb1fPmDHD1gqo+TU2P6gFp3i0WHGqibnDX+Qe5VvhPZaEhATatTt1OWQLYIuJiSEpKQmzOd6X29ZkkgaDmyxBncMjdHo9GpWq1aRdJMkVF2fe4HK5Xrz7xiF05wiTXt/Ap0oiA2JV6HVhTq6whOXXIDab7Y2uXS/9JsgEbWymrbWajNsUMNCI5qAWWuTuJZBMSkoiJibmlP1pFVnat29PdXU1VquV+vp6XyF8I06nE6fTiaOhniO2RowmE2qPk8ZGBUVREEIIRVEUEB4hkCSQkSTVJ5988vJVV13Va9pNv8kGcNeVc/W2aP4UH16pKixh+RWYoLtfffW1za341YJBzYU319UjSZLSPBm3ya8WWjZlMESHFLy3b9/+tPrUKrBpNBqSk5Opra3FZqvDbrfjcDi8lEaOBr4+VocqMgpJuGhwK8ItJEmtUgkhFDwe8NIaSYoANwLX1VcPLNvz5a5FX3qiFidpFd75+HOycnvTMYxrYQnLL16++eab1Q888ID1JCZoi2Rc36pTLdI7vH61llHQxMQEkpOT0WhODzROyKdqsViaJe5G+2pJI4mPi8OkjwCVCkmlQpK9qCvLKiFJCCRJSJKvYl/CJUmSM/Oy7E2lJSXPri86TM/efXl6cOfwjAhLWH7hUltbuyQjo9uBk2hrfmDz+9Z8AYMAqIUw4nqjoP5a0OiQRNzmhe5nrLH5JSUlJYjSyO6jNGokPVnxcbbZqK+309DQIBobGyWPx4Narcbj8QifBBZZliTJmVhT+tKM3/++myzLg8JTIixh+WWL2+3e8uijsz9uBmoOmnLWThQFDTZBhZe1I5g8Uu8zQU0+E9RCSkrKGfXtpAz4UVFRJCcnk5iY4EvcjcFgCC6Ubwom+Gu7VL5Agn+pPoIqEu666+7jhw4degEoD0+LsITlFy0/fvrpp+89++yzDa2YoI5mJmigwiA0YKAWwZqav8DdYIgOLKPnN0Gbs3f8JI0NvIGE2tragNYW8LU5vdThbrcbt9uNx+NBUZqCCEIIfOAmCSHcgCRJkpya2vFzq7V2QXR09Nzw3AhLWH6Zcvjw4WV9+/Yr84FXMKA1N0HdQRUGomlRltBggb/APSrK4EvtaEN8vDe143QDBmcEbAAdOnTwRUhtNDQ00NjowOl04nI5g4DNjcfjER6PRwoGOJ/WJvlMUpckSSqjMebfjY2ONK1We1d4ioQlLL8ssdlsbyQnt99FaGpHcxPURWjZVAsTtIljLbjAPZSOqEOHDmfVx9NajC06Opr27dsH0RsFM+76qxL8xJSaU5mkTqDxww/zlyiKUhCeJmEJyy9H3G73R4sWLSqg9QhoQGM7mQnqBzWtNqJZdYGBmBhTgI6offv2REdHn1U/TztDtn379lit3kVeQrU2v0nqwePx4PEoJzJJEUJIPtXUOWzYsPLvvy9+vkOH1A6SRKfwlAlLWH7eIoQo3rFjx9o//emhulZMUActAwaeE5ugXk1Np4v0sXb4Oda8Be7JyclnZYKekcbml44dO9KunTcFJFKvB00k+qioIGLKCLQaDZIsC1nlX0k+hG03EEiQJMnZsWPazpqa48/RcvnMi0aspXtYv23PubnO9n0XpM/b1q+gzPpzf66wftuFas1OwfotOH8hc6W5fLZpNQerT/kKuou//u/yfv36lzXT1lozQf2JuL7qAq8JqtH4tbVQv5q/ZKpNm1ji4+Np1y6Jjh07/qR7OiNg0+v1dGhv5q1PCnn96zI+KSln03eVNKi9NrIkPJRU13HM7sRqdwi7S0FWqYUsS0KSUBThXYtUCOEWApckSY2xsXHvNTQ0PPVLAaInJo9kW9m5I1yqLMznmZVbfvJ1yj9bxSML116Qe1rw0O/Z8TOPa1cWwjMrW3lOO+Deeee2rd0r5/FkwUG0v5C50lxennM/24ptJz3m2LHqF9N79N0TpKk5gjdJkhqDQa3JBJWESqUWXlDTihPVgXrz1cy0bZtEhw4dQlacOu/ABtC2XXsm/m4M838/ggduGES/9kb21ziJiorCEB3DpR3akZ6UQLuENkhCwYWMLKuEIoQASciyv1Be+BkAGnNzc5e4XK7XfgH+BQq3fUhZjTdoEireCaw4bBQXl+IMms/2miqKi0uwu0MnuaIopA6ZzMb5k1u9lsNWRUlZ1Zn10W6lpLSiBdedw1ZDSXExNof7DO7Ju35ocUkpdmfLF7SmsoyK6pYvhK2qvNV+K047JcXFVFnt53WcFAVSh8DG+S1/t5XD1l3gdnv/DtnvgJISsLeieil47YqS4ub77Tz5xBtMmjT2lzVXFCdlJSXYWhnX5uNkt9v/3aNHj+B8tRYmKC1TO3xrGKhEMMda82CBnziyKV+tPW3btv3Jc+AsqtAjuK5vT776SsZubyDFksCntdUYDBG4XG4kWcaGgsfjQa1RC6FSS2oZHI1OZFkSEiKQAiK8KSBSYeHXckFBwYuDBg1KUKlU1/0cQa1w3TNMe+ZdCg/a2X3XdSwxqBk29Z9MHZYFwKvTb2R1TUcqP9sMeh3qzJvZtmQGT9w7iGW7PaQl6Nizr5zZr77N2L7pgINZ44aTX/gNtqz72LNsRqCtRVN/w4oDcajdx6k6WEjK6MdZO2/8KftYXbiGAYM+QEc1Ffo8CtY/T4IWVs4Zy6zV39M51czBwiLGP/EGD43KOeU9rVvwIFOe2kRGVmfKDxQzd+0XDEn36iXLZo9nsfUI+3buYurL/2H6sExwVzNr/M2sLFJI0dupNvRm3ep/YdFBxe41DB71J1Iys7BVHiR7/NM8NXHgeRmrWeMgvxBsWbBnWdPvD42BbUVQUgFDhgCxsHIlxAI7VsL4GZCeCQeKYO5yGJXjPS9/AczZBrqDYNVCjQmKfAtNOorWU2DPYUma7hczV5Sag4wc/BsqDF2R7Q04Kp3k+vY1H6eet/8jP831zYeHDx9uLVetNRNUCa4F9a8JqtFoRdMqU5GBOtCYGBOxsXEkJiaSnNyeTp3OkbtdCOWstuPHq/l48wf0v2U8193/Z+677z5Gj/4t1157LVdccQWdL0lDNsQRb2lLbGwbSVKpJJVWK0uyrJJkWQNSBJIUJUmSSZKkRKDDvn17hyuK51NvwcL52Y4cqRCHDh066/Nv6xEl3trvbPH7K3+8XsT3GiV+rHcLIRTR0GgXQiiitrYmcMz3G54QHa6dGnLe/rdmiW63zQ357fkHrxGX3zZXeIQiXIcLRLu4K8QPnpP3a/9bs4SmXT9xqEERQjjEH3/TUfzp9c9a9KFu/yoR3+VmUX+Ke6r9apWIa3eF2H/M4f2tsUYcr/Pe2y3dVOKPL24XQihi779nik43zBBCKGLzc5NEj5sfEY1CEUK4xdN3Xyn+8OI23/O5Ttzxj7WB6zc2Ok7+rBv3iT5tE0ViYuh29f3zT2uc9r+liG63tfz923cU0e2W0N88RxXRKVERnxz2/v3jx4po308RLt/+D59TRGQ7Rew96v27oaHp3C9emyG6/+6xX9RceffxsaLffd7n2Hhkh+gUqRKvfF7dYpzcbtfO995b+wDwW2A4MBjoC2QDXYEOkiQl+t7hKFmWI1QqlUatVqsiIiJkg8EgxcbGSm3btiUtrSOZmd244ooruPbaaxk9+rfcd999/O1vf+OVV17m44+3cvx49VnjUfPtrHmDTMYotuwtJrJbH4bFeygvK/NFSN00NtRzyOrCkhiHxt2IQ3iEJMmSJKuE1/yWFCF5kLxqqwTIkiRJGRndvi4rO7QwKSkpVpKk9F9aIGDwyFux6L3WvU7r/YJXFG5i8jOvcKCsGsVRRaWcd1rX6p2XiwzIScmYndVYnYDu5Oek5V5Nsg5AS/+BeSzcuRvG5mAr3cmMef9i98EKFLeNmmojVuBkXoxdOwpIHXQzXWN9niOtEZO2SdHvnedVZ5JSUrBVfQ7A1q2b0dpzmDXjYQBKS+xU6AqBPLL79mPG5D9xb8Vn5PXtz6hhgzjpml/armwv//GCjFvJdihXw5r5sNZrpWHd4y2P8Rfy9BwKGWbv/3VB41BZfRSjMfkXNVd27fyc/iOnex9zQg59M4yBfU3j9Ol3SW2T3np0+v1HmgUKgiOgJ/CryaJpBXd/sKApAmowGHxrgrYhIcFbB5qamorJZDpnY3qWwOZhxXsb2BOfwxPXGPj+myKcPlojh72OT47W0S45mWjFQX291z8gq1RIspoILcLjceNUEEiSgi9x1w9wycntP66qOvpcXFzcTCD+lwRsOqOhmbOpkFGj/spj6z9gWHYK9l1LsUz48PQGRg4aGvnMHdCK34OqVDFh+G0MW/Qh8wdnoq7cgiXzrz85DC0H98/nrFKArNxrGTHY900acSPGhFQAskbMYF/OcPI3FbB03n0s3fJH8p+598QNOA8yIu+3lDTraNdhD7DisQnnfOyMyTByRNPfI8dAQvB+Y+vnmY3R2OzWX9ZckeXW3HTB41S17PV/v/Hg9Pu/J7Sw3dGKXy1A9R202LHwrwnaMgJq8AULvPxqbdt6k3CTk5PP6XieBbAJ3v/wQ/5dZ2bp73phkAWehgYcDgcOWw3rdhwjOS2dRBxYrbV4zFNiAAAgAElEQVSBUquoyAhR5xSSTq1G8bgBSZElCQF4CxS8/jYhhGQ2x6+vqTluiImJ+eup9ZQLKwajnqrKauiacOqDq8soVafQt2cKMrB+zbu40Z+3vhXv2EyZYzbJOifbCraTM/YP4K6ktNpI/7xM1MCO9eupVE59T9m5AymZ8w+Kqqd4tTa3lRqHAZPhxPGmAf2v5qFtxWTPGuvVxhQ7VTXexqxWK7HJGYyekEFukpu8J4tOfjPaVBavfY/mvm2t4ad91fVGsFZ6vdz+yZ+aB4ZSkFOht49Aoqrq9CZe1545lD+zASe00EB/rnOld04v5m3bCrdm4azcybYiKwN8+6xWq6NBinnlwUf+3z6a0jocQEMIqLVM7fBra8H8aqK1ygL/KlNt21pISelA587nnunnzIGt4QiPF3yHVRfBwLn7AVBFW3iqdwqFhV9ySNGiPnKMb+x1uBvstNFHYtbpiDXFUH/kmKhv9EjCI4RKrZZk/MSUIfWkkhBCNpnavGWz1UVFRUU98nMCtgmT/sD4CVex2GRgzCMv8tDInic+OGUAU/IepW/uNaQZFMwp8YEHXrFjBaOm/wt7VQklVTJ9+75P5rAHWTRj1Fn3zWL2MHbQ1aipptI4lILR2aBVmD6hM8Nz+9AzWY+c1B6LfOp7MmaN4NUZHzE0pwcZWZ2pLC3lsZWfMjj9xAbkgIlzGPrZb8nseSUZKSYOHihm8oL3uXeQgbVPjOex9UfJSI1lX2ERjyx8+5RTMyHpzL/iFTtg1HSwV0FJFfTtC5nDYJHP356UC4OArCwwJMHGjRBrhuXzYVyeN3hgLQdtDuQvOo0PXc+h5LkfZWuZk0HJ2l/EXBly7yxeHnQ9uQM/QO10YbQ0qaPLHv3di/c/s2FXM1BzBIGbtxa0lWCBf6FjXwRUtBYBjYkxBdYtaN8+hfT0TkiSdM7fU0mIc5Nnc+TIEfbu3ct3333HoUNlHDlSwbFjxzh+vIa6ujrq671F9PX1DThdTsntLaCXPB6PJISQfZsa0ABaIYQOiLTb6++JjIz8w7m64crKSpxOF8nJ7S4YGFaVleDWm7HEGs57W267lfIaB8lJCSG5PDWVZdgwkJxwZhqP22GjvLIasyUZvfb0soPsNZVUWd1YkpLQBn06HbYqyqtsWJJSTvtaF1IUN5SVgdEMpjMYqm1LpjK/NI+Vc0b/guaKm/LSckxB43r8+PEXYmPjtjQzPRsAu+9fr9YmSU7Jm2QfADZfZYE/T000AZqB6Ghv/WdcXByJiRbat0+mU6dOdOvW7ZSLspytqGbPfvTcmGgGA5Ik0djoLY53ufyF8QqK4vGXWPlDsT5QFU2/Bdu6Xs0NgK+++mrPyJEjUavVvc9FP+vr6/F4FIwncpqcB9EbTRgitRekLVkTQUx0FM2/gbooI8aoM7fqZbWWmJgYNKrT/6pqdFHExESjaoZdaq2eNibTGV3rQookQ4wJdGc4VClZvWk8XEbXHl1R/WLmikx00LjW1ta+PGjQtZt//PFHVyvA5k3C9fnVJElyNTM/A6DmNz/9Cxz7AwVt2rTxrVnQNmB+nmu/2jkIHrQuqampOBwOnE4vrZHb7QpQGnk8ig/kvGDWBGpCeJMlFcVXV4oQwuV3uq1b9770+OPzljzyyMPqiIiIe7hopYblC5dR3YqCbcnsy6gBPQnL/0jUsYwdN+IXO1fq6upee+CBBzZ/8cUXzfPUmkDNGwH1a2oefMwd/gho8wRcbwTUn6sWusJUWlpHUlNTz++QnOsLdunSxcfZ5gykf/gL5P2am28TQgif1kZAlVMU4WcCkfw+tzlz5tTEx5uX3H333XJERMTdF+fbY+LWSZPDIBKWczpX6urqXv/rX2cVvP76soYgTa0hePODGkGVBbIstRYBDfjVvISRhqAa0IRAWkeXLl3O/7fmnKvzkkSXLl1obGz08bW5/FxtAc2tKZFOBIGbQAih+IhAQkxUSZJ44IEpx7Ra7ZI77riDixfcwhKWcyd1dXWvP/bYY/nPPvtsPaGBgoA/zQdqIflqXhNUbhEB9S/E0pww0pur1pbU1A506dLlvAQLzjuwAURGRtK5c+cgWiOv1tbka/OapD6z1A9uwqel+SOlweAmSRLSPffce7SxsXHx3Xffreh0unvCUzMsYTlrUHvtr3+dVXASUGuQpNBVpoKXzguOgDZpak0JuDExxoBfzZ+r1rlzZyIjIy/I/Z2z4EFr4KbT6QLg5vH4wS3A1ebX2vybD8bFiXRBAbBhw0aXJEl7+vTJdWs0mjMOKPwvggdhCcvPSWpra1+ePHlyweLFL9pPpKnRSmVBE6jJwr/AcWgENKrFegV+n9qll16K2Wy+YPd4FjF3D58W7mXO6nz+uLKAV778IcBD1Vhfw/KPPmXGvzfxl3e3U6xEcckll9ChQwoJ5jgaFInD9Y3UCK1vdXl98OryQqPRoFKphT+D2R91oYnDrRFwPPbYY7U33zzqBbvd/vSFnhQH9+yk2nGuruZk367d2E4746ackTm/4cBZEH9ZK4opOgP2h22vPsK9T6752b+kI3OgqJXnsW8XZ/BcT0fczLtrNFtK7D/puZ5KKkuLKKk8S7I79wGGZN9M2UkOOX78+AvXXDMoP8in1kJToyUNUXBhu4+GKNSnFhmp9yXgeqsK4uPNWCxt6dAhhUsuueS8pXWcO2BT6lizq5wuqR24IaMdm7fkM2trCQA/FJfwdb3M1d07kx0reOCFVRw2tCU9PZ1onYb9DRL1HsERRYPRaMRgaEZS6QM3tdoPbl5yymYElY2AY8OGDfVRUYaXbDbb476BuSAye+zVFJScK17MSiYOvYki++kDYWlJMc6zeGE/W/U40xesO+3jbTVHqaiy/eyBbfxUSGhlFk8cyhk819MYqR1LWVGRRv9U/U96rqeStfP/wLzVhWf9oSwpLj1RuZzj6NGjz8XGxm0Jin6eDqh5JEny+IMFLc3PULJIf1WBn4IoPT39JzHhXjgfm2zi8fHXBv5sYz/Kfbt/gP6pdO7ek8e7+/eksmvvfrZ+X81D2Z1wuQYSk9CO9zeup6Dcgckk+czSQNoHPr9awNfmduMrJcUT7HPzpYQAEB1tXHb8eLXdZDJN4TzWlpbuXMfiNZ9SWOHE/syj7DbL5I64m2E53jLpfVtXs2T5+1jlNoy5dyqDsrw5Ooq9gkXPzGdH0WFikzsy7t5pZKcY2Z2/jFVbvqDEVsOiOX/FopUZOu4P5HU+dQLt7vylzF+1mYSMq5g+bTwmNbitZSxe9DK7i75H0ccxesIUBmengLOcp+Y+z84duzhgrWTmzO/QJfdi5r0jAi9D/srFrNr4BRjaMmrCJAb19PXdWc2SuY+w7eAxhk34I6P6+kpf3FZWLJzPpp3fktD5cqZOmxQo6N63bTWLlr6PDS0ZA25i2q2DOR+puPu2wvJN3hncO+TZwKotUGKDRXPAooWh4yDP1/Xt62DZGnAbYOI0yPFXuTvgmQUwZDAsXgB2A0yfBem+4Xh18QsMH/tC072c4rnaqw6wYP4i9pTUkjnot0wdNyRQcrVj3WJeXf1fnFojecNv466hvVGq9jHn/7d37uFRlHf7/8zsIZvNZrMsIQkhiTFgiCHEiBgRIyIiIlJERKSIiJQiWqrWorVKKS8vPzzUIqUUrVI8IZ4QEREpIqUUERARMUaMMcQQYgghhGWz2ezOzvP7Y/YwuzmAeKK+Ptc1155nZmeeuef+nu7vwhfYtbWCurK/M6vmn6QVXsaMcYNPwNJcLF/4CBtLv2LI2IujkayhgoULF1NWfawhPjn9qScefWA30bWfLTHmZ7ugpmtwHAVqkUBBAomJ0aCmVRX0+vZkiL5zYIsZn9Y3kJt+VtsP/MepOKIyKTUJgLy8PBRFoVtKN+JbWkhORudrCy1h8AqDG0Ag0Cm4iS5dnKsOHapr7tat223flSqIPSOP4cNtbH/xEYpKLmNItpm0DM1PV75hESPufI0Fi/6XZF8lM8ZcxdJt71OcYmbpfTeyzncF82aOo75yDw0Nbsiyk96rH8MtFtYseZHiIVeQb4Os5JNIoFWqWPZyOQ/e/ktWzL+DyXMsrJ43Hl99JY2WbCbfNgpf/W5uG30ZS3d+ysAUO4OGXoHs2k1lbR+GD78C2RapXXxx9g3M22ZnwZxbsXpqKN1XHga2LS8/x8glDzEhexsTxt5McfW7ZJkVHpxyBZvNVzD7zjsoXfkoIyY3suvl2VC3lRHj/4cFz/6dbLuPbXs0wcvOgG3bqsfZsPdQzM2zK7fdN4OUTmZnSjYMHwpTR8PYeyEt+N30XjDcAmuWQPEQgsc1aF4vg6lPwMJHgFoYPww27YEsSxDY5sG67TB1MtAIjS7AAdDA+vWV3DevUHfldHJcPdWMHXwF+VMf4vZRaSyb+xtmeiwsmj6Yxt0rGD3zFZYvewiH2sDuas2Mla0pDB1+Bd7yDchZFzB8eBHW5BM3CV457xcs3JvBovt+ybpF91Kho2tzpv6M+nNnfXH99bbnR468JlT7GZunFlpaOwK1UFVBZ+anBmpdSUtLJTMzk169epKXl/eDMflvBGzV+z/hsU8CPDnj7Fh7lWfWbCTu7AFc2SMu/G6fPn1IT08nobmZ1FQ6CiIEvy0EhKOlHYIbaICYmpq2fv/+/a6srMxbZFk+/9s+UI60XpSk9SLNZiS//yBK8iKHbunCvzBx1quMKMkD+jN16FOsWLuL4ikDaWxowJqVQk5uAUWFRboLM5+UbDt2s4V+JSX0P9kKGtnKzLlzKM42Ujj3t6SMeg7XvPHYew1i5qQ8du7ZjVtNIT/dzc7dtQwckUX/khKa9qSTbM6lpKREB5LVLFy8lQV7vmRYlhkoRvcpBSNvZNqoIUAxA2f9mb21kGXZysJ1Cpsr7yXbDP3u+wNP9PoZpZ7Z5LsbaFKspGRk0S83nX79T/x3LA4naWltbiMYT0DzkrOgJAtsxraAl5INdjP0KyHquC56BO56AgYH92v007B6K9w+NPgFD9y7CIakx2ysqZJKVwbZ+iJb2dbhcS1b+yxlGdewcvooZGDuvbeSf8+LLJo+GG9DI6rFRlpGNgVZ/QgfImsyJSUl7FvtpKlXUfR56thhwPIVG5m56iADC6wUz72HJav/EPGnHWr8oLXV/crIkTfup23tp65EilaJjkHNYDAIk8mI2WzSgVpsUXuoXCozXC71Q45TBrYjX1VxyysfMfem0eQm6GehYMOmjbx6PJnlNxZG3a0lSSI7O5vE4y4yM9CZomqUORpaj8bgoDPmBhIaeRPizDPP3Pbhh7ub+vbtO9VgMAz/vg5idXUtZYt/x65nQ//WwtCh2vPpc//OfbP+l36592PJKGLRsqcYkvcNokNyCulBemJJy8DaVE8j0LT1aYZOfpThY64mxW6mwa3g9Z0gyuCupUZNIyer/RKeZIczPE3MZgVFAW9dDY3eGu4cd03ke0XnoHrB2Gskz87azaxJV1Be42X41Pt5fM7kTnXXbI4U0tJiviHbv5M8pOpaWDoLVumIcT/9hhyQm96uYxlF/jrb+RJX6XbGjP40/F5x3kWoQPrQyTw4poKpIy+k2iUz+d5HmT/9VKdqE3X1FjKSNb+fMS0NZ3A//X7/xosn3r7mxhm3HtKZn3pQCxe1S7RR6ogBNRMmU3sNWEKy3m1B7fvIVfvWge34kYP8YvlWZoy/mkvSop2p7773H/7yuczTN1+MvZ3COYPRgCOrJz3PFKhqIIathYAs5G8Lm6QdgVsIDUXIND333H6frFr16p+uuuqqw2az+cZvPdoiy6gxYvlZWRkUTf8b945qawU7copZsuINQGH5rJ8za8Fytj1xZyR2I6tttPc7D97UU1OrUJRjxFtXg8eZQTLwxLLHGDPrKR6c3A/wUbnmz7E73ma/saWTIddRWe2jV9bJ1Sea0zJw2nJ5eu1bYfNPP51GzZjLqBlzcdXtZnDh5WyeOplhnZQEVu7ZwtptB2JWk0rxiCHYv4lzTm7b0yArHcYshvEFXzOU5sgmx1JHTQP0SuGExzUr/QxSBqSyfuW8drZhY8rshUyZvZD60lUUDfw9U6YOp5dRP79ONjjlID3FS02DB9KsKHV1NKrQ4vG89NjSf7x9xx1/cHUCal6dWaqPfrYBtUhhe7xOqcOu61WQGixsz6FPnz6YTKYfPKj09YHNf5wZ/3gTS0ZvGg/u57mDYIh3MKEoi/3le7j1rc+54dL+rP9Ai+ycdcaZDEhPRPU0seKjaj6pbuKIT2VvNyf2tDPIUKN9bDpQCz0XIavT79dy2bREXwIRbAszQiGEEGPGXHswLy9vwfvv76y32Wx38C0mIufn92L5ogVYRhbQq3Ag+VlOpt75K4bf9UtyzP9DrlNm56b15Iy6h6H5dlY+/iBkDyQ3zcyufVX06n+T3nAiP0fh8QVPUN8/g/wBQ8g5kZ9N9bJgzixSbh/Fivl/ZtjE32EDsrKzeXHt8+wqkilb9wTryhX0Kle5uX3YveQlXhyQjCMth+EDC8CYxZ0zSrhryq0smPMrrN4a9jXamDqu414EcloJdw71MXn6HGZNHwWNNazdXsXc2bfjK9/MovXVDCkpwlO9lQZzDtnOzv/O8CmzGX4KupG7t0KjF1w+2L4JGqwwcHBEFTg/Bx5fAPX9IX8A5CTD7TNh6jSwzdeCClvWw+Dbod8JCXQaw4amsG17OYNHRWuHtXdc80dOImfupdy1II8JQ/KpL99DqTuNe6aMoGrralaV+xjcL5fa3buQs7JJ1s3OvF5n8+CKf7Aqw01yRh6D+nXmMrYxceJw5s++n6z7fs6aRY8oxxXlyUtze//nUNseBXpA80qS1CqEaCf5Vh8oMIaYmoiPD5mfNh1T00At1KugT58+WCynh3zi10/QVf0c9RlITTDh9St4/QqtspniDCfHm1uw2myYRCD8WVIXJzlJFkSrmy37D2NL6sLZTit+IZGXm4vTKFAUBVWNlFupqgibojqyRoi9CdHh3glJkgQgGhoa1AceeKDsttturbJarT0lSXLCN0/QLR5yFUrdPj6tqCK+Rx9y05Po2nMAVxY5WfPqq2x+vwxrZl+GXnweiXEynoZKNqz/Jxs37ySrZDJzfj2aODlCES4ZcSUN5Xv4fH81qb36k9n1BBNDTmXUsDN4/pmVOM/9OQ/dM544GfIvuBRRtYNX3/gXCf3GMX10ET37FJOVrGV6J+Wcx4Asid0ffUqdx8zF52mO3YJLR5NrqeO1V1/n42oXFw+9guxU7dg4M3pTkJMa3tc+xReTHC9TMmoclroPWbVqHZ8eOEa/S4ZyTq8eGCSFD7f9iw3r/0nZVxJ/WPAo5/VI/E4m7tsvw0cV0PdCcB+E6ho4d1AE2C4ZAQ3l8Pl+SO0FmV0h61wY0B1WvQo7PoK0PjD4fLAYIrf5AQMhrp3tZXfxM+fpXUwbe0nU++0eV1MS1467is/fXc/atzZR3xrHkKHDOCPVjoyX7Zvf5q317/BlSzce/ssDnJkUOeeZ55ZwVtwxPiwrx210cn5+dqfH4eyLhmE/9AEvrXu3Mmfw1Y+tX/nY+83Hj3ek0KFP5/AFAS0q+TY2+hlqvhIfr5mfiYn2oASRJhSpBQp6UVBQgM1m43QZ35oe26mOY8eOUVpaSkXFFxw4cIC6ujqOHGmI0XFrCRbWt+Lz+SR/UMtNVVVJVdWQnpsBMKDpuZmEEHFoc9RSVvZJUW5u7hSDwXDpD6HH9tP4MQwPd46+klEL32JItvW02jNFUf69ffv2NR00M+6gT4HwC0FAluWAPvm2/Ty1WF21UEqHFv0sKCggKSnptDomxh96B5KSkujTp4/O9NSbllFETU/fJNB6J2imadjJIUJ+t6BZqgJqfn6f3c8//3ztmDHXVAE3n86XT/muTeytamznEzvDxg7jp0KwH2pYWbj639/7Vn0NFazZvKfdz3KLh5LjND7/+OOPb7r77nuOE53OEWt+6tvk+SVJDkgSqr5Mqr2KglCeWqz5qReLPN1A7bQANgCHw0GfPvk6UJN0j1IY4CRJCi1CkiRJ87kpQUBTUVUh9PltIZ8bIG644YZa4K+ffbavympNmA50Px0vn4y8IuwZ7UQzZSO2n9Dl/9ww2jMYVGKjHbvqK7fHtTwxMTsk461P59CboO31/gwAAa2yR1bbL2jXfGoh8zMU/dSYWgjU8r/VzlI/OmAD6NKlSzD3JQJmGoiFmJsUfh3L3ABJVSUVVCkEanrmBqhB9iZ6985bvWnTpqru3dNuMhgMQ063E2K1ObH+hGA/jdD9zGwhJSbRT1GUzTt27HijpOTiGjrvzq6vJGiv8UqoqXGbioJI8m1HgYJ8unTpctoet+9M3eNURnx8PHa7PazfFgokhLI6OggadJYwE7ZtQwAHiGeeeeaw1Wrd0a9fP8+pKIT8NH4aP9Q4duzY0vvuu//1W2655YjO9DxRzWdUMbtOeigmncOi69IeKz2k96n1Oa1BDU6D4EEHJ49PPinjiy++oKbmAHV1hzhy5AhNTU24XC6am5vxeDztBBT8KEogFFCIDSoY0YIKZoJBBSDuwIHqi3v06DFZkqRzf7psfhqn61BVdc9nn322Kj+/T3mQpcX60/QmaJTpiSbjHWJqItLQ2ETHPjW9+RnN1E5Hn9q3xtiaXC4Ouf3YLGZkPWcKKNQ2HsMjDNjM0Rm6rS0tHGxqJi4uDpPcMdGyWCw4HI5wT9Lo6gTCvriY5GapI/IWSgHRm6ah148++ujBgoKCnTk5OX6j0fi9g5urupR3Pq7nrKyUk/+Rt55Va3bQ8+wzv3HzkNNpVO3dyvp3tlDXYiGnR9fvfwdO8bhuXfsicloB9rjvZrfcbvfzTz659OWRI0cepP16T30qh1fquOenru7THGZqQvFhtjmw2xJITIw0XwlJD4VUOgoKCk6YJrV3yzoCXXuSaJZAbeTFJ59h6/u7qPfZOCvz+9Nj+/o+NtXNr/+ykt1+M6lxAWr98Tw66SouTImn5vOPue7FHTgddjyu43Tv1Ze/X1dMogxPrVrFkrLjZDriOHDUyy1jRjC1T8cXc2JiIn379kWWZWTZEHyMLJKkf4wEFCRJwu/3i2CFghBCoKpqVCAhqPGmCk06JHDddeNqgL/V1BzYm56efpMkSd9qZ5T1S2dRkT6eGSPaprzX793Iwg1GRpQUnPwKPVXMf3Apg8cMwflfBFx71ixkVWMBcycPbfNZ3bYnGDTlOaZP/hlyiuc724fa7S8zd7PC4/dO+JaOq8qKBX9kVMF4Mr7lkLWqqh99/vnnq/Lyzv5Mx9JiO7N3xNIUSZICQqiqEAjZaFINBgOREqlInlrdoa8wdc0iMTExqqA9UialVRQkJCR0fl+o3szkWS+wZcuIkIcQm83G3g1PsbbCwoiBeacxsMkmbhk7moJMLRqyat0bzN34MW9NKMbqTOfV395EutWE6nMzacFzvFSex9Q8OxdecBE3jE7FLEPNvg8YtnIr1/QZQ2f35YSEBAoLC9FOiIzB0B7ISUFgkwmKU6JFTP3BoEK4ITNhpNMYmypJUiiooAKBjIzMzU89teyTcePGjbVardPavXs21VPvUsnKSos6eCrgdTXQ4JbJSo9cFqqiUF32AaW+ISiKgiwbkeXwxCV7+AzWjzS2uVjcjfX4zE7ssoc6t0xGij38mWLvx87ty9tUAClKdCmObDRGvqP6qKmuwZKcTrLNErs5kFXqqqswOtJJtn/72eOqqlBX9Qm7a+ztHAeFndveo9/YW7hn5nhk48lNS8Xrorq2kbSMmD6lKqiKm+raJtKzM8K1qqqq4q6tYMtub3AftDl0wuPqddHghjSnmZraJtIz0sLfURSVRRs/bVO0rypKVCRT/38Bmuqqccv2Nn1eQ2ooB/eXP/23f6zY8sD/m+smEiDQl0fpzdD2TE9VkiRVVTXrRKgiupmx2Ywsy8RZrJhkiE+w4XA4tMVuw2KOIy09g9zcs4IVBWZtDtU2kp6RRkNNNba0LKy6U/XswgcYMvl/ItF72cHICROxNL7L3qoO7tFN9dS5FLKy0qOuJ8Xrpqa2HkdKOo7Y+Ro8So211fgszqgerKrPQ3Vtw6lEReMoyIxw7ixnEt5DfgCcXSMwJZsTyLAbafFpF1tej4iCZorTjqz4aT2Rpk3QLI2AmyEG5CKsLcLgpBDASZIkidDFHgQ4gS5i2g57U26+eUrg5punPFle/tkHOTk5EwwGwyWhg/n0fT9nzupK8tNkKtzprF73EvnJZlY/ciOzVh7AbjQge6oxF93CumUzMVdvYfiU/6Vm326abHdTscpJ9uAbWTprEuBl9qRRbNz7Ge7CWyldHmxV7t5DbtbPKCjJY/veRgb0S2Pf7r3MW/0xY4ocrHx4Bo+v2cG2KifVNW8TJvc1Wxg+/v6g4qaP0p27WbT9KJP62agv28CY8b/CnJFPU0UZQ2Y+xiPTNNaklL6IY/xzTMk9xtYagadRYcWuHfT7NqP43nImjfoVZdWlVLm3MXz3C1hyL2ftknvAVcr4sb+hvLyUGnUXw7c/Q9HoO3hkxsgTsr8xM/5GfmEOe0treeTFNxk3IIum7UvJmfAYRSlWLFaFfe50Nmx8hV72Ju4Zfz1b91VQVacyfPh74DyHl19+BCd0eFwnD+hOVfIAqnfvJG/AhbgqP6Jo2t9ZfNsQyjcs5baHn2fv9u0s2dPC2HD1k4u7xv2MXfUatFXv283QWa+w7M4RqK5Kpo29jt0eJw5fPRT8nLXL7g1WTNRxcWr//5wxrOjNF5avq+qApenNUF8Q0Hx6lha6aUtauE3EmQyiVVEJ9f00G+Gr2oOoBhPyV4eQVLAmJtG1q5NDn/yH1ys9ZGek8Pwzy7nl0Zc57zwLy++9hvmbmrG7P8WYcR425Svqk69k98tzgpdHPS++XMbse082FufliacxvDgAACAASURBVHtv4pF1VeSmmKl0JbNq/SvkOY1sffo+Jj/8NgW56VSXlTLwtr+w+M7gfGjaRXberYwdncqGXUdQXI3MW/MR+aWPMPzhLRQ5BE1Nteg6Rp3C4jvOrQv/wZJPDrf5rHZ/KRfOf4UD3tjfBXh65Uomv/nx19qWqgb4+OO9vPbaayxa9Bfuu+/3/PKXv+S668YybNgwLrpoIEVFReTl9SY7O5vu3buTnJwsJSUlSQkJVikuLk42mUwGg8FglGXZJMtynCRJVkmSEiVJ6iJJUgqQAeQAZwNFvXr1GtDYeOT/CaHWNH+6SnTtfqHY36wIIVTxt19dKn52/7NCCFW89qcbRLcLJovjAVUIf4O4+uyu4qkdDUIIVQihiid/e4W45bEt4df65dNXZos+N8yPvHd8tzirx6XisFDEzecliX+83yhee+AG8avHNkW+c3iL6NHjMnG4nfUJoYp3Hvu1OPfqe7T9EW5x8/k9xENvlgohVBE4VirOyzxbfHBM+67/4xXCYOginnq3Wvu93yNa/O2vVwhVvP/8bJGamhqzdBdP/ru2w9+Elrf/+gtx1e+WtfvZG3+6SVz7xxUnXIcQqhCBOnFpjy7i+Q/qhRCq+OSV2aLbhVNFq1DF0feeEIb4s8SOw14hhCr+/MuLxE0PrQ3/9vPX5os+189uf73tHNebLkgVr3zqE8/87ipx459WiyPvLhV9rpur+51PXN8nQbzyefv7+tWHK0Xv3iXi4+D+PHX3VeLK3y4TAaEKITzijsvOEn95p1qoaqCmru6jBTL8HBgLjAauAi4HBgEXAEXBuZkDZEiSlBKcu4mSJFllWY6TZdlkMBiMJpPJYJQlGckgJdkTJAkkZ2p3srOzSXPEYbKnctFFA7l88PmYJCi5ehL33fd7HnroIV577TU+/ngvrrKVdOt9Lc1C5bnfXc2vH9vMl288TOZVdyIC5Zx75iUcCl6fgf3r6NL9Mg63c+2+/ddbuOq3y6Le++LNh8m88AaO+rXXr/+/6/nZ/SsQQuX4sSYCofUe3U7PrufyRfB74uhOzjCZ+MMLu4Lr8tLSqvDpK3OJP/MKDrWqCOH6Bnlsqp+/vfoWSq8LuCU/2qBsbvyKW1/+gPtvuIaMGIfqezv/w/MNdl6Y8vX0miRJoqCgAKPRiNFowGAwhhmcLOsfo3xxYb+bJCkh9iZUVQ0rhujYW6i/QiDE3ioqKhSns+uqt95a937XQ9tHOwdcelN2UCl26JDLmP/EbmAiAMWDBmGTAdnJ4IE57NpdyuTiQad0aGWbHRsydocdu82OzWbD7Tk5me7qrc8yfUk567a8oe2Pq4zNezzIm57j3i0a8/Qp1ZRWuOnXT6Pw5pxBjB8YlOAwWujMEO0/YQ51E+b8sM662r3s9eQzOFi9nj9kKMbJv6ZahWTAnj+Q/smaATpk0MUsW7sLGHGKG7NisxnBbsNhc2Kze/Ce5LnwNZQybvz9zH/xXxQE92fTxi34crO5797PACh3qxx5f/uKFV+1bpk48cajJ2BpoRpPnyRJoTSOgC7qKfT5aT7FL4xx8Zjj4jEbPKLVD9au8bgP+enaozt2exJ2eyKZ9t0kdU2hR48MEkQjLy5dTHWDB1Vx09RoJ9SBwW6zY3XYcdo8INuw4ibkDfU2NeCxOzhZor9187+xIvPgrN9rHLeynlLvHmA8alMF9971J3aWVeFVfdS7G2hwQ05o5ZZ8Jo3tF3xhxhL0NWT3v4AUM4DtVIEtwItvvMV/5DN56sr8KGuy1d3Arc9u5Nqrr+KqrOhM04/3vs8ftrv4x9QRdD1FZZO8vDxCzk+j0YjBEAK6iJmq+eHCvjgRfJSCEVGdbzYK4FQdwIXALQAoV145Yj+wJPOyX76rKMq1RqPxipNxKn/zIUds9ZNYnad2N+On/JnFq/9FL4cxvB+qOZlhY64mK7iq0aOvJSc3Uu8oW22crFdt7+oFTJrzXJv37338n4wfkMKPb8jhh8jZOAlZIaWJ28ffQMnspxhTlBa1vgFDr2ZkgQ1FUd4+66xeG6ZOHXdgeQTQOgI1vY9N0ZmeYX9xqE+ILBuE0SDwekH1ukVDazMIgb/FS0KCjTizjMlqo0uXLjidDqxGia6pPeh5Zlfm/fIPXL9sM9OHFWCs30xawR9i/m37c9Jit2P2uHBB28CL3N7VoZJVdDGjR4du/lcz1ZEBKNw36Wosk55nwxODMFNNcfJF0dPfasPSDnLJsvEbBA8QvPn227x0PJlnf34e8bqdVjxN3PHUegYOGcaNvaP/3uflH/GbTQdZ8ouRnGH9Zir4PXv2xGw2BwHOiMkUDXDtMLcgwElSRHo8UqEQYm26wEJAx97Ck+jAO09+YDI9WVpTc+Cdt9/ZeF2//lPCSr07t2zBrU7GpjayeVslo6ZGZKRtVhuNDfXf7fXnq2f6uBsY+eALDMvXHXt7AUPyPVS7nIwbrknuuBsaMNpO7RzkDZvK2v7j2sxcZ8qJQ/lWayINDV+3o5OPhTOnYx0yg2kjgnfp9AIKrWVs3t3AhH7JlG3aiFJ4PlkyeABX2VZ2NfgoTjazact/6N/v95F9sNtw1deg8F2W3agsvedGagp/zZIJA6I+GTJ0IK9+XrNr0uCSN3uflftp6OYZA2jtgJrklyQN+IQQAQEBOZxwixoIqALJgNloEkajEeFrBtkkzshM1wQiZS8ff/YVRlsi6ald+dztoVu3bjitXg42BRiecSb5uQkccXdl0MACjMD2deuoP8n7s5zdj0LfPsoaoSQG2dKc3ancWBUlEz9o8CXMmf8Zef3vQbsHK5psPh6qqz1MLSnGLEPVpjXsPYWmXV//3LYc4oFNX+CyxDFkvqYQau6Ww7vTL2XHhx+yse44H7y+ln+8HmQHlw/j/gGZ/P2t96htlLlh4TPBFcWzbOYE+p5i/9TMzEwduJnQkg2NYVM1msWFgU4IIaRgPamQpEAoVy4cWNCxtxDARbE3wJ+Rkfkv2Rj/3r8/eX6YEOI6IC+FSoYNugyjpwZzye+ZMCBydoeNv4VF435F0eoHyBt2Cy/On0rd9hcZO/NveBqqqGqQKSl5k4KRd/D4jE70t7z7GDfsl9R6XdTXVzOy5GLMGRez8cX51G96keW76iicezMvz9VO7bwV/2ZkvpUHn/4H48b/jDUL8rD46ql292DjrpVknMJxN1vtZFhPLa+h/8hJOB6/gYKiF3AWXcOWp2edFLBtXPkcjrRREWCT01iw+A+MHXMhKwpyKC2rZfGKNzGjAZs9zc69Iy/FalUpd2ew7pGIQm36gNEM5RoKC8/Dln4B69cvwdnJce1szJ92BevK3Oyr9LB33EUstDpYsOpNiu17eXDResiroV/R37TrYOZf+eMNF3029Bez1vyq76APez8cUHRRTL0ihy+WoUngF5oahxKch2oE1CQhywhFEUJIMmazdj0cb3YJc0JyuAuc1erEYTyAqzWO4uKLaFj3T15+zUW80YSzazwZPfPI7NmLmVNyGTXgQooyrMjpmaSd7P1PzmDc6CzWb9hDyfjobKmCUVMYuOwacvJeoXDEraxZMIOcEbcza8vN9C88n4Je6VRV7mPEPU8yf9IgbrtzAlOHX8CygjS81u70OoWcptOy8uDrjKNHj1JeXk5V1ZfU1tZSX19PY+MRmpqOBWWPQlUKLXi9rXg8Hnw+H0KoktahXiEQCEjB/guhagUpWLEgB8HfCBiDVQsmtMoFMxB3332/TzzbUnH56sA11y2/a2hOg1cmI+V0zC5TqaupBouTtOQfh0aI4nVTU9dASkYW1mC+RdP2peTN/IDaTX+ips5FekwawQ8xhBD7Dx8+vGbOnDm7Hnvs8VadKelrx/QMPfqDEU9Ft6h6X1qwioBg0m3QejGHGhljsUS6s2uqt4k4HEk4nV1JSelKvNnC2eecR2Gf3lElUk31NbixtUlFOdFwla2hZMYGdm5afNKuDa+7ibpGF2lpGVh0KTvuxnoaPDJZGcmn1OXM+N8+ubt06UJhYSFxcXHExZnDdyw9g9MzNyHUUIcrIct+SZZlFEURgUAUewsV18sx5mkAUILmqR/wz5//gA94rfcg8Y73zuFDe3RLuhboefodKZm0jOwflffLaLGRnd2+YoBstpGVZfuhAa3y8OHDbzz88MMf/PnPC7w6gPJ3AGixgQFFHxwIApsIlUUF5bvRQE3LTwtWE0SBms2mqd4mJYX6E2gd2rOzs+nduzfx8dFmkyMlg1PJ9rHnj2LhjEZqXSo5J6nrbrE5yLa13ZrNmYLtG/CD/3rGpptEfPbZZ1RW7ufgwRoOHTpEQ0OkvtTtduPxeHC5jtHS4kUIgc/nw+fz4ff7JUVpl71JQgg5CHChmlNDkL2ZguzNrF/uvntm4u9+97tLnU7n1ZIk9eGn8f2yuKYatuxzMWRA/g/HjVW1rL6+fv3s2X/88Mknn2ztBNBiF38Q1NoDND2ohVlaENREMEcNveRQBNT01QSp9OiRQU7OmfTu3fsHb7ryXY0fDbCFRlVVFZWVldTU1FBXV0dDg6bG63Id4/hxN0ePHsXj8SCECBbQt+Lz+fH7/SFl3iBzC0iqKqRg5DRkooZCQgadedouwOXk5Ji3bv3PxampqVfJsnzhT5Dz4x+BQGD7gQM171x8cUlpTc1BJSYw0Bmo6QEt7EcLVQ8AQh/xbMvSTJjNcegVb61Wfd1npJFxRkYGOTk5ZGdn/6jPhfHH9oeys7OJj4/HYoknLi4OszkuHGQwGk0EAgFkWUYIoTNTWzEYDKE7YYi9iUAggCRJoby3kEkqxwYXYsxTH2CurKw0p6f3eAfYUl7+WVF2dvZQk8k06qfL/8c3Wltb1+7bt+/doqJz9+vATM/SfO2Amr8DQAvoUjjCZmcsSzMajUGWpoGaxWLRyXgnYLMlkpSUhNOplx3KomfPHFJTU3/058T4Y/xTqampWK3WIMBZsFgiABcIKBgMBlRVDUdQvV5jCNzw+XxCluX2fG8iaJrGRk8DBJtioIXiTXqAA8y5ub13AnveeWfjS8XFFwyy2RKuglMKSv40Th/XR83x48f/+a9/bd49evTohg4ArT1Q83fG0DoyO0MsrX3TU+9P04IESUkOnE4nKSnd6N69O1lZZ9CrV08SExP/T5yfUzZFm1wujvllenSxRRcABxRqjx7HEJ9AakJ0r8qWFg/1bh/JjiQSTNL3MfkoLy/nyy+1iOmhQ/UcOFDN0aNNqGoAt1uLmLa0RJrFtLa24vf78Pm0hjE63xuh5jFqQKAKIQfbmYZM1I58cHpT1QSYJ0yYYPnTnx6+ICUlZYjRaOxQxXfP5tVY8oaRl3byzUNqy6BCgUGFP66JWrFrM2pGMbnhY6GiKFFl5hiDE/FEJciqquqK36M+ob6mGp/Z0SYi2NRQQ6Mb0tLT/nXoYM27v/nNbz59/fXX/ScJaP52AC3QAUNTQ/XOwQAB0Swt0ry4rT8toqPmdGpBgvT0dM444wxyc3O/U39a9d6tuJ2F5GecHhH37022aPnqVTy2r5nURDO1jc1MvvpKphd+t20HJEmid+/eJCQkBPN54vH7/RgMRlQ1EJXkG5k8BlpbjRgMPvx+v9C+L0uKEkBRFKH4AvhVFUkSKtpNNawWEsx3MwQna4jBGYOA5gsB24oVK1pXrFjxL2Drxo1vP3X++edfkJiYOFSSpChdl/VPP0TylAFfC9j2bYMVjT8uYFNd5UyZ+v9Ysf3t8Hsr593AxAfXk+ywhafyI2s+Yny/Ropt5zJv31GGt8eJPWUUpBVgH/cw25fOjABXxVbGjbuJWmMGdqUeufBmtj59D3jruWPC1Z+t/sS3OcnQ/NHHn5Yf0YFSe4Dm7wDQlBMAmmg/OGDAaDTppYaIizMTF2dpx5+mKd527ZpMamoqGRk92P36YtzXLaL3dxwksCk1jJm+lm1rH8R8GsyZU2BsrZQeaImSLXqyKZW3JhTTeOQI3nh7lGzR4NE3MDXPTkurj/g47S8f2b+Xi5//gv/MuobvS06wqamJysr9lJaWUltbSyAQ4OjRRo4d04IKsfluQWXeUNQURVHw+/1S8/EAfjVAnDkSPdUFGCQhkKFNkMEQZHDGGBYXtXz88d68nj17XhgfHz9EVZR0VcdCTgoAVG2RjTGMJUhh3I3Q5IOMtK8JLF6oqoWMbAilGnmaoK4R0rKIkq4J1b5UV0FyBlh1s1zxQnUdZGW3vaOqwc9S0qN/A7Bx0TSWNA5h1ZzxOmD7OQtrLmHr49Nj1lRF/06ArXLtg4xdsgt32WE2V/ybdCOAm0n9e2Kf9hKLpw0GoLS0rPbMM8/Y/NJD0z78xf++UB3yqZ4EoOkXJcjQAu2ZnASFT4M1zTFmpwGDwRRsWmyiI9MzISGBRJsVCYkuKen0zM4IBgkyyc7K4pFpA3FMfpO7RmRHy1gB7oZaGrxmsjOS28yVxrpqFGsyKfbom6qnqZ66Ji9p6RnRUlH4mD6oD4MXvs/4fj98g5fvTbYoBGqhY2c0yHyfgWaHw8E55xTS2urFZDKhKH7i4y3ExVmCQQbNEdvcbMJobMFkMuL1aizO5/Phb/VzpMEgVFWRBAqtrYqQ5ABmk4qEJHx+DdxCQQZZDgcZAkJgAClYxSNCzK0NyPXtW7gH+AR4+oILLuh74LMPz7/7hYrBdw7PSD+Z/zhtOOyqgOwJsHpe5P17x8AeGVQ3VJfC0Fmw+LYTr+/pmbCqCep3AlYwFsDWpfDwdFi+B3JSoLQM5jwNE0vAvQcyxsHIXGhwwZ462LILcu1QtxsGj4aMQu2f79sMW5sgG9j+Mky+F3oVQPk+mL8CxvYPwyErVrzO6EUPfyvzYM3qNxg64VG8S69l7fYGppUk4923ntUVWeyZfEmtx+PZUlHxxUfnnHPOfj276gDQ2gO20HuhoFIgDGiyrEpCqGqoIzgIJEkYTSYMsiS8LS3I5gS6WOPA3ywajrrIzM7GatFAzWKJIy4u1JHdSkKCjXjJzesvv4E17Qzi1GZSisfx5JzB2Bp2M278PZTvqcFYeRMbFlkZMP5u5k0dBkojsydfy8v7VLKsHhptxaxd9TfSLDBzRCbbPH0xmg3UV+5l9OzneHCyVs/54twbmPVyJYW9kqnYV88TW3cwIIyJZkaNuoglL69lfL+JUcfcVbaeCfc8y7zlKyhynLbAphv+Zpbt+IJxl7cN9n1V9Slbjjl5WVczuv2D91n0/n4qj7Qyb8LPvnf1V4PBQM+ePYmLs+DztWK1JgS7XMcCnJmWFi2K2traqoGb0ccZ2UaO1vmFK+CnS6IWPQ0EAqLFFwBJxWxShaqqkqIgCRCSFI6iBgCDJKGAZAhOfGPQTDW2A3TGHTt27AL2/ObKrKcu2/tR75ycnCKr1XphZ7lxSzfA2oWwtJ1yTFsBrJwLTdshexosvO3kTv72PbB3O6RZwRvsCjj9Ybgn6EqpWg+D58LEDcE7eh3csxMKHXDPcFi5Ee4bAw/fC2MfhHkToGoD9NoYvMk1wMTb4dndMDAd6rZC8V0wektw/3wV7Cy1c3tB2yuidM1fGFrxqjaR0y5g9fJ5nWe8q3WsXlfF7Hn98dReyuNr1zF14MSy8g/37fB0cZT1jDPomZmqY1mdAZqiY2eKHswkCTXYlFhoiguSkGRJGMORTolWb6tQhYF4s4n4OBONTcdFgHiOHWshLasnSbb4sD8t0j3Kis2mqd0e+bSUhL4jefiucfTokU56ejpZWVmQm8vGjeOZNfZsHJOfZ+bI7PBh2Pz4bNZ4L2LvrnmYUVk47RIeXr6NBVMHaiRgwDjWPTwZT/VGevW/m2njd5BjqWPJ4s0s23uQQWmA4sMXY0wUFhax68GdhBRvwrcmVx27dn2E2/ffEBU9Bdmivnln8z/pZ7B19wcsemcPl00dTMIPQFNTUlJwOruQmJiIzZYQFUHVJtFx3G4zZrOHlhaN4YVM02azD8lvxGLxi2BgQfK4FQymgDAatR4NAUUVICRZDkdRJQ3khBy8UOTghWAImqnhsq12gM5YWHjOR0Em99Jbb63rft555+U7HI4ik8l0IXBSnTUGBvX/HFlgaQQ3nFR2+bAxGqgBYXmYur0wYyGU12gmZL1ugttyNVADyMqCUO/nXbth9tPa8+yBkBGceVXboNYIqxfBGkD1gasUaoEsAFcDjUYHjnbcjDmDrmPxnKDEt9F2Qt9O4/a1lKZdduz8roEd9UXFe9+Z9NcvDA9NPhLykXbCztoDNb3CRrTvDFSBpGqPQoR7bsiyMMgI7YaoCJC03pEGIxaLRRiNRtKNcPBwA/bUbLp3tesCBBqo2WzRqRzZCefz+qKVPLsygWHDRpBbdGKhxy1b/oXZ05/Z9/4+6DbwUGfZC2jANmSQZo5bswZSbC9ld5VCTl4yQwYlc9u4axg38jIGDx/FoMKsqPXanQ5c9UfabM85YDJ1dZNPd1MUTlW2KCHBxlkJNs66soQ35q5g25FLuLzrD5P5bLVa6dOnD3a7ncTERBISbFitVqzWeJqaNAbndsdhNjdjNpvwek14va0cNxsx4Cc+Pux7E7LkB2NAMps1Budr1RicLGspIoGAQJKFhAgH7KTgXV3WmJzk1/niDDEgpwc6Y1BC6QCw8ZxzCk3Llj2Vk5NzZm+bzVZoNBr7Q/t9lcOKLl+z8M4SG+Ryw9ixMG8djOwHnt2QNqWd7cRsSzaCT4n4IvSeXXsGjBkdeT1mPIQFkOwO7IoLlxdi6ZjVkU5e3gl19N2KonzgcrlKFz7+VOWRD7fX2M3L1RhmFojxg3UEaHow0/9G1fvPgo0iVUlCIBCyLKMGAkKWDahKqxDIJNoTMZuMHGtsEAaTBl4mkwmP5wiyLOHzK9gSbcTHtMQL9fl0Op1065ZCevqFbLvmJj779FNWPfsgf33tA8rWzO88KgwUDric0cOCggujr8aekn1CqJjz8vuM3r6FLZs2MHHI+Ty47mMmFEekqtxNLmzO06OD1fckW6Ty1bEWuidp/Kyxvo4Dipkulh++nCMzMxOHwxEEOFsY4OLjj2KxaOCmBRZaMJlaOBZnwoCPhARjqGKBhDgjLsUvLHYDii8guYWCyRwQJlklEAjg96tIkiDYTybU6FlvpsrBC8QgSVI46KADufbAzvjRR3uN5513XimwD1h7xhlnGG4b9XxWq+GsHJ8vqbfJZCqQJKnXt3rAGqHaCCVF2k6vW31S6mQMGgjr18CIGbB3PdQoEfZmqwY5G4qDQY2GBh2GmXMpzm2ktNxDYeGJo8NCiApViE+OHq6r2Fyx78sbb5x0qKamRo1hZe2xs45YWvizoNKLErMOVQihT9UQWgtcScgyBFSEwWBA8fuFwWRCVVoxmOKxxscJgxRAUSE+Tmt7J7xNfHVM0K+4mOq9H1Djyub8NIcu4VYf9dTqPbt26UJqjx6cfe6FDO/nIG3kc3g1l6jGoC0W6hsa0LyZ2hg86FLu2VpJv9kTNZaremhoitxqNm3ZxMyRU/BUb2Onq4AF2UbAh8utUjRwKEUDh9JU+k/KymtBB2xlZaUU9W/LGN3lm5gxfxX3LFpMvv10BbZTki1K5S/PvcS7LRa6xct8eaSZcSMvo3/CaQHuJCYmUlBQQFJSkg7gErBaG2lqisdicREX10xcnJnGODMm4cVmM9HaqkVN0zJ9uCtM1B/2I1RFyGYFe4IiBZN7hdcbQDaqQhaqFEr01QUaQiAXZnHBvDg/0blxhhiAa/P8yy+/NPzuryWfARVxC3kHMDzyyJ9sh5ouT0909chqbbWdaRKmXiD3RlMo+fojC24fCCUDIMcGyVknN4nuehhGj4H8pZDbH7KCdqOcDCsWwaSBWvDAVQvm/rDx8YhTeuy4K1i5fiMTCkdFh+eF+Mzr9X5x/PjxL6urqw/+858bDt1///0tgDqhX7o4AZh1BGqxz8NL8PxEJdIG2wMJiKRrIElCQsJokIRf0dKKfK1eTOY4LCZVHGlyc7jBC0LCaJAwx8VjNcPefXXk9RtIalc7GYMv4u2NO/Hk9ya7W3JQlcNJt27dwqVRmZmZbHriLi5e+B8K8rKo3LuH2+77B3r4HzvtN4yddgMbF9sZPPl/WDBjBIOnzWXEzusoKLqI/CwHFeWVzFj8JtOHamS/afvLDBr6Gk2VpUx6+BlyLAB1jC++FHdGPnYaqHTnsmZkYRR5Wbvm34ydO6/NuffWl/PMMy8x8cHvD9i+11rRZk8zR7wKXRMTSTDJPwiI1dfX4/P5ycjo0f4+NjdTXV0dTug9ciRUa+oKyyC1tGi+t9ZWbxDctHpTj9uHIhSEqqWHhIrqQ9ULwRpUgjWooUJ7QkCne5SDgCfrlpCMkiGmCfSJnhtifw/Iq1a9mpyXl9ctOblbqs2WkG4ymbobDIYMSZIy2xp9bUdDDShWSPuaESBFAWohayiUl0fsZlWBmhqwJ4MjYkx7hRAHWg/vOjhw+B+/WrH26a+UxvrDZWVlR66/fvxRIhp64fSJDsCsI4bW4fNQ8bnu9/oUjXCqRugx2B0tqNYsiZBcvW6JlEMZZAQS1gQblrhQnac5GPEMBQgSwu3wunRxhFlaKDigb4Xn87iorW/UOjpZTz6LzNNUT4NLIS09HXPw7jRzeCbZM99nYqGCYnGSHJXuodJQW4sbM1npKdGpI/vWMnD6OrZvXoL1NCArP7oi+G8KbKFRV1cXLKQ/REPDYRobG4MabxGlEI+n/YoFv98fzn3TVy4EAooUCKhhgAsE1CCwqahqGNTQMbqOQC4MUDGqI50tcsxzOeZ5aBvSo48usPXt29eelpZmT0pKslutVrvZbLYbjUa7wWCwy7JskyTJJklSgiRJ8UEgDAkAGHTetRAw+Gq34pv5LN5ze4uWba+J5vQJwr3wl6o7EAgcVxTF1dra6vJ4PMebmppcX3311fG9ez9233333R4deIkYIBOdb+/04gAAC8xJREFUgJkeyDpialFLJ0AWBWZ6IAOELEtC65ImYTDIOkCTMRiMsZUDRBJt21YQaMm2miJHYqI9zNKSk7sFu7FrOWrf5QgB24yhX287+7atpcFRTEn+6SEP/xOwdZbN4vdz4MCBsIClJoN0lGPHXO2KWEarhfiCAKe0A3ARFqd1uldD5VrEMLjOQK5dsNOVd8mdgJqhHWCLXfTb6WyhncfY59FO2rbP9Y+dLbFAFrt0xNLaPA9Jv7cHYicCs9DzmJ4aUeysLaCFQC1SuN6RGGRSkh2HowvJyV1xyG7+82ElDmcXDIbo/vT9h41nQO632119387NWHsNJMtp/q++zn8CtpMYx44d4+DBg9TV1XH4cIi9RXTemps9OvM0UrUQqTmNBrhAIBBlpqqqGgVyQqiSqoqwqUq44bOQhEAPdFI7IBQDUMKgVUO0y9I6AzepA4CT2wG1zgCuM3CLBTTaAbHOGJraAVuLeq2l2kidgljQZ6brNxv2m4XALGhqSkhSNJjpQE2EFGP0gGY0RhhaqHqgbV6aTVfnGfGl9ejRg6SkJH4a33lU9P/eSEpKIikpia5du1Jb+xX19YeCOm9HgyVZx4MF9c3hgnqvV1+SpWdvIRM1EKUeoglcBggEVFRVFUGQE6qqSqF+M1q/BqJYXPACjmV0OgCSZEmKBTwhBwGyM0DrDNy+DnP7OsD2dczOdgEuCEidAhjRzbLDoKr3mYVeBwEtiplpQCaH2j6KEFOL1HYawwrOEZYWqR6wRKVwhFhaEl26dCE5OZmUlFTS07v/n5AX+gnYfuBRWvoJublnkZqayoEDNdTVfcXhw4c5cuRIlJBlyDzVK4boa04135sGcoFAGOAIBAJ6iSRJx+BEhMmJ0KOIMVXRR1cjbFxI7YNSFNhFfacdc1c6AbB1xNpiTVLRCbh1BnBqe691oNQZs4v9TdS29K9jTE1kWdYFA/SAZiCkuhELaAZDhKHpi9bbU7bVzM6IEGTXrl2DLK07mZk/KVr9BGw/wMjMzCA1NYXa2tqwSm9b87Q5GFwIAZwvxv/Whr2FAgxBkFM7BDkdwBHN5qRYoIt63s5nbZZgHl0nzExL0voufWxB1nWyTK6jBb1pGfOa9lhZiJnp/GftgFnI7DR2wtL0fjRzUBMwXicCGW12htRt09PTMZvNP11gPwywBdixdx//rPiKY4pMwVk9ueHcMzADrc1NvLrrM/bWHcNgsTGyuJALu8ckwivNPPXvjzmz99kMzvjv9R2YzWays7NJTU1tY57qo6fR/jc9g+s4eqooCoq/lZZWCYtZigI5XbChPZAj0iYVKfZRVVUkWQ4J2MQyOzphYrrXUkjW62TBrCPGFvWeCNnZJ2ZydAJgkd8LIVRVYDDIUUxM5y9Dn6IRC2ahwIC+CbeeoXUW7Yz40Sxt/GihaGes2RnbUKW9UbYbsoqg3Zaw7iomTHmYxSuW4NRd1bXle5BT8klzfDuA6SldxeC5u9j58vxvvJ4hc3ex/RTWczL/6RT02I6zenctRYXZpJpVlr29kc+OX8aDg7L5srKKj5tlLu2bi/vIQX7995UsvmMiA7pENvPW5q0see9LrrL1+K8GttCIj4+nZ88c0tJSqauro76+Pmie6v1vIYBraSOL1FH0tLnhCIcbA+RkpejTQ4TOD6cHOYRQhRZwUAkGHsJAF7zOJSEEkiwjRcCOk2FdMcB3IjA72XKSNqapiPw4CqRC7KojtqcHxPDz4P8zGAzh92MCAEQeY8FM1jXd1gOaIdiYu6NoZ7SsUEiFQwO0iB+ta9eupKSkkJaWFpWPdqIxbQQsrID+7RTNrVsyB8uA8VGgBrDkvp/jmPxWVBH8N7qhpxVw+6RvntKhel1UVR8+pd+ezH/6+sAmO3hg8uXhl108h7l1z5cwKJvcvkU80Df0STa7P/mULfsbGdBFOxCuuv08V2vjujOteH5k1DchIYGePXvSvXv3cPT0SO1nPP/Ce/QtKcHechzXoUo2fVJLn765JLS2BAMMsQzOy4EvvqDpWDNCERw5cgRVMpGS4oRAgIDi5fDhY1itRnHM5UJFxp7kQBZ+yeVyowS0WIIpziJMRgkhBAG/D18gIABJlg1IhMBORVFULSChqqCxlpMFrTYApkXYpTClC6bkI7cvcijC3wmBrPb9YF4YYYAK7m2Q1WmAJIQqhNB+L0kyRqMhBHAEFD8CCUnWopQhUAv4W1ExorS2EhBgtdmxxpnCQNZO2gZtfWntMzSt70AQ0Izx7PnESu4ZNnZsS6RbThI3T3SQ3k3zox2tSONvz1hxyTB+OgwtBDywcBGMvxPSLOCrh0eehRl3QeUmWLkZqtzw+FxIM8OISTAwN4QSjSx+4l/ctWVp+OA2lW9jwbNvsbm0HsvyP9O03UHe4GuZOFRrZly5cy1bm5JJqd3Ci5s+IXfIz7lv8nAqd23g6ZfforqukfTc85lx+3TS7RpMrHv6YbZVHMeadX7UiazYvobtjXa8ezawteIII6f8lrEluSdx1fhYvWQea3Z+Sb+RN3Hb2BJkoL58O0ufXUV59SGcGb2Zdvud5KVZT/ifVE89yxYvZmvpAb5x+v+n9Q3kpreTS+M/TsURlT6pQVam+nho7U6mX3k+cT/Ojl+AVlyfk5PDOeecQ/65gzjH0cCLG8vIykpjx/o1mDPyyUxLpVu3FJKTu+J0OnE4uoTLuex2O6k9Mkh1JiKZE0hLSyM1pSsJVo0BxMcZcLuPc+RoM3aHE7vNgtEcR5xRFrIpTtiTkoQtwSx8Lc1gDGa0WzQ5Js02MwmTySSMRqMwGiQRBAhhMBqE1sRBUg0GgyrLcntLILiEGvdGL5r2nCJJkqZ4odVVhl/HLAFJkgKyJAVkWQ4myWrrlmUpvB2BUIWGumpwu6rBYFAltI5NJpNRSKhCCajCaDQKk8kkTCazMEiIgCp0irNxiIBCa2ursCQkCptZFm7XcREXr/m/Io794HGOj8dqtXC8sZ5Dhw5RV1dHbW0tBw8e5Ksjbux2O0lJSTgcXYJ+sq5065ZCamoq6cndeW9LBmUNZ3D99Tk07sxlW10+55xzDkpFDtfeaaVkLEwaCXeNgZ31gBWyfDDpHk0sdNYUcKWBXYb0XjB8ODjNUDxEe56lu+R85ZvYKfdnQHqEp1iSsxg2/AqyU2z06ncxw4dfQb9eEVm/yp1vct+0X7CqwsL4iddjVVwAVFWU02vAldx+1x1kud9j2JR5YcGCvH6DKckK8MiyN2KA7Q1mTLsbtWAoE4ZmMn3szVSfhERR0+5VbHD1YvqUa1k9+zoWb6gEoKayAmd+CXfedQclKYcYNuIW3Cf6T6qLGSMuZl2NnWm33/HNggfV+z/hsU8CPDnj7FiiyTNrNhJ39gCu7KGVJO7c8R5NmUUM6mbmw/8DzkuLxUJ2djZ3LX6BTy+/mMcf/4DGzJHMvu4S3C59ioinTYmW1ZqITbio9PjJyMiI9sEZtRmTcVZvEg1CZ6ZaMMf7aPY0o0jxyHKLUDEQF2dGmM3EWVQaWr2S0RxHnCFosiqCFq9fxNsSkIWgtaUZRYDRaCRiwYqQORomWkEiFkW+hNDipqo/ALKMjCoFAmAwGJGljk1QjWRJ+H0+JIMRoxx5D0AEAgQkCYslLsqkNJtNBBSFgCowGmR8AUFcnBlJkpEsFpQWF65WSVgscWFzs/W4hCkuiWSnA1lK4HhlLXJcPPFGfbWAPjAg02pLJI5oc9Sc2AWns0uUD03fSMVOEiajg9/+0Um/1G50P57KqzVGLBZYuhAmzoIRJdr/nzoUVqyF4ikwZhZsHgFjxkBTCmwMypqlZGuL3Qz9StqaorXlVVhyMqNkXSzODEpKMlifYsWRX0xJSVuzzZh3BY/Pux0ZGB58b8j4GdRW7GVveQ0ZhedS9+xbNALJQE5hMSm+MuRlbU3IgpE3Mm3UEKCYgbP+zN5aTSm505E+iPn3jscBzJpxDfe8uIrbh82k3/CJZFfvY09ZJeZe52CpfIAKNxR18p9cu1ezvDaPms0zsQP/H3ixgJmQO5wuAAAAAElFTkSuQmCC"],[1,"details-container"],[1,"details"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging/experimental/enable_dump_debug_info","target","blank","rel","noreferrer noopener"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging","target","blank","rel","noreferrer noopener"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"div",1),T(2,"Debugger V2 is inactive because no data is available."),g(),f(3,"div"),T(4,"To use the debugger,"),g(),f(5,"div")(6,"ol")(7,"li"),T(8," Add the following line to the beginning of your program: "),f(9,"div",2)(10,"span"),T(11,"tf.debugging.experimental.enable_dump_debug_info("),g(),f(12,"span",3),T(13,"logdir"),g(),T(14,", "),f(15,"span",3),T(16,'tensor_debug_mode="FULL_HEALTH"'),g(),T(17,", "),f(18,"span",3),T(19,"circular_buffer_size=-1"),g(),f(20,"span"),T(21,")"),g()()(),f(22,"li"),T(23,"Re-run the program."),g()()(),f(24,"div",4)(25,"div",5)(26,"div",6),k(27,"img",7),g(),f(28,"div",8),T(29,"Auto-alerts for problems found"),g()(),f(30,"div",5)(31,"div",6),k(32,"img",9),g(),f(33,"div",8),T(34," Integrated debugging to trace problems to their causes "),g()(),f(35,"div",5)(36,"div",6),k(37,"img",10),g(),f(38,"div",8),T(39,"Link log to code"),g()()(),f(40,"div",11)(41,"div",12),T(42," The log directory must contain TensorFlow Debugger (V2) data. tf.debugging.experimental.enable_dump_debug_info() will collect tensor data, graph structures, the associated stack traces, and source code to the specificed directory logdir as the instrumented TensorFlow program executes. "),g(),f(43,"div",12)(44,"div"),T(45," See "),f(46,"a",13),T(47," documentation "),g(),T(48," of the Python API of Debugger V2. "),g(),f(49,"div"),T(50," See "),f(51,"a",14),T(52," here "),g(),T(53," for other TensorFlow debugging APIs. "),g()()()())},styles:[".arg[_ngcontent-%COMP%] {\n  color: lightblue;\n  font-style: italic;\n  margin: 2px;\n}\n\n.code[_ngcontent-%COMP%] {\n  font-family: 'Roboto Mono', monospace;\n  margin: 10px;\n}\n\n.container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  overflow-y: auto;\n  padding: 50px;\n}\n\n.details-container[_ngcontent-%COMP%] {\n  display: inline-flex;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.details[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 10px 60px;\n  width: 50%;\n}\n\n.exhibit-container[_ngcontent-%COMP%] {\n  white-space: nowrap;\n  width: 100%;\n}\n\n.exhibit[_ngcontent-%COMP%] {\n  align-content: center;\n  display: inline-block;\n  margin: 10px 60px;\n  vertical-align: top;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .description[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-align: center;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .screenshot[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%] {\n  height: 200px;\n  width: 100%;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]}),n})(),wY=(()=>{class n{constructor(e){this.store=e}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-inactive"]],decls:1,vars:0,template:function(e,i){1&e&&k(0,"inactive-component")},dependencies:[MY],encapsulation:2}),n})(),EY={getWindow:function(){return window}};function SY(n){let t=EY.getWindow().require;return new Promise(e=>{t(n,e)})}var bN_loadMonaco=async function(){let n=EY.getWindow();if(void 0===n.monaco){if(!n.require)throw new Error("loadMonaco() failed because function require() is unavailable");n.require.config({paths:{vs:"/tf-imports/vs"}}),await SY(["vs/editor/editor.main"]),await SY(["vs/python/python.contribution"])}};function $E(n){return n?"vs-dark":"vs"}var Vh=(()=>{class n{constructor(e){this.resizeEventDebouncePeriodInMs=100,this.onResize=new F,this.ngUnsubscribe$=new Ee,this.onResize$=new Ee;let i=new ResizeObserver(()=>{this.onResize$.next()});i.observe(e.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(e.nativeElement)})}ngOnInit(){this.onResize$.pipe(os(1),Cr(this.resizeEventDebouncePeriodInMs),it(this.ngUnsubscribe$)).subscribe(()=>{this.onResize.emit()})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275dir=Me({type:n,selectors:[["","detectResize",""]],inputs:{resizeEventDebouncePeriodInMs:"resizeEventDebouncePeriodInMs"},outputs:{onResize:"onResize"}}),n})(),Fwe=["codeViewerContainer"],AY=(()=>{class n{constructor(){this.lines=null,this.focusedLineno=null,this.monaco=null,this.editor=null,this.decorations=[],this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(e){if(null===this.monaco)return;let i=e.monaco&&null===this.editor;null===this.editor&&(this.editor=this.monaco.editor.create(this.codeViewerContainer.nativeElement,{value:(this.lines??[]).join("\n"),language:"python",readOnly:!0,fontSize:10,minimap:{enabled:!0},theme:$E(this.useDarkMode)})),e.lines&&this.lines&&this.editor.setValue(this.lines.join("\n"));let r=i||e.focusedLineno?this.focusedLineno:null;if(r&&this.lines){this.editor.revealLineInCenter(r,this.monaco.editor.ScrollType.Smooth);let o=this.lines[r-1].length;this.decorations=this.editor.deltaDecorations(this.decorations,[{range:new this.monaco.Range(r,1,r,1),options:{isWholeLine:!0,linesDecorationsClassName:"highlight-gutter"}},{range:new this.monaco.Range(r,1,r,o+1),options:{inlineClassName:"highlight-line"}}])}e.useDarkMode&&this.monaco.editor.setTheme($E(this.useDarkMode))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["source-code-component"]],viewQuery:function(e,i){if(1&e&&Ue(Fwe,7,xe),2&e){let r;be(r=ve())&&(i.codeViewerContainer=r.first)}},inputs:{lines:"lines",focusedLineno:"focusedLineno",monaco:"monaco",useDarkMode:"useDarkMode"},features:[qt],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function(e,i){1&e&&(f(0,"div",0,1),A("onResize",function(){return i.onResize()}),g()),2&e&&b("resizeEventDebouncePeriodInMs",i.RESIZE_DEBOUNCE_INTERVAL_MS)},dependencies:[Vh],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n  height: 100%;\n}\n\n[_nghost-%COMP%]     .highlight-gutter {\n  background: rgba(255, 111, 0, 0.7);\n  width: 5px !important;\n}\n\n[_nghost-%COMP%]     .highlight-line {\n  background: rgba(255, 111, 0, 0.3);\n}"],changeDetection:0}),n})(),RY=(()=>{class n{ngOnInit(){this.monaco$=Jr(bN_loadMonaco()).pipe(q(()=>window.monaco))}constructor(){this.lines=null,this.focusedLineno=null,this.useDarkMode=!1,this.monaco$=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["source-code"]],inputs:{lines:"lines",focusedLineno:"focusedLineno",useDarkMode:"useDarkMode"},decls:2,vars:6,consts:[[3,"lines","focusedLineno","monaco","useDarkMode"]],template:function(e,i){1&e&&(k(0,"source-code-component",0),U(1,"async")),2&e&&b("lines",i.lines)("focusedLineno",i.focusedLineno)("monaco",G(1,4,i.monaco$))("useDarkMode",i.useDarkMode)},dependencies:[AY,ct],encapsulation:2}),n})();function Bwe(n,t){if(1&n&&(f(0,"div",6),T(1),g()),2&n){let e=w();v(1),Ve(" ",e.focusedSourceLineSpec.file_path," ")}}function Vwe(n,t){1&n&&(f(0,"div",7),T(1," No file selected. Click a line number in the Stack Trace section to show the source code. "),g())}function Hwe(n,t){if(1&n&&k(0,"source-code",8),2&n){let e=w();b("lines",e.focusedSourceFileContent.lines)("focusedLineno",e.focusedSourceLineSpec.lineno)("useDarkMode",e.useDarkMode)}}var PY=(()=>{class n{constructor(){this.focusedSourceFileContent=null,this.focusedSourceLineSpec=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["source-files-component"]],inputs:{focusedSourceFileContent:"focusedSourceFileContent",focusedSourceLineSpec:"focusedSourceLineSpec",useDarkMode:"useDarkMode"},decls:8,vars:3,consts:[[1,"source-files-container"],[1,"header-section"],[1,"title-tag"],["class","file-label",4,"ngIf","ngIfElse"],["noFileSelected",""],[3,"lines","focusedLineno","useDarkMode",4,"ngIf"],[1,"file-label"],[1,"no-file-selected"],[3,"lines","focusedLineno","useDarkMode"]],template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1)(2,"div",2),T(3,"Source Code"),g(),S(4,Bwe,2,1,"div",3),S(5,Vwe,2,0,"ng-template",null,4,jt),g(),S(7,Hwe,1,3,"source-code",5),g()),2&e){let r=st(6);v(4),b("ngIf",null!==i.focusedSourceLineSpec)("ngIfElse",r),v(3),b("ngIf",null!==i.focusedSourceFileContent&&null!==i.focusedSourceLineSpec&&null!==i.focusedSourceFileContent.lines)}},dependencies:[Ne,RY],styles:['.header-section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;height:24px;padding-bottom:6px;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .header-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .header-section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.file-label[_ngcontent-%COMP%]{display:inline-block;font-weight:normal;white-space:normal;overflow-wrap:anywhere;overflow-y:auto;padding:0 20px}.no-file-selected[_ngcontent-%COMP%]{display:inline-block;color:#666;padding:0 20px;white-space:normal}.source-files-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;font-family:"Roboto Mono",monospace;font-size:10px;height:100%}.title-tag[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;height:100%;padding-left:6px;vertical-align:top}source-code[_ngcontent-%COMP%]{flex-grow:1;width:100%}']}),n})(),kY=(()=>{class n{constructor(e){this.store=e,this.focusedSourceFileContent$=this.store.select(QE),this.focusedSourceLineSpec$=this.store.select(ZE),this.useDarkMode$=this.store.select(Pl)}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-source-files"]],decls:4,vars:9,consts:[[3,"focusedSourceFileContent","focusedSourceLineSpec","useDarkMode"]],template:function(e,i){1&e&&(k(0,"source-files-component",0),U(1,"async"),U(2,"async"),U(3,"async")),2&e&&b("focusedSourceFileContent",G(1,3,i.focusedSourceFileContent$))("focusedSourceLineSpec",G(2,5,i.focusedSourceLineSpec$))("useDarkMode",G(3,7,i.useDarkMode$))},dependencies:[PY,ct],encapsulation:2}),n})(),jwe=["stackFrameArray"];function Gwe(n,t){if(1&n&&(f(0,"span",13),T(1),g()),2&n){let e=w(3);v(1),Ve(" #",e.executionIndex,": ")}}function Wwe(n,t){if(1&n&&(f(0,"span",14),T(1),g()),2&n){let e=w(3);v(1),Ve(" ",e.opType," ")}}function qwe(n,t){if(1&n&&(f(0,"div"),T(1," Eager execution "),S(2,Gwe,2,1,"span",11),S(3,Wwe,2,1,"span",12),g()),2&n){let e=w(2);v(2),b("ngIf",null!==e.opType),v(1),b("ngIf",null!==e.opType)}}function Xwe(n,t){if(1&n&&(f(0,"span",16),T(1),g()),2&n){let e=w(3);v(1),Ve(' "',e.opName,'" ')}}function Ywe(n,t){if(1&n&&(f(0,"span",14),T(1),g()),2&n){let e=w(3);v(1),Ve(" ",e.opType," ")}}function Qwe(n,t){if(1&n&&(f(0,"div"),T(1," Creation of graph op "),S(2,Xwe,2,1,"span",15),S(3,Ywe,2,1,"span",12),g()),2&n){let e=w(2);v(2),b("ngIf",null!==e.opName),v(1),b("ngIf",null!==e.opType)}}function Zwe(n,t){if(1&n&&(f(0,"span",17),T(1),g()),2&n){let e=w(2);v(1),Ve(" (Host name: ",e.stackFramesForDisplay[0].host_name,") ")}}function Kwe(n,t){if(1&n&&(f(0,"div",7)(1,"span")(2,"span",8),S(3,qwe,4,2,"div",9),S(4,Qwe,4,2,"div",9),g()(),f(5,"div"),S(6,Zwe,2,1,"span",10),g()()),2&n){let e=w();v(2),b("ngSwitch",e.codeLocationType),v(1),b("ngSwitchCase",e.CodeLocationType.EXECUTION),v(1),b("ngSwitchCase",e.CodeLocationType.GRAPH_OP_CREATION),v(2),b("ngIf",null!==e.stackFramesForDisplay&&e.stackFramesForDisplay.length>0)}}function Jwe(n,t){1&n&&(f(0,"div",18),T(1," Click an eager execution or graph op to show its original stack trace. "),g())}function $we(n,t){1&n&&(f(0,"div",28),T(1," \u2913 "),g())}var eSe=function(n,t){return[n,t]};function tSe(n,t){if(1&n){let e=Te();f(0,"div",22)(1,"div",23),T(2),g(),f(3,"div",24),S(4,$we,2,0,"div",25),f(5,"div",26),A("click",function(){let o=ne(e).$implicit;return ie(w(2).onSourceLineClicked.emit(o))}),T(6),g(),f(7,"div",27),T(8),g()()()}if(2&n){let e=t.$implicit,i=w(2);b("ngClass",So(6,eSe,e.belongsToFocusedFile?"focused-file":"",e.focused?"focused-stack-frame":"")),v(1),Zi("title",e.file_path),v(1),Ve(" ",e.concise_file_path," "),v(2),b("ngIf",i.stickToBottommostFrameInFocusedFile&&e.focused),v(2),Ve(" Line ",e.lineno," "),v(2),Ve(" ",e.function_name," ")}}function nSe(n,t){if(1&n&&(f(0,"div",19,20),S(2,tSe,9,9,"div",21),g()),2&n){let e=w();v(2),b("ngForOf",e.stackFramesForDisplay)}}function iSe(n,t){}var OY=(()=>{class n{constructor(){this.stackFramesForDisplay=null,this.onSourceLineClicked=new F,this.CodeLocationType=zo}ngAfterViewChecked(){if(void 0===this.stackFrameArray)return;let e=this.stackFrameArray.nativeElement,i=e.querySelector(".focused-stack-frame");if(null!==i)return void this.scrollToElement(e,i);let r=e.querySelector(".stack-frame-container:last-child");null!==r&&this.scrollToElement(e,r)}scrollToElement(e,i){e.scrollTop=i.offsetTop}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["stack-trace-component"]],viewQuery:function(e,i){if(1&e&&Ue(jwe,5),2&e){let r;be(r=ve())&&(i.stackFrameArray=r.first)}},inputs:{codeLocationType:"codeLocationType",opType:"opType",opName:"opName",executionIndex:"executionIndex",stickToBottommostFrameInFocusedFile:"stickToBottommostFrameInFocusedFile",stackFramesForDisplay:"stackFramesForDisplay"},outputs:{onSourceLineClicked:"onSourceLineClicked"},decls:10,vars:4,consts:[[1,"stack-trace-container"],[1,"stack-trace-header"],[1,"stack-trace-title"],["class","stack-trace-aux-info",4,"ngIf","ngIfElse"],["noStackTrace",""],["class","stack-frame-array",4,"ngIf","ngIfElse"],["loadingSection",""],[1,"stack-trace-aux-info"],[1,"code-location-origin",3,"ngSwitch"],[4,"ngSwitchCase"],["class","stack-trace-host-name",4,"ngIf"],["class","eager-execution-index",4,"ngIf"],["class","op-type",4,"ngIf"],[1,"eager-execution-index"],[1,"op-type"],["class","op-name",4,"ngIf"],[1,"op-name"],[1,"stack-trace-host-name"],[1,"stack-trace-aux-info","no-stack-trace"],[1,"stack-frame-array"],["stackFrameArray",""],["class","stack-frame-container",3,"ngClass",4,"ngFor","ngForOf"],[1,"stack-frame-container",3,"ngClass"],[1,"stack-frame-file-path",3,"title"],[1,"stack-frame-lineno-function"],["class","stick-to-bottommost-indicator","title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",4,"ngIf"],[1,"stack-frame-lineno",3,"click"],[1,"stack-frame-function"],["title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",1,"stick-to-bottommost-indicator"]],template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1)(2,"span",2),T(3," Stack Trace "),g(),S(4,Kwe,7,4,"div",3),S(5,Jwe,2,0,"ng-template",null,4,jt),g(),S(7,nSe,3,1,"div",5),S(8,iSe,0,0,"ng-template",null,6,jt),g()),2&e){let r=st(6),o=st(9);v(4),b("ngIf",null!==i.codeLocationType)("ngIfElse",r),v(3),b("ngIf",null!==i.stackFramesForDisplay)("ngIfElse",o)}},dependencies:[wn,nn,Ne,mr,kr],styles:['.focused-file[_ngcontent-%COMP%]{font-weight:bold}.focused-stack-frame[_ngcontent-%COMP%]{background-color:rgba(255,111,0,.3)}.no-stack-trace[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{word-wrap:anywhere}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.stack-frame-array[_ngcontent-%COMP%]{overflow-x:hidden;overflow-y:auto;width:calc(100% - 8px)}.stack-frame-container[_ngcontent-%COMP%]{border-bottom:1px solid #a0a0a0}.stack-frame-file-path[_ngcontent-%COMP%]{max-width:180px;width:180px}.stack-frame-lineno-function[_ngcontent-%COMP%]{text-align:right;white-space:nowrap}.stack-frame-function[_ngcontent-%COMP%]{display:inline-block;max-width:200px;padding-left:10px;text-align:left;white-space:normal;width:200px;word-wrap:anywhere}.stack-frame-lineno[_ngcontent-%COMP%]{cursor:pointer;display:inline-block;max-width:80px;text-align:left;text-decoration:underline;width:80px}.stack-trace-aux-info[_ngcontent-%COMP%]{margin-top:15px;padding-left:24px}.stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;box-sizing:border-box;display:flex;flex-flow:column;font-size:10px;font-family:"Roboto Mono",monospace;height:100%;margin-left:8px;max-height:360px;overflow-x:hidden;overflow-y:hidden;padding-left:8px;width:100%}body.dark-mode[_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #555}.stack-trace-header[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:3px}.stack-trace-host-name[_ngcontent-%COMP%]{color:gray}.stack-trace-title[_ngcontent-%COMP%]{font-weight:bold}.stick-to-bottommost-indicator[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;font-size:12px;padding-right:3px}']}),n})(),FY=(()=>{class n{constructor(e){this.store=e,this.codeLocationType$=this.store.pipe(un(W(fy,i=>null===i?null:i.codeLocationType))),this.opType$=this.store.pipe(un(W(fy,i=>null===i?null:i.opType))),this.opName$=this.store.pipe(un(W(fy,i=>null===i||i.codeLocationType!==zo.GRAPH_OP_CREATION?null:i.opName))),this.executionIndex$=this.store.pipe(un(W(fy,i=>null===i||i.codeLocationType!==zo.EXECUTION?null:i.executionIndex))),this.stickToBottommostFrameInFocusedFile$=this.store.pipe(un(hY)),this.stackFramesForDisplay$=this.store.pipe(un(W(uY,ZE,(i,r)=>{if(null===i)return null;let o=[];for(let a of i){let{host_name:s,file_path:l,lineno:c,function_name:d}=a,u=l.split("/"),h=null!==r&&s===r.host_name&&l===r.file_path;o.push({host_name:s,file_path:l,concise_file_path:u[u.length-1],lineno:c,function_name:d,belongsToFocusedFile:h,focused:h&&c===r.lineno})}return o})))}onSourceLineClicked(e){let{host_name:i,file_path:r,lineno:o,function_name:a}=e;this.store.dispatch(Ng({stackFrame:{host_name:i,file_path:r,lineno:o,function_name:a}}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-stack-trace"]],decls:7,vars:18,consts:[[3,"codeLocationType","opType","opName","executionIndex","stickToBottommostFrameInFocusedFile","stackFramesForDisplay","onSourceLineClicked"]],template:function(e,i){1&e&&(f(0,"stack-trace-component",0),A("onSourceLineClicked",function(o){return i.onSourceLineClicked(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),g()),2&e&&b("codeLocationType",G(1,6,i.codeLocationType$))("opType",G(2,8,i.opType$))("opName",G(3,10,i.opName$))("executionIndex",G(4,12,i.executionIndex$))("stickToBottommostFrameInFocusedFile",G(5,14,i.stickToBottommostFrameInFocusedFile$))("stackFramesForDisplay",G(6,16,i.stackFramesForDisplay$))},dependencies:[OY,ct],encapsulation:2}),n})(),aSe=function(n,t){return{tensorDebugMode:n,array:t}};function sSe(n,t){if(1&n&&(f(0,"div",12)(1,"div",13),T(2),g(),f(3,"div",14),k(4,"debug-tensor-value",15),g()()),2&n){let e=t.$implicit,i=t.index,r=w(3);v(2),Ve("Output slot ",i,":"),v(2),b("debugTensorValue",r.parseDebugTensorValue(So(2,aSe,r.tensorDebugMode,e)))}}function lSe(n,t){if(1&n&&(f(0,"div",10),S(1,sSe,5,5,"div",11),g()),2&n){let e=w(2);v(1),b("ngForOf",e.debugTensorValues)}}function cSe(n,t){if(1&n&&(f(0,"div")(1,"div")(2,"div",3)(3,"span",4),T(4," Op: "),g(),f(5,"span",5),T(6),g()(),f(7,"div",3)(8,"span",4),T(9," # of input tensors: "),g(),f(10,"span",6),T(11),g()(),f(12,"div",3)(13,"span",4),T(14," # of output tensors: "),g(),f(15,"span",7),T(16),g(),f(17,"span",8),T(18),g()(),S(19,lSe,2,1,"div",9),g()()),2&n){let e=w();v(6),Ve(" ",e.focusedExecutionData.op_type," "),v(5),Ve(" ",null==e.focusedExecutionData.input_tensor_ids?0:e.focusedExecutionData.input_tensor_ids.length," "),v(5),Ve(" ",null==e.focusedExecutionData.output_tensor_ids?0:e.focusedExecutionData.output_tensor_ids.length," "),v(2),Ve(" (debug mode: ",e.TensorDebugMode[e.tensorDebugMode],") "),v(1),b("ngIf",e.hasDebugTensorValues)}}function dSe(n,t){}var NY=(()=>{class n{constructor(){this.tensorDebugMode=Ao.UNSPECIFIED,this.hasDebugTensorValues=!1,this.debugTensorValues=null,this.debugTensorDtypes=null,this.TensorDebugMode=Ao,this.parseDebugTensorValue=KE}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["execution-data-component"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionData:"focusedExecutionData",tensorDebugMode:"tensorDebugMode",hasDebugTensorValues:"hasDebugTensorValues",debugTensorValues:"debugTensorValues",debugTensorDtypes:"debugTensorDtypes"},decls:7,vars:3,consts:[[1,"focus-execution-container"],[4,"ngIf","ngIfElse"],["loading_section",""],[1,"execution-data-field"],[1,"execution-data-key"],[1,"execution-data-value","op-type"],[1,"execution-data-value","input-tensors"],[1,"execution-data-value","output-tensors"],[1,"execution-data-value"],["class","output-slots",4,"ngIf"],[1,"output-slots"],["class","output-slot-container",4,"ngFor","ngForOf"],[1,"output-slot-container"],[1,"output-slot-number"],[1,"output-slot-debug-tensor-value"],[3,"debugTensorValue"]],template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div")(2,"span"),T(3),g()(),S(4,cSe,20,5,"div",1),S(5,dSe,0,0,"ng-template",null,2,jt),g()),2&e){let r=st(6);v(3),Ve(" Python Execution #",i.focusedExecutionIndex," "),v(1),b("ngIf",null!==i.focusedExecutionData)("ngIfElse",r)}},dependencies:[nn,Ne,JE],styles:['.debug-tensor-values-table[_ngcontent-%COMP%]{width:100%}.debug-tensor-values-table[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{border-top:1px solid #000;text-align:left}.debug-tensor-values-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.execution-data-field[_ngcontent-%COMP%]{white-space:nowrap}.execution-data-key[_ngcontent-%COMP%]{display:inline-block;max-width:120px;text-align:right;width:120px}.execution-data-value[_ngcontent-%COMP%]{display:inline-block;margin-left:10px}.focus-execution-container[_ngcontent-%COMP%]{background-color:#ffcc80;border-radius:4px;font-size:12px;height:120px;padding:5px;width:360px}body.dark-mode[_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%]{background-color:#e65100}.output-slots[_ngcontent-%COMP%]{height:60px;overflow-x:auto;overflow-y:auto}.output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;margin-top:5px;padding:2px 0;vertical-align:top}body.dark-mode[_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #555}.output-slot-number[_ngcontent-%COMP%]{display:block;font-family:"Roboto Mono",monospace}.output-slot-debug-tensor-value[_ngcontent-%COMP%]{display:block;margin:3px 0 3px 30px}.output-tensors[_ngcontent-%COMP%]{margin-top:5px}']}),n})(),LY="Unknown dtype",BY=(()=>{class n{constructor(e){this.store=e,this.focusedExecutionData$=this.store.pipe(un(Bh)),this.tensorDebugMode$=this.store.pipe(un(W(Bh,i=>null===i?Ao.UNSPECIFIED:i.tensor_debug_mode))),this.hasDebugTensorValues$=this.store.pipe(un(W(Bh,i=>{if(null===i||null===i.debug_tensor_values)return!1;for(let r of i.debug_tensor_values)if(null!==r&&r.length>0)return!0;return!1}))),this.debugTensorValues$=this.store.pipe(un(W(Bh,i=>null===i?null:i.debug_tensor_values))),this.debugTensorDtypes$=this.store.pipe(un(W(Bh,i=>{if(null===i||null===i.debug_tensor_values||i.tensor_debug_mode!==Ao.FULL_HEALTH&&i.tensor_debug_mode!==Ao.SHAPE)return null;let r=[];for(let o of i.debug_tensor_values)if(null===o)r.push(LY);else{let a=String(i.tensor_debug_mode===Ao.FULL_HEALTH?o[2]:o[1]);r.push(gy[a]||LY)}return r})))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-execution-data"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex"},decls:6,vars:16,consts:[[3,"focusedExecutionIndex","focusedExecutionData","tensorDebugMode","hasDebugTensorValues","debugTensorValues","debugTensorDtypes"]],template:function(e,i){1&e&&(k(0,"execution-data-component",0),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async")),2&e&&b("focusedExecutionIndex",i.focusedExecutionIndex)("focusedExecutionData",G(1,6,i.focusedExecutionData$))("tensorDebugMode",G(2,8,i.tensorDebugMode$))("hasDebugTensorValues",G(3,10,i.hasDebugTensorValues$))("debugTensorValues",G(4,12,i.debugTensorValues$))("debugTensorDtypes",G(5,14,i.debugTensorDtypes$))},dependencies:[NY,ct],encapsulation:2}),n})(),hSe=["knob"],mSe=["valueIndicatorContainer"];function fSe(n,t){if(1&n&&(f(0,"div",4,5)(2,"div",6)(3,"span",7),T(4),g()()()),2&n){let e=w();v(4),kt(e.valueIndicatorText)}}var gSe=["trackActive"];function _Se(n,t){if(1&n&&k(0,"div"),2&n){let e=t.$implicit,i=t.index,r=w(3);Xo(0===e?"mdc-slider__tick-mark--active":"mdc-slider__tick-mark--inactive"),Bt("transform",r._calcTickMarkTransform(i))}}function bSe(n,t){if(1&n&&(Gt(0),S(1,_Se,1,4,"div",11),Wt()),2&n){let e=w(2);v(1),b("ngForOf",e._tickMarks)}}function vSe(n,t){if(1&n&&(f(0,"div",8,9),S(2,bSe,2,1,"ng-container",10),g()),2&n){let e=w();v(2),b("ngIf",e._cachedWidth)}}function ySe(n,t){if(1&n&&k(0,"mat-slider-visual-thumb",7),2&n){let e=w();b("discrete",e.discrete)("thumbPosition",1)("valueIndicatorText",e.startValueIndicatorText)}}var xSe=["*"],tT=new te("_MatSlider"),VY=new te("_MatSliderThumb"),HY=new te("_MatSliderRangeThumb"),zY=new te("_MatSliderVisualThumb"),CSe=(()=>{class n{constructor(e,i,r,o){this._cdr=e,this._ngZone=i,this._slider=o,this._isHovered=!1,this._isActive=!1,this._isValueIndicatorVisible=!1,this._onPointerMove=a=>{if(this._sliderInput._isFocused)return;let s=this._hostElement.getBoundingClientRect(),l=this._isSliderThumbHovered(a,s);this._isHovered=l,l?this._showHoverRipple():this._hideRipple(this._hoverRippleRef)},this._onMouseLeave=()=>{this._isHovered=!1,this._hideRipple(this._hoverRippleRef)},this._onFocus=()=>{this._hideRipple(this._hoverRippleRef),this._showFocusRipple(),this._hostElement.classList.add("mdc-slider__thumb--focused")},this._onBlur=()=>{this._isActive||this._hideRipple(this._focusRippleRef),this._isHovered&&this._showHoverRipple(),this._hostElement.classList.remove("mdc-slider__thumb--focused")},this._onDragStart=()=>{this._isActive=!0,this._showActiveRipple()},this._onDragEnd=()=>{this._isActive=!1,this._hideRipple(this._activeRippleRef),this._sliderInput._isFocused||this._hideRipple(this._focusRippleRef)},this._hostElement=r.nativeElement}ngAfterViewInit(){this._ripple.radius=24,this._sliderInput=this._slider._getInput(this.thumbPosition),this._sliderInputEl=this._sliderInput._hostElement;let e=this._sliderInputEl;this._ngZone.runOutsideAngular(()=>{e.addEventListener("pointermove",this._onPointerMove),e.addEventListener("pointerdown",this._onDragStart),e.addEventListener("pointerup",this._onDragEnd),e.addEventListener("pointerleave",this._onMouseLeave),e.addEventListener("focus",this._onFocus),e.addEventListener("blur",this._onBlur)})}ngOnDestroy(){let e=this._sliderInputEl;e.removeEventListener("pointermove",this._onPointerMove),e.removeEventListener("pointerdown",this._onDragStart),e.removeEventListener("pointerup",this._onDragEnd),e.removeEventListener("pointerleave",this._onMouseLeave),e.removeEventListener("focus",this._onFocus),e.removeEventListener("blur",this._onBlur)}_showHoverRipple(){this._isShowingRipple(this._hoverRippleRef)||(this._hoverRippleRef=this._showRipple({enterDuration:0,exitDuration:0}),this._hoverRippleRef?.element.classList.add("mat-mdc-slider-hover-ripple"))}_showFocusRipple(){this._isShowingRipple(this._focusRippleRef)||(this._focusRippleRef=this._showRipple({enterDuration:0,exitDuration:0},!0),this._focusRippleRef?.element.classList.add("mat-mdc-slider-focus-ripple"))}_showActiveRipple(){this._isShowingRipple(this._activeRippleRef)||(this._activeRippleRef=this._showRipple({enterDuration:225,exitDuration:400}),this._activeRippleRef?.element.classList.add("mat-mdc-slider-active-ripple"))}_isShowingRipple(e){return 0===e?.state||1===e?.state}_showRipple(e,i){if(!this._slider.disabled&&(this._showValueIndicator(),this._slider._isRange&&this._slider._getThumb(1===this.thumbPosition?2:1)._showValueIndicator(),!this._slider._globalRippleOptions?.disabled||i))return this._ripple.launch({animation:this._slider._noopAnimations?{enterDuration:0,exitDuration:0}:e,centered:!0,persistent:!0})}_hideRipple(e){if(e?.fadeOut(),this._isShowingAnyRipple())return;this._slider._isRange||this._hideValueIndicator();let i=this._getSibling();i._isShowingAnyRipple()||(this._hideValueIndicator(),i._hideValueIndicator())}_showValueIndicator(){this._hostElement.classList.add("mdc-slider__thumb--with-indicator")}_hideValueIndicator(){this._hostElement.classList.remove("mdc-slider__thumb--with-indicator")}_getSibling(){return this._slider._getThumb(1===this.thumbPosition?2:1)}_getValueIndicatorContainer(){return this._valueIndicatorContainer?.nativeElement}_getKnob(){return this._knob.nativeElement}_isShowingAnyRipple(){return this._isShowingRipple(this._hoverRippleRef)||this._isShowingRipple(this._focusRippleRef)||this._isShowingRipple(this._activeRippleRef)}_isSliderThumbHovered(e,i){let r=i.width/2,l=e.clientY-(i.y+r);return Math.pow(e.clientX-(i.x+r),2)+Math.pow(l,2)<Math.pow(r,2)}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(ot),C(xe),C(tT))},n.\u0275cmp=P({type:n,selectors:[["mat-slider-visual-thumb"]],viewQuery:function(e,i){if(1&e&&(Ue(Ki,5),Ue(hSe,5),Ue(mSe,5)),2&e){let r;be(r=ve())&&(i._ripple=r.first),be(r=ve())&&(i._knob=r.first),be(r=ve())&&(i._valueIndicatorContainer=r.first)}},hostAttrs:[1,"mdc-slider__thumb","mat-mdc-slider-visual-thumb"],inputs:{discrete:"discrete",thumbPosition:"thumbPosition",valueIndicatorText:"valueIndicatorText"},features:[Vt([{provide:zY,useExisting:n}])],decls:4,vars:2,consts:[["class","mdc-slider__value-indicator-container",4,"ngIf"],[1,"mdc-slider__thumb-knob"],["knob",""],["matRipple","",1,"mat-mdc-focus-indicator",3,"matRippleDisabled"],[1,"mdc-slider__value-indicator-container"],["valueIndicatorContainer",""],[1,"mdc-slider__value-indicator"],[1,"mdc-slider__value-indicator-text"]],template:function(e,i){1&e&&(S(0,fSe,5,1,"div",0),k(1,"div",1,2)(3,"div",3)),2&e&&(b("ngIf",i.discrete),v(3),b("matRippleDisabled",!0))},dependencies:[Ne,Ki],styles:[".mat-mdc-slider-visual-thumb .mat-ripple{height:100%;width:100%}.mat-mdc-slider .mdc-slider__tick-marks{justify-content:start}.mat-mdc-slider .mdc-slider__tick-marks .mdc-slider__tick-mark--active,.mat-mdc-slider .mdc-slider__tick-marks .mdc-slider__tick-mark--inactive{position:absolute;left:2px}"],encapsulation:2,changeDetection:0}),n})(),MSe=Ko(go(class{constructor(n){this._elementRef=n}}),"primary"),Ju=(()=>{class n extends MSe{get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e);let i=this._getInput(2),r=this._getInput(1);i&&(i.disabled=this._disabled),r&&(r.disabled=this._disabled)}get discrete(){return this._discrete}set discrete(e){this._discrete=vt(e),this._updateValueIndicatorUIs()}get showTickMarks(){return this._showTickMarks}set showTickMarks(e){this._showTickMarks=vt(e)}get min(){return this._min}set min(e){let i=mi(e,this._min);this._min!==i&&this._updateMin(i)}_updateMin(e){let i=this._min;this._min=e,this._isRange?this._updateMinRange({old:i,new:e}):this._updateMinNonRange(e),this._onMinMaxOrStepChange()}_updateMinRange(e){let i=this._getInput(2),r=this._getInput(1),o=i.value,a=r.value;r.min=e.new,i.min=Math.max(e.new,r.value),r.max=Math.min(i.max,i.value),r._updateWidthInactive(),i._updateWidthInactive(),e.new<e.old?this._onTranslateXChangeBySideEffect(i,r):this._onTranslateXChangeBySideEffect(r,i),o!==i.value&&this._onValueChange(i),a!==r.value&&this._onValueChange(r)}_updateMinNonRange(e){let i=this._getInput(2);if(i){let r=i.value;i.min=e,i._updateThumbUIByValue(),this._updateTrackUI(i),r!==i.value&&this._onValueChange(i)}}get max(){return this._max}set max(e){let i=mi(e,this._max);this._max!==i&&this._updateMax(i)}_updateMax(e){let i=this._max;this._max=e,this._isRange?this._updateMaxRange({old:i,new:e}):this._updateMaxNonRange(e),this._onMinMaxOrStepChange()}_updateMaxRange(e){let i=this._getInput(2),r=this._getInput(1),o=i.value,a=r.value;i.max=e.new,r.max=Math.min(e.new,i.value),i.min=r.value,i._updateWidthInactive(),r._updateWidthInactive(),e.new>e.old?this._onTranslateXChangeBySideEffect(r,i):this._onTranslateXChangeBySideEffect(i,r),o!==i.value&&this._onValueChange(i),a!==r.value&&this._onValueChange(r)}_updateMaxNonRange(e){let i=this._getInput(2);if(i){let r=i.value;i.max=e,i._updateThumbUIByValue(),this._updateTrackUI(i),r!==i.value&&this._onValueChange(i)}}get step(){return this._step}set step(e){let i=mi(e,this._step);this._step!==i&&this._updateStep(i)}_updateStep(e){this._step=e,this._isRange?this._updateStepRange():this._updateStepNonRange(),this._onMinMaxOrStepChange()}_updateStepRange(){let e=this._getInput(2),i=this._getInput(1),r=e.value,o=i.value,a=i.value;e.min=this._min,i.max=this._max,e.step=this._step,i.step=this._step,this._platform.SAFARI&&(e.value=e.value,i.value=i.value),e.min=Math.max(this._min,i.value),i.max=Math.min(this._max,e.value),i._updateWidthInactive(),e._updateWidthInactive(),e.value<a?this._onTranslateXChangeBySideEffect(i,e):this._onTranslateXChangeBySideEffect(e,i),r!==e.value&&this._onValueChange(e),o!==i.value&&this._onValueChange(i)}_updateStepNonRange(){let e=this._getInput(2);if(e){let i=e.value;e.step=this._step,this._platform.SAFARI&&(e.value=e.value),e._updateThumbUIByValue(),i!==e.value&&this._onValueChange(e)}}constructor(e,i,r,o,a,s,l){super(o),this._ngZone=e,this._cdr=i,this._platform=r,this._dir=a,this._globalRippleOptions=s,this._disabled=!1,this._discrete=!1,this._showTickMarks=!1,this._min=0,this._max=100,this._step=0,this.displayWith=c=>`${c}`,this._rippleRadius=24,this.startValueIndicatorText="",this.endValueIndicatorText="",this._isRange=!1,this._isRtl=!1,this._hasViewInitialized=!1,this._tickMarkTrackWidth=0,this._hasAnimation=!1,this._resizeTimer=null,this._knobRadius=8,this._thumbsOverlap=!1,this._noopAnimations="NoopAnimations"===l,this._dirChangeSubscription=this._dir.change.subscribe(()=>this._onDirChange()),this._isRtl="rtl"===this._dir.value}ngAfterViewInit(){this._platform.isBrowser&&this._updateDimensions();let e=this._getInput(2),i=this._getInput(1);this._isRange=!!e&&!!i,this._cdr.detectChanges();let r=this._getThumb(2);this._rippleRadius=r._ripple.radius,this._inputPadding=this._rippleRadius-this._knobRadius,this._inputOffset=this._knobRadius,this._isRange?this._initUIRange(e,i):this._initUINonRange(e),this._updateTrackUI(e),this._updateTickMarkUI(),this._updateTickMarkTrackUI(),this._observeHostResize(),this._cdr.detectChanges()}_initUINonRange(e){e.initProps(),e.initUI(),this._updateValueIndicatorUI(e),this._hasViewInitialized=!0,e._updateThumbUIByValue()}_initUIRange(e,i){e.initProps(),e.initUI(),i.initProps(),i.initUI(),e._updateMinMax(),i._updateMinMax(),e._updateStaticStyles(),i._updateStaticStyles(),this._updateValueIndicatorUIs(),this._hasViewInitialized=!0,e._updateThumbUIByValue(),i._updateThumbUIByValue()}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._resizeObserver?.disconnect(),this._resizeObserver=null}_onDirChange(){this._isRtl="rtl"===this._dir.value,this._isRange?this._onDirChangeRange():this._onDirChangeNonRange(),this._updateTickMarkUI()}_onDirChangeRange(){let e=this._getInput(2),i=this._getInput(1);e._setIsLeftThumb(),i._setIsLeftThumb(),e.translateX=e._calcTranslateXByValue(),i.translateX=i._calcTranslateXByValue(),e._updateStaticStyles(),i._updateStaticStyles(),e._updateWidthInactive(),i._updateWidthInactive(),e._updateThumbUIByValue(),i._updateThumbUIByValue()}_onDirChangeNonRange(){this._getInput(2)._updateThumbUIByValue()}_observeHostResize(){typeof ResizeObserver>"u"||!ResizeObserver||this._ngZone.runOutsideAngular(()=>{this._resizeObserver=new ResizeObserver(()=>{this._isActive()||(this._resizeTimer&&clearTimeout(this._resizeTimer),this._onResize())}),this._resizeObserver.observe(this._elementRef.nativeElement)})}_isActive(){return this._getThumb(1)._isActive||this._getThumb(2)._isActive}_getValue(e=2){let i=this._getInput(e);return i?i.value:this.min}_skipUpdate(){return!(!this._getInput(1)?._skipUIUpdate&&!this._getInput(2)?._skipUIUpdate)}_updateDimensions(){this._cachedWidth=this._elementRef.nativeElement.offsetWidth,this._cachedLeft=this._elementRef.nativeElement.getBoundingClientRect().left}_setTrackActiveStyles(e){let i=this._trackActive.nativeElement.style,r=e.left!==i.left&&e.right!==i.right;i.left=e.left,i.right=e.right,i.transformOrigin=e.transformOrigin,r?(this._elementRef.nativeElement.classList.add("mat-mdc-slider-disable-track-animation"),this._ngZone.onStable.pipe(Lt(1)).subscribe(()=>{this._elementRef.nativeElement.classList.remove("mat-mdc-slider-disable-track-animation"),i.transform=e.transform})):i.transform=e.transform}_calcTickMarkTransform(e){return`translateX(${e*(this._tickMarkTrackWidth/(this._tickMarks.length-1))}px`}_onTranslateXChange(e){!this._hasViewInitialized||(this._updateThumbUI(e),this._updateTrackUI(e),this._updateOverlappingThumbUI(e))}_onTranslateXChangeBySideEffect(e,i){!this._hasViewInitialized||(e._updateThumbUIByValue(),i._updateThumbUIByValue())}_onValueChange(e){!this._hasViewInitialized||(this._updateValueIndicatorUI(e),this._updateTickMarkUI(),this._cdr.detectChanges())}_onMinMaxOrStepChange(){!this._hasViewInitialized||(this._updateTickMarkUI(),this._updateTickMarkTrackUI(),this._cdr.markForCheck())}_onResize(){if(this._hasViewInitialized){if(this._updateDimensions(),this._isRange){let e=this._getInput(2),i=this._getInput(1);e._updateThumbUIByValue(),i._updateThumbUIByValue(),e._updateStaticStyles(),i._updateStaticStyles(),e._updateMinMax(),i._updateMinMax(),e._updateWidthInactive(),i._updateWidthInactive()}else{let e=this._getInput(2);e&&e._updateThumbUIByValue()}this._updateTickMarkUI(),this._updateTickMarkTrackUI(),this._cdr.detectChanges()}}_areThumbsOverlapping(){let e=this._getInput(1),i=this._getInput(2);return!(!e||!i)&&i.translateX-e.translateX<20}_updateOverlappingThumbClassNames(e){let i=e.getSibling(),r=this._getThumb(e.thumbPosition);this._getThumb(i.thumbPosition)._hostElement.classList.remove("mdc-slider__thumb--top"),r._hostElement.classList.toggle("mdc-slider__thumb--top",this._thumbsOverlap)}_updateOverlappingThumbUI(e){!this._isRange||this._skipUpdate()||this._thumbsOverlap!==this._areThumbsOverlapping()&&(this._thumbsOverlap=!this._thumbsOverlap,this._updateOverlappingThumbClassNames(e))}_updateThumbUI(e){this._skipUpdate()||(this._getThumb(2===e.thumbPosition?2:1)._hostElement.style.transform=`translateX(${e.translateX}px)`)}_updateValueIndicatorUI(e){if(this._skipUpdate())return;let i=this.displayWith(e.value);if(this._hasViewInitialized?e._valuetext=i:e._hostElement.setAttribute("aria-valuetext",i),this.discrete){1===e.thumbPosition?this.startValueIndicatorText=i:this.endValueIndicatorText=i;let r=this._getThumb(e.thumbPosition);i.length<3?r._hostElement.classList.add("mdc-slider__thumb--short-value"):r._hostElement.classList.remove("mdc-slider__thumb--short-value")}}_updateValueIndicatorUIs(){let e=this._getInput(2),i=this._getInput(1);e&&this._updateValueIndicatorUI(e),i&&this._updateValueIndicatorUI(i)}_updateTickMarkTrackUI(){if(!this.showTickMarks||this._skipUpdate())return;let e=this._step&&this._step>0?this._step:1,r=(Math.floor(this.max/e)*e-this.min)/(this.max-this.min);this._tickMarkTrackWidth=this._cachedWidth*r-6}_updateTrackUI(e){this._skipUpdate()||(this._isRange?this._updateTrackUIRange(e):this._updateTrackUINonRange(e))}_updateTrackUIRange(e){let i=e.getSibling();if(!i||!this._cachedWidth)return;let r=Math.abs(i.translateX-e.translateX)/this._cachedWidth;this._setTrackActiveStyles(e._isLeftThumb&&this._cachedWidth?{left:"auto",right:this._cachedWidth-i.translateX+"px",transformOrigin:"right",transform:`scaleX(${r})`}:{left:`${i.translateX}px`,right:"auto",transformOrigin:"left",transform:`scaleX(${r})`})}_updateTrackUINonRange(e){this._setTrackActiveStyles(this._isRtl?{left:"auto",right:"0px",transformOrigin:"right",transform:`scaleX(${1-e.fillPercentage})`}:{left:"0px",right:"auto",transformOrigin:"left",transform:`scaleX(${e.fillPercentage})`})}_updateTickMarkUI(){if(!this.showTickMarks||void 0===this.step||void 0===this.min||void 0===this.max)return;let e=this.step>0?this.step:1;this._isRange?this._updateTickMarkUIRange(e):this._updateTickMarkUINonRange(e),this._isRtl&&this._tickMarks.reverse()}_updateTickMarkUINonRange(e){let i=this._getValue(),r=Math.max(Math.round((i-this.min)/e),0),o=Math.max(Math.round((this.max-i)/e),0);this._isRtl?r++:o++,this._tickMarks=Array(r).fill(0).concat(Array(o).fill(1))}_updateTickMarkUIRange(e){let i=this._getValue(),r=this._getValue(1),o=Math.max(Math.floor((r-this.min)/e),0),a=Math.max(Math.floor((i-r)/e)+1,0),s=Math.max(Math.floor((this.max-i)/e),0);this._tickMarks=Array(o).fill(1).concat(Array(a).fill(0),Array(s).fill(1))}_getInput(e){return 2===e&&this._input?this._input:this._inputs?.length?1===e?this._inputs.first:this._inputs.last:void 0}_getThumb(e){return 2===e?this._thumbs?.last:this._thumbs?.first}_setTransition(e){this._hasAnimation=e&&!this._noopAnimations,this._elementRef.nativeElement.classList.toggle("mat-mdc-slider-with-animation",this._hasAnimation)}}return n.\u0275fac=function(e){return new(e||n)(C(ot),C(Qt),C(Vn),C(xe),C(zi,8),C(Th,8),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-slider"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,VY,5),Bn(r,HY,4)),2&e){let o;be(o=ve())&&(i._input=o.first),be(o=ve())&&(i._inputs=o)}},viewQuery:function(e,i){if(1&e&&(Ue(gSe,5),Ue(zY,5)),2&e){let r;be(r=ve())&&(i._trackActive=r.first),be(r=ve())&&(i._thumbs=r)}},hostAttrs:[1,"mat-mdc-slider","mdc-slider"],hostVars:10,hostBindings:function(e,i){2&e&&nt("mdc-slider--range",i._isRange)("mdc-slider--disabled",i.disabled)("mdc-slider--discrete",i.discrete)("mdc-slider--tick-marks",i.showTickMarks)("_mat-animation-noopable",i._noopAnimations)},inputs:{color:"color",disableRipple:"disableRipple",disabled:"disabled",discrete:"discrete",showTickMarks:"showTickMarks",min:"min",max:"max",step:"step",displayWith:"displayWith"},exportAs:["matSlider"],features:[Vt([{provide:tT,useExisting:n}]),Xe],ngContentSelectors:xSe,decls:9,vars:5,consts:[[1,"mdc-slider__track"],[1,"mdc-slider__track--inactive"],[1,"mdc-slider__track--active"],[1,"mdc-slider__track--active_fill"],["trackActive",""],["class","mdc-slider__tick-marks",4,"ngIf"],[3,"discrete","thumbPosition","valueIndicatorText",4,"ngIf"],[3,"discrete","thumbPosition","valueIndicatorText"],[1,"mdc-slider__tick-marks"],["tickMarkContainer",""],[4,"ngIf"],[3,"class","transform",4,"ngFor","ngForOf"]],template:function(e,i){1&e&&(fn(),Tt(0),f(1,"div",0),k(2,"div",1),f(3,"div",2),k(4,"div",3,4),g(),S(6,vSe,3,1,"div",5),g(),S(7,ySe,1,3,"mat-slider-visual-thumb",6),k(8,"mat-slider-visual-thumb",7)),2&e&&(v(6),b("ngIf",i.showTickMarks),v(1),b("ngIf",i._isRange),v(1),b("discrete",i.discrete)("thumbPosition",2)("valueIndicatorText",i.endValueIndicatorText))},dependencies:[nn,Ne,CSe],styles:['.mdc-slider{cursor:pointer;height:48px;margin:0 24px;position:relative;touch-action:pan-y}.mdc-slider .mdc-slider__track{position:absolute;top:50%;transform:translateY(-50%);width:100%}.mdc-slider .mdc-slider__track--active,.mdc-slider .mdc-slider__track--inactive{display:flex;height:100%;position:absolute;width:100%}.mdc-slider .mdc-slider__track--active{overflow:hidden}.mdc-slider .mdc-slider__track--active_fill{border-top-style:solid;box-sizing:border-box;height:100%;width:100%;position:relative;-webkit-transform-origin:left;transform-origin:left}[dir=rtl] .mdc-slider .mdc-slider__track--active_fill,.mdc-slider .mdc-slider__track--active_fill[dir=rtl]{-webkit-transform-origin:right;transform-origin:right}.mdc-slider .mdc-slider__track--inactive{left:0;top:0}.mdc-slider .mdc-slider__track--inactive::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-slider .mdc-slider__track--inactive::before{border-color:CanvasText}}.mdc-slider .mdc-slider__value-indicator-container{bottom:44px;left:var(--slider-value-indicator-container-left, 50%);pointer-events:none;position:absolute;right:var(--slider-value-indicator-container-right);transform:var(--slider-value-indicator-container-transform, translateX(-50%))}.mdc-slider .mdc-slider__value-indicator{transition:transform 100ms 0ms cubic-bezier(0.4, 0, 1, 1);align-items:center;border-radius:4px;display:flex;height:32px;padding:0 12px;transform:scale(0);transform-origin:bottom}.mdc-slider .mdc-slider__value-indicator::before{border-left:6px solid rgba(0,0,0,0);border-right:6px solid rgba(0,0,0,0);border-top:6px solid;bottom:-5px;content:"";height:0;left:var(--slider-value-indicator-caret-left, 50%);position:absolute;right:var(--slider-value-indicator-caret-right);transform:var(--slider-value-indicator-caret-transform, translateX(-50%));width:0}.mdc-slider .mdc-slider__value-indicator::after{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-slider .mdc-slider__value-indicator::after{border-color:CanvasText}}.mdc-slider .mdc-slider__thumb--with-indicator .mdc-slider__value-indicator-container{pointer-events:auto}.mdc-slider .mdc-slider__thumb--with-indicator .mdc-slider__value-indicator{transition:transform 100ms 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(1)}@media(prefers-reduced-motion){.mdc-slider .mdc-slider__value-indicator,.mdc-slider .mdc-slider__thumb--with-indicator .mdc-slider__value-indicator{transition:none}}.mdc-slider .mdc-slider__thumb{display:flex;left:-24px;outline:none;position:absolute;user-select:none;height:48px;width:48px}.mdc-slider .mdc-slider__thumb--top{z-index:1}.mdc-slider .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-style:solid;border-width:1px;box-sizing:content-box}.mdc-slider .mdc-slider__thumb-knob{box-sizing:border-box;left:50%;position:absolute;top:50%;transform:translate(-50%, -50%)}.mdc-slider .mdc-slider__tick-marks{align-items:center;box-sizing:border-box;display:flex;height:100%;justify-content:space-between;padding:0 1px;position:absolute;width:100%}.mdc-slider--discrete .mdc-slider__thumb,.mdc-slider--discrete .mdc-slider__track--active_fill{transition:transform 80ms ease}@media(prefers-reduced-motion){.mdc-slider--discrete .mdc-slider__thumb,.mdc-slider--discrete .mdc-slider__track--active_fill{transition:none}}.mdc-slider--disabled{cursor:auto}.mdc-slider--disabled .mdc-slider__thumb{pointer-events:none}.mdc-slider__input{cursor:pointer;left:0;margin:0;height:100%;opacity:0;pointer-events:none;position:absolute;top:0;width:100%}.mat-mdc-slider{display:inline-block;box-sizing:border-box;outline:none;vertical-align:middle;margin-left:8px;margin-right:8px;width:auto;min-width:112px;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-slider .mdc-slider__thumb-knob{background-color:var(--mdc-slider-handle-color, var(--mdc-theme-primary, #6200ee));border-color:var(--mdc-slider-handle-color, var(--mdc-theme-primary, #6200ee))}.mat-mdc-slider .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:#fff}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__thumb-knob{background-color:var(--mdc-slider-disabled-handle-color, var(--mdc-theme-on-surface, #000));border-color:var(--mdc-slider-disabled-handle-color, var(--mdc-theme-on-surface, #000))}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider.mdc-slider--disabled .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider.mdc-slider--disabled .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:#fff}.mat-mdc-slider .mdc-slider__thumb::before,.mat-mdc-slider .mdc-slider__thumb::after{background-color:var(--mdc-slider-handle-color, var(--mdc-theme-primary, #6200ee))}.mat-mdc-slider .mdc-slider__thumb:hover::before,.mat-mdc-slider .mdc-slider__thumb.mdc-ripple-surface--hover::before{opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mat-mdc-slider .mdc-slider__thumb.mdc-ripple-upgraded--background-focused::before,.mat-mdc-slider .mdc-slider__thumb:not(.mdc-ripple-upgraded):focus::before{transition-duration:75ms;opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mat-mdc-slider .mdc-slider__thumb:not(.mdc-ripple-upgraded)::after{transition:opacity 150ms linear}.mat-mdc-slider .mdc-slider__thumb:not(.mdc-ripple-upgraded):active::after{transition-duration:75ms;opacity:var(--mdc-ripple-press-opacity, 0.12)}.mat-mdc-slider .mdc-slider__thumb.mdc-ripple-upgraded{--mdc-ripple-fg-opacity:var(--mdc-ripple-press-opacity, 0.12)}.mat-mdc-slider .mdc-slider__track--active_fill{border-color:var(--mdc-slider-active-track-color, var(--mdc-theme-primary, #6200ee))}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__track--active_fill{border-color:var(--mdc-slider-disabled-active-track-color, var(--mdc-theme-on-surface, #000))}.mat-mdc-slider .mdc-slider__track--inactive{background-color:var(--mdc-slider-inactive-track-color, var(--mdc-theme-primary, #6200ee));opacity:.24}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__track--inactive{background-color:var(--mdc-slider-disabled-inactive-track-color, var(--mdc-theme-on-surface, #000));opacity:.24}.mat-mdc-slider .mdc-slider__tick-mark--active{background-color:var(--mdc-slider-with-tick-marks-active-container-color, var(--mdc-theme-on-primary, #fff));opacity:var(--mdc-slider-with-tick-marks-active-container-opacity, 0.6)}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__tick-mark--active{background-color:var(--mdc-slider-with-tick-marks-active-container-color, var(--mdc-theme-on-primary, #fff));opacity:var(--mdc-slider-with-tick-marks-active-container-opacity, 0.6)}.mat-mdc-slider .mdc-slider__tick-mark--inactive{background-color:var(--mdc-slider-with-tick-marks-inactive-container-color, var(--mdc-theme-primary, #6200ee));opacity:var(--mdc-slider-with-tick-marks-inactive-container-opacity, 0.6)}.mat-mdc-slider.mdc-slider--disabled .mdc-slider__tick-mark--inactive{background-color:var(--mdc-slider-with-tick-marks-disabled-container-color, var(--mdc-theme-on-surface, #000));opacity:var(--mdc-slider-with-tick-marks-inactive-container-opacity, 0.6)}.mat-mdc-slider .mdc-slider__value-indicator{background-color:var(--mdc-slider-label-container-color, #666666);opacity:1}.mat-mdc-slider .mdc-slider__value-indicator::before{border-top-color:var(--mdc-slider-label-container-color, #666666)}.mat-mdc-slider .mdc-slider__value-indicator{color:var(--mdc-slider-label-label-text-color, var(--mdc-theme-on-primary, #fff))}.mat-mdc-slider .mdc-slider__track{height:var(--mdc-slider-inactive-track-height, 4px)}.mat-mdc-slider .mdc-slider__track--active{height:var(--mdc-slider-active-track-height, 6px);top:calc((var(--mdc-slider-inactive-track-height, 4px) - var(--mdc-slider-active-track-height, 6px)) / 2)}.mat-mdc-slider .mdc-slider__track--active_fill{border-top-width:var(--mdc-slider-active-track-height, 6px)}.mat-mdc-slider .mdc-slider__track--inactive{height:var(--mdc-slider-inactive-track-height, 4px)}.mat-mdc-slider .mdc-slider__tick-mark--active,.mat-mdc-slider .mdc-slider__tick-mark--inactive{height:var(--mdc-slider-with-tick-marks-container-size, 2px);width:var(--mdc-slider-with-tick-marks-container-size, 2px)}.mat-mdc-slider.mdc-slider--disabled{opacity:0.38}.mat-mdc-slider .mdc-slider__value-indicator-text{letter-spacing:var(--mdc-slider-label-label-text-tracking, 0.0071428571em);font-size:var(--mdc-slider-label-label-text-size, 0.875rem);font-family:var(--mdc-slider-label-label-text-font, Roboto, sans-serif);font-weight:var(--mdc-slider-label-label-text-weight, 500);line-height:var(--mdc-slider-label-label-text-line-height, 1.375rem)}.mat-mdc-slider .mdc-slider__track--active{border-radius:var(--mdc-slider-active-track-shape, 9999px)}.mat-mdc-slider .mdc-slider__track--inactive{border-radius:var(--mdc-slider-inactive-track-shape, 9999px)}.mat-mdc-slider .mdc-slider__thumb-knob{border-radius:var(--mdc-slider-handle-shape, 50%);width:var(--mdc-slider-handle-width, 20px);height:var(--mdc-slider-handle-height, 20px);border-style:solid;border-width:calc(var(--mdc-slider-handle-height, 20px) / 2) calc(var(--mdc-slider-handle-width, 20px) / 2)}.mat-mdc-slider .mdc-slider__tick-mark--active,.mat-mdc-slider .mdc-slider__tick-mark--inactive{border-radius:var(--mdc-slider-with-tick-marks-container-shape, 50%)}.mat-mdc-slider .mdc-slider__thumb-knob{box-shadow:var(--mdc-slider-handle-elevation, 0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 1px 3px 0px rgba(0, 0, 0, 0.12))}.mat-mdc-slider .mdc-slider__thumb:hover .mdc-slider__thumb-knob{background-color:var(--mdc-slider-hover-handle-color, var(--mdc-theme-primary, #6200ee));border-color:var(--mdc-slider-hover-handle-color, var(--mdc-theme-primary, #6200ee))}.mat-mdc-slider .mdc-slider__thumb:hover .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb:hover .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb:hover .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:#fff}.mat-mdc-slider .mdc-slider__thumb--focused .mdc-slider__thumb-knob{background-color:var(--mdc-slider-focus-handle-color, var(--mdc-theme-primary, #6200ee));border-color:var(--mdc-slider-focus-handle-color, var(--mdc-theme-primary, #6200ee))}.mat-mdc-slider .mdc-slider__thumb--focused .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--focused .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--focused .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:#fff}.mat-mdc-slider .mdc-slider__thumb:not(:disabled):active .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb:not(:disabled):active .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb:not(:disabled):active .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:#fff}.mat-mdc-slider .mdc-slider__thumb--top .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb:hover .mdc-slider__thumb-knob,.mat-mdc-slider .mdc-slider__thumb--top.mdc-slider__thumb--focused .mdc-slider__thumb-knob{border-color:var(--mdc-slider-with-overlap-handle-outline-color, #fff);border-width:var(--mdc-slider-with-overlap-handle-outline-width, 1px)}.mat-mdc-slider .mdc-slider__input{box-sizing:content-box;pointer-events:auto}.mat-mdc-slider .mdc-slider__input.mat-mdc-slider-input-no-pointer-events{pointer-events:none}.mat-mdc-slider .mdc-slider__input.mat-slider__right-input{left:auto;right:0}.mat-mdc-slider .mdc-slider__thumb,.mat-mdc-slider .mdc-slider__track--active_fill{transition-duration:0ms}.mat-mdc-slider.mat-mdc-slider-with-animation .mdc-slider__thumb,.mat-mdc-slider.mat-mdc-slider-with-animation .mdc-slider__track--active_fill{transition-duration:80ms}.mat-mdc-slider.mat-mdc-slider-with-animation.mat-mdc-slider-disable-track-animation .mdc-slider__track--active_fill{transition-duration:0ms}.mat-mdc-slider.mdc-slider--discrete .mdc-slider__thumb,.mat-mdc-slider.mdc-slider--discrete .mdc-slider__track--active_fill{transition-duration:0ms}.mat-mdc-slider.mat-mdc-slider-with-animation .mdc-slider__thumb,.mat-mdc-slider.mat-mdc-slider-with-animation .mdc-slider__track--active_fill{transition-duration:80ms}.mat-mdc-slider.mat-mdc-slider-with-animation.mat-mdc-slider-disable-track-animation .mdc-slider__track--active_fill{transition-duration:0ms}.mat-mdc-slider .mdc-slider__track,.mat-mdc-slider .mdc-slider__thumb{pointer-events:none}.mat-mdc-slider .mdc-slider__value-indicator{opacity:var(--mat-mdc-slider-value-indicator-opacity, 1)}.mat-mdc-slider .mat-ripple .mat-ripple-element{background-color:var(--mat-mdc-slider-ripple-color, transparent)}.mat-mdc-slider .mat-ripple .mat-mdc-slider-hover-ripple{background-color:var(--mat-mdc-slider-hover-ripple-color, transparent)}.mat-mdc-slider .mat-ripple .mat-mdc-slider-focus-ripple,.mat-mdc-slider .mat-ripple .mat-mdc-slider-active-ripple{background-color:var(--mat-mdc-slider-focus-ripple-color, transparent)}.mat-mdc-slider._mat-animation-noopable.mdc-slider--discrete .mdc-slider__thumb,.mat-mdc-slider._mat-animation-noopable.mdc-slider--discrete .mdc-slider__track--active_fill,.mat-mdc-slider._mat-animation-noopable .mdc-slider__value-indicator{transition:none}.mat-mdc-slider .mat-mdc-focus-indicator::before{border-radius:50%}.mdc-slider__thumb--focused .mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),wSe={provide:Xr,useExisting:Wn(()=>$u),multi:!0},SSe={provide:Xr,useExisting:Wn(()=>vN),multi:!0},$u=(()=>{class n{get value(){return mi(this._hostElement.value)}set value(e){let i=mi(e).toString();this._hasSetInitialValue?this._isActive||(this._hostElement.value=i,this._updateThumbUIByValue(),this._slider._onValueChange(this),this._cdr.detectChanges()):this._initialValue=i}get translateX(){return this._slider.min>=this._slider.max?(this._translateX=0,this._translateX):(void 0===this._translateX&&(this._translateX=this._calcTranslateXByValue()),this._translateX)}set translateX(e){this._translateX=e}get min(){return mi(this._hostElement.min)}set min(e){this._hostElement.min=mi(e).toString(),this._cdr.detectChanges()}get max(){return mi(this._hostElement.max)}set max(e){this._hostElement.max=mi(e).toString(),this._cdr.detectChanges()}get step(){return mi(this._hostElement.step)}set step(e){this._hostElement.step=mi(e).toString(),this._cdr.detectChanges()}get disabled(){return vt(this._hostElement.disabled)}set disabled(e){this._hostElement.disabled=vt(e),this._cdr.detectChanges(),this._slider.disabled!==this.disabled&&(this._slider.disabled=this.disabled)}get percentage(){return this._slider.min>=this._slider.max?this._slider._isRtl?1:0:(this.value-this._slider.min)/(this._slider.max-this._slider.min)}get fillPercentage(){return this._slider._cachedWidth?0===this._translateX?0:this.translateX/this._slider._cachedWidth:this._slider._isRtl?1:0}_setIsFocused(e){this._isFocused=e}constructor(e,i,r,o){this._ngZone=e,this._elementRef=i,this._cdr=r,this._slider=o,this.valueChange=new F,this.dragStart=new F,this.dragEnd=new F,this.thumbPosition=2,this._knobRadius=8,this._isActive=!1,this._isFocused=!1,this._hasSetInitialValue=!1,this._destroyed=new Ee,this._skipUIUpdate=!1,this._onChangeFn=()=>{},this._onTouchedFn=()=>{},this._hostElement=i.nativeElement,this._ngZone.runOutsideAngular(()=>{this._hostElement.addEventListener("pointerdown",this._onPointerDown.bind(this)),this._hostElement.addEventListener("pointermove",this._onPointerMove.bind(this)),this._hostElement.addEventListener("pointerup",this._onPointerUp.bind(this))})}ngOnDestroy(){this._hostElement.removeEventListener("pointerdown",this._onPointerDown),this._hostElement.removeEventListener("pointermove",this._onPointerMove),this._hostElement.removeEventListener("pointerup",this._onPointerUp),this._destroyed.next(),this._destroyed.complete(),this.dragStart.complete(),this.dragEnd.complete()}initProps(){this._updateWidthInactive(),this.disabled!==this._slider.disabled&&(this._slider.disabled=!0),this.step=this._slider.step,this.min=this._slider.min,this.max=this._slider.max,this._initValue()}initUI(){this._updateThumbUIByValue()}_initValue(){this._hasSetInitialValue=!0,void 0===this._initialValue?this.value=this._getDefaultValue():(this._hostElement.value=this._initialValue,this._updateThumbUIByValue(),this._slider._onValueChange(this),this._cdr.detectChanges())}_getDefaultValue(){return this.min}_onBlur(){this._setIsFocused(!1),this._onTouchedFn()}_onFocus(){this._setIsFocused(!0)}_onChange(){this.valueChange.emit(this.value),this._isActive&&this._updateThumbUIByValue({withAnimation:!0})}_onInput(){this._onChangeFn(this.value),(this._slider.step||!this._isActive)&&this._updateThumbUIByValue({withAnimation:!0}),this._slider._onValueChange(this)}_onNgControlValueChange(){(!this._isActive||!this._isFocused)&&(this._slider._onValueChange(this),this._updateThumbUIByValue()),this._slider.disabled=this._formControl.disabled}_onPointerDown(e){this.disabled||0!==e.button||(this._isActive=!0,this._setIsFocused(!0),this._updateWidthActive(),this._slider._updateDimensions(),this._slider.step||this._updateThumbUIByPointerEvent(e,{withAnimation:!0}),this.disabled||(this._handleValueCorrection(e),this.dragStart.emit({source:this,parent:this._slider,value:this.value})))}_handleValueCorrection(e){this._skipUIUpdate=!0,setTimeout(()=>{this._skipUIUpdate=!1,this._fixValue(e)},0)}_fixValue(e){let i=e.clientX-this._slider._cachedLeft,r=this._slider._cachedWidth,o=0===this._slider.step?1:this._slider.step,a=Math.floor((this._slider.max-this._slider.min)/o),c=Math.round((this._slider._isRtl?1-i/r:i/r)*a)/a*(this._slider.max-this._slider.min)+this._slider.min,d=Math.round(c/o)*o;if(d===this.value)return this._slider._onValueChange(this),void(this._slider.step>0?this._updateThumbUIByValue():this._updateThumbUIByPointerEvent(e,{withAnimation:this._slider._hasAnimation}));this.value=d,this.valueChange.emit(this.value),this._onChangeFn(this.value),this._slider._onValueChange(this),this._slider.step>0?this._updateThumbUIByValue():this._updateThumbUIByPointerEvent(e,{withAnimation:this._slider._hasAnimation})}_onPointerMove(e){!this._slider.step&&this._isActive&&this._updateThumbUIByPointerEvent(e)}_onPointerUp(){this._isActive&&(this._isActive=!1,this.dragEnd.emit({source:this,parent:this._slider,value:this.value}),setTimeout(()=>this._updateWidthInactive()))}_clamp(e){return Math.max(Math.min(e,this._slider._cachedWidth),0)}_calcTranslateXByValue(){return this._slider._isRtl?(1-this.percentage)*this._slider._cachedWidth:this.percentage*this._slider._cachedWidth}_calcTranslateXByPointerEvent(e){return e.clientX-this._slider._cachedLeft}_updateWidthActive(){this._hostElement.style.padding=`0 ${this._slider._inputPadding}px`,this._hostElement.style.width=`calc(100% + ${this._slider._inputPadding}px)`}_updateWidthInactive(){this._hostElement.style.padding="0px",this._hostElement.style.width="calc(100% + 48px)",this._hostElement.style.left="-24px"}_updateThumbUIByValue(e){this.translateX=this._clamp(this._calcTranslateXByValue()),this._updateThumbUI(e)}_updateThumbUIByPointerEvent(e,i){this.translateX=this._clamp(this._calcTranslateXByPointerEvent(e)),this._updateThumbUI(i)}_updateThumbUI(e){this._slider._setTransition(!!e?.withAnimation),this._slider._onTranslateXChange(this)}writeValue(e){this.value=e}registerOnChange(e){this._onChangeFn=e}registerOnTouched(e){this._onTouchedFn=e}setDisabledState(e){this.disabled=e}focus(){this._hostElement.focus()}blur(){this._hostElement.blur()}}return n.\u0275fac=function(e){return new(e||n)(C(ot),C(xe),C(Qt),C(tT))},n.\u0275dir=Me({type:n,selectors:[["input","matSliderThumb",""]],hostAttrs:["type","range",1,"mdc-slider__input"],hostVars:1,hostBindings:function(e,i){1&e&&A("change",function(){return i._onChange()})("input",function(){return i._onInput()})("blur",function(){return i._onBlur()})("focus",function(){return i._onFocus()}),2&e&&Be("aria-valuetext",i._valuetext)},inputs:{value:"value"},outputs:{valueChange:"valueChange",dragStart:"dragStart",dragEnd:"dragEnd"},exportAs:["matSliderThumb"],features:[Vt([wSe,{provide:VY,useExisting:n}])]}),n})(),vN=(()=>{class n extends $u{getSibling(){return this._sibling||(this._sibling=this._slider._getInput(this._isEndThumb?1:2)),this._sibling}getMinPos(){let e=this.getSibling();return!this._isLeftThumb&&e?e.translateX:0}getMaxPos(){let e=this.getSibling();return this._isLeftThumb&&e?e.translateX:this._slider._cachedWidth}_setIsLeftThumb(){this._isLeftThumb=this._isEndThumb&&this._slider._isRtl||!this._isEndThumb&&!this._slider._isRtl}constructor(e,i,r,o){super(e,r,o,i),this._cdr=o,this._isEndThumb=this._hostElement.hasAttribute("matSliderEndThumb"),this._setIsLeftThumb(),this.thumbPosition=this._isEndThumb?2:1}_getDefaultValue(){return this._isEndThumb&&this._slider._isRange?this.max:this.min}_onInput(){super._onInput(),this._updateSibling(),this._isActive||this._updateWidthInactive()}_onNgControlValueChange(){super._onNgControlValueChange(),this.getSibling()?._updateMinMax()}_onPointerDown(e){this.disabled||(this._sibling&&(this._sibling._updateWidthActive(),this._sibling._hostElement.classList.add("mat-mdc-slider-input-no-pointer-events")),super._onPointerDown(e))}_onPointerUp(){super._onPointerUp(),this._sibling&&setTimeout(()=>{this._sibling._updateWidthInactive(),this._sibling._hostElement.classList.remove("mat-mdc-slider-input-no-pointer-events")})}_onPointerMove(e){super._onPointerMove(e),!this._slider.step&&this._isActive&&this._updateSibling()}_fixValue(e){super._fixValue(e),this._sibling?._updateMinMax()}_clamp(e){return Math.max(Math.min(e,this.getMaxPos()),this.getMinPos())}_updateMinMax(){let e=this.getSibling();!e||(this._isEndThumb?(this.min=Math.max(this._slider.min,e.value),this.max=this._slider.max):(this.min=this._slider.min,this.max=Math.min(this._slider.max,e.value)))}_updateWidthActive(){let e=2*this._slider._rippleRadius-2*this._slider._inputPadding;this._hostElement.style.width=`${(this._slider._cachedWidth+this._slider._inputPadding-e)*(this._slider.min<this._slider.max?(this.max-this.min)/(this._slider.max-this._slider.min):1)+e}px`,this._hostElement.style.padding=`0 ${this._slider._inputPadding}px`}_updateWidthInactive(){let e=this.getSibling();if(!e)return;let r=this._isEndThumb?this.value-(this.value-e.value)/2:this.value+(e.value-this.value)/2;this._hostElement.style.width=this._slider._cachedWidth*(this._slider.min<this._slider.max?this._isEndThumb?(this.max-r)/(this._slider.max-this._slider.min):(r-this.min)/(this._slider.max-this._slider.min):1)+24+"px",this._hostElement.style.padding="0px",this._isLeftThumb?(this._hostElement.style.left="-24px",this._hostElement.style.right="auto"):(this._hostElement.style.left="auto",this._hostElement.style.right="-24px")}_updateStaticStyles(){this._hostElement.classList.toggle("mat-slider__right-input",!this._isLeftThumb)}_updateSibling(){let e=this.getSibling();!e||(e._updateMinMax(),this._isActive?e._updateWidthActive():e._updateWidthInactive())}writeValue(e){this.value=e,this._updateWidthInactive(),this._updateSibling()}}return n.\u0275fac=function(e){return new(e||n)(C(ot),C(tT),C(xe),C(Qt))},n.\u0275dir=Me({type:n,selectors:[["input","matSliderStartThumb",""],["input","matSliderEndThumb",""]],exportAs:["matSliderRangeThumb"],features:[Vt([SSe,{provide:HY,useExisting:n}]),Xe]}),n})(),ep=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,De,_a]}),n})();function ESe(n,t){if(1&n){let e=Te();f(0,"mat-slider",11)(1,"input",12),A("valueChange",function(r){return ne(e),ie(w(2).onSliderChange.emit(r))}),g()()}if(2&n){let e=w(2);b("min",0)("max",e.scrollBeginIndexUpperLimit),v(1),b("value",e.scrollBeginIndex)}}function TSe(n,t){if(1&n){let e=Te();f(0,"div",6)(1,"button",7),A("click",function(){return ne(e),ie(w().onNavigateLeft.emit())}),T(2," < "),g(),f(3,"div",8),T(4),g(),f(5,"button",9),A("click",function(){return ne(e),ie(w().onNavigateRight.emit())}),T(6," > "),g(),S(7,ESe,2,3,"mat-slider",10),g()}if(2&n){let e=w();v(4),GM(" ",e.scrollBeginIndex," ~ ",e.scrollBeginIndex+e.displayCount-1," of ",e.numExecutions," "),v(3),b("ngIf",e.scrollBeginIndexUpperLimit>0)}}var DSe=function(n,t,e){return[n,t,e]};function ISe(n,t){if(1&n){let e=Te();f(0,"div",15),A("click",function(){let o=ne(e).index;return ie(w(2).onExecutionDigestClicked.emit(o))}),f(1,"div",16),T(2),g()()}if(2&n){let e=t.$implicit,i=t.index,r=w(2);v(1),Zi("title",e.op_type),b("ngClass",yb(3,DSe,e.is_graph?"func-graph-execution":"",i===r.focusedExecutionDisplayIndex?"focused":"",r.displayFocusedAlertTypes[i]||"")),v(1),Ve(" ",e.short_op_type," ")}}function ASe(n,t){if(1&n&&(f(0,"div",13),S(1,ISe,3,7,"div",14),g()),2&n){let e=w();v(1),b("ngForOf",e.displayExecutionDigests)}}function RSe(n,t){if(1&n&&(Gt(0),k(1,"tf-debugger-v2-execution-data",17),Wt()),2&n){let e=w();v(1),b("focusedExecutionIndex",e.focusedExecutionIndex)}}var UY=(()=>{class n{constructor(){this.activeRunId=null,this.loadingNumExecutions=!1,this.numExecutions=0,this.scrollBeginIndex=0,this.scrollBeginIndexUpperLimit=0,this.pageSize=0,this.displayCount=0,this.displayExecutionDigests=[],this.displayFocusedAlertTypes=[],this.focusedExecutionIndex=null,this.focusedExecutionDisplayIndex=null,this.focusedExecutionData=null,this.onNavigateLeft=new F,this.onNavigateRight=new F,this.onExecutionDigestClicked=new F,this.onSliderChange=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["timeline-component"]],inputs:{activeRunId:"activeRunId",loadingNumExecutions:"loadingNumExecutions",numExecutions:"numExecutions",scrollBeginIndex:"scrollBeginIndex",scrollBeginIndexUpperLimit:"scrollBeginIndexUpperLimit",pageSize:"pageSize",displayCount:"displayCount",displayExecutionDigests:"displayExecutionDigests",displayFocusedAlertTypes:"displayFocusedAlertTypes",focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionDisplayIndex:"focusedExecutionDisplayIndex",focusedExecutionData:"focusedExecutionData"},outputs:{onNavigateLeft:"onNavigateLeft",onNavigateRight:"onNavigateRight",onExecutionDigestClicked:"onExecutionDigestClicked",onSliderChange:"onSliderChange"},decls:9,vars:4,consts:[[1,"timeline-title"],[1,"execution-count"],[1,"top-level-executions"],["class","navigation-section",4,"ngIf"],["class","execution-timeline",4,"ngIf"],[4,"ngIf"],[1,"navigation-section"],["mat-button","",1,"navigation-button-left",3,"click"],[1,"navigation-position-info"],["mat-button","",1,"navigation-button-right",3,"click"],["class","timeline-slider","step","1",3,"min","max",4,"ngIf"],["step","1",1,"timeline-slider",3,"min","max"],["matSliderThumb","",3,"value","valueChange"],[1,"execution-timeline"],[3,"click",4,"ngFor","ngForOf"],[3,"click"],[1,"execution-digest",3,"ngClass","title"],[3,"focusedExecutionIndex"]],template:function(e,i){1&e&&(f(0,"div")(1,"div",0),T(2," Python Execution Timeline "),f(3,"span",1),T(4),g()(),f(5,"div",2),S(6,TSe,8,4,"div",3),S(7,ASe,2,1,"div",4),S(8,RSe,2,1,"ng-container",5),g()()),2&e&&(v(4),Ve(" (",i.numExecutions,") "),v(2),b("ngIf",i.numExecutions),v(1),b("ngIf",i.numExecutions),v(1),b("ngIf",null!==i.activeRunId&&null!==i.focusedExecutionIndex))},dependencies:[wn,nn,Ne,BY,ki,Ju,$u],styles:[".execution-digest[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  color: #425066;\n  display: inline-block;\n  font-size: 10px;\n  height: 15px;\n  padding: 1px;\n  text-align: center;\n  vertical-align: middle;\n  width: 12px;\n}\n\n.execution-digest.func-graph-execution[_ngcontent-%COMP%] {\n  background-color: #c7dbf5;\n  color: #4e5664;\n  text-decoration: underline;\n}\n\n.execution-digest.focused[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-digest.InfNanAlert[_ngcontent-%COMP%] {\n  background-color: #e52592;\n  color: #fff;\n}\n\n\n.execution-digest[_ngcontent-%COMP%]:hover {\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-timeline[_ngcontent-%COMP%] {\n  display: flex;\n  overflow-x: hidden;\n  white-space: nowrap;\n  width: 100%;\n  margin-top: 5px;\n  margin-bottom: 5px;\n}\n\n.timeline-slider[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 48px;\n  left: 340px; \n  padding: 0;\n  position: absolute;\n  right: 40px;\n  --mdc-slider-handle-width: 80px;\n  --mdc-slider-handle-height: 16px;\n  --mdc-slider-handle-shape: 5px;\n}\n\n  .mat-mdc-focus-indicator {\n  display: none;\n}\n\n.navigation-position-info[_ngcontent-%COMP%] {\n  display: inline-flex;\n  font-size: 14px;\n  line-height: normal;\n  max-width: 200px;\n  padding-left: 10px;\n  padding-right: 10px;\n  text-align: center;\n  vertical-align: middle;\n}\n\n.navigation-section[_ngcontent-%COMP%] {\n  height: 48px;\n  line-height: 48px;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}"],changeDetection:0}),n})(),kSe=["__forward_","__backward_","__inference_"],jY=(()=>{class n{constructor(e){this.store=e,this.activeRunId$=this.store.pipe(un($o)),this.loadingNumExecutions$=this.store.pipe(un(W(qE,i=>i.state==Re.LOADING))),this.scrollBeginIndex$=this.store.pipe(un(hy)),this.scrollBeginIndexUpperLimit$=this.store.pipe(un(W(Zu,Hg,(i,r)=>Math.max(0,i-r)))),this.pageSize$=this.store.pipe(un(Vg)),this.displayCount$=this.store.pipe(un(Hg)),this.displayExecutionDigests$=this.store.pipe(un(W($X,i=>i.map(r=>function(n,t=1){if(!n)return{op_type:"(N/A)",short_op_type:"..",is_graph:!1};let e=kSe.filter(i=>n.op_type.startsWith(i));if(e.length){let i=n.op_type.slice(e[0].length);return{op_type:n.op_type,short_op_type:i.slice(0,t),is_graph:!0}}return{op_type:n.op_type,short_op_type:n.op_type.slice(0,t),is_graph:!1}}(r))))),this.displayFocusedAlertTypes$=this.store.pipe(un(lY)),this.focusedExecutionIndex$=this.store.pipe(un(pN)),this.focusedExecutionDisplayIndex$=this.store.pipe(un(cY)),this.numExecutions$=this.store.pipe(un(Zu))}onNavigateLeft(){this.store.dispatch(Ig())}onNavigateRight(){this.store.dispatch(Ag())}onExecutionDigestClicked(e){this.store.dispatch(Pg({displayIndex:e}))}onSliderChange(e){this.store.dispatch(Rg({index:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2-timeline"]],decls:12,vars:33,consts:[[3,"activeRunId","loadingNumExecutions","numExecutions","scrollBeginIndex","scrollBeginIndexUpperLimit","pageSize","displayCount","displayExecutionDigests","displayFocusedAlertTypes","focusedExecutionIndex","focusedExecutionDisplayIndex","onNavigateLeft","onNavigateRight","onExecutionDigestClicked","onSliderChange"]],template:function(e,i){1&e&&(f(0,"timeline-component",0),A("onNavigateLeft",function(){return i.onNavigateLeft()})("onNavigateRight",function(){return i.onNavigateRight()})("onExecutionDigestClicked",function(o){return i.onExecutionDigestClicked(o)})("onSliderChange",function(o){return i.onSliderChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),U(10,"async"),U(11,"async"),g()),2&e&&b("activeRunId",G(1,11,i.activeRunId$))("loadingNumExecutions",G(2,13,i.loadingNumExecutions$))("numExecutions",G(3,15,i.numExecutions$))("scrollBeginIndex",G(4,17,i.scrollBeginIndex$))("scrollBeginIndexUpperLimit",G(5,19,i.scrollBeginIndexUpperLimit$))("pageSize",G(6,21,i.pageSize$))("displayCount",G(7,23,i.displayCount$))("displayExecutionDigests",G(8,25,i.displayExecutionDigests$))("displayFocusedAlertTypes",G(9,27,i.displayFocusedAlertTypes$))("focusedExecutionIndex",G(10,29,i.focusedExecutionIndex$))("focusedExecutionDisplayIndex",G(11,31,i.focusedExecutionDisplayIndex$))},dependencies:[UY,ct],encapsulation:2,changeDetection:0}),n})();function NSe(n,t){1&n&&k(0,"tf-debugger-v2-inactive")}function LSe(n,t){1&n&&(f(0,"div",3),k(1,"tf-debugger-v2-alerts"),f(2,"div",4),k(3,"tf-debugger-v2-timeline")(4,"tf-debugger-v2-graph"),g(),k(5,"tf-debugger-v2-graph-executions"),g(),f(6,"div",5),k(7,"tf-debugger-v2-source-files")(8,"tf-debugger-v2-stack-trace"),g())}var GY=(()=>{class n{constructor(){this.runs={},this.runIds=[],this.activeRunId=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["debugger-component"]],inputs:{runs:"runs",runIds:"runIds",activeRunId:"activeRunId"},decls:4,vars:2,consts:[[1,"debugger-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[1,"top-section"],[1,"top-center-section"],[1,"bottom-section"]],template:function(e,i){if(1&e&&(f(0,"div",0),S(1,NSe,1,0,"tf-debugger-v2-inactive",1),S(2,LSe,9,0,"ng-template",null,2,jt),g()),2&e){let r=st(3);v(1),b("ngIf",0===i.runIds.length)("ngIfElse",r)}},dependencies:[gY,Ne,vY,CY,wY,kY,FY,jY],styles:[".bottom-section[_ngcontent-%COMP%]{box-sizing:border-box;border-top:1px solid #ebebeb;display:flex;flex-grow:1;height:34%;padding-top:6px}body.dark-mode[_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%]{border-top:1px solid #555}.debugger-container[_ngcontent-%COMP%]{box-sizing:border-box;height:100%;overflow:hidden}.top-section[_ngcontent-%COMP%]{box-sizing:border-box;display:flex;flex-grow:1;height:66%;padding:6px 0}tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #ebebeb;display:inline-block;margin-right:10px;min-width:160px;width:calc(15% - 11px)}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #555}tf-debugger-v2-graph-executions[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;min-width:540px;width:540px}tf-debugger-v2-source-files[_ngcontent-%COMP%]{display:inline-block;height:100%;width:70%}tf-debugger-v2-stack-trace[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;height:100%;min-width:540px;width:540px}.top-center-section[_ngcontent-%COMP%]{display:inline-block;overflow:auto;width:55%}tf-debugger-v2-timeline[_ngcontent-%COMP%]{display:block}tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;display:block;margin-top:5px}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #555}"],changeDetection:0}),n})(),WY=(()=>{class n{constructor(e){this.store=e,this.runs$=this.store.pipe(un(Nh)),this.runsIds$=this.store.pipe(un(W(Nh,i=>Object.keys(i)))),this.activeRunId$=this.store.pipe(un($o))}ngOnInit(){this.store.dispatch(ME())}ngOnDestroy(){this.store.dispatch(wE())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["tf-debugger-v2"]],decls:4,vars:9,consts:[[3,"runs","runIds","activeRunId"]],template:function(e,i){1&e&&(k(0,"debugger-component",0),U(1,"async"),U(2,"async"),U(3,"async")),2&e&&b("runs",G(1,3,i.runs$))("runIds",G(2,5,i.runsIds$))("activeRunId",G(3,7,i.activeRunId$))},dependencies:[GY,ct],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"]}),n})(),iT="debugger-v2";function yN(n,t,e,i,r){if(e<=0||!Number.isInteger(e))throw new Error(`Invalid pageSize: ${e}`);if(t>i)throw new Error(`end index (${t}) exceeds total number of items (${i})`);if(t-n>e)throw new Error("begin-end span exceeds page size, which is not allowed");let o=[],a=Math.floor(n/e);(!(a in r)||r[a]<e&&a*e+r[a]<i)&&o.push(a);let s=Math.floor((t-1)/e);return s!==a&&(!(s in r)||s*e+r[s]<t&&t<i)&&o.push(s),o}var YY=(()=>{class n{onDebuggerDataPoll(){return this.actions$.pipe(Zn(ME),Jn(e=>function(n,t,e){return n.pipe(function(n){return Yt((t,e)=>{let i,o,r=!1,a=!1,s=!1,l=()=>s&&a&&(e.complete(),!0),d=()=>{s=!1,i=t.subscribe(Ht(e,void 0,()=>{s=!0,!l()&&(o||(o=new Ee,n(o).subscribe(Ht(e,()=>{i?d():r=!0},()=>{a=!0,l()}))),o).next()})),r&&(i.unsubscribe(),i=null,r=!1,d())};d()})}(i=>i.pipe(It(t),Hm(([,r])=>rs(r)))),it(e),q(()=>{}))}($t(e),this.store.select(YX).pipe(q(i=>function(n){return n>6e4?6e4:n>4e3?n:2e3}(i))),this.actions$.pipe(Zn(wE)))),Dt(()=>this.store.dispatch(sy())),q(()=>{}))}onCoreReload(){return tn(this.actions$.pipe(Zn(Ba,ma)),this.actions$.pipe(Zn(yc)).pipe(It(this.store.select(oN)),Oe(([,e])=>e.state===Re.NOT_LOADED||e.state===Re.FAILED&&null===e.lastLoadedTimeInMs))).pipe(It(this.store.select(Zo)),Oe(([,e])=>e===iT),Dt(()=>this.store.dispatch(sy())),q(()=>{}))}loadDebuggerRuns(e){return e.pipe(It(this.store.select(oN)),Oe(([,{state:i}])=>i!==Re.LOADING),Dt(()=>this.store.dispatch(SE())),xn(()=>this.dataSource.fetchRuns().pipe(Dt(i=>{this.store.dispatch(EE({runs:i}))}),q(()=>{}))))}createNumExecutionLoader(e){return e.pipe(It(this.store.select(Nh),this.store.select(qE)),Oe(([,i,r])=>Object.keys(i).length>0&&r.state!==Re.LOADING),Dt(()=>this.store.dispatch(IE())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchExecutionDigests(r,0,0).pipe(Dt(s=>{this.store.dispatch(AE({numExecutions:s.num_digests}))}),q(()=>{}))}))}createNumGraphExecutionLoader(e){return e.pipe(It(this.store.select(Nh),this.store.select(eY)),Oe(([,i,r])=>Object.keys(i).length>0&&r.state!==Re.LOADING),Dt(()=>this.store.dispatch(OE())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchGraphExecutionDigests(r,0,0).pipe(Dt(s=>{this.store.dispatch(FE({numGraphExecutions:s.num_digests}))}),q(()=>{}))}))}createNumAlertsAndBreakdownLoader(e){return e.pipe(It(this.store.select(Nh),this.store.select(aN)),Oe(([,i,r])=>Object.keys(i).length>0&&r.state!==Re.LOADING),Dt(()=>this.store.dispatch(ly())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchAlerts(r,0,0).pipe(Dt(s=>{this.store.dispatch(TE({numAlerts:s.num_alerts,alertsBreakdown:s.alerts_breakdown}))}),q(()=>{}))}))}createInitialExecutionDetector(e){return e.pipe(It(this.store.select(Zu),this.store.select(py)),Oe(([,i,r])=>i>0&&0===Object.keys(r.pageLoadedSizes).length),q(()=>{}))}createInitialExecutionDigest(e){return e.pipe(It(this.store.select(Zu),this.store.select($o),this.store.select(Vg)),Oe(([,,i])=>null!==i),q(([,i,r,o])=>({begin:0,end:Math.min(i,o),runId:r})))}onExecutionScroll(){return this.actions$.pipe(Zn(Ig,Ag,Rg),It(this.store.select($o),this.store.select(hy),this.store.select(Zu),this.store.select(Hg),this.store.select(Vg)),Oe(([e])=>null!==e),q(([,e,i,r,o,a])=>({runId:e,begin:i,end:Math.min(r,i+o),pageSize:a})),It(this.store.select(py)),q(([e,i])=>({props:e,loaded:i,missingPages:yN(e.begin,e.end,e.pageSize,i.numExecutions,i.pageLoadedSizes)})),Oe(({missingPages:e})=>e.length>0),q(({props:e,loaded:i,missingPages:r})=>{let{runId:o,pageSize:a}=e;return{begin:r[0]*a,end:Math.min(i.numExecutions,(r[r.length-1]+1)*a),runId:o}}))}createExecutionDigestLoader(e){return e.pipe(It(this.store.select(py)),Oe(([{begin:i,end:r},o])=>r>i&&!function(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return-1!==n.findIndex(i=>i.begin>=t&&i.end<=e)}(o.loadingRanges,i,r)),Dt(([{begin:i,end:r}])=>{this.store.dispatch(RE({begin:i,end:r}))}),xn(([{runId:i,begin:r,end:o}])=>this.dataSource.fetchExecutionDigests(i,r,o).pipe(Dt(a=>{this.store.dispatch(PE(a))}),q(()=>{}))))}onExecutionDigestFocused(){return this.actions$.pipe(Zn(Pg),It(this.store.select($o),this.store.select(hN),this.store.select(hy)),q(([e,i,r,o])=>({activeRunId:i,loadedExecutionData:r,focusIndex:o+e.displayIndex})))}createExecutionDataAndStackFramesLoader(e){return e.pipe(Oe(({activeRunId:i,loadedExecutionData:r,focusIndex:o})=>null!==i&&null!==o&&void 0===r[o]),xn(({activeRunId:i,focusIndex:r})=>{let o=r,a=o+1;return this.dataSource.fetchExecutionData(i,o,a).pipe(Dt(s=>{this.store.dispatch(kE(s))}),q(s=>({executionData:s,begin:o,end:a})))}),q(({executionData:i})=>i.executions[0]),It(this.store.select($o),this.store.select(mN)),Oe(([i,r,o])=>{if(null===r)return!1;for(let a of i.stack_frame_ids)if(void 0===o[a])return!0;return!1}),xn(([i,r])=>{let o=i.stack_frame_ids;return this.dataSource.fetchStackFrames(r,o).pipe(Dt(a=>{let s={};for(let l=0;l<o.length;++l)s[o[l]]=a.stack_frames[l];this.store.dispatch(cy({stackFrames:s}))}),q(()=>{}))}))}onGraphExecutionScroll(){return this.actions$.pipe(Zn(kg),Cr(100),It(this.store.select($o),this.store.select(my),this.store.select(tY)),Oe(([,e,i])=>null!==e&&i>0),q(([,e,i,r])=>({runId:e,numGraphExecutions:i,scrollBeginIndex:r})),It(this.store.select(iY),this.store.select(nY),this.store.select(rY),this.store.select(oY)),q(([{runId:e,numGraphExecutions:i,scrollBeginIndex:r},o,a,s,l])=>{let c=yN(r,Math.min(r+a,i),o,i,l);return c=c.filter(d=>-1===s.indexOf(d)),{runId:e,missingPages:c,pageSize:o,numGraphExecutions:i}}))}loadGraphExecutionPages(e){return e.pipe(Oe(({missingPages:i})=>i.length>0),Dt(({missingPages:i})=>{i.forEach(r=>{this.store.dispatch(NE({pageIndex:r}))})}),xn(({runId:i,missingPages:r,pageSize:o,numGraphExecutions:a})=>{let s=r[0]*o,l=Math.min((r[r.length-1]+1)*o,a);return this.dataSource.fetchGraphExecutionData(i,s,l).pipe(Dt(c=>{this.store.dispatch(LE(c))}),q(()=>{}))}))}loadGraphOpInfo(){return this.actions$.pipe(Zn(Fg,Og),It(this.store.select($o),this.store.select(dY)),Oe(([e,i,r])=>{let{graph_id:o,op_name:a}=e;return!(null===i||void 0!==r[o]&&r[o].has(a)&&(r[o].get(a)===Re.LOADING||r[o].get(a)===Re.LOADED))}),Dt(([{graph_id:e,op_name:i}])=>this.store.dispatch(BE({graph_id:e,op_name:i}))),xn(([e,i])=>{let{graph_id:r,op_name:o}=e;return this.dataSource.fetchGraphOpInfo(i,r,o).pipe(Dt(a=>this.store.dispatch(VE({graphOpInfoResponse:a}))),q(a=>({runId:i,stackFrameIds:a.stack_frame_ids})))}))}loadGraphOpStackFrames(e){return e.pipe(It(this.store.select(mN)),q(([{runId:i,stackFrameIds:r},o])=>({runId:i,missingStackFrameIds:r.filter(s=>void 0===o[s])})),Oe(({runId:i,missingStackFrameIds:r})=>null!==i&&r.length>0),xn(({runId:i,missingStackFrameIds:r})=>this.dataSource.fetchStackFrames(i,r).pipe(Dt(o=>{let a={};for(let s=0;s<r.length;++s)a[r[s]]=o.stack_frames[s];this.store.dispatch(cy({stackFrames:a}))}),q(()=>{}))))}onAlertTypeFocused(){return this.actions$.pipe(Zn(Dg),It(this.store.select($o),this.store.select(WE),this.store.select(ZX),this.store.select(KX),this.store.select(aN)),Oe(([,e,i,r,o,a])=>null!==e&&null!==i&&r>0&&(null===o||Object.keys(o).length<r)&&a.state!==Re.LOADING),Dt(()=>this.store.dispatch(ly())),xn(([,e,i])=>this.dataSource.fetchAlerts(e,0,-1,i)),Dt(({num_alerts:e,alerts_breakdown:i,alert_type:r,begin:o,end:a,alerts:s})=>{this.store.dispatch(DE({numAlerts:e,alertsBreakdown:i,alertType:r,begin:o,end:a,alerts:s}))}))}fetchExecutionDigestsForAlertTypeFocus(e){return e.pipe(It(this.store.select(Vg),this.store.select(Hg),this.store.select(Zu),this.store.select(py),this.store.select($o)),q(([i,r,o,a,s,l])=>{let d=i.alerts[0].execution_index,u=yN(Math.max(0,d-Math.floor(o/2)),Math.min(d+Math.floor(o/2),a),r,a,s.pageLoadedSizes);return 0===u.length?{runId:l,begin:0,end:0}:{runId:l,begin:u[0]*r,end:Math.min(s.numExecutions,(u[u.length-1]+1)*r)}}))}loadSourceFileList(e){return e.pipe(It(this.store.select($o),this.store.select(pY)),Oe(([,i,r])=>null!==i&&r.state!==Re.LOADING),Dt(()=>this.store.dispatch(HE())),xn(([,i])=>this.dataSource.fetchSourceFileList(i).pipe(Dt(r=>{let o=[];r.forEach(([a,s])=>{o.push({host_name:a,file_path:s})}),this.store.dispatch(zE({sourceFiles:o}))}),q(()=>{}))))}onSourceFileFocused(){return this.actions$.pipe(Zn(Ng),It(this.store.select($o),this.store.select(fN),this.store.select(QE)),q(([e,i,r,o])=>({runId:i,stackFrame:e.stackFrame,fileIndex:r,fileContent:o})),Oe(({runId:e,fileContent:i})=>null!==e&&null!==i&&i.loadState===Re.NOT_LOADED),Dt(({stackFrame:e})=>this.store.dispatch(UE({host_name:e.host_name,file_path:e.file_path}))),xn(({fileIndex:e,runId:i})=>this.dataSource.fetchSourceFile(i,e).pipe(Dt(r=>{this.store.dispatch(jE(r))}),q(()=>{}))))}constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadData$=_r(()=>{let o=this.loadDebuggerRuns(tn(this.onDebuggerDataPoll(),this.onCoreReload())).pipe(Ta()),a=this.loadSourceFileList(o),s=this.createNumExecutionLoader(o),l=this.createNumAlertsAndBreakdownLoader(o),c=this.onAlertTypeFocused(),d=this.fetchExecutionDigestsForAlertTypeFocus(c),u=this.createInitialExecutionDetector(s).pipe(Ta()),p=this.createExecutionDigestLoader(tn(this.onExecutionScroll(),this.createInitialExecutionDigest(u),d)),h=this.createExecutionDataAndStackFramesLoader(tn(this.onExecutionDigestFocused(),u.pipe(It(this.store.select($o),this.store.select(hN)),q(([,x,R])=>({activeRunId:x,loadedExecutionData:R,focusIndex:0})))));return tn(l,p,h,this.createNumGraphExecutionLoader(o),a,this.onSourceFileFocused(),this.loadGraphExecutionPages(this.onGraphExecutionScroll()),this.loadGraphOpStackFrames(this.loadGraphOpInfo())).pipe(q(()=>({})))},{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(CE))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),QY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),ZY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),rT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),KY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,rT,Cd]}),n})(),JY=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),tp=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),oT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,tp]}),n})(),$Y=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,oT]}),n})(),eQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,oT]}),n})(),tQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,rT]}),n})(),nQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,tQ,Kn,ep]}),n})(),iQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[QY,De,Qs,KY,ZY,JY,$Y,eQ,UX,nQ,wr.forFeature(dy,XX),to.forFeature([YY]),Oc.forPlugin(iT,WY)]}),n})(),aT=fe("[Metrics] Metrics Settings Pane Closed"),sT=fe("[Metrics] Metrics Settings Pane Toggled"),lT=fe("[Metrics] Slide out settings menu toggled"),cT=fe("[Metrics] User requested to open the slide out menu",{_as:"props",_p:void 0}),dT=fe("[Metrics] User changed the tab in the table editor",{_as:"props",_p:void 0}),uT=fe("[Metrics] Slide out settings menu closed"),pT=fe("[Metrics] Metrics Tag Metadata Requested"),hT=fe("[Metrics] Metrics Tag Metadata Loaded",{_as:"props",_p:void 0}),mT=fe("[Metrics] Metrics Tag Metadata Failed"),fT=fe("[Metrics] Metrics Card State Updated",{_as:"props",_p:void 0}),zg=fe("[Metrics] Metrics Card Full Size Toggled",{_as:"props",_p:void 0}),gT=fe("[Metrics] Metrics Settings Change Tooltip",{_as:"props",_p:void 0}),_T=(fe("[Metrics] Metrics Settings Toggle Show Data Download"),fe("[Metrics] Metrics Setting Toggle Ignore Outlier")),bT=fe("[Metrics] Metrics Setting Change X Axis Type",{_as:"props",_p:void 0}),vT=fe("[Metrics] Metrics Setting Change Card Width",{_as:"props",_p:void 0}),yT=fe("[Metrics] Metrics Setting Reset Card Width"),xT=fe("[Metrics] Metrics Setting Change Scalar Smoothing",{_as:"props",_p:void 0}),CT=fe("[Metrics] Metrics Setting Partition Non Monotonic X Toggled"),MT=fe("[Metrics] Metrics Setting Change Image Brightness",{_as:"props",_p:void 0}),wT=fe("[Metrics] Metrics Setting Change Image Contrast",{_as:"props",_p:void 0}),ST=fe("[Metrics] Image Brightness Setting Reset"),ET=fe("[Metrics] Image Contrast Setting Reset"),TT=fe("[Metrics] Metrics Setting Toggle Image Show Actual Size"),DT=fe("[Metrics] Metrics Setting Change Histogram Mode",{_as:"props",_p:void 0}),IT=fe("[Metrics] Multiple Time Series Requested",{_as:"props",_p:void 0}),AT=fe("[Metrics] Fetch Time Series Request Failed",{_as:"props",_p:void 0}),RT=fe("[Metrics] Fetch Time Series Response Loaded",{_as:"props",_p:void 0}),Ug=fe("[Metrics] Card Visibility Changed",{_as:"props",_p:void 0}),PT=fe("[Metrics] Card Step Slider Changed",{_as:"props",_p:void 0}),kT=fe("[Metrics] Tag Filter Changed",{_as:"props",_p:void 0}),OT=fe("[Metrics] Metrics Tag Group Expansion Changed",{_as:"props",_p:void 0}),np=fe("[Metrics] Card Pin State Toggled",{_as:"props",_p:void 0}),FT=fe("[Metrics] Toggle Visible Plugin",{_as:"props",_p:void 0}),NT=fe("[Metrics] Toggle Show All Plugins"),Hh=fe("[Metrics] Time Selection Changed",{_as:"props",_p:void 0}),_y=fe("[Metrics] Card User View Box Changed",{_as:"props",_p:void 0}),LT=fe("[Metrics] Linked Time Enable Toggle",{_as:"props",_p:void 0}),rQ=fe("[Metrics] Sorting Data Table By Header",{_as:"props",_p:void 0}),jg=fe("[Metrics] Data table columns order changed",{_as:"props",_p:void 0}),Gg=fe("[Metrics] Data table column toggled in edit menu or delete button clicked",{_as:"props",_p:void 0}),Td=fe("[Metrics] Time Selector Enable Toggle",{_as:"props",_p:void 0}),BT=fe("[Metrics] Range Selection Toggled",{_as:"props",_p:void 0}),oQ=fe("[Metrics] Hide Empty Cards Changed"),VT=fe("[Metrics] Unresolved Pinned Cards From Local Storage Added",{_as:"props",_p:void 0}),Wg=fe("[Metrics] Clear all pinned cards"),zh=fe("[Metrics] Enable Saving Pins Toggled");function by(n,t){let e={};for(let i of Object.keys(n))e[i]=t(n[i],i);return e}var Qa=(()=>(function(n){n.NONE="no affordance",n.EXTENDED_LINE="extendedLine",n.FOB="fob",n.FOB_REMOVED="fobRemoved",n.FOB_TEXT="fobText",n.HISTOGRAM_CLICK_TO_RANGE="histogramClickToRange",n.FOB_ADDED="fobAdded"}(Qa||(Qa={})),Qa))(),Za=(()=>(function(n){n.NONE="no toggle affordance",n.FOB_DESELECT="fobDeselect",n.CHECK_BOX="checkBox"}(Za||(Za={})),Za))(),va=(()=>(function(n){n[n.HORIZONTAL=0]="HORIZONTAL",n[n.VERTICAL=1]="VERTICAL"}(va||(va={})),va))();function HT(n){let t=new Map,e=n.slice().sort((i,r)=>vy(i.tag,r.tag));for(let i of e){let r=jSe(i.tag);t.has(r)||t.set(r,{groupName:r,items:[]}),t.get(r).items.push(i)}return[...t.values()]}function jSe(n){return n.split("/",1)[0]}function vy(n,t){let e=0,i=0;for(;;){if(e===n.length)return i===t.length?0:-1;if(i===t.length)return 1;if(Uh(n[e])&&Uh(t[i])){let r=e,o=i;e=aQ(n,e+1),i=aQ(t,i+1);let a=Number(n.slice(r,e)),s=Number(t.slice(o,i));if(a<s)return-1;if(a>s)return 1}else{if(xN(n[e])){if(!xN(t[i]))return-1}else{if(xN(t[i]))return 1;if(n[e]<t[i])return-1;if(n[e]>t[i])return 1}e++,i++}}}function aQ(n,t){let e;var o;(o=e||(e={}))[o.NATURAL=0]="NATURAL",o[o.REAL=1]="REAL",o[o.EXPONENT_SIGN=2]="EXPONENT_SIGN",o[o.EXPONENT=3]="EXPONENT";let i=e.NATURAL,r=t;for(;r<n.length;r++)if(i===e.NATURAL){if("."===n[r])i=e.REAL;else if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Uh(n[r]))break}else if(i===e.REAL){if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!Uh(n[r]))break}else if(i===e.EXPONENT_SIGN){if(!Uh(n[r])&&"+"!==n[r]&&"-"!==n[r])break;i=e.EXPONENT}else if(i===e.EXPONENT&&!Uh(n[r]))break;return r}function Uh(n){return"0"<=n&&n<="9"}function xN(n){return"/"===n||Uh(n)}function CN(n,t,e){let{plugin:i,tag:r,runId:o,sample:a}=t[n],s=fd(e,i,r,a);if(s){if(null!==o&&s.runToSeries.hasOwnProperty(o)){let c=s.runToSeries[o].length;return c>0?c-1:null}let l=Object.values(s.runToSeries).map(c=>c.length);if(l.length)return Math.max(...l)-1}return null}function WSe(n,t,e,i){let r={...t};for(let o in n){if(!n.hasOwnProperty(o))continue;let a=CN(o,n,e);if(null===a)continue;let s=t.hasOwnProperty(o)?t[o].index:null,l=CN(o,n,i);(null!==s&&s>a||null===s||null!==s&&s===l)&&(r[o]={index:a,isClosest:!1})}return r}function sQ(n){let t=by(n.runToLoadState,e=>e===Re.LOADING?Re.LOADING:Re.NOT_LOADED);return{...n,runToLoadState:t}}function lQ(n,t,e,i){return JSON.stringify([n,t,e||"",i])}var{initialState:dQ,reducers:qSe}=_h({tagMetadataLoadState:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardToPinnedCopy:new Map,cardToPinnedCopyCache:new Map,pinnedCardToOriginal:new Map,unresolvedImportedPinnedCards:[],cardMetadataMap:{},cardStateMap:{},cardStepIndex:{},tagFilter:"",tagGroupExpanded:new Map,linkedTimeSelection:null,linkedTimeEnabled:!1,stepSelectorEnabled:!0,rangeSelectionEnabled:!1,singleSelectionHeaders:[{type:gt.RUN,name:"run",displayName:"Run",enabled:!0,removable:!1,sortable:!0,movable:!1},{type:gt.SMOOTHED,name:"smoothed",displayName:"Smoothed",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.VALUE,name:"value",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.STEP,name:"step",displayName:"Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.RELATIVE_TIME,name:"relative",displayName:"Relative",enabled:!0,removable:!0,sortable:!0,movable:!0}],rangeSelectionHeaders:[{type:gt.RUN,name:"run",displayName:"Run",enabled:!0,removable:!1,sortable:!0,movable:!0},{type:gt.MIN_VALUE,name:"min",displayName:"Min",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.MAX_VALUE,name:"max",displayName:"Max",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.START_VALUE,name:"start",displayName:"Start Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.END_VALUE,name:"end",displayName:"End Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.VALUE_CHANGE,name:"valueChange",displayName:"Value",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.PERCENTAGE_CHANGE,name:"percentageChange",displayName:"%",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.START_STEP,name:"startStep",displayName:"Start Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.END_STEP,name:"endStep",displayName:"End Step",enabled:!0,removable:!0,sortable:!0,movable:!0},{type:gt.STEP_AT_MAX,name:"stepAtMax",displayName:"Step At Max",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:gt.STEP_AT_MIN,name:"stepAtMin",displayName:"Step At Min",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:gt.MEAN,name:"mean",displayName:"Mean",enabled:!1,removable:!0,sortable:!0,movable:!0},{type:gt.RAW_CHANGE,name:"rawChange",displayName:"Raw",enabled:!1,removable:!0,sortable:!0,movable:!0}],filteredPluginTypes:new Set,stepMinMax:{min:1/0,max:-1/0}},{isSettingsPaneOpen:!0,isSlideoutMenuOpen:!1,lastPinnedCardTime:0,tableEditorSelectedTab:Wr.SINGLE,timeSeriesData:{scalars:{},histograms:{},images:{}},settings:$S,settingOverrides:{},visibleCardMap:new Map,previousCardInteractions:{tagFilters:[],pins:[],clicks:[]},newCardInteractions:{tagFilters:[],pins:[],clicks:[]}},(n,t,e)=>Vo(t,e)?n:{...n,tagMetadataLoadState:{state:Re.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardMetadataMap:{},visibleCardMap:new Map}),MN=dQ,XSe=gr(dQ,ye(fu,(n,{routeKind:t,partialState:e})=>{if(t!==Cn.EXPERIMENT&&t!==Cn.COMPARE_EXPERIMENT)return n;let i=new Set;for(let d of n.pinnedCardToOriginal.keys()){let{plugin:u,tag:p,runId:h,sample:m}=n.cardMetadataMap[d];i.add(lQ(u,p,h,m))}let r=e,o=[];for(let d of[...n.unresolvedImportedPinnedCards,...r.metrics.pinnedCards]){let u=lQ(d.plugin,d.tag,d.runId,d.sample);i.has(u)||(i.add(u),o.push(d))}let a=GF(o,n.cardList,n.cardMetadataMap,n.cardToPinnedCopy,n.cardToPinnedCopyCache,n.pinnedCardToOriginal,n.cardStepIndex,n.cardStateMap),s=r.metrics.smoothing,l=n.settingOverrides;if(Number.isFinite(s)&&null!==s){let d=Math.max(0,Math.min(.999,Number(s.toPrecision(3))));l={...n.settingOverrides,scalarSmoothing:d}}let c={...n,...a,settingOverrides:l};return null!==r.metrics.tagFilter&&(c.tagFilter=r.metrics.tagFilter),c}),ye(hs,(n,{partialSettings:t})=>{let e={};t.tooltipSort&&Object.values(oo).includes(t.tooltipSort)&&(e.tooltipSort=t.tooltipSort),"number"==typeof t.timeSeriesCardMinWidth&&(e.cardMinWidth=t.timeSeriesCardMinWidth),"boolean"==typeof t.ignoreOutliers&&(e.ignoreOutliers=t.ignoreOutliers),"number"==typeof t.scalarSmoothing&&(e.scalarSmoothing=t.scalarSmoothing),"boolean"==typeof t.savingPinsEnabled&&(e.savingPinsEnabled=t.savingPinsEnabled);let i=t.timeSeriesSettingsPaneOpened??n.isSettingsPaneOpen,r=t.stepSelectorEnabled??n.stepSelectorEnabled,o=t.rangeSelectionEnabled??n.rangeSelectionEnabled,a=t.linkedTimeEnabled??n.linkedTimeEnabled,s=t.singleSelectionHeaders??n.singleSelectionHeaders,l=t.rangeSelectionHeaders??n.rangeSelectionHeaders;return{...n,isSettingsPaneOpen:i,stepSelectorEnabled:r,rangeSelectionEnabled:o,linkedTimeEnabled:a,singleSelectionHeaders:s,rangeSelectionHeaders:l,settings:{...n.settings,...e}}}),ye(ma,Ba,n=>{let t=n.tagMetadataLoadState.state===Re.LOADING?Re.LOADING:Re.NOT_LOADED,e=by(n.timeSeriesData,(i,r)=>by(i,o=>fs(r)?by(o,a=>sQ(a)):sQ(o)));return{...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:t},timeSeriesData:e}}),ye(pT,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Re.LOADING}})),ye(mT,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Re.FAILED}})),ye(hT,(n,{tagMetadata:t})=>{let e={scalars:cQ(t,An.SCALARS),histograms:cQ(t,An.HISTOGRAMS),images:t[An.IMAGES]},i={},r=function(n){let t=[];for(let e of Object.keys(n)){let r,i=e;if(fs(i)){if(!gs(i))throw new Error("Multi-run, sampled plugin support not yet implemented");{let o=n[i].tagRunSampledInfo;for(let a of Object.keys(o))for(let s of Object.keys(o[a])){let{maxSamplesPerStep:l}=o[a][s];for(let c=0;c<l;c++)t.push({plugin:i,tag:a,runId:s,sample:c,numSample:l})}}}else if(gs(i)){r=n[i].tagToRuns;for(let o of Object.keys(r))for(let a of r[o])t.push({plugin:i,tag:o,runId:a})}else{r=n[i].tagToRuns;for(let o of Object.keys(r))t.push({plugin:i,tag:o,runId:null})}}return t}(e),o=[];for(let h of r){let m=jF(h);i[m]=h,o.push(m)}let a=n.tagGroupExpanded;if(0===n.tagGroupExpanded.size){let m=HT(o.map(_=>({...i[_],cardId:_})).filter(Boolean));a=new Map(n.tagGroupExpanded);for(let _ of m.slice(0,2))a.set(_.groupName,!0)}let{nextCardToPinnedCopy:s,nextPinnedCardToOriginal:l,pinnedCardMetadataMap:c}=function(n,t,e){let i=new Map,r=new Map,o={};return n.forEach((a,s)=>{-1!==e.indexOf(s)&&(i.set(s,a),r.set(a,s),o[a]=t[s])}),{nextCardToPinnedCopy:i,nextPinnedCardToOriginal:r,pinnedCardMetadataMap:o}}(n.cardToPinnedCopyCache,i,o),d={...i,...c},u=function(n,t){let e={};return Object.entries(n).forEach(([i,r])=>{t[i]&&(e[i]=r)}),e}(n.cardStepIndex,d),p=GF(n.unresolvedImportedPinnedCards,o,d,s,n.cardToPinnedCopyCache,l,u,n.cardStateMap);return{...n,...p,tagGroupExpanded:a,tagMetadataLoadState:{state:Re.LOADED,lastLoadedTimeInMs:Date.now()},tagMetadata:e,cardList:o}}),ye(fT,(n,{cardId:t,settings:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],...e},{...n,cardStateMap:i}}),ye(zg,(n,{cardId:t})=>{let e={...n.cardStateMap};return e[t]={...e[t],fullWidth:!e[t]?.fullWidth,tableExpanded:!e[t]?.fullWidth},{...n,cardStateMap:e}}),ye(kT,(n,{tagFilter:t})=>({...n,tagFilter:t})),ye(gT,(n,{sort:t})=>({...n,settingOverrides:{...n.settingOverrides,tooltipSort:t}})),ye(_T,n=>{let t=!(n.settingOverrides.ignoreOutliers??n.settings.ignoreOutliers);return{...n,settingOverrides:{...n.settingOverrides,ignoreOutliers:t}}}),ye(bT,(n,{xAxisType:t})=>({...n,settingOverrides:{...n.settingOverrides,xAxisType:t}})),ye(xT,(n,{smoothing:t})=>({...n,settingOverrides:{...n.settingOverrides,scalarSmoothing:t}})),ye(CT,n=>{let t=!(n.settingOverrides.scalarPartitionNonMonotonicX??n.settings.scalarPartitionNonMonotonicX);return{...n,settingOverrides:{...n.settingOverrides,scalarPartitionNonMonotonicX:t}}}),ye(MT,(n,{brightnessInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageBrightnessInMilli:t}})),ye(wT,(n,{contrastInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageContrastInMilli:t}})),ye(ST,n=>{let{imageBrightnessInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),ye(ET,n=>{let{imageContrastInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),ye(TT,n=>{let t=!(n.settingOverrides.imageShowActualSize??n.settings.imageShowActualSize);return{...n,settingOverrides:{...n.settingOverrides,imageShowActualSize:t}}}),ye(DT,(n,{histogramMode:t})=>({...n,settingOverrides:{...n.settingOverrides,histogramMode:t}})),ye(vT,(n,{cardMinWidth:t})=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:t}})),ye(yT,n=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:null}})),ye(oQ,n=>({...n,settingOverrides:{...n.settingOverrides,hideEmptyCards:!n.settingOverrides.hideEmptyCards}})),ye(zh,n=>{let t=!(n.settingOverrides.savingPinsEnabled??n.settings.savingPinsEnabled);return{...n,settingOverrides:{...n.settingOverrides,savingPinsEnabled:t}}}),ye(IT,(n,{requests:t})=>{if(!t.length)return n;let e={...n.timeSeriesData};for(let i of t){let{plugin:r,tag:o,sample:a}=i;e[r]=e1(e,r,o,a);let s=fd(e,r,o,a),l=NF(i)?[i.runId]:Zf(n.tagMetadata,r,o,a);s.runToLoadState=t1(Re.LOADING,l,s.runToLoadState)}return{...n,timeSeriesData:e}}),ye(AT,(n,{request:t})=>{let e={...n.timeSeriesData},{plugin:i,tag:r,sample:o}=t;e[i]=e1(e,i,r,o);let a=fd(e,i,r,o),s=NF(t)?[t.runId]:Zf(n.tagMetadata,i,r,o);return a.runToLoadState=t1(Re.FAILED,s,a.runToLoadState),{...n,timeSeriesData:e}}),ye(RT,(n,{response:t})=>{let e={...n.stepMinMax},i={...n.cardStateMap},r={...n.timeSeriesData},{plugin:o,tag:a,runId:s,sample:l}=t;r[o]=e1(r,o,a,l);let c=fd(r,o,a,l);if(qS(t)){let u=s?[s]:Zf(n.tagMetadata,o,a,l);c.runToLoadState=t1(Re.FAILED,u,c.runToLoadState)}else{let u=t.runToSeries;c.runToSeries={...c.runToSeries},c.runToLoadState={...c.runToLoadState};for(let p in u)if(u.hasOwnProperty(p)){c.runToSeries[p]=u[p],c.runToLoadState[p]=Re.LOADED;for(let h of u[p])e.min=Math.min(e.min,h.step),e.max=Math.max(e.max,h.step)}}if(t.runToSeries&&t.plugin===An.SCALARS){let u=jF({plugin:o,tag:a,runId:null}),p=function(n){let t=1/0,e=-1/0;return Object.values(n).flat().forEach(i=>{t=Math.min(t,i.step),e=Math.max(e,i.step)}),{minStep:t,maxStep:e}}(c.runToSeries);i[u]={...i[u],dataMinMax:p};let h=n.cardToPinnedCopy.get(u);h&&(i[h]={...i[h],dataMinMax:p})}return{...n,timeSeriesData:r,cardStepIndex:WSe(n.cardMetadataMap,n.cardStepIndex,r,n.timeSeriesData),stepMinMax:e,cardStateMap:i}}),ye(PT,(n,{cardId:t,stepIndex:e})=>{let i=CN(t,n.cardMetadataMap,n.timeSeriesData),r=e;return null===i?r=null:e>i&&(r=i),{...n,cardStepIndex:{...n.cardStepIndex,[t]:{index:r,isClosest:!1}}}}),ye(OT,(n,{tagGroup:t})=>{let e=new Map(n.tagGroupExpanded);return e.set(t,!e.get(t)),{...n,tagGroupExpanded:e}}),ye(Ug,(n,{enteredCards:t,exitedCards:e})=>{if(!t.length&&!e.length)return n;let i=new Map(n.visibleCardMap);return t.forEach(({elementId:r,cardId:o})=>{let a=i.get(r)??null;if(null!==a&&a!==o)throw new Error("A DOM element cannot be reused for more than 1 unique card metadata");i.set(r,o)}),e.forEach(({elementId:r})=>{i.delete(r)}),{...n,visibleCardMap:i}}),ye(np,(n,{cardId:t})=>{let e=n.pinnedCardToOriginal.has(t),i=!e&&!n.cardToPinnedCopy.has(t);if(i&&!n1(n))return n;let r=new Map(n.cardToPinnedCopy),o=new Map(n.cardToPinnedCopyCache),a=new Map(n.pinnedCardToOriginal),s={...n.cardMetadataMap},l={...n.cardStepIndex},c={...n.cardStateMap},d=n.lastPinnedCardTime;if(e){let u=n.pinnedCardToOriginal.get(t);r.delete(u),o.delete(u),a.delete(t),delete s[t],delete l[t],delete c[t]}else if(i){let u=WF(t,r,o,a,l,s,c);r=u.cardToPinnedCopy,o=u.cardToPinnedCopyCache,a=u.pinnedCardToOriginal,s=u.cardMetadataMap,l=u.cardStepIndex,c=u.cardStateMap,d=Date.now()}else{let u=n.cardToPinnedCopy.get(t);r.delete(t),o.delete(t),a.delete(u),delete s[u],delete l[u],delete c[t]}return{...n,cardMetadataMap:s,cardStateMap:c,cardStepIndex:l,cardToPinnedCopy:r,cardToPinnedCopyCache:o,pinnedCardToOriginal:a,lastPinnedCardTime:d}}),ye(LT,n=>{let t=!n.linkedTimeEnabled,e={...n.cardStepIndex},i=n.linkedTimeSelection,r=n.stepSelectorEnabled,o=n.rangeSelectionEnabled;if(t){let{max:a}=n.stepMinMax;i=n.linkedTimeSelection??{start:{step:a===-1/0?0:a},end:null},e=qF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,i),r=t,o=Boolean(i.end)}return{...n,cardStepIndex:e,linkedTimeEnabled:t,linkedTimeSelection:i,stepSelectorEnabled:r,rangeSelectionEnabled:o}}),ye(BT,n=>{let t=!n.rangeSelectionEnabled,e=n.stepSelectorEnabled,i=n.linkedTimeSelection,r=Object.entries(n.cardStateMap).reduce((o,[a,s])=>(o[a]={...s,stepSelectionOverride:Va.NONE,rangeSelectionOverride:Va.NONE},o),{});return t?(e=t,i||(i={start:{step:n.stepMinMax.min},end:{step:n.stepMinMax.max}}),i.end||(i={start:{step:n.stepMinMax.min},end:i.start})):i&&(i={start:i.end??i.start,end:null}),{...n,stepSelectorEnabled:e,rangeSelectionEnabled:t,linkedTimeSelection:i,cardStateMap:r}}),ye(Hh,(n,t)=>{let{cardId:e,timeSelection:i}=t,r=i.start.step,o=i.end?.step,s=n.rangeSelectionEnabled;n.linkedTimeEnabled&&(s=void 0!==o);let l={start:{step:r},end:void 0===o?null:{step:r>o?r:o}},c=qF(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,l),d={...n.cardStateMap};return e&&(d[e]={...d[e],timeSelection:l,stepSelectionOverride:Va.OVERRIDE_AS_ENABLED,rangeSelectionOverride:void 0===l.end?.step?Va.OVERRIDE_AS_DISABLED:Va.OVERRIDE_AS_ENABLED}),{...n,linkedTimeSelection:l,cardStepIndex:c,cardStateMap:d,rangeSelectionEnabled:s}}),ye(_y,(n,{cardId:t,userViewBox:e})=>{let i={...n.cardStateMap};return i[t]={...i[t],userViewBox:e},{...n,cardStateMap:i}}),ye(Td,(n,{affordance:t,cardId:e})=>{let i={...n.cardStateMap};if(e){let{timeSelection:s,...l}=i[e]||{};i[e]={...l,stepSelectionOverride:Va.OVERRIDE_AS_DISABLED}}else Object.keys(i).forEach(s=>{i[s]={...i[s],stepSelectionOverride:Va.NONE}});if(!n.linkedTimeEnabled&&t!==Za.CHECK_BOX)return{...n,cardStateMap:i};let r=!n.stepSelectorEnabled,o=r&&n.linkedTimeEnabled,a=r&&n.rangeSelectionEnabled;return{...n,linkedTimeEnabled:o,stepSelectorEnabled:r,rangeSelectionEnabled:a,cardStateMap:i}}),ye(dT,(n,{tab:t})=>({...n,tableEditorSelectedTab:t})),ye(jg,(n,{source:t,destination:e,side:i,dataTableMode:r})=>{let o=r===Wr.RANGE?[...n.rangeSelectionHeaders]:[...n.singleSelectionHeaders];return o=kl.moveColumn(o,t,e,i),r===Wr.RANGE?{...n,rangeSelectionHeaders:o}:{...n,singleSelectionHeaders:o}}),ye(Gg,(n,{dataTableMode:t,header:e,cardId:i})=>{let{cardStateMap:r,rangeSelectionEnabled:o,linkedTimeEnabled:a}=n,s=i?r1(r,o,a,i):t===Wr.RANGE,c=(s?n.rangeSelectionHeaders:n.singleSelectionHeaders).map(d=>{let u={...d};return d.name===e.name&&(u.enabled=!u.enabled),u});return s?{...n,rangeSelectionHeaders:c}:{...n,singleSelectionHeaders:c}}),ye(FT,(n,{plugin:t})=>{let e=new Set(n.filteredPluginTypes);return e.has(t)?e.delete(t):e.add(t),Object.values(An).every(i=>e.has(i))&&(e=new Set),{...n,filteredPluginTypes:e}}),ye(NT,n=>({...n,filteredPluginTypes:new Set})),ye(sT,n=>({...n,isSettingsPaneOpen:!n.isSettingsPaneOpen})),ye(aT,n=>({...n,isSettingsPaneOpen:!1})),ye(lT,n=>({...n,isSlideoutMenuOpen:!n.isSlideoutMenuOpen})),ye(cT,(n,{mode:t})=>({...n,isSlideoutMenuOpen:!0,isSettingsPaneOpen:!0,tableEditorSelectedTab:t})),ye(uT,n=>({...n,isSlideoutMenuOpen:!1})),ye(VT,(n,{cards:t})=>({...n,unresolvedImportedPinnedCards:[...n.unresolvedImportedPinnedCards,...t]})),ye(Wg,n=>{let t={...n.cardMetadataMap},e={...n.cardStepIndex},i={...n.cardStateMap};for(let r of n.pinnedCardToOriginal.keys())delete t[r],delete e[r],delete i[r];return{...n,cardMetadataMap:t,cardStateMap:i,cardStepIndex:e,cardToPinnedCopy:new Map,cardToPinnedCopyCache:new Map,pinnedCardToOriginal:new Map}}));function uQ(n,t){return bh(XSe,qSe)(n,t)}function cQ(n,t){return{tagDescriptions:n[t].tagDescriptions,tagToRuns:YSe(n[t].runTagInfo)}}function YSe(n){let t={};for(let e in n)for(let i of n[e])t[i]=[...t[i]||[],e];return t}var QSe=W(gd,Ks,(n,t,e)=>t?{...t,loadState:n,id:e}:null),wN=fe("[Metrics Effects] Init"),pQ=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.metricsDataSource=r,this.savedPinsDataSource=o,this.dashboardShownWithoutData$=this.actions$.pipe(Zn(wN,yc,gh,Na),It(this.store.select(Zo),this.store.select(xv)),Oe(([,a,s])=>a===_v&&s.state===Re.NOT_LOADED)),this.reloadRequestedWhileShown$=this.actions$.pipe(Zn(ma,Ba),It(this.store.select(Zo)),Oe(([,a])=>a===_v)),this.loadTagMetadata$=tn(this.dashboardShownWithoutData$,this.reloadRequestedWhileShown$).pipe(It(this.store.select(xv),this.store.select(or)),Oe(([,a,s])=>a.state!==Re.LOADING&&null!==s),ic(10),Dt(()=>{this.store.dispatch(pT())}),Jn(([,,a])=>this.metricsDataSource.fetchTagMetadata(a).pipe(Dt(s=>{this.store.dispatch(hT({tagMetadata:s}))}),co(()=>(this.store.dispatch(mT()),$t(null)))))),this.visibleCardsWithoutDataChanged$=this.actions$.pipe(Zn(Ug),It(this.getVisibleCardFetchInfos()),q(([,a])=>a.filter(s=>s.loadState===Re.NOT_LOADED))),this.visibleCardsReloaded$=this.reloadRequestedWhileShown$.pipe(It(this.getVisibleCardFetchInfos()),q(([,a])=>a.filter(s=>s.loadState!==Re.LOADING))),this.loadTimeSeries$=tn(this.visibleCardsWithoutDataChanged$,this.visibleCardsReloaded$).pipe(Oe(a=>a.length>0),It(this.store.select(or).pipe(Oe(a=>null!==a))),xn(([a,s])=>this.fetchTimeSeriesForCards(a,s))),this.addOrRemovePin$=this.actions$.pipe(Zn(np),It(this.getVisibleCardFetchInfos(),this.store.select(pd),this.store.select(ph),this.store.select(bd)),Oe(([,,a,s,l])=>a&&s&&l),Dt(([{cardId:a,canCreateNewPins:s,wasPinned:l},c])=>{let d=c.find(u=>u.id===a);!d||d.plugin!==An.SCALARS||(l?this.savedPinsDataSource.removeScalarPin(d.tag):s&&this.savedPinsDataSource.saveScalarPin(d.tag))})),this.loadSavedPins$=this.actions$.pipe(Zn(wN),It(this.store.select(pd),this.store.select(ph),this.store.select(bd)),Oe(([,a,s,l])=>a&&s&&l),Dt(()=>{let a=this.savedPinsDataSource.getSavedScalarPins();if(!a||0===a.length)return;let s=a.map(l=>({plugin:An.SCALARS,tag:l}));this.store.dispatch(VT({cards:s}))})),this.removeAllPins$=this.actions$.pipe(Zn(Wg),It(this.store.select(pd),this.store.select(ph),this.store.select(bd)),Oe(([,a,s,l])=>a&&s&&l),Dt(()=>{this.savedPinsDataSource.removeAllScalarPins()})),this.addOrRemovePinsOnToggle$=this.actions$.pipe(Zn(zh),It(this.store.select(Kf),this.store.select(pd),this.store.select(ph),this.store.select(bd)),Oe(([,,a,s])=>a&&s),Dt(([,a,,,s])=>{if(s){let l=a.map(c=>c.plugin===An.SCALARS?c.tag:null).filter(c=>null!==c);this.savedPinsDataSource.saveScalarPins(l)}else this.savedPinsDataSource.removeAllScalarPins()})),this.dataEffects$=_r(()=>tn(this.loadTagMetadata$,this.loadTimeSeries$,this.addOrRemovePin$,this.loadSavedPins$,this.removeAllPins$,this.addOrRemovePinsOnToggle$),{dispatch:!1})}ngrxOnInitEffects(){return wN()}getVisibleCardFetchInfos(){return this.store.select(IW).pipe(Jn(i=>i.size?Co([...i].map(o=>this.store.select(QSe,o).pipe(Lt(1)))):$t([])),q(i=>i.filter(Boolean)))}fetchTimeSeries(e){return this.metricsDataSource.fetchTimeSeries([e]).pipe(Dt(i=>{let r=i.filter(qS);r.length&&console.error("Time series response contained errors:",r),this.store.dispatch(RT({response:i[0]}))}),co(()=>(this.store.dispatch(AT({request:e})),$t(null))))}fetchTimeSeriesForCards(e,i){return $t(e.map(o=>{let{plugin:a,tag:s,runId:l,sample:c}=o,d=gs(a)?{plugin:a,tag:s,runId:l}:{plugin:a,tag:s,experimentIds:i};return void 0!==c&&(d.sample=c),d})).pipe(Dt(o=>{this.store.dispatch(IT({requests:o}))}),xn(o=>tn(...o.map(s=>this.fetchTimeSeries(s)))))}}return n.\u0275fac=function(e){return new(e||n)(O(Eo),O(Ie),O(wc),O(XS))},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),SN=new te("Metrics Store Config"),EN=new te("Metrics Initial Settings Config");function hQ(n){return n?{initialState:{...MN,settings:n}}:{initialState:MN}}var Cs=(()=>(function(n){n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT",n[n.MIDDLE=4]="MIDDLE",n[n.FOURTH=8]="FOURTH",n[n.FIFTH=32]="FIFTH"}(Cs||(Cs={})),Cs))(),mQ=0;function ZSe(n,t){if(1&n){let e=Te();f(0,"button",3),A("click",function(){return ne(e),ie(w().expandSidebar())}),k(1,"mat-icon",4),g()}}var KSe=function(n){return{"full-screen":n}};function JSe(n,t){if(1&n){let e=Te();f(0,"nav",5),U(1,"async"),U(2,"async"),Tt(3,1),f(4,"div",6),U(5,"async"),f(6,"button",7),A("click",function(){return ne(e),ie(w().toggleFullScreen())}),U(7,"async"),k(8,"mat-icon",8),U(9,"async"),g()()()}if(2&n){let e=w();Bt("width",G(1,9,e.width$),"%")("min-width",e.MINIMUM_SIDEBAR_WIDTH_IN_PX,"px")("max-width",G(2,11,e.runsTableFullScreen$)?100:"","%"),v(4),b("ngClass",Un(19,KSe,G(5,13,e.runsTableFullScreen$))),v(2),b("ngClass",G(7,15,e.runsTableFullScreen$)?"collapse":"expand"),v(2),b("svgIcon",G(9,17,e.runsTableFullScreen$)?"arrow_back_24px":"arrow_forward_24px")}}function $Se(n,t){if(1&n){let e=Te();f(0,"div",9),A("mousedown",function(){return ne(e),ie(w().resizeGrabbed())}),g()}}var e1e=[[["","main",""]],[["","sidebar",""]]],t1e=["[main]","[sidebar]"],_Q=(()=>{class n{constructor(e,i){this.store=e,this.runsTableFullScreen$=this.store.select(wS),this.width$=this.store.select(MS).pipe(Vi(this.runsTableFullScreen$),q(([r,o])=>o?100:r)),this.ngUnsubscribe=new Ee,this.resizing=!1,this.MINIMUM_SIDEBAR_WIDTH_IN_PX=75,Ei(i.nativeElement,"mousemove").pipe(it(this.ngUnsubscribe),Oe(()=>this.resizing)).subscribe(r=>{if((r.buttons&Cs.LEFT)!==Cs.LEFT)return void(this.resizing=!1);r.preventDefault();let{width:o}=i.nativeElement.getBoundingClientRect();this.store.dispatch(Uf({widthInPercent:r.clientX<=this.MINIMUM_SIDEBAR_WIDTH_IN_PX?0:r.clientX/o*100}))}),Ei(i.nativeElement,"mouseup",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(()=>{this.resizing=!1})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}resizeGrabbed(){this.resizing=!0}expandSidebar(){this.store.dispatch(Uf({widthInPercent:20}))}toggleFullScreen(){this.store.dispatch(vS())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(xe))},n.\u0275cmp=P({type:n,selectors:[["tb-dashboard-layout"]],ngContentSelectors:t1e,decls:7,vars:9,consts:[["class","expand-collapsed-sidebar",3,"click",4,"ngIf"],["class","sidebar",3,"width","minWidth","maxWidth",4,"ngIf"],["class","resizer",3,"mousedown",4,"ngIf"],[1,"expand-collapsed-sidebar",3,"click"],["svgIcon","expand_more_24px"],[1,"sidebar"],[1,"full-screen-toggle",3,"ngClass"],["mat-button","",1,"full-screen-btn",3,"ngClass","click"],[1,"expand-collapse-icon",3,"svgIcon"],[1,"resizer",3,"mousedown"]],template:function(e,i){1&e&&(fn(e1e),S(0,ZSe,2,0,"button",0),U(1,"async"),S(2,JSe,10,21,"nav",1),U(3,"async"),S(4,$Se,1,0,"div",2),U(5,"async"),Tt(6)),2&e&&(b("ngIf",0===G(1,3,i.width$)),v(2),b("ngIf",G(3,5,i.width$)>0),v(2),b("ngIf",G(5,7,i.width$)>0))},dependencies:[wn,Ne,bn,ki,ct],styles:["[_nghost-%COMP%]{display:flex;flex-direction:row;height:100%;width:100%;position:relative}.sidebar[_ngcontent-%COMP%]{max-width:80vw;position:relative}.resizer[_ngcontent-%COMP%], .expand-collapsed-sidebar[_ngcontent-%COMP%]{border-color:#ebebeb;box-sizing:border-box;flex:0 0;justify-self:stretch}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]{border-color:#555}body.dark-mode[_nghost-%COMP%]   .expand-collapsed-sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand-collapsed-sidebar[_ngcontent-%COMP%]{border-color:#555}.expand-collapsed-sidebar[_ngcontent-%COMP%]{width:20px;align-items:center;background:rgba(0,0,0,0);border-style:solid;border-width:0 1px 0 0;color:inherit;contain:content;cursor:pointer;display:flex;justify-self:stretch;padding:0}.expand-collapsed-sidebar[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}.resizer[_ngcontent-%COMP%]{align-items:center;border-style:solid;border-width:0 2px;cursor:ew-resize;contain:strict;display:flex;justify-self:stretch}.resizer[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%}.resizer[_ngcontent-%COMP%]:hover{border-color:#ccc;outline:3px solid #ccc;z-index:1}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover{outline-color:#777;border-color:#777}.full-screen-toggle[_ngcontent-%COMP%]{opacity:0;position:absolute;height:100%;left:calc(100% + 2px);top:0;z-index:1;display:flex;align-items:center}.full-screen-toggle[_ngcontent-%COMP%]:hover{opacity:.8}.full-screen-toggle.full-screen[_ngcontent-%COMP%]{left:unset;right:0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]{background-color:gray;padding:0;min-width:20px;width:20px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.expand[_ngcontent-%COMP%]{border-radius:0 20px 20px 0}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn.collapse[_ngcontent-%COMP%]{border-radius:20px 0 0 20px}.full-screen-toggle[_ngcontent-%COMP%]   .full-screen-btn[_ngcontent-%COMP%]   .expand-collapse-icon[_ngcontent-%COMP%]{font-size:16px;margin-right:0}"],changeDetection:0}),n})(),TN=new WeakMap,yy=class{constructor(t,e){this.root=t,this.buffer=e,this.destroyedTargets=new WeakSet}initialize(t){if(this.intersectionObserver)return;this.intersectionCallback=t;let e={threshold:0,root:this.root??null};this.buffer&&(e.rootMargin=this.buffer),this.intersectionObserver=new IntersectionObserver(this.onCardIntersection.bind(this),e)}add(t){this.ensureInitialized()&&this.intersectionObserver.observe(t)}willDestroy(t){this.ensureInitialized()&&this.destroyedTargets.add(t)}ensureInitialized(){if(!this.intersectionObserver)throw new Error("CardObserver must be initialized before use");return!0}onCardIntersection(t){t.sort((r,o)=>r.time-o.time);let e=new Set,i=new Set;for(let{isIntersecting:r,target:o}of t)r?(e.add(o),i.delete(o)):(e.delete(o),i.add(o)),this.destroyedTargets.has(o)&&!r&&(this.destroyedTargets.delete(o),this.intersectionObserver.unobserve(o));this.intersectionCallback(e,i)}onCardIntersectionForTest(t){this.onCardIntersection(t)}},bQ=(()=>{class n{constructor(e,i){this.host=e,this.store=i}onCardIntersection(e,i){let r=[...e].map(a=>{let s=TN.get(a);if(!s)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:s.elementId,cardId:s.cardId}}),o=[...i].map(a=>{let s=TN.get(a);if(!s)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:s.elementId,cardId:s.cardId}});this.store.dispatch(Ug({enteredCards:r,exitedCards:o}))}ngOnInit(){let e=this.host.nativeElement;TN.set(e,{elementId:(mQ++,Symbol(mQ)),cardId:this.cardId}),this.cardObserver||(this.cardObserver=new yy),this.cardObserver.initialize(this.onCardIntersection.bind(this)),this.cardObserver.add(e)}ngOnDestroy(){this.cardObserver&&this.cardObserver.willDestroy(this.host.nativeElement)}hostForTest(){return this.host}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Ie))},n.\u0275dir=Me({type:n,selectors:[["","cardLazyLoader",""]],inputs:{cardId:["cardLazyLoader","cardId"],cardObserver:"cardObserver"}}),n})();function r1e(n,t){1&n&&(Gt(0),Tt(1),Wt())}var o1e=["*"],vQ=(()=>{class n{constructor(e,i){this.viewContainerRef=e,this.componentFactoryResolver=i}ngOnInit(){if(this.customizableComponent){let e=this.componentFactoryResolver.resolveComponentFactory(this.customizableComponent.constructor);this.viewContainerRef.createComponent(e)}}}return n.\u0275fac=function(e){return new(e||n)(C(ei),C(ho))},n.\u0275cmp=P({type:n,selectors:[["tb-customization"]],inputs:{customizableComponent:"customizableComponent"},ngContentSelectors:o1e,decls:1,vars:1,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(fn(),S(0,r1e,2,0,"ng-container",0)),2&e&&b("ngIf",!i.customizableComponent)},dependencies:[Ne],encapsulation:2}),n})(),s1e=["button"],l1e=["*"],yQ=new te("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS"),xQ=new te("MatButtonToggleGroup"),c1e={provide:Xr,useExisting:Wn(()=>DN),multi:!0},CQ=0,zT=class{constructor(t,e){this.source=t,this.value=e}},DN=(()=>{class n{get name(){return this._name}set name(e){this._name=e,this._markButtonsForCheck()}get vertical(){return this._vertical}set vertical(e){this._vertical=vt(e)}get value(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e.map(i=>i.value):e[0]?e[0].value:void 0}set value(e){this._setSelectionByValue(e),this.valueChange.emit(this.value)}get selected(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e:e[0]||null}get multiple(){return this._multiple}set multiple(e){this._multiple=vt(e),this._markButtonsForCheck()}get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e),this._markButtonsForCheck()}constructor(e,i){this._changeDetector=e,this._vertical=!1,this._multiple=!1,this._disabled=!1,this._controlValueAccessorChangeFn=()=>{},this._onTouched=()=>{},this._name="mat-button-toggle-group-"+CQ++,this.valueChange=new F,this.change=new F,this.appearance=i&&i.appearance?i.appearance:"standard"}ngOnInit(){this._selectionModel=new fg(this.multiple,void 0,!1)}ngAfterContentInit(){this._selectionModel.select(...this._buttonToggles.filter(e=>e.checked))}writeValue(e){this.value=e,this._changeDetector.markForCheck()}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_emitChangeEvent(e){let i=new zT(e,this.value);this._controlValueAccessorChangeFn(i.value),this.change.emit(i)}_syncButtonToggle(e,i,r=!1,o=!1){!this.multiple&&this.selected&&!e.checked&&(this.selected.checked=!1),this._selectionModel?i?this._selectionModel.select(e):this._selectionModel.deselect(e):o=!0,o?Promise.resolve().then(()=>this._updateModelValue(e,r)):this._updateModelValue(e,r)}_isSelected(e){return this._selectionModel&&this._selectionModel.isSelected(e)}_isPrechecked(e){return!(typeof this._rawValue>"u")&&(this.multiple&&Array.isArray(this._rawValue)?this._rawValue.some(i=>null!=e.value&&i===e.value):e.value===this._rawValue)}_setSelectionByValue(e){this._rawValue=e,this._buttonToggles&&(this.multiple&&e?(Array.isArray(e),this._clearSelection(),e.forEach(i=>this._selectValue(i))):(this._clearSelection(),this._selectValue(e)))}_clearSelection(){this._selectionModel.clear(),this._buttonToggles.forEach(e=>e.checked=!1)}_selectValue(e){let i=this._buttonToggles.find(r=>null!=r.value&&r.value===e);i&&(i.checked=!0,this._selectionModel.select(i))}_updateModelValue(e,i){i&&this._emitChangeEvent(e),this.valueChange.emit(this.value)}_markButtonsForCheck(){this._buttonToggles?.forEach(e=>e._markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(yQ,8))},n.\u0275dir=Me({type:n,selectors:[["mat-button-toggle-group"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,u1e,5),2&e){let o;be(o=ve())&&(i._buttonToggles=o)}},hostAttrs:["role","group",1,"mat-button-toggle-group"],hostVars:5,hostBindings:function(e,i){2&e&&(Be("aria-disabled",i.disabled),nt("mat-button-toggle-vertical",i.vertical)("mat-button-toggle-group-appearance-standard","standard"===i.appearance))},inputs:{appearance:"appearance",name:"name",vertical:"vertical",value:"value",multiple:"multiple",disabled:"disabled"},outputs:{valueChange:"valueChange",change:"change"},exportAs:["matButtonToggleGroup"],features:[Vt([c1e,{provide:xQ,useExisting:n}])]}),n})(),d1e=go(class{}),u1e=(()=>{class n extends d1e{get buttonId(){return`${this.id}-button`}get appearance(){return this.buttonToggleGroup?this.buttonToggleGroup.appearance:this._appearance}set appearance(e){this._appearance=e}get checked(){return this.buttonToggleGroup?this.buttonToggleGroup._isSelected(this):this._checked}set checked(e){let i=vt(e);i!==this._checked&&(this._checked=i,this.buttonToggleGroup&&this.buttonToggleGroup._syncButtonToggle(this,this._checked),this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled||this.buttonToggleGroup&&this.buttonToggleGroup.disabled}set disabled(e){this._disabled=vt(e)}constructor(e,i,r,o,a,s){super(),this._changeDetectorRef=i,this._elementRef=r,this._focusMonitor=o,this._checked=!1,this.ariaLabelledby=null,this._disabled=!1,this.change=new F;let l=Number(a);this.tabIndex=l||0===l?l:null,this.buttonToggleGroup=e,this.appearance=s&&s.appearance?s.appearance:"standard"}ngOnInit(){let e=this.buttonToggleGroup;this.id=this.id||"mat-button-toggle-"+CQ++,e&&(e._isPrechecked(this)?this.checked=!0:e._isSelected(this)!==this._checked&&e._syncButtonToggle(this,this._checked))}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){let e=this.buttonToggleGroup;this._focusMonitor.stopMonitoring(this._elementRef),e&&e._isSelected(this)&&e._syncButtonToggle(this,!1,!1,!0)}focus(e){this._buttonElement.nativeElement.focus(e)}_onButtonClick(){let e=!!this._isSingleSelector()||!this._checked;e!==this._checked&&(this._checked=e,this.buttonToggleGroup&&(this.buttonToggleGroup._syncButtonToggle(this,this._checked,!0),this.buttonToggleGroup._onTouched())),this.change.emit(new zT(this,this.value))}_markForCheck(){this._changeDetectorRef.markForCheck()}_getButtonName(){return this._isSingleSelector()?this.buttonToggleGroup.name:this.name||null}_isSingleSelector(){return this.buttonToggleGroup&&!this.buttonToggleGroup.multiple}}return n.\u0275fac=function(e){return new(e||n)(C(xQ,8),C(Qt),C(xe),C(fo),Mo("tabindex"),C(yQ,8))},n.\u0275cmp=P({type:n,selectors:[["mat-button-toggle"]],viewQuery:function(e,i){if(1&e&&Ue(s1e,5),2&e){let r;be(r=ve())&&(i._buttonElement=r.first)}},hostAttrs:["role","presentation",1,"mat-button-toggle"],hostVars:12,hostBindings:function(e,i){1&e&&A("focus",function(){return i.focus()}),2&e&&(Be("aria-label",null)("aria-labelledby",null)("id",i.id)("name",null),nt("mat-button-toggle-standalone",!i.buttonToggleGroup)("mat-button-toggle-checked",i.checked)("mat-button-toggle-disabled",i.disabled)("mat-button-toggle-appearance-standard","standard"===i.appearance))},inputs:{disableRipple:"disableRipple",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],id:"id",name:"name",value:"value",tabIndex:"tabIndex",appearance:"appearance",checked:"checked",disabled:"disabled"},outputs:{change:"change"},exportAs:["matButtonToggle"],features:[Xe],ngContentSelectors:l1e,decls:6,vars:9,consts:[["type","button",1,"mat-button-toggle-button","mat-focus-indicator",3,"id","disabled","click"],["button",""],[1,"mat-button-toggle-label-content"],[1,"mat-button-toggle-focus-overlay"],["matRipple","",1,"mat-button-toggle-ripple",3,"matRippleTrigger","matRippleDisabled"]],template:function(e,i){if(1&e&&(fn(),f(0,"button",0,1),A("click",function(){return i._onButtonClick()}),f(2,"span",2),Tt(3),g()(),k(4,"span",3)(5,"span",4)),2&e){let r=st(1);b("id",i.buttonId)("disabled",i.disabled||null),Be("tabindex",i.disabled?-1:i.tabIndex)("aria-pressed",i.checked)("name",i._getButtonName())("aria-label",i.ariaLabel)("aria-labelledby",i.ariaLabelledby),v(5),b("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)}},dependencies:[Ki],styles:[".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:rgba(0,0,0,0);transform:translateZ(0)}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;pointer-events:none;opacity:0}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px;opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked:hover .mat-button-toggle-focus-overlay{opacity:.6}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}"],encapsulation:2,changeDetection:0}),n})(),UT=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,_a,dn]}),n})(),h1e=["determinateSpinner"];function m1e(n,t){if(1&n&&(qn(),f(0,"svg",11),k(1,"circle",12),g()),2&n){let e=w();Be("viewBox",e._viewBox()),v(1),Bt("stroke-dasharray",e._strokeCircumference(),"px")("stroke-dashoffset",e._strokeCircumference()/2,"px")("stroke-width",e._circleStrokeWidth(),"%"),Be("r",e._circleRadius())}}var f1e=Ko(class{constructor(n){this._elementRef=n}},"primary"),g1e=new te("mat-progress-spinner-default-options",{providedIn:"root",factory:function(){return{diameter:MQ}}}),MQ=100,Nc=(()=>{class n extends f1e{constructor(e,i,r){super(e),this.mode="mat-spinner"===this._elementRef.nativeElement.nodeName.toLowerCase()?"indeterminate":"determinate",this._value=0,this._diameter=MQ,this._noopAnimations="NoopAnimations"===i&&!!r&&!r._forceAnimations,r&&(r.color&&(this.color=this.defaultColor=r.color),r.diameter&&(this.diameter=r.diameter),r.strokeWidth&&(this.strokeWidth=r.strokeWidth))}get value(){return"determinate"===this.mode?this._value:0}set value(e){this._value=Math.max(0,Math.min(100,mi(e)))}get diameter(){return this._diameter}set diameter(e){this._diameter=mi(e)}get strokeWidth(){return this._strokeWidth??this.diameter/10}set strokeWidth(e){this._strokeWidth=mi(e)}_circleRadius(){return(this.diameter-10)/2}_viewBox(){let e=2*this._circleRadius()+this.strokeWidth;return`0 0 ${e} ${e}`}_strokeCircumference(){return 2*Math.PI*this._circleRadius()}_strokeDashOffset(){return"determinate"===this.mode?this._strokeCircumference()*(100-this._value)/100:null}_circleStrokeWidth(){return this.strokeWidth/this.diameter*100}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(pi,8),C(g1e))},n.\u0275cmp=P({type:n,selectors:[["mat-progress-spinner"],["mat-spinner"]],viewQuery:function(e,i){if(1&e&&Ue(h1e,5),2&e){let r;be(r=ve())&&(i._determinateCircle=r.first)}},hostAttrs:["role","progressbar","tabindex","-1",1,"mat-mdc-progress-spinner","mdc-circular-progress"],hostVars:12,hostBindings:function(e,i){2&e&&(Be("aria-valuemin",0)("aria-valuemax",100)("aria-valuenow","determinate"===i.mode?i.value:null)("mode",i.mode),Bt("width",i.diameter,"px")("height",i.diameter,"px"),nt("_mat-animation-noopable",i._noopAnimations)("mdc-circular-progress--indeterminate","indeterminate"===i.mode))},inputs:{color:"color",mode:"mode",value:"value",diameter:"diameter",strokeWidth:"strokeWidth"},exportAs:["matProgressSpinner"],features:[Xe],decls:14,vars:11,consts:[["circle",""],["aria-hidden","true",1,"mdc-circular-progress__determinate-container"],["determinateSpinner",""],["xmlns","http://www.w3.org/2000/svg","focusable","false",1,"mdc-circular-progress__determinate-circle-graphic"],["cx","50%","cy","50%",1,"mdc-circular-progress__determinate-circle"],["aria-hidden","true",1,"mdc-circular-progress__indeterminate-container"],[1,"mdc-circular-progress__spinner-layer"],[1,"mdc-circular-progress__circle-clipper","mdc-circular-progress__circle-left"],[3,"ngTemplateOutlet"],[1,"mdc-circular-progress__gap-patch"],[1,"mdc-circular-progress__circle-clipper","mdc-circular-progress__circle-right"],["xmlns","http://www.w3.org/2000/svg","focusable","false",1,"mdc-circular-progress__indeterminate-circle-graphic"],["cx","50%","cy","50%"]],template:function(e,i){if(1&e&&(S(0,m1e,2,8,"ng-template",null,0,jt),f(2,"div",1,2),qn(),f(4,"svg",3),k(5,"circle",4),g()(),ua(),f(6,"div",5)(7,"div",6)(8,"div",7),hi(9,8),g(),f(10,"div",9),hi(11,8),g(),f(12,"div",10),hi(13,8),g()()()),2&e){let r=st(1);v(4),Be("viewBox",i._viewBox()),v(1),Bt("stroke-dasharray",i._strokeCircumference(),"px")("stroke-dashoffset",i._strokeDashOffset(),"px")("stroke-width",i._circleStrokeWidth(),"%"),Be("r",i._circleRadius()),v(4),b("ngTemplateOutlet",r),v(2),b("ngTemplateOutlet",r),v(2),b("ngTemplateOutlet",r)}},dependencies:[eo],styles:["@keyframes mdc-circular-progress-container-rotate{to{transform:rotate(360deg)}}@keyframes mdc-circular-progress-spinner-layer-rotate{12.5%{transform:rotate(135deg)}25%{transform:rotate(270deg)}37.5%{transform:rotate(405deg)}50%{transform:rotate(540deg)}62.5%{transform:rotate(675deg)}75%{transform:rotate(810deg)}87.5%{transform:rotate(945deg)}100%{transform:rotate(1080deg)}}@keyframes mdc-circular-progress-color-1-fade-in-out{from{opacity:.99}25%{opacity:.99}26%{opacity:0}89%{opacity:0}90%{opacity:.99}to{opacity:.99}}@keyframes mdc-circular-progress-color-2-fade-in-out{from{opacity:0}15%{opacity:0}25%{opacity:.99}50%{opacity:.99}51%{opacity:0}to{opacity:0}}@keyframes mdc-circular-progress-color-3-fade-in-out{from{opacity:0}40%{opacity:0}50%{opacity:.99}75%{opacity:.99}76%{opacity:0}to{opacity:0}}@keyframes mdc-circular-progress-color-4-fade-in-out{from{opacity:0}65%{opacity:0}75%{opacity:.99}90%{opacity:.99}to{opacity:0}}@keyframes mdc-circular-progress-left-spin{from{transform:rotate(265deg)}50%{transform:rotate(130deg)}to{transform:rotate(265deg)}}@keyframes mdc-circular-progress-right-spin{from{transform:rotate(-265deg)}50%{transform:rotate(-130deg)}to{transform:rotate(-265deg)}}.mdc-circular-progress{display:inline-flex;position:relative;direction:ltr;line-height:0;transition:opacity 250ms 0ms cubic-bezier(0.4, 0, 0.6, 1)}.mdc-circular-progress__determinate-container,.mdc-circular-progress__indeterminate-circle-graphic,.mdc-circular-progress__indeterminate-container,.mdc-circular-progress__spinner-layer{position:absolute;width:100%;height:100%}.mdc-circular-progress__determinate-container{transform:rotate(-90deg)}.mdc-circular-progress__indeterminate-container{font-size:0;letter-spacing:0;white-space:nowrap;opacity:0}.mdc-circular-progress__determinate-circle-graphic,.mdc-circular-progress__indeterminate-circle-graphic{fill:rgba(0,0,0,0)}.mdc-circular-progress__determinate-circle{transition:stroke-dashoffset 500ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-circular-progress__gap-patch{position:absolute;top:0;left:47.5%;box-sizing:border-box;width:5%;height:100%;overflow:hidden}.mdc-circular-progress__gap-patch .mdc-circular-progress__indeterminate-circle-graphic{left:-900%;width:2000%;transform:rotate(180deg)}.mdc-circular-progress__circle-clipper{display:inline-flex;position:relative;width:50%;height:100%;overflow:hidden}.mdc-circular-progress__circle-clipper .mdc-circular-progress__indeterminate-circle-graphic{width:200%}.mdc-circular-progress__circle-right .mdc-circular-progress__indeterminate-circle-graphic{left:-100%}.mdc-circular-progress--indeterminate .mdc-circular-progress__determinate-container{opacity:0}.mdc-circular-progress--indeterminate .mdc-circular-progress__indeterminate-container{opacity:1}.mdc-circular-progress--indeterminate .mdc-circular-progress__indeterminate-container{animation:mdc-circular-progress-container-rotate 1568.2352941176ms linear infinite}.mdc-circular-progress--indeterminate .mdc-circular-progress__spinner-layer{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-1{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-1-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-2{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-2-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-3{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-3-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__color-4{animation:mdc-circular-progress-spinner-layer-rotate 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both,mdc-circular-progress-color-4-fade-in-out 5332ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__circle-left .mdc-circular-progress__indeterminate-circle-graphic{animation:mdc-circular-progress-left-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--indeterminate .mdc-circular-progress__circle-right .mdc-circular-progress__indeterminate-circle-graphic{animation:mdc-circular-progress-right-spin 1333ms cubic-bezier(0.4, 0, 0.2, 1) infinite both}.mdc-circular-progress--closed{opacity:0}.mat-mdc-progress-spinner{display:block;overflow:hidden;line-height:0}.mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle,.mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic{stroke:var(--mdc-circular-progress-active-indicator-color, transparent)}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle,.mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-1 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-2 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-3 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}@media screen and (forced-colors: active),(-ms-high-contrast: active){.mat-mdc-progress-spinner .mdc-circular-progress--four-color .mdc-circular-progress__color-4 .mdc-circular-progress__indeterminate-circle-graphic{stroke:CanvasText}}.mat-mdc-progress-spinner._mat-animation-noopable,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__determinate-circle{transition:none}.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-circle-graphic,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__spinner-layer,.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-container{animation:none}.mat-mdc-progress-spinner._mat-animation-noopable .mdc-circular-progress__indeterminate-container circle{stroke-dasharray:0 !important}.cdk-high-contrast-active .mat-mdc-progress-spinner .mdc-circular-progress__indeterminate-circle-graphic,.cdk-high-contrast-active .mat-mdc-progress-spinner .mdc-circular-progress__determinate-circle{stroke:currentColor;stroke:CanvasText}"],encapsulation:2,changeDetection:0}),n})(),ol=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,dn]}),n})(),wQ=(()=>{class n{constructor(e){this.dialogRef=e}closeWithoutDisabling(){this.dialogRef.close({shouldDisable:!1})}closeAndDisable(){this.dialogRef.close({shouldDisable:!0})}}return n.\u0275fac=function(e){return new(e||n)(C(Vl))},n.\u0275cmp=P({type:n,selectors:[["saving-pins-dialog"]],decls:11,vars:0,consts:[[1,"title"],[1,"bottom-buttons"],["mat-flat-button","",1,"cancel-button",3,"click"],["mat-flat-button","",1,"disable-button",3,"click"]],template:function(e,i){1&e&&(f(0,"h3",0),T(1,"Disable Saving Pins?"),g(),f(2,"p"),T(3," Disabling saving pins will remove locally stored pinned card data and no longer allow pinned cards to be shared across multiple experiments."),k(4,"br"),T(5,"You can re-enable the feature and re-pin cards at any time.\n"),g(),f(6,"div",1)(7,"button",2),A("click",function(){return i.closeWithoutDisabling()}),T(8," Cancel "),g(),f(9,"button",3),A("click",function(){return i.closeAndDisable()}),T(10," Disable "),g()())},dependencies:[ki],styles:[".title[_ngcontent-%COMP%]{font-size:19px;font-weight:500;margin:0}.bottom-buttons[_ngcontent-%COMP%]{display:flex;justify-content:flex-end;margin-top:10px;gap:10px}.bottom-buttons[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{text-transform:uppercase}"],changeDetection:0}),n})();function v1e(n,t){if(1&n&&(f(0,"b"),T(1),g()),2&n){let e=w().$implicit;v(1),Ve("",e.displayAlias,":")}}function y1e(n,t){if(1&n&&(f(0,"mat-option",2)(1,"span",3),S(2,v1e,2,1,"b",4),T(3),g()()),2&n){let e=t.$implicit;b("value",e.value)("disabled",e.disabled),v(1),jM("title","",e.displayAlias,": ",e.displayText,""),v(1),b("ngIf",e.displayAlias),v(1),Ve(" ",e.displayText," ")}}var SQ=(()=>{class n{constructor(){this.value="",this.options=[],this.selectionChange=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-dropdown"]],inputs:{value:"value",options:"options"},outputs:{selectionChange:"selectionChange"},decls:2,vars:3,consts:[[3,"value","hideSingleSelectionIndicator","selectionChange"],[3,"value","disabled",4,"ngFor","ngForOf"],[3,"value","disabled"],[1,"option-content",3,"title"],[4,"ngIf"]],template:function(e,i){1&e&&(f(0,"mat-select",0),A("selectionChange",function(o){return i.selectionChange.emit(o.value)}),S(1,y1e,4,6,"mat-option",1),g()),2&e&&(b("value",i.value)("hideSingleSelectionIndicator",!0),v(1),b("ngForOf",i.options))},dependencies:[nn,Ne,Wu,ja],styles:["mat-select[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:3px;box-sizing:border-box;padding:6px;font-size:12px;line-height:normal}mat-select[_ngcontent-%COMP%]     .mat-mdc-select-arrow-wrapper{height:12px}mat-select[_ngcontent-%COMP%]:focus{outline-color:-webkit-focus-ring-color;outline-style:auto}  .mat-mdc-select-panel{max-width:70vw}  mat-option.mat-mdc-option{min-height:32px;font-size:12px}"]}),n})(),EQ=(()=>{class n{constructor(){this.onCheckboxToggled=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["saving-pins-checkbox"]],inputs:{isChecked:"isChecked"},outputs:{onCheckboxToggled:"onCheckboxToggled"},features:[Vt([{provide:Z2,useValue:{clickAction:"noop"}}])],decls:4,vars:1,consts:[[1,"saving-pins-checkbox"],["color","primary",3,"checked","click"],["svgIcon","help_outline_24px","title","When saving pins are enabled, pinned cards will be visible across multiple experiments.",1,"info"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"mat-checkbox",1),A("click",function(){return i.onCheckboxToggled.emit()}),T(2,"Enable saving pins (Scalars only)"),g(),k(3,"mat-icon",2),g()),2&e&&(v(1),b("checked",i.isChecked))},dependencies:[xs,bn],styles:["[_nghost-%COMP%]{color:#616161;font-size:12px}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}mat-checkbox[_ngcontent-%COMP%]{margin-left:-11px}mat-checkbox[_ngcontent-%COMP%]     label{color:#616161;font-size:12px;letter-spacing:normal;padding-left:0px;white-space:nowrap}body.dark-mode[_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label, body.dark-mode   [_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{color:rgba(255,255,255,.7)}.saving-pins-checkbox[_ngcontent-%COMP%]{align-items:center;display:flex}.saving-pins-checkbox[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px;min-width:15px}"],changeDetection:0}),n})(),M1e=function(n){return{"column-edit-menu-toggle":!0,"toggle-opened":n}};function w1e(n,t){if(1&n){let e=Te();f(0,"button",33),A("click",function(){return ne(e),ie(w().onSlideOutToggled.emit())}),k(1,"mat-icon",34),T(2," Edit Table Columns "),g()}if(2&n){let e=w();b("ngClass",Un(1,M1e,e.isSlideOutMenuOpen))}}function S1e(n,t){if(1&n){let e=Te();f(0,"div",35)(1,"saving-pins-checkbox",36),A("onCheckboxToggled",function(){ne(e);let r=w();return ie(r.onEnableSavingPinsToggled.emit(r.isSavingPinsEnabled))}),g()()}if(2&n){let e=w();v(1),b("isChecked",e.isSavingPinsEnabled)}}function E1e(n,t){if(1&n){let e=Te();f(0,"section",37)(1,"h3",1),T(2,"Images"),g(),f(3,"div",38)(4,"div",39),T(5,"Brightness"),g(),f(6,"div",13)(7,"mat-slider",40)(8,"input",15),A("valueChange",function(r){return ne(e),ie(w().imageBrightnessSliderChanged$.emit(r))}),g()(),f(9,"button",41),A("click",function(){return ne(e),ie(w().imageBrightnessReset.emit())}),k(10,"mat-icon",17),g()()(),f(11,"div",42)(12,"div",43),T(13,"Contrast"),g(),f(14,"div",13)(15,"mat-slider",44)(16,"input",15),A("valueChange",function(r){return ne(e),ie(w().imageContrastSliderChanged$.emit(r))}),g()(),f(17,"button",45),A("click",function(){return ne(e),ie(w().imageContrastReset.emit())}),k(18,"mat-icon",17),g()()(),f(19,"div",46)(20,"mat-checkbox",27),A("change",function(r){return ne(e),ie(w().imageShowActualSizeChanged.emit(r.checked))}),T(21,"Show actual image size"),g()()()}if(2&n){let e=w();v(7),b("max",2e3)("min",0)("step",10)("displayWith",e.formatMilliToZeroth),v(1),b("value",e.imageBrightnessInMilli),v(7),b("max",5e3)("min",0)("step",10)("displayWith",e.formatMilliToZeroth),v(1),b("value",e.imageContrastInMilli),v(4),b("checked",e.imageShowActualSize)}}var DQ=(()=>{class n{constructor(e){this.locale=e,this.globalPinsFeatureEnabled=!1,this.linkedTimeToggled=new F,this.stepSelectorToggled=new F,this.rangeSelectionToggled=new F,this.onSlideOutToggled=new F,this.onEnableSavingPinsToggled=new F,this.TooltipSortDropdownOptions=[{value:oo.ALPHABETICAL,displayText:"Alphabetical"},{value:oo.ASCENDING,displayText:"Ascending"},{value:oo.DESCENDING,displayText:"Descending"},{value:oo.NEAREST,displayText:"Nearest Pixel"},{value:oo.NEAREST_Y,displayText:"Nearest Y"}],this.tooltipSortChanged=new F,this.ignoreOutliersChanged=new F,this.XAxisType=Pi,this.XAxisTypeDropdownOptions=[{value:Pi.STEP,displayText:"Step"},{value:Pi.RELATIVE,displayText:"Relative"},{value:Pi.WALL_TIME,displayText:"Wall"}],this.xAxisTypeChanged=new F,this.MAX_CARD_WIDTH_SLIDER_VALUE=735,this.MIN_CARD_WIDTH_SLIDER_VALUE=335,this.cardWidthSliderChanged$=new F,this.cardWidthChanged=this.cardWidthSliderChanged$.pipe(nc(250)),this.cardWidthReset=new F,this.HistogramModeDropdownOptions=[{value:Sr.OFFSET,displayText:"Offset"},{value:Sr.OVERLAY,displayText:"Overlay"}],this.histogramModeChanged=new F,this.MAX_SMOOTHING_VALUE=.999,this.MAX_SMOOTHING_SLIDER_VALUE=.99,this.scalarSmoothingControlChanged$=new F,this.scalarSmoothing=10,this.scalarSmoothingChanged=this.scalarSmoothingControlChanged$.pipe(nc(250)),this.scalarPartitionXToggled=new F,this.imageBrightnessSliderChanged$=new F,this.imageBrightnessInMilliChanged=this.imageBrightnessSliderChanged$.pipe(nc(250)),this.imageBrightnessReset=new F,this.imageContrastSliderChanged$=new F,this.imageContrastInMilliChanged=this.imageContrastSliderChanged$.pipe(nc(250)),this.imageContrastReset=new F,this.imageShowActualSizeChanged=new F}onScalarSmoothingInput(e){let i=e.target;if(!i.value)return;let r=Math.min(Math.max(0,parseFloat(i.value)),.999);r!==parseFloat(i.value)&&(i.value=String(r)),this.scalarSmoothingControlChanged$.emit(r)}formatMilliToZeroth(e){return eO(e/1e3,this.locale||"en-US","1.0-2")}getLinkedTimeSelectionStartStep(){return this.isLinkedTimeEnabled||null===this.linkedTimeSelection||null!==this.linkedTimeSelection.end?"":this.linkedTimeSelection.start.step}isAxisTypeStep(){return this.xAxisType===Pi.STEP}}return n.\u0275fac=function(e){return new(e||n)(C(ad))},n.\u0275cmp=P({type:n,selectors:[["metrics-dashboard-settings-component"]],inputs:{isLinkedTimeEnabled:"isLinkedTimeEnabled",isScalarStepSelectorEnabled:"isScalarStepSelectorEnabled",isScalarStepSelectorRangeEnabled:"isScalarStepSelectorRangeEnabled",isScalarColumnCustomizationEnabled:"isScalarColumnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepMinMax:"stepMinMax",isSlideOutMenuOpen:"isSlideOutMenuOpen",isSavingPinsEnabled:"isSavingPinsEnabled",globalPinsFeatureEnabled:"globalPinsFeatureEnabled",isImageSupportEnabled:"isImageSupportEnabled",tooltipSort:"tooltipSort",ignoreOutliers:"ignoreOutliers",xAxisType:"xAxisType",cardMinWidth:"cardMinWidth",histogramMode:"histogramMode",scalarSmoothing:"scalarSmoothing",scalarPartitionX:"scalarPartitionX",imageBrightnessInMilli:"imageBrightnessInMilli",imageContrastInMilli:"imageContrastInMilli",imageShowActualSize:"imageShowActualSize"},outputs:{linkedTimeToggled:"linkedTimeToggled",stepSelectorToggled:"stepSelectorToggled",rangeSelectionToggled:"rangeSelectionToggled",onSlideOutToggled:"onSlideOutToggled",onEnableSavingPinsToggled:"onEnableSavingPinsToggled",tooltipSortChanged:"tooltipSortChanged",ignoreOutliersChanged:"ignoreOutliersChanged",xAxisTypeChanged:"xAxisTypeChanged",cardWidthChanged:"cardWidthChanged",cardWidthReset:"cardWidthReset",histogramModeChanged:"histogramModeChanged",scalarSmoothingChanged:"scalarSmoothingChanged",scalarPartitionXToggled:"scalarPartitionXToggled",imageBrightnessInMilliChanged:"imageBrightnessInMilliChanged",imageBrightnessReset:"imageBrightnessReset",imageContrastInMilliChanged:"imageContrastInMilliChanged",imageContrastReset:"imageContrastReset",imageShowActualSizeChanged:"imageShowActualSizeChanged"},decls:57,vars:29,consts:function(){let t,e,i;return t=$localize`:A button to reset the card width setting␟ccdc96b003fbba90db7a6959b5b26e3cc58f7d80␟5223111047968102466:Reset card width`,e=$localize`:A button to reset the image brightness setting␟c482b3a47ea0975fa8be01afb3fbec9b76628bd7␟1189161857240378395:Reset brightness`,i=$localize`:A button to reset the image contrast setting␟ed712a8b927041be15252b29eb521ebb1374bad8␟5370703342923611955:Reset contrast`,[[1,"general"],[1,"section-title"],[1,"control-row","x-axis-type"],["id","x-axis-type-label",1,"control-name"],[3,"value","options","selectionChange"],[1,"control-row","scalars-step-selector",3,"title"],[3,"checked","disabled","change"],[1,"indent"],[1,"indent","range-selection"],[1,"control-row","linked-time","indent"],["mat-button","",3,"ngClass","click",4,"ngIf"],[1,"control-row","card-width"],["id","card-width-label",1,"control-name"],[1,"slider-row"],["aria-labelledby","card-width-label","color","primary",3,"max","min","step"],["matSliderThumb","",3,"value","valueChange"],["mat-icon-button","","aria-label",t,"title","Reset card width",1,"reset-button",3,"click"],["svgIcon","settings_backup_restore_24px"],["class","control-row saving-pins",4,"ngIf"],[1,"scalars"],[1,"control-row","scalars-smoothing"],["id","scalars-smoothing-label",1,"control-name"],["aria-labelledby","scalars-smoothing-label","color","primary","discrete","",3,"max","min","step"],["aria-labelledby","scalars-smoothing-label","type","number","min","0","step","0.001",1,"slider-input",3,"max","value","input"],[1,"control-row","tooltip-sort"],[1,"control-name"],[1,"control-row","scalars-ignore-outliers"],[3,"checked","change"],[1,"control-row","scalars-partition-x"],["svgIcon","help_outline_24px","title","Non-monotonic steps can occur when reusing a logdir with multiple summary writers and overlapping steps. Line charts, without this option enabled, can appear zig zagged. This is common when restarting from a checkpoint.\n\nWhen enabled, a non-monotonic time series composed of N monotonic pieces will be shown as N monotonic lines.",1,"info"],[1,"Histograms"],[1,"control-row","histogram-mode"],["class","image",4,"ngIf"],["mat-button","",3,"ngClass","click"],["svgIcon","edit_24px"],[1,"control-row","saving-pins"],[3,"isChecked","onCheckboxToggled"],[1,"image"],[1,"control-row","image-brightness"],["id","image-brightness-label",1,"control-name"],["aria-labelledby","image-brightness-label","color","primary","discrete","",3,"max","min","step","displayWith"],["mat-icon-button","","aria-label",e,"title","Reset brightness",1,"reset-button",3,"click"],[1,"control-row","image-contrast"],["id","image-constrast-label",1,"control-name"],["aria-labelledby","image-constrast-label","color","primary","discrete","",3,"max","min","step","displayWith"],["mat-icon-button","","aria-label",i,"title","Reset contrast",1,"reset-button",3,"click"],[1,"control-row","image-show-actual-size"]]},template:function(e,i){1&e&&(f(0,"section",0)(1,"h3",1),T(2,"General"),g(),f(3,"div",2)(4,"div",3),T(5,"Horizontal Axis"),g(),f(6,"tb-dropdown",4),A("selectionChange",function(o){return i.xAxisTypeChanged.emit(o)}),g()(),f(7,"div",5)(8,"mat-checkbox",6),A("change",function(){return i.stepSelectorToggled.emit()}),T(9,"Enable step selection and data table "),g(),f(10,"span",7),T(11,"(Scalars only)"),g(),f(12,"div",8)(13,"mat-checkbox",6),A("change",function(){return i.rangeSelectionToggled.emit()}),T(14,"Enable Range Selection "),g()(),f(15,"div",9)(16,"mat-checkbox",6),A("change",function(){return i.linkedTimeToggled.emit()}),T(17),g()(),S(18,w1e,3,3,"button",10),g(),f(19,"div",11)(20,"div",12),T(21,"Card Width"),g(),f(22,"div",13)(23,"mat-slider",14)(24,"input",15),A("valueChange",function(o){return i.cardWidthSliderChanged$.emit(o)}),g()(),f(25,"button",16),A("click",function(){return i.cardWidthReset.emit()}),k(26,"mat-icon",17),g()()(),S(27,S1e,2,1,"div",18),g(),f(28,"section",19)(29,"h3",1),T(30,"Scalars"),g(),f(31,"div",20)(32,"div",21),T(33,"Smoothing"),g(),f(34,"div",13)(35,"mat-slider",22)(36,"input",15),A("valueChange",function(o){return i.scalarSmoothingControlChanged$.emit(o)}),g()(),f(37,"input",23),A("input",function(o){return i.onScalarSmoothingInput(o)}),g()()(),f(38,"div",24)(39,"div",25),T(40,"Tooltip sorting method"),g(),f(41,"tb-dropdown",4),A("selectionChange",function(o){return i.tooltipSortChanged.emit(o)}),g()(),f(42,"div",26)(43,"mat-checkbox",27),A("change",function(o){return i.ignoreOutliersChanged.emit(o.checked)}),T(44,"Ignore outliers in chart scaling"),g()(),f(45,"div",28)(46,"mat-checkbox",27),A("change",function(){return i.scalarPartitionXToggled.emit()}),T(47,"Partition non-monotonic X axis"),g(),k(48,"mat-icon",29),g()(),f(49,"section",30)(50,"h3",1),T(51,"Histograms"),g(),f(52,"div",31)(53,"div",25),T(54,"Mode"),g(),f(55,"tb-dropdown",4),A("selectionChange",function(o){return i.histogramModeChanged.emit(o)}),g()()(),S(56,E1e,22,11,"section",32)),2&e&&(v(6),b("value",i.xAxisType)("options",i.XAxisTypeDropdownOptions),v(1),b("title",i.isAxisTypeStep()?"":"Only available when Horizontal Axis is set to step"),v(1),b("checked",i.isScalarStepSelectorEnabled)("disabled",!i.isAxisTypeStep()),v(5),b("checked",i.isScalarStepSelectorRangeEnabled)("disabled",!i.isAxisTypeStep()),v(3),b("checked",i.isLinkedTimeEnabled)("disabled",!i.isAxisTypeStep()),v(1),Ve("Link by step ",i.getLinkedTimeSelectionStartStep()," "),v(1),b("ngIf",i.isScalarColumnCustomizationEnabled),v(5),b("max",i.MAX_CARD_WIDTH_SLIDER_VALUE)("min",i.MIN_CARD_WIDTH_SLIDER_VALUE)("step",50),v(1),b("value",i.cardMinWidth),v(3),b("ngIf",i.globalPinsFeatureEnabled),v(8),b("max",i.MAX_SMOOTHING_SLIDER_VALUE)("min",0)("step",.01),v(1),b("value",i.scalarSmoothing),v(1),b("max",i.MAX_SMOOTHING_VALUE)("value",i.scalarSmoothing),v(4),b("value",i.tooltipSort)("options",i.TooltipSortDropdownOptions),v(2),b("checked",i.ignoreOutliers),v(3),b("checked",i.scalarPartitionX),v(9),b("value",i.histogramMode)("options",i.HistogramModeDropdownOptions),v(1),b("ngIf",i.isImageSupportEnabled))},dependencies:[wn,Ne,SQ,ki,Er,xs,bn,Ju,$u,EQ],styles:["[_nghost-%COMP%]{color:#616161;font-size:12px}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;padding:16px}body.dark-mode[_nghost-%COMP%]   section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.section-title[_ngcontent-%COMP%]{color:#212121;text-transform:uppercase;font-weight:500;font-size:13px;line-height:normal;margin:0 0 12px 0}body.dark-mode[_nghost-%COMP%]   .section-title[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .section-title[_ngcontent-%COMP%]{color:#fff}section[_ngcontent-%COMP%]   .control-row[_ngcontent-%COMP%]:not(:has( + .control-row[_ngcontent-%COMP%] > mat-checkbox))[_ngcontent-%COMP%]:not(:last-child){margin-bottom:12px}.control-name[_ngcontent-%COMP%]{margin-bottom:8px}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:28px}.slider-row[_ngcontent-%COMP%]   .reset-button[_ngcontent-%COMP%]{margin-left:6px}.slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{background-color:inherit;border:1px solid #8e98a3;border-radius:2px;box-sizing:border-box;color:inherit;height:100%;margin-left:12px;padding:0 4px}body.dark-mode[_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{border-color:#425066}.scalars-smoothing[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{flex:none;width:5em}.scalars-partition-x[_ngcontent-%COMP%]{align-items:center;display:flex}.scalars-partition-x[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px;min-width:15px}mat-checkbox[_ngcontent-%COMP%]{margin-left:-11px}mat-checkbox[_ngcontent-%COMP%]     label{color:#616161;font-size:12px;letter-spacing:normal;padding-left:0px;white-space:nowrap}body.dark-mode[_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label, body.dark-mode   [_nghost-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{color:rgba(255,255,255,.7)}mat-slider[_ngcontent-%COMP%]{flex:1;margin-left:0px;margin-right:0px}.column-edit-menu-toggle[_ngcontent-%COMP%]{align-items:center;display:flex;cursor:pointer;font-size:inherit;height:28px;padding-left:5px;padding-right:12px}.column-edit-menu-toggle.mat-button-wrapper[_ngcontent-%COMP%]{display:inline-flex;align-items:center}.column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .column-edit-menu-toggle.toggle-opened[_ngcontent-%COMP%]{background-color:#424242}.column-edit-menu-toggle[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:6px}tb-dropdown[_ngcontent-%COMP%]{display:block}.control-row[_ngcontent-%COMP%]   .indent[_ngcontent-%COMP%]{margin-left:28px}"],changeDetection:0}),n})(),IQ=(()=>{class n{constructor(e,i){this.store=e,this.dialog=i,this.isScalarStepSelectorEnabled$=this.store.select(Cv),this.isScalarStepSelectorRangeEnabled$=this.store.select(Tu),this.isLinkedTimeEnabled$=this.store.select(Eu),this.isScalarColumnCustomizationEnabled$=this.store.select(uS),this.linkedTimeSelection$=this.store.select(JF),this.stepMinMax$=this.store.select(KF),this.isSlideOutMenuOpen$=this.store.select(h1),this.isImageSupportEnabled$=this.store.select(bu).pipe(Oe(Boolean),Lt(1),It(this.store.select(dS)),q(([,r])=>r)),this.tooltipSort$=this.store.select(xh),this.ignoreOutliers$=this.store.select(Ch),this.xAxisType$=this.store.select(Ol),this.cardMinWidth$=this.store.select(Jf),this.histogramMode$=this.store.select(a1),this.scalarSmoothing$=this.store.select(_d),this.scalarPartitionX$=this.store.select(s1),this.imageBrightnessInMilli$=this.store.select(l1),this.imageContrastInMilli$=this.store.select(c1),this.imageShowActualSize$=this.store.select(d1),this.isSavingPinsEnabled$=this.store.select(bd),this.globalPinsFeatureEnabled$=this.store.select(pd)}onTooltipSortChanged(e){this.store.dispatch(gT({sort:e}))}onIgnoreOutliersChanged(){this.store.dispatch(_T())}onXAxisTypeChanged(e){this.store.dispatch(bT({xAxisType:e}))}onCardWidthChanged(e){this.store.dispatch(vT({cardMinWidth:e}))}onCardWidthReset(){this.store.dispatch(yT())}onHistogramModeChanged(e){this.store.dispatch(DT({histogramMode:e}))}onScalarSmoothingChanged(e){this.store.dispatch(xT({smoothing:e}))}onScalarPartitionXToggled(){this.store.dispatch(CT())}onImageBrightnessInMilliChanged(e){this.store.dispatch(MT({brightnessInMilli:e}))}onImageBrightnessReset(){this.store.dispatch(ST())}onImageContrastReset(){this.store.dispatch(ET())}onImageContrastInMilliChanged(e){this.store.dispatch(wT({contrastInMilli:e}))}onImageShowActualSizeChanged(){this.store.dispatch(TT())}onLinkedTimeToggled(){this.store.dispatch(LT({affordance:Za.CHECK_BOX}))}onStepSelectorToggled(){this.store.dispatch(Td({affordance:Za.CHECK_BOX}))}onRangeSelectionToggled(){this.store.dispatch(BT({affordance:Za.CHECK_BOX}))}onSlideOutToggled(){this.store.dispatch(lT())}onEnableSavingPinsToggled(e){e?this.dialog.open(wQ).afterClosed().subscribe(r=>{r?.shouldDisable&&this.store.dispatch(zh())}):this.store.dispatch(zh())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(ys))},n.\u0275cmp=P({type:n,selectors:[["metrics-dashboard-settings"]],decls:21,vars:60,consts:[[3,"isImageSupportEnabled","tooltipSort","ignoreOutliers","xAxisType","cardMinWidth","histogramMode","scalarSmoothing","scalarPartitionX","imageBrightnessInMilli","imageContrastInMilli","imageShowActualSize","isScalarStepSelectorEnabled","isScalarStepSelectorRangeEnabled","isLinkedTimeEnabled","isScalarColumnCustomizationEnabled","linkedTimeSelection","stepMinMax","isSlideOutMenuOpen","isSavingPinsEnabled","globalPinsFeatureEnabled","tooltipSortChanged","ignoreOutliersChanged","xAxisTypeChanged","cardWidthChanged","cardWidthReset","histogramModeChanged","scalarSmoothingChanged","scalarPartitionXToggled","imageBrightnessInMilliChanged","imageBrightnessReset","imageContrastInMilliChanged","imageContrastReset","imageShowActualSizeChanged","linkedTimeToggled","stepSelectorToggled","rangeSelectionToggled","onSlideOutToggled","onEnableSavingPinsToggled"]],template:function(e,i){1&e&&(f(0,"metrics-dashboard-settings-component",0),A("tooltipSortChanged",function(o){return i.onTooltipSortChanged(o)})("ignoreOutliersChanged",function(){return i.onIgnoreOutliersChanged()})("xAxisTypeChanged",function(o){return i.onXAxisTypeChanged(o)})("cardWidthChanged",function(o){return i.onCardWidthChanged(o)})("cardWidthReset",function(){return i.onCardWidthReset()})("histogramModeChanged",function(o){return i.onHistogramModeChanged(o)})("scalarSmoothingChanged",function(o){return i.onScalarSmoothingChanged(o)})("scalarPartitionXToggled",function(){return i.onScalarPartitionXToggled()})("imageBrightnessInMilliChanged",function(o){return i.onImageBrightnessInMilliChanged(o)})("imageBrightnessReset",function(){return i.onImageBrightnessReset()})("imageContrastInMilliChanged",function(o){return i.onImageContrastInMilliChanged(o)})("imageContrastReset",function(){return i.onImageContrastReset()})("imageShowActualSizeChanged",function(){return i.onImageShowActualSizeChanged()})("linkedTimeToggled",function(){return i.onLinkedTimeToggled()})("stepSelectorToggled",function(){return i.onStepSelectorToggled()})("rangeSelectionToggled",function(){return i.onRangeSelectionToggled()})("onSlideOutToggled",function(){return i.onSlideOutToggled()})("onEnableSavingPinsToggled",function(o){return i.onEnableSavingPinsToggled(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),U(10,"async"),U(11,"async"),U(12,"async"),U(13,"async"),U(14,"async"),U(15,"async"),U(16,"async"),U(17,"async"),U(18,"async"),U(19,"async"),U(20,"async"),g()),2&e&&b("isImageSupportEnabled",G(1,20,i.isImageSupportEnabled$))("tooltipSort",G(2,22,i.tooltipSort$))("ignoreOutliers",G(3,24,i.ignoreOutliers$))("xAxisType",G(4,26,i.xAxisType$))("cardMinWidth",G(5,28,i.cardMinWidth$))("histogramMode",G(6,30,i.histogramMode$))("scalarSmoothing",G(7,32,i.scalarSmoothing$))("scalarPartitionX",G(8,34,i.scalarPartitionX$))("imageBrightnessInMilli",G(9,36,i.imageBrightnessInMilli$))("imageContrastInMilli",G(10,38,i.imageContrastInMilli$))("imageShowActualSize",G(11,40,i.imageShowActualSize$))("isScalarStepSelectorEnabled",G(12,42,i.isScalarStepSelectorEnabled$))("isScalarStepSelectorRangeEnabled",G(13,44,i.isScalarStepSelectorRangeEnabled$))("isLinkedTimeEnabled",G(14,46,i.isLinkedTimeEnabled$))("isScalarColumnCustomizationEnabled",G(15,48,i.isScalarColumnCustomizationEnabled$))("linkedTimeSelection",G(16,50,i.linkedTimeSelection$))("stepMinMax",G(17,52,i.stepMinMax$))("isSlideOutMenuOpen",G(18,54,i.isSlideOutMenuOpen$))("isSavingPinsEnabled",G(19,56,i.isSavingPinsEnabled$))("globalPinsFeatureEnabled",G(20,58,i.globalPinsFeatureEnabled$))},dependencies:[DQ,ct],encapsulation:2,changeDetection:0}),n})(),AQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-dashboard-right-pane"]],decls:1,vars:0,template:function(e,i){1&e&&k(0,"metrics-dashboard-settings")},dependencies:[IQ],encapsulation:2,changeDetection:0}),n})(),k1e=["tooltip"],kQ=new te("mat-tooltip-scroll-strategy"),N1e={provide:kQ,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition({scrollThrottle:20})}},B1e=new te("mat-tooltip-default-options",{providedIn:"root",factory:function(){return{showDelay:0,hideDelay:0,touchendHideDelay:1500}}}),RQ="tooltip-panel",PQ=za({passive:!0}),G1e=(()=>{class n{get position(){return this._position}set position(e){e!==this._position&&(this._position=e,this._overlayRef&&(this._updatePosition(this._overlayRef),this._tooltipInstance?.show(0),this._overlayRef.updatePosition()))}get positionAtOrigin(){return this._positionAtOrigin}set positionAtOrigin(e){this._positionAtOrigin=vt(e),this._detach(),this._overlayRef=null}get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e),this._disabled?this.hide(0):this._setupPointerEnterEventsIfNeeded()}get showDelay(){return this._showDelay}set showDelay(e){this._showDelay=mi(e)}get hideDelay(){return this._hideDelay}set hideDelay(e){this._hideDelay=mi(e),this._tooltipInstance&&(this._tooltipInstance._mouseLeaveHideDelay=this._hideDelay)}get message(){return this._message}set message(e){this._ariaDescriber.removeDescription(this._elementRef.nativeElement,this._message,"tooltip"),this._message=null!=e?String(e).trim():"",!this._message&&this._isTooltipVisible()?this.hide(0):(this._setupPointerEnterEventsIfNeeded(),this._updateTooltipMessage(),this._ngZone.runOutsideAngular(()=>{Promise.resolve().then(()=>{this._ariaDescriber.describe(this._elementRef.nativeElement,this.message,"tooltip")})}))}get tooltipClass(){return this._tooltipClass}set tooltipClass(e){this._tooltipClass=e,this._tooltipInstance&&this._setTooltipClass(this._tooltipClass)}constructor(e,i,r,o,a,s,l,c,d,u,p,h){this._overlay=e,this._elementRef=i,this._scrollDispatcher=r,this._viewContainerRef=o,this._ngZone=a,this._platform=s,this._ariaDescriber=l,this._focusMonitor=c,this._dir=u,this._defaultOptions=p,this._position="below",this._positionAtOrigin=!1,this._disabled=!1,this._viewInitialized=!1,this._pointerExitEventsInitialized=!1,this._viewportMargin=8,this._cssClassPrefix="mat",this._showDelay=this._defaultOptions.showDelay,this._hideDelay=this._defaultOptions.hideDelay,this.touchGestures="auto",this._message="",this._passiveListeners=[],this._destroyed=new Ee,this._scrollStrategy=d,this._document=h,p&&(p.position&&(this.position=p.position),p.positionAtOrigin&&(this.positionAtOrigin=p.positionAtOrigin),p.touchGestures&&(this.touchGestures=p.touchGestures)),u.change.pipe(it(this._destroyed)).subscribe(()=>{this._overlayRef&&this._updatePosition(this._overlayRef)})}ngAfterViewInit(){this._viewInitialized=!0,this._setupPointerEnterEventsIfNeeded(),this._focusMonitor.monitor(this._elementRef).pipe(it(this._destroyed)).subscribe(e=>{e?"keyboard"===e&&this._ngZone.run(()=>this.show()):this._ngZone.run(()=>this.hide(0))})}ngOnDestroy(){let e=this._elementRef.nativeElement;clearTimeout(this._touchstartTimeout),this._overlayRef&&(this._overlayRef.dispose(),this._tooltipInstance=null),this._passiveListeners.forEach(([i,r])=>{e.removeEventListener(i,r,PQ)}),this._passiveListeners.length=0,this._destroyed.next(),this._destroyed.complete(),this._ariaDescriber.removeDescription(e,this.message,"tooltip"),this._focusMonitor.stopMonitoring(e)}show(e=this.showDelay,i){if(this.disabled||!this.message||this._isTooltipVisible())return void this._tooltipInstance?._cancelPendingAnimations();let r=this._createOverlay(i);this._detach(),this._portal=this._portal||new Ll(this._tooltipComponent,this._viewContainerRef);let o=this._tooltipInstance=r.attach(this._portal).instance;o._triggerElement=this._elementRef.nativeElement,o._mouseLeaveHideDelay=this._hideDelay,o.afterHidden().pipe(it(this._destroyed)).subscribe(()=>this._detach()),this._setTooltipClass(this._tooltipClass),this._updateTooltipMessage(),o.show(e)}hide(e=this.hideDelay){let i=this._tooltipInstance;i&&(i.isVisible()?i.hide(e):(i._cancelPendingAnimations(),this._detach()))}toggle(e){this._isTooltipVisible()?this.hide():this.show(void 0,e)}_isTooltipVisible(){return!!this._tooltipInstance&&this._tooltipInstance.isVisible()}_createOverlay(e){if(this._overlayRef){let o=this._overlayRef.getConfig().positionStrategy;if((!this.positionAtOrigin||!e)&&o._origin instanceof xe)return this._overlayRef;this._detach()}let i=this._scrollDispatcher.getAncestorScrollContainers(this._elementRef),r=this._overlay.position().flexibleConnectedTo(this.positionAtOrigin&&e||this._elementRef).withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`).withFlexibleDimensions(!1).withViewportMargin(this._viewportMargin).withScrollableContainers(i);return r.positionChanges.pipe(it(this._destroyed)).subscribe(o=>{this._updateCurrentPositionClass(o.connectionPair),this._tooltipInstance&&o.scrollableViewProperties.isOverlayClipped&&this._tooltipInstance.isVisible()&&this._ngZone.run(()=>this.hide(0))}),this._overlayRef=this._overlay.create({direction:this._dir,positionStrategy:r,panelClass:`${this._cssClassPrefix}-${RQ}`,scrollStrategy:this._scrollStrategy()}),this._updatePosition(this._overlayRef),this._overlayRef.detachments().pipe(it(this._destroyed)).subscribe(()=>this._detach()),this._overlayRef.outsidePointerEvents().pipe(it(this._destroyed)).subscribe(()=>this._tooltipInstance?._handleBodyInteraction()),this._overlayRef.keydownEvents().pipe(it(this._destroyed)).subscribe(o=>{this._isTooltipVisible()&&27===o.keyCode&&!Or(o)&&(o.preventDefault(),o.stopPropagation(),this._ngZone.run(()=>this.hide(0)))}),this._defaultOptions?.disableTooltipInteractivity&&this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`),this._overlayRef}_detach(){this._overlayRef&&this._overlayRef.hasAttached()&&this._overlayRef.detach(),this._tooltipInstance=null}_updatePosition(e){let i=e.getConfig().positionStrategy,r=this._getOrigin(),o=this._getOverlayPosition();i.withPositions([this._addOffset({...r.main,...o.main}),this._addOffset({...r.fallback,...o.fallback})])}_addOffset(e){return e}_getOrigin(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i||"below"==i?r={originX:"center",originY:"above"==i?"top":"bottom"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={originX:"start",originY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={originX:"end",originY:"center"});let{x:o,y:a}=this._invertPosition(r.originX,r.originY);return{main:r,fallback:{originX:o,originY:a}}}_getOverlayPosition(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i?r={overlayX:"center",overlayY:"bottom"}:"below"==i?r={overlayX:"center",overlayY:"top"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={overlayX:"end",overlayY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={overlayX:"start",overlayY:"center"});let{x:o,y:a}=this._invertPosition(r.overlayX,r.overlayY);return{main:r,fallback:{overlayX:o,overlayY:a}}}_updateTooltipMessage(){this._tooltipInstance&&(this._tooltipInstance.message=this.message,this._tooltipInstance._markForCheck(),this._ngZone.onMicrotaskEmpty.pipe(Lt(1),it(this._destroyed)).subscribe(()=>{this._tooltipInstance&&this._overlayRef.updatePosition()}))}_setTooltipClass(e){this._tooltipInstance&&(this._tooltipInstance.tooltipClass=e,this._tooltipInstance._markForCheck())}_invertPosition(e,i){return"above"===this.position||"below"===this.position?"top"===i?i="bottom":"bottom"===i&&(i="top"):"end"===e?e="start":"start"===e&&(e="end"),{x:e,y:i}}_updateCurrentPositionClass(e){let a,{overlayY:i,originX:r,originY:o}=e;if(a="center"===i?this._dir&&"rtl"===this._dir.value?"end"===r?"left":"right":"start"===r?"left":"right":"bottom"===i&&"top"===o?"above":"below",a!==this._currentPosition){let s=this._overlayRef;if(s){let l=`${this._cssClassPrefix}-${RQ}-`;s.removePanelClass(l+this._currentPosition),s.addPanelClass(l+a)}this._currentPosition=a}}_setupPointerEnterEventsIfNeeded(){this._disabled||!this.message||!this._viewInitialized||this._passiveListeners.length||(this._platformSupportsMouseEvents()?this._passiveListeners.push(["mouseenter",e=>{let i;this._setupPointerExitEventsIfNeeded(),void 0!==e.x&&void 0!==e.y&&(i=e),this.show(void 0,i)}]):"off"!==this.touchGestures&&(this._disableNativeGesturesIfNecessary(),this._passiveListeners.push(["touchstart",e=>{let i=e.targetTouches?.[0],r=i?{x:i.clientX,y:i.clientY}:void 0;this._setupPointerExitEventsIfNeeded(),clearTimeout(this._touchstartTimeout),this._touchstartTimeout=setTimeout(()=>this.show(void 0,r),500)}])),this._addListeners(this._passiveListeners))}_setupPointerExitEventsIfNeeded(){if(this._pointerExitEventsInitialized)return;this._pointerExitEventsInitialized=!0;let e=[];if(this._platformSupportsMouseEvents())e.push(["mouseleave",i=>{let r=i.relatedTarget;(!r||!this._overlayRef?.overlayElement.contains(r))&&this.hide()}],["wheel",i=>this._wheelListener(i)]);else if("off"!==this.touchGestures){this._disableNativeGesturesIfNecessary();let i=()=>{clearTimeout(this._touchstartTimeout),this.hide(this._defaultOptions.touchendHideDelay)};e.push(["touchend",i],["touchcancel",i])}this._addListeners(e),this._passiveListeners.push(...e)}_addListeners(e){e.forEach(([i,r])=>{this._elementRef.nativeElement.addEventListener(i,r,PQ)})}_platformSupportsMouseEvents(){return!this._platform.IOS&&!this._platform.ANDROID}_wheelListener(e){if(this._isTooltipVisible()){let i=this._document.elementFromPoint(e.clientX,e.clientY),r=this._elementRef.nativeElement;i!==r&&!r.contains(i)&&this.hide()}}_disableNativeGesturesIfNecessary(){let e=this.touchGestures;if("off"!==e){let i=this._elementRef.nativeElement,r=i.style;("on"===e||"INPUT"!==i.nodeName&&"TEXTAREA"!==i.nodeName)&&(r.userSelect=r.msUserSelect=r.webkitUserSelect=r.MozUserSelect="none"),("on"===e||!i.draggable)&&(r.webkitUserDrag="none"),r.touchAction="none",r.webkitTapHighlightColor="transparent"}}}return n.\u0275fac=function(e){cs()},n.\u0275dir=Me({type:n,inputs:{position:["matTooltipPosition","position"],positionAtOrigin:["matTooltipPositionAtOrigin","positionAtOrigin"],disabled:["matTooltipDisabled","disabled"],showDelay:["matTooltipShowDelay","showDelay"],hideDelay:["matTooltipHideDelay","hideDelay"],touchGestures:["matTooltipTouchGestures","touchGestures"],message:["matTooltip","message"],tooltipClass:["matTooltipClass","tooltipClass"]}}),n})(),GT=(()=>{class n extends G1e{constructor(e,i,r,o,a,s,l,c,d,u,p,h){super(e,i,r,o,a,s,l,c,d,u,p,h),this._tooltipComponent=q1e,this._cssClassPrefix="mat-mdc",this._viewportMargin=8}_addOffset(e){let r=!this._dir||"ltr"==this._dir.value;return"top"===e.originY?e.offsetY=-8:"bottom"===e.originY?e.offsetY=8:"start"===e.originX?e.offsetX=r?-8:8:"end"===e.originX&&(e.offsetX=r?8:-8),e}}return n.\u0275fac=function(e){return new(e||n)(C(Oi),C(xe),C(Lu),C(ei),C(ot),C(Vn),C(T7),C(fo),C(kQ),C(zi,8),C(B1e,8),C(Nt))},n.\u0275dir=Me({type:n,selectors:[["","matTooltip",""]],hostAttrs:[1,"mat-mdc-tooltip-trigger"],exportAs:["matTooltip"],features:[Xe]}),n})(),W1e=(()=>{class n{constructor(e,i){this._changeDetectorRef=e,this._closeOnInteraction=!1,this._isVisible=!1,this._onHide=new Ee,this._animationsDisabled="NoopAnimations"===i}show(e){clearTimeout(this._hideTimeoutId),this._showTimeoutId=setTimeout(()=>{this._toggleVisibility(!0),this._showTimeoutId=void 0},e)}hide(e){clearTimeout(this._showTimeoutId),this._hideTimeoutId=setTimeout(()=>{this._toggleVisibility(!1),this._hideTimeoutId=void 0},e)}afterHidden(){return this._onHide}isVisible(){return this._isVisible}ngOnDestroy(){this._cancelPendingAnimations(),this._onHide.complete(),this._triggerElement=null}_handleBodyInteraction(){this._closeOnInteraction&&this.hide(0)}_markForCheck(){this._changeDetectorRef.markForCheck()}_handleMouseLeave({relatedTarget:e}){(!e||!this._triggerElement.contains(e))&&(this.isVisible()?this.hide(this._mouseLeaveHideDelay):this._finalizeAnimation(!1))}_onShow(){}_handleAnimationEnd({animationName:e}){(e===this._showAnimation||e===this._hideAnimation)&&this._finalizeAnimation(e===this._showAnimation)}_cancelPendingAnimations(){clearTimeout(this._showTimeoutId),clearTimeout(this._hideTimeoutId),this._showTimeoutId=this._hideTimeoutId=void 0}_finalizeAnimation(e){e?this._closeOnInteraction=!0:this.isVisible()||this._onHide.next()}_toggleVisibility(e){let i=this._tooltip.nativeElement,r=this._showAnimation,o=this._hideAnimation;if(i.classList.remove(e?o:r),i.classList.add(e?r:o),this._isVisible=e,e&&!this._animationsDisabled&&"function"==typeof getComputedStyle){let a=getComputedStyle(i);("0s"===a.getPropertyValue("animation-duration")||"none"===a.getPropertyValue("animation-name"))&&(this._animationsDisabled=!0)}e&&this._onShow(),this._animationsDisabled&&(i.classList.add("_mat-animation-noopable"),this._finalizeAnimation(e))}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(pi,8))},n.\u0275dir=Me({type:n}),n})(),q1e=(()=>{class n extends W1e{constructor(e,i,r){super(e,r),this._elementRef=i,this._isMultiline=!1,this._showAnimation="mat-mdc-tooltip-show",this._hideAnimation="mat-mdc-tooltip-hide"}_onShow(){this._isMultiline=this._isTooltipMultiline(),this._markForCheck()}_isTooltipMultiline(){let e=this._elementRef.nativeElement.getBoundingClientRect();return e.height>24&&e.width>=200}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(xe),C(pi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-tooltip-component"]],viewQuery:function(e,i){if(1&e&&Ue(k1e,7),2&e){let r;be(r=ve())&&(i._tooltip=r.first)}},hostAttrs:["aria-hidden","true"],hostVars:2,hostBindings:function(e,i){1&e&&A("mouseleave",function(o){return i._handleMouseLeave(o)}),2&e&&Bt("zoom",i.isVisible()?1:null)},features:[Xe],decls:4,vars:4,consts:[[1,"mdc-tooltip","mdc-tooltip--shown","mat-mdc-tooltip",3,"ngClass","animationend"],["tooltip",""],[1,"mdc-tooltip__surface","mdc-tooltip__surface-animation"]],template:function(e,i){1&e&&(f(0,"div",0,1),A("animationend",function(o){return i._handleAnimationEnd(o)}),f(2,"div",2),T(3),g()()),2&e&&(nt("mdc-tooltip--multiline",i._isMultiline),b("ngClass",i.tooltipClass),v(3),kt(i.message))},dependencies:[wn],styles:['.mdc-tooltip__surface{word-break:var(--mdc-tooltip-word-break, normal);overflow-wrap:anywhere}.mdc-tooltip{position:fixed;display:none;z-index:9}.mdc-tooltip-wrapper--rich{position:relative}.mdc-tooltip--shown,.mdc-tooltip--showing,.mdc-tooltip--hide{display:inline-flex}.mdc-tooltip--shown.mdc-tooltip--rich,.mdc-tooltip--showing.mdc-tooltip--rich,.mdc-tooltip--hide.mdc-tooltip--rich{display:inline-block;left:-320px;position:absolute}.mdc-tooltip__surface{line-height:16px;padding:4px 8px;min-width:40px;max-width:200px;min-height:24px;max-height:40vh;box-sizing:border-box;overflow:hidden;text-align:center}.mdc-tooltip__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:1px solid rgba(0,0,0,0);border-radius:inherit;content:"";pointer-events:none}@media screen and (forced-colors: active){.mdc-tooltip__surface::before{border-color:CanvasText}}.mdc-tooltip--rich .mdc-tooltip__surface{align-items:flex-start;display:flex;flex-direction:column;min-height:24px;min-width:40px;max-width:320px;position:relative}.mdc-tooltip--multiline .mdc-tooltip__surface{text-align:left}[dir=rtl] .mdc-tooltip--multiline .mdc-tooltip__surface,.mdc-tooltip--multiline .mdc-tooltip__surface[dir=rtl]{text-align:right}.mdc-tooltip__surface .mdc-tooltip__title{margin:0 8px}.mdc-tooltip__surface .mdc-tooltip__content{max-width:calc(200px - (2 * 8px));margin:8px;text-align:left}[dir=rtl] .mdc-tooltip__surface .mdc-tooltip__content,.mdc-tooltip__surface .mdc-tooltip__content[dir=rtl]{text-align:right}.mdc-tooltip--rich .mdc-tooltip__surface .mdc-tooltip__content{max-width:calc(320px - (2 * 8px));align-self:stretch}.mdc-tooltip__surface .mdc-tooltip__content-link{text-decoration:none}.mdc-tooltip--rich-actions,.mdc-tooltip__content,.mdc-tooltip__title{z-index:1}.mdc-tooltip__surface-animation{opacity:0;transform:scale(0.8);will-change:transform,opacity}.mdc-tooltip--shown .mdc-tooltip__surface-animation{transform:scale(1);opacity:1}.mdc-tooltip--hide .mdc-tooltip__surface-animation{transform:scale(1)}.mdc-tooltip__caret-surface-top,.mdc-tooltip__caret-surface-bottom{position:absolute;height:24px;width:24px;transform:rotate(35deg) skewY(20deg) scaleX(0.9396926208)}.mdc-tooltip__caret-surface-top .mdc-elevation-overlay,.mdc-tooltip__caret-surface-bottom .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-tooltip__caret-surface-bottom{outline:1px solid rgba(0,0,0,0);z-index:-1}@media screen and (forced-colors: active){.mdc-tooltip__caret-surface-bottom{outline-color:CanvasText}}.mdc-tooltip__surface{background-color:var(--mdc-plain-tooltip-container-color, #fff)}.mdc-tooltip__surface{border-radius:var(--mdc-plain-tooltip-container-shape, var(--mdc-shape-small, 4px))}.mdc-tooltip__caret-surface-top,.mdc-tooltip__caret-surface-bottom{border-radius:var(--mdc-plain-tooltip-container-shape, var(--mdc-shape-small, 4px))}.mdc-tooltip__surface{color:var(--mdc-plain-tooltip-supporting-text-color, #000)}.mdc-tooltip__surface{font-family:var(--mdc-plain-tooltip-supporting-text-font, inherit);font-size:var(--mdc-plain-tooltip-supporting-text-size, inherit);font-weight:var(--mdc-plain-tooltip-supporting-text-weight, inherit);letter-spacing:var(--mdc-plain-tooltip-supporting-text-tracking, inherit)}.mat-mdc-tooltip{position:relative;transform:scale(0)}.mat-mdc-tooltip::before{content:"";top:0;right:0;bottom:0;left:0;z-index:-1;position:absolute}.mat-mdc-tooltip-panel-below .mat-mdc-tooltip::before{top:-8px}.mat-mdc-tooltip-panel-above .mat-mdc-tooltip::before{bottom:-8px}.mat-mdc-tooltip-panel-right .mat-mdc-tooltip::before{left:-8px}.mat-mdc-tooltip-panel-left .mat-mdc-tooltip::before{right:-8px}.mat-mdc-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.mat-mdc-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-mdc-tooltip-show{0%{opacity:0;transform:scale(0.8)}100%{opacity:1;transform:scale(1)}}@keyframes mat-mdc-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(0.8)}}.mat-mdc-tooltip-show{animation:mat-mdc-tooltip-show 150ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-mdc-tooltip-hide{animation:mat-mdc-tooltip-hide 75ms cubic-bezier(0.4, 0, 1, 1) forwards}'],encapsulation:2,changeDetection:0}),n})(),Xg=(fr("state",[Si("initial, void, hidden",rn({opacity:0,transform:"scale(0.8)"})),Si("visible",rn({transform:"scale(1)"})),bi("* => visible",Mi("150ms cubic-bezier(0, 0, 0.2, 1)")),bi("* => hidden",Mi("75ms cubic-bezier(0.4, 0, 1, 1)"))]),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[N1e],imports:[pg,De,Do,dn,dn,Ic]}),n})());function X1e(n,t){1&n&&k(0,"mat-icon",4)}function Y1e(n,t){1&n&&k(0,"mat-icon",4)}function Q1e(n,t){1&n&&k(0,"mat-icon",4)}function Z1e(n,t){1&n&&k(0,"div",5)}var K1e=function(){return{sensitivity:"accent"}},WT=(()=>{class n{constructor(){this.ColumnHeaderType=gt}getSpecialTypeClasses(e){switch(e){case gt.STEP_AT_MIN:return"step-at-min";case gt.STEP_AT_MAX:return"step-at-max";default:return""}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-header"]],inputs:{header:"header"},decls:7,vars:9,consts:[[1,"header-container",3,"ngSwitch"],["svgIcon","change_history_24px",4,"ngSwitchCase"],["class","extra-right-padding",4,"ngSwitchDefault"],[3,"ngClass","matTooltip","matTooltipDisabled"],["svgIcon","change_history_24px"],[1,"extra-right-padding"]],template:function(e,i){1&e&&(f(0,"div",0),S(1,X1e,1,0,"mat-icon",1),S(2,Y1e,1,0,"mat-icon",1),S(3,Q1e,1,0,"mat-icon",1),S(4,Z1e,1,0,"div",2),f(5,"span",3),T(6),g()()),2&e&&(b("ngSwitch",i.header.type),v(1),b("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),v(1),b("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE),v(1),b("ngSwitchCase",i.ColumnHeaderType.RAW_CHANGE),v(2),b("ngClass",i.getSpecialTypeClasses(i.header.type))("matTooltip",i.header.name)("matTooltipDisabled",0===i.header.name.localeCompare(i.header.displayName,void 0,mc(8,K1e))),v(1),kt(i.header.displayName))},dependencies:[wn,mr,kr,du,bn,GT],styles:[".header-container[_ngcontent-%COMP%]{align-items:center;display:flex}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}mat-icon[_ngcontent-%COMP%]{height:12px;width:12px;min-width:12px;line-height:12px}.step-at-min[_ngcontent-%COMP%]{min-width:37px}.step-at-max[_ngcontent-%COMP%]{min-width:40px}"],changeDetection:0}),n})();function J1e(n,t){if(1&n){let e=Te();f(0,"div",8),A("dragstart",function(){let o=ne(e).$implicit;return ie(w(2).dragStart(o))})("dragend",function(){ne(e);let r=w().dataTableMode;return ie(w().dragEnd(r))})("dragenter",function(){let o=ne(e).$implicit,a=w().dataTableMode;return ie(w().dragEnter(o,a))}),f(1,"mat-checkbox",9),A("change",function(){let o=ne(e).$implicit,a=w().dataTableMode;return ie(w().toggleHeader(o,a))}),k(2,"tb-data-table-header",10),g()()}if(2&n){let e=t.$implicit;b("ngClass",w(2).getHighlightClasses(e)),v(1),b("checked",e.enabled),v(1),b("header",e)}}function $1e(n,t){1&n&&S(0,J1e,3,3,"div",7),2&n&&b("ngForOf",t.headers)}var NQ=function(n,t){return{headers:n,dataTableMode:t}},IN=n=>{n.preventDefault()},LQ=(n,t)=>t.findIndex(e=>e.name===n.name),Dd=(()=>(function(n){n[n.TOP=0]="TOP",n[n.BOTTOM=1]="BOTTOM"}(Dd||(Dd={})),Dd))(),BQ=(()=>{class n{constructor(e){this.hostElement=e,this.DataTableMode=Wr,this.highlightEdge=Dd.TOP,this.onScalarTableColumnEdit=new F,this.onScalarTableColumnToggled=new F,this.onScalarTableColumnEditorClosed=new F,this.onTabChange=new F}ngOnDestroy(){this.hostElement.nativeElement.removeEventListener("dragover",IN)}tabChange(e){this.onTabChange.emit(0===e.index?Wr.SINGLE:Wr.RANGE)}dragStart(e){this.draggingHeader=e,this.hostElement.nativeElement.addEventListener("dragover",IN)}dragEnd(e){if(!this.draggingHeader||!this.highlightedHeader)return;this.getHeadersForMode(e);let r={...this.draggingHeader},o={...this.highlightedHeader};r&&o&&r.name!==o.name&&this.onScalarTableColumnEdit.emit({source:r,destination:o,side:this.highlightEdge===Dd.TOP?mo.LEFT:mo.RIGHT,dataTableMode:e}),this.draggingHeader=void 0,this.highlightedHeader=void 0,this.hostElement.nativeElement.removeEventListener("dragover",IN)}dragEnter(e,i){if(!this.draggingHeader)return;let r=this.getHeadersForMode(i);this.highlightEdge=LQ(e,r)<LQ(this.draggingHeader,r)?Dd.TOP:Dd.BOTTOM,this.highlightedHeader=e}toggleHeader(e,i){this.onScalarTableColumnToggled.emit({dataTableMode:i,header:e})}getHighlightClasses(e){return e.name!==this.highlightedHeader?.name?{}:{highlighted:!0,"highlight-top":this.highlightEdge===Dd.TOP,"highlight-bottom":this.highlightEdge===Dd.BOTTOM}}getSelectedTabIndex(){return this.selectedTab===Wr.SINGLE?0:1}getHeadersForMode(e){return e===Wr.SINGLE?this.singleHeaders:this.rangeHeaders}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275cmp=P({type:n,selectors:[["metrics-scalar-column-editor-component"]],inputs:{rangeHeaders:"rangeHeaders",singleHeaders:"singleHeaders",selectedTab:"selectedTab"},outputs:{onScalarTableColumnEdit:"onScalarTableColumnEdit",onScalarTableColumnToggled:"onScalarTableColumnToggled",onScalarTableColumnEditorClosed:"onScalarTableColumnEditorClosed",onTabChange:"onTabChange"},decls:11,vars:13,consts:function(){let t;return t=$localize`:Label on a button to close the column editor.␟cb616ce9b4327b41e6bdb9344669ba7c72e2c70e␟7205635764713034842:Close column editor`,[[1,"editor-controls"],[1,"tab-group",3,"selectedIndex","selectedTabChange"],[3,"label"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"footer"],["mat-button","","aria-label",t,1,"close-button",3,"click"],["headerList",""],["class","header-list-item","draggable","true",3,"ngClass","dragstart","dragend","dragenter",4,"ngFor","ngForOf"],["draggable","true",1,"header-list-item",3,"ngClass","dragstart","dragend","dragenter"],[3,"checked","change"],[3,"header"]]},template:function(e,i){if(1&e&&(f(0,"div",0)(1,"mat-tab-group",1),A("selectedTabChange",function(o){return i.tabChange(o)}),f(2,"mat-tab",2),hi(3,3),g(),f(4,"mat-tab",2),hi(5,3),g()()(),f(6,"div",4)(7,"button",5),A("click",function(){return i.onScalarTableColumnEditorClosed.emit()}),T(8," Close "),g()(),S(9,$1e,1,1,"ng-template",null,6,jt)),2&e){let r=st(10);v(1),b("selectedIndex",i.getSelectedTabIndex()),v(1),b("label","Single"),v(1),b("ngTemplateOutlet",r)("ngTemplateOutletContext",So(7,NQ,i.singleHeaders,i.DataTableMode.SINGLE)),v(1),b("label","Range"),v(1),b("ngTemplateOutlet",r)("ngTemplateOutletContext",So(10,NQ,i.rangeHeaders,i.DataTableMode.RANGE))}},dependencies:[wn,nn,eo,WT,xs,ay,vE,ki],styles:["[_nghost-%COMP%]     .mat-tab-label{min-width:0;padding:0 30px}.editor-controls[_ngcontent-%COMP%]{height:calc(100% - 45px)}.tab-group[_ngcontent-%COMP%]{position:relative;z-index:0;height:100%}.header-list-item[_ngcontent-%COMP%]{padding:3px;height:24px}.highlighted[_ngcontent-%COMP%]{background-color:#eee}.highlight-bottom[_ngcontent-%COMP%]{border-bottom:2px solid #ff9800}.highlight-top[_ngcontent-%COMP%]{border-top:2px solid #ff9800}.footer[_ngcontent-%COMP%]{display:flex;position:absolute;left:0;bottom:0;box-sizing:border-box;width:100%;align-items:center;justify-content:flex-end;padding:4px;border-top:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .footer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .footer[_ngcontent-%COMP%]{border-color:#555}.close-button[_ngcontent-%COMP%]{color:#616161;width:84px}body.dark-mode[_nghost-%COMP%]   .close-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .close-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}  .mat-mdc-tab-body-wrapper{flex:1}"],changeDetection:0}),n})();function VQ(n){return n.filter(t=>"RUN"!==t.type)}var HQ=(()=>{class n{constructor(e){this.store=e,this.singleHeaders$=this.store.select(Mv).pipe(q(VQ)),this.rangeHeaders$=this.store.select(wv).pipe(q(VQ)),this.selectedTab$=this.store.select(LW)}onScalarTableColumnToggled(e){this.store.dispatch(Gg(e))}onScalarTableColumnEdit(e){this.store.dispatch(jg(e))}onScalarTableColumnEditorClosed(){this.store.dispatch(uT())}onTabChange(e){this.store.dispatch(dT({tab:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-scalar-column-editor"]],decls:4,vars:9,consts:[[3,"singleHeaders","rangeHeaders","selectedTab","onScalarTableColumnToggled","onScalarTableColumnEdit","onScalarTableColumnEditorClosed","onTabChange"]],template:function(e,i){1&e&&(f(0,"metrics-scalar-column-editor-component",0),A("onScalarTableColumnToggled",function(o){return i.onScalarTableColumnToggled(o)})("onScalarTableColumnEdit",function(o){return i.onScalarTableColumnEdit(o)})("onScalarTableColumnEditorClosed",function(){return i.onScalarTableColumnEditorClosed()})("onTabChange",function(o){return i.onTabChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("singleHeaders",G(1,3,i.singleHeaders$))("rangeHeaders",G(2,5,i.rangeHeaders$))("selectedTab",G(3,7,i.selectedTab$))},dependencies:[BQ,ct],encapsulation:2,changeDetection:0}),n})(),Yg=(()=>(function(n){n[n.ORIGINAL=0]="ORIGINAL",n[n.DERIVED=1]="DERIVED"}(Yg||(Yg={})),Yg))(),nEe=W(DW,Ru,(n,t)=>new Set(Object.entries(n.scalars.tagToRuns).filter(([,e])=>!t||!t.size||e.some(i=>t?.get(i))).map(([e])=>e))),iEe=W(o1,Ru,NW,nEe,(n,t,e,i)=>{let r=Array.from(t?.values()||[]).some(Boolean);return n.filter(o=>gs(o.plugin)?Boolean(t&&t.get(o.runId)):!e||!r||o.plugin!==An.SCALARS||i.has(o.tag))}),jh=W(iEe,n=>n.sort((t,e)=>vy(t.tag,e.tag))),qT={filterRunItemsByRegex:(n,t,e)=>t?n.filter(i=>S1({runName:i.run.name,experimentAlias:i.experimentAlias},t,e)):n,matchFilter:(n,t)=>void 0===t?n.includeUndefined:n.type===io.DISCRETE?n.filterValues.includes(t):n.type===io.INTERVAL&&"number"==typeof t&&n.filterLowerValue<=t&&t<=n.filterUpperValue,filterRunItemsByHparamAndMetricFilter:(n,t,e)=>n.filter(({hparams:i,metrics:r})=>{let o=[...t.entries()].every(([s,l])=>{let c=i.get(s);return qT.matchFilter(l,c)}),a=[...e.entries()].every(([s,l])=>{let c=r.get(s);return qT.matchFilter(l,c)});return o&&a})},XT=W(RF,IS,AS,(n,t,e)=>new Map([...n,...t,...e])),rEe=W(v1,yu,Ru,Pu,qs,(n,t,e,i,r)=>n.map(o=>{let a=new Map;(o.hparams||[]).forEach(l=>{a.set(l.name,l.value)});let s=new Map;return(o.metrics||[]).forEach(l=>{s.set(l.tag,l.value)}),{run:o,experimentName:t[o.experimentId]||"",experimentAlias:r[o.experimentId],selected:Boolean(e&&e.get(o.id)),runColor:i[o.id],hparams:a,metrics:s}})),AN=W(Au,rEe,IS,AS,Ws,(n,t,e,i,r)=>{let o=qT.filterRunItemsByRegex(t,n,r===Cn.COMPARE_EXPERIMENT);return qT.filterRunItemsByHparamAndMetricFilter(o,e,i)}),zQ=W(AN,n=>new Set(n.map(({run:{id:t}})=>t))),UQ=W(DS,or,(n,t)=>t?n.map(e=>({type:gt.HPARAM,name:e.name,displayName:e.displayName||e.name,enabled:!1,tags:e.differs?["differs"]:[],removable:!0,sortable:!0,movable:!0,filterable:!0})):[]),YT=W(UQ,md,(n,t)=>{let e=new Set(t.map(({name:i})=>i));return n.filter(i=>!e.has(i.name))}),Qg=(_s(n=>W(e2(n),UQ,(t,e)=>[...t,...e])),(()=>{class n{constructor(e,i){this.ref=e,this.cdkScrollable=i,this.onVisibilityChange=new F,this.ngUnsubscribe$=new Ee,this.onEvent$=new Ee}ngOnInit(){let e={root:this.cdkScrollable?this.cdkScrollable.getElementRef().nativeElement:null};this.intersectionObserverMargin&&(e.rootMargin=this.intersectionObserverMargin);let i=new IntersectionObserver(r=>{this.onEvent$.next(r)},e);i.observe(this.ref.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(this.ref.nativeElement)}),this.onEvent$.pipe(it(this.ngUnsubscribe$)).subscribe(r=>{let o=r.slice(-1)[0];this.onVisibilityChange.emit({visible:o.isIntersecting})})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}waitForEventForTestOnly(){return new Promise(e=>this.onEvent$.pipe(Lt(1)).subscribe(()=>{e()}))}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(xd,8))},n.\u0275dir=Me({type:n,selectors:[["","observeIntersection",""]],inputs:{intersectionObserverMargin:"intersectionObserverMargin"},outputs:{onVisibilityChange:"onVisibilityChange"}}),n})()),jQ="/scalar_summary";function Zg(n,t){let e=n;return t&&n.startsWith(t+"/")&&(e=n.slice(t.length+1)),e.endsWith(jQ)&&(e=e.slice(0,-jQ.length)),e||n}var QT=(()=>{class n{constructor(e,i){this.store=e,this.changeDetectorRef=i,this.hrefAttr=void 0,this.srcAttr=void 0,this.includeFeatureFlags=!0}getUrlWithFeatureFlags(e){return this.store.select(Hf).pipe(q(i=>{if(Object.keys(i).length>0){let r=new URLSearchParams([["tensorBoardFeatureFlags",JSON.stringify(i)]]),o=e.includes("?")?"&":"?";return e+o+String(r)}return e}))}set href(e){e&&AC(this.getUrlWithFeatureFlags(e)).then(i=>{this.hrefAttr=i,this.changeDetectorRef.detectChanges()})}set src(e){e&&AC(this.getUrlWithFeatureFlags(e)).then(i=>{this.srcAttr=i,this.changeDetectorRef.detectChanges()})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(Qt))},n.\u0275dir=Me({type:n,selectors:[["a","includeFeatureFlags",""],["img","includeFeatureFlags",""]],hostVars:2,hostBindings:function(e,i){2&e&&Be("href",i.hrefAttr,Vs)("src",i.srcAttr,Vs)},inputs:{includeFeatureFlags:"includeFeatureFlags",href:"href",src:"src"}}),n})(),oEe=["measurer"],aEe=["input"],WQ=(()=>{class n{constructor(e){this.changeDetector=e,this.placeholder="",this.style="default",this.patternRegex=new RegExp(".*"),this.isValid=!0,this.onValueChange=new F,this.blur=new F,this.focus=new F,this.keydown=new F,this.keyup=new F,this.internalValue="",this.fontChangeListener=this.updateInputWidth.bind(this)}ngOnInit(){document.fonts&&document.fonts.addEventListener("loadingdone",this.fontChangeListener)}ngOnDestroy(){document.fonts&&document.fonts.removeEventListener("loadingdone",this.fontChangeListener)}ngOnChanges(e){e.pattern&&(this.patternRegex=new RegExp(this.pattern??"")),e.value&&(this.internalValue=this.value),this.isValid=this.patternRegex.test(this.internalValue)}ngAfterViewChecked(){this.updateInputWidth()}onInput(e){let i=this.internalValue;this.internalValue=this.inputElRef.nativeElement.value,this.internalValue!==i&&(this.isValid=this.patternRegex.test(this.internalValue),this.changeDetector.markForCheck()),this.onValueChange.emit({value:this.internalValue})}updateInputWidth(){let{width:e}=this.measurerElRef.nativeElement.getBoundingClientRect();this.inputElRef.nativeElement.style.width=`${e}px`}}return n.\u0275fac=function(e){return new(e||n)(C(Qt))},n.\u0275cmp=P({type:n,selectors:[["content-wrapping-input"]],viewQuery:function(e,i){if(1&e&&(Ue(oEe,7,xe),Ue(aEe,7,xe)),2&e){let r;be(r=ve())&&(i.measurerElRef=r.first),be(r=ve())&&(i.inputElRef=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&Xo(i.style)},inputs:{value:"value",placeholder:"placeholder",style:"style",pattern:"pattern"},outputs:{onValueChange:"onValueChange",blur:"blur",focus:"focus",keydown:"keydown",keyup:"keyup"},features:[qt],decls:6,vars:7,consts:[["aria-hidden","true",1,"measurer"],["measurer",""],["autocomplete","off","spellcheck","false","type","text",3,"value","placeholder","blur","focus","input","keydown","keyup"],["input",""]],template:function(e,i){1&e&&(f(0,"span")(1,"span",0,1),T(3),g(),f(4,"input",2,3),A("blur",function(o){return i.blur.emit(o)})("focus",function(o){return i.focus.emit(o)})("input",function(o){return i.onInput(o)})("keydown",function(o){return i.keydown.emit(o)})("keyup",function(o){return i.keyup.emit(o)}),g()()),2&e&&(nt("container",!0)("is-valid",i.isValid),v(3),kt(i.internalValue||i.placeholder),v(1),b("value",i.value)("placeholder",i.placeholder))},styles:["[_nghost-%COMP%]{display:inline-flex;width:max-content}[_nghost-%COMP%]:focus-within   .container[_ngcontent-%COMP%]{border-color:#f57c00}.default[_nghost-%COMP%]:hover   .container[_ngcontent-%COMP%]{border-color:#ebebeb}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%], [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid){border-color:#ef9a9a}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover, .error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:focus-within, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):hover, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):focus-within{border-color:#ef9a9a}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]{border-color:#bdbdbd}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover{border-color:#757575}.container[_ngcontent-%COMP%]{border-radius:4px;border:2px solid rgba(0,0,0,0);padding:1px 2px;position:relative}.measurer[_ngcontent-%COMP%]{pointer-events:none;position:absolute;visibility:hidden}.measurer[_ngcontent-%COMP%], input[_ngcontent-%COMP%]{font-family:inherit;font-size:inherit;line-height:1.4;padding:0;white-space:pre}.measurer[_ngcontent-%COMP%]:empty, input[_ngcontent-%COMP%]:empty{width:2ch}input[_ngcontent-%COMP%]{appearance:none;background-color:inherit;border:0;color:inherit;display:inline-block;font-family:inherit;outline:0}input[_ngcontent-%COMP%]:focus{padding-right:1ch}"],changeDetection:0}),n})();function lEe(n,t){if(1&n){let e=Te();f(0,"content-wrapping-input",3),A("onValueChange",function(r){return ne(e),ie(w().aliasChanged.emit(r))}),g()}if(2&n){let e=w();Hs(e.isAliasNameLegal?"high-contrast":"error"),b("value",e.alias.aliasText)}}function cEe(n,t){if(1&n&&(f(0,"span",4),T(1),g()),2&n){let e=w();nt("illegal",!e.isAliasNameLegal),b("title",e.title),v(1),kt(e.alias.aliasText)}}var Kg=(()=>{class n{constructor(){this.isAliasNameLegal=!0,this.aliasChanged=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-experiment-alias"]],inputs:{alias:"alias",aliasEditable:"aliasEditable",title:"title",isAliasNameLegal:"isAliasNameLegal"},outputs:{aliasChanged:"aliasChanged"},decls:5,vars:3,consts:[[1,"alias-number"],["placeholder","Alias for experiment",3,"style","value","onValueChange",4,"ngIf","ngIfElse"],["noEditAliasName",""],["placeholder","Alias for experiment",3,"value","onValueChange"],[3,"title"]],template:function(e,i){if(1&e&&(f(0,"span",0),T(1),g(),S(2,lEe,1,3,"content-wrapping-input",1),S(3,cEe,2,4,"ng-template",null,2,jt)),2&e){let r=st(4);v(1),kt(i.alias.aliasNumber),v(1),b("ngIf",i.aliasEditable)("ngIfElse",r)}},dependencies:[Ne,WQ],styles:[".alias-number[_ngcontent-%COMP%]{background-color:#e0e0e0;border:1px solid #ebebeb;color:#212121;border-radius:2px;margin-right:2px;padding:0 2px}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{background-color:#616161}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{color:#fff}[_nghost-%COMP%]{display:inline-flex;align-items:baseline}"]}),n})();function dEe(n,t){1&n&&k(0,"tb-experiment-alias",2),2&n&&b("alias",w().experimentAlias)}function uEe(n,t){1&n&&(f(0,"span"),T(1,"/"),g())}var qQ=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["card-run-name-component"]],inputs:{name:"name",experimentAlias:"experimentAlias"},decls:4,vars:3,consts:[[3,"alias",4,"ngIf"],[4,"ngIf"],[3,"alias"]],template:function(e,i){1&e&&(S(0,dEe,1,1,"tb-experiment-alias",0),S(1,uEe,2,0,"span",1),f(2,"span"),T(3),g()),2&e&&(b("ngIf",null!=i.experimentAlias),v(1),b("ngIf",null!=i.experimentAlias),v(2),kt(i.name))},dependencies:[Ne,Kg],styles:["[_nghost-%COMP%]{color:#616161}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),ZT=(()=>{class n{constructor(e){this.store=e}ngOnInit(){this.name$=In([this.store.select(b1,{runId:this.runId})]).pipe(q(([e])=>function(n,t,e){if(!t)return n;let i=t?.name??"...";return i}(this.runId,e))),this.experimentAlias$=In([this.store.select(_1,{runId:this.runId}),this.store.select(qs)]).pipe(q(([e,i])=>e?i[e]:null))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["card-run-name"]],inputs:{runId:"runId"},decls:4,vars:9,consts:[[3,"name","experimentAlias"]],template:function(e,i){1&e&&(k(0,"card-run-name-component",0),U(1,"async"),U(2,"async"),U(3,"async")),2&e&&(b("name",G(1,3,i.name$))("experimentAlias",G(3,7,i.experimentAlias$)),Be("title",G(2,5,i.name$)))},dependencies:[qQ,ct],encapsulation:2,changeDetection:0}),n})();function hEe(n,t){if(1&n&&(f(0,"span",2),T(1),g()),2&n){let e=w();v(1),kt(e.firstTextPart())}}var Jg=(()=>{class n{parseValue(){let e=this.value.lastIndexOf("/");return-1===e?{first:"",second:this.value}:{first:this.value.slice(0,e),second:this.value.slice(e)}}firstTextPart(){return this.parseValue().first}secondTextPart(){return this.parseValue().second}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-truncated-path"]],inputs:{value:"value"},decls:3,vars:2,consts:[["class","first-text-part",4,"ngIf"],[1,"second-text-part"],[1,"first-text-part"]],template:function(e,i){1&e&&(S(0,hEe,2,1,"span",0),f(1,"span",1),T(2),g()),2&e&&(b("ngIf",i.firstTextPart().length>0),v(2),kt(i.secondTextPart()))},dependencies:[Ne],styles:["[_nghost-%COMP%]{display:inline-flex;white-space:nowrap}.first-text-part[_ngcontent-%COMP%]{flex:1 1 4ch;max-width:max-content}.first-text-part[_ngcontent-%COMP%], .second-text-part[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis}"]}),n})();function mEe(n,t){1&n&&k(0,"mat-icon",2)}function fEe(n,t){1&n&&k(0,"mat-icon",3)}var $g=(()=>{class n{constructor(){this.isClipped=!1,this.isClosestStepHighlighted=!1}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["vis-linked-time-selection-warning"]],inputs:{isClipped:"isClipped",isClosestStepHighlighted:"isClosestStepHighlighted"},decls:2,vars:2,consts:[["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you.",4,"ngIf"],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you.",4,"ngIf"],["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you."],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you."]],template:function(e,i){1&e&&(S(0,mEe,1,0,"mat-icon",0),S(1,fEe,1,0,"mat-icon",1)),2&e&&(b("ngIf",i.isClipped),v(1),b("ngIf",i.isClosestStepHighlighted))},dependencies:[Ne,bn],styles:["[_nghost-%COMP%]{color:#d32f2f;height:1em;line-height:0;display:inline-flex}body.dark-mode   [_nghost-%COMP%]{color:#d32f2f}[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:100%;width:100%}"],changeDetection:0}),n})();function gEe(n,t){if(1&n&&(f(0,"span",19),T(1),U(2,"number"),g()),2&n){let e=w();v(1),Ve("Step ",G(2,1,e.steps[e.stepIndex]),"")}}function _Ee(n,t){if(1&n&&(f(0,"span",20),T(1),U(2,"number"),U(3,"number"),g()),2&n){let e=w();v(1),lu("Sample ",G(2,2,e.sample+1),"/",G(3,4,e.numSample),"")}}function bEe(n,t){1&n&&k(0,"mat-spinner",21)}function vEe(n,t){if(1&n&&k(0,"div",30),2&n){let e=t.$implicit,i=w(3);Bt("left",i.getLinkedTimeTickLeftStyle(e))("margin-left",i.getLinkedTimeTickMarginLeftStyle(e))}}function yEe(n,t){if(1&n&&(f(0,"div",28),S(1,vEe,1,4,"div",29),g()),2&n){let e=w(2);v(1),b("ngForOf",e.selectedSteps)}}var xEe=function(n){return{filter:n}};function CEe(n,t){if(1&n){let e=Te();Gt(0),f(1,"div",22)(2,"mat-slider",23)(3,"input",24),A("valueChange",function(r){return ne(e),ie(w().onSliderInput(r))}),g()(),S(4,yEe,2,1,"div",25),g(),f(5,"div",26),k(6,"img",27),g(),Wt()}if(2&n){let e=w();v(2),b("disabled",e.steps.length<=1)("min",0)("max",e.steps.length-1)("step",1),v(1),b("value",e.stepIndex),v(1),b("ngIf",e.linkedTimeSelection),v(2),_b("alt","Image at step ",e.steps[e.stepIndex],""),Zi("src",e.imageUrl,Vs),b("ngStyle",Un(9,xEe,e.cssFilter()))}}function MEe(n,t){1&n&&(f(0,"div",32),T(1," Data failed to load. "),g())}function wEe(n,t){if(1&n&&S(0,MEe,2,0,"div",31),2&n){let e=w();b("ngIf",e.loadState===e.DataLoadState.FAILED)}}var SEe=function(n){return{backgroundColor:n}},YQ=(()=>{class n{constructor(){this.DataLoadState=Re,this.sliderStartPosition="",this.sliderTrackWidth="",this.linkedTimeSelection=null,this.isClosestStepHighlighted=!1,this.onActualSizeToggle=new F,this.stepIndexChange=new F,this.onPinClicked=new F}cssFilter(){return`contrast(${this.contrastInMilli/10}%) brightness(${this.brightnessInMilli/1e3})`}onSliderInput(e){this.stepIndexChange.emit(e)}changeDistinct(e){return e.currentValue!==e.previousValue}ngOnChanges(e){(e.selectedSteps&&this.changeDistinct(e.selectedSteps)||e.linkedTimeSelection&&this.changeDistinct(e.linkedTimeSelection))&&this.renderRangeSlider()}renderRangeSlider(){if(!this.linkedTimeSelection||!this.linkedTimeSelection.endStep)return;let e=this.steps.length-1,i=this.linkedTimeSelection.startStep<this.steps[0]?this.steps[0]:this.linkedTimeSelection.startStep,r=this.linkedTimeSelection.endStep>this.steps[e]?this.steps[e]:this.linkedTimeSelection.endStep,{startPosition:o,width:a}=this.getTrackStartPositionAndWidth(i,r,e);this.sliderStartPosition=100*o+"%",this.sliderTrackWidth=100*a+"%"}getTrackStartPositionAndWidth(e,i,r){let o=1/r,a=0,s=0,l=0;for(;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(c<=e&&e<=d){a+=(e-c)/(d-c);break}}for(a=(a+l)*o;l<this.steps.length-1;l++){let c=this.steps[l],d=this.steps[l+1];if(e>=c&&i<=d){s=(i-e)/(d-c);break}if(e>=c&&i>=d)s+=(d-e)/(d-c);else{if(!(i>=d)){s+=(i-c)/(d-c);break}s+=1}}return s*=o,(a>1||a<0)&&(a=0),{startPosition:a,width:s}}getLinkedTimeTickLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return this.steps.indexOf(e)/(this.steps.length-1)*100+"%"}getLinkedTimeTickMarginLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return`-${this.steps.indexOf(e)/(this.steps.length-1)*12}px`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["image-card-component"]],hostVars:2,hostBindings:function(e,i){2&e&&nt("actual-size",i.showActualSize)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",sample:"sample",numSample:"numSample",imageUrl:"imageUrl",stepIndex:"stepIndex",steps:"steps",brightnessInMilli:"brightnessInMilli",contrastInMilli:"contrastInMilli",showActualSize:"showActualSize",runColorScale:"runColorScale",allowToggleActualSize:"allowToggleActualSize",isPinned:"isPinned",selectedSteps:"selectedSteps",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onActualSizeToggle:"onActualSizeToggle",stepIndexChange:"stepIndexChange",onPinClicked:"onPinClicked"},features:[qt],decls:21,vars:16,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on an image card that toggles actual image size.␟3ca05ef3a6e3a37065f5e0f69c5d5a2178d90791␟7635101936664789140:Toggle actual image size`,[[1,"heading"],[1,"line"],[1,"tag"],[1,"tag-path",3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle actual image size",3,"disabled","click"],["svgIcon","image_search_24px"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"metadata"],["class","step",4,"ngIf"],["class","sample",4,"ngIf"],["class","loading","diameter","18",4,"ngIf"],[4,"ngIf","ngIfElse"],["noImageData",""],[1,"step"],[1,"sample"],["diameter","18",1,"loading"],[1,"slider-row"],["color","primary",1,"step-slider",3,"disabled","min","max","step"],["matSliderThumb","",3,"value","valueChange"],["class","linked-time-wrapper",4,"ngIf"],[1,"img-container"],[3,"alt","src","ngStyle","includeFeatureFlags"],[1,"linked-time-wrapper"],["class","linked-time-tick",3,"left","margin-left",4,"ngFor","ngForOf"],[1,"linked-time-tick"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1)(2,"span",2),k(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),f(5,"span",5)(6,"button",6),A("click",function(){return i.onPinClicked.emit(!i.isPinned)}),k(7,"mat-icon",7),g(),f(8,"button",8),A("click",function(){return i.onActualSizeToggle.emit()}),k(9,"mat-icon",9),g()()(),f(10,"div",1)(11,"span",10),k(12,"span",11)(13,"card-run-name",12),g(),f(14,"div",13),S(15,gEe,3,3,"span",14),S(16,_Ee,4,6,"span",15),S(17,bEe,1,0,"mat-spinner",16),g()()(),S(18,CEe,7,11,"ng-container",17),S(19,wEe,1,1,"ng-template",null,18,jt)),2&e){let r=st(20);v(3),Zi("title",i.tag),Zi("value",i.title),v(1),b("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),v(2),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),b("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(1),b("disabled",!i.allowToggleActualSize),v(4),b("ngStyle",Un(14,SEe,i.runColorScale(i.runId))),v(1),b("runId",i.runId),v(2),b("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length),v(1),b("ngIf",i.numSample>1),v(1),b("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),b("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length)("ngIfElse",r)}},dependencies:[nn,Ne,Mf,QT,Er,bn,Nc,Ju,$u,ZT,Jg,$g,Us],styles:["[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.actual-size[_nghost-%COMP%]{height:auto}.heading[_ngcontent-%COMP%]{align-items:center;font-size:14px;margin-bottom:4px;position:relative}.line[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-columns:1fr max-content}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px}.metadata[_ngcontent-%COMP%]{display:flex;flex-wrap:wrap;gap:5px;justify-content:flex-end;max-width:175px;text-align:end}.tag-path[_ngcontent-%COMP%]{overflow:hidden}.run[_ngcontent-%COMP%]{align-self:baseline;display:flex;overflow:hidden;white-space:nowrap}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.run[_ngcontent-%COMP%], .sample[_ngcontent-%COMP%], .step[_ngcontent-%COMP%]{color:#616161;font-size:13px}body.dark-mode[_nghost-%COMP%]   .run[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .run[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .sample[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sample[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .step[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .step[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.img-container[_ngcontent-%COMP%]{flex-grow:1;overflow-y:auto;position:relative}.img-container[_ngcontent-%COMP%]   img[_ngcontent-%COMP%]{image-rendering:-moz-crisp-edges;image-rendering:pixelated}.actual-size[_nghost-%COMP%]   .img-container[_ngcontent-%COMP%]{overflow:auto;flex:none}[_nghost-%COMP%]:not(.actual-size)   img[_ngcontent-%COMP%]{position:absolute;max-height:100%;max-width:100%;width:auto;height:100%;object-fit:contain}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:24px;position:relative}.slider-row[_ngcontent-%COMP%]   mat-slider[_ngcontent-%COMP%]{margin-left:6px}.step-slider[_ngcontent-%COMP%]{flex:1}[_nghost-%COMP%]     .mat-slider-min-value .mat-slider-thumb{background-color:#f57c00}[_nghost-%COMP%]     .hide-slider.mat-slider-horizontal .mat-slider-track-wrapper{height:0}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}.linked-time-wrapper[_ngcontent-%COMP%]{position:absolute;top:5px;width:100%}.linked-time-tick[_ngcontent-%COMP%]{background-color:#e0e0e0;border-radius:50%;height:12px;position:absolute;width:12px;z-index:-1}body.dark-mode[_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%]{background-color:#212121}"],changeDetection:0}),n})(),QQ=(()=>{class n{constructor(e,i){this.store=e,this.dataSource=i,this.fullWidthChanged=new F,this.pinStateChanged=new F,this.brightnessInMilli$=this.store.select(l1),this.contrastInMilli$=this.store.select(c1),this.actualSizeGlobalSetting$=this.store.select(d1),this.showActualSize=!1,this.actualSizeUiToggled=!1,this.actualSizeUiToggleSubject=new xr(this.actualSizeUiToggled),this.ngUnsubscribe=new Ee}onStepIndexChanged(e){this.store.dispatch(PT({cardId:this.cardId,stepIndex:e}))}isImageCardMetadata(e){let{plugin:i}=e;return i===An.IMAGES}onActualSizeToggle(){this.actualSizeUiToggled=!this.actualSizeUiToggled,this.actualSizeUiToggleSubject.next(this.actualSizeUiToggled)}ngOnInit(){In([this.actualSizeGlobalSetting$,this.actualSizeUiToggleSubject]).pipe(it(this.ngUnsubscribe),Dt(([l,c])=>{this.showActualSize=l||c,this.fullWidthChanged.emit(this.showActualSize)})).subscribe(()=>{});let i=this.store.select(Ks,this.cardId).pipe(it(this.ngUnsubscribe),Oe(l=>!!l&&this.isImageCardMetadata(l)),q(l=>l),Da(1)),o=In([i,this.store.select(wu,this.cardId)]).pipe(it(this.ngUnsubscribe),q(([l,c])=>{let d=l.runId;return c&&c.hasOwnProperty(d)?c[d]:[]}),ri((l,c)=>l.length===c.length&&0===l.length||l===c),Da(1));this.stepIndex$=this.store.select(ZF,this.cardId).pipe(q(l=>l?l.index:null)),this.isClosestStepHighlighted$=this.store.select(ZF,this.cardId).pipe(q(l=>!!l&&l.isClosest)),this.loadState$=this.store.select(gd,this.cardId),this.tag$=i.pipe(q(l=>l.tag)),this.title$=this.tag$.pipe(q(l=>Zg(l,this.groupName))),this.runId$=i.pipe(q(l=>l.runId)),this.sample$=i.pipe(q(l=>l.sample)),this.numSample$=i.pipe(q(l=>l.numSample)),this.steps$=this.store.select(AW,this.cardId),this.isPinned$=this.store.select(Su,this.cardId),this.linkedTimeSelection$=this.store.select(Du).pipe(Vi(this.steps$),q(([l,c])=>l?Yf(l,Math.min(...c),Math.max(...c)):null)),this.selectedSteps$=this.linkedTimeSelection$.pipe(Vi(this.steps$),q(([l,c])=>l?null===l.endStep?-1!==c.indexOf(l.startStep)?[l.startStep]:[]:c.filter(d=>d>=l.startStep&&d<=l.endStep):[]));let s=In([o,this.stepIndex$]).pipe(q(([l,c])=>null!==c&&l[c]?l[c]:null));this.imageUrl$=s.pipe(q(l=>l?this.dataSource.imageUrl(l.imageId):null))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(wc))},n.\u0275cmp=P({type:n,selectors:[["image-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",pinStateChanged:"pinStateChanged"},decls:17,vars:50,consts:[[3,"loadState","title","tag","runId","sample","numSample","imageUrl","stepIndex","steps","isClosestStepHighlighted","brightnessInMilli","contrastInMilli","runColorScale","showActualSize","allowToggleActualSize","isPinned","linkedTimeSelection","selectedSteps","stepIndexChange","onActualSizeToggle","onPinClicked"]],template:function(e,i){1&e&&(f(0,"image-card-component",0),A("stepIndexChange",function(o){return i.onStepIndexChanged(o)})("onActualSizeToggle",function(){return i.onActualSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),U(10,"async"),U(11,"async"),U(12,"async"),U(13,"async"),U(14,"async"),U(15,"async"),U(16,"async"),g()),2&e&&b("loadState",G(1,18,i.loadState$))("title",G(2,20,i.title$))("tag",G(3,22,i.tag$))("runId",G(4,24,i.runId$))("sample",G(5,26,i.sample$))("numSample",G(6,28,i.numSample$))("imageUrl",G(7,30,i.imageUrl$))("stepIndex",G(8,32,i.stepIndex$))("steps",G(9,34,i.steps$))("isClosestStepHighlighted",G(10,36,i.isClosestStepHighlighted$))("brightnessInMilli",G(11,38,i.brightnessInMilli$))("contrastInMilli",G(12,40,i.contrastInMilli$))("runColorScale",i.runColorScale)("showActualSize",i.showActualSize)("allowToggleActualSize",!1===G(13,42,i.actualSizeGlobalSetting$))("isPinned",G(14,44,i.isPinned$))("linkedTimeSelection",G(15,46,i.linkedTimeSelection$))("selectedSteps",G(16,48,i.selectedSteps$))},dependencies:[YQ,ct],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})(),Yi=(()=>(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"}(Yi||(Yi={})),Yi))(),tr=(()=>(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"}(tr||(tr={})),tr))(),Tr=(()=>(function(n){n.NONE="NONE",n.DRAG_ZOOMING="DRAG_ZOOMING",n.SCROLL_ZOOMING="SCROLL_ZOOMING",n.PANNING="PANNING"}(Tr||(Tr={})),Tr))();function IEe(n,t){1&n&&(f(0,"span"),T(1,"scalar"),g())}function AEe(n,t){1&n&&(f(0,"span"),T(1,"histogram"),g())}function REe(n,t){1&n&&(f(0,"span"),T(1,"unknown"),g())}function PEe(n,t){if(1&n&&(Gt(0,13),S(1,IEe,2,0,"span",14),S(2,AEe,2,0,"span",14),S(3,REe,2,0,"span",15),Wt()),2&n){let e=w(2);b("ngSwitch",e.cardMetadata.plugin),v(1),b("ngSwitchCase",e.PluginType.SCALARS),v(1),b("ngSwitchCase",e.PluginType.HISTOGRAMS)}}function kEe(n,t){1&n&&hi(0)}function OEe(n,t){if(1&n&&(f(0,"option",16),T(1),g()),2&n){let e=t.$implicit;b("value",e.id),v(1),kt(e.name)}}function FEe(n,t){if(1&n){let e=Te();Gt(0),f(1,"h2"),S(2,PEe,4,3,"ng-template",null,2,jt),f(4,"span"),T(5,"Download\xa0"),g(),S(6,kEe,1,0,"ng-container",3),f(7,"span"),T(8,"\xa0data for\xa0"),g(),f(9,"code",4),T(10),g()(),f(11,"mat-dialog-content")(12,"mat-form-field",5)(13,"mat-label"),T(14,"Select a run to download a data for a series"),g(),f(15,"select",6),A("change",function(r){return ne(e),ie(w().runSelected.emit(r.target.value))}),f(16,"option",7),T(17,"-"),g(),S(18,OEe,2,2,"option",8),g()(),f(19,"div",9)(20,"span"),T(21,"Download as\u2026"),g(),T(22,"\xa0"),f(23,"a",10),T(24,"JSON"),g(),f(25,"a",10),T(26,"CSV"),g()()(),f(27,"mat-dialog-actions",11)(28,"button",12),T(29,"Close"),g()(),Wt()}if(2&n){let e=st(3),i=w();v(6),b("ngTemplateOutlet",e),v(3),b("title",i.cardMetadata.tag),v(1),kt(i.cardMetadata.tag),v(5),b("value",i.selectedRunId||""),v(1),b("value",""),v(2),b("ngForOf",i.runs),v(5),b("disabled",!i.downloadUrlJson)("download",i.getDownloadName("json"))("href",i.downloadUrlJson,Vs),v(2),b("disabled",!i.downloadUrlCsv)("download",i.getDownloadName("csv"))("href",i.downloadUrlCsv,Vs)}}function NEe(n,t){1&n&&T(0,"Loading...")}var KQ=(()=>{class n{constructor(){this.runSelected=new F,this.PluginType=An}getDownloadName(e){let i=this.runs.find(r=>r.id===this.selectedRunId);return i?`${i.name}.${e}`:""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["data_download_dialog_component"]],inputs:{cardMetadata:"cardMetadata",runs:"runs",selectedRunId:"selectedRunId",downloadUrlCsv:"downloadUrlCsv",downloadUrlJson:"downloadUrlJson"},outputs:{runSelected:"runSelected"},decls:3,vars:2,consts:[[4,"ngIf","ngIfElse"],["noCardMetadata",""],["dataName",""],[4,"ngTemplateOutlet"],[1,"tag-name",3,"title"],["appearance","fill",1,"run-selector"],["matNativeControl","","name","run","cdkFocusInitial","","required","",3,"value","change"],["selected","",3,"value"],[3,"value",4,"ngFor","ngForOf"],[1,"download-controls"],["mat-stroked-button","",3,"disabled","download","href","includeFeatureFlags"],["align","end"],["mat-button","","mat-dialog-close",""],[3,"ngSwitch"],[4,"ngSwitchCase"],[4,"NgSwitchDefault"],[3,"value"]],template:function(e,i){if(1&e&&(S(0,FEe,30,12,"ng-container",0),S(1,NEe,1,0,"ng-template",null,1,jt)),2&e){let r=st(2);b("ngIf",i.cardMetadata)("ngIfElse",r)}},dependencies:[nn,Ne,eo,mr,kr,QT,xq,Mq,z7,ki,Z1,K1,J1,qu,Pc,nl],styles:["h2[_ngcontent-%COMP%]{font-size:1.25em;overflow-wrap:break-word}.run-selector[_ngcontent-%COMP%]{font-size:.9em;width:100%}.download-controls[_ngcontent-%COMP%]{font-size:.9em}.download-controls[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{margin:3px 10px 3px 0}"],changeDetection:0}),n})(),JQ=(()=>{class n{constructor(e,i,r){this.selectedRunId$=new xr(null),this.cardMetadata$=e.select(Ks,r.cardId).pipe(Oe(o=>Boolean(o))),this.downloadUrlCsv$=In([e.select(Ks,r.cardId),this.selectedRunId$]).pipe(q(([o,a])=>o&&a?i.downloadUrl(o.plugin,o.tag,a,"csv"):null),kn(null)),this.downloadUrlJson$=In([e.select(Ks,r.cardId),this.selectedRunId$]).pipe(q(([o,a])=>o&&a?i.downloadUrl(o.plugin,o.tag,a,"json"):null),kn(null)),this.runs$=In([e.select(QW),e.select(wu,r.cardId)]).pipe(q(([o,a])=>a?Object.keys(a).map(s=>o.get(s)).filter(Boolean):[]))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(wc),C(Xv))},n.\u0275cmp=P({type:n,selectors:[["data_download_dialog"]],decls:6,vars:15,consts:[[3,"cardMetadata","runs","selectedRunId","downloadUrlCsv","downloadUrlJson","runSelected"]],template:function(e,i){1&e&&(f(0,"data_download_dialog_component",0),A("runSelected",function(o){return i.selectedRunId$.next(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),g()),2&e&&b("cardMetadata",G(1,5,i.cardMetadata$))("runs",G(2,7,i.runs$))("selectedRunId",G(3,9,i.selectedRunId$))("downloadUrlCsv",G(4,11,i.downloadUrlCsv$))("downloadUrlJson",G(5,13,i.downloadUrlJson$))},dependencies:[KQ,ct],encapsulation:2,changeDetection:0}),n})();function al(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Cy(n){return 1===n.length&&(n=function(n){return function(t,e){return al(n(t),e)}}(n)),{left:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)<0?i=o+1:r=o}return i},right:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)>0?r=o:i=o+1}return i}}}var Lc=Cy(al).right,FN=Math.sqrt(50),NN=Math.sqrt(10),LN=Math.sqrt(2);function My(n,t,e){var i,o,a,s,r=-1;if(e=+e,(n=+n)==(t=+t)&&e>0)return[n];if((i=t<n)&&(o=n,n=t,t=o),0===(s=e0(n,t,e))||!isFinite(s))return[];if(s>0)for(n=Math.ceil(n/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-n+1));++r<o;)a[r]=(n+r)*s;else for(n=Math.floor(n*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(n-t+1));++r<o;)a[r]=(n-r)/s;return i&&a.reverse(),a}function e0(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=FN?10:o>=NN?5:o>=LN?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=FN?10:o>=NN?5:o>=LN?2:1)}function Id(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=FN?r*=10:o>=NN?r*=5:o>=LN&&(r*=2),t<n?-r:r}var JT=Array.prototype.slice;function rZ(n){return n}var VN=1,eD=2,HN=3,$T=4,oZ=1e-6;function XEe(n){return"translate("+(n+.5)+",0)"}function YEe(n){return"translate(0,"+(n+.5)+")"}function QEe(n){return function(t){return+n(t)}}function ZEe(n){var t=Math.max(0,n.bandwidth()-1)/2;return n.round()&&(t=Math.round(t)),function(e){return+n(e)+t}}function KEe(){return!this.__axis}function aZ(n,t){var e=[],i=null,r=null,o=6,a=6,s=3,l=n===VN||n===$T?-1:1,c=n===$T||n===eD?"x":"y",d=n===VN||n===HN?XEe:YEe;function u(p){var h=i??(t.ticks?t.ticks.apply(t,e):t.domain()),m=r??(t.tickFormat?t.tickFormat.apply(t,e):rZ),_=Math.max(o,0)+s,M=t.range(),y=+M[0]+.5,x=+M[M.length-1]+.5,R=(t.bandwidth?ZEe:QEe)(t.copy()),I=p.selection?p.selection():p,B=I.selectAll(".domain").data([null]),ee=I.selectAll(".tick").data(h,t).order(),Q=ee.exit(),we=ee.enter().append("g").attr("class","tick"),Qe=ee.select("line"),Ae=ee.select("text");B=B.merge(B.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),ee=ee.merge(we),Qe=Qe.merge(we.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),Ae=Ae.merge(we.append("text").attr("fill","currentColor").attr(c,l*_).attr("dy",n===VN?"0em":n===HN?"0.71em":"0.32em")),p!==I&&(B=B.transition(p),ee=ee.transition(p),Qe=Qe.transition(p),Ae=Ae.transition(p),Q=Q.transition(p).attr("opacity",oZ).attr("transform",function(D){return isFinite(D=R(D))?d(D):this.getAttribute("transform")}),we.attr("opacity",oZ).attr("transform",function(D){var re=this.parentNode.__axis;return d(re&&isFinite(re=re(D))?re:R(D))})),Q.remove(),B.attr("d",n===$T||n==eD?a?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M0.5,"+y+"V"+x:a?"M"+y+","+l*a+"V0.5H"+x+"V"+l*a:"M"+y+",0.5H"+x),ee.attr("opacity",1).attr("transform",function(D){return d(R(D))}),Qe.attr(c+"2",l*o),Ae.attr(c,l*_).text(m),I.filter(KEe).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",n===eD?"start":n===$T?"end":"middle"),I.each(function(){this.__axis=R})}return u.scale=function(p){return arguments.length?(t=p,u):t},u.ticks=function(){return e=JT.call(arguments),u},u.tickArguments=function(p){return arguments.length?(e=null==p?[]:JT.call(p),u):e.slice()},u.tickValues=function(p){return arguments.length?(i=null==p?null:JT.call(p),u):i&&i.slice()},u.tickFormat=function(p){return arguments.length?(r=p,u):r},u.tickSize=function(p){return arguments.length?(o=a=+p,u):o},u.tickSizeInner=function(p){return arguments.length?(o=+p,u):o},u.tickSizeOuter=function(p){return arguments.length?(a=+p,u):a},u.tickPadding=function(p){return arguments.length?(s=+p,u):s},u}var JEe={value:function(){}};function lZ(){for(var i,n=0,t=arguments.length,e={};n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new tD(e)}function tD(n){this._=n}function eTe(n,t){for(var r,e=0,i=n.length;e<i;++e)if((r=n[e]).name===t)return r.value}function sZ(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=JEe,n=n.slice(0,i).concat(n.slice(i+1));break}return null!=e&&n.push({name:t,value:e}),n}tD.prototype=lZ.prototype={constructor:tD,on:function(n,t){var r,e=this._,i=function(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}(n+"",e),o=-1,a=i.length;if(!(arguments.length<2)){if(null!=t&&"function"!=typeof t)throw new Error("invalid callback: "+t);for(;++o<a;)if(r=(n=i[o]).type)e[r]=sZ(e[r],n.name,t);else if(null==t)for(r in e)e[r]=sZ(e[r],n.name,null);return this}for(;++o<a;)if((r=(n=i[o]).type)&&(r=eTe(e[r],n.name)))return r},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new tD(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var r,o,e=new Array(r),i=0;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(i=0,r=(o=this._[n]).length;i<r;++i)o[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,o=i.length;r<o;++r)i[r].value.apply(t,e)}};var jN=lZ,nD="http://www.w3.org/1999/xhtml",GN={svg:"http://www.w3.org/2000/svg",xhtml:nD,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Ad(n){var t=n+="",e=t.indexOf(":");return e>=0&&"xmlns"!==(t=n.slice(0,e))&&(n=n.slice(e+1)),GN.hasOwnProperty(t)?{space:GN[t],local:n}:n}function tTe(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===nD&&t.documentElement.namespaceURI===nD?t.createElement(n):t.createElementNS(e,n)}}function nTe(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function iD(n){var t=Ad(n);return(t.local?nTe:tTe)(t)}function iTe(){}function Gh(n){return null==n?iTe:function(){return this.querySelector(n)}}function rTe(){return[]}function Sy(n){return null==n?rTe:function(){return this.querySelectorAll(n)}}function Ey(n){return function(){return this.matches(n)}}function rD(n){return new Array(n.length)}function Ty(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}Ty.prototype={constructor:Ty,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};var mZ="$";function oTe(n,t,e,i,r,o){for(var s,a=0,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],i[a]=s):e[a]=new Ty(n,o[a]);for(;a<l;++a)(s=t[a])&&(r[a]=s)}function aTe(n,t,e,i,r,o,a){var s,l,h,c={},d=t.length,u=o.length,p=new Array(d);for(s=0;s<d;++s)(l=t[s])&&(p[s]=h=mZ+a.call(l,l.__data__,s,t),h in c?r[s]=l:c[h]=l);for(s=0;s<u;++s)(l=c[h=mZ+a.call(n,o[s],s,o)])?(i[s]=l,l.__data__=o[s],c[h]=null):e[s]=new Ty(n,o[s]);for(s=0;s<d;++s)(l=t[s])&&c[p[s]]===l&&(r[s]=l)}function sTe(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function lTe(n){return function(){this.removeAttribute(n)}}function cTe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function dTe(n,t){return function(){this.setAttribute(n,t)}}function uTe(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function pTe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttribute(n):this.setAttribute(n,e)}}function hTe(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function oD(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function mTe(n){return function(){this.style.removeProperty(n)}}function fTe(n,t,e){return function(){this.style.setProperty(n,t,e)}}function gTe(n,t,e){return function(){var i=t.apply(this,arguments);null==i?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function ip(n,t){return n.style.getPropertyValue(t)||oD(n).getComputedStyle(n,null).getPropertyValue(t)}function _Te(n){return function(){delete this[n]}}function bTe(n,t){return function(){this[n]=t}}function vTe(n,t){return function(){var e=t.apply(this,arguments);null==e?delete this[n]:this[n]=e}}function AZ(n){return n.trim().split(/^|\s+/)}function WN(n){return n.classList||new RZ(n)}function RZ(n){this._node=n,this._names=AZ(n.getAttribute("class")||"")}function PZ(n,t){for(var e=WN(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function kZ(n,t){for(var e=WN(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function yTe(n){return function(){PZ(this,n)}}function xTe(n){return function(){kZ(this,n)}}function CTe(n,t){return function(){(t.apply(this,arguments)?PZ:kZ)(this,n)}}function MTe(){this.textContent=""}function wTe(n){return function(){this.textContent=n}}function STe(n){return function(){var t=n.apply(this,arguments);this.textContent=t??""}}function ETe(){this.innerHTML=""}function TTe(n){return function(){this.innerHTML=n}}function DTe(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t??""}}function ITe(){this.nextSibling&&this.parentNode.appendChild(this)}function ATe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function RTe(){return null}function PTe(){var n=this.parentNode;n&&n.removeChild(this)}function kTe(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function OTe(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}RZ.prototype={add:function(n){this._names.indexOf(n)<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};var WZ={},qN=null;function FTe(n,t,e){return n=qZ(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(8&r.compareDocumentPosition(this)))&&n.call(this,i)}}function qZ(n,t,e){return function(i){var r=qN;qN=i;try{n.call(this,this.__data__,t,e)}finally{qN=r}}}function LTe(n){return function(){var t=this.__on;if(t){for(var o,e=0,i=-1,r=t.length;e<r;++e)o=t[e],n.type&&o.type!==n.type||o.name!==n.name?t[++i]=o:this.removeEventListener(o.type,o.listener,o.capture);++i?t.length=i:delete this.__on}}}function BTe(n,t,e){var i=WZ.hasOwnProperty(n.type)?FTe:qZ;return function(r,o,a){var l,s=this.__on,c=i(t,o,a);if(s)for(var d=0,u=s.length;d<u;++d)if((l=s[d]).type===n.type&&l.name===n.name)return this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),void(l.value=t);this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},s?s.push(l):this.__on=[l]}}function YZ(n,t,e){var i=oD(n),r=i.CustomEvent;"function"==typeof r?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function VTe(n,t){return function(){return YZ(this,n,t)}}function HTe(n,t){return function(){return YZ(this,n,t.apply(this,arguments))}}typeof document<"u"&&("onmouseenter"in document.documentElement||(WZ={mouseenter:"mouseover",mouseleave:"mouseout"}));var XN=[null];function Br(n,t){this._groups=n,this._parents=t}function ZZ(){return new Br([[document.documentElement]],XN)}Br.prototype=ZZ.prototype={constructor:Br,select:function(n){"function"!=typeof n&&(n=Gh(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,c,o=t[r],a=o.length,s=i[r]=new Array(a),d=0;d<a;++d)(l=o[d])&&(c=n.call(l,l.__data__,d,o))&&("__data__"in l&&(c.__data__=l.__data__),s[d]=c);return new Br(i,this._parents)},selectAll:function(n){"function"!=typeof n&&(n=Sy(n));for(var t=this._groups,e=t.length,i=[],r=[],o=0;o<e;++o)for(var l,a=t[o],s=a.length,c=0;c<s;++c)(l=a[c])&&(i.push(n.call(l,l.__data__,c,a)),r.push(l));return new Br(i,r)},filter:function(n){"function"!=typeof n&&(n=Ey(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],a=o.length,s=i[r]=[],c=0;c<a;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&s.push(l);return new Br(i,this._parents)},data:function(n,t){if(!n)return h=new Array(this.size()),c=-1,this.each(function(ee){h[++c]=ee}),h;var e=t?aTe:oTe,i=this._parents,r=this._groups;"function"!=typeof n&&(n=function(n){return function(){return n}}(n));for(var o=r.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var d=i[c],u=r[c],p=u.length,h=n.call(d,d&&d.__data__,c,i),m=h.length,_=s[c]=new Array(m),M=a[c]=new Array(m);e(d,u,_,M,l[c]=new Array(p),h,t);for(var I,B,x=0,R=0;x<m;++x)if(I=_[x]){for(x>=R&&(R=x+1);!(B=M[R])&&++R<m;);I._next=B||null}}return(a=new Br(a,i))._enter=s,a._exit=l,a},enter:function(){return new Br(this._enter||this._groups.map(rD),this._parents)},exit:function(){return new Br(this._exit||this._groups.map(rD),this._parents)},join:function(n,t,e){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof n?n(i):i.append(n+""),null!=t&&(r=t(r)),null==e?o.remove():e(o),i&&r?i.merge(r).order():r},merge:function(n){for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),a=new Array(i),s=0;s<o;++s)for(var p,l=t[s],c=e[s],d=l.length,u=a[s]=new Array(d),h=0;h<d;++h)(p=l[h]||c[h])&&(u[h]=p);for(;s<i;++s)a[s]=t[s];return new Br(a,this._parents)},order:function(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var a,i=n[t],r=i.length-1,o=i[r];--r>=0;)(a=i[r])&&(o&&4^a.compareDocumentPosition(o)&&o.parentNode.insertBefore(a,o),o=a);return this},sort:function(n){function t(u,p){return u&&p?n(u.__data__,p.__data__):!u-!p}n||(n=sTe);for(var e=this._groups,i=e.length,r=new Array(i),o=0;o<i;++o){for(var c,a=e[o],s=a.length,l=r[o]=new Array(s),d=0;d<s;++d)(c=a[d])&&(l[d]=c);l.sort(t)}return new Br(r,this._parents).order()},call:function(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this},nodes:function(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n},node:function(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function(){var n=0;return this.each(function(){++n}),n},empty:function(){return!this.node()},each:function(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var s,r=t[e],o=0,a=r.length;o<a;++o)(s=r[o])&&n.call(s,s.__data__,o,r);return this},attr:function(n,t){var e=Ad(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((null==t?e.local?cTe:lTe:"function"==typeof t?e.local?hTe:pTe:e.local?uTe:dTe)(e,t))},style:function(n,t,e){return arguments.length>1?this.each((null==t?mTe:"function"==typeof t?gTe:fTe)(n,t,e??"")):ip(this.node(),n)},property:function(n,t){return arguments.length>1?this.each((null==t?_Te:"function"==typeof t?vTe:bTe)(n,t)):this.node()[n]},classed:function(n,t){var e=AZ(n+"");if(arguments.length<2){for(var i=WN(this.node()),r=-1,o=e.length;++r<o;)if(!i.contains(e[r]))return!1;return!0}return this.each(("function"==typeof t?CTe:t?yTe:xTe)(e,t))},text:function(n){return arguments.length?this.each(null==n?MTe:("function"==typeof n?STe:wTe)(n)):this.node().textContent},html:function(n){return arguments.length?this.each(null==n?ETe:("function"==typeof n?DTe:TTe)(n)):this.node().innerHTML},raise:function(){return this.each(ITe)},lower:function(){return this.each(ATe)},append:function(n){var t="function"==typeof n?n:iD(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})},insert:function(n,t){var e="function"==typeof n?n:iD(n),i=null==t?RTe:"function"==typeof t?t:Gh(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})},remove:function(){return this.each(PTe)},clone:function(n){return this.select(n?OTe:kTe)},datum:function(n){return arguments.length?this.property("__data__",n):this.node().__data__},on:function(n,t,e){var r,a,i=function(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}(n+""),o=i.length;if(!(arguments.length<2)){for(s=t?BTe:LTe,null==e&&(e=!1),r=0;r<o;++r)this.each(s(i[r],t,e));return this}var s=this.node().__on;if(s)for(var d,l=0,c=s.length;l<c;++l)for(r=0,d=s[l];r<o;++r)if((a=i[r]).type===d.type&&a.name===d.name)return d.value},dispatch:function(n,t){return this.each(("function"==typeof t?HTe:VTe)(n,t))}};var Rd=ZZ;function aD(n){return"string"==typeof n?new Br([[document.querySelector(n)]],[document.documentElement]):new Br([[n]],XN)}function Wh(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function t0(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function rp(){}var lD=1/.7,n0="\\s*([+-]?\\d+)\\s*",Iy="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Vc="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",zTe=/^#([0-9a-f]{3,8})$/,UTe=new RegExp("^rgb\\("+[n0,n0,n0]+"\\)$"),jTe=new RegExp("^rgb\\("+[Vc,Vc,Vc]+"\\)$"),GTe=new RegExp("^rgba\\("+[n0,n0,n0,Iy]+"\\)$"),WTe=new RegExp("^rgba\\("+[Vc,Vc,Vc,Iy]+"\\)$"),qTe=new RegExp("^hsl\\("+[Iy,Vc,Vc]+"\\)$"),XTe=new RegExp("^hsla\\("+[Iy,Vc,Vc,Iy]+"\\)$"),KZ={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function JZ(){return this.rgb().formatHex()}function $Z(){return this.rgb().formatRgb()}function Hl(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=zTe.exec(n))?(e=t[1].length,t=parseInt(t[1],16),6===e?eK(t):3===e?new ea(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===e?sD(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===e?sD(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=UTe.exec(n))?new ea(t[1],t[2],t[3],1):(t=jTe.exec(n))?new ea(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=GTe.exec(n))?sD(t[1],t[2],t[3],t[4]):(t=WTe.exec(n))?sD(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=qTe.exec(n))?iK(t[1],t[2]/100,t[3]/100,1):(t=XTe.exec(n))?iK(t[1],t[2]/100,t[3]/100,t[4]):KZ.hasOwnProperty(n)?eK(KZ[n]):"transparent"===n?new ea(NaN,NaN,NaN,0):null}function eK(n){return new ea(n>>16&255,n>>8&255,255&n,1)}function sD(n,t,e,i){return i<=0&&(n=t=e=NaN),new ea(n,t,e,i)}function ZN(n){return n instanceof rp||(n=Hl(n)),n?new ea((n=n.rgb()).r,n.g,n.b,n.opacity):new ea}function i0(n,t,e,i){return 1===arguments.length?ZN(n):new ea(n,t,e,i??1)}function ea(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}function tK(){return"#"+YN(this.r)+YN(this.g)+YN(this.b)}function nK(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===n?")":", "+n+")")}function YN(n){return((n=Math.max(0,Math.min(255,Math.round(n)||0)))<16?"0":"")+n.toString(16)}function iK(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new Bc(n,t,e,i)}function rK(n){if(n instanceof Bc)return new Bc(n.h,n.s,n.l,n.opacity);if(n instanceof rp||(n=Hl(n)),!n)return new Bc;if(n instanceof Bc)return n;var t=(n=n.rgb()).r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),o=Math.max(t,e,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=t===o?(e-i)/s+6*(e<i):e===o?(i-t)/s+2:(t-e)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new Bc(a,s,l,n.opacity)}function qh(n,t,e,i){return 1===arguments.length?rK(n):new Bc(n,t,e,i??1)}function Bc(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}function QN(n,t,e){return 255*(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)}Wh(rp,Hl,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:JZ,formatHex:JZ,formatHsl:function(){return rK(this).formatHsl()},formatRgb:$Z,toString:$Z}),Wh(ea,i0,t0(rp,{brighter:function(n){return n=null==n?lD:Math.pow(lD,n),new ea(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new ea(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:tK,formatHex:tK,formatRgb:nK,toString:nK})),Wh(Bc,qh,t0(rp,{brighter:function(n){return n=null==n?lD:Math.pow(lD,n),new Bc(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new Bc(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+360*(this.h<0),t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new ea(QN(n>=240?n-240:n+120,r,i),QN(n,r,i),QN(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===n?")":", "+n+")")}}));var oK=Math.PI/180,aK=180/Math.PI,sK=.96422,lK=1,cK=.82521,dK=4/29,r0=6/29,uK=3*r0*r0,QTe=r0*r0*r0;function pK(n){if(n instanceof Hc)return new Hc(n.l,n.a,n.b,n.opacity);if(n instanceof Pd)return hK(n);n instanceof ea||(n=ZN(n));var o,a,t=eL(n.r),e=eL(n.g),i=eL(n.b),r=KN((.2225045*t+.7168786*e+.0606169*i)/lK);return t===e&&e===i?o=a=r:(o=KN((.4360747*t+.3850649*e+.1430804*i)/sK),a=KN((.0139322*t+.0971045*e+.7141733*i)/cK)),new Hc(116*r-16,500*(o-r),200*(r-a),n.opacity)}function Hc(n,t,e,i){this.l=+n,this.a=+t,this.b=+e,this.opacity=+i}function KN(n){return n>QTe?Math.pow(n,1/3):n/uK+dK}function JN(n){return n>r0?n*n*n:uK*(n-dK)}function $N(n){return 255*(n<=.0031308?12.92*n:1.055*Math.pow(n,1/2.4)-.055)}function eL(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}function Xh(n,t,e,i){return 1===arguments.length?function(n){if(n instanceof Pd)return new Pd(n.h,n.c,n.l,n.opacity);if(n instanceof Hc||(n=pK(n)),0===n.a&&0===n.b)return new Pd(NaN,0<n.l&&n.l<100?0:NaN,n.l,n.opacity);var t=Math.atan2(n.b,n.a)*aK;return new Pd(t<0?t+360:t,Math.sqrt(n.a*n.a+n.b*n.b),n.l,n.opacity)}(n):new Pd(n,t,e,i??1)}function Pd(n,t,e,i){this.h=+n,this.c=+t,this.l=+e,this.opacity=+i}function hK(n){if(isNaN(n.h))return new Hc(n.l,0,0,n.opacity);var t=n.h*oK;return new Hc(n.l,Math.cos(t)*n.c,Math.sin(t)*n.c,n.opacity)}function nL(n,t,e,i,r){var o=n*n,a=o*n;return((1-3*n+3*o-a)*t+(4-6*o+3*a)*e+(1+3*n+3*o-3*a)*i+a*r)/6}function o0(n){return function(){return n}}function gK(n,t){return function(e){return n+e*t}}function dD(n,t){var e=t-n;return e?gK(n,e>180||e<-180?e-360*Math.round(e/360):e):o0(isNaN(n)?t:n)}function Ka(n,t){var e=t-n;return e?gK(n,e):o0(isNaN(n)?t:n)}Wh(Hc,function(n,t,e,i){return 1===arguments.length?pK(n):new Hc(n,t,e,i??1)},t0(rp,{brighter:function(n){return new Hc(this.l+18*(n??1),this.a,this.b,this.opacity)},darker:function(n){return new Hc(this.l-18*(n??1),this.a,this.b,this.opacity)},rgb:function(){var n=(this.l+16)/116,t=isNaN(this.a)?n:n+this.a/500,e=isNaN(this.b)?n:n-this.b/200;return new ea($N(3.1338561*(t=sK*JN(t))-1.6168667*(n=lK*JN(n))-.4906146*(e=cK*JN(e))),$N(-.9787684*t+1.9161415*n+.033454*e),$N(.0719453*t-.2289914*n+1.4052427*e),this.opacity)}})),Wh(Pd,Xh,t0(rp,{brighter:function(n){return new Pd(this.h,this.c,this.l+18*(n??1),this.opacity)},darker:function(n){return new Pd(this.h,this.c,this.l-18*(n??1),this.opacity)},rgb:function(){return hK(this).rgb()}}));var Yh=function n(t){var e=function(n){return 1==(n=+n)?Ka:function(t,e){return e-t?function(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}(t,e,n):o0(isNaN(t)?e:t)}}(t);function i(r,o){var a=e((r=i0(r)).r,(o=i0(o)).r),s=e(r.g,o.g),l=e(r.b,o.b),c=Ka(r.opacity,o.opacity);return function(d){return r.r=a(d),r.g=s(d),r.b=l(d),r.opacity=c(d),r+""}}return i.gamma=n,i}(1);function bK(n){return function(t){var a,s,e=t.length,i=new Array(e),r=new Array(e),o=new Array(e);for(a=0;a<e;++a)s=i0(t[a]),i[a]=s.r||0,r[a]=s.g||0,o[a]=s.b||0;return i=n(i),r=n(r),o=n(o),s.opacity=1,function(l){return s.r=i(l),s.g=r(l),s.b=o(l),s+""}}}function vK(n,t){t||(t=[]);var r,e=n?Math.min(t.length,n.length):0,i=t.slice();return function(o){for(r=0;r<e;++r)i[r]=n[r]*(1-o)+t[r]*o;return i}}function xK(n,t){var a,e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),o=new Array(e);for(a=0;a<i;++a)r[a]=Qh(n[a],t[a]);for(;a<e;++a)o[a]=t[a];return function(s){for(a=0;a<i;++a)o[a]=r[a](s);return o}}function CK(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function Uo(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function MK(n,t){var r,e={},i={};for(r in(null===n||"object"!=typeof n)&&(n={}),(null===t||"object"!=typeof t)&&(t={}),t)r in n?e[r]=Qh(n[r],t[r]):i[r]=t[r];return function(o){for(r in e)i[r]=e[r](o);return i}}bK(function(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],o=n[i+1];return nL((e-i/t)*t,i>0?n[i-1]:2*r-o,r,o,i<t-1?n[i+2]:2*o-r)}}),bK(function(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t);return nL((e-i/t)*t,n[(i+t-1)%t],n[i%t],n[(i+1)%t],n[(i+2)%t])}});var rL=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,iL=new RegExp(rL.source,"g");function Ay(n,t){var i,r,o,e=rL.lastIndex=iL.lastIndex=0,a=-1,s=[],l=[];for(n+="",t+="";(i=rL.exec(n))&&(r=iL.exec(t));)(o=r.index)>e&&(o=t.slice(e,o),s[a]?s[a]+=o:s[++a]=o),(i=i[0])===(r=r[0])?s[a]?s[a]+=r:s[++a]=r:(s[++a]=null,l.push({i:a,x:Uo(i,r)})),e=iL.lastIndex;return e<t.length&&(o=t.slice(e),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?function(n){return function(t){return n(t)+""}}(l[0].x):function(n){return function(){return n}}(t):(t=l.length,function(c){for(var u,d=0;d<t;++d)s[(u=l[d]).i]=u.x(c);return s.join("")})}function Qh(n,t){var i,e=typeof t;return null==t||"boolean"===e?o0(t):("number"===e?Uo:"string"===e?(i=Hl(t))?(t=i,Yh):Ay:t instanceof Hl?Yh:t instanceof Date?CK:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}(t)?vK:Array.isArray(t)?xK:"function"!=typeof t.valueOf&&"function"!=typeof t.toString||isNaN(t)?MK:Uo)(n,t)}function oL(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Ry,sL,SK,pD,wK=180/Math.PI,uD={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function aL(n,t,e,i,r,o){var a,s,l;return(a=Math.sqrt(n*n+t*t))&&(n/=a,t/=a),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(s=Math.sqrt(e*e+i*i))&&(e/=s,i/=s,l/=s),n*i<t*e&&(n=-n,t=-t,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(t,n)*wK,skewX:Math.atan(l)*wK,scaleX:a,scaleY:s}}function DK(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}return function(c,d){var u=[],p=[];return c=n(c),d=n(d),function(c,d,u,p,h,m){if(c!==u||d!==p){var _=h.push("translate(",null,t,null,e);m.push({i:_-4,x:Uo(c,u)},{i:_-2,x:Uo(d,p)})}else(u||p)&&h.push("translate("+u+t+p+e)}(c.translateX,c.translateY,d.translateX,d.translateY,u,p),function(c,d,u,p){c!==d?(c-d>180?d+=360:d-c>180&&(c+=360),p.push({i:u.push(r(u)+"rotate(",null,i)-2,x:Uo(c,d)})):d&&u.push(r(u)+"rotate("+d+i)}(c.rotate,d.rotate,u,p),function(c,d,u,p){c!==d?p.push({i:u.push(r(u)+"skewX(",null,i)-2,x:Uo(c,d)}):d&&u.push(r(u)+"skewX("+d+i)}(c.skewX,d.skewX,u,p),function(c,d,u,p,h,m){if(c!==u||d!==p){var _=h.push(r(h)+"scale(",null,",",null,")");m.push({i:_-4,x:Uo(c,u)},{i:_-2,x:Uo(d,p)})}else(1!==u||1!==p)&&h.push(r(h)+"scale("+u+","+p+")")}(c.scaleX,c.scaleY,d.scaleX,d.scaleY,u,p),c=d=null,function(h){for(var M,m=-1,_=p.length;++m<_;)u[(M=p[m]).i]=M.x(h);return u.join("")}}}var lL=DK(function(n){return"none"===n?uD:(Ry||(Ry=document.createElement("DIV"),sL=document.documentElement,SK=document.defaultView),Ry.style.transform=n,n=SK.getComputedStyle(sL.appendChild(Ry),null).getPropertyValue("transform"),sL.removeChild(Ry),aL(+(n=n.slice(7,-1).split(","))[0],+n[1],+n[2],+n[3],+n[4],+n[5]))},"px, ","px)","deg)"),cL=DK(function(n){return null==n?uD:(pD||(pD=document.createElementNS("http://www.w3.org/2000/svg","g")),pD.setAttribute("transform",n),(n=pD.transform.baseVal.consolidate())?aL((n=n.matrix).a,n.b,n.c,n.d,n.e,n.f):uD)},", ",")",")");function IK(n){return function(t,e){var i=n((t=qh(t)).h,(e=qh(e)).h),r=Ka(t.s,e.s),o=Ka(t.l,e.l),a=Ka(t.opacity,e.opacity);return function(s){return t.h=i(s),t.s=r(s),t.l=o(s),t.opacity=a(s),t+""}}}var dL=IK(dD);function AK(n){return function(t,e){var i=n((t=Xh(t)).h,(e=Xh(e)).h),r=Ka(t.c,e.c),o=Ka(t.l,e.l),a=Ka(t.opacity,e.opacity);return function(s){return t.h=i(s),t.c=r(s),t.l=o(s),t.opacity=a(s),t+""}}}IK(Ka);var hD,Oy,uL=AK(dD),a0=(AK(Ka),0),ky=0,Py=0,PK=1e3,mD=0,Zh=0,fD=0,Fy="object"==typeof performance&&performance.now?performance:Date,kK="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function s0(){return Zh||(kK(rDe),Zh=Fy.now()+fD)}function rDe(){Zh=0}function Ny(){this._call=this._time=this._next=null}function gD(n,t,e){var i=new Ny;return i.restart(n,t,e),i}function RK(){Zh=(mD=Fy.now())+fD,a0=ky=0;try{!function(){s0(),++a0;for(var t,n=hD;n;)(t=Zh-n._time)>=0&&n._call.call(null,t),n=n._next;--a0}()}finally{a0=0,function(){for(var n,e,t=hD,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:hD=e);Oy=n,pL(i)}(),Zh=0}}function oDe(){var n=Fy.now(),t=n-mD;t>PK&&(fD-=t,mD=n)}function pL(n){a0||(ky&&(ky=clearTimeout(ky)),n-Zh>24?(n<1/0&&(ky=setTimeout(RK,n-Fy.now()-fD)),Py&&(Py=clearInterval(Py))):(Py||(mD=Fy.now(),Py=setInterval(oDe,PK)),a0=1,kK(RK)))}function _D(n,t,e){var i=new Ny;return i.restart(function(r){i.stop(),n(r+t)},t=null==t?0:+t,e),i}Ny.prototype=gD.prototype={constructor:Ny,restart:function(n,t,e){if("function"!=typeof n)throw new TypeError("callback is not a function");e=(null==e?s0():+e)+(null==t?0:+t),!this._next&&Oy!==this&&(Oy?Oy._next=this:hD=this,Oy=this),this._call=n,this._time=e,pL()},stop:function(){this._call&&(this._call=null,this._time=1/0,pL())}};var sDe=jN("start","end","cancel","interrupt"),lDe=[],NK=0,hL=1,vD=2,bD=3,FK=4,yD=5,Ly=6;function op(n,t,e,i,r,o){var a=n.__transition;if(a){if(e in a)return}else n.__transition={};!function(n,t,e){var r,i=n.__transition;function a(c){var d,u,p,h;if(e.state!==hL)return l();for(d in i)if((h=i[d]).name===e.name){if(h.state===bD)return _D(a);h.state===FK?(h.state=Ly,h.timer.stop(),h.on.call("interrupt",n,n.__data__,h.index,h.group),delete i[d]):+d<t&&(h.state=Ly,h.timer.stop(),h.on.call("cancel",n,n.__data__,h.index,h.group),delete i[d])}if(_D(function(){e.state===bD&&(e.state=FK,e.timer.restart(s,e.delay,e.time),s(c))}),e.state=vD,e.on.call("start",n,n.__data__,e.index,e.group),e.state===vD){for(e.state=bD,r=new Array(p=e.tween.length),d=0,u=-1;d<p;++d)(h=e.tween[d].value.call(n,n.__data__,e.index,e.group))&&(r[++u]=h);r.length=u+1}}function s(c){for(var d=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=yD,1),u=-1,p=r.length;++u<p;)r[u].call(n,d);e.state===yD&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){for(var c in e.state=Ly,e.timer.stop(),delete i[t],i)return;delete n.__transition}i[t]=e,e.timer=gD(function(c){e.state=hL,e.timer.restart(a,e.delay,e.time),e.delay<=c&&a(c-e.delay)},0,e.time)}(n,e,{name:t,index:i,group:r,on:sDe,tween:lDe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:NK})}function By(n,t){var e=_o(n,t);if(e.state>NK)throw new Error("too late; already scheduled");return e}function ya(n,t){var e=_o(n,t);if(e.state>bD)throw new Error("too late; already running");return e}function _o(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function dDe(n,t){var e,i;return function(){var r=ya(this,n),o=r.tween;if(o!==e)for(var a=0,s=(i=e=o).length;a<s;++a)if(i[a].name===t){(i=i.slice()).splice(a,1);break}r.tween=i}}function uDe(n,t,e){var i,r;if("function"!=typeof e)throw new Error;return function(){var o=ya(this,n),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function l0(n,t,e){var i=n._id;return n.each(function(){var r=ya(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return _o(r,i).value[t]}}function xD(n,t){var e;return("number"==typeof t?Uo:t instanceof Hl?Yh:(e=Hl(t))?(t=e,Yh):Ay)(n,t)}function pDe(n){return function(){this.removeAttribute(n)}}function hDe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function mDe(n,t,e){var i,o,r=e+"";return function(){var a=this.getAttribute(n);return a===r?null:a===i?o:o=t(i=a,e)}}function fDe(n,t,e){var i,o,r=e+"";return function(){var a=this.getAttributeNS(n.space,n.local);return a===r?null:a===i?o:o=t(i=a,e)}}function gDe(n,t,e){var i,r,o;return function(){var a,l,s=e(this);return null==s?void this.removeAttribute(n):(a=this.getAttribute(n))===(l=s+"")?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}function _De(n,t,e){var i,r,o;return function(){var a,l,s=e(this);return null==s?void this.removeAttributeNS(n.space,n.local):(a=this.getAttributeNS(n.space,n.local))===(l=s+"")?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}function yDe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}(n,o)),e}return r._value=t,r}function xDe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&function(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}(n,o)),e}return r._value=t,r}function CDe(n,t){return function(){By(this,n).delay=+t.apply(this,arguments)}}function MDe(n,t){return t=+t,function(){By(this,n).delay=t}}function wDe(n,t){return function(){ya(this,n).duration=+t.apply(this,arguments)}}function SDe(n,t){return t=+t,function(){ya(this,n).duration=t}}var ADe=Rd.prototype.constructor;function KK(n){return function(){this.style.removeProperty(n)}}var zDe=0;function ta(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function CD(){return++zDe}var c0=Rd.prototype;ta.prototype=function(n){return Rd().transition(n)}.prototype={constructor:ta,select:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Gh(n));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var d,u,s=i[a],l=s.length,c=o[a]=new Array(l),p=0;p<l;++p)(d=s[p])&&(u=n.call(d,d.__data__,p,s))&&("__data__"in d&&(u.__data__=d.__data__),c[p]=u,op(c[p],t,e,p,c,_o(d,e)));return new ta(o,this._parents,t,e)},selectAll:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Sy(n));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var d,l=i[s],c=l.length,u=0;u<c;++u)if(d=l[u]){for(var h,p=n.call(d,d.__data__,u,l),m=_o(d,e),_=0,M=p.length;_<M;++_)(h=p[_])&&op(h,t,e,_,p,m);o.push(p),a.push(d)}return new ta(o,a,t,e)},filter:function(n){"function"!=typeof n&&(n=Ey(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],a=o.length,s=i[r]=[],c=0;c<a;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&s.push(l);return new ta(i,this._parents,this._name,this._id)},merge:function(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),a=new Array(i),s=0;s<o;++s)for(var p,l=t[s],c=e[s],d=l.length,u=a[s]=new Array(d),h=0;h<d;++h)(p=l[h]||c[h])&&(u[h]=p);for(;s<i;++s)a[s]=t[s];return new ta(a,this._parents,this._name,this._id)},selection:function(){return new ADe(this._groups,this._parents)},transition:function(){for(var n=this._name,t=this._id,e=CD(),i=this._groups,r=i.length,o=0;o<r;++o)for(var l,a=i[o],s=a.length,c=0;c<s;++c)if(l=a[c]){var d=_o(l,t);op(l,n,e,c,a,{time:d.time+d.delay+d.duration,delay:0,duration:d.duration,ease:d.ease})}return new ta(i,this._parents,n,e)},call:c0.call,nodes:c0.nodes,node:c0.node,size:c0.size,empty:c0.empty,each:c0.each,on:function(n,t){var e=this._id;return arguments.length<2?_o(this.node(),e).on.on(n):this.each(function(n,t,e){var i,r,o=function(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t})}(t)?By:ya;return function(){var a=o(this,n),s=a.on;s!==i&&(r=(i=s).copy()).on(t,e),a.on=r}}(e,n,t))},attr:function(n,t){var e=Ad(n),i="transform"===e?cL:xD;return this.attrTween(n,"function"==typeof t?(e.local?_De:gDe)(e,i,l0(this,"attr."+n,t)):null==t?(e.local?hDe:pDe)(e):(e.local?fDe:mDe)(e,i,t))},attrTween:function(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;var i=Ad(n);return this.tween(e,(i.local?yDe:xDe)(i,t))},style:function(n,t,e){var i="transform"==(n+="")?lL:xD;return null==t?this.styleTween(n,function(n,t){var e,i,r;return function(){var o=ip(this,n),a=(this.style.removeProperty(n),ip(this,n));return o===a?null:o===e&&a===i?r:r=t(e=o,i=a)}}(n,i)).on("end.style."+n,KK(n)):"function"==typeof t?this.styleTween(n,function(n,t,e){var i,r,o;return function(){var a=ip(this,n),s=e(this),l=s+"";return null==s&&(this.style.removeProperty(n),l=s=ip(this,n)),a===l?null:a===i&&l===r?o:(r=l,o=t(i=a,s))}}(n,i,l0(this,"style."+n,t))).each(function(n,t){var e,i,r,s,o="style."+t,a="end."+o;return function(){var l=ya(this,n),c=l.on,d=null==l.value[o]?s||(s=KK(t)):void 0;(c!==e||r!==d)&&(i=(e=c).copy()).on(a,r=d),l.on=i}}(this._id,n)):this.styleTween(n,function(n,t,e){var i,o,r=e+"";return function(){var a=ip(this,n);return a===r?null:a===i?o:o=t(i=a,e)}}(n,i,t),e).on("end.style."+n,null)},styleTween:function(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==t)return this.tween(i,null);if("function"!=typeof t)throw new Error;return this.tween(i,function(n,t,e){var i,r;function o(){var a=t.apply(this,arguments);return a!==r&&(i=(r=a)&&function(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}(n,a,e)),i}return o._value=t,o}(n,t,e??""))},text:function(n){return this.tween("text","function"==typeof n?function(n){return function(){var t=n(this);this.textContent=t??""}}(l0(this,"text",n)):function(n){return function(){this.textContent=n}}(null==n?"":n+""))},textTween:function(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(null==n)return this.tween(t,null);if("function"!=typeof n)throw new Error;return this.tween(t,function(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&function(n){return function(t){this.textContent=n.call(this,t)}}(r)),t}return i._value=n,i}(n))},remove:function(){return this.on("end.remove",function(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}(this._id))},tween:function(n,t){var e=this._id;if(n+="",arguments.length<2){for(var a,i=_o(this.node(),e).tween,r=0,o=i.length;r<o;++r)if((a=i[r]).name===n)return a.value;return null}return this.each((null==t?dDe:uDe)(e,n,t))},delay:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?CDe:MDe)(t,n)):_o(this.node(),t).delay},duration:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?wDe:SDe)(t,n)):_o(this.node(),t).duration},ease:function(n){var t=this._id;return arguments.length?this.each(function(n,t){if("function"!=typeof t)throw new Error;return function(){ya(this,n).ease=t}}(t,n)):_o(this.node(),t).ease},end:function(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(o,a){var s={value:a},l={value:function(){0==--r&&o()}};e.each(function(){var c=ya(this,i),d=c.on;d!==n&&((t=(n=d).copy())._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}};var fL={time:null,delay:0,duration:250,ease:function(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}};function UDe(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return fL.time=s0(),fL;return e}function gL(n){return{type:n}}Rd.prototype.interrupt=function(n){return this.each(function(){!function(n,t){var i,r,a,e=n.__transition,o=!0;if(e){for(a in t=null==t?null:t+"",e)(i=e[a]).name===t?(r=i.state>vD&&i.state<yD,i.state=Ly,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[a]):o=!1;o&&delete n.__transition}}(this,n)})},Rd.prototype.transition=function(n){var t,e;n instanceof ta?(t=n._id,n=n._name):(t=CD(),(e=fL).time=s0(),n=null==n?null:n+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var l,a=i[o],s=a.length,c=0;c<s;++c)(l=a[c])&&op(l,n,t,c,a,e||UDe(l,t));return new ta(i,this._parents,n,t)},["w","e"].map(gL),["n","s"].map(gL),["n","w","e","s","nw","ne","sw","se"].map(gL),Math;var Ms="$";function wD(){}function sJ(n,t){var e=new wD;if(n instanceof wD)n.each(function(s,l){e.set(l,s)});else if(Array.isArray(n)){var o,i=-1,r=n.length;if(null==t)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(o=n[i],i,n),o)}else if(n)for(var a in n)e.set(a,n[a]);return e}function SD(){}wD.prototype=sJ.prototype={constructor:wD,has:function(n){return Ms+n in this},get:function(n){return this[Ms+n]},set:function(n,t){return this[Ms+n]=t,this},remove:function(n){var t=Ms+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Ms&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Ms&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Ms&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Ms&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Ms&&++n;return n},empty:function(){for(var n in this)if(n[0]===Ms)return!1;return!0},each:function(n){for(var t in this)t[0]===Ms&&n(this[t],t.slice(1),this)}};var Jh=sJ.prototype;function $h(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function zc(n){return(n=$h(Math.abs(n)))?n[1]:NaN}SD.prototype=function(n,t){var e=new SD;if(n instanceof SD)n.each(function(o){e.add(o)});else if(n){var i=-1,r=n.length;if(null==t)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}.prototype={constructor:SD,has:Jh.has,add:function(n){return this[Ms+(n+="")]=n,this},remove:Jh.remove,clear:Jh.clear,values:Jh.keys,size:Jh.size,empty:Jh.empty,each:Jh.each},Math,Math.sqrt(5);var _L,KDe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ap(n){if(!(t=KDe.exec(n)))throw new Error("invalid format: "+n);var t;return new ED({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function ED(n){this.fill=void 0===n.fill?" ":n.fill+"",this.align=void 0===n.align?">":n.align+"",this.sign=void 0===n.sign?"-":n.sign+"",this.symbol=void 0===n.symbol?"":n.symbol+"",this.zero=!!n.zero,this.width=void 0===n.width?void 0:+n.width,this.comma=!!n.comma,this.precision=void 0===n.precision?void 0:+n.precision,this.trim=!!n.trim,this.type=void 0===n.type?"":n.type+""}function bL(n,t){var e=$h(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}ap.prototype=ED.prototype,ED.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var vL={"%":function(n,t){return(100*n).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:function(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)},e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return bL(100*n,t)},r:bL,s:function(n,t){var e=$h(n,t);if(!e)return n+"";var i=e[0],r=e[1],o=r-(_L=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,a=i.length;return o===a?i:o>a?i+new Array(o-a+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+$h(n,Math.max(0,t+o-1))[0]},X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function yL(n){return n}var TD,Yr,DD,fJ=Array.prototype.map,gJ=["y","z","a","f","p","n","\xb5","m","","k","M","G","T","P","E","Z","Y"];function sl(){return Math.random()}TD=function(n){var t=void 0===n.grouping||void 0===n.thousands?yL:function(n,t){return function(e,i){for(var r=e.length,o=[],a=0,s=n[0],l=0;r>0&&s>0&&(l+s+1>i&&(s=Math.max(1,i-l)),o.push(e.substring(r-=s,r+s)),!((l+=s+1)>i));)s=n[a=(a+1)%n.length];return o.reverse().join(t)}}(fJ.call(n.grouping,Number),n.thousands+""),e=void 0===n.currency?"":n.currency[0]+"",i=void 0===n.currency?"":n.currency[1]+"",r=void 0===n.decimal?".":n.decimal+"",o=void 0===n.numerals?yL:function(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}(fJ.call(n.numerals,String)),a=void 0===n.percent?"%":n.percent+"",s=void 0===n.minus?"-":n.minus+"",l=void 0===n.nan?"NaN":n.nan+"";function c(u){var p=(u=ap(u)).fill,h=u.align,m=u.sign,_=u.symbol,M=u.zero,y=u.width,x=u.comma,R=u.precision,I=u.trim,B=u.type;"n"===B?(x=!0,B="g"):vL[B]||(void 0===R&&(R=12),I=!0,B="g"),(M||"0"===p&&"="===h)&&(M=!0,p="0",h="=");var ee="$"===_?e:"#"===_&&/[boxX]/.test(B)?"0"+B.toLowerCase():"",Q="$"===_?i:/[%p]/.test(B)?a:"",we=vL[B],Qe=/[defgprs%]/.test(B);function Ae(D){var he,_e,$,re=ee,ce=Q;if("c"===B)ce=we(D)+ce,D="";else{var de=(D=+D)<0||1/D<0;if(D=isNaN(D)?l:we(Math.abs(D),R),I&&(D=function(n){e:for(var r,t=n.length,e=1,i=-1;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":0===i&&(i=e),r=e;break;default:if(!+n[e])break e;i>0&&(i=0)}return i>0?n.slice(0,i)+n.slice(r+1):n}(D)),de&&0==+D&&"+"!==m&&(de=!1),re=(de?"("===m?m:s:"-"===m||"("===m?"":m)+re,ce=("s"===B?gJ[8+_L/3]:"")+ce+(de&&"("===m?")":""),Qe)for(he=-1,_e=D.length;++he<_e;)if(48>($=D.charCodeAt(he))||$>57){ce=(46===$?r+D.slice(he+1):D.slice(he))+ce,D=D.slice(0,he);break}}x&&!M&&(D=t(D,1/0));var pe=re.length+D.length+ce.length,Ge=pe<y?new Array(y-pe+1).join(p):"";switch(x&&M&&(D=t(Ge+D,Ge.length?y-ce.length:1/0),Ge=""),h){case"<":D=re+D+ce+Ge;break;case"=":D=re+Ge+D+ce;break;case"^":D=Ge.slice(0,pe=Ge.length>>1)+re+D+ce+Ge.slice(pe);break;default:D=Ge+re+D+ce}return o(D)}return R=void 0===R?6:/[gprs]/.test(B)?Math.max(1,Math.min(21,R)):Math.max(0,Math.min(20,R)),Ae.toString=function(){return u+""},Ae}return{format:c,formatPrefix:function(u,p){var h=c(((u=ap(u)).type="f",u)),m=3*Math.max(-8,Math.min(8,Math.floor(zc(p)/3))),_=Math.pow(10,-m),M=gJ[8+m/3];return function(y){return h(_*y)+M}}}}({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"}),Yr=TD.format,DD=TD.formatPrefix,function n(t){function e(i,r){return i=null==i?0:+i,r=null==r?1:+r,1===arguments.length?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(sl);var SL=function n(t){function e(i,r){var o,a;return i=null==i?0:+i,r=null==r?1:+r,function(){var s;if(null!=o)s=o,o=null;else do{o=2*t()-1,s=2*t()-1,a=o*o+s*s}while(!a||a>1);return i+r*s*Math.sqrt(-2*Math.log(a)/a)}}return e.source=n,e}(sl),EL=(function n(t){function e(){var i=SL.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(sl),function n(t){function e(i){return function(){for(var r=0,o=0;o<i;++o)r+=t();return r}}return e.source=n,e}(sl));function Ja(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n)}return this}(function n(t){function e(i){var r=EL.source(t)(i);return function(){return r()/i}}return e.source=n,e})(sl),function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(sl);var bJ=Array.prototype,zy=bJ.map,em=bJ.slice;function TL(n){return+n}var yJ=[0,1];function $a(n){return n}function DL(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:function(n){return function(){return n}}(isNaN(t)?NaN:.5)}function xJ(n){var i,t=n[0],e=n[n.length-1];return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function iIe(n,t,e){var i=n[0],r=n[1],o=t[0],a=t[1];return r<i?(i=DL(r,i),o=e(a,o)):(i=DL(i,r),o=e(o,a)),function(s){return o(i(s))}}function rIe(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),o=new Array(i),a=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++a<i;)r[a]=DL(n[a],n[a+1]),o[a]=e(t[a],t[a+1]);return function(s){var l=Lc(n,s,1,i)-1;return o[l](r[l](s))}}function sp(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Uy(){var i,r,o,s,l,c,n=yJ,t=yJ,e=Qh,a=$a;function d(){return s=Math.min(n.length,t.length)>2?rIe:iIe,l=c=null,u}function u(p){return isNaN(p=+p)?o:(l||(l=s(n.map(i),t,e)))(i(a(p)))}return u.invert=function(p){return a(r((c||(c=s(t,n.map(i),Uo)))(p)))},u.domain=function(p){return arguments.length?(n=zy.call(p,TL),a===$a||(a=xJ(n)),d()):n.slice()},u.range=function(p){return arguments.length?(t=em.call(p),d()):t.slice()},u.rangeRound=function(p){return t=em.call(p),e=oL,d()},u.clamp=function(p){return arguments.length?(a=p?xJ(n):$a,u):a!==$a},u.interpolate=function(p){return arguments.length?(e=p,d()):e},u.unknown=function(p){return arguments.length?(o=p,u):o},function(p,h){return i=p,r=h,d()}}function jy(n,t){return Uy()(n,t)}function zl(){var n=jy($a,$a);return n.copy=function(){return sp(n,zl())},Ja.apply(n,arguments),function(n){var t=n.domain;return n.ticks=function(e){var i=t();return My(i[0],i[i.length-1],e??10)},n.tickFormat=function(e,i){var r=t();return function(n,t,e,i){var o,r=Id(n,t,e);switch((i=ap(i??",f")).type){case"s":var a=Math.max(Math.abs(n),Math.abs(t));return null==i.precision&&!isNaN(o=function(n,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(zc(t)/3)))-zc(Math.abs(n)))}(r,a))&&(i.precision=o),DD(i,a);case"":case"e":case"g":case"p":case"r":null==i.precision&&!isNaN(o=function(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,zc(t)-zc(n))+1}(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=o-("e"===i.type));break;case"f":case"%":null==i.precision&&!isNaN(o=function(n){return Math.max(0,-zc(Math.abs(n)))}(r))&&(i.precision=o-2*("%"===i.type))}return Yr(i)}(r[0],r[r.length-1],e??10,i)},n.nice=function(e){null==e&&(e=10);var l,i=t(),r=0,o=i.length-1,a=i[r],s=i[o];return s<a&&(l=a,a=s,s=l,l=r,r=o,o=l),(l=e0(a,s,e))>0?l=e0(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,e):l<0&&(l=e0(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,e)),l>0?(i[r]=Math.floor(a/l)*l,i[o]=Math.ceil(s/l)*l,t(i)):l<0&&(i[r]=Math.ceil(a*l)/l,i[o]=Math.floor(s*l)/l,t(i)),n},n}(n)}function ID(n,t){var a,e=0,i=(n=n.slice()).length-1,r=n[e],o=n[i];return o<r&&(a=e,e=i,i=a,a=r,r=o,o=a),n[e]=t.floor(r),n[i]=t.ceil(o),n}function CJ(n){return Math.log(n)}function MJ(n){return Math.exp(n)}function oIe(n){return-Math.log(-n)}function aIe(n){return-Math.exp(-n)}function sIe(n){return isFinite(n)?+("1e"+n):n<0?0:n}function wJ(n){return function(t){return-n(-t)}}function Gy(){var n=function(n){var r,o,t=n(CJ,MJ),e=t.domain,i=10;function a(){return r=function(n){return n===Math.E?Math.log:10===n&&Math.log10||2===n&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}(i),o=function(n){return 10===n?sIe:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}(i),e()[0]<0?(r=wJ(r),o=wJ(o),n(oIe,aIe)):n(CJ,MJ),t}return t.base=function(s){return arguments.length?(i=+s,a()):i},t.domain=function(s){return arguments.length?(e(s),a()):e()},t.ticks=function(s){var u,l=e(),c=l[0],d=l[l.length-1];(u=d<c)&&(p=c,c=d,d=p);var m,_,M,p=r(c),h=r(d),y=null==s?10:+s,x=[];if(!(i%1)&&h-p<y){if(p=Math.round(p)-1,h=Math.round(h)+1,c>0){for(;p<h;++p)for(_=1,m=o(p);_<i;++_)if(!((M=m*_)<c)){if(M>d)break;x.push(M)}}else for(;p<h;++p)for(_=i-1,m=o(p);_>=1;--_)if(!((M=m*_)<c)){if(M>d)break;x.push(M)}}else x=My(p,h,Math.min(h-p,y)).map(o);return u?x.reverse():x},t.tickFormat=function(s,l){if(null==l&&(l=10===i?".0e":","),"function"!=typeof l&&(l=Yr(l)),s===1/0)return l;null==s&&(s=10);var c=Math.max(1,i*s/t.ticks().length);return function(d){var u=d/o(Math.round(r(d)));return u*i<i-.5&&(u*=i),u<=c?l(d):""}},t.nice=function(){return e(ID(e(),{floor:function(s){return o(Math.floor(r(s)))},ceil:function(s){return o(Math.ceil(r(s)))}}))},t}(Uy()).domain([1,10]);return n.copy=function(){return sp(n,Gy()).base(n.base())},Ja.apply(n,arguments),n}var RL=new Date,PL=new Date;function nr(n,t,e,i){function r(o){return n(o=0===arguments.length?new Date:new Date(+o)),o}return r.floor=function(o){return n(o=new Date(+o)),o},r.ceil=function(o){return n(o=new Date(o-1)),t(o,1),n(o),o},r.round=function(o){var a=r(o),s=r.ceil(o);return o-a<s-o?a:s},r.offset=function(o,a){return t(o=new Date(+o),null==a?1:Math.floor(a)),o},r.range=function(o,a,s){var c,l=[];if(o=r.ceil(o),s=null==s?1:Math.floor(s),!(o<a&&s>0))return l;do{l.push(c=new Date(+o)),t(o,s),n(o)}while(c<o&&o<a);return l},r.filter=function(o){return nr(function(a){if(a>=a)for(;n(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},e&&(r.count=function(o,a){return RL.setTime(+o),PL.setTime(+a),n(RL),n(PL),Math.floor(e(RL,PL))},r.every=function(o){return o=Math.floor(o),isFinite(o)&&o>0?o>1?r.filter(i?function(a){return i(a)%o==0}:function(a){return r.count(0,a)%o==0}):r:null}),r}var AD=nr(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});AD.every=function(n){return n=Math.floor(n),isFinite(n)&&n>0?n>1?nr(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):AD:null};var RD=AD,kd=6e4,kD=6048e5,EJ=nr(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+1e3*t)},function(n,t){return(t-n)/1e3},function(n){return n.getUTCSeconds()}),OD=EJ,DJ=nr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds())},function(n,t){n.setTime(+n+t*kd)},function(n,t){return(t-n)/kd},function(n){return n.getMinutes()}),OL=DJ,IJ=nr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds()-n.getMinutes()*kd)},function(n,t){n.setTime(+n+36e5*t)},function(n,t){return(t-n)/36e5},function(n){return n.getHours()}),FL=IJ,AJ=nr(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*kd)/864e5},function(n){return n.getDate()-1}),d0=AJ;function im(n){return nr(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+7*e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*kd)/kD})}var rm=im(0),u0=im(1),lp=(im(2),im(3),im(4)),NJ=(im(5),im(6),nr(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+12*(t.getFullYear()-n.getFullYear())},function(n){return n.getMonth()})),NL=NJ,LL=nr(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});LL.every=function(n){return isFinite(n=Math.floor(n))&&n>0?nr(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)}):null};var Od=LL,LJ=nr(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/864e5},function(n){return n.getUTCDate()-1}),FD=LJ;function om(n){return nr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+7*e)},function(t,e){return(e-t)/kD})}var Wy=om(0),p0=om(1),cp=(om(2),om(3),om(4)),BL=(om(5),om(6),nr(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()}));BL.every=function(n){return isFinite(n=Math.floor(n))&&n>0?nr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)}):null};var am=BL;function VL(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function HL(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function qy(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}var h0,m0,jJ={"-":"",_:" ",0:"0"},Po=/^\s*\d+/,IIe=/^%/,AIe=/[\\^$*+?|[\]().{}]/g;function Fi(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",o=r.length;return i+(o<e?new Array(e-o+1).join(t)+r:r)}function RIe(n){return n.replace(AIe,"\\$&")}function Xy(n){return new RegExp("^(?:"+n.map(RIe).join("|")+")","i")}function Yy(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function PIe(n,t,e){var i=Po.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function kIe(n,t,e){var i=Po.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function OIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function FIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function NIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function GJ(n,t,e){var i=Po.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function WJ(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function LIe(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function BIe(n,t,e){var i=Po.exec(t.slice(e,e+1));return i?(n.q=3*i[0]-3,e+i[0].length):-1}function VIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function qJ(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function HIe(n,t,e){var i=Po.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function XJ(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function zIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function UIe(n,t,e){var i=Po.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function jIe(n,t,e){var i=Po.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function GIe(n,t,e){var i=Po.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function WIe(n,t,e){var i=IIe.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function qIe(n,t,e){var i=Po.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function XIe(n,t,e){var i=Po.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function YJ(n,t){return Fi(n.getDate(),t,2)}function YIe(n,t){return Fi(n.getHours(),t,2)}function QIe(n,t){return Fi(n.getHours()%12||12,t,2)}function ZIe(n,t){return Fi(1+d0.count(Od(n),n),t,3)}function $J(n,t){return Fi(n.getMilliseconds(),t,3)}function KIe(n,t){return $J(n,t)+"000"}function JIe(n,t){return Fi(n.getMonth()+1,t,2)}function $Ie(n,t){return Fi(n.getMinutes(),t,2)}function eAe(n,t){return Fi(n.getSeconds(),t,2)}function tAe(n){var t=n.getDay();return 0===t?7:t}function nAe(n,t){return Fi(rm.count(Od(n)-1,n),t,2)}function e$(n){var t=n.getDay();return t>=4||0===t?lp(n):lp.ceil(n)}function iAe(n,t){return n=e$(n),Fi(lp.count(Od(n),n)+(4===Od(n).getDay()),t,2)}function rAe(n){return n.getDay()}function oAe(n,t){return Fi(u0.count(Od(n)-1,n),t,2)}function aAe(n,t){return Fi(n.getFullYear()%100,t,2)}function sAe(n,t){return Fi((n=e$(n)).getFullYear()%100,t,2)}function lAe(n,t){return Fi(n.getFullYear()%1e4,t,4)}function cAe(n,t){var e=n.getDay();return Fi((n=e>=4||0===e?lp(n):lp.ceil(n)).getFullYear()%1e4,t,4)}function dAe(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Fi(t/60|0,"0",2)+Fi(t%60,"0",2)}function QJ(n,t){return Fi(n.getUTCDate(),t,2)}function uAe(n,t){return Fi(n.getUTCHours(),t,2)}function pAe(n,t){return Fi(n.getUTCHours()%12||12,t,2)}function hAe(n,t){return Fi(1+FD.count(am(n),n),t,3)}function t$(n,t){return Fi(n.getUTCMilliseconds(),t,3)}function mAe(n,t){return t$(n,t)+"000"}function fAe(n,t){return Fi(n.getUTCMonth()+1,t,2)}function gAe(n,t){return Fi(n.getUTCMinutes(),t,2)}function _Ae(n,t){return Fi(n.getUTCSeconds(),t,2)}function bAe(n){var t=n.getUTCDay();return 0===t?7:t}function vAe(n,t){return Fi(Wy.count(am(n)-1,n),t,2)}function n$(n){var t=n.getUTCDay();return t>=4||0===t?cp(n):cp.ceil(n)}function yAe(n,t){return n=n$(n),Fi(cp.count(am(n),n)+(4===am(n).getUTCDay()),t,2)}function xAe(n){return n.getUTCDay()}function CAe(n,t){return Fi(p0.count(am(n)-1,n),t,2)}function MAe(n,t){return Fi(n.getUTCFullYear()%100,t,2)}function wAe(n,t){return Fi((n=n$(n)).getUTCFullYear()%100,t,2)}function SAe(n,t){return Fi(n.getUTCFullYear()%1e4,t,4)}function EAe(n,t){var e=n.getUTCDay();return Fi((n=e>=4||0===e?cp(n):cp.ceil(n)).getUTCFullYear()%1e4,t,4)}function TAe(){return"+0000"}function ZJ(){return"%"}function KJ(n){return+n}function JJ(n){return Math.floor(+n/1e3)}h0=function(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,o=n.days,a=n.shortDays,s=n.months,l=n.shortMonths,c=Xy(r),d=Yy(r),u=Xy(o),p=Yy(o),h=Xy(a),m=Yy(a),_=Xy(s),M=Yy(s),y=Xy(l),x=Yy(l),R={a:function(Ce){return a[Ce.getDay()]},A:function(Ce){return o[Ce.getDay()]},b:function(Ce){return l[Ce.getMonth()]},B:function(Ce){return s[Ce.getMonth()]},c:null,d:YJ,e:YJ,f:KIe,g:sAe,G:cAe,H:YIe,I:QIe,j:ZIe,L:$J,m:JIe,M:$Ie,p:function(Ce){return r[+(Ce.getHours()>=12)]},q:function(Ce){return 1+~~(Ce.getMonth()/3)},Q:KJ,s:JJ,S:eAe,u:tAe,U:nAe,V:iAe,w:rAe,W:oAe,x:null,X:null,y:aAe,Y:lAe,Z:dAe,"%":ZJ},I={a:function(Ce){return a[Ce.getUTCDay()]},A:function(Ce){return o[Ce.getUTCDay()]},b:function(Ce){return l[Ce.getUTCMonth()]},B:function(Ce){return s[Ce.getUTCMonth()]},c:null,d:QJ,e:QJ,f:mAe,g:wAe,G:EAe,H:uAe,I:pAe,j:hAe,L:t$,m:fAe,M:gAe,p:function(Ce){return r[+(Ce.getUTCHours()>=12)]},q:function(Ce){return 1+~~(Ce.getUTCMonth()/3)},Q:KJ,s:JJ,S:_Ae,u:bAe,U:vAe,V:yAe,w:xAe,W:CAe,x:null,X:null,y:MAe,Y:SAe,Z:TAe,"%":ZJ},B={a:function(Ce,mt,ht){var oe=h.exec(mt.slice(ht));return oe?(Ce.w=m[oe[0].toLowerCase()],ht+oe[0].length):-1},A:function(Ce,mt,ht){var oe=u.exec(mt.slice(ht));return oe?(Ce.w=p[oe[0].toLowerCase()],ht+oe[0].length):-1},b:function(Ce,mt,ht){var oe=y.exec(mt.slice(ht));return oe?(Ce.m=x[oe[0].toLowerCase()],ht+oe[0].length):-1},B:function(Ce,mt,ht){var oe=_.exec(mt.slice(ht));return oe?(Ce.m=M[oe[0].toLowerCase()],ht+oe[0].length):-1},c:function(Ce,mt,ht){return we(Ce,t,mt,ht)},d:qJ,e:qJ,f:GIe,g:WJ,G:GJ,H:XJ,I:XJ,j:HIe,L:jIe,m:VIe,M:zIe,p:function(Ce,mt,ht){var oe=c.exec(mt.slice(ht));return oe?(Ce.p=d[oe[0].toLowerCase()],ht+oe[0].length):-1},q:BIe,Q:qIe,s:XIe,S:UIe,u:kIe,U:OIe,V:FIe,w:PIe,W:NIe,x:function(Ce,mt,ht){return we(Ce,e,mt,ht)},X:function(Ce,mt,ht){return we(Ce,i,mt,ht)},y:WJ,Y:GJ,Z:LIe,"%":WIe};function ee(Ce,mt){return function(ht){var ut,an,yn,oe=[],at=-1,Ye=0,_t=Ce.length;for(ht instanceof Date||(ht=new Date(+ht));++at<_t;)37===Ce.charCodeAt(at)&&(oe.push(Ce.slice(Ye,at)),null!=(an=jJ[ut=Ce.charAt(++at)])?ut=Ce.charAt(++at):an="e"===ut?" ":"0",(yn=mt[ut])&&(ut=yn(ht,an)),oe.push(ut),Ye=at+1);return oe.push(Ce.slice(Ye,at)),oe.join("")}}function Q(Ce,mt){return function(ht){var Ye,_t,oe=qy(1900,void 0,1);if(we(oe,Ce,ht+="",0)!=ht.length)return null;if("Q"in oe)return new Date(oe.Q);if("s"in oe)return new Date(1e3*oe.s+("L"in oe?oe.L:0));if(mt&&!("Z"in oe)&&(oe.Z=0),"p"in oe&&(oe.H=oe.H%12+12*oe.p),void 0===oe.m&&(oe.m="q"in oe?oe.q:0),"V"in oe){if(oe.V<1||oe.V>53)return null;"w"in oe||(oe.w=1),"Z"in oe?(_t=(Ye=HL(qy(oe.y,0,1))).getUTCDay(),Ye=_t>4||0===_t?p0.ceil(Ye):p0(Ye),Ye=FD.offset(Ye,7*(oe.V-1)),oe.y=Ye.getUTCFullYear(),oe.m=Ye.getUTCMonth(),oe.d=Ye.getUTCDate()+(oe.w+6)%7):(_t=(Ye=VL(qy(oe.y,0,1))).getDay(),Ye=_t>4||0===_t?u0.ceil(Ye):u0(Ye),Ye=d0.offset(Ye,7*(oe.V-1)),oe.y=Ye.getFullYear(),oe.m=Ye.getMonth(),oe.d=Ye.getDate()+(oe.w+6)%7)}else("W"in oe||"U"in oe)&&("w"in oe||(oe.w="u"in oe?oe.u%7:"W"in oe?1:0),_t="Z"in oe?HL(qy(oe.y,0,1)).getUTCDay():VL(qy(oe.y,0,1)).getDay(),oe.m=0,oe.d="W"in oe?(oe.w+6)%7+7*oe.W-(_t+5)%7:oe.w+7*oe.U-(_t+6)%7);return"Z"in oe?(oe.H+=oe.Z/100|0,oe.M+=oe.Z%100,HL(oe)):VL(oe)}}function we(Ce,mt,ht,oe){for(var ut,an,at=0,Ye=mt.length,_t=ht.length;at<Ye;){if(oe>=_t)return-1;if(37===(ut=mt.charCodeAt(at++))){if(ut=mt.charAt(at++),!(an=B[ut in jJ?mt.charAt(at++):ut])||(oe=an(Ce,ht,oe))<0)return-1}else if(ut!=ht.charCodeAt(oe++))return-1}return oe}return R.x=ee(e,R),R.X=ee(i,R),R.c=ee(t,R),I.x=ee(e,I),I.X=ee(i,I),I.c=ee(t,I),{format:function(Ce){var mt=ee(Ce+="",R);return mt.toString=function(){return Ce},mt},parse:function(Ce){var mt=Q(Ce+="",!1);return mt.toString=function(){return Ce},mt},utcFormat:function(Ce){var mt=ee(Ce+="",I);return mt.toString=function(){return Ce},mt},utcParse:function(Ce){var mt=Q(Ce+="",!0);return mt.toString=function(){return Ce},mt}}}({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]}),m0=h0.format;var Qy=1e3,Zy=60*Qy,Ky=60*Zy,Jy=24*Ky,DAe=7*Jy,a$=30*Jy,jL=365*Jy;function IAe(n){return new Date(n)}function AAe(n){return n instanceof Date?+n:+new Date(+n)}function GL(n,t,e,i,r,o,a,s,l){var c=jy($a,$a),d=c.invert,u=c.domain,p=l(".%L"),h=l(":%S"),m=l("%I:%M"),_=l("%I %p"),M=l("%a %d"),y=l("%b %d"),x=l("%B"),R=l("%Y"),I=[[a,1,Qy],[a,5,5*Qy],[a,15,15*Qy],[a,30,30*Qy],[o,1,Zy],[o,5,5*Zy],[o,15,15*Zy],[o,30,30*Zy],[r,1,Ky],[r,3,3*Ky],[r,6,6*Ky],[r,12,12*Ky],[i,1,Jy],[i,2,2*Jy],[e,1,DAe],[t,1,a$],[t,3,3*a$],[n,1,jL]];function B(Q){return(a(Q)<Q?p:o(Q)<Q?h:r(Q)<Q?m:i(Q)<Q?_:t(Q)<Q?e(Q)<Q?M:y:n(Q)<Q?x:R)(Q)}function ee(Q,we,Qe,Ae){if(null==Q&&(Q=10),"number"==typeof Q){var D=Math.abs(Qe-we)/Q,re=Cy(function(ce){return ce[2]}).right(I,D);re===I.length?(Ae=Id(we/jL,Qe/jL,Q),Q=n):re?(Ae=(re=I[D/I[re-1][2]<I[re][2]/D?re-1:re])[1],Q=re[0]):(Ae=Math.max(Id(we,Qe,Q),1),Q=s)}return null==Ae?Q:Q.every(Ae)}return c.invert=function(Q){return new Date(d(Q))},c.domain=function(Q){return arguments.length?u(zy.call(Q,AAe)):u().map(IAe)},c.ticks=function(Q,we){var ce,Qe=u(),Ae=Qe[0],D=Qe[Qe.length-1],re=D<Ae;return re&&(ce=Ae,Ae=D,D=ce),ce=(ce=ee(Q,Ae,D,we))?ce.range(Ae,D+1):[],re?ce.reverse():ce},c.tickFormat=function(Q,we){return null==we?B:l(we)},c.nice=function(Q,we){var Qe=u();return(Q=ee(Q,Qe[0],Qe[Qe.length-1],we))?u(ID(Qe,Q)):c},c.copy=function(){return sp(c,GL(n,t,e,i,r,o,a,s,l))},c}function sm(){return Ja.apply(GL(Od,NL,rm,d0,FL,OL,OD,RD,m0).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function WL(){this._=null}function f0(n){n.U=n.C=n.L=n.R=n.P=n.N=null}function $y(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function ex(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function l$(n){for(;n.L;)n=n.L;return n}WL.prototype={constructor:WL,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=l$(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)e===(i=e.U).L?(r=i.R)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&($y(this,e),e=(n=e).U),e.C=!1,i.C=!0,ex(this,i)):(r=i.L)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(ex(this,e),e=(n=e).U),e.C=!1,i.C=!0,$y(this,i)),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var e,o,a,t=n.U,i=n.L,r=n.R;if(o=i?r?l$(r):i:r,t?t.L===n?t.L=o:t.R=o:this._=o,i&&r?(a=o.C,o.C=n.C,o.L=i,i.U=o,o!==r?(t=o.U,o.U=n.U,t.L=n=o.R,o.R=r,r.U=o):(o.U=t,t=o,n=o.R)):(a=n.C,n=o),n&&(n.U=t),!a){if(n&&n.C)return void(n.C=!1);do{if(n===this._)break;if(n===t.L){if((e=t.R).C&&(e.C=!1,t.C=!0,$y(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,ex(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,$y(this,t),n=this._;break}}else if((e=t.L).C&&(e.C=!1,t.C=!0,ex(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,$y(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,ex(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};var qL=WL;function g0(n,t,e,i){var r=[null,null],o=ko.push(r)-1;return r.left=n,r.right=t,e&&tx(r,n,t,e),i&&tx(r,t,n,i),xa[n.index].halfedges.push(o),xa[t.index].halfedges.push(o),r}function _0(n,t,e){var i=[t,e];return i.left=n,i}function tx(n,t,e,i){n[0]||n[1]?n.left===e?n[1]=i:n[0]=i:(n[0]=i,n.left=t,n.right=e)}function kAe(n,t,e,i,r){var _,o=n[0],a=n[1],s=o[0],l=o[1],u=0,p=1,h=a[0]-s,m=a[1]-l;if(_=t-s,h||!(_>0)){if(_/=h,h<0){if(_<u)return;_<p&&(p=_)}else if(h>0){if(_>p)return;_>u&&(u=_)}if(_=i-s,h||!(_<0)){if(_/=h,h<0){if(_>p)return;_>u&&(u=_)}else if(h>0){if(_<u)return;_<p&&(p=_)}if(_=e-l,m||!(_>0)){if(_/=m,m<0){if(_<u)return;_<p&&(p=_)}else if(m>0){if(_>p)return;_>u&&(u=_)}if(_=r-l,m||!(_<0)){if(_/=m,m<0){if(_>p)return;_>u&&(u=_)}else if(m>0){if(_<u)return;_<p&&(p=_)}return!(u>0)&&!(p<1)||(u>0&&(n[0]=[s+u*h,l+u*m]),p<1&&(n[1]=[s+p*h,l+p*m])),!0}}}}}function OAe(n,t,e,i,r){var o=n[1];if(o)return!0;var _,M,a=n[0],s=n.left,l=n.right,c=s[0],d=s[1],u=l[0],p=l[1],h=(c+u)/2;if(p===d){if(h<t||h>=i)return;if(c>u){if(a){if(a[1]>=r)return}else a=[h,e];o=[h,r]}else{if(a){if(a[1]<e)return}else a=[h,r];o=[h,e]}}else if(M=(d+p)/2-(_=(c-u)/(p-d))*h,_<-1||_>1)if(c>u){if(a){if(a[1]>=r)return}else a=[(e-M)/_,e];o=[(r-M)/_,r]}else{if(a){if(a[1]<e)return}else a=[(r-M)/_,r];o=[(e-M)/_,e]}else if(d<p){if(a){if(a[0]>=i)return}else a=[t,_*t+M];o=[i,_*i+M]}else{if(a){if(a[0]<t)return}else a=[i,_*i+M];o=[t,_*t+M]}return n[0]=a,n[1]=o,!0}function FAe(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function XL(n,t){return t[+(t.left!==n.site)]}function NAe(n,t){return t[+(t.left===n.site)]}var ND,h$=[];function LAe(){f0(this),this.x=this.y=this.arc=this.site=this.cy=null}function lm(n){var t=n.P,e=n.N;if(t&&e){var i=t.site,r=n.site,o=e.site;if(i!==o){var a=r[0],s=r[1],l=i[0]-a,c=i[1]-s,d=o[0]-a,u=o[1]-s,p=2*(l*u-c*d);if(!(p>=-m$)){var h=l*l+c*c,m=d*d+u*u,_=(u*h-c*m)/p,M=(l*m-d*h)/p,y=h$.pop()||new LAe;y.arc=n,y.site=r,y.x=_+a,y.y=(y.cy=M+s)+Math.sqrt(_*_+M*M),n.circle=y;for(var x=null,R=b0._;R;)if(y.y<R.y||y.y===R.y&&y.x<=R.x){if(!R.L){x=R.P;break}R=R.L}else{if(!R.R){x=R;break}R=R.R}b0.insert(x,y),x||(ND=y)}}}}function cm(n){var t=n.circle;t&&(t.P||(ND=t.N),b0.remove(t),h$.push(t),f0(t),n.circle=null)}var g$=[];function BAe(){f0(this),this.edge=this.site=this.circle=null}function f$(n){var t=g$.pop()||new BAe;return t.site=n,t}function YL(n){cm(n),dm.remove(n),g$.push(n),f0(n)}function _$(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],o=n.P,a=n.N,s=[n];YL(n);for(var l=o;l.circle&&Math.abs(e-l.circle.x)<Ji&&Math.abs(i-l.circle.cy)<Ji;)o=l.P,s.unshift(l),YL(l),l=o;s.unshift(l),cm(l);for(var c=a;c.circle&&Math.abs(e-c.circle.x)<Ji&&Math.abs(i-c.circle.cy)<Ji;)a=c.N,s.push(c),YL(c),c=a;s.push(c),cm(c);var u,d=s.length;for(u=1;u<d;++u)tx((c=s[u]).edge,(l=s[u-1]).site,c.site,r);(c=s[d-1]).edge=g0((l=s[0]).site,c.site,null,r),lm(l),lm(c)}function b$(n){for(var i,r,o,a,t=n[0],e=n[1],s=dm._;s;)if((o=v$(s,e)-t)>Ji)s=s.L;else{if(!((a=t-VAe(s,e))>Ji)){o>-Ji?(i=s.P,r=s):a>-Ji?(i=s,r=s.N):i=r=s;break}if(!s.R){i=s;break}s=s.R}!function(n){xa[n.index]={site:n,halfedges:[]}}(n);var l=f$(n);if(dm.insert(i,l),i||r){if(i===r)return cm(i),r=f$(i.site),dm.insert(l,r),l.edge=r.edge=g0(i.site,l.site),lm(i),void lm(r);if(!r)return void(l.edge=g0(i.site,l.site));cm(i),cm(r);var c=i.site,d=c[0],u=c[1],p=n[0]-d,h=n[1]-u,m=r.site,_=m[0]-d,M=m[1]-u,y=2*(p*M-h*_),x=p*p+h*h,R=_*_+M*M,I=[(M*x-h*R)/y+d,(p*R-_*x)/y+u];tx(r.edge,c,m,I),l.edge=g0(c,n,null,I),r.edge=g0(n,m,null,I),lm(i),lm(r)}}function v$(n,t){var e=n.site,i=e[0],r=e[1],o=r-t;if(!o)return i;var a=n.P;if(!a)return-1/0;var s=(e=a.site)[0],l=e[1],c=l-t;if(!c)return s;var d=s-i,u=1/o-1/c,p=d/c;return u?(-p+Math.sqrt(p*p-2*u*(d*d/(-2*c)-l+c/2+r-o/2)))/u+i:(i+s)/2}function VAe(n,t){var e=n.N;if(e)return v$(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var dm,xa,b0,ko,Ji=1e-6,m$=1e-12;function HAe(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function zAe(n,t){return t[1]-n[1]||t[0]-n[0]}function LD(n,t){var i,r,o,e=n.sort(zAe).pop();for(ko=[],xa=new Array(n.length),dm=new qL,b0=new qL;;)if(o=ND,e&&(!o||e[1]<o.y||e[1]===o.y&&e[0]<o.x))(e[0]!==i||e[1]!==r)&&(b$(e),i=e[0],r=e[1]),e=n.pop();else{if(!o)break;_$(o.arc)}if(function(){for(var e,i,r,o,n=0,t=xa.length;n<t;++n)if((e=xa[n])&&(o=(i=e.halfedges).length)){var a=new Array(o),s=new Array(o);for(r=0;r<o;++r)a[r]=r,s[r]=FAe(e,ko[i[r]]);for(a.sort(function(l,c){return s[c]-s[l]}),r=0;r<o;++r)s[r]=i[a[r]];for(r=0;r<o;++r)i[r]=s[r]}}(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];(function(n,t,e,i){for(var o,r=ko.length;r--;)OAe(o=ko[r],n,t,e,i)&&kAe(o,n,t,e,i)&&(Math.abs(o[0][0]-o[1][0])>Ji||Math.abs(o[0][1]-o[1][1])>Ji)||delete ko[r]})(a,s,l,c),function(n,t,e,i){var o,a,s,l,c,d,u,p,h,m,_,M,r=xa.length,y=!0;for(o=0;o<r;++o)if(a=xa[o]){for(s=a.site,l=(c=a.halfedges).length;l--;)ko[c[l]]||c.splice(l,1);for(l=0,d=c.length;l<d;)_=(m=NAe(a,ko[c[l]]))[0],M=m[1],p=(u=XL(a,ko[c[++l%d]]))[0],h=u[1],(Math.abs(_-p)>Ji||Math.abs(M-h)>Ji)&&(c.splice(l,0,ko.push(_0(s,m,Math.abs(_-n)<Ji&&i-M>Ji?[n,Math.abs(p-n)<Ji?h:i]:Math.abs(M-i)<Ji&&e-_>Ji?[Math.abs(h-i)<Ji?p:e,i]:Math.abs(_-e)<Ji&&M-t>Ji?[e,Math.abs(p-e)<Ji?h:t]:Math.abs(M-t)<Ji&&_-n>Ji?[Math.abs(h-t)<Ji?p:n,t]:null))-1),++d);d&&(y=!1)}if(y){var x,R,I,B=1/0;for(o=0,y=null;o<r;++o)(a=xa[o])&&(I=(x=(s=a.site)[0]-n)*x+(R=s[1]-t)*R)<B&&(B=I,y=a);if(y){var ee=[n,t],Q=[n,i],we=[e,i],Qe=[e,t];y.halfedges.push(ko.push(_0(s=y.site,ee,Q))-1,ko.push(_0(s,Q,we))-1,ko.push(_0(s,we,Qe))-1,ko.push(_0(s,Qe,ee))-1)}}for(o=0;o<r;++o)(a=xa[o])&&(a.halfedges.length||delete xa[o])}(a,s,l,c)}this.edges=ko,this.cells=xa,dm=b0=ko=xa=null}function um(n,t,e){this.k=n,this.x=t,this.y=e}LD.prototype={constructor:LD,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return XL(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(s=(o=e.halfedges).length)for(var o,s,l,r=e.site,a=-1,c=t[o[s-1]],d=c.left===r?c.right:c.left;++a<s;)l=d,d=(c=t[o[a]]).left===r?c.right:c.left,l&&d&&i<l.index&&i<d.index&&HAe(r,l,d)<0&&n.push([r.data,l.data,d.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var r,s,i=this,o=i._found||0,a=i.cells.length;!(s=i.cells[o]);)if(++o>=a)return null;var l=n-s.site[0],c=t-s.site[1],d=l*l+c*c;do{s=i.cells[r=o],o=null,s.halfedges.forEach(function(u){var p=i.edges[u],h=p.left;if(h!==s.site&&h||(h=p.right)){var m=n-h[0],_=t-h[1],M=m*m+_*_;M<d&&(d=M,o=h.index)}})}while(null!==o);return i._found=r,null==e||d<=e*e?s.site:null}},um.prototype={constructor:um,scale:function(n){return 1===n?this:new um(this.k*n,this.x,this.y)},translate:function(n,t){return 0===n&0===t?this:new um(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}},new um(1,0,0);var i3=1e4,r3=.001,M$=Yr(".2~e"),UAe=Yr(".4~r"),y$=Yr(",~");function x$(n){if(0===n)return"0";let t=Math.abs(n);return t>=i3||t<r3?M$(n):UAe(n)}var dp={formatTick:x$,formatShort:x$,formatReadable(n){let t=Math.abs(n);return t>=i3||t<r3?M$(n):y$(n)},formatLong:y$},jAe=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});function BD(n){return jAe.format(n)}var y0={formatTick:BD,formatShort:BD,formatReadable:BD,formatLong:BD},GAe=Yr("0.3~s"),WAe=Yr(",.3~f");function VD(n){let t=Math.abs(n);return t>=i3||t<r3?GAe(n):WAe(n)}var o3={formatTick:VD,formatShort:VD,formatReadable:VD,formatLong:VD},$L=1e3,e3=60*$L,t3=60*e3,n3=24*t3,C$=365*n3,v0=Yr(".4~");function HD(n){if(0===n)return"0";let t=Math.sign(n)>0?"":"-",e=Math.abs(n);return t+=e<$L?`${v0(e)} ms`:e<e3?`${v0(e/$L)} sec`:e<t3?`${v0(e/e3)} min`:e<n3?`${v0(e/t3)} hr`:e<C$?`${v0(e/n3)} day`:`${v0(e/C$)} yr`,t}var JL,x0={formatTick:HD,formatShort:HD,formatReadable:HD,formatLong:HD},qAe=sm().tickFormat(),w$={formatTick:n=>qAe(new Date(n)),formatShort:n=>new Date(n).toLocaleString(JL,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:n=>new Date(n).toLocaleString(JL,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"}),formatLong:n=>new Date(n).toLocaleString(JL,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};function Ul(n){switch(n){case tr.LINEAR:return new nx;case tr.LOG10:return new a3;case tr.TIME:return new ix;default:throw new RangeError(`ScaleType ${n} not supported.`)}}var nx=class{constructor(){this.defaultFormatter=dp}transform(t,e,i){let[r,o]=t,a=o-r,[s,l]=e;return 0===a?s:(l-s)/a*(i-r)+s}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return 0===e?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=zl(),o=.05*(i-e+Number.EPSILON),[a,s]=r.domain([e-o,i+o]).nice().domain();return[a,s]}ticks(t,e){return zl().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},a3=class{constructor(){this.defaultFormatter=dp}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,o]=t,[a,s]=e,l=this.transform(r),d=this.transform(o)-l,u=s-a;return i=this.transform(i),u/(d+Number.EPSILON)*(i-l)+a}reverse(t,e,i){let[r,o]=t,[a,s]=e,l=this.transform(r),d=this.transform(o)-l;return this.untransform(d/(s-a+Number.EPSILON)*(i-a)+l)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),o=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*r),2*o]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],o=Gy().domain([i,r]).ticks(e);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},ix=class{constructor(){this.scale=sm(),this.defaultFormatter=w$}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}},s3=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{s3=!1});let t=n.getContext("webgl2");s3=Boolean(t)}var jl_convertRectToExtent=function(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}},jl_isWebGl2Supported=function(){return s3},jl_isWebGl2OffscreenCanvasSupported=function(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)},jl_arePolylinesEqual=function(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0},C0=class{constructor(){this.xScale=Ul(tr.LINEAR),this.yScale=Ul(tr.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=jl_convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};function zD(n,t,e,i){let{color:r,visible:o,opacity:a}=i,s=n;return s||o?(s=s??t(),s=e(s),s.style.display=o?"":"none",s.style.stroke=r,s.style.opacity=String(a??1),s):null}var sV="137",$Ae=0,S$=1,eRe=2,ste=1,tRe=2,mx=3,yx=0,bo=1,Z0=2,vp=0,gx=1,E$=2,T$=3,D$=4,nRe=5,U0=100,iRe=101,rRe=102,I$=103,A$=104,oRe=200,aRe=201,sRe=202,lRe=203,cte=204,dte=205,cRe=206,dRe=207,uRe=208,pRe=209,hRe=210,mRe=0,fRe=1,gRe=2,X3=3,_Re=4,bRe=5,vRe=6,yRe=7,KI=0,xRe=1,CRe=2,yp=0,MRe=1,wRe=2,SRe=3,ERe=4,TRe=5,Wx=301,qx=302,Y3=303,Q3=304,JI=306,lV=307,Z3=1e3,Es=1001,K3=1002,vo=1003,R$=1004,P$=1005,ia=1006,DRe=1007,$I=1008,xp=1009,IRe=1010,ARe=1011,xx=1012,RRe=1013,xI=1014,gm=1015,q0=1016,PRe=1017,kRe=1018,X0=1020,ORe=1021,Ca=1023,FRe=1024,NRe=1025,bm=1026,K0=1027,LRe=1028,BRe=1029,VRe=1030,HRe=1031,zRe=1033,l3=33776,c3=33777,d3=33778,u3=33779,k$=35840,O$=35841,F$=35842,N$=35843,URe=36196,L$=37492,B$=37496,V$=37808,H$=37809,z$=37810,U$=37811,j$=37812,G$=37813,W$=37814,q$=37815,X$=37816,Y$=37817,Q$=37818,Z$=37819,K$=37820,J$=37821,$$=36492,j0=2400,G0=2401,wp=3e3,Dr=3001,YRe=3201,c_=0,QRe=1,Cx=35044,SI=35048,eee="300 es",J3=1035,zd=class{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});let i=this._listeners;void 0===i[t]&&(i[t]=[]),-1===i[t].indexOf(e)&&i[t].push(e)}hasEventListener(t,e){if(void 0===this._listeners)return!1;let i=this._listeners;return void 0!==i[t]&&-1!==i[t].indexOf(e)}removeEventListener(t,e){if(void 0===this._listeners)return;let r=this._listeners[t];if(void 0!==r){let o=r.indexOf(e);-1!==o&&r.splice(o,1)}}dispatchEvent(t){if(void 0===this._listeners)return;let i=this._listeners[t.type];if(void 0!==i){t.target=this;let r=i.slice(0);for(let o=0,a=r.length;o<a;o++)r[o].call(this,t);t.target=null}}},jo=[];for(let n=0;n<256;n++)jo[n]=(n<16?"0":"")+n.toString(16);var m3=Math.PI/180,$3=180/Math.PI;function Yl(){let n=4294967295*Math.random()|0,t=4294967295*Math.random()|0,e=4294967295*Math.random()|0,i=4294967295*Math.random()|0;return(jo[255&n]+jo[n>>8&255]+jo[n>>16&255]+jo[n>>24&255]+"-"+jo[255&t]+jo[t>>8&255]+"-"+jo[t>>16&15|64]+jo[t>>24&255]+"-"+jo[63&e|128]+jo[e>>8&255]+"-"+jo[e>>16&255]+jo[e>>24&255]+jo[255&i]+jo[i>>8&255]+jo[i>>16&255]+jo[i>>24&255]).toUpperCase()}function es(n,t,e){return Math.max(t,Math.min(e,n))}function f3(n,t,e){return(1-e)*n+e*t}function tee(n){return 0==(n&n-1)&&0!==n}function JRe(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var $e=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),o=this.x-t.x,a=this.y-t.y;return this.x=o*i-a*r+t.x,this.y=o*r+a*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};$e.prototype.isVector2=!0;var yo=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,a,s,l,c){let d=this.elements;return d[0]=t,d[1]=r,d[2]=s,d[3]=e,d[4]=o,d[5]=l,d[6]=i,d[7]=a,d[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,a=i[0],s=i[3],l=i[6],c=i[1],d=i[4],u=i[7],p=i[2],h=i[5],m=i[8],_=r[0],M=r[3],y=r[6],x=r[1],R=r[4],I=r[7],B=r[2],ee=r[5],Q=r[8];return o[0]=a*_+s*x+l*B,o[3]=a*M+s*R+l*ee,o[6]=a*y+s*I+l*Q,o[1]=c*_+d*x+u*B,o[4]=c*M+d*R+u*ee,o[7]=c*y+d*I+u*Q,o[2]=p*_+h*x+m*B,o[5]=p*M+h*R+m*ee,o[8]=p*y+h*I+m*Q,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8];return e*a*d-e*s*c-i*o*d+i*s*l+r*o*c-r*a*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8],u=d*a-s*c,p=s*l-d*o,h=c*o-a*l,m=e*u+i*p+r*h;if(0===m)return this.set(0,0,0,0,0,0,0,0,0);let _=1/m;return t[0]=u*_,t[1]=(r*c-d*i)*_,t[2]=(s*i-r*a)*_,t[3]=p*_,t[4]=(d*e-r*l)*_,t[5]=(r*o-s*e)*_,t[6]=h*_,t[7]=(i*l-c*e)*_,t[8]=(a*e-i*o)*_,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(i*l,i*c,-i*(l*a+c*s)+a+t,-r*c,r*l,-r*(-c*a+l*s)+s+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,o=r[0],a=r[3],s=r[6],l=r[1],c=r[4],d=r[7];return r[0]=e*o+i*l,r[3]=e*a+i*c,r[6]=e*s+i*d,r[1]=-i*o+e*l,r[4]=-i*a+e*c,r[7]=-i*s+e*d,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return(new this.constructor).fromArray(this.elements)}};function hte(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function Mx(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}yo.prototype.isMatrix3=!0;var nee={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},Gl={h:0,s:0,l:0},UD={h:0,s:0,l:0};function g3(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+6*(t-n)*e:e<.5?t:e<2/3?n+6*(t-n)*(2/3-e):n}function Y0(n){return n<.04045?.0773993808*n:Math.pow(.9478672986*n+.0521327014,2.4)}function _3(n){return n<.0031308?12.92*n:1.055*Math.pow(n,.41666)-.055}var sn=(()=>{class n{constructor(e,i,r){return void 0===i&&void 0===r?this.set(e):this.setRGB(e,i,r)}set(e){return e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e),this}setScalar(e){return this.r=e,this.g=e,this.b=e,this}setHex(e){return e=Math.floor(e),this.r=(e>>16&255)/255,this.g=(e>>8&255)/255,this.b=(255&e)/255,this}setRGB(e,i,r){return this.r=e,this.g=i,this.b=r,this}setHSL(e,i,r){if(e=function(n,t){return(n%1+1)%1}(e),i=es(i,0,1),r=es(r,0,1),0===i)this.r=this.g=this.b=r;else{let o=r<=.5?r*(1+i):r+i-r*i,a=2*r-o;this.r=g3(a,o,e+1/3),this.g=g3(a,o,e),this.b=g3(a,o,e-1/3)}return this}setStyle(e){function i(o){void 0!==o&&parseFloat(o)<1&&console.warn("THREE.Color: Alpha component of "+e+" will be ignored.")}let r;if(r=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(e)){let o,s=r[2];switch(r[1]){case"rgb":case"rgba":if(o=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s))return this.r=Math.min(255,parseInt(o[1],10))/255,this.g=Math.min(255,parseInt(o[2],10))/255,this.b=Math.min(255,parseInt(o[3],10))/255,i(o[4]),this;if(o=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s))return this.r=Math.min(100,parseInt(o[1],10))/100,this.g=Math.min(100,parseInt(o[2],10))/100,this.b=Math.min(100,parseInt(o[3],10))/100,i(o[4]),this;break;case"hsl":case"hsla":if(o=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(s)){let l=parseFloat(o[1])/360,c=parseInt(o[2],10)/100,d=parseInt(o[3],10)/100;return i(o[4]),this.setHSL(l,c,d)}}}else if(r=/^\#([A-Fa-f\d]+)$/.exec(e)){let o=r[1],a=o.length;if(3===a)return this.r=parseInt(o.charAt(0)+o.charAt(0),16)/255,this.g=parseInt(o.charAt(1)+o.charAt(1),16)/255,this.b=parseInt(o.charAt(2)+o.charAt(2),16)/255,this;if(6===a)return this.r=parseInt(o.charAt(0)+o.charAt(1),16)/255,this.g=parseInt(o.charAt(2)+o.charAt(3),16)/255,this.b=parseInt(o.charAt(4)+o.charAt(5),16)/255,this}return e&&e.length>0?this.setColorName(e):this}setColorName(e){let i=nee[e.toLowerCase()];return void 0!==i?this.setHex(i):console.warn("THREE.Color: Unknown color "+e),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(e){return this.r=e.r,this.g=e.g,this.b=e.b,this}copySRGBToLinear(e){return this.r=Y0(e.r),this.g=Y0(e.g),this.b=Y0(e.b),this}copyLinearToSRGB(e){return this.r=_3(e.r),this.g=_3(e.g),this.b=_3(e.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(e){let l,c,i=this.r,r=this.g,o=this.b,a=Math.max(i,r,o),s=Math.min(i,r,o),d=(s+a)/2;if(s===a)l=0,c=0;else{let u=a-s;switch(c=d<=.5?u/(a+s):u/(2-a-s),a){case i:l=(r-o)/u+(r<o?6:0);break;case r:l=(o-i)/u+2;break;case o:l=(i-r)/u+4}l/=6}return e.h=l,e.s=c,e.l=d,e}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(e,i,r){return this.getHSL(Gl),Gl.h+=e,Gl.s+=i,Gl.l+=r,this.setHSL(Gl.h,Gl.s,Gl.l),this}add(e){return this.r+=e.r,this.g+=e.g,this.b+=e.b,this}addColors(e,i){return this.r=e.r+i.r,this.g=e.g+i.g,this.b=e.b+i.b,this}addScalar(e){return this.r+=e,this.g+=e,this.b+=e,this}sub(e){return this.r=Math.max(0,this.r-e.r),this.g=Math.max(0,this.g-e.g),this.b=Math.max(0,this.b-e.b),this}multiply(e){return this.r*=e.r,this.g*=e.g,this.b*=e.b,this}multiplyScalar(e){return this.r*=e,this.g*=e,this.b*=e,this}lerp(e,i){return this.r+=(e.r-this.r)*i,this.g+=(e.g-this.g)*i,this.b+=(e.b-this.b)*i,this}lerpColors(e,i,r){return this.r=e.r+(i.r-e.r)*r,this.g=e.g+(i.g-e.g)*r,this.b=e.b+(i.b-e.b)*r,this}lerpHSL(e,i){this.getHSL(Gl),e.getHSL(UD);let r=f3(Gl.h,UD.h,i),o=f3(Gl.s,UD.s,i),a=f3(Gl.l,UD.l,i);return this.setHSL(r,o,a),this}equals(e){return e.r===this.r&&e.g===this.g&&e.b===this.b}fromArray(e,i=0){return this.r=e[i],this.g=e[i+1],this.b=e[i+2],this}toArray(e=[],i=0){return e[i]=this.r,e[i+1]=this.g,e[i+2]=this.b,e}fromBufferAttribute(e,i){return this.r=e.getX(i),this.g=e.getY(i),this.b=e.getZ(i),!0===e.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}return n.NAMES=nee,n})();sn.prototype.isColor=!0,sn.prototype.r=1,sn.prototype.g=1,sn.prototype.b=1;var M0,Ud=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement>"u")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===M0&&(M0=Mx("canvas")),M0.width=t.width,M0.height=t.height;let i=M0.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=M0}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement<"u"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&t instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&t instanceof ImageBitmap){let e=Mx("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),o=r.data;for(let a=0;a<o.length;a++)o[a]=255*Y0(o[a]/255);return i.putImageData(r,0,0),e}if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e[i]=e instanceof Uint8Array||e instanceof Uint8ClampedArray?Math.floor(255*Y0(e[i]/255)):Y0(e[i]);return{data:e,width:t.width,height:t.height}}return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},$Re=0,lo=class extends zd{constructor(t=lo.DEFAULT_IMAGE,e=lo.DEFAULT_MAPPING,i=Es,r=Es,o=ia,a=$I,s=Ca,l=xp,c=1,d=wp){super(),Object.defineProperty(this,"id",{value:$Re++}),this.uuid=Yl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new $e(0,0),this.repeat=new $e(1,1),this.center=new $e(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new yo,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=d,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){let r=this.image;if(void 0===r.uuid&&(r.uuid=Yl()),!e&&void 0===t.images[r.uuid]){let o;if(Array.isArray(r)){o=[];for(let a=0,s=r.length;a<s;a++)o.push(b3(r[a].isDataTexture?r[a].image:r[a]))}else o=b3(r);t.images[r.uuid]={uuid:r.uuid,url:o}}i.image=r.uuid}return"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(300!==this.mapping)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case Z3:t.x=t.x-Math.floor(t.x);break;case Es:t.x=t.x<0?0:1;break;case K3:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case Z3:t.y=t.y-Math.floor(t.y);break;case Es:t.y=t.y<0?0:1;break;case K3:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&this.version++}};function b3(n){return typeof HTMLImageElement<"u"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&n instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&n instanceof ImageBitmap?Ud.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}lo.DEFAULT_IMAGE=void 0,lo.DEFAULT_MAPPING=300,lo.prototype.isTexture=!0;var Qi=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=this.w,a=t.elements;return this.x=a[0]*e+a[4]*i+a[8]*r+a[12]*o,this.y=a[1]*e+a[5]*i+a[9]*r+a[13]*o,this.z=a[2]*e+a[6]*i+a[10]*r+a[14]*o,this.w=a[3]*e+a[7]*i+a[11]*r+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,o,l=t.elements,c=l[0],d=l[4],u=l[8],p=l[1],h=l[5],m=l[9],_=l[2],M=l[6],y=l[10];if(Math.abs(d-p)<.01&&Math.abs(u-_)<.01&&Math.abs(m-M)<.01){if(Math.abs(d+p)<.1&&Math.abs(u+_)<.1&&Math.abs(m+M)<.1&&Math.abs(c+h+y-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let R=(c+1)/2,I=(h+1)/2,B=(y+1)/2,ee=(d+p)/4,Q=(u+_)/4,we=(m+M)/4;return R>I&&R>B?R<.01?(i=0,r=.707106781,o=.707106781):(i=Math.sqrt(R),r=ee/i,o=Q/i):I>B?I<.01?(i=.707106781,r=0,o=.707106781):(r=Math.sqrt(I),i=ee/r,o=we/r):B<.01?(i=.707106781,r=.707106781,o=0):(o=Math.sqrt(B),i=Q/o,r=we/o),this.set(i,r,o,e),this}let x=Math.sqrt((M-m)*(M-m)+(u-_)*(u-_)+(p-d)*(p-d));return Math.abs(x)<.001&&(x=1),this.x=(M-m)/x,this.y=(u-_)/x,this.z=(p-d)/x,this.w=Math.acos((c+h+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Qi.prototype.isVector4=!0;var ts=class extends zd{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Qi(0,0,t,e),this.scissorTest=!1,this.viewport=new Qi(0,0,t,e),this.texture=new lo(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=void 0!==i.generateMipmaps&&i.generateMipmaps,this.texture.internalFormat=void 0!==i.internalFormat?i.internalFormat:null,this.texture.minFilter=void 0!==i.minFilter?i.minFilter:ia,this.depthBuffer=void 0===i.depthBuffer||i.depthBuffer,this.stencilBuffer=void 0!==i.stencilBuffer&&i.stencilBuffer,this.depthTexture=void 0!==i.depthTexture?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};ts.prototype.isWebGLRenderTarget=!0,class extends ts{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let o=0;o<i;o++)this.texture[o]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,o=this.texture.length;r<o;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}}.prototype.isWebGLMultipleRenderTargets=!0;var wx=class extends ts{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=void 0===i.ignoreDepth||i.ignoreDepth,this.useRenderToTexture=void 0!==i.useRenderToTexture&&i.useRenderToTexture,this.useRenderbuffer=!1===this.useRenderToTexture}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};wx.prototype.isWebGLMultisampleRenderTarget=!0;var oa=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,o,a,s){let l=i[r+0],c=i[r+1],d=i[r+2],u=i[r+3],p=o[a+0],h=o[a+1],m=o[a+2],_=o[a+3];if(0===s)return t[e+0]=l,t[e+1]=c,t[e+2]=d,void(t[e+3]=u);if(1===s)return t[e+0]=p,t[e+1]=h,t[e+2]=m,void(t[e+3]=_);if(u!==_||l!==p||c!==h||d!==m){let M=1-s,y=l*p+c*h+d*m+u*_,x=y>=0?1:-1,R=1-y*y;if(R>Number.EPSILON){let B=Math.sqrt(R),ee=Math.atan2(B,y*x);M=Math.sin(M*ee)/B,s=Math.sin(s*ee)/B}let I=s*x;if(l=l*M+p*I,c=c*M+h*I,d=d*M+m*I,u=u*M+_*I,M===1-s){let B=1/Math.sqrt(l*l+c*c+d*d+u*u);l*=B,c*=B,d*=B,u*=B}}t[e]=l,t[e+1]=c,t[e+2]=d,t[e+3]=u}static multiplyQuaternionsFlat(t,e,i,r,o,a){let s=i[r],l=i[r+1],c=i[r+2],d=i[r+3],u=o[a],p=o[a+1],h=o[a+2],m=o[a+3];return t[e]=s*m+d*u+l*h-c*p,t[e+1]=l*m+d*p+c*u-s*h,t[e+2]=c*m+d*h+s*p-l*u,t[e+3]=d*m-s*u-l*p-c*h,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(i/2),d=s(r/2),u=s(o/2),p=l(i/2),h=l(r/2),m=l(o/2);switch(a){case"XYZ":this._x=p*d*u+c*h*m,this._y=c*h*u-p*d*m,this._z=c*d*m+p*h*u,this._w=c*d*u-p*h*m;break;case"YXZ":this._x=p*d*u+c*h*m,this._y=c*h*u-p*d*m,this._z=c*d*m-p*h*u,this._w=c*d*u+p*h*m;break;case"ZXY":this._x=p*d*u-c*h*m,this._y=c*h*u+p*d*m,this._z=c*d*m+p*h*u,this._w=c*d*u-p*h*m;break;case"ZYX":this._x=p*d*u-c*h*m,this._y=c*h*u+p*d*m,this._z=c*d*m-p*h*u,this._w=c*d*u+p*h*m;break;case"YZX":this._x=p*d*u+c*h*m,this._y=c*h*u+p*d*m,this._z=c*d*m-p*h*u,this._w=c*d*u-p*h*m;break;case"XZY":this._x=p*d*u-c*h*m,this._y=c*h*u-p*d*m,this._z=c*d*m+p*h*u,this._w=c*d*u+p*h*m;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],o=e[8],a=e[1],s=e[5],l=e[9],c=e[2],d=e[6],u=e[10],p=i+s+u;if(p>0){let h=.5/Math.sqrt(p+1);this._w=.25/h,this._x=(d-l)*h,this._y=(o-c)*h,this._z=(a-r)*h}else if(i>s&&i>u){let h=2*Math.sqrt(1+i-s-u);this._w=(d-l)/h,this._x=.25*h,this._y=(r+a)/h,this._z=(o+c)/h}else if(s>u){let h=2*Math.sqrt(1+s-i-u);this._w=(o-c)/h,this._x=(r+a)/h,this._y=.25*h,this._z=(l+d)/h}else{let h=2*Math.sqrt(1+u-i-s);this._w=(a-r)/h,this._x=(o+c)/h,this._y=(l+d)/h,this._z=.25*h}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(es(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(0===i)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,o=t._z,a=t._w,s=e._x,l=e._y,c=e._z,d=e._w;return this._x=i*d+a*s+r*c-o*l,this._y=r*d+a*l+o*s-i*c,this._z=o*d+a*c+i*l-r*s,this._w=a*d-i*s-r*l-o*c,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);let i=this._x,r=this._y,o=this._z,a=this._w,s=a*t._w+i*t._x+r*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=i,this._y=r,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let h=1-e;return this._w=h*a+e*this._w,this._x=h*i+e*this._x,this._y=h*r+e*this._y,this._z=h*o+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),d=Math.atan2(c,s),u=Math.sin((1-e)*d)/c,p=Math.sin(e*d)/c;return this._w=a*u+this._w*p,this._x=i*u+this._x*p,this._y=r*u+this._y*p,this._z=o*u+this._z*p,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(o),i*Math.cos(o),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};oa.prototype.isQuaternion=!0;var K=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return void 0===i&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(iee.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(iee.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[3]*i+o[6]*r,this.y=o[1]*e+o[4]*i+o[7]*r,this.z=o[2]*e+o[5]*i+o[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=t.elements,a=1/(o[3]*e+o[7]*i+o[11]*r+o[15]);return this.x=(o[0]*e+o[4]*i+o[8]*r+o[12])*a,this.y=(o[1]*e+o[5]*i+o[9]*r+o[13])*a,this.z=(o[2]*e+o[6]*i+o[10]*r+o[14])*a,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*e+a*r-s*i,d=l*i+s*e-o*r,u=l*r+o*i-a*e,p=-o*e-a*i-s*r;return this.x=c*l+p*-o+d*-s-u*-a,this.y=d*l+p*-a+u*-o-c*-s,this.z=u*l+p*-s+c*-a-d*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r,this.y=o[1]*e+o[5]*i+o[9]*r,this.z=o[2]*e+o[6]*i+o[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,o=t.z,a=e.x,s=e.y,l=e.z;return this.x=r*l-o*s,this.y=o*a-i*l,this.z=i*s-r*a,this}projectOnVector(t){let e=t.lengthSq();if(0===e)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return v3.copy(this).projectOnVector(t),this.sub(v3)}reflect(t){return this.sub(v3.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(es(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=2*(Math.random()-.5),e=Math.random()*Math.PI*2,i=Math.sqrt(1-t**2);return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};K.prototype.isVector3=!0;var v3=new K,iee=new oa,Ts=class{constructor(t=new K(1/0,1/0,1/0),e=new K(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let d=t[l],u=t[l+1],p=t[l+2];d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>a&&(a=u),p>s&&(s=p)}return this.min.set(e,i,r),this.max.set(o,a,s),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let d=t.getX(l),u=t.getY(l),p=t.getZ(l);d<e&&(e=d),u<i&&(i=u),p<r&&(r=p),d>o&&(o=d),u>a&&(a=u),p>s&&(s=p)}return this.min.set(e,i,r),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=pm.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(void 0!==i)if(e&&null!=i.attributes&&void 0!==i.attributes.position){let o=i.attributes.position;for(let a=0,s=o.count;a<s;a++)pm.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(pm)}else null===i.boundingBox&&i.computeBoundingBox(),y3.copy(i.boundingBox),y3.applyMatrix4(t.matrixWorld),this.union(y3);let r=t.children;for(let o=0,a=r.length;o<a;o++)this.expandByObject(r[o],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,pm),pm.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ox),jD.subVectors(this.max,ox),w0.subVectors(t.a,ox),S0.subVectors(t.b,ox),E0.subVectors(t.c,ox),up.subVectors(S0,w0),pp.subVectors(E0,S0),hm.subVectors(w0,E0);let e=[0,-up.z,up.y,0,-pp.z,pp.y,0,-hm.z,hm.y,up.z,0,-up.x,pp.z,0,-pp.x,hm.z,0,-hm.x,-up.y,up.x,0,-pp.y,pp.x,0,-hm.y,hm.x,0];return!(!x3(e,w0,S0,E0,jD)||(e=[1,0,0,0,1,0,0,0,1],!x3(e,w0,S0,E0,jD)))&&(GD.crossVectors(up,pp),e=[GD.x,GD.y,GD.z],x3(e,w0,S0,E0,jD))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return pm.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=.5*this.getSize(pm).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(Fd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Fd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Fd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Fd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Fd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Fd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Fd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Fd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Fd)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Ts.prototype.isBox3=!0;var Fd=[new K,new K,new K,new K,new K,new K,new K,new K],pm=new K,y3=new Ts,w0=new K,S0=new K,E0=new K,up=new K,pp=new K,hm=new K,ox=new K,jD=new K,GD=new K,mm=new K;function x3(n,t,e,i,r){for(let o=0,a=n.length-3;o<=a;o+=3){mm.fromArray(n,o);let s=r.x*Math.abs(mm.x)+r.y*Math.abs(mm.y)+r.z*Math.abs(mm.z),l=t.dot(mm),c=e.dot(mm),d=i.dot(mm);if(Math.max(-Math.max(l,c,d),Math.min(l,c,d))>s)return!1}return!0}var ePe=new Ts,ree=new K,WD=new K,C3=new K,Sp=class{constructor(t=new K,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;void 0!==e?i.copy(e):ePe.setFromPoints(t).getCenter(i);let r=0;for(let o=0,a=t.length;o<a;o++)r=Math.max(r,i.distanceToSquared(t[o]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){C3.subVectors(t,this.center);let e=C3.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=.5*(i-this.radius);this.center.add(C3.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return!0===this.center.equals(t.center)?WD.set(0,0,1).multiplyScalar(t.radius):WD.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(ree.copy(t.center).add(WD)),this.expandByPoint(ree.copy(t.center).sub(WD)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}},Nd=new K,M3=new K,qD=new K,hp=new K,w3=new K,XD=new K,S3=new K,Ep=class{constructor(t=new K,e=new K(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Nd)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Nd.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Nd.copy(this.direction).multiplyScalar(e).add(this.origin),Nd.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){M3.copy(t).add(e).multiplyScalar(.5),qD.copy(e).sub(t).normalize(),hp.copy(this.origin).sub(M3);let u,p,h,m,o=.5*t.distanceTo(e),a=-this.direction.dot(qD),s=hp.dot(this.direction),l=-hp.dot(qD),c=hp.lengthSq(),d=Math.abs(1-a*a);if(d>0)if(u=a*l-s,p=a*s-l,m=o*d,u>=0)if(p>=-m)if(p<=m){let _=1/d;u*=_,p*=_,h=u*(u+a*p+2*s)+p*(a*u+p+2*l)+c}else p=o,u=Math.max(0,-(a*p+s)),h=-u*u+p*(p+2*l)+c;else p=-o,u=Math.max(0,-(a*p+s)),h=-u*u+p*(p+2*l)+c;else p<=-m?(u=Math.max(0,-(-a*o+s)),p=u>0?-o:Math.min(Math.max(-o,-l),o),h=-u*u+p*(p+2*l)+c):p<=m?(u=0,p=Math.min(Math.max(-o,-l),o),h=p*(p+2*l)+c):(u=Math.max(0,-(a*o+s)),p=u>0?o:Math.min(Math.max(-o,-l),o),h=-u*u+p*(p+2*l)+c);else p=a>0?-o:o,u=Math.max(0,-(a*p+s)),h=-u*u+p*(p+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(u).add(this.origin),r&&r.copy(qD).multiplyScalar(p).add(M3),h}intersectSphere(t,e){Nd.subVectors(t.center,this.origin);let i=Nd.dot(this.direction),r=Nd.dot(Nd)-i*i,o=t.radius*t.radius;if(r>o)return null;let a=Math.sqrt(o-r),s=i-a,l=i+a;return s<0&&l<0?null:this.at(s<0?l:s,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return null===i?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return 0===e||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,o,a,s,l,c=1/this.direction.x,d=1/this.direction.y,u=1/this.direction.z,p=this.origin;return c>=0?(i=(t.min.x-p.x)*c,r=(t.max.x-p.x)*c):(i=(t.max.x-p.x)*c,r=(t.min.x-p.x)*c),d>=0?(o=(t.min.y-p.y)*d,a=(t.max.y-p.y)*d):(o=(t.max.y-p.y)*d,a=(t.min.y-p.y)*d),i>a||o>r||((o>i||i!=i)&&(i=o),(a<r||r!=r)&&(r=a),u>=0?(s=(t.min.z-p.z)*u,l=(t.max.z-p.z)*u):(s=(t.max.z-p.z)*u,l=(t.min.z-p.z)*u),i>l||s>r)||((s>i||i!=i)&&(i=s),(l<r||r!=r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return null!==this.intersectBox(t,Nd)}intersectTriangle(t,e,i,r,o){w3.subVectors(e,t),XD.subVectors(i,t),S3.crossVectors(w3,XD);let s,a=this.direction.dot(S3);if(a>0){if(r)return null;s=1}else{if(!(a<0))return null;s=-1,a=-a}hp.subVectors(this.origin,t);let l=s*this.direction.dot(XD.crossVectors(hp,XD));if(l<0)return null;let c=s*this.direction.dot(w3.cross(hp));if(c<0||l+c>a)return null;let d=-s*hp.dot(S3);return d<0?null:this.at(d/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}},vn=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,a,s,l,c,d,u,p,h,m,_,M){let y=this.elements;return y[0]=t,y[4]=e,y[8]=i,y[12]=r,y[1]=o,y[5]=a,y[9]=s,y[13]=l,y[2]=c,y[6]=d,y[10]=u,y[14]=p,y[3]=h,y[7]=m,y[11]=_,y[15]=M,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new vn).fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/T0.setFromMatrixColumn(t,0).length(),o=1/T0.setFromMatrixColumn(t,1).length(),a=1/T0.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*o,e[5]=i[5]*o,e[6]=i[6]*o,e[7]=0,e[8]=i[8]*a,e[9]=i[9]*a,e[10]=i[10]*a,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,o=t.z,a=Math.cos(i),s=Math.sin(i),l=Math.cos(r),c=Math.sin(r),d=Math.cos(o),u=Math.sin(o);if("XYZ"===t.order){let p=a*d,h=a*u,m=s*d,_=s*u;e[0]=l*d,e[4]=-l*u,e[8]=c,e[1]=h+m*c,e[5]=p-_*c,e[9]=-s*l,e[2]=_-p*c,e[6]=m+h*c,e[10]=a*l}else if("YXZ"===t.order){let p=l*d,h=l*u,m=c*d,_=c*u;e[0]=p+_*s,e[4]=m*s-h,e[8]=a*c,e[1]=a*u,e[5]=a*d,e[9]=-s,e[2]=h*s-m,e[6]=_+p*s,e[10]=a*l}else if("ZXY"===t.order){let p=l*d,h=l*u,m=c*d,_=c*u;e[0]=p-_*s,e[4]=-a*u,e[8]=m+h*s,e[1]=h+m*s,e[5]=a*d,e[9]=_-p*s,e[2]=-a*c,e[6]=s,e[10]=a*l}else if("ZYX"===t.order){let p=a*d,h=a*u,m=s*d,_=s*u;e[0]=l*d,e[4]=m*c-h,e[8]=p*c+_,e[1]=l*u,e[5]=_*c+p,e[9]=h*c-m,e[2]=-c,e[6]=s*l,e[10]=a*l}else if("YZX"===t.order){let p=a*l,h=a*c,m=s*l,_=s*c;e[0]=l*d,e[4]=_-p*u,e[8]=m*u+h,e[1]=u,e[5]=a*d,e[9]=-s*d,e[2]=-c*d,e[6]=h*u+m,e[10]=p-_*u}else if("XZY"===t.order){let p=a*l,h=a*c,m=s*l,_=s*c;e[0]=l*d,e[4]=-u,e[8]=c*d,e[1]=p*u+_,e[5]=a*d,e[9]=h*u-m,e[2]=m*u-h,e[6]=s*d,e[10]=_*u+p}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(tPe,t,nPe)}lookAt(t,e,i){let r=this.elements;return ws.subVectors(t,e),0===ws.lengthSq()&&(ws.z=1),ws.normalize(),mp.crossVectors(i,ws),0===mp.lengthSq()&&(1===Math.abs(i.z)?ws.x+=1e-4:ws.z+=1e-4,ws.normalize(),mp.crossVectors(i,ws)),mp.normalize(),YD.crossVectors(ws,mp),r[0]=mp.x,r[4]=YD.x,r[8]=ws.x,r[1]=mp.y,r[5]=YD.y,r[9]=ws.y,r[2]=mp.z,r[6]=YD.z,r[10]=ws.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,a=i[0],s=i[4],l=i[8],c=i[12],d=i[1],u=i[5],p=i[9],h=i[13],m=i[2],_=i[6],M=i[10],y=i[14],x=i[3],R=i[7],I=i[11],B=i[15],ee=r[0],Q=r[4],we=r[8],Qe=r[12],Ae=r[1],D=r[5],re=r[9],ce=r[13],he=r[2],_e=r[6],$=r[10],de=r[14],pe=r[3],Ge=r[7],Se=r[11],Fe=r[15];return o[0]=a*ee+s*Ae+l*he+c*pe,o[4]=a*Q+s*D+l*_e+c*Ge,o[8]=a*we+s*re+l*$+c*Se,o[12]=a*Qe+s*ce+l*de+c*Fe,o[1]=d*ee+u*Ae+p*he+h*pe,o[5]=d*Q+u*D+p*_e+h*Ge,o[9]=d*we+u*re+p*$+h*Se,o[13]=d*Qe+u*ce+p*de+h*Fe,o[2]=m*ee+_*Ae+M*he+y*pe,o[6]=m*Q+_*D+M*_e+y*Ge,o[10]=m*we+_*re+M*$+y*Se,o[14]=m*Qe+_*ce+M*de+y*Fe,o[3]=x*ee+R*Ae+I*he+B*pe,o[7]=x*Q+R*D+I*_e+B*Ge,o[11]=x*we+R*re+I*$+B*Se,o[15]=x*Qe+R*ce+I*de+B*Fe,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],d=t[2],u=t[6],p=t[10],h=t[14];return t[3]*(+o*l*u-r*c*u-o*s*p+i*c*p+r*s*h-i*l*h)+t[7]*(+e*l*h-e*c*p+o*a*p-r*a*h+r*c*d-o*l*d)+t[11]*(+e*c*u-e*s*h-o*a*u+i*a*h+o*s*d-i*c*d)+t[15]*(-r*s*d-e*l*u+e*s*p+r*a*u-i*a*p+i*l*d)}transpose(){let e,t=this.elements;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],d=t[8],u=t[9],p=t[10],h=t[11],m=t[12],_=t[13],M=t[14],y=t[15],x=u*M*c-_*p*c+_*l*h-s*M*h-u*l*y+s*p*y,R=m*p*c-d*M*c-m*l*h+a*M*h+d*l*y-a*p*y,I=d*_*c-m*u*c+m*s*h-a*_*h-d*s*y+a*u*y,B=m*u*l-d*_*l-m*s*p+a*_*p+d*s*M-a*u*M,ee=e*x+i*R+r*I+o*B;if(0===ee)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let Q=1/ee;return t[0]=x*Q,t[1]=(_*p*o-u*M*o-_*r*h+i*M*h+u*r*y-i*p*y)*Q,t[2]=(s*M*o-_*l*o+_*r*c-i*M*c-s*r*y+i*l*y)*Q,t[3]=(u*l*o-s*p*o-u*r*c+i*p*c+s*r*h-i*l*h)*Q,t[4]=R*Q,t[5]=(d*M*o-m*p*o+m*r*h-e*M*h-d*r*y+e*p*y)*Q,t[6]=(m*l*o-a*M*o-m*r*c+e*M*c+a*r*y-e*l*y)*Q,t[7]=(a*p*o-d*l*o+d*r*c-e*p*c-a*r*h+e*l*h)*Q,t[8]=I*Q,t[9]=(m*u*o-d*_*o-m*i*h+e*_*h+d*i*y-e*u*y)*Q,t[10]=(a*_*o-m*s*o+m*i*c-e*_*c-a*i*y+e*s*y)*Q,t[11]=(d*s*o-a*u*o-d*i*c+e*u*c+a*i*h-e*s*h)*Q,t[12]=B*Q,t[13]=(d*_*r-m*u*r+m*i*p-e*_*p-d*i*M+e*u*M)*Q,t[14]=(m*s*r-a*_*r-m*i*l+e*_*l+a*i*M-e*s*M)*Q,t[15]=(a*u*r-d*s*r+d*i*l-e*u*l-a*i*p+e*s*p)*Q,this}scale(t){let e=this.elements,i=t.x,r=t.y,o=t.z;return e[0]*=i,e[4]*=r,e[8]*=o,e[1]*=i,e[5]*=r,e[9]*=o,e[2]*=i,e[6]*=r,e[10]*=o,e[3]*=i,e[7]*=r,e[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),o=1-i,a=t.x,s=t.y,l=t.z,c=o*a,d=o*s;return this.set(c*a+i,c*s-r*l,c*l+r*s,0,c*s+r*l,d*s+i,d*l-r*a,0,c*l-r*s,d*l+r*a,o*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,o,a){return this.set(1,i,o,0,t,1,a,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,o=e._x,a=e._y,s=e._z,l=e._w,c=o+o,d=a+a,u=s+s,p=o*c,h=o*d,m=o*u,_=a*d,M=a*u,y=s*u,x=l*c,R=l*d,I=l*u,B=i.x,ee=i.y,Q=i.z;return r[0]=(1-(_+y))*B,r[1]=(h+I)*B,r[2]=(m-R)*B,r[3]=0,r[4]=(h-I)*ee,r[5]=(1-(p+y))*ee,r[6]=(M+x)*ee,r[7]=0,r[8]=(m+R)*Q,r[9]=(M-x)*Q,r[10]=(1-(p+_))*Q,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,o=T0.set(r[0],r[1],r[2]).length(),a=T0.set(r[4],r[5],r[6]).length(),s=T0.set(r[8],r[9],r[10]).length();this.determinant()<0&&(o=-o),t.x=r[12],t.y=r[13],t.z=r[14],Wl.copy(this);let c=1/o,d=1/a,u=1/s;return Wl.elements[0]*=c,Wl.elements[1]*=c,Wl.elements[2]*=c,Wl.elements[4]*=d,Wl.elements[5]*=d,Wl.elements[6]*=d,Wl.elements[8]*=u,Wl.elements[9]*=u,Wl.elements[10]*=u,e.setFromRotationMatrix(Wl),i.x=o,i.y=a,i.z=s,this}makePerspective(t,e,i,r,o,a){void 0===a&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,c=2*o/(i-r),d=(e+t)/(e-t),u=(i+r)/(i-r),p=-(a+o)/(a-o),h=-2*a*o/(a-o);return s[0]=2*o/(e-t),s[4]=0,s[8]=d,s[12]=0,s[1]=0,s[5]=c,s[9]=u,s[13]=0,s[2]=0,s[6]=0,s[10]=p,s[14]=h,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,e,i,r,o,a){let s=this.elements,l=1/(e-t),c=1/(i-r),d=1/(a-o),u=(e+t)*l,p=(i+r)*c,h=(a+o)*d;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-u,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-p,s[2]=0,s[6]=0,s[10]=-2*d,s[14]=-h,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};vn.prototype.isMatrix4=!0;var T0=new K,Wl=new vn,tPe=new K(0,0,0),nPe=new K(1,1,1),mp=new K,YD=new K,ws=new K,oee=new vn,aee=new oa,Tp=class{constructor(t=0,e=0,i=0,r=Tp.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,o=r[0],a=r[4],s=r[8],l=r[1],c=r[5],d=r[9],u=r[2],p=r[6],h=r[10];switch(e){case"XYZ":this._y=Math.asin(es(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-d,h),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(p,c),this._z=0);break;case"YXZ":this._x=Math.asin(-es(d,-1,1)),Math.abs(d)<.9999999?(this._y=Math.atan2(s,h),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-u,o),this._z=0);break;case"ZXY":this._x=Math.asin(es(p,-1,1)),Math.abs(p)<.9999999?(this._y=Math.atan2(-u,h),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-es(u,-1,1)),Math.abs(u)<.9999999?(this._x=Math.atan2(p,h),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(es(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-d,c),this._y=Math.atan2(-u,o)):(this._x=0,this._y=Math.atan2(s,h));break;case"XZY":this._z=Math.asin(-es(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(p,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-d,h),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!0===i&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return oee.makeRotationFromQuaternion(t),this.setFromRotationMatrix(oee,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return aee.setFromEuler(this),this.setFromQuaternion(aee,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new K(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Tp.prototype.isEuler=!0,Tp.DefaultOrder="XYZ",Tp.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var EI=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}isEnabled(t){return 0!=(this.mask&(1<<t|0))}},iPe=0,see=new K,D0=new oa,Ld=new vn,QD=new K,ax=new K,rPe=new K,oPe=new oa,lee=new K(1,0,0),cee=new K(0,1,0),dee=new K(0,0,1),aPe={type:"added"},uee={type:"removed"},Ui=class extends zd{constructor(){super(),Object.defineProperty(this,"id",{value:iPe++}),this.uuid=Yl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=Ui.DefaultUp.clone();let t=new K,e=new Tp,i=new oa,r=new K(1,1,1);e._onChange(function(){i.setFromEuler(e,!1)}),i._onChange(function(){e.setFromQuaternion(i,void 0,!1)}),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new vn},normalMatrix:{value:new yo}}),this.matrix=new vn,this.matrixWorld=new vn,this.matrixAutoUpdate=Ui.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new EI,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return D0.setFromAxisAngle(t,e),this.quaternion.multiply(D0),this}rotateOnWorldAxis(t,e){return D0.setFromAxisAngle(t,e),this.quaternion.premultiply(D0),this}rotateX(t){return this.rotateOnAxis(lee,t)}rotateY(t){return this.rotateOnAxis(cee,t)}rotateZ(t){return this.rotateOnAxis(dee,t)}translateOnAxis(t,e){return see.copy(t).applyQuaternion(this.quaternion),this.position.add(see.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(lee,t)}translateY(t){return this.translateOnAxis(cee,t)}translateZ(t){return this.translateOnAxis(dee,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Ld.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?QD.copy(t):QD.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),ax.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Ld.lookAt(ax,QD,this.up):Ld.lookAt(QD,ax,this.up),this.quaternion.setFromRotationMatrix(Ld),r&&(Ld.extractRotation(r.matrixWorld),D0.setFromRotationMatrix(Ld),this.quaternion.premultiply(D0.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(aPe)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return-1!==e&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(uee)),this}removeFromParent(){let t=this.parent;return null!==t&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(uee)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Ld.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),Ld.multiply(t.parent.matrixWorld)),t.applyMatrix4(Ld),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let a=this.children[i].getObjectByProperty(t,e);if(void 0!==a)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(ax,t,rPe),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(ax,oPe,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(!1===this.visible)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;null!==e&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(!0===t&&null!==i&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===e){let r=this.children;for(let o=0,a=r.length;o<a;o++)r[o].updateWorldMatrix(!1,!0)}}toJSON(t){let e=void 0===t||"string"==typeof t,i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};function o(s,l){return void 0===s[l.uuid]&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(r.uuid=this.uuid,r.type=this.type,""!==this.name&&(r.name=this.name),!0===this.castShadow&&(r.castShadow=!0),!0===this.receiveShadow&&(r.receiveShadow=!0),!1===this.visible&&(r.visible=!1),!1===this.frustumCulled&&(r.frustumCulled=!1),0!==this.renderOrder&&(r.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(r.instanceColor=this.instanceColor.toJSON())),this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(void 0!==s&&void 0!==s.shapes){let l=s.shapes;if(Array.isArray(l))for(let c=0,d=l.length;c<d;c++)o(t.shapes,l[c]);else o(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(o(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));r.material=s}else r.material=o(t.materials,this.material);if(this.children.length>0){r.children=[];for(let s=0;s<this.children.length;s++)r.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let s=0;s<this.animations.length;s++)r.animations.push(o(t.animations,this.animations[s]))}if(e){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),d=a(t.images),u=a(t.shapes),p=a(t.skeletons),h=a(t.animations);s.length>0&&(i.geometries=s),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),d.length>0&&(i.images=d),u.length>0&&(i.shapes=u),p.length>0&&(i.skeletons=p),h.length>0&&(i.animations=h)}return i.object=r,i;function a(s){let l=[];for(let c in s){let d=s[c];delete d.metadata,l.push(d)}return l}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let i=0;i<t.children.length;i++)this.add(t.children[i].clone());return this}};Ui.DefaultUp=new K(0,1,0),Ui.DefaultMatrixAutoUpdate=!0,Ui.prototype.isObject3D=!0;var ql=new K,Bd=new K,E3=new K,Vd=new K,I0=new K,A0=new K,pee=new K,T3=new K,D3=new K,I3=new K,Vr=class{constructor(t=new K,e=new K,i=new K){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),ql.subVectors(t,e),r.cross(ql);let o=r.lengthSq();return o>0?r.multiplyScalar(1/Math.sqrt(o)):r.set(0,0,0)}static getBarycoord(t,e,i,r,o){ql.subVectors(r,e),Bd.subVectors(i,e),E3.subVectors(t,e);let a=ql.dot(ql),s=ql.dot(Bd),l=ql.dot(E3),c=Bd.dot(Bd),d=Bd.dot(E3),u=a*c-s*s;if(0===u)return o.set(-2,-1,-1);let p=1/u,h=(c*l-s*d)*p,m=(a*d-s*l)*p;return o.set(1-h-m,m,h)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Vd),Vd.x>=0&&Vd.y>=0&&Vd.x+Vd.y<=1}static getUV(t,e,i,r,o,a,s,l){return this.getBarycoord(t,e,i,r,Vd),l.set(0,0),l.addScaledVector(o,Vd.x),l.addScaledVector(a,Vd.y),l.addScaledVector(s,Vd.z),l}static isFrontFacing(t,e,i,r){return ql.subVectors(i,e),Bd.subVectors(t,e),ql.cross(Bd).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return ql.subVectors(this.c,this.b),Bd.subVectors(this.a,this.b),.5*ql.cross(Bd).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return Vr.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return Vr.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,o){return Vr.getUV(t,this.a,this.b,this.c,e,i,r,o)}containsPoint(t){return Vr.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return Vr.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let a,s,i=this.a,r=this.b,o=this.c;I0.subVectors(r,i),A0.subVectors(o,i),T3.subVectors(t,i);let l=I0.dot(T3),c=A0.dot(T3);if(l<=0&&c<=0)return e.copy(i);D3.subVectors(t,r);let d=I0.dot(D3),u=A0.dot(D3);if(d>=0&&u<=d)return e.copy(r);let p=l*u-d*c;if(p<=0&&l>=0&&d<=0)return a=l/(l-d),e.copy(i).addScaledVector(I0,a);I3.subVectors(t,o);let h=I0.dot(I3),m=A0.dot(I3);if(m>=0&&h<=m)return e.copy(o);let _=h*c-l*m;if(_<=0&&c>=0&&m<=0)return s=c/(c-m),e.copy(i).addScaledVector(A0,s);let M=d*m-h*u;if(M<=0&&u-d>=0&&h-m>=0)return pee.subVectors(o,r),s=(u-d)/(u-d+(h-m)),e.copy(r).addScaledVector(pee,s);let y=1/(M+_+p);return a=_*y,s=p*y,e.copy(i).addScaledVector(I0,a).addScaledVector(A0,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},sPe=0,Fo=class extends zd{constructor(){super(),Object.defineProperty(this,"id",{value:sPe++}),this.uuid=Yl(),this.name="",this.type="Material",this.fog=!0,this.blending=gx,this.side=yx,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=cte,this.blendDst=dte,this.blendEquation=U0,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=X3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=7680,this.stencilZFail=7680,this.stencilZPass=7680,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(let e in t){let i=t[e];if(void 0===i){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===i;continue}let r=this[e];void 0!==r?r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}}toJSON(t){let e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function r(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),void 0!==this.roughness&&(i.roughness=this.roughness),void 0!==this.metalness&&(i.metalness=this.metalness),void 0!==this.sheen&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(i.shininess=this.shininess),void 0!==this.clearcoat&&(i.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(i.combine=this.combine)),void 0!==this.envMapIntensity&&(i.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(i.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&(i.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(i.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(i.size=this.size),null!==this.shadowSide&&(i.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==gx&&(i.blending=this.blending),this.side!==yx&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),!0===this.transparent&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(i.rotation=this.rotation),!0===this.polygonOffset&&(i.polygonOffset=!0),0!==this.polygonOffsetFactor&&(i.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(i.linewidth=this.linewidth),void 0!==this.dashSize&&(i.dashSize=this.dashSize),void 0!==this.gapSize&&(i.gapSize=this.gapSize),void 0!==this.scale&&(i.scale=this.scale),!0===this.dithering&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),!0===this.alphaToCoverage&&(i.alphaToCoverage=this.alphaToCoverage),!0===this.premultipliedAlpha&&(i.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(i.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(i.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(i.flatShading=this.flatShading),!1===this.visible&&(i.visible=!1),!1===this.toneMapped&&(i.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e){let o=r(t.textures),a=r(t.images);o.length>0&&(i.textures=o),a.length>0&&(i.images=a)}return i}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(null!==e){let r=e.length;i=new Array(r);for(let o=0;o!==r;++o)i[o]=e[o].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}};Fo.prototype.isMaterial=!0;var vm=class extends Fo{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new sn(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=KI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};vm.prototype.isMeshBasicMaterial=!0;var sr=new K,ZD=new $e,Ar=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=!0===i,this.usage=Cx,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,o=this.itemSize;r<o;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),a=new sn),e[i++]=a.r,e[i++]=a.g,e[i++]=a.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),a=new $e),e[i++]=a.x,e[i++]=a.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),a=new K),e[i++]=a.x,e[i++]=a.y,e[i++]=a.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let a=t[r];void 0===a&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),a=new Qi),e[i++]=a.x,e[i++]=a.y,e[i++]=a.z,e[i++]=a.w}return this}applyMatrix3(t){if(2===this.itemSize)for(let e=0,i=this.count;e<i;e++)ZD.fromBufferAttribute(this,e),ZD.applyMatrix3(t),this.setXY(e,ZD.x,ZD.y);else if(3===this.itemSize)for(let e=0,i=this.count;e<i;e++)sr.fromBufferAttribute(this,e),sr.applyMatrix3(t),this.setXYZ(e,sr.x,sr.y,sr.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)sr.x=this.getX(e),sr.y=this.getY(e),sr.z=this.getZ(e),sr.applyMatrix4(t),this.setXYZ(e,sr.x,sr.y,sr.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)sr.x=this.getX(e),sr.y=this.getY(e),sr.z=this.getZ(e),sr.applyNormalMatrix(t),this.setXYZ(e,sr.x,sr.y,sr.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)sr.x=this.getX(e),sr.y=this.getY(e),sr.z=this.getZ(e),sr.transformDirection(t),this.setXYZ(e,sr.x,sr.y,sr.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return""!==this.name&&(t.name=this.name),this.usage!==Cx&&(t.usage=this.usage),(0!==this.updateRange.offset||-1!==this.updateRange.count)&&(t.updateRange=this.updateRange),t}};Ar.prototype.isBufferAttribute=!0;var TI=class extends Ar{constructor(t,e,i){super(new Uint16Array(t),e,i)}},DI=class extends Ar{constructor(t,e,i){super(new Uint32Array(t),e,i)}};(class extends Ar{constructor(t,e,i){super(new Uint16Array(t),e,i)}}).prototype.isFloat16BufferAttribute=!0;var Nr=class extends Ar{constructor(t,e,i){super(new Float32Array(t),e,i)}},lPe=0,ll=new vn,A3=new Ui,R0=new K,Ss=new Ts,sx=new Ts,Oo=new K,Gi=class extends zd{constructor(){super(),Object.defineProperty(this,"id",{value:lPe++}),this.uuid=Yl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return this.index=Array.isArray(t)?new(hte(t)?DI:TI)(t,1):t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(void 0!==i){let o=(new yo).getNormalMatrix(t);i.applyNormalMatrix(o),i.needsUpdate=!0}let r=this.attributes.tangent;return void 0!==r&&(r.transformDirection(t),r.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}applyQuaternion(t){return ll.makeRotationFromQuaternion(t),this.applyMatrix4(ll),this}rotateX(t){return ll.makeRotationX(t),this.applyMatrix4(ll),this}rotateY(t){return ll.makeRotationY(t),this.applyMatrix4(ll),this}rotateZ(t){return ll.makeRotationZ(t),this.applyMatrix4(ll),this}translate(t,e,i){return ll.makeTranslation(t,e,i),this.applyMatrix4(ll),this}scale(t,e,i){return ll.makeScale(t,e,i),this.applyMatrix4(ll),this}lookAt(t){return A3.lookAt(t),A3.updateMatrix(),this.applyMatrix4(A3.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(R0).negate(),this.translate(R0.x,R0.y,R0.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let o=t[i];e.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new Nr(e,3)),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new Ts);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new K(-1/0,-1/0,-1/0),new K(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++)Ss.setFromBufferAttribute(e[i]),this.morphTargetsRelative?(Oo.addVectors(this.boundingBox.min,Ss.min),this.boundingBox.expandByPoint(Oo),Oo.addVectors(this.boundingBox.max,Ss.max),this.boundingBox.expandByPoint(Oo)):(this.boundingBox.expandByPoint(Ss.min),this.boundingBox.expandByPoint(Ss.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new Sp);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new K,1/0);if(t){let i=this.boundingSphere.center;if(Ss.setFromBufferAttribute(t),e)for(let o=0,a=e.length;o<a;o++)sx.setFromBufferAttribute(e[o]),this.morphTargetsRelative?(Oo.addVectors(Ss.min,sx.min),Ss.expandByPoint(Oo),Oo.addVectors(Ss.max,sx.max),Ss.expandByPoint(Oo)):(Ss.expandByPoint(sx.min),Ss.expandByPoint(sx.max));Ss.getCenter(i);let r=0;for(let o=0,a=t.count;o<a;o++)Oo.fromBufferAttribute(t,o),r=Math.max(r,i.distanceToSquared(Oo));if(e)for(let o=0,a=e.length;o<a;o++){let s=e[o],l=this.morphTargetsRelative;for(let c=0,d=s.count;c<d;c++)Oo.fromBufferAttribute(s,c),l&&(R0.fromBufferAttribute(t,c),Oo.add(R0)),r=Math.max(r,i.distanceToSquared(Oo))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(null===t||void 0===e.position||void 0===e.normal||void 0===e.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");let i=t.array,r=e.position.array,o=e.normal.array,a=e.uv.array,s=r.length/3;void 0===e.tangent&&this.setAttribute("tangent",new Ar(new Float32Array(4*s),4));let l=e.tangent.array,c=[],d=[];for(let Ae=0;Ae<s;Ae++)c[Ae]=new K,d[Ae]=new K;let u=new K,p=new K,h=new K,m=new $e,_=new $e,M=new $e,y=new K,x=new K;function R(Ae,D,re){u.fromArray(r,3*Ae),p.fromArray(r,3*D),h.fromArray(r,3*re),m.fromArray(a,2*Ae),_.fromArray(a,2*D),M.fromArray(a,2*re),p.sub(u),h.sub(u),_.sub(m),M.sub(m);let ce=1/(_.x*M.y-M.x*_.y);!isFinite(ce)||(y.copy(p).multiplyScalar(M.y).addScaledVector(h,-_.y).multiplyScalar(ce),x.copy(h).multiplyScalar(_.x).addScaledVector(p,-M.x).multiplyScalar(ce),c[Ae].add(y),c[D].add(y),c[re].add(y),d[Ae].add(x),d[D].add(x),d[re].add(x))}let I=this.groups;0===I.length&&(I=[{start:0,count:i.length}]);for(let Ae=0,D=I.length;Ae<D;++Ae){let re=I[Ae],ce=re.start;for(let _e=ce,$=ce+re.count;_e<$;_e+=3)R(i[_e+0],i[_e+1],i[_e+2])}let B=new K,ee=new K,Q=new K,we=new K;function Qe(Ae){Q.fromArray(o,3*Ae),we.copy(Q);let D=c[Ae];B.copy(D),B.sub(Q.multiplyScalar(Q.dot(D))).normalize(),ee.crossVectors(we,D);let ce=ee.dot(d[Ae])<0?-1:1;l[4*Ae]=B.x,l[4*Ae+1]=B.y,l[4*Ae+2]=B.z,l[4*Ae+3]=ce}for(let Ae=0,D=I.length;Ae<D;++Ae){let re=I[Ae],ce=re.start;for(let _e=ce,$=ce+re.count;_e<$;_e+=3)Qe(i[_e+0]),Qe(i[_e+1]),Qe(i[_e+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(void 0!==e){let i=this.getAttribute("normal");if(void 0===i)i=new Ar(new Float32Array(3*e.count),3),this.setAttribute("normal",i);else for(let p=0,h=i.count;p<h;p++)i.setXYZ(p,0,0,0);let r=new K,o=new K,a=new K,s=new K,l=new K,c=new K,d=new K,u=new K;if(t)for(let p=0,h=t.count;p<h;p+=3){let m=t.getX(p+0),_=t.getX(p+1),M=t.getX(p+2);r.fromBufferAttribute(e,m),o.fromBufferAttribute(e,_),a.fromBufferAttribute(e,M),d.subVectors(a,o),u.subVectors(r,o),d.cross(u),s.fromBufferAttribute(i,m),l.fromBufferAttribute(i,_),c.fromBufferAttribute(i,M),s.add(d),l.add(d),c.add(d),i.setXYZ(m,s.x,s.y,s.z),i.setXYZ(_,l.x,l.y,l.z),i.setXYZ(M,c.x,c.y,c.z)}else for(let p=0,h=e.count;p<h;p+=3)r.fromBufferAttribute(e,p+0),o.fromBufferAttribute(e,p+1),a.fromBufferAttribute(e,p+2),d.subVectors(a,o),u.subVectors(r,o),d.cross(u),i.setXYZ(p+0,d.x,d.y,d.z),i.setXYZ(p+1,d.x,d.y,d.z),i.setXYZ(p+2,d.x,d.y,d.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===e&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(void 0===t.attributes[r])continue;let a=i[r].array,s=t.attributes[r],l=s.array,c=s.itemSize*e,d=Math.min(l.length,a.length-c);for(let u=0,p=c;u<d;u++,p++)a[p]=l[u]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)Oo.fromBufferAttribute(t,e),Oo.normalize(),t.setXYZ(e,Oo.x,Oo.y,Oo.z)}toNonIndexed(){function t(s,l){let c=s.array,d=s.itemSize,u=s.normalized,p=new c.constructor(l.length*d),h=0,m=0;for(let _=0,M=l.length;_<M;_++){h=s.isInterleavedBufferAttribute?l[_]*s.data.stride+s.offset:l[_]*d;for(let y=0;y<d;y++)p[m++]=c[h++]}return new Ar(p,d,u)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Gi,i=this.index.array,r=this.attributes;for(let s in r){let c=t(r[s],i);e.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let d=0,u=c.length;d<u;d++){let h=t(c[d],i);l.push(h)}e.morphAttributes[s]=l}e.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){let l=this.parameters;for(let c in l)void 0!==l[c]&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i)t.data.attributes[l]=i[l].toJSON(t.data);let r={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],d=[];for(let u=0,p=c.length;u<p;u++)d.push(c[u].toJSON(t.data));d.length>0&&(r[l]=d,o=!0)}o&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return null!==s&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;null!==i&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r)this.setAttribute(c,r[c].clone(e));let o=t.morphAttributes;for(let c in o){let d=[],u=o[c];for(let p=0,h=u.length;p<h;p++)d.push(u[p].clone(e));this.morphAttributes[c]=d}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,d=a.length;c<d;c++){let u=a[c];this.addGroup(u.start,u.count,u.materialIndex)}let s=t.boundingBox;null!==s&&(this.boundingBox=s.clone());let l=t.boundingSphere;return null!==l&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,void 0!==t.parameters&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Gi.prototype.isBufferGeometry=!0;var hee=new vn,P0=new Ep,R3=new Sp,fp=new K,gp=new K,_p=new K,P3=new K,k3=new K,O3=new K,KD=new K,JD=new K,$D=new K,eI=new $e,tI=new $e,nI=new $e,F3=new K,iI=new K,so=class extends Ui{constructor(t=new Gi,e=new vm){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let a,i=this.geometry,r=this.material,o=this.matrixWorld;if(void 0!==r&&(null===i.boundingSphere&&i.computeBoundingSphere(),R3.copy(i.boundingSphere),R3.applyMatrix4(o),!1!==t.ray.intersectsSphere(R3))&&(hee.copy(o).invert(),P0.copy(t.ray).applyMatrix4(hee),null===i.boundingBox||!1!==P0.intersectsBox(i.boundingBox)))if(i.isBufferGeometry){let s=i.index,l=i.attributes.position,c=i.morphAttributes.position,d=i.morphTargetsRelative,u=i.attributes.uv,p=i.attributes.uv2,h=i.groups,m=i.drawRange;if(null!==s)if(Array.isArray(r))for(let _=0,M=h.length;_<M;_++){let y=h[_],x=r[y.materialIndex];for(let B=Math.max(y.start,m.start),ee=Math.min(s.count,Math.min(y.start+y.count,m.start+m.count));B<ee;B+=3){let Q=s.getX(B),we=s.getX(B+1),Qe=s.getX(B+2);a=rI(this,x,t,P0,l,c,d,u,p,Q,we,Qe),a&&(a.faceIndex=Math.floor(B/3),a.face.materialIndex=y.materialIndex,e.push(a))}}else for(let y=Math.max(0,m.start),x=Math.min(s.count,m.start+m.count);y<x;y+=3){let R=s.getX(y),I=s.getX(y+1),B=s.getX(y+2);a=rI(this,r,t,P0,l,c,d,u,p,R,I,B),a&&(a.faceIndex=Math.floor(y/3),e.push(a))}else if(void 0!==l)if(Array.isArray(r))for(let _=0,M=h.length;_<M;_++){let y=h[_],x=r[y.materialIndex];for(let B=Math.max(y.start,m.start),ee=Math.min(l.count,Math.min(y.start+y.count,m.start+m.count));B<ee;B+=3)a=rI(this,x,t,P0,l,c,d,u,p,B,B+1,B+2),a&&(a.faceIndex=Math.floor(B/3),a.face.materialIndex=y.materialIndex,e.push(a))}else for(let y=Math.max(0,m.start),x=Math.min(l.count,m.start+m.count);y<x;y+=3)a=rI(this,r,t,P0,l,c,d,u,p,y,y+1,y+2),a&&(a.faceIndex=Math.floor(y/3),e.push(a))}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};function rI(n,t,e,i,r,o,a,s,l,c,d,u){fp.fromBufferAttribute(r,c),gp.fromBufferAttribute(r,d),_p.fromBufferAttribute(r,u);let p=n.morphTargetInfluences;if(o&&p){KD.set(0,0,0),JD.set(0,0,0),$D.set(0,0,0);for(let m=0,_=o.length;m<_;m++){let M=p[m],y=o[m];0!==M&&(P3.fromBufferAttribute(y,c),k3.fromBufferAttribute(y,d),O3.fromBufferAttribute(y,u),a?(KD.addScaledVector(P3,M),JD.addScaledVector(k3,M),$D.addScaledVector(O3,M)):(KD.addScaledVector(P3.sub(fp),M),JD.addScaledVector(k3.sub(gp),M),$D.addScaledVector(O3.sub(_p),M)))}fp.add(KD),gp.add(JD),_p.add($D)}n.isSkinnedMesh&&(n.boneTransform(c,fp),n.boneTransform(d,gp),n.boneTransform(u,_p));let h=function(n,t,e,i,r,o,a,s){let l;if(l=t.side===bo?i.intersectTriangle(a,o,r,!0,s):i.intersectTriangle(r,o,a,t.side!==Z0,s),null===l)return null;iI.copy(s),iI.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(iI);return c<e.near||c>e.far?null:{distance:c,point:iI.clone(),object:n}}(n,t,e,i,fp,gp,_p,F3);if(h){s&&(eI.fromBufferAttribute(s,c),tI.fromBufferAttribute(s,d),nI.fromBufferAttribute(s,u),h.uv=Vr.getUV(F3,fp,gp,_p,eI,tI,nI,new $e)),l&&(eI.fromBufferAttribute(l,c),tI.fromBufferAttribute(l,d),nI.fromBufferAttribute(l,u),h.uv2=Vr.getUV(F3,fp,gp,_p,eI,tI,nI,new $e));let m={a:c,b:d,c:u,normal:new K,materialIndex:0};Vr.getNormal(fp,gp,_p,m.normal),h.face=m}return h}so.prototype.isMesh=!0;var ym=class extends Gi{constructor(t=1,e=1,i=1,r=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:o,depthSegments:a};let s=this;r=Math.floor(r),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],d=[],u=[],p=0,h=0;function m(_,M,y,x,R,I,B,ee,Q,we,Qe){let Ae=I/Q,D=B/we,re=I/2,ce=B/2,he=ee/2,_e=Q+1,$=we+1,de=0,pe=0,Ge=new K;for(let Se=0;Se<$;Se++){let Fe=Se*D-ce;for(let lt=0;lt<_e;lt++)Ge[_]=(lt*Ae-re)*x,Ge[M]=Fe*R,Ge[y]=he,c.push(Ge.x,Ge.y,Ge.z),Ge[_]=0,Ge[M]=0,Ge[y]=ee>0?1:-1,d.push(Ge.x,Ge.y,Ge.z),u.push(lt/Q),u.push(1-Se/we),de+=1}for(let Se=0;Se<we;Se++)for(let Fe=0;Fe<Q;Fe++){let Mt=p+Fe+_e*(Se+1),pt=p+(Fe+1)+_e*(Se+1),ke=p+(Fe+1)+_e*Se;l.push(p+Fe+_e*Se,Mt,ke),l.push(Mt,pt,ke),pe+=6}s.addGroup(h,pe,Qe),h+=pe,p+=de}m("z","y","x",-1,-1,i,e,t,a,o,0),m("z","y","x",1,-1,i,e,-t,a,o,1),m("x","z","y",1,1,t,i,e,r,a,2),m("x","z","y",1,-1,t,i,-e,r,a,3),m("x","y","z",1,-1,t,e,i,r,o,4),m("x","y","z",-1,-1,t,e,-i,r,o,5),this.setIndex(l),this.setAttribute("position",new Nr(c,3)),this.setAttribute("normal",new Nr(d,3)),this.setAttribute("uv",new Nr(u,2))}static fromJSON(t){return new ym(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function J0(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];t[e][i]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?r.clone():Array.isArray(r)?r.slice():r}}return t}function na(n){let t={};for(let e=0;e<n.length;e++){let i=J0(n[e]);for(let r in i)t[r]=i[r]}return t}var dPe={clone:J0,merge:na},jd=class extends Fo{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=J0(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let a=this.uniforms[r].value;e.uniforms[r]=a&&a.isTexture?{type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?{type:"c",value:a.getHex()}:a&&a.isVector2?{type:"v2",value:a.toArray()}:a&&a.isVector3?{type:"v3",value:a.toArray()}:a&&a.isVector4?{type:"v4",value:a.toArray()}:a&&a.isMatrix3?{type:"m3",value:a.toArray()}:a&&a.isMatrix4?{type:"m4",value:a.toArray()}:{value:a}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)!0===this.extensions[r]&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};jd.prototype.isShaderMaterial=!0;var Sx=class extends Ui{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new vn,this.projectionMatrix=new vn,this.projectionMatrixInverse=new vn}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return(new this.constructor).copy(this)}};Sx.prototype.isCamera=!0;var ra=class extends Sx{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=2*$3*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(.5*m3*this.fov);return.5*this.getFilmHeight()/t}getEffectiveFOV(){return 2*$3*Math.atan(Math.tan(.5*m3*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,o,a){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(.5*m3*this.fov)/this.zoom,i=2*e,r=this.aspect*i,o=-.5*r,a=this.view;if(null!==this.view&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*r/l,e-=a.offsetY*i/c,r*=a.width/l,i*=a.height/c}let s=this.filmOffset;0!==s&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};ra.prototype.isPerspectiveCamera=!0;var Ex=class extends Ui{constructor(t,e,i){if(super(),this.type="CubeCamera",!0!==i.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=i;let r=new ra(90,1,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new K(1,0,0)),this.add(r);let o=new ra(90,1,t,e);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new K(-1,0,0)),this.add(o);let a=new ra(90,1,t,e);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new K(0,1,0)),this.add(a);let s=new ra(90,1,t,e);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new K(0,-1,0)),this.add(s);let l=new ra(90,1,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new K(0,0,1)),this.add(l);let c=new ra(90,1,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new K(0,0,-1)),this.add(c)}update(t,e){null===this.parent&&this.updateMatrixWorld();let i=this.renderTarget,[r,o,a,s,l,c]=this.children,d=t.xr.enabled,u=t.getRenderTarget();t.xr.enabled=!1;let p=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,o),t.setRenderTarget(i,2),t.render(e,a),t.setRenderTarget(i,3),t.render(e,s),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=p,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(u),t.xr.enabled=d,i.texture.needsPMREMUpdate=!0}},$0=class extends lo{constructor(t,e,i,r,o,a,s,l,c,d){super(t=void 0!==t?t:[],e=void 0!==e?e:Wx,i,r,o,a,s,l,c,d),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};$0.prototype.isCubeTexture=!0;var II=class extends ts{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),this.texture=new $0(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:ia}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=Ca,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i_uniforms={tEquirect:{value:null}},i_vertexShader="\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",i_fragmentShader="\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",r=new ym(5,5,5),o=new jd({name:"CubemapFromEquirect",uniforms:J0(i_uniforms),vertexShader:i_vertexShader,fragmentShader:i_fragmentShader,side:bo,blending:vp});o.uniforms.tEquirect.value=e;let a=new so(r,o),s=e.minFilter;return e.minFilter===$I&&(e.minFilter=ia),new Ex(1,10,this).update(t,a),e.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,e,i,r){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(e,i,r);t.setRenderTarget(o)}};II.prototype.isWebGLCubeRenderTarget=!0;var N3=new K,hPe=new K,mPe=new yo,Xl=class{constructor(t=new K(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=N3.subVectors(i,e).cross(hPe.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(N3),r=this.normal.dot(i);if(0===r)return 0===this.distanceToPoint(t.start)?e.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/r;return o<0||o>1?null:e.copy(i).multiplyScalar(o).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||mPe.getNormalMatrix(t),r=this.coplanarPoint(N3).applyMatrix4(t),o=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}};Xl.prototype.isPlane=!0;var F0=new Sp,oI=new K,e_=class{constructor(t=new Xl,e=new Xl,i=new Xl,r=new Xl,o=new Xl,a=new Xl){this.planes=[t,e,i,r,o,a]}set(t,e,i,r,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(e),s[2].copy(i),s[3].copy(r),s[4].copy(o),s[5].copy(a),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],o=i[1],a=i[2],s=i[3],l=i[4],c=i[5],d=i[6],u=i[7],p=i[8],h=i[9],m=i[10],_=i[11],M=i[12],y=i[13],x=i[14],R=i[15];return e[0].setComponents(s-r,u-l,_-p,R-M).normalize(),e[1].setComponents(s+r,u+l,_+p,R+M).normalize(),e[2].setComponents(s+o,u+c,_+h,R+y).normalize(),e[3].setComponents(s-o,u-c,_-h,R-y).normalize(),e[4].setComponents(s-a,u-d,_-m,R-x).normalize(),e[5].setComponents(s+a,u+d,_+m,R+x).normalize(),this}intersectsObject(t){let e=t.geometry;return null===e.boundingSphere&&e.computeBoundingSphere(),F0.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(F0)}intersectsSprite(t){return F0.center.set(0,0,0),F0.radius=.7071067811865476,F0.applyMatrix4(t.matrixWorld),this.intersectsSphere(F0)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let o=0;o<6;o++)if(e[o].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(oI.x=r.normal.x>0?t.max.x:t.min.x,oI.y=r.normal.y>0?t.max.y:t.min.y,oI.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(oI)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}};function mte(){let n=null,t=!1,e=null,i=null;function r(o,a){e(o,a),i=n.requestAnimationFrame(r)}return{start:function(){!0!==t&&null!==e&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(o){e=o},setContext:function(o){n=o}}}function fPe(n,t){let e=t.isWebGL2,i=new WeakMap;return{get:function(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)},remove:function(c){c.isInterleavedBufferAttribute&&(c=c.data);let d=i.get(c);d&&(n.deleteBuffer(d.buffer),i.delete(c))},update:function(c,d){if(c.isGLBufferAttribute){let p=i.get(c);return void((!p||p.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version}))}c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);void 0===u?i.set(c,function(c,d){let u=c.array,p=c.usage,h=n.createBuffer();n.bindBuffer(d,h),n.bufferData(d,u,p),c.onUploadCallback();let m=5126;return u instanceof Float32Array?m=5126:u instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):u instanceof Uint16Array?c.isFloat16BufferAttribute?e?m=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):m=5123:u instanceof Int16Array?m=5122:u instanceof Uint32Array?m=5125:u instanceof Int32Array?m=5124:u instanceof Int8Array?m=5120:(u instanceof Uint8Array||u instanceof Uint8ClampedArray)&&(m=5121),{buffer:h,type:m,bytesPerElement:u.BYTES_PER_ELEMENT,version:c.version}}(c,d)):u.version<c.version&&(function(c,d,u){let p=d.array,h=d.updateRange;n.bindBuffer(u,c),-1===h.count?n.bufferSubData(u,0,p):(e?n.bufferSubData(u,h.offset*p.BYTES_PER_ELEMENT,p,h.offset,h.count):n.bufferSubData(u,h.offset*p.BYTES_PER_ELEMENT,p.subarray(h.offset,h.offset+h.count)),h.count=-1)}(u.buffer,c,d),u.version=c.version)}}}var Tx=class extends Gi{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let o=t/2,a=e/2,s=Math.floor(i),l=Math.floor(r),c=s+1,d=l+1,u=t/s,p=e/l,h=[],m=[],_=[],M=[];for(let y=0;y<d;y++){let x=y*p-a;for(let R=0;R<c;R++)m.push(R*u-o,-x,0),_.push(0,0,1),M.push(R/s),M.push(1-y/l)}for(let y=0;y<l;y++)for(let x=0;x<s;x++){let I=x+c*(y+1),B=x+1+c*(y+1),ee=x+1+c*y;h.push(x+c*y,I,ee),h.push(I,B,ee)}this.setIndex(h),this.setAttribute("position",new Nr(m,3)),this.setAttribute("normal",new Nr(_,3)),this.setAttribute("uv",new Nr(M,2))}static fromJSON(t){return new Tx(t.width,t.height,t.widthSegments,t.heightSegments)}},vi={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef USE_ALPHATEST\n\tif ( diffuseColor.a < alphaTest ) discard;\n#endif",alphatest_pars_fragment:"#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\treturn texture2D( envMap, uv ).rgb;\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"vec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 reflectVec;\n\t\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\t\treflectVec = reflect( - viewDir, normal );\n\t\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\t#else\n\t\t\t\treflectVec = refract( - viewDir, normal, refractionRatio );\n\t\t\t#endif\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tlightMapIrradiance *= PI;\n\t#endif\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointLightInfo( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotLightInfo( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalLightInfo( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#else\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\t#ifdef SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULARINTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;\n\t\t#endif\n\t\t#ifdef USE_SPECULARCOLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vUv ).rgb;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;\n\t#endif\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n};\nvec3 clearcoatSpecular = vec3( 0.0 );\nvec3 sheenSpecular = vec3( 0.0 );\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\tvec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tcomputeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef USE_CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry.normal );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometry.normal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform vec2 morphTargetsTextureSize;\n\t\tvec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {\n\t\t\tfloat texelIndex = float( vertexIndex * stride + offset );\n\t\t\tfloat y = floor( texelIndex / morphTargetsTextureSize.x );\n\t\t\tfloat x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tvec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );\n\t\t\treturn texture( morphTargetsTexture, morphUV ).xyz;\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\t#ifndef USE_MORPHNORMALS\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];\n\t\t\t#else\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];\n\t\t\t#endif\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * faceDirection;\n\t\t\tbitangent = bitangent * faceDirection;\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );\n\t\treturn normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",output_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= transmissionAlpha + 0.1;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tfloat transmissionAlpha = 1.0;\n\tfloat transmissionFactor = transmission;\n\tfloat thicknessFactor = thickness;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\ttransmissionFactor *= texture2D( transmissionMap, vUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tthicknessFactor *= texture2D( thicknessMap, vUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmission = getIBLVolumeRefraction(\n\t\tn, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,\n\t\tattenuationColor, attenuationDistance );\n\ttotalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );\n\ttransmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\treturn texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#else\n\t\t\treturn texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#endif\n\t}\n\tvec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( attenuationDistance == 0.0 ) {\n\t\t\treturn radiance;\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance * radiance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );\n\t}\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tgl_FragColor = texture2D( t2D, vUv );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULARINTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULARCOLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;\n\t#endif\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}"},Rt={common:{diffuse:{value:new sn(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new yo},uv2Transform:{value:new yo},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new $e(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new sn(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new sn(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new yo}},sprite:{diffuse:{value:new sn(16777215)},opacity:{value:1},center:{value:new $e(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new yo}}},jc={basic:{uniforms:na([Rt.common,Rt.specularmap,Rt.envmap,Rt.aomap,Rt.lightmap,Rt.fog]),vertexShader:vi.meshbasic_vert,fragmentShader:vi.meshbasic_frag},lambert:{uniforms:na([Rt.common,Rt.specularmap,Rt.envmap,Rt.aomap,Rt.lightmap,Rt.emissivemap,Rt.fog,Rt.lights,{emissive:{value:new sn(0)}}]),vertexShader:vi.meshlambert_vert,fragmentShader:vi.meshlambert_frag},phong:{uniforms:na([Rt.common,Rt.specularmap,Rt.envmap,Rt.aomap,Rt.lightmap,Rt.emissivemap,Rt.bumpmap,Rt.normalmap,Rt.displacementmap,Rt.fog,Rt.lights,{emissive:{value:new sn(0)},specular:{value:new sn(1118481)},shininess:{value:30}}]),vertexShader:vi.meshphong_vert,fragmentShader:vi.meshphong_frag},standard:{uniforms:na([Rt.common,Rt.envmap,Rt.aomap,Rt.lightmap,Rt.emissivemap,Rt.bumpmap,Rt.normalmap,Rt.displacementmap,Rt.roughnessmap,Rt.metalnessmap,Rt.fog,Rt.lights,{emissive:{value:new sn(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:vi.meshphysical_vert,fragmentShader:vi.meshphysical_frag},toon:{uniforms:na([Rt.common,Rt.aomap,Rt.lightmap,Rt.emissivemap,Rt.bumpmap,Rt.normalmap,Rt.displacementmap,Rt.gradientmap,Rt.fog,Rt.lights,{emissive:{value:new sn(0)}}]),vertexShader:vi.meshtoon_vert,fragmentShader:vi.meshtoon_frag},matcap:{uniforms:na([Rt.common,Rt.bumpmap,Rt.normalmap,Rt.displacementmap,Rt.fog,{matcap:{value:null}}]),vertexShader:vi.meshmatcap_vert,fragmentShader:vi.meshmatcap_frag},points:{uniforms:na([Rt.points,Rt.fog]),vertexShader:vi.points_vert,fragmentShader:vi.points_frag},dashed:{uniforms:na([Rt.common,Rt.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:vi.linedashed_vert,fragmentShader:vi.linedashed_frag},depth:{uniforms:na([Rt.common,Rt.displacementmap]),vertexShader:vi.depth_vert,fragmentShader:vi.depth_frag},normal:{uniforms:na([Rt.common,Rt.bumpmap,Rt.normalmap,Rt.displacementmap,{opacity:{value:1}}]),vertexShader:vi.meshnormal_vert,fragmentShader:vi.meshnormal_frag},sprite:{uniforms:na([Rt.sprite,Rt.fog]),vertexShader:vi.sprite_vert,fragmentShader:vi.sprite_frag},background:{uniforms:{uvTransform:{value:new yo},t2D:{value:null}},vertexShader:vi.background_vert,fragmentShader:vi.background_frag},cube:{uniforms:na([Rt.envmap,{opacity:{value:1}}]),vertexShader:vi.cube_vert,fragmentShader:vi.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:vi.equirect_vert,fragmentShader:vi.equirect_frag},distanceRGBA:{uniforms:na([Rt.common,Rt.displacementmap,{referencePosition:{value:new K},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:vi.distanceRGBA_vert,fragmentShader:vi.distanceRGBA_frag},shadow:{uniforms:na([Rt.lights,Rt.fog,{color:{value:new sn(0)},opacity:{value:1}}]),vertexShader:vi.shadow_vert,fragmentShader:vi.shadow_frag}};function UOe(n,t,e,i,r,o){let l,c,a=new sn(0),s=!0===r?0:1,d=null,u=0,p=null;function m(_,M){e.buffers.color.setClear(_.r,_.g,_.b,M,o)}return{getClearColor:function(){return a},setClearColor:function(_,M=1){a.set(_),s=M,m(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(_){s=_,m(a,s)},render:function(_,M){let y=!1,x=!0===M.isScene?M.background:null;x&&x.isTexture&&(x=t.get(x));let R=n.xr,I=R.getSession&&R.getSession();I&&"additive"===I.environmentBlendMode&&(x=null),null===x?m(a,s):x&&x.isColor&&(m(x,1),y=!0),(n.autoClear||y)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),x&&(x.isCubeTexture||x.mapping===JI)?(void 0===c&&(c=new so(new ym(1,1,1),new jd({name:"BackgroundCubeMaterial",uniforms:J0(jc.cube.uniforms),vertexShader:jc.cube.vertexShader,fragmentShader:jc.cube.fragmentShader,side:bo,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(B,ee,Q){this.matrixWorld.copyPosition(Q.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&!1===x.isRenderTargetTexture?-1:1,(d!==x||u!==x.version||p!==n.toneMapping)&&(c.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),_.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(void 0===l&&(l=new so(new Tx(2,2),new jd({name:"BackgroundMaterial",uniforms:J0(jc.background.uniforms),vertexShader:jc.background.vertexShader,fragmentShader:jc.background.fragmentShader,side:yx,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=x,!0===x.matrixAutoUpdate&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(d!==x||u!==x.version||p!==n.toneMapping)&&(l.material.needsUpdate=!0,d=x,u=x.version,p=n.toneMapping),_.unshift(l,l.geometry,l.material,0,0,null))}}}function jOe(n,t,e,i){let r=n.getParameter(34921),o=i.isWebGL2?null:t.get("OES_vertex_array_object"),a=i.isWebGL2||null!==o,s={},l=_(null),c=l;function p(ce){return i.isWebGL2?n.bindVertexArray(ce):o.bindVertexArrayOES(ce)}function h(ce){return i.isWebGL2?n.deleteVertexArray(ce):o.deleteVertexArrayOES(ce)}function _(ce){let he=[],_e=[],$=[];for(let de=0;de<r;de++)he[de]=0,_e[de]=0,$[de]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:he,enabledAttributes:_e,attributeDivisors:$,object:ce,attributes:{},index:null}}function x(){let ce=c.newAttributes;for(let he=0,_e=ce.length;he<_e;he++)ce[he]=0}function R(ce){I(ce,0)}function I(ce,he){let $=c.enabledAttributes,de=c.attributeDivisors;c.newAttributes[ce]=1,0===$[ce]&&(n.enableVertexAttribArray(ce),$[ce]=1),de[ce]!==he&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](ce,he),de[ce]=he)}function B(){let ce=c.newAttributes,he=c.enabledAttributes;for(let _e=0,$=he.length;_e<$;_e++)he[_e]!==ce[_e]&&(n.disableVertexAttribArray(_e),he[_e]=0)}function ee(ce,he,_e,$,de,pe){!0!==i.isWebGL2||5124!==_e&&5125!==_e?n.vertexAttribPointer(ce,he,_e,$,de,pe):n.vertexAttribIPointer(ce,he,_e,de,pe)}function D(){re(),c!==l&&(c=l,p(c.object))}function re(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:function(ce,he,_e,$,de){let pe=!1;if(a){let Ge=function(ce,he,_e){let $=!0===_e.wireframe,de=s[ce.id];void 0===de&&(de={},s[ce.id]=de);let pe=de[he.id];void 0===pe&&(pe={},de[he.id]=pe);let Ge=pe[$];return void 0===Ge&&(Ge=_(i.isWebGL2?n.createVertexArray():o.createVertexArrayOES()),pe[$]=Ge),Ge}($,_e,he);c!==Ge&&(c=Ge,p(c.object)),pe=function(ce,he){let _e=c.attributes,$=ce.attributes,de=0;for(let pe in $){let Ge=_e[pe],Se=$[pe];if(void 0===Ge||Ge.attribute!==Se||Ge.data!==Se.data)return!0;de++}return c.attributesNum!==de||c.index!==he}($,de),pe&&function(ce,he){let _e={},$=ce.attributes,de=0;for(let pe in $){let Ge=$[pe],Se={};Se.attribute=Ge,Ge.data&&(Se.data=Ge.data),_e[pe]=Se,de++}c.attributes=_e,c.attributesNum=de,c.index=he}($,de)}else{let Ge=!0===he.wireframe;(c.geometry!==$.id||c.program!==_e.id||c.wireframe!==Ge)&&(c.geometry=$.id,c.program=_e.id,c.wireframe=Ge,pe=!0)}!0===ce.isInstancedMesh&&(pe=!0),null!==de&&e.update(de,34963),pe&&(function(ce,he,_e,$){if(!1===i.isWebGL2&&(ce.isInstancedMesh||$.isInstancedBufferGeometry)&&null===t.get("ANGLE_instanced_arrays"))return;x();let de=$.attributes,pe=_e.getAttributes(),Ge=he.defaultAttributeValues;for(let Se in pe){let Fe=pe[Se];if(Fe.location>=0){let lt=de[Se];if(void 0===lt&&("instanceMatrix"===Se&&ce.instanceMatrix&&(lt=ce.instanceMatrix),"instanceColor"===Se&&ce.instanceColor&&(lt=ce.instanceColor)),void 0!==lt){let Mt=lt.normalized,pt=lt.itemSize,ke=e.get(lt);if(void 0===ke)continue;let Tn=ke.buffer,wt=ke.type,on=ke.bytesPerElement;if(lt.isInterleavedBufferAttribute){let Ce=lt.data,mt=Ce.stride,ht=lt.offset;if(Ce&&Ce.isInstancedInterleavedBuffer){for(let oe=0;oe<Fe.locationSize;oe++)I(Fe.location+oe,Ce.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===$._maxInstanceCount&&($._maxInstanceCount=Ce.meshPerAttribute*Ce.count)}else for(let oe=0;oe<Fe.locationSize;oe++)R(Fe.location+oe);n.bindBuffer(34962,Tn);for(let oe=0;oe<Fe.locationSize;oe++)ee(Fe.location+oe,pt/Fe.locationSize,wt,Mt,mt*on,(ht+pt/Fe.locationSize*oe)*on)}else{if(lt.isInstancedBufferAttribute){for(let Ce=0;Ce<Fe.locationSize;Ce++)I(Fe.location+Ce,lt.meshPerAttribute);!0!==ce.isInstancedMesh&&void 0===$._maxInstanceCount&&($._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let Ce=0;Ce<Fe.locationSize;Ce++)R(Fe.location+Ce);n.bindBuffer(34962,Tn);for(let Ce=0;Ce<Fe.locationSize;Ce++)ee(Fe.location+Ce,pt/Fe.locationSize,wt,Mt,pt*on,pt/Fe.locationSize*Ce*on)}}else if(void 0!==Ge){let Mt=Ge[Se];if(void 0!==Mt)switch(Mt.length){case 2:n.vertexAttrib2fv(Fe.location,Mt);break;case 3:n.vertexAttrib3fv(Fe.location,Mt);break;case 4:n.vertexAttrib4fv(Fe.location,Mt);break;default:n.vertexAttrib1fv(Fe.location,Mt)}}}}B()}(ce,he,_e,$),null!==de&&n.bindBuffer(34963,e.get(de).buffer))},reset:D,resetDefaultState:re,dispose:function(){D();for(let ce in s){let he=s[ce];for(let _e in he){let $=he[_e];for(let de in $)h($[de].object),delete $[de];delete he[_e]}delete s[ce]}},releaseStatesOfGeometry:function(ce){if(void 0===s[ce.id])return;let he=s[ce.id];for(let _e in he){let $=he[_e];for(let de in $)h($[de].object),delete $[de];delete he[_e]}delete s[ce.id]},releaseStatesOfProgram:function(ce){for(let he in s){let _e=s[he];if(void 0===_e[ce.id])continue;let $=_e[ce.id];for(let de in $)h($[de].object),delete $[de];delete _e[ce.id]}},initAttributes:x,enableAttribute:R,disableUnusedAttributes:B}}function GOe(n,t,e,i){let o,r=i.isWebGL2;this.setMode=function(c){o=c},this.render=function(c,d){n.drawArrays(o,c,d),e.update(d,o,1)},this.renderInstances=function(c,d,u){if(0===u)return;let p,h;if(r)p=n,h="drawArraysInstanced";else if(p=t.get("ANGLE_instanced_arrays"),h="drawArraysInstancedANGLE",null===p)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");p[h](o,c,d,u),e.update(d,o,u)}}function WOe(n,t,e){let i;function o(Q){if("highp"===Q){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";Q="mediump"}return"mediump"===Q&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext<"u"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext<"u"&&n instanceof WebGL2ComputeRenderingContext,s=void 0!==e.precision?e.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),d=!0===e.logarithmicDepthBuffer,u=n.getParameter(34930),p=n.getParameter(35660),h=n.getParameter(3379),m=n.getParameter(34076),_=n.getParameter(34921),M=n.getParameter(36347),y=n.getParameter(36348),x=n.getParameter(36349),R=p>0,I=a||t.has("OES_texture_float");return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:function(){if(void 0!==i)return i;if(!0===t.has("EXT_texture_filter_anisotropic")){let Q=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(Q.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i},getMaxPrecision:o,precision:s,logarithmicDepthBuffer:d,maxTextures:u,maxVertexTextures:p,maxTextureSize:h,maxCubemapSize:m,maxAttributes:_,maxVertexUniforms:M,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:R,floatFragmentTextures:I,floatVertexTextures:R&&I,maxSamples:a?n.getParameter(36183):0}}function qOe(n){let t=this,e=null,i=0,r=!1,o=!1,a=new Xl,s=new yo,l={value:null,needsUpdate:!1};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function d(u,p,h,m){let _=null!==u?u.length:0,M=null;if(0!==_){if(M=l.value,!0!==m||null===M){let y=h+4*_,x=p.matrixWorldInverse;s.getNormalMatrix(x),(null===M||M.length<y)&&(M=new Float32Array(y));for(let R=0,I=h;R!==_;++R,I+=4)a.copy(u[R]).applyMatrix4(x,s),a.normal.toArray(M,I),M[I+3]=a.constant}l.value=M,l.needsUpdate=!0}return t.numPlanes=_,t.numIntersection=0,M}this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(u,p,h){let m=0!==u.length||p||0!==i||r;return r=p,e=d(u,h,0),i=u.length,m},this.beginShadows=function(){o=!0,d(null)},this.endShadows=function(){o=!1,c()},this.setState=function(u,p,h){let m=u.clippingPlanes,_=u.clipIntersection,M=u.clipShadows,y=n.get(u);if(!r||null===m||0===m.length||o&&!M)o?d(null):c();else{let x=o?0:i,R=4*x,I=y.clippingState||null;l.value=I,I=d(m,p,R,h);for(let B=0;B!==R;++B)I[B]=e[B];y.clippingState=I,this.numIntersection=_?this.numPlanes:0,this.numPlanes+=x}}}function XOe(n){let t=new WeakMap;function e(a,s){return s===Y3?a.mapping=Wx:s===Q3&&(a.mapping=qx),a}function r(a){let s=a.target;s.removeEventListener("dispose",r);let l=t.get(s);void 0!==l&&(t.delete(s),l.dispose())}return{get:function(a){if(a&&a.isTexture&&!1===a.isRenderTargetTexture){let s=a.mapping;if(s===Y3||s===Q3){if(t.has(a))return e(t.get(a).texture,a.mapping);{let l=a.image;if(l&&l.height>0){let c=new II(l.height/2);return c.fromEquirectangularTexture(n,a),t.set(a,c),a.addEventListener("dispose",r),e(c.texture,a.mapping)}return null}}}return a},dispose:function(){t=new WeakMap}}}jc.physical={uniforms:na([jc.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new $e(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new sn(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new $e},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new sn(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new sn(1,1,1)},specularColorMap:{value:null}}]),vertexShader:vi.meshphysical_vert,fragmentShader:vi.meshphysical_frag};var xm=class extends Sx{constructor(t=-1,e=1,i=1,r=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,o,a){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,o=i-t,a=i+t,s=r+e,l=r-e;if(null!==this.view&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,d=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=d*this.view.offsetY,l=s-d*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}};xm.prototype.isOrthographicCamera=!0;var t_=class extends jd{constructor(t){super(t),this.type="RawShaderMaterial"}};t_.prototype.isRawShaderMaterial=!0;var Q0=4,Cp=8,Uc=Math.pow(2,Cp),fte=[.125,.215,.35,.446,.526,.582],gte=Cp-Q0+1+fte.length,L3=new xm,{_lodPlanes:lx,_sizeLods:mee,_sigmas:aI}=YOe(),fee=new sn,B3=null,fm=(1+Math.sqrt(5))/2,L0=1/fm,gee=[new K(1,1,1),new K(-1,1,1),new K(1,1,-1),new K(-1,1,-1),new K(0,fm,L0),new K(0,fm,-L0),new K(L0,0,fm),new K(-L0,0,fm),new K(fm,L0,0),new K(-fm,L0,0)],AI=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=function(n){let t=new Float32Array(20),e=new K(0,1,0);return new t_({name:"SphericalGaussianBlur",defines:{n:20},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:vp,depthTest:!1,depthWrite:!1})}(),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){B3=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,i,r,o),e>0&&this._blur(o,0,0,e),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){null===this._cubemapShader&&(this._cubemapShader=vee(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){null===this._equirectShader&&(this._equirectShader=bee(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose(),null!==this._cubemapShader&&this._cubemapShader.dispose(),null!==this._equirectShader&&this._equirectShader.dispose();for(let t=0;t<lx.length;t++)lx[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(B3),t.scissorTest=!1,sI(t,0,0,t.width,t.height)}_fromTexture(t,e){B3=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:ia,minFilter:ia,generateMipmaps:!1,type:q0,format:Ca,encoding:wp,depthBuffer:!1},i=_ee(e);return i.depthBuffer=!t,null===this._pingPongRenderTarget&&(this._pingPongRenderTarget=_ee(e)),i}_compileMaterial(t){let e=new so(lx[0],t);this._renderer.compile(e,L3)}_sceneToCubeUV(t,e,i,r){let s=new ra(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],d=this._renderer,u=d.autoClear,p=d.toneMapping;d.getClearColor(fee),d.toneMapping=yp,d.autoClear=!1;let h=new vm({name:"PMREM.Background",side:bo,depthWrite:!1,depthTest:!1}),m=new so(new ym,h),_=!1,M=t.background;M?M.isColor&&(h.color.copy(M),t.background=null,_=!0):(h.color.copy(fee),_=!0);for(let y=0;y<6;y++){let x=y%3;0===x?(s.up.set(0,l[y],0),s.lookAt(c[y],0,0)):1===x?(s.up.set(0,0,l[y]),s.lookAt(0,c[y],0)):(s.up.set(0,l[y],0),s.lookAt(0,0,c[y])),sI(r,x*Uc,y>2?Uc:0,Uc,Uc),d.setRenderTarget(r),_&&d.render(m,s),d.render(t,s)}m.geometry.dispose(),m.material.dispose(),d.toneMapping=p,d.autoClear=u,t.background=M}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Wx||t.mapping===qx;r?(null===this._cubemapShader&&(this._cubemapShader=vee()),this._cubemapShader.uniforms.flipEnvMap.value=!1===t.isRenderTargetTexture?-1:1):null===this._equirectShader&&(this._equirectShader=bee());let o=r?this._cubemapShader:this._equirectShader,a=new so(lx[0],o),s=o.uniforms;s.envMap.value=t,r||s.texelSize.value.set(1/t.image.width,1/t.image.height),sI(e,0,0,3*Uc,2*Uc),i.setRenderTarget(e),i.render(a,L3)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<gte;r++){let o=Math.sqrt(aI[r]*aI[r]-aI[r-1]*aI[r-1]);this._blur(t,r-1,r,o,gee[(r-1)%gee.length])}e.autoClear=i}_blur(t,e,i,r,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,e,i,r,"latitudinal",o),this._halfBlur(a,t,i,i,r,"longitudinal",o)}_halfBlur(t,e,i,r,o,a,s){let l=this._renderer,c=this._blurMaterial;"latitudinal"!==a&&"longitudinal"!==a&&console.error("blur direction must be either latitudinal or longitudinal!");let u=new so(lx[r],c),p=c.uniforms,h=mee[i]-1,m=isFinite(o)?Math.PI/(2*h):2*Math.PI/39,_=o/m,M=isFinite(o)?1+Math.floor(3*_):20;M>20&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${M} samples when the maximum is set to 20`);let y=[],x=0;for(let ee=0;ee<20;++ee){let Q=ee/_,we=Math.exp(-Q*Q/2);y.push(we),0===ee?x+=we:ee<M&&(x+=2*we)}for(let ee=0;ee<y.length;ee++)y[ee]=y[ee]/x;p.envMap.value=t.texture,p.samples.value=M,p.weights.value=y,p.latitudinal.value="latitudinal"===a,s&&(p.poleAxis.value=s),p.dTheta.value=m,p.mipInt.value=Cp-i;let R=mee[r];sI(e,3*Math.max(0,Uc-2*R),(0===r?0:2*Uc)+2*R*(r>Cp-Q0?r-Cp+Q0:0),3*R,2*R),l.setRenderTarget(e),l.render(u,L3)}};function YOe(){let n=[],t=[],e=[],i=Cp;for(let r=0;r<gte;r++){let o=Math.pow(2,i);t.push(o);let a=1/o;r>Cp-Q0?a=fte[r-Cp+Q0-1]:0===r&&(a=0),e.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,d=[l,l,c,l,c,c,l,l,c,c,l,c],u=6,p=6,h=3,m=2,_=1,M=new Float32Array(h*p*u),y=new Float32Array(m*p*u),x=new Float32Array(_*p*u);for(let I=0;I<u;I++){let B=I%3*2/3-1,ee=I>2?0:-1;M.set([B,ee,0,B+2/3,ee,0,B+2/3,ee+1,0,B,ee,0,B+2/3,ee+1,0,B,ee+1,0],h*p*I),y.set(d,m*p*I),x.set([I,I,I,I,I,I],_*p*I)}let R=new Gi;R.setAttribute("position",new Ar(M,h)),R.setAttribute("uv",new Ar(y,m)),R.setAttribute("faceIndex",new Ar(x,_)),n.push(R),i>Q0&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function _ee(n){let t=new ts(3*Uc,3*Uc,n);return t.texture.mapping=JI,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function sI(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function bee(){let n=new $e(1,1);return new t_({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = texture2D ( envMap, uv ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t}\n\t\t",blending:vp,depthTest:!1,depthWrite:!1})}function vee(){return new t_({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:vp,depthTest:!1,depthWrite:!1})}function ZOe(n){let t=new WeakMap,e=null;function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);void 0!==c&&(t.delete(l),c.dispose())}return{get:function(s){if(s&&s.isTexture){let l=s.mapping,c=l===Y3||l===Q3,d=l===Wx||l===qx;if(c||d){if(s.isRenderTargetTexture&&!0===s.needsPMREMUpdate){s.needsPMREMUpdate=!1;let u=t.get(s);return null===e&&(e=new AI(n)),u=c?e.fromEquirectangular(s,u):e.fromCubemap(s,u),t.set(s,u),u.texture}if(t.has(s))return t.get(s).texture;{let u=s.image;if(c&&u&&u.height>0||d&&u&&function(s){let l=0;for(let d=0;d<6;d++)void 0!==s[d]&&l++;return 6===l}(u)){null===e&&(e=new AI(n));let p=c?e.fromEquirectangular(s):e.fromCubemap(s);return t.set(s,p),s.addEventListener("dispose",o),p.texture}return null}}}return s},dispose:function(){t=new WeakMap,null!==e&&(e.dispose(),e=null)}}}function KOe(n){let t={};function e(i){if(void 0!==t[i])return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return null!==e(i)},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return null===r&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function JOe(n,t,e,i){let r={},o=new WeakMap;function a(u){let p=u.target;null!==p.index&&t.remove(p.index);for(let m in p.attributes)t.remove(p.attributes[m]);p.removeEventListener("dispose",a),delete r[p.id];let h=o.get(p);h&&(t.remove(h),o.delete(p)),i.releaseStatesOfGeometry(p),!0===p.isInstancedBufferGeometry&&delete p._maxInstanceCount,e.memory.geometries--}function c(u){let p=[],h=u.index,m=u.attributes.position,_=0;if(null!==h){let x=h.array;_=h.version;for(let R=0,I=x.length;R<I;R+=3){let B=x[R+0],ee=x[R+1],Q=x[R+2];p.push(B,ee,ee,Q,Q,B)}}else{_=m.version;for(let R=0,I=m.array.length/3-1;R<I;R+=3){let B=R+0,ee=R+1,Q=R+2;p.push(B,ee,ee,Q,Q,B)}}let M=new(hte(p)?DI:TI)(p,1);M.version=_;let y=o.get(u);y&&t.remove(y),o.set(u,M)}return{get:function(u,p){return!0===r[p.id]||(p.addEventListener("dispose",a),r[p.id]=!0,e.memory.geometries++),p},update:function(u){let p=u.attributes;for(let m in p)t.update(p[m],34962);let h=u.morphAttributes;for(let m in h){let _=h[m];for(let M=0,y=_.length;M<y;M++)t.update(_[M],34962)}},getWireframeAttribute:function(u){let p=o.get(u);if(p){let h=u.index;null!==h&&p.version<h.version&&c(u)}else c(u);return o.get(u)}}}function $Oe(n,t,e,i){let o,s,l,r=i.isWebGL2;this.setMode=function(p){o=p},this.setIndex=function(p){s=p.type,l=p.bytesPerElement},this.render=function(p,h){n.drawElements(o,h,s,p*l),e.update(h,o,1)},this.renderInstances=function(p,h,m){if(0===m)return;let _,M;if(r)_=n,M="drawElementsInstanced";else if(_=t.get("ANGLE_instanced_arrays"),M="drawElementsInstancedANGLE",null===_)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");_[M](o,h,s,p*l,m),e.update(h,o,m)}}function eFe(n){let e={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:e,programs:null,autoReset:!0,reset:function(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0},update:function(o,a,s){switch(e.calls++,a){case 4:e.triangles+=s*(o/3);break;case 1:e.lines+=s*(o/2);break;case 3:e.lines+=s*(o-1);break;case 2:e.lines+=s*o;break;case 0:e.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a)}}}}var Dx=class extends lo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=vo,this.minFilter=vo,this.wrapR=Es,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};function tFe(n,t){return n[0]-t[0]}function nFe(n,t){return Math.abs(t[1])-Math.abs(n[1])}function yee(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function iFe(n,t,e){let i={},r=new Float32Array(8),o=new WeakMap,a=new K,s=[];for(let c=0;c<8;c++)s[c]=[c,0];return{update:function(c,d,u,p){let h=c.morphTargetInfluences;if(!0===t.isWebGL2){let m=d.morphAttributes.position.length,_=o.get(d);if(void 0===_||_.count!==m){let re=function(){Ae.dispose(),o.delete(d),d.removeEventListener("dispose",re)};void 0!==_&&_.texture.dispose();let x=void 0!==d.morphAttributes.normal,R=d.morphAttributes.position,I=d.morphAttributes.normal||[],ee=!0===x?2:1,Q=d.attributes.position.count*ee,we=1;Q>t.maxTextureSize&&(we=Math.ceil(Q/t.maxTextureSize),Q=t.maxTextureSize);let Qe=new Float32Array(Q*we*4*m),Ae=new Dx(Qe,Q,we,m);Ae.format=Ca,Ae.type=gm,Ae.needsUpdate=!0;let D=4*ee;for(let ce=0;ce<m;ce++){let he=R[ce],_e=I[ce],$=Q*we*4*ce;for(let de=0;de<he.count;de++){a.fromBufferAttribute(he,de),!0===he.normalized&&yee(a,he);let pe=de*D;Qe[$+pe+0]=a.x,Qe[$+pe+1]=a.y,Qe[$+pe+2]=a.z,Qe[$+pe+3]=0,!0===x&&(a.fromBufferAttribute(_e,de),!0===_e.normalized&&yee(a,_e),Qe[$+pe+4]=a.x,Qe[$+pe+5]=a.y,Qe[$+pe+6]=a.z,Qe[$+pe+7]=0)}}_={count:m,texture:Ae,size:new $e(Q,we)},o.set(d,_),d.addEventListener("dispose",re)}let M=0;for(let x=0;x<h.length;x++)M+=h[x];let y=d.morphTargetsRelative?1:1-M;p.getUniforms().setValue(n,"morphTargetBaseInfluence",y),p.getUniforms().setValue(n,"morphTargetInfluences",h),p.getUniforms().setValue(n,"morphTargetsTexture",_.texture,e),p.getUniforms().setValue(n,"morphTargetsTextureSize",_.size)}else{let m=void 0===h?0:h.length,_=i[d.id];if(void 0===_||_.length!==m){_=[];for(let I=0;I<m;I++)_[I]=[I,0];i[d.id]=_}for(let I=0;I<m;I++){let B=_[I];B[0]=I,B[1]=h[I]}_.sort(nFe);for(let I=0;I<8;I++)I<m&&_[I][1]?(s[I][0]=_[I][0],s[I][1]=_[I][1]):(s[I][0]=Number.MAX_SAFE_INTEGER,s[I][1]=0);s.sort(tFe);let M=d.morphAttributes.position,y=d.morphAttributes.normal,x=0;for(let I=0;I<8;I++){let B=s[I],ee=B[0],Q=B[1];ee!==Number.MAX_SAFE_INTEGER&&Q?(M&&d.getAttribute("morphTarget"+I)!==M[ee]&&d.setAttribute("morphTarget"+I,M[ee]),y&&d.getAttribute("morphNormal"+I)!==y[ee]&&d.setAttribute("morphNormal"+I,y[ee]),r[I]=Q,x+=Q):(M&&!0===d.hasAttribute("morphTarget"+I)&&d.deleteAttribute("morphTarget"+I),y&&!0===d.hasAttribute("morphNormal"+I)&&d.deleteAttribute("morphNormal"+I),r[I]=0)}let R=d.morphTargetsRelative?1:1-x;p.getUniforms().setValue(n,"morphTargetBaseInfluence",R),p.getUniforms().setValue(n,"morphTargetInfluences",r)}}}}function rFe(n,t,e,i){let r=new WeakMap;function s(l){let c=l.target;c.removeEventListener("dispose",s),e.remove(c.instanceMatrix),null!==c.instanceColor&&e.remove(c.instanceColor)}return{update:function(l){let c=i.render.frame,u=t.get(l,l.geometry);return r.get(u)!==c&&(t.update(u),r.set(u,c)),l.isInstancedMesh&&(!1===l.hasEventListener("dispose",s)&&l.addEventListener("dispose",s),e.update(l.instanceMatrix,34962),null!==l.instanceColor&&e.update(l.instanceColor,34962)),u},dispose:function(){r=new WeakMap}}}Dx.prototype.isDataTexture2DArray=!0;var RI=class extends lo{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=vo,this.minFilter=vo,this.wrapR=Es,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};RI.prototype.isDataTexture3D=!0;var _te=new lo,bte=new Dx,vte=new RI,yte=new $0,xee=[],Cee=[],Mee=new Float32Array(16),wee=new Float32Array(9),See=new Float32Array(4);function d_(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,o=xee[r];if(void 0===o&&(o=new Float32Array(r),xee[r]=o),0!==t){i.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=e,n[a].toArray(o,s)}return o}function Ma(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function aa(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function eA(n,t){let e=Cee[t];void 0===e&&(e=new Int32Array(t),Cee[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function oFe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function aFe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(Ma(e,t))return;n.uniform2fv(this.addr,t),aa(e,t)}}function sFe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(void 0!==t.r)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(Ma(e,t))return;n.uniform3fv(this.addr,t),aa(e,t)}}function lFe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(Ma(e,t))return;n.uniform4fv(this.addr,t),aa(e,t)}}function cFe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(Ma(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),aa(e,t)}else{if(Ma(e,i))return;See.set(i),n.uniformMatrix2fv(this.addr,!1,See),aa(e,i)}}function dFe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(Ma(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),aa(e,t)}else{if(Ma(e,i))return;wee.set(i),n.uniformMatrix3fv(this.addr,!1,wee),aa(e,i)}}function uFe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(Ma(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),aa(e,t)}else{if(Ma(e,i))return;Mee.set(i),n.uniformMatrix4fv(this.addr,!1,Mee),aa(e,i)}}function pFe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function hFe(n,t){let e=this.cache;Ma(e,t)||(n.uniform2iv(this.addr,t),aa(e,t))}function mFe(n,t){let e=this.cache;Ma(e,t)||(n.uniform3iv(this.addr,t),aa(e,t))}function fFe(n,t){let e=this.cache;Ma(e,t)||(n.uniform4iv(this.addr,t),aa(e,t))}function gFe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function _Fe(n,t){let e=this.cache;Ma(e,t)||(n.uniform2uiv(this.addr,t),aa(e,t))}function bFe(n,t){let e=this.cache;Ma(e,t)||(n.uniform3uiv(this.addr,t),aa(e,t))}function vFe(n,t){let e=this.cache;Ma(e,t)||(n.uniform4uiv(this.addr,t),aa(e,t))}function yFe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||_te,r)}function xFe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||vte,r)}function CFe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||yte,r)}function MFe(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||bte,r)}function SFe(n,t){n.uniform1fv(this.addr,t)}function EFe(n,t){let e=d_(t,this.size,2);n.uniform2fv(this.addr,e)}function TFe(n,t){let e=d_(t,this.size,3);n.uniform3fv(this.addr,e)}function DFe(n,t){let e=d_(t,this.size,4);n.uniform4fv(this.addr,e)}function IFe(n,t){let e=d_(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function AFe(n,t){let e=d_(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function RFe(n,t){let e=d_(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function PFe(n,t){n.uniform1iv(this.addr,t)}function kFe(n,t){n.uniform2iv(this.addr,t)}function OFe(n,t){n.uniform3iv(this.addr,t)}function FFe(n,t){n.uniform4iv(this.addr,t)}function NFe(n,t){n.uniform1uiv(this.addr,t)}function LFe(n,t){n.uniform2uiv(this.addr,t)}function BFe(n,t){n.uniform3uiv(this.addr,t)}function VFe(n,t){n.uniform4uiv(this.addr,t)}function HFe(n,t,e){let i=t.length,r=eA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTexture2D(t[o]||_te,r[o])}function zFe(n,t,e){let i=t.length,r=eA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture3D(t[o]||vte,r[o])}function UFe(n,t,e){let i=t.length,r=eA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTextureCube(t[o]||yte,r[o])}function jFe(n,t,e){let i=t.length,r=eA(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture2DArray(t[o]||bte,r[o])}function WFe(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=function(n){switch(n){case 5126:return oFe;case 35664:return aFe;case 35665:return sFe;case 35666:return lFe;case 35674:return cFe;case 35675:return dFe;case 35676:return uFe;case 5124:case 35670:return pFe;case 35667:case 35671:return hFe;case 35668:case 35672:return mFe;case 35669:case 35673:return fFe;case 5125:return gFe;case 36294:return _Fe;case 36295:return bFe;case 36296:return vFe;case 35678:case 36198:case 36298:case 36306:case 35682:return yFe;case 35679:case 36299:case 36307:return xFe;case 35680:case 36300:case 36308:case 36293:return CFe;case 36289:case 36303:case 36311:case 36292:return MFe}}(t.type)}function xte(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=function(n){switch(n){case 5126:return SFe;case 35664:return EFe;case 35665:return TFe;case 35666:return DFe;case 35674:return IFe;case 35675:return AFe;case 35676:return RFe;case 5124:case 35670:return PFe;case 35667:case 35671:return kFe;case 35668:case 35672:return OFe;case 35669:case 35673:return FFe;case 5125:return NFe;case 36294:return LFe;case 36295:return BFe;case 36296:return VFe;case 35678:case 36198:case 36298:case 36306:case 35682:return HFe;case 35679:case 36299:case 36307:return zFe;case 35680:case 36300:case 36308:case 36293:return UFe;case 36289:case 36303:case 36311:case 36292:return jFe}}(t.type)}function Cte(n){this.id=n,this.seq=[],this.map={}}xte.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),aa(t,n)},Cte.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,o=i.length;r!==o;++r){let a=i[r];a.setValue(n,t[a.id],e)}};var V3=/(\w+)(\])?(\[|\.)?/g;function Eee(n,t){n.seq.push(t),n.map[t.id]=t}function qFe(n,t,e){let i=n.name,r=i.length;for(V3.lastIndex=0;;){let o=V3.exec(i),s=o[1],c=o[3];if("]"===o[2]&&(s|=0),void 0===c||"["===c&&V3.lastIndex+2===r){Eee(e,void 0===c?new WFe(s,n,t):new xte(s,n,t));break}{let u=e.map[s];void 0===u&&(u=new Cte(s),Eee(e,u)),e=u}}}function Mp(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i);qFe(r,n.getUniformLocation(t,r.name),this)}}function Tee(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}Mp.prototype.setValue=function(n,t,e,i){let r=this.map[t];void 0!==r&&r.setValue(n,e,i)},Mp.prototype.setOptional=function(n,t,e){let i=t[e];void 0!==i&&this.setValue(n,e,i)},Mp.upload=function(n,t,e,i){for(let r=0,o=t.length;r!==o;++r){let a=t[r],s=e[a.id];!1!==s.needsUpdate&&a.setValue(n,s.value,i)}},Mp.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let o=n[i];o.id in t&&e.push(o)}return e};var XFe=0;function Dee(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&""===r?"":e.toUpperCase()+"\n\n"+r+"\n\n"+function(n){let t=n.split("\n");for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join("\n")}(n.getShaderSource(t))}function ZFe(n,t){let e=function(n){switch(n){case wp:return["Linear","( value )"];case Dr:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function KFe(n,t){let e;switch(t){case MRe:e="Linear";break;case wRe:e="Reinhard";break;case SRe:e="OptimizedCineon";break;case ERe:e="ACESFilmic";break;case TRe:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function fx(n){return""!==n}function Iee(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Aee(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var t2e=/^[ \t]*#include +<([\w\d./]+)>/gm;function nB(n){return n.replace(t2e,n2e)}function n2e(n,t){let e=vi[t];if(void 0===e)throw new Error("Can not resolve #include <"+t+">");return nB(e)}var i2e=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,r2e=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Ree(n){return n.replace(r2e,Mte).replace(i2e,o2e)}function o2e(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),Mte(0,t,e,i)}function Mte(n,t,e,i){let r="";for(let o=parseInt(t);o<parseInt(e);o++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return r}function Pee(n){let t="precision "+n.precision+" float;\nprecision "+n.precision+" int;";return"highp"===n.precision?t+="\n#define HIGH_PRECISION":"mediump"===n.precision?t+="\n#define MEDIUM_PRECISION":"lowp"===n.precision&&(t+="\n#define LOW_PRECISION"),t}function d2e(n,t,e,i){let _,M,r=n.getContext(),o=e.defines,a=e.vertexShader,s=e.fragmentShader,l=function(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===ste?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===tRe?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===mx&&(t="SHADOWMAP_TYPE_VSM"),t}(e),c=function(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Wx:case qx:t="ENVMAP_TYPE_CUBE";break;case JI:case lV:t="ENVMAP_TYPE_CUBE_UV"}return t}(e),d=function(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case qx:case lV:t="ENVMAP_MODE_REFRACTION"}return t}(e),u=function(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case KI:t="ENVMAP_BLENDING_MULTIPLY";break;case xRe:t="ENVMAP_BLENDING_MIX";break;case CRe:t="ENVMAP_BLENDING_ADD"}return t}(e),p=e.isWebGL2?"":function(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||"physical"===n.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(fx).join("\n")}(e),h=function(n){let t=[];for(let e in n){let i=n[e];!1!==i&&t.push("#define "+e+" "+i)}return t.join("\n")}(o),m=r.createProgram(),y=e.glslVersion?"#version "+e.glslVersion+"\n":"";e.isRawShaderMaterial?(_=[h].filter(fx).join("\n"),_.length>0&&(_+="\n"),M=[p,h].filter(fx).join("\n"),M.length>0&&(M+="\n")):(_=[Pee(e),"#define SHADER_NAME "+e.shaderName,h,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+d:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&!1===e.flatShading?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(fx).join("\n"),M=[p,Pee(e),"#define SHADER_NAME "+e.shaderName,h,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+d:"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==yp?"#define TONE_MAPPING":"",e.toneMapping!==yp?vi.tonemapping_pars_fragment:"",e.toneMapping!==yp?KFe("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",vi.encodings_pars_fragment,ZFe("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"","\n"].filter(fx).join("\n")),a=nB(a),a=Iee(a,e),a=Aee(a,e),s=nB(s),s=Iee(s,e),s=Aee(s,e),a=Ree(a),s=Ree(s),e.isWebGL2&&!0!==e.isRawShaderMaterial&&(y="#version 300 es\n",_=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+_,M=["#define varying in",e.glslVersion===eee?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===eee?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+M);let ee,Q,R=y+M+s,I=Tee(r,35633,y+_+a),B=Tee(r,35632,R);if(r.attachShader(m,I),r.attachShader(m,B),void 0!==e.index0AttributeName?r.bindAttribLocation(m,0,e.index0AttributeName):!0===e.morphTargets&&r.bindAttribLocation(m,0,"position"),r.linkProgram(m),n.debug.checkShaderErrors){let we=r.getProgramInfoLog(m).trim(),Qe=r.getShaderInfoLog(I).trim(),Ae=r.getShaderInfoLog(B).trim(),D=!0,re=!0;if(!1===r.getProgramParameter(m,35714)){D=!1;let ce=Dee(r,I,"vertex"),he=Dee(r,B,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(m,35715)+"\n\nProgram Info Log: "+we+"\n"+ce+"\n"+he)}else""!==we?console.warn("THREE.WebGLProgram: Program Info Log:",we):(""===Qe||""===Ae)&&(re=!1);re&&(this.diagnostics={runnable:D,programLog:we,vertexShader:{log:Qe,prefix:_},fragmentShader:{log:Ae,prefix:M}})}return r.deleteShader(I),r.deleteShader(B),this.getUniforms=function(){return void 0===ee&&(ee=new Mp(r,m)),ee},this.getAttributes=function(){return void 0===Q&&(Q=function(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let o=n.getActiveAttrib(t,r),a=o.name,s=1;35674===o.type&&(s=2),35675===o.type&&(s=3),35676===o.type&&(s=4),e[a]={type:o.type,location:n.getAttribLocation(t,a),locationSize:s}}return e}(r,m)),Q},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(m),this.program=void 0},this.name=e.shaderName,this.id=XFe++,this.cacheKey=t,this.usedTimes=1,this.program=m,this.vertexShader=I,this.fragmentShader=B,this}var u2e=0,iB=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let i=t.fragmentShader,r=this._getShaderStage(t.vertexShader),o=this._getShaderStage(i),a=this._getShaderCacheForMaterial(t);return!1===a.has(r)&&(a.add(r),r.usedTimes++),!1===a.has(o)&&(a.add(o),o.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,0===i.usedTimes&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return!1===e.has(t)&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(!1===e.has(t)){let i=new rB;e.set(t,i)}return e.get(t)}},rB=class{constructor(){this.id=u2e++,this.usedTimes=0}};function p2e(n,t,e,i,r,o,a){let s=new EI,l=new iB,c=[],d=r.isWebGL2,u=r.logarithmicDepthBuffer,p=r.floatVertexTextures,h=r.maxVertexUniforms,m=r.vertexTextures,_=r.precision,M={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};return{getParameters:function(D,re,ce,he,_e){let Fe,lt,Mt,pt,$=he.fog,pe=(D.isMeshStandardMaterial?e:t).get(D.envMap||(D.isMeshStandardMaterial?he.environment:null)),Ge=M[D.type],Se=_e.isSkinnedMesh?function(D){let ce=D.skeleton.bones;if(p)return 1024;{let _e=Math.floor((h-20)/4),$=Math.min(_e,ce.length);return $<ce.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+ce.length+" bones. This GPU supports "+$+"."),0):$}}(_e):0;if(null!==D.precision&&(_=r.getMaxPrecision(D.precision),_!==D.precision&&console.warn("THREE.WebGLProgram.getParameters:",D.precision,"not supported, using",_,"instead.")),Ge){let Ce=jc[Ge];Fe=Ce.vertexShader,lt=Ce.fragmentShader}else Fe=D.vertexShader,lt=D.fragmentShader,l.update(D),Mt=l.getVertexShaderID(D),pt=l.getFragmentShaderID(D);let ke=n.getRenderTarget(),wt=D.clearcoat>0;return{isWebGL2:d,shaderID:Ge,shaderName:D.type,vertexShader:Fe,fragmentShader:lt,defines:D.defines,customVertexShaderID:Mt,customFragmentShaderID:pt,isRawShaderMaterial:!0===D.isRawShaderMaterial,glslVersion:D.glslVersion,precision:_,instancing:!0===_e.isInstancedMesh,instancingColor:!0===_e.isInstancedMesh&&null!==_e.instanceColor,supportsVertexTextures:m,outputEncoding:null===ke?n.outputEncoding:!0===ke.isXRRenderTarget?ke.texture.encoding:wp,map:!!D.map,matcap:!!D.matcap,envMap:!!pe,envMapMode:pe&&pe.mapping,envMapCubeUV:!!pe&&(pe.mapping===JI||pe.mapping===lV),lightMap:!!D.lightMap,aoMap:!!D.aoMap,emissiveMap:!!D.emissiveMap,bumpMap:!!D.bumpMap,normalMap:!!D.normalMap,objectSpaceNormalMap:D.normalMapType===QRe,tangentSpaceNormalMap:D.normalMapType===c_,decodeVideoTexture:!!D.map&&!0===D.map.isVideoTexture&&D.map.encoding===Dr,clearcoat:wt,clearcoatMap:wt&&!!D.clearcoatMap,clearcoatRoughnessMap:wt&&!!D.clearcoatRoughnessMap,clearcoatNormalMap:wt&&!!D.clearcoatNormalMap,displacementMap:!!D.displacementMap,roughnessMap:!!D.roughnessMap,metalnessMap:!!D.metalnessMap,specularMap:!!D.specularMap,specularIntensityMap:!!D.specularIntensityMap,specularColorMap:!!D.specularColorMap,alphaMap:!!D.alphaMap,alphaTest:D.alphaTest>0,alphaWrite:D.alphaWrite||D.transparent,gradientMap:!!D.gradientMap,sheen:D.sheen>0,sheenColorMap:!!D.sheenColorMap,sheenRoughnessMap:!!D.sheenRoughnessMap,transmission:D.transmission>0,transmissionMap:!!D.transmissionMap,thicknessMap:!!D.thicknessMap,combine:D.combine,vertexTangents:!!D.normalMap&&!!_e.geometry&&!!_e.geometry.attributes.tangent,vertexColors:D.vertexColors,vertexAlphas:!0===D.vertexColors&&!!_e.geometry&&!!_e.geometry.attributes.color&&4===_e.geometry.attributes.color.itemSize,vertexUvs:!!(D.map||D.bumpMap||D.normalMap||D.specularMap||D.alphaMap||D.emissiveMap||D.roughnessMap||D.metalnessMap||D.clearcoatMap||D.clearcoatRoughnessMap||D.clearcoatNormalMap||D.displacementMap||D.transmissionMap||D.thicknessMap||D.specularIntensityMap||D.specularColorMap||D.sheenColorMap||D.sheenRoughnessMap),uvsVertexOnly:!(D.map||D.bumpMap||D.normalMap||D.specularMap||D.alphaMap||D.emissiveMap||D.roughnessMap||D.metalnessMap||D.clearcoatNormalMap||D.transmission>0||D.transmissionMap||D.thicknessMap||D.specularIntensityMap||D.specularColorMap||D.sheen>0||D.sheenColorMap||D.sheenRoughnessMap||!D.displacementMap),fog:!!$,useFog:D.fog,fogExp2:$&&$.isFogExp2,flatShading:!!D.flatShading,sizeAttenuation:D.sizeAttenuation,logarithmicDepthBuffer:u,skinning:!0===_e.isSkinnedMesh&&Se>0,maxBones:Se,useVertexTexture:p,morphTargets:!!_e.geometry&&!!_e.geometry.morphAttributes.position,morphNormals:!!_e.geometry&&!!_e.geometry.morphAttributes.normal,morphTargetsCount:_e.geometry&&_e.geometry.morphAttributes.position?_e.geometry.morphAttributes.position.length:0,numDirLights:re.directional.length,numPointLights:re.point.length,numSpotLights:re.spot.length,numRectAreaLights:re.rectArea.length,numHemiLights:re.hemi.length,numDirLightShadows:re.directionalShadowMap.length,numPointLightShadows:re.pointShadowMap.length,numSpotLightShadows:re.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:D.dithering,shadowMapEnabled:n.shadowMap.enabled&&ce.length>0,shadowMapType:n.shadowMap.type,toneMapping:D.toneMapped?n.toneMapping:yp,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:D.premultipliedAlpha,doubleSided:D.side===Z0,flipSided:D.side===bo,depthPacking:void 0!==D.depthPacking&&D.depthPacking,index0AttributeName:D.index0AttributeName,extensionDerivatives:D.extensions&&D.extensions.derivatives,extensionFragDepth:D.extensions&&D.extensions.fragDepth,extensionDrawBuffers:D.extensions&&D.extensions.drawBuffers,extensionShaderTextureLOD:D.extensions&&D.extensions.shaderTextureLOD,rendererExtensionFragDepth:d||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:d||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:d||i.has("EXT_shader_texture_lod"),customProgramCacheKey:D.customProgramCacheKey()}},getProgramCacheKey:function(D){let re=[];if(D.shaderID?re.push(D.shaderID):(re.push(D.customVertexShaderID),re.push(D.customFragmentShaderID)),void 0!==D.defines)for(let ce in D.defines)re.push(ce),re.push(D.defines[ce]);return!1===D.isRawShaderMaterial&&(function(D,re){D.push(re.precision),D.push(re.outputEncoding),D.push(re.envMapMode),D.push(re.combine),D.push(re.vertexUvs),D.push(re.fogExp2),D.push(re.sizeAttenuation),D.push(re.maxBones),D.push(re.morphTargetsCount),D.push(re.numDirLights),D.push(re.numPointLights),D.push(re.numSpotLights),D.push(re.numHemiLights),D.push(re.numRectAreaLights),D.push(re.numDirLightShadows),D.push(re.numPointLightShadows),D.push(re.numSpotLightShadows),D.push(re.shadowMapType),D.push(re.toneMapping),D.push(re.numClippingPlanes),D.push(re.numClipIntersection),D.push(re.alphaWrite)}(re,D),function(D,re){s.disableAll(),re.isWebGL2&&s.enable(0),re.supportsVertexTextures&&s.enable(1),re.instancing&&s.enable(2),re.instancingColor&&s.enable(3),re.map&&s.enable(4),re.matcap&&s.enable(5),re.envMap&&s.enable(6),re.envMapCubeUV&&s.enable(7),re.lightMap&&s.enable(8),re.aoMap&&s.enable(9),re.emissiveMap&&s.enable(10),re.bumpMap&&s.enable(11),re.normalMap&&s.enable(12),re.objectSpaceNormalMap&&s.enable(13),re.tangentSpaceNormalMap&&s.enable(14),re.clearcoat&&s.enable(15),re.clearcoatMap&&s.enable(16),re.clearcoatRoughnessMap&&s.enable(17),re.clearcoatNormalMap&&s.enable(18),re.displacementMap&&s.enable(19),re.specularMap&&s.enable(20),re.roughnessMap&&s.enable(21),re.metalnessMap&&s.enable(22),re.gradientMap&&s.enable(23),re.alphaMap&&s.enable(24),re.alphaTest&&s.enable(25),re.vertexColors&&s.enable(26),re.vertexAlphas&&s.enable(27),re.vertexUvs&&s.enable(28),re.vertexTangents&&s.enable(29),re.uvsVertexOnly&&s.enable(30),re.fog&&s.enable(31),D.push(s.mask),s.disableAll(),re.useFog&&s.enable(0),re.flatShading&&s.enable(1),re.logarithmicDepthBuffer&&s.enable(2),re.skinning&&s.enable(3),re.useVertexTexture&&s.enable(4),re.morphTargets&&s.enable(5),re.morphNormals&&s.enable(6),re.premultipliedAlpha&&s.enable(7),re.shadowMapEnabled&&s.enable(8),re.physicallyCorrectLights&&s.enable(9),re.doubleSided&&s.enable(10),re.flipSided&&s.enable(11),re.depthPacking&&s.enable(12),re.dithering&&s.enable(13),re.specularIntensityMap&&s.enable(14),re.specularColorMap&&s.enable(15),re.transmission&&s.enable(16),re.transmissionMap&&s.enable(17),re.thicknessMap&&s.enable(18),re.sheen&&s.enable(19),re.sheenColorMap&&s.enable(20),re.sheenRoughnessMap&&s.enable(21),re.decodeVideoTexture&&s.enable(22),D.push(s.mask)}(re,D),re.push(n.outputEncoding)),re.push(D.customProgramCacheKey),re.join()},getUniforms:function(D){let ce,re=M[D.type];return ce=re?dPe.clone(jc[re].uniforms):D.uniforms,ce},acquireProgram:function(D,re){let ce;for(let he=0,_e=c.length;he<_e;he++){let $=c[he];if($.cacheKey===re){ce=$,++ce.usedTimes;break}}return void 0===ce&&(ce=new d2e(n,re,D,o),c.push(ce)),ce},releaseProgram:function(D){if(0==--D.usedTimes){let re=c.indexOf(D);c[re]=c[c.length-1],c.pop(),D.destroy()}},releaseShaderCache:function(D){l.remove(D)},programs:c,dispose:function(){l.dispose()}}}function h2e(){let n=new WeakMap;return{get:function(o){let a=n.get(o);return void 0===a&&(a={},n.set(o,a)),a},remove:function(o){n.delete(o)},update:function(o,a,s){n.get(o)[a]=s},dispose:function(){n=new WeakMap}}}function m2e(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function kee(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Oee(){let n=[],t=0,e=[],i=[],r=[];function a(u,p,h,m,_,M){let y=n[t];return void 0===y?(y={id:u.id,object:u,geometry:p,material:h,groupOrder:m,renderOrder:u.renderOrder,z:_,group:M},n[t]=y):(y.id=u.id,y.object=u,y.geometry=p,y.material=h,y.groupOrder=m,y.renderOrder=u.renderOrder,y.z=_,y.group=M),t++,y}return{opaque:e,transmissive:i,transparent:r,init:function(){t=0,e.length=0,i.length=0,r.length=0},push:function(u,p,h,m,_,M){let y=a(u,p,h,m,_,M);h.transmission>0?i.push(y):!0===h.transparent?r.push(y):e.push(y)},unshift:function(u,p,h,m,_,M){let y=a(u,p,h,m,_,M);h.transmission>0?i.unshift(y):!0===h.transparent?r.unshift(y):e.unshift(y)},finish:function(){for(let u=t,p=n.length;u<p;u++){let h=n[u];if(null===h.id)break;h.id=null,h.object=null,h.geometry=null,h.material=null,h.group=null}},sort:function(u,p){e.length>1&&e.sort(u||m2e),i.length>1&&i.sort(p||kee),r.length>1&&r.sort(p||kee)}}}function f2e(){let n=new WeakMap;return{get:function(i,r){let o;return!1===n.has(i)?(o=new Oee,n.set(i,[o])):r>=n.get(i).length?(o=new Oee,n.get(i).push(o)):o=n.get(i)[r],o},dispose:function(){n=new WeakMap}}}function g2e(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new K,color:new sn};break;case"SpotLight":e={position:new K,direction:new K,color:new sn,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new K,color:new sn,distance:0,decay:0};break;case"HemisphereLight":e={direction:new K,skyColor:new sn,groundColor:new sn};break;case"RectAreaLight":e={color:new sn,position:new K,halfWidth:new K,halfHeight:new K}}return n[t.id]=e,e}}}var b2e=0;function v2e(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function y2e(n,t){let e=new g2e,i=function(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new $e,shadowCameraNear:1,shadowCameraFar:1e3}}return n[t.id]=e,e}}}(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let d=0;d<9;d++)r.probe.push(new K);let o=new K,a=new vn,s=new vn;return{setup:function(d,u){let p=0,h=0,m=0;for(let Qe=0;Qe<9;Qe++)r.probe[Qe].set(0,0,0);let _=0,M=0,y=0,x=0,R=0,I=0,B=0,ee=0;d.sort(v2e);let Q=!0!==u?Math.PI:1;for(let Qe=0,Ae=d.length;Qe<Ae;Qe++){let D=d[Qe],re=D.color,ce=D.intensity,he=D.distance,_e=D.shadow&&D.shadow.map?D.shadow.map.texture:null;if(D.isAmbientLight)p+=re.r*ce*Q,h+=re.g*ce*Q,m+=re.b*ce*Q;else if(D.isLightProbe)for(let $=0;$<9;$++)r.probe[$].addScaledVector(D.sh.coefficients[$],ce);else if(D.isDirectionalLight){let $=e.get(D);if($.color.copy(D.color).multiplyScalar(D.intensity*Q),D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,r.directionalShadow[_]=pe,r.directionalShadowMap[_]=_e,r.directionalShadowMatrix[_]=D.shadow.matrix,I++}r.directional[_]=$,_++}else if(D.isSpotLight){let $=e.get(D);if($.position.setFromMatrixPosition(D.matrixWorld),$.color.copy(re).multiplyScalar(ce*Q),$.distance=he,$.coneCos=Math.cos(D.angle),$.penumbraCos=Math.cos(D.angle*(1-D.penumbra)),$.decay=D.decay,D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,r.spotShadow[y]=pe,r.spotShadowMap[y]=_e,r.spotShadowMatrix[y]=D.shadow.matrix,ee++}r.spot[y]=$,y++}else if(D.isRectAreaLight){let $=e.get(D);$.color.copy(re).multiplyScalar(ce),$.halfWidth.set(.5*D.width,0,0),$.halfHeight.set(0,.5*D.height,0),r.rectArea[x]=$,x++}else if(D.isPointLight){let $=e.get(D);if($.color.copy(D.color).multiplyScalar(D.intensity*Q),$.distance=D.distance,$.decay=D.decay,D.castShadow){let de=D.shadow,pe=i.get(D);pe.shadowBias=de.bias,pe.shadowNormalBias=de.normalBias,pe.shadowRadius=de.radius,pe.shadowMapSize=de.mapSize,pe.shadowCameraNear=de.camera.near,pe.shadowCameraFar=de.camera.far,r.pointShadow[M]=pe,r.pointShadowMap[M]=_e,r.pointShadowMatrix[M]=D.shadow.matrix,B++}r.point[M]=$,M++}else if(D.isHemisphereLight){let $=e.get(D);$.skyColor.copy(D.color).multiplyScalar(ce*Q),$.groundColor.copy(D.groundColor).multiplyScalar(ce*Q),r.hemi[R]=$,R++}}x>0&&(t.isWebGL2||!0===n.has("OES_texture_float_linear")?(r.rectAreaLTC1=Rt.LTC_FLOAT_1,r.rectAreaLTC2=Rt.LTC_FLOAT_2):!0===n.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=Rt.LTC_HALF_1,r.rectAreaLTC2=Rt.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=p,r.ambient[1]=h,r.ambient[2]=m;let we=r.hash;(we.directionalLength!==_||we.pointLength!==M||we.spotLength!==y||we.rectAreaLength!==x||we.hemiLength!==R||we.numDirectionalShadows!==I||we.numPointShadows!==B||we.numSpotShadows!==ee)&&(r.directional.length=_,r.spot.length=y,r.rectArea.length=x,r.point.length=M,r.hemi.length=R,r.directionalShadow.length=I,r.directionalShadowMap.length=I,r.pointShadow.length=B,r.pointShadowMap.length=B,r.spotShadow.length=ee,r.spotShadowMap.length=ee,r.directionalShadowMatrix.length=I,r.pointShadowMatrix.length=B,r.spotShadowMatrix.length=ee,we.directionalLength=_,we.pointLength=M,we.spotLength=y,we.rectAreaLength=x,we.hemiLength=R,we.numDirectionalShadows=I,we.numPointShadows=B,we.numSpotShadows=ee,r.version=b2e++)},setupView:function(d,u){let p=0,h=0,m=0,_=0,M=0,y=u.matrixWorldInverse;for(let x=0,R=d.length;x<R;x++){let I=d[x];if(I.isDirectionalLight){let B=r.directional[p];B.direction.setFromMatrixPosition(I.matrixWorld),o.setFromMatrixPosition(I.target.matrixWorld),B.direction.sub(o),B.direction.transformDirection(y),p++}else if(I.isSpotLight){let B=r.spot[m];B.position.setFromMatrixPosition(I.matrixWorld),B.position.applyMatrix4(y),B.direction.setFromMatrixPosition(I.matrixWorld),o.setFromMatrixPosition(I.target.matrixWorld),B.direction.sub(o),B.direction.transformDirection(y),m++}else if(I.isRectAreaLight){let B=r.rectArea[_];B.position.setFromMatrixPosition(I.matrixWorld),B.position.applyMatrix4(y),s.identity(),a.copy(I.matrixWorld),a.premultiply(y),s.extractRotation(a),B.halfWidth.set(.5*I.width,0,0),B.halfHeight.set(0,.5*I.height,0),B.halfWidth.applyMatrix4(s),B.halfHeight.applyMatrix4(s),_++}else if(I.isPointLight){let B=r.point[h];B.position.setFromMatrixPosition(I.matrixWorld),B.position.applyMatrix4(y),h++}else if(I.isHemisphereLight){let B=r.hemi[M];B.direction.setFromMatrixPosition(I.matrixWorld),B.direction.transformDirection(y),B.direction.normalize(),M++}}},state:r}}function Fee(n,t){let e=new y2e(n,t),i=[],r=[];return{init:function(){i.length=0,r.length=0},state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:function(u){e.setup(i,u)},setupLightsView:function(u){e.setupView(i,u)},pushLight:function(u){i.push(u)},pushShadow:function(u){r.push(u)}}}function x2e(n,t){let e=new WeakMap;return{get:function(o,a=0){let s;return!1===e.has(o)?(s=new Fee(n,t),e.set(o,[s])):a>=e.get(o).length?(s=new Fee(n,t),e.get(o).push(s)):s=e.get(o)[a],s},dispose:function(){e=new WeakMap}}}var PI=class extends Fo{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};PI.prototype.isMeshDepthMaterial=!0;var kI=class extends Fo{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new K,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};kI.prototype.isMeshDistanceMaterial=!0;var C2e="void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",M2e="uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";function wte(n,t,e){let i=new e_,r=new $e,o=new $e,a=new Qi,s=new PI({depthPacking:YRe}),l=new kI,c={},d=e.maxTextureSize,u={0:bo,1:yx,2:Z0},p=new jd({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new $e},radius:{value:4}},vertexShader:C2e,fragmentShader:M2e}),h=p.clone();h.defines.HORIZONTAL_PASS=1;let m=new Gi;m.setAttribute("position",new Ar(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let _=new so(m,p),M=this;function y(I,B){let ee=t.update(_);p.defines.VSM_SAMPLES!==I.blurSamples&&(p.defines.VSM_SAMPLES=I.blurSamples,h.defines.VSM_SAMPLES=I.blurSamples,p.needsUpdate=!0,h.needsUpdate=!0),p.uniforms.shadow_pass.value=I.map.texture,p.uniforms.resolution.value=I.mapSize,p.uniforms.radius.value=I.radius,n.setRenderTarget(I.mapPass),n.clear(),n.renderBufferDirect(B,null,ee,p,_,null),h.uniforms.shadow_pass.value=I.mapPass.texture,h.uniforms.resolution.value=I.mapSize,h.uniforms.radius.value=I.radius,n.setRenderTarget(I.map),n.clear(),n.renderBufferDirect(B,null,ee,h,_,null)}function x(I,B,ee,Q,we,Qe,Ae){let D=null,re=!0===Q.isPointLight?I.customDistanceMaterial:I.customDepthMaterial;if(D=void 0!==re?re:!0===Q.isPointLight?l:s,n.localClippingEnabled&&!0===ee.clipShadows&&0!==ee.clippingPlanes.length||ee.displacementMap&&0!==ee.displacementScale||ee.alphaMap&&ee.alphaTest>0){let ce=D.uuid,he=ee.uuid,_e=c[ce];void 0===_e&&(_e={},c[ce]=_e);let $=_e[he];void 0===$&&($=D.clone(),_e[he]=$),D=$}return D.visible=ee.visible,D.wireframe=ee.wireframe,D.side=Ae===mx?null!==ee.shadowSide?ee.shadowSide:ee.side:null!==ee.shadowSide?ee.shadowSide:u[ee.side],D.alphaMap=ee.alphaMap,D.alphaTest=ee.alphaTest,D.clipShadows=ee.clipShadows,D.clippingPlanes=ee.clippingPlanes,D.clipIntersection=ee.clipIntersection,D.displacementMap=ee.displacementMap,D.displacementScale=ee.displacementScale,D.displacementBias=ee.displacementBias,D.wireframeLinewidth=ee.wireframeLinewidth,D.linewidth=ee.linewidth,!0===Q.isPointLight&&!0===D.isMeshDistanceMaterial&&(D.referencePosition.setFromMatrixPosition(Q.matrixWorld),D.nearDistance=we,D.farDistance=Qe),D}function R(I,B,ee,Q,we){if(!1===I.visible)return;if(I.layers.test(B.layers)&&(I.isMesh||I.isLine||I.isPoints)&&(I.castShadow||I.receiveShadow&&we===mx)&&(!I.frustumCulled||i.intersectsObject(I))){I.modelViewMatrix.multiplyMatrices(ee.matrixWorldInverse,I.matrixWorld);let D=t.update(I),re=I.material;if(Array.isArray(re)){let ce=D.groups;for(let he=0,_e=ce.length;he<_e;he++){let $=ce[he],de=re[$.materialIndex];if(de&&de.visible){let pe=x(I,0,de,Q,ee.near,ee.far,we);n.renderBufferDirect(ee,null,D,pe,I,$)}}}else if(re.visible){let ce=x(I,0,re,Q,ee.near,ee.far,we);n.renderBufferDirect(ee,null,D,ce,I,null)}}let Ae=I.children;for(let D=0,re=Ae.length;D<re;D++)R(Ae[D],B,ee,Q,we)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=ste,this.render=function(I,B,ee){if(!1===M.enabled||!1===M.autoUpdate&&!1===M.needsUpdate||0===I.length)return;let Q=n.getRenderTarget(),we=n.getActiveCubeFace(),Qe=n.getActiveMipmapLevel(),Ae=n.state;Ae.setBlending(vp),Ae.buffers.color.setClear(1,1,1,1),Ae.buffers.depth.setTest(!0),Ae.setScissorTest(!1);for(let D=0,re=I.length;D<re;D++){let ce=I[D],he=ce.shadow;if(void 0===he){console.warn("THREE.WebGLShadowMap:",ce,"has no shadow.");continue}if(!1===he.autoUpdate&&!1===he.needsUpdate)continue;r.copy(he.mapSize);let _e=he.getFrameExtents();if(r.multiply(_e),o.copy(he.mapSize),(r.x>d||r.y>d)&&(r.x>d&&(o.x=Math.floor(d/_e.x),r.x=o.x*_e.x,he.mapSize.x=o.x),r.y>d&&(o.y=Math.floor(d/_e.y),r.y=o.y*_e.y,he.mapSize.y=o.y)),null===he.map&&!he.isPointLightShadow&&this.type===mx){let de={minFilter:ia,magFilter:ia,format:Ca};he.map=new ts(r.x,r.y,de),he.map.texture.name=ce.name+".shadowMap",he.mapPass=new ts(r.x,r.y,de),he.camera.updateProjectionMatrix()}null===he.map&&(he.map=new ts(r.x,r.y,{minFilter:vo,magFilter:vo,format:Ca}),he.map.texture.name=ce.name+".shadowMap",he.camera.updateProjectionMatrix()),n.setRenderTarget(he.map),n.clear();let $=he.getViewportCount();for(let de=0;de<$;de++){let pe=he.getViewport(de);a.set(o.x*pe.x,o.y*pe.y,o.x*pe.z,o.y*pe.w),Ae.viewport(a),he.updateMatrices(ce,de),i=he.getFrustum(),R(B,ee,he.camera,ce,this.type)}!he.isPointLightShadow&&this.type===mx&&y(he,ee),he.needsUpdate=!1}M.needsUpdate=!1,n.setRenderTarget(Q,we,Qe)}}function w2e(n,t,e){let i=e.isWebGL2,s=new function(){let se=!1,Jt=new Qi,Ut=null,Sn=new Qi(0,0,0,0);return{setMask:function(We){Ut!==We&&!se&&(n.colorMask(We,We,We,We),Ut=We)},setLocked:function(We){se=We},setClear:function(We,gn,fi,lr,Wo){!0===Wo&&(We*=lr,gn*=lr,fi*=lr),Jt.set(We,gn,fi,lr),!1===Sn.equals(Jt)&&(n.clearColor(We,gn,fi,lr),Sn.copy(Jt))},reset:function(){se=!1,Ut=null,Sn.set(-1,0,0,0)}}},l=new function(){let se=!1,Jt=null,Ut=null,Sn=null;return{setTest:function(We){We?ke(2929):Tn(2929)},setMask:function(We){Jt!==We&&!se&&(n.depthMask(We),Jt=We)},setFunc:function(We){if(Ut!==We){if(We)switch(We){case mRe:n.depthFunc(512);break;case fRe:n.depthFunc(519);break;case gRe:n.depthFunc(513);break;case X3:n.depthFunc(515);break;case _Re:n.depthFunc(514);break;case bRe:n.depthFunc(518);break;case vRe:n.depthFunc(516);break;case yRe:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);Ut=We}},setLocked:function(We){se=We},setClear:function(We){Sn!==We&&(n.clearDepth(We),Sn=We)},reset:function(){se=!1,Jt=null,Ut=null,Sn=null}}},c=new function(){let se=!1,Jt=null,Ut=null,Sn=null,We=null,gn=null,fi=null,lr=null,Wo=null;return{setTest:function(vr){se||(vr?ke(2960):Tn(2960))},setMask:function(vr){Jt!==vr&&!se&&(n.stencilMask(vr),Jt=vr)},setFunc:function(vr,Is,wa){(Ut!==vr||Sn!==Is||We!==wa)&&(n.stencilFunc(vr,Is,wa),Ut=vr,Sn=Is,We=wa)},setOp:function(vr,Is,wa){(gn!==vr||fi!==Is||lr!==wa)&&(n.stencilOp(vr,Is,wa),gn=vr,fi=Is,lr=wa)},setLocked:function(vr){se=vr},setClear:function(vr){Wo!==vr&&(n.clearStencil(vr),Wo=vr)},reset:function(){se=!1,Jt=null,Ut=null,Sn=null,We=null,gn=null,fi=null,lr=null,Wo=null}}},d={},u={},p=new WeakMap,h=[],m=null,_=!1,M=null,y=null,x=null,R=null,I=null,B=null,ee=null,Q=!1,we=null,Qe=null,Ae=null,D=null,re=null,ce=n.getParameter(35661),he=!1,_e=0,$=n.getParameter(7938);-1!==$.indexOf("WebGL")?(_e=parseFloat(/^WebGL (\d)/.exec($)[1]),he=_e>=1):-1!==$.indexOf("OpenGL ES")&&(_e=parseFloat(/^OpenGL ES (\d)/.exec($)[1]),he=_e>=2);let de=null,pe={},Ge=n.getParameter(3088),Se=n.getParameter(2978),Fe=(new Qi).fromArray(Ge),lt=(new Qi).fromArray(Se);function Mt(se,Jt,Ut){let Sn=new Uint8Array(4),We=n.createTexture();n.bindTexture(se,We),n.texParameteri(se,10241,9728),n.texParameteri(se,10240,9728);for(let gn=0;gn<Ut;gn++)n.texImage2D(Jt+gn,0,6408,1,1,0,6408,5121,Sn);return We}let pt={};function ke(se){!0!==d[se]&&(n.enable(se),d[se]=!0)}function Tn(se){!1!==d[se]&&(n.disable(se),d[se]=!1)}pt[3553]=Mt(3553,3553,1),pt[34067]=Mt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),ke(2929),l.setFunc(X3),Ye(!1),_t(S$),ke(2884),oe(vp);let mt={[U0]:32774,[iRe]:32778,[rRe]:32779};if(i)mt[I$]=32775,mt[A$]=32776;else{let se=t.get("EXT_blend_minmax");null!==se&&(mt[I$]=se.MIN_EXT,mt[A$]=se.MAX_EXT)}let ht={[oRe]:0,[aRe]:1,[sRe]:768,[cte]:770,[hRe]:776,[uRe]:774,[cRe]:772,[lRe]:769,[dte]:771,[pRe]:775,[dRe]:773};function oe(se,Jt,Ut,Sn,We,gn,fi,lr){if(se!==vp){if(!1===_&&(ke(3042),_=!0),se===nRe)We=We||Jt,gn=gn||Ut,fi=fi||Sn,(Jt!==y||We!==I)&&(n.blendEquationSeparate(mt[Jt],mt[We]),y=Jt,I=We),(Ut!==x||Sn!==R||gn!==B||fi!==ee)&&(n.blendFuncSeparate(ht[Ut],ht[Sn],ht[gn],ht[fi]),x=Ut,R=Sn,B=gn,ee=fi),M=se,Q=null;else if(se!==M||lr!==Q){if((y!==U0||I!==U0)&&(n.blendEquation(32774),y=U0,I=U0),lr)switch(se){case gx:n.blendFuncSeparate(1,771,1,771);break;case E$:n.blendFunc(1,1);break;case T$:n.blendFuncSeparate(0,769,0,1);break;case D$:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",se)}else switch(se){case gx:n.blendFuncSeparate(770,771,1,771);break;case E$:n.blendFunc(770,1);break;case T$:n.blendFuncSeparate(0,769,0,1);break;case D$:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",se)}x=null,R=null,B=null,ee=null,M=se,Q=lr}}else!0===_&&(Tn(3042),_=!1)}function Ye(se){we!==se&&(n.frontFace(se?2304:2305),we=se)}function _t(se){se!==$Ae?(ke(2884),se!==Qe&&n.cullFace(se===S$?1029:se===eRe?1028:1032)):Tn(2884),Qe=se}function an(se,Jt,Ut){se?(ke(32823),(D!==Jt||re!==Ut)&&(n.polygonOffset(Jt,Ut),D=Jt,re=Ut)):Tn(32823)}function si(se){void 0===se&&(se=33984+ce-1),de!==se&&(n.activeTexture(se),de=se)}return{buffers:{color:s,depth:l,stencil:c},enable:ke,disable:Tn,bindFramebuffer:function(se,Jt){return u[se]!==Jt&&(n.bindFramebuffer(se,Jt),u[se]=Jt,i&&(36009===se&&(u[36160]=Jt),36160===se&&(u[36009]=Jt)),!0)},drawBuffers:function(se,Jt){let Ut=h,Sn=!1;if(se)if(Ut=p.get(Jt),void 0===Ut&&(Ut=[],p.set(Jt,Ut)),se.isWebGLMultipleRenderTargets){let We=se.texture;if(Ut.length!==We.length||36064!==Ut[0]){for(let gn=0,fi=We.length;gn<fi;gn++)Ut[gn]=36064+gn;Ut.length=We.length,Sn=!0}}else 36064!==Ut[0]&&(Ut[0]=36064,Sn=!0);else 1029!==Ut[0]&&(Ut[0]=1029,Sn=!0);Sn&&(e.isWebGL2?n.drawBuffers(Ut):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Ut))},useProgram:function(se){return m!==se&&(n.useProgram(se),m=se,!0)},setBlending:oe,setMaterial:function(se,Jt){se.side===Z0?Tn(2884):ke(2884);let Ut=se.side===bo;Jt&&(Ut=!Ut),Ye(Ut),se.blending===gx&&!1===se.transparent?oe(vp):oe(se.blending,se.blendEquation,se.blendSrc,se.blendDst,se.blendEquationAlpha,se.blendSrcAlpha,se.blendDstAlpha,se.premultipliedAlpha),l.setFunc(se.depthFunc),l.setTest(se.depthTest),l.setMask(se.depthWrite),s.setMask(se.colorWrite);let Sn=se.stencilWrite;c.setTest(Sn),Sn&&(c.setMask(se.stencilWriteMask),c.setFunc(se.stencilFunc,se.stencilRef,se.stencilFuncMask),c.setOp(se.stencilFail,se.stencilZFail,se.stencilZPass)),an(se.polygonOffset,se.polygonOffsetFactor,se.polygonOffsetUnits),!0===se.alphaToCoverage?ke(32926):Tn(32926)},setFlipSided:Ye,setCullFace:_t,setLineWidth:function(se){se!==Ae&&(he&&n.lineWidth(se),Ae=se)},setPolygonOffset:an,setScissorTest:function(se){se?ke(3089):Tn(3089)},activeTexture:si,bindTexture:function(se,Jt){null===de&&si();let Ut=pe[de];void 0===Ut&&(Ut={type:void 0,texture:void 0},pe[de]=Ut),(Ut.type!==se||Ut.texture!==Jt)&&(n.bindTexture(se,Jt||pt[se]),Ut.type=se,Ut.texture=Jt)},unbindTexture:function(){let se=pe[de];void 0!==se&&void 0!==se.type&&(n.bindTexture(se.type,null),se.type=void 0,se.texture=void 0)},compressedTexImage2D:function(){try{n.compressedTexImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texImage2D:function(){try{n.texImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texImage3D:function(){try{n.texImage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texStorage2D:function(){try{n.texStorage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texStorage3D:function(){try{n.texStorage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texSubImage2D:function(){try{n.texSubImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},texSubImage3D:function(){try{n.texSubImage3D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},compressedTexSubImage2D:function(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(se){console.error("THREE.WebGLState:",se)}},scissor:function(se){!1===Fe.equals(se)&&(n.scissor(se.x,se.y,se.z,se.w),Fe.copy(se))},viewport:function(se){!1===lt.equals(se)&&(n.viewport(se.x,se.y,se.z,se.w),lt.copy(se))},reset:function(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),!0===i&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),d={},de=null,pe={},u={},p=new WeakMap,h=[],m=null,_=!1,M=null,y=null,x=null,R=null,I=null,B=null,ee=null,Q=!1,we=null,Qe=null,Ae=null,D=null,re=null,Fe.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),s.reset(),l.reset(),c.reset()}}}function S2e(n,t,e,i,r,o,a){let _,s=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,d=r.maxTextureSize,u=r.maxSamples,h=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,m=new WeakMap,M=!1;try{M=typeof OffscreenCanvas<"u"&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch{}function y(Y,L){return M?new OffscreenCanvas(Y,L):Mx("canvas")}function x(Y,L,He,yt){let en=1;if((Y.width>yt||Y.height>yt)&&(en=yt/Math.max(Y.width,Y.height)),en<1||!0===L){if(typeof HTMLImageElement<"u"&&Y instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&Y instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&Y instanceof ImageBitmap){let Le=L?JRe:Math.floor,hn=Le(en*Y.width),ln=Le(en*Y.height);void 0===_&&(_=y(hn,ln));let Ft=He?y(hn,ln):_;return Ft.width=hn,Ft.height=ln,Ft.getContext("2d").drawImage(Y,0,0,hn,ln),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+Y.width+"x"+Y.height+") to ("+hn+"x"+ln+")."),Ft}return"data"in Y&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+Y.width+"x"+Y.height+")."),Y}return Y}function R(Y){return tee(Y.width)&&tee(Y.height)}function B(Y,L){return Y.generateMipmaps&&L&&Y.minFilter!==vo&&Y.minFilter!==ia}function ee(Y){n.generateMipmap(Y)}function Q(Y,L,He,yt,en=!1){if(!1===s)return L;if(null!==Y){if(void 0!==n[Y])return n[Y];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+Y+"'")}let Le=L;return 6403===L&&(5126===He&&(Le=33326),5131===He&&(Le=33325),5121===He&&(Le=33321)),33319===L&&(5126===He&&(Le=33328),5131===He&&(Le=33327),5121===He&&(Le=33323)),6408===L&&(5126===He&&(Le=34836),5131===He&&(Le=34842),5121===He&&(Le=yt===Dr&&!1===en?35907:32856),32819===He&&(Le=32854),32820===He&&(Le=32855)),(33325===Le||33326===Le||33327===Le||33328===Le||34842===Le||34836===Le)&&t.get("EXT_color_buffer_float"),Le}function we(Y,L,He){return!0===B(Y,He)||Y.isFramebufferTexture&&Y.minFilter!==vo&&Y.minFilter!==ia?Math.log2(Math.max(L.width,L.height))+1:void 0!==Y.mipmaps&&Y.mipmaps.length>0?Y.mipmaps.length:Y.isCompressedTexture&&Array.isArray(Y.image)?L.mipmaps.length:1}function Qe(Y){return Y===vo||Y===R$||Y===P$?9728:9729}function Ae(Y){let L=Y.target;L.removeEventListener("dispose",Ae),function(Y){let L=i.get(Y);void 0!==L.__webglInit&&(n.deleteTexture(L.__webglTexture),i.remove(Y))}(L),L.isVideoTexture&&m.delete(L),a.memory.textures--}function D(Y){let L=Y.target;L.removeEventListener("dispose",D),function(Y){let L=Y.texture,He=i.get(Y),yt=i.get(L);if(Y){if(void 0!==yt.__webglTexture&&(n.deleteTexture(yt.__webglTexture),a.memory.textures--),Y.depthTexture&&Y.depthTexture.dispose(),Y.isWebGLCubeRenderTarget)for(let en=0;en<6;en++)n.deleteFramebuffer(He.__webglFramebuffer[en]),He.__webglDepthbuffer&&n.deleteRenderbuffer(He.__webglDepthbuffer[en]);else n.deleteFramebuffer(He.__webglFramebuffer),He.__webglDepthbuffer&&n.deleteRenderbuffer(He.__webglDepthbuffer),He.__webglMultisampledFramebuffer&&n.deleteFramebuffer(He.__webglMultisampledFramebuffer),He.__webglColorRenderbuffer&&n.deleteRenderbuffer(He.__webglColorRenderbuffer),He.__webglDepthRenderbuffer&&n.deleteRenderbuffer(He.__webglDepthRenderbuffer);if(Y.isWebGLMultipleRenderTargets)for(let en=0,Le=L.length;en<Le;en++){let hn=i.get(L[en]);hn.__webglTexture&&(n.deleteTexture(hn.__webglTexture),a.memory.textures--),i.remove(L[en])}i.remove(L),i.remove(Y)}}(L)}let he=0;function de(Y,L){let He=i.get(Y);if(Y.isVideoTexture&&function(Y){let L=a.render.frame;m.get(Y)!==L&&(m.set(Y,L),Y.update())}(Y),Y.version>0&&He.__version!==Y.version){let yt=Y.image;if(void 0===yt)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==yt.complete)return void ke(He,Y,L);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}e.activeTexture(33984+L),e.bindTexture(3553,He.__webglTexture)}function Se(Y,L){let He=i.get(Y);Y.version>0&&He.__version!==Y.version?function(Y,L,He){if(6!==L.image.length)return;pt(Y,L),e.activeTexture(33984+He),e.bindTexture(34067,Y.__webglTexture),n.pixelStorei(37440,L.flipY),n.pixelStorei(37441,L.premultiplyAlpha),n.pixelStorei(3317,L.unpackAlignment),n.pixelStorei(37443,0);let yt=L&&(L.isCompressedTexture||L.image[0].isCompressedTexture),en=L.image[0]&&L.image[0].isDataTexture,Le=[];for(let We=0;We<6;We++)Le[We]=yt||en?en?L.image[We].image:L.image[We]:x(L.image[We],!1,!0,c),Le[We]=an(L,Le[We]);let Sn,hn=Le[0],ln=R(hn)||s,Ft=o.convert(L.format,L.encoding),Ot=o.convert(L.type),Nn=Q(L.internalFormat,Ft,Ot,L.encoding),se=s&&!0!==L.isVideoTexture,Jt=void 0===Y.__version,Ut=we(L,hn,ln);if(Mt(34067,L,ln),yt){se&&Jt&&e.texStorage2D(34067,Ut,Nn,hn.width,hn.height);for(let We=0;We<6;We++){Sn=Le[We].mipmaps;for(let gn=0;gn<Sn.length;gn++){let fi=Sn[gn];L.format!==Ca?null!==Ft?se?e.compressedTexSubImage2D(34069+We,gn,0,0,fi.width,fi.height,Ft,fi.data):e.compressedTexImage2D(34069+We,gn,Nn,fi.width,fi.height,0,fi.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):se?e.texSubImage2D(34069+We,gn,0,0,fi.width,fi.height,Ft,Ot,fi.data):e.texImage2D(34069+We,gn,Nn,fi.width,fi.height,0,Ft,Ot,fi.data)}}}else{Sn=L.mipmaps,se&&Jt&&(Sn.length>0&&Ut++,e.texStorage2D(34067,Ut,Nn,Le[0].width,Le[0].height));for(let We=0;We<6;We++)if(en){se?e.texSubImage2D(34069+We,0,0,0,Le[We].width,Le[We].height,Ft,Ot,Le[We].data):e.texImage2D(34069+We,0,Nn,Le[We].width,Le[We].height,0,Ft,Ot,Le[We].data);for(let gn=0;gn<Sn.length;gn++){let lr=Sn[gn].image[We].image;se?e.texSubImage2D(34069+We,gn+1,0,0,lr.width,lr.height,Ft,Ot,lr.data):e.texImage2D(34069+We,gn+1,Nn,lr.width,lr.height,0,Ft,Ot,lr.data)}}else{se?e.texSubImage2D(34069+We,0,0,0,Ft,Ot,Le[We]):e.texImage2D(34069+We,0,Nn,Ft,Ot,Le[We]);for(let gn=0;gn<Sn.length;gn++){let fi=Sn[gn];se?e.texSubImage2D(34069+We,gn+1,0,0,Ft,Ot,fi.image[We]):e.texImage2D(34069+We,gn+1,Nn,Ft,Ot,fi.image[We])}}}B(L,ln)&&ee(34067),Y.__version=L.version,L.onUpdate&&L.onUpdate(L)}(He,Y,L):(e.activeTexture(33984+L),e.bindTexture(34067,He.__webglTexture))}let Fe={[Z3]:10497,[Es]:33071,[K3]:33648},lt={[vo]:9728,[R$]:9984,[P$]:9986,[ia]:9729,[DRe]:9985,[$I]:9987};function Mt(Y,L,He){if(He?(n.texParameteri(Y,10242,Fe[L.wrapS]),n.texParameteri(Y,10243,Fe[L.wrapT]),(32879===Y||35866===Y)&&n.texParameteri(Y,32882,Fe[L.wrapR]),n.texParameteri(Y,10240,lt[L.magFilter]),n.texParameteri(Y,10241,lt[L.minFilter])):(n.texParameteri(Y,10242,33071),n.texParameteri(Y,10243,33071),(32879===Y||35866===Y)&&n.texParameteri(Y,32882,33071),(L.wrapS!==Es||L.wrapT!==Es)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(Y,10240,Qe(L.magFilter)),n.texParameteri(Y,10241,Qe(L.minFilter)),L.minFilter!==vo&&L.minFilter!==ia&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),!0===t.has("EXT_texture_filter_anisotropic")){let yt=t.get("EXT_texture_filter_anisotropic");if(L.type===gm&&!1===t.has("OES_texture_float_linear")||!1===s&&L.type===q0&&!1===t.has("OES_texture_half_float_linear"))return;(L.anisotropy>1||i.get(L).__currentAnisotropy)&&(n.texParameterf(Y,yt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(L.anisotropy,r.getMaxAnisotropy())),i.get(L).__currentAnisotropy=L.anisotropy)}}function pt(Y,L){void 0===Y.__webglInit&&(Y.__webglInit=!0,L.addEventListener("dispose",Ae),Y.__webglTexture=n.createTexture(),a.memory.textures++)}function ke(Y,L,He){let yt=3553;L.isDataTexture2DArray&&(yt=35866),L.isDataTexture3D&&(yt=32879),pt(Y,L),e.activeTexture(33984+He),e.bindTexture(yt,Y.__webglTexture),n.pixelStorei(37440,L.flipY),n.pixelStorei(37441,L.premultiplyAlpha),n.pixelStorei(3317,L.unpackAlignment),n.pixelStorei(37443,0);let en=function(Y){return!s&&(Y.wrapS!==Es||Y.wrapT!==Es||Y.minFilter!==vo&&Y.minFilter!==ia)}(L)&&!1===R(L.image),Le=x(L.image,en,!1,d);Le=an(L,Le);let hn=R(Le)||s,ln=o.convert(L.format,L.encoding),Ft=o.convert(L.type),Ot=Q(L.internalFormat,ln,Ft,L.encoding,L.isVideoTexture);Mt(yt,L,hn);let Nn,se=L.mipmaps,Jt=s&&!0!==L.isVideoTexture,Ut=void 0===Y.__version,Sn=we(L,Le,hn);if(L.isDepthTexture)Ot=6402,s?Ot=L.type===gm?36012:L.type===xI?33190:L.type===X0?35056:33189:L.type===gm&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),L.format===bm&&6402===Ot&&L.type!==xx&&L.type!==xI&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),L.type=xx,Ft=o.convert(L.type)),L.format===K0&&6402===Ot&&(Ot=34041,L.type!==X0&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),L.type=X0,Ft=o.convert(L.type))),Jt&&Ut?e.texStorage2D(3553,1,Ot,Le.width,Le.height):e.texImage2D(3553,0,Ot,Le.width,Le.height,0,ln,Ft,null);else if(L.isDataTexture)if(se.length>0&&hn){Jt&&Ut&&e.texStorage2D(3553,Sn,Ot,se[0].width,se[0].height);for(let We=0,gn=se.length;We<gn;We++)Nn=se[We],Jt?e.texSubImage2D(3553,0,0,0,Nn.width,Nn.height,ln,Ft,Nn.data):e.texImage2D(3553,We,Ot,Nn.width,Nn.height,0,ln,Ft,Nn.data);L.generateMipmaps=!1}else Jt?(Ut&&e.texStorage2D(3553,Sn,Ot,Le.width,Le.height),e.texSubImage2D(3553,0,0,0,Le.width,Le.height,ln,Ft,Le.data)):e.texImage2D(3553,0,Ot,Le.width,Le.height,0,ln,Ft,Le.data);else if(L.isCompressedTexture){Jt&&Ut&&e.texStorage2D(3553,Sn,Ot,se[0].width,se[0].height);for(let We=0,gn=se.length;We<gn;We++)Nn=se[We],L.format!==Ca?null!==ln?Jt?e.compressedTexSubImage2D(3553,We,0,0,Nn.width,Nn.height,ln,Nn.data):e.compressedTexImage2D(3553,We,Ot,Nn.width,Nn.height,0,Nn.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):Jt?e.texSubImage2D(3553,We,0,0,Nn.width,Nn.height,ln,Ft,Nn.data):e.texImage2D(3553,We,Ot,Nn.width,Nn.height,0,ln,Ft,Nn.data)}else if(L.isDataTexture2DArray)Jt?(Ut&&e.texStorage3D(35866,Sn,Ot,Le.width,Le.height,Le.depth),e.texSubImage3D(35866,0,0,0,0,Le.width,Le.height,Le.depth,ln,Ft,Le.data)):e.texImage3D(35866,0,Ot,Le.width,Le.height,Le.depth,0,ln,Ft,Le.data);else if(L.isDataTexture3D)Jt?(Ut&&e.texStorage3D(32879,Sn,Ot,Le.width,Le.height,Le.depth),e.texSubImage3D(32879,0,0,0,0,Le.width,Le.height,Le.depth,ln,Ft,Le.data)):e.texImage3D(32879,0,Ot,Le.width,Le.height,Le.depth,0,ln,Ft,Le.data);else if(L.isFramebufferTexture)Jt&&Ut?e.texStorage2D(3553,Sn,Ot,Le.width,Le.height):e.texImage2D(3553,0,Ot,Le.width,Le.height,0,ln,Ft,null);else if(se.length>0&&hn){Jt&&Ut&&e.texStorage2D(3553,Sn,Ot,se[0].width,se[0].height);for(let We=0,gn=se.length;We<gn;We++)Nn=se[We],Jt?e.texSubImage2D(3553,We,0,0,ln,Ft,Nn):e.texImage2D(3553,We,Ot,ln,Ft,Nn);L.generateMipmaps=!1}else Jt?(Ut&&e.texStorage2D(3553,Sn,Ot,Le.width,Le.height),e.texSubImage2D(3553,0,0,0,ln,Ft,Le)):e.texImage2D(3553,0,Ot,ln,Ft,Le);B(L,hn)&&ee(yt),Y.__version=L.version,L.onUpdate&&L.onUpdate(L)}function wt(Y,L,He,yt,en){let Le=o.convert(He.format,He.encoding),hn=o.convert(He.type),ln=Q(He.internalFormat,Le,hn,He.encoding);i.get(L).__hasExternalTextures||(32879===en||35866===en?e.texImage3D(en,0,ln,L.width,L.height,L.depth,0,Le,hn,null):e.texImage2D(en,0,ln,L.width,L.height,0,Le,hn,null)),e.bindFramebuffer(36160,Y),L.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,yt,en,i.get(He).__webglTexture,0,_t(L)):n.framebufferTexture2D(36160,yt,en,i.get(He).__webglTexture,0),e.bindFramebuffer(36160,null)}function on(Y,L,He){if(n.bindRenderbuffer(36161,Y),L.depthBuffer&&!L.stencilBuffer){let yt=33189;if(He||L.useRenderToTexture){let en=L.depthTexture;en&&en.isDepthTexture&&(en.type===gm?yt=36012:en.type===xI&&(yt=33190));let Le=_t(L);L.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,Le,yt,L.width,L.height):n.renderbufferStorageMultisample(36161,Le,yt,L.width,L.height)}else n.renderbufferStorage(36161,yt,L.width,L.height);n.framebufferRenderbuffer(36160,36096,36161,Y)}else if(L.depthBuffer&&L.stencilBuffer){let yt=_t(L);He&&L.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,35056,L.width,L.height):L.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,yt,35056,L.width,L.height):n.renderbufferStorage(36161,34041,L.width,L.height),n.framebufferRenderbuffer(36160,33306,36161,Y)}else{let yt=!0===L.isWebGLMultipleRenderTargets?L.texture[0]:L.texture,en=o.convert(yt.format,yt.encoding),Le=o.convert(yt.type),hn=Q(yt.internalFormat,en,Le,yt.encoding),ln=_t(L);He&&L.useRenderbuffer?n.renderbufferStorageMultisample(36161,ln,hn,L.width,L.height):L.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,ln,hn,L.width,L.height):n.renderbufferStorage(36161,hn,L.width,L.height)}n.bindRenderbuffer(36161,null)}function mt(Y){let L=i.get(Y),He=!0===Y.isWebGLCubeRenderTarget;if(Y.depthTexture&&!L.__autoAllocateDepthBuffer){if(He)throw new Error("target.depthTexture not supported in Cube render targets");!function(Y,L){if(L&&L.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,Y),!L.depthTexture||!L.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(L.depthTexture).__webglTexture||L.depthTexture.image.width!==L.width||L.depthTexture.image.height!==L.height)&&(L.depthTexture.image.width=L.width,L.depthTexture.image.height=L.height,L.depthTexture.needsUpdate=!0),de(L.depthTexture,0);let yt=i.get(L.depthTexture).__webglTexture,en=_t(L);if(L.depthTexture.format===bm)L.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,36096,3553,yt,0,en):n.framebufferTexture2D(36160,36096,3553,yt,0);else{if(L.depthTexture.format!==K0)throw new Error("Unknown depthTexture format");L.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,33306,3553,yt,0,en):n.framebufferTexture2D(36160,33306,3553,yt,0)}}(L.__webglFramebuffer,Y)}else if(He){L.__webglDepthbuffer=[];for(let yt=0;yt<6;yt++)e.bindFramebuffer(36160,L.__webglFramebuffer[yt]),L.__webglDepthbuffer[yt]=n.createRenderbuffer(),on(L.__webglDepthbuffer[yt],Y,!1)}else e.bindFramebuffer(36160,L.__webglFramebuffer),L.__webglDepthbuffer=n.createRenderbuffer(),on(L.__webglDepthbuffer,Y,!1);e.bindFramebuffer(36160,null)}function _t(Y){return s&&(Y.useRenderbuffer||Y.useRenderToTexture)?Math.min(u,Y.samples):0}function an(Y,L){let He=Y.encoding,yt=Y.format,en=Y.type;return!0===Y.isCompressedTexture||!0===Y.isVideoTexture||Y.format===J3||He!==wp&&(He===Dr?!1===s?!0===t.has("EXT_sRGB")&&yt===Ca?(Y.format=J3,Y.minFilter=ia,Y.generateMipmaps=!1):L=Ud.sRGBToLinear(L):(yt!==Ca||en!==xp)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",He)),L}let yn=!1,si=!1;this.allocateTextureUnit=function(){let Y=he;return Y>=l&&console.warn("THREE.WebGLTextures: Trying to use "+Y+" texture units while this GPU supports only "+l),he+=1,Y},this.resetTextureUnits=function(){he=0},this.setTexture2D=de,this.setTexture2DArray=function(Y,L){let He=i.get(Y);Y.version>0&&He.__version!==Y.version?ke(He,Y,L):(e.activeTexture(33984+L),e.bindTexture(35866,He.__webglTexture))},this.setTexture3D=function(Y,L){let He=i.get(Y);Y.version>0&&He.__version!==Y.version?ke(He,Y,L):(e.activeTexture(33984+L),e.bindTexture(32879,He.__webglTexture))},this.setTextureCube=Se,this.rebindTextures=function(Y,L,He){let yt=i.get(Y);void 0!==L&&wt(yt.__webglFramebuffer,Y,Y.texture,36064,3553),void 0!==He&&mt(Y)},this.setupRenderTarget=function(Y){let L=Y.texture,He=i.get(Y),yt=i.get(L);Y.addEventListener("dispose",D),!0!==Y.isWebGLMultipleRenderTargets&&(void 0===yt.__webglTexture&&(yt.__webglTexture=n.createTexture()),yt.__version=L.version,a.memory.textures++);let en=!0===Y.isWebGLCubeRenderTarget,Le=!0===Y.isWebGLMultipleRenderTargets,hn=L.isDataTexture3D||L.isDataTexture2DArray,ln=R(Y)||s;if(en){He.__webglFramebuffer=[];for(let Ft=0;Ft<6;Ft++)He.__webglFramebuffer[Ft]=n.createFramebuffer()}else if(He.__webglFramebuffer=n.createFramebuffer(),Le)if(r.drawBuffers){let Ft=Y.texture;for(let Ot=0,Nn=Ft.length;Ot<Nn;Ot++){let se=i.get(Ft[Ot]);void 0===se.__webglTexture&&(se.__webglTexture=n.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(Y.useRenderbuffer)if(s){He.__webglMultisampledFramebuffer=n.createFramebuffer(),He.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,He.__webglColorRenderbuffer);let Ft=o.convert(L.format,L.encoding),Ot=o.convert(L.type),Nn=Q(L.internalFormat,Ft,Ot,L.encoding),se=_t(Y);n.renderbufferStorageMultisample(36161,se,Nn,Y.width,Y.height),e.bindFramebuffer(36160,He.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,He.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),Y.depthBuffer&&(He.__webglDepthRenderbuffer=n.createRenderbuffer(),on(He.__webglDepthRenderbuffer,Y,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(en){e.bindTexture(34067,yt.__webglTexture),Mt(34067,L,ln);for(let Ft=0;Ft<6;Ft++)wt(He.__webglFramebuffer[Ft],Y,L,36064,34069+Ft);B(L,ln)&&ee(34067),e.unbindTexture()}else if(Le){let Ft=Y.texture;for(let Ot=0,Nn=Ft.length;Ot<Nn;Ot++){let se=Ft[Ot],Jt=i.get(se);e.bindTexture(3553,Jt.__webglTexture),Mt(3553,se,ln),wt(He.__webglFramebuffer,Y,se,36064+Ot,3553),B(se,ln)&&ee(3553)}e.unbindTexture()}else{let Ft=3553;hn&&(s?Ft=L.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(Ft,yt.__webglTexture),Mt(Ft,L,ln),wt(He.__webglFramebuffer,Y,L,36064,Ft),B(L,ln)&&ee(Ft),e.unbindTexture()}Y.depthBuffer&&mt(Y)},this.updateRenderTargetMipmap=function(Y){let L=R(Y)||s,He=!0===Y.isWebGLMultipleRenderTargets?Y.texture:[Y.texture];for(let yt=0,en=He.length;yt<en;yt++){let Le=He[yt];if(B(Le,L)){let hn=Y.isWebGLCubeRenderTarget?34067:3553,ln=i.get(Le).__webglTexture;e.bindTexture(hn,ln),ee(hn),e.unbindTexture()}}},this.updateMultisampleRenderTarget=function(Y){if(Y.useRenderbuffer)if(s){let L=Y.width,He=Y.height,yt=16384,en=[36064],Le=Y.stencilBuffer?33306:36096;Y.depthBuffer&&en.push(Le),Y.ignoreDepthForMultisampleCopy||(Y.depthBuffer&&(yt|=256),Y.stencilBuffer&&(yt|=1024));let hn=i.get(Y);e.bindFramebuffer(36008,hn.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,hn.__webglFramebuffer),Y.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[Le]),n.invalidateFramebuffer(36009,[Le])),n.blitFramebuffer(0,0,L,He,0,0,L,He,yt,9728),n.invalidateFramebuffer(36008,en),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,hn.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.setupDepthRenderbuffer=mt,this.setupFrameBufferTexture=wt,this.safeSetTexture2D=function(Y,L){Y&&Y.isWebGLRenderTarget&&(!1===yn&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),yn=!0),Y=Y.texture),de(Y,L)},this.safeSetTextureCube=function(Y,L){Y&&Y.isWebGLCubeRenderTarget&&(!1===si&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),si=!0),Y=Y.texture),Se(Y,L)}}function E2e(n,t,e){let i=e.isWebGL2;return{convert:function(o,a=null){let s;if(o===xp)return 5121;if(o===PRe)return 32819;if(o===kRe)return 32820;if(o===IRe)return 5120;if(o===ARe)return 5122;if(o===xx)return 5123;if(o===RRe)return 5124;if(o===xI)return 5125;if(o===gm)return 5126;if(o===q0)return i?5131:(s=t.get("OES_texture_half_float"),null!==s?s.HALF_FLOAT_OES:null);if(o===ORe)return 6406;if(o===Ca)return 6408;if(o===FRe)return 6409;if(o===NRe)return 6410;if(o===bm)return 6402;if(o===K0)return 34041;if(o===LRe)return 6403;if(o===J3)return s=t.get("EXT_sRGB"),null!==s?s.SRGB_ALPHA_EXT:null;if(o===BRe)return 36244;if(o===VRe)return 33319;if(o===HRe)return 33320;if(o===zRe)return 36249;if(o===l3||o===c3||o===d3||o===u3)if(a===Dr){if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),null===s)return null;if(o===l3)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===c3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===d3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===u3)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else{if(s=t.get("WEBGL_compressed_texture_s3tc"),null===s)return null;if(o===l3)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===c3)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===d3)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===u3)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(o===k$||o===O$||o===F$||o===N$){if(s=t.get("WEBGL_compressed_texture_pvrtc"),null===s)return null;if(o===k$)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===O$)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===F$)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===N$)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(o===URe)return s=t.get("WEBGL_compressed_texture_etc1"),null!==s?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===L$||o===B$){if(s=t.get("WEBGL_compressed_texture_etc"),null===s)return null;if(o===L$)return a===Dr?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===B$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}if(o===V$||o===H$||o===z$||o===U$||o===j$||o===G$||o===W$||o===q$||o===X$||o===Y$||o===Q$||o===Z$||o===K$||o===J$){if(s=t.get("WEBGL_compressed_texture_astc"),null===s)return null;if(o===V$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===H$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===z$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===U$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===j$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===G$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===W$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===q$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===X$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Y$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Q$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===Z$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===K$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===J$)return a===Dr?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}if(o===$$){if(s=t.get("EXT_texture_compression_bptc"),null===s)return null;if(o===$$)return a===Dr?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}return o===X0?i?34042:(s=t.get("WEBGL_depth_texture"),null!==s?s.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}var OI=class extends ra{constructor(t=[]){super(),this.cameras=t}};OI.prototype.isArrayCamera=!0;var _m=class extends Ui{constructor(){super(),this.type="Group"}};_m.prototype.isGroup=!0;var T2e={type:"move"},_x=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return null===this._hand&&(this._hand=new _m,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return null===this._targetRay&&(this._targetRay=new _m,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new K,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new K),this._targetRay}getGripSpace(){return null===this._grip&&(this._grip=new _m,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new K,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new K),this._grip}dispatchEvent(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this}update(t,e,i){let r=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&"visible-blurred"!==e.session.visibilityState)if(null!==s&&(r=e.getPose(t.targetRaySpace,i),null!==r&&(s.matrix.fromArray(r.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),r.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(r.linearVelocity)):s.hasLinearVelocity=!1,r.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(r.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(T2e))),c&&t.hand){a=!0;for(let _ of t.hand.values()){let M=e.getJointPose(_,i);if(void 0===c.joints[_.jointName]){let x=new _m;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[_.jointName]=x,c.add(x)}let y=c.joints[_.jointName];null!==M&&(y.matrix.fromArray(M.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=M.radius),y.visible=null!==M}let p=c.joints["index-finger-tip"].position.distanceTo(c.joints["thumb-tip"].position),h=.02,m=.005;c.inputState.pinching&&p>h+m?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&p<=h-m&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==l&&t.gripSpace&&(o=e.getPose(t.gripSpace,i),null!==o&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return null!==s&&(s.visible=null!==r),null!==l&&(l.visible=null!==o),null!==c&&(c.visible=null!==a),this}},Ix=class extends lo{constructor(t,e,i,r,o,a,s,l,c,d){if((d=void 0!==d?d:bm)!==bm&&d!==K0)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===i&&d===bm&&(i=xx),void 0===i&&d===K0&&(i=X0),super(null,r,o,a,s,l,d,i,c),this.image={width:t,height:e},this.magFilter=void 0!==s?s:vo,this.minFilter=void 0!==l?l:vo,this.flipY=!1,this.generateMipmaps=!1}};Ix.prototype.isDepthTexture=!0;var oB=class extends zd{constructor(t,e){super();let i=this,r=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,d=null,u=null,p=null,h=!1,m=null,_=e.getContextAttributes(),M=null,y=null,x=[],R=new Map,I=new ra;I.layers.enable(1),I.viewport=new Qi;let B=new ra;B.layers.enable(2),B.viewport=new Qi;let ee=[I,B],Q=new OI;Q.layers.enable(1),Q.layers.enable(2);let we=null,Qe=null;function Ae(Se){let Fe=R.get(Se.inputSource);Fe&&Fe.dispatchEvent({type:Se.type,data:Se.inputSource})}function D(){R.forEach(function(Se,Fe){Se.disconnect(Fe)}),R.clear(),we=null,Qe=null,t.setRenderTarget(M),p=null,u=null,d=null,r=null,y=null,Ge.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}function re(Se){let Fe=r.inputSources;for(let lt=0;lt<x.length;lt++)R.set(Fe[lt],x[lt]);for(let lt=0;lt<Se.removed.length;lt++){let Mt=Se.removed[lt],pt=R.get(Mt);pt&&(pt.dispatchEvent({type:"disconnected",data:Mt}),R.delete(Mt))}for(let lt=0;lt<Se.added.length;lt++){let Mt=Se.added[lt],pt=R.get(Mt);pt&&pt.dispatchEvent({type:"connected",data:Mt})}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(Se){let Fe=x[Se];return void 0===Fe&&(Fe=new _x,x[Se]=Fe),Fe.getTargetRaySpace()},this.getControllerGrip=function(Se){let Fe=x[Se];return void 0===Fe&&(Fe=new _x,x[Se]=Fe),Fe.getGripSpace()},this.getHand=function(Se){let Fe=x[Se];return void 0===Fe&&(Fe=new _x,x[Se]=Fe),Fe.getHandSpace()},this.setFramebufferScaleFactor=function(Se){o=Se,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(Se){s=Se,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return null!==u?u:p},this.getBinding=function(){return d},this.getFrame=function(){return m},this.getSession=function(){return r},this.setSession=async function(Se){if(r=Se,null!==r){if(M=t.getRenderTarget(),r.addEventListener("select",Ae),r.addEventListener("selectstart",Ae),r.addEventListener("selectend",Ae),r.addEventListener("squeeze",Ae),r.addEventListener("squeezestart",Ae),r.addEventListener("squeezeend",Ae),r.addEventListener("end",D),r.addEventListener("inputsourceschange",re),!0!==_.xrCompatible&&await e.makeXRCompatible(),void 0===r.renderState.layers||!1===t.capabilities.isWebGL2)p=new XRWebGLLayer(r,e,{antialias:void 0!==r.renderState.layers||_.antialias,alpha:_.alpha,depth:_.depth,stencil:_.stencil,framebufferScaleFactor:o}),r.updateRenderState({baseLayer:p}),y=new ts(p.framebufferWidth,p.framebufferHeight,{format:Ca,type:xp,encoding:t.outputEncoding});else{h=_.antialias;let Fe=null,lt=null,Mt=null;_.depth&&(Mt=_.stencil?35056:33190,Fe=_.stencil?K0:bm,lt=_.stencil?X0:xx);let pt={colorFormat:t.outputEncoding===Dr?35907:32856,depthFormat:Mt,scaleFactor:o};d=new XRWebGLBinding(r,e),u=d.createProjectionLayer(pt),r.updateRenderState({layers:[u]}),y=h?new wx(u.textureWidth,u.textureHeight,{format:Ca,type:xp,depthTexture:new Ix(u.textureWidth,u.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,Fe),stencilBuffer:_.stencil,ignoreDepth:u.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):new ts(u.textureWidth,u.textureHeight,{format:Ca,type:xp,depthTexture:new Ix(u.textureWidth,u.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,Fe),stencilBuffer:_.stencil,ignoreDepth:u.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),a=await r.requestReferenceSpace(s),Ge.setContext(r),Ge.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}};let ce=new K,he=new K;function $(Se,Fe){null===Fe?Se.matrixWorld.copy(Se.matrix):Se.matrixWorld.multiplyMatrices(Fe.matrixWorld,Se.matrix),Se.matrixWorldInverse.copy(Se.matrixWorld).invert()}this.updateCamera=function(Se){if(null===r)return;Q.near=B.near=I.near=Se.near,Q.far=B.far=I.far=Se.far,(we!==Q.near||Qe!==Q.far)&&(r.updateRenderState({depthNear:Q.near,depthFar:Q.far}),we=Q.near,Qe=Q.far);let Fe=Se.parent,lt=Q.cameras;$(Q,Fe);for(let pt=0;pt<lt.length;pt++)$(lt[pt],Fe);Q.matrixWorld.decompose(Q.position,Q.quaternion,Q.scale),Se.position.copy(Q.position),Se.quaternion.copy(Q.quaternion),Se.scale.copy(Q.scale),Se.matrix.copy(Q.matrix),Se.matrixWorld.copy(Q.matrixWorld);let Mt=Se.children;for(let pt=0,ke=Mt.length;pt<ke;pt++)Mt[pt].updateMatrixWorld(!0);2===lt.length?function(Se,Fe,lt){ce.setFromMatrixPosition(Fe.matrixWorld),he.setFromMatrixPosition(lt.matrixWorld);let Mt=ce.distanceTo(he),pt=Fe.projectionMatrix.elements,ke=lt.projectionMatrix.elements,Tn=pt[14]/(pt[10]-1),wt=pt[14]/(pt[10]+1),on=(pt[9]+1)/pt[5],Ce=(pt[9]-1)/pt[5],mt=(pt[8]-1)/pt[0],ht=(ke[8]+1)/ke[0],oe=Tn*mt,at=Tn*ht,Ye=Mt/(-mt+ht),_t=Ye*-mt;Fe.matrixWorld.decompose(Se.position,Se.quaternion,Se.scale),Se.translateX(_t),Se.translateZ(Ye),Se.matrixWorld.compose(Se.position,Se.quaternion,Se.scale),Se.matrixWorldInverse.copy(Se.matrixWorld).invert();let ut=Tn+Ye,an=wt+Ye;Se.projectionMatrix.makePerspective(oe-_t,at+(Mt-_t),on*wt/an*ut,Ce*wt/an*ut,ut,an)}(Q,I,B):Q.projectionMatrix.copy(I.projectionMatrix)},this.getCamera=function(){return Q},this.getFoveation=function(){return null!==u?u.fixedFoveation:null!==p?p.fixedFoveation:void 0},this.setFoveation=function(Se){null!==u&&(u.fixedFoveation=Se),null!==p&&void 0!==p.fixedFoveation&&(p.fixedFoveation=Se)};let de=null,Ge=new mte;Ge.setAnimationLoop(function(Se,Fe){if(c=Fe.getViewerPose(a),m=Fe,null!==c){let Mt=c.views;null!==p&&(t.setRenderTargetFramebuffer(y,p.framebuffer),t.setRenderTarget(y));let pt=!1;Mt.length!==Q.cameras.length&&(Q.cameras.length=0,pt=!0);for(let ke=0;ke<Mt.length;ke++){let Tn=Mt[ke],wt=null;if(null!==p)wt=p.getViewport(Tn);else{let Ce=d.getViewSubImage(u,Tn);wt=Ce.viewport,0===ke&&(t.setRenderTargetTextures(y,Ce.colorTexture,u.ignoreDepthValues?void 0:Ce.depthStencilTexture),t.setRenderTarget(y))}let on=ee[ke];on.matrix.fromArray(Tn.transform.matrix),on.projectionMatrix.fromArray(Tn.projectionMatrix),on.viewport.set(wt.x,wt.y,wt.width,wt.height),0===ke&&Q.matrix.copy(on.matrix),!0===pt&&Q.cameras.push(on)}}let lt=r.inputSources;for(let Mt=0;Mt<x.length;Mt++)x[Mt].update(lt[Mt],Fe,a);de&&de(Se,Fe),m=null}),this.setAnimationLoop=function(Se){de=Se},this.dispose=function(){}}};function D2e(n){function i(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let I,B,R=n.get(x).envMap;R&&(y.envMap.value=R,y.flipEnvMap.value=R.isCubeTexture&&!1===R.isRenderTargetTexture?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity),x.map?I=x.map:x.specularMap?I=x.specularMap:x.displacementMap?I=x.displacementMap:x.normalMap?I=x.normalMap:x.bumpMap?I=x.bumpMap:x.roughnessMap?I=x.roughnessMap:x.metalnessMap?I=x.metalnessMap:x.alphaMap?I=x.alphaMap:x.emissiveMap?I=x.emissiveMap:x.clearcoatMap?I=x.clearcoatMap:x.clearcoatNormalMap?I=x.clearcoatNormalMap:x.clearcoatRoughnessMap?I=x.clearcoatRoughnessMap:x.specularIntensityMap?I=x.specularIntensityMap:x.specularColorMap?I=x.specularColorMap:x.transmissionMap?I=x.transmissionMap:x.thicknessMap?I=x.thicknessMap:x.sheenColorMap?I=x.sheenColorMap:x.sheenRoughnessMap&&(I=x.sheenRoughnessMap),void 0!==I&&(I.isWebGLRenderTarget&&(I=I.texture),!0===I.matrixAutoUpdate&&I.updateMatrix(),y.uvTransform.value.copy(I.matrix)),x.aoMap?B=x.aoMap:x.lightMap&&(B=x.lightMap),void 0!==B&&(B.isWebGLRenderTarget&&(B=B.texture),!0===B.matrixAutoUpdate&&B.updateMatrix(),y.uv2Transform.value.copy(B.matrix))}function u(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===bo&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===bo&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),n.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}return{refreshFogUniforms:function(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)},refreshMaterialUniforms:function(y,x,R,I,B){x.isMeshBasicMaterial?i(y,x):x.isMeshLambertMaterial?(i(y,x),function(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}(y,x)):x.isMeshToonMaterial?(i(y,x),function(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===bo&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===bo&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshPhongMaterial?(i(y,x),function(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===bo&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===bo&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshStandardMaterial?(i(y,x),x.isMeshPhysicalMaterial?function(y,x,R){u(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===bo&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=R.texture,y.transmissionSamplerSize.value.set(R.width,R.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}(y,x,B):u(y,x)):x.isMeshMatcapMaterial?(i(y,x),function(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===bo&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===bo&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshDepthMaterial?(i(y,x),function(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isMeshDistanceMaterial?(i(y,x),function(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}(y,x)):x.isMeshNormalMaterial?(i(y,x),function(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===bo&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===bo&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}(y,x)):x.isLineBasicMaterial?(function(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}(y,x),x.isLineDashedMaterial&&function(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}(y,x)):x.isPointsMaterial?function(y,x,R,I){let B;y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*R,y.scale.value=.5*I,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest),x.map?B=x.map:x.alphaMap&&(B=x.alphaMap),void 0!==B&&(!0===B.matrixAutoUpdate&&B.updateMatrix(),y.uvTransform.value.copy(B.matrix))}(y,x,R,I):x.isSpriteMaterial?function(y,x){let R;y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest),x.map?R=x.map:x.alphaMap&&(R=x.alphaMap),void 0!==R&&(!0===R.matrixAutoUpdate&&R.updateMatrix(),y.uvTransform.value.copy(R.matrix))}(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}}}function Wi(n={}){let t=void 0!==n.canvas?n.canvas:function(){let n=Mx("canvas");return n.style.display="block",n}(),e=void 0!==n.context?n.context:null,i=void 0!==n.alpha&&n.alpha,r=void 0===n.depth||n.depth,o=void 0===n.stencil||n.stencil,a=void 0!==n.antialias&&n.antialias,s=void 0===n.premultipliedAlpha||n.premultipliedAlpha,l=void 0!==n.preserveDrawingBuffer&&n.preserveDrawingBuffer,c=void 0!==n.powerPreference?n.powerPreference:"default",d=void 0!==n.failIfMajorPerformanceCaveat&&n.failIfMajorPerformanceCaveat,u=null,p=null,h=[],m=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=wp,this.physicallyCorrectLights=!1,this.toneMapping=yp,this.toneMappingExposure=1;let _=this,M=!1,y=0,x=0,R=null,I=-1,B=null,ee=new Qi,Q=new Qi,we=null,Qe=t.width,Ae=t.height,D=1,re=null,ce=null,he=new Qi(0,0,Qe,Ae),_e=new Qi(0,0,Qe,Ae),$=!1,de=new e_,pe=!1,Ge=!1,Se=null,Fe=new vn,lt=new K,Mt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function pt(){return null===R?D:1}let wt,on,Ce,mt,ht,oe,at,Ye,_t,ut,an,yn,si,Ni,Li,Y,L,He,yt,en,Le,hn,ln,ke=e;function Tn(E,V){for(let X=0;X<E.length;X++){let ae=t.getContext(E[X],V);if(null!==ae)return ae}return null}try{let E={alpha:!0,depth:r,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:d};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${sV}`),t.addEventListener("webglcontextlost",Nn,!1),t.addEventListener("webglcontextrestored",se,!1),null===ke){let V=["webgl2","webgl","experimental-webgl"];if(!0===_.isWebGL1Renderer&&V.shift(),ke=Tn(V,E),null===ke)throw Tn(V)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===ke.getShaderPrecisionFormat&&(ke.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(E){throw console.error("THREE.WebGLRenderer: "+E.message),E}function Ft(){wt=new KOe(ke),on=new WOe(ke,wt,n),wt.init(on),hn=new E2e(ke,wt,on),Ce=new w2e(ke,wt,on),mt=new eFe(ke),ht=new h2e,oe=new S2e(ke,wt,Ce,ht,on,hn,mt),at=new XOe(_),Ye=new ZOe(_),_t=new fPe(ke,on),ln=new jOe(ke,wt,_t,on),ut=new JOe(ke,_t,mt,ln),an=new rFe(ke,ut,_t,mt),yt=new iFe(ke,on,oe),Y=new qOe(ht),yn=new p2e(_,at,Ye,wt,on,ln,Y),si=new D2e(ht),Ni=new f2e,Li=new x2e(wt,on),He=new UOe(_,at,Ce,an,i,s),L=new wte(_,an,on),en=new GOe(ke,wt,mt,on),Le=new $Oe(ke,wt,mt,on),mt.programs=yn.programs,_.capabilities=on,_.extensions=wt,_.properties=ht,_.renderLists=Ni,_.shadowMap=L,_.state=Ce,_.info=mt}Ft();let Ot=new oB(_,ke);function Nn(E){E.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),M=!0}function se(){console.log("THREE.WebGLRenderer: Context Restored."),M=!1;let E=mt.autoReset,V=L.enabled,X=L.autoUpdate,Z=L.needsUpdate,ae=L.type;Ft(),mt.autoReset=E,L.enabled=V,L.autoUpdate=X,L.needsUpdate=Z,L.type=ae}function Jt(E){let V=E.target;V.removeEventListener("dispose",Jt),function(E){(function(E){let V=ht.get(E).programs;void 0!==V&&(V.forEach(function(X){yn.releaseProgram(X)}),E.isShaderMaterial&&yn.releaseShaderCache(E))})(E),ht.remove(E)}(V)}this.xr=Ot,this.getContext=function(){return ke},this.getContextAttributes=function(){return ke.getContextAttributes()},this.forceContextLoss=function(){let E=wt.get("WEBGL_lose_context");E&&E.loseContext()},this.forceContextRestore=function(){let E=wt.get("WEBGL_lose_context");E&&E.restoreContext()},this.getPixelRatio=function(){return D},this.setPixelRatio=function(E){void 0!==E&&(D=E,this.setSize(Qe,Ae,!1))},this.getSize=function(E){return E.set(Qe,Ae)},this.setSize=function(E,V,X){Ot.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(Qe=E,Ae=V,t.width=Math.floor(E*D),t.height=Math.floor(V*D),!1!==X&&(t.style.width=E+"px",t.style.height=V+"px"),this.setViewport(0,0,E,V))},this.getDrawingBufferSize=function(E){return E.set(Qe*D,Ae*D).floor()},this.setDrawingBufferSize=function(E,V,X){Qe=E,Ae=V,D=X,t.width=Math.floor(E*X),t.height=Math.floor(V*X),this.setViewport(0,0,E,V)},this.getCurrentViewport=function(E){return E.copy(ee)},this.getViewport=function(E){return E.copy(he)},this.setViewport=function(E,V,X,Z){E.isVector4?he.set(E.x,E.y,E.z,E.w):he.set(E,V,X,Z),Ce.viewport(ee.copy(he).multiplyScalar(D).floor())},this.getScissor=function(E){return E.copy(_e)},this.setScissor=function(E,V,X,Z){E.isVector4?_e.set(E.x,E.y,E.z,E.w):_e.set(E,V,X,Z),Ce.scissor(Q.copy(_e).multiplyScalar(D).floor())},this.getScissorTest=function(){return $},this.setScissorTest=function(E){Ce.setScissorTest($=E)},this.setOpaqueSort=function(E){re=E},this.setTransparentSort=function(E){ce=E},this.getClearColor=function(E){return E.copy(He.getClearColor())},this.setClearColor=function(){He.setClearColor.apply(He,arguments)},this.getClearAlpha=function(){return He.getClearAlpha()},this.setClearAlpha=function(){He.setClearAlpha.apply(He,arguments)},this.clear=function(E,V,X){let Z=0;(void 0===E||E)&&(Z|=16384),(void 0===V||V)&&(Z|=256),(void 0===X||X)&&(Z|=1024),ke.clear(Z)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",Nn,!1),t.removeEventListener("webglcontextrestored",se,!1),Ni.dispose(),Li.dispose(),ht.dispose(),at.dispose(),Ye.dispose(),an.dispose(),ln.dispose(),yn.dispose(),Ot.dispose(),Ot.removeEventListener("sessionstart",fi),Ot.removeEventListener("sessionend",lr),Se&&(Se.dispose(),Se=null),Wo.stop()},this.renderBufferDirect=function(E,V,X,Z,ae,ze){null===V&&(V=Mt);let et=ae.isMesh&&ae.matrixWorld.determinant()<0,qe=function(E,V,X,Z,ae){!0!==V.isScene&&(V=Mt),oe.resetTextureUnits();let ze=V.fog,qe=null===R?_.outputEncoding:!0===R.isXRRenderTarget?R.texture.encoding:wp,rt=(Z.isMeshStandardMaterial?Ye:at).get(Z.envMap||(Z.isMeshStandardMaterial?V.environment:null)),dt=!0===Z.vertexColors&&!!X.attributes.color&&4===X.attributes.color.itemSize,St=!!Z.normalMap&&!!X.attributes.tangent,At=!!X.morphAttributes.position,cn=!!X.morphAttributes.normal,qi=X.morphAttributes.position?X.morphAttributes.position.length:0,yi=Z.toneMapped?_.toneMapping:yp,pn=ht.get(Z),Rn=p.state.lights;!0!==pe||!0!==Ge&&E===B||Y.setState(Z,E,E===B&&Z.id===I);let Et=!1;Z.version===pn.__version?(pn.needsLights&&pn.lightsStateVersion!==Rn.state.version||pn.outputEncoding!==qe||ae.isInstancedMesh&&!1===pn.instancing||!ae.isInstancedMesh&&!0===pn.instancing||ae.isSkinnedMesh&&!1===pn.skinning||!ae.isSkinnedMesh&&!0===pn.skinning||pn.envMap!==rt||Z.fog&&pn.fog!==ze||void 0!==pn.numClippingPlanes&&(pn.numClippingPlanes!==Y.numPlanes||pn.numIntersection!==Y.numIntersection)||pn.vertexAlphas!==dt||pn.vertexTangents!==St||pn.morphTargets!==At||pn.morphNormals!==cn||pn.toneMapping!==yi||!0===on.isWebGL2&&pn.morphTargetsCount!==qi)&&(Et=!0):(Et=!0,pn.__version=Z.version);let gi=pn.currentProgram;!0===Et&&(gi=S_(Z,V,ae));let ti=!1,Hn=!1,Qn=!1,zt=gi.getUniforms(),Bi=pn.uniforms;if(Ce.useProgram(gi.program)&&(ti=!0,Hn=!0,Qn=!0),Z.id!==I&&(I=Z.id,Hn=!0),ti||B!==E){if(zt.setValue(ke,"projectionMatrix",E.projectionMatrix),on.logarithmicDepthBuffer&&zt.setValue(ke,"logDepthBufFC",2/(Math.log(E.far+1)/Math.LN2)),B!==E&&(B=E,Hn=!0,Qn=!0),Z.isShaderMaterial||Z.isMeshPhongMaterial||Z.isMeshToonMaterial||Z.isMeshStandardMaterial||Z.envMap){let _n=zt.map.cameraPosition;void 0!==_n&&_n.setValue(ke,lt.setFromMatrixPosition(E.matrixWorld))}(Z.isMeshPhongMaterial||Z.isMeshToonMaterial||Z.isMeshLambertMaterial||Z.isMeshBasicMaterial||Z.isMeshStandardMaterial||Z.isShaderMaterial)&&zt.setValue(ke,"isOrthographic",!0===E.isOrthographicCamera),(Z.isMeshPhongMaterial||Z.isMeshToonMaterial||Z.isMeshLambertMaterial||Z.isMeshBasicMaterial||Z.isMeshStandardMaterial||Z.isShaderMaterial||Z.isShadowMaterial||ae.isSkinnedMesh)&&zt.setValue(ke,"viewMatrix",E.matrixWorldInverse)}if(ae.isSkinnedMesh){zt.setOptional(ke,ae,"bindMatrix"),zt.setOptional(ke,ae,"bindMatrixInverse");let _n=ae.skeleton;_n&&(on.floatVertexTextures?(null===_n.boneTexture&&_n.computeBoneTexture(),zt.setValue(ke,"boneTexture",_n.boneTexture,oe),zt.setValue(ke,"boneTextureSize",_n.boneTextureSize)):zt.setOptional(ke,_n,"boneMatrices"))}return!!X&&(void 0!==X.morphAttributes.position||void 0!==X.morphAttributes.normal)&&yt.update(ae,X,Z,gi),(Hn||pn.receiveShadow!==ae.receiveShadow)&&(pn.receiveShadow=ae.receiveShadow,zt.setValue(ke,"receiveShadow",ae.receiveShadow)),Hn&&(zt.setValue(ke,"toneMappingExposure",_.toneMappingExposure),pn.needsLights&&function(E,V){E.ambientLightColor.needsUpdate=V,E.lightProbe.needsUpdate=V,E.directionalLights.needsUpdate=V,E.directionalLightShadows.needsUpdate=V,E.pointLights.needsUpdate=V,E.pointLightShadows.needsUpdate=V,E.spotLights.needsUpdate=V,E.spotLightShadows.needsUpdate=V,E.rectAreaLights.needsUpdate=V,E.hemisphereLights.needsUpdate=V}(Bi,Qn),ze&&Z.fog&&si.refreshFogUniforms(Bi,ze),si.refreshMaterialUniforms(Bi,Z,D,Ae,Se),Mp.upload(ke,pn.uniformsList,Bi,oe)),Z.isShaderMaterial&&!0===Z.uniformsNeedUpdate&&(Mp.upload(ke,pn.uniformsList,Bi,oe),Z.uniformsNeedUpdate=!1),Z.isSpriteMaterial&&zt.setValue(ke,"center",ae.center),zt.setValue(ke,"modelViewMatrix",ae.modelViewMatrix),zt.setValue(ke,"normalMatrix",ae.normalMatrix),zt.setValue(ke,"modelMatrix",ae.matrixWorld),gi}(E,V,X,Z,ae);Ce.setMaterial(Z,et);let rt=X.index,dt=X.attributes.position;if(null===rt){if(void 0===dt||0===dt.count)return}else if(0===rt.count)return;let St=1;!0===Z.wireframe&&(rt=ut.getWireframeAttribute(X),St=2),ln.setup(ae,Z,qe,X,rt);let At,cn=en;null!==rt&&(At=_t.get(rt),cn=Le,cn.setIndex(At));let qi=null!==rt?rt.count:dt.count,yi=X.drawRange.start*St,pn=X.drawRange.count*St,Rn=null!==ze?ze.start*St:0,Et=null!==ze?ze.count*St:1/0,gi=Math.max(yi,Rn),ti=Math.min(qi,yi+pn,Rn+Et)-1,Hn=Math.max(0,ti-gi+1);if(0!==Hn){if(ae.isMesh)!0===Z.wireframe?(Ce.setLineWidth(Z.wireframeLinewidth*pt()),cn.setMode(1)):cn.setMode(4);else if(ae.isLine){let Qn=Z.linewidth;void 0===Qn&&(Qn=1),Ce.setLineWidth(Qn*pt()),cn.setMode(ae.isLineSegments?1:ae.isLineLoop?2:3)}else ae.isPoints?cn.setMode(0):ae.isSprite&&cn.setMode(4);if(ae.isInstancedMesh)cn.renderInstances(gi,Hn,ae.count);else if(X.isInstancedBufferGeometry){let Qn=Math.min(X.instanceCount,X._maxInstanceCount);cn.renderInstances(gi,Hn,Qn)}else cn.render(gi,Hn)}},this.compile=function(E,V){p=Li.get(E),p.init(),m.push(p),E.traverseVisible(function(X){X.isLight&&X.layers.test(V.layers)&&(p.pushLight(X),X.castShadow&&p.pushShadow(X))}),p.setupLights(_.physicallyCorrectLights),E.traverse(function(X){let Z=X.material;if(Z)if(Array.isArray(Z))for(let ae=0;ae<Z.length;ae++)S_(Z[ae],E,X);else S_(Z,E,X)}),m.pop(),p=null};let We=null;function fi(){Wo.stop()}function lr(){Wo.start()}let Wo=new mte;function vr(E,V,X,Z){if(!1===E.visible)return;if(E.layers.test(V.layers))if(E.isGroup)X=E.renderOrder;else if(E.isLOD)!0===E.autoUpdate&&E.update(V);else if(E.isLight)p.pushLight(E),E.castShadow&&p.pushShadow(E);else if(E.isSprite){if(!E.frustumCulled||de.intersectsSprite(E)){Z&&lt.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Fe);let et=an.update(E),qe=E.material;qe.visible&&u.push(E,et,qe,X,lt.z,null)}}else if((E.isMesh||E.isLine||E.isPoints)&&(E.isSkinnedMesh&&E.skeleton.frame!==mt.render.frame&&(E.skeleton.update(),E.skeleton.frame=mt.render.frame),!E.frustumCulled||de.intersectsObject(E))){Z&&lt.setFromMatrixPosition(E.matrixWorld).applyMatrix4(Fe);let et=an.update(E),qe=E.material;if(Array.isArray(qe)){let rt=et.groups;for(let dt=0,St=rt.length;dt<St;dt++){let At=rt[dt],cn=qe[At.materialIndex];cn&&cn.visible&&u.push(E,et,cn,X,lt.z,At)}}else qe.visible&&u.push(E,et,qe,X,lt.z,null)}let ze=E.children;for(let et=0,qe=ze.length;et<qe;et++)vr(ze[et],V,X,Z)}function Is(E,V,X,Z){let ae=E.opaque,ze=E.transmissive,et=E.transparent;p.setupLightsView(X),ze.length>0&&function(E,V,X){null===Se&&(Se=new(!0===a&&!0===on.isWebGL2?wx:ts)(1024,1024,{generateMipmaps:!0,type:null!==hn.convert(q0)?q0:xp,minFilter:$I,magFilter:vo,wrapS:Es,wrapT:Es,useRenderToTexture:wt.has("WEBGL_multisampled_render_to_texture")}));let Z=_.getRenderTarget();_.setRenderTarget(Se),_.clear();let ae=_.toneMapping;_.toneMapping=yp,pl(E,V,X),_.toneMapping=ae,oe.updateMultisampleRenderTarget(Se),oe.updateRenderTargetMipmap(Se),_.setRenderTarget(Z)}(ae,V,X),Z&&Ce.viewport(ee.copy(Z)),ae.length>0&&pl(ae,V,X),ze.length>0&&pl(ze,V,X),et.length>0&&pl(et,V,X)}function pl(E,V,X){let Z=!0===V.isScene?V.overrideMaterial:null;for(let ae=0,ze=E.length;ae<ze;ae++){let et=E[ae],qe=et.object,rt=et.geometry,dt=null===Z?et.material:Z,St=et.group;qe.layers.test(X.layers)&&kA(qe,V,X,rt,dt,St)}}function kA(E,V,X,Z,ae,ze){E.onBeforeRender(_,V,X,Z,ae,ze),E.modelViewMatrix.multiplyMatrices(X.matrixWorldInverse,E.matrixWorld),E.normalMatrix.getNormalMatrix(E.modelViewMatrix),ae.onBeforeRender(_,V,X,Z,E,ze),!0===ae.transparent&&ae.side===Z0?(ae.side=bo,ae.needsUpdate=!0,_.renderBufferDirect(X,V,Z,ae,E,ze),ae.side=yx,ae.needsUpdate=!0,_.renderBufferDirect(X,V,Z,ae,E,ze),ae.side=Z0):_.renderBufferDirect(X,V,Z,ae,E,ze),E.onAfterRender(_,V,X,Z,ae,ze)}function S_(E,V,X){!0!==V.isScene&&(V=Mt);let Z=ht.get(E),ae=p.state.lights,et=ae.state.version,qe=yn.getParameters(E,ae.state,p.state.shadowsArray,V,X),rt=yn.getProgramCacheKey(qe),dt=Z.programs;Z.environment=E.isMeshStandardMaterial?V.environment:null,Z.fog=V.fog,Z.envMap=(E.isMeshStandardMaterial?Ye:at).get(E.envMap||Z.environment),void 0===dt&&(E.addEventListener("dispose",Jt),dt=new Map,Z.programs=dt);let St=dt.get(rt);if(void 0!==St){if(Z.currentProgram===St&&Z.lightsStateVersion===et)return tC(E,qe),St}else qe.uniforms=yn.getUniforms(E),E.onBuild(X,qe,_),E.onBeforeCompile(qe,_),St=yn.acquireProgram(qe,rt),dt.set(rt,St),Z.uniforms=qe.uniforms;let At=Z.uniforms;(!E.isShaderMaterial&&!E.isRawShaderMaterial||!0===E.clipping)&&(At.clippingPlanes=Y.uniform),tC(E,qe),Z.needsLights=function(E){return E.isMeshLambertMaterial||E.isMeshToonMaterial||E.isMeshPhongMaterial||E.isMeshStandardMaterial||E.isShadowMaterial||E.isShaderMaterial&&!0===E.lights}(E),Z.lightsStateVersion=et,Z.needsLights&&(At.ambientLightColor.value=ae.state.ambient,At.lightProbe.value=ae.state.probe,At.directionalLights.value=ae.state.directional,At.directionalLightShadows.value=ae.state.directionalShadow,At.spotLights.value=ae.state.spot,At.spotLightShadows.value=ae.state.spotShadow,At.rectAreaLights.value=ae.state.rectArea,At.ltc_1.value=ae.state.rectAreaLTC1,At.ltc_2.value=ae.state.rectAreaLTC2,At.pointLights.value=ae.state.point,At.pointLightShadows.value=ae.state.pointShadow,At.hemisphereLights.value=ae.state.hemi,At.directionalShadowMap.value=ae.state.directionalShadowMap,At.directionalShadowMatrix.value=ae.state.directionalShadowMatrix,At.spotShadowMap.value=ae.state.spotShadowMap,At.spotShadowMatrix.value=ae.state.spotShadowMatrix,At.pointShadowMap.value=ae.state.pointShadowMap,At.pointShadowMatrix.value=ae.state.pointShadowMatrix);let cn=St.getUniforms(),qi=Mp.seqWithValue(cn.seq,At);return Z.currentProgram=St,Z.uniformsList=qi,St}function tC(E,V){let X=ht.get(E);X.outputEncoding=V.outputEncoding,X.instancing=V.instancing,X.skinning=V.skinning,X.morphTargets=V.morphTargets,X.morphNormals=V.morphNormals,X.morphTargetsCount=V.morphTargetsCount,X.numClippingPlanes=V.numClippingPlanes,X.numIntersection=V.numClipIntersection,X.vertexAlphas=V.vertexAlphas,X.vertexTangents=V.vertexTangents,X.toneMapping=V.toneMapping}Wo.setAnimationLoop(function(E){We&&We(E)}),typeof window<"u"&&Wo.setContext(window),this.setAnimationLoop=function(E){We=E,Ot.setAnimationLoop(E),null===E?Wo.stop():Wo.start()},Ot.addEventListener("sessionstart",fi),Ot.addEventListener("sessionend",lr),this.render=function(E,V){if(void 0===V||!0===V.isCamera){if(!0!==M){if(!0===E.autoUpdate&&E.updateMatrixWorld(),null===V.parent&&V.updateMatrixWorld(),!0===Ot.enabled&&!0===Ot.isPresenting&&(!0===Ot.cameraAutoUpdate&&Ot.updateCamera(V),V=Ot.getCamera()),!0===E.isScene&&E.onBeforeRender(_,E,V,R),p=Li.get(E,m.length),p.init(),m.push(p),Fe.multiplyMatrices(V.projectionMatrix,V.matrixWorldInverse),de.setFromProjectionMatrix(Fe),Ge=this.localClippingEnabled,pe=Y.init(this.clippingPlanes,Ge,V),u=Ni.get(E,h.length),u.init(),h.push(u),vr(E,V,0,_.sortObjects),u.finish(),!0===_.sortObjects&&u.sort(re,ce),!0===pe&&Y.beginShadows(),L.render(p.state.shadowsArray,E,V),!0===pe&&Y.endShadows(),!0===this.info.autoReset&&this.info.reset(),He.render(u,E),p.setupLights(_.physicallyCorrectLights),V.isArrayCamera){let Z=V.cameras;for(let ae=0,ze=Z.length;ae<ze;ae++){let et=Z[ae];Is(u,E,et,et.viewport)}}else Is(u,E,V);null!==R&&(oe.updateMultisampleRenderTarget(R),oe.updateRenderTargetMipmap(R)),!0===E.isScene&&E.onAfterRender(_,E,V),Ce.buffers.depth.setTest(!0),Ce.buffers.depth.setMask(!0),Ce.buffers.color.setMask(!0),Ce.setPolygonOffset(!1),ln.resetDefaultState(),I=-1,B=null,m.pop(),p=m.length>0?m[m.length-1]:null,h.pop(),u=h.length>0?h[h.length-1]:null}}else console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")},this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return R},this.setRenderTargetTextures=function(E,V,X){ht.get(E.texture).__webglTexture=V,ht.get(E.depthTexture).__webglTexture=X;let Z=ht.get(E);Z.__hasExternalTextures=!0,Z.__hasExternalTextures&&(Z.__autoAllocateDepthBuffer=void 0===X,Z.__autoAllocateDepthBuffer||E.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),E.useRenderToTexture=!1,E.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(E,V){let X=ht.get(E);X.__webglFramebuffer=V,X.__useDefaultFramebuffer=void 0===V},this.setRenderTarget=function(E,V=0,X=0){R=E,y=V,x=X;let Z=!0;if(E){let rt=ht.get(E);void 0!==rt.__useDefaultFramebuffer?(Ce.bindFramebuffer(36160,null),Z=!1):void 0===rt.__webglFramebuffer?oe.setupRenderTarget(E):rt.__hasExternalTextures&&oe.rebindTextures(E,ht.get(E.texture).__webglTexture,ht.get(E.depthTexture).__webglTexture)}let ae=null,ze=!1,et=!1;if(E){let rt=E.texture;(rt.isDataTexture3D||rt.isDataTexture2DArray)&&(et=!0);let dt=ht.get(E).__webglFramebuffer;E.isWebGLCubeRenderTarget?(ae=dt[V],ze=!0):ae=E.useRenderbuffer?ht.get(E).__webglMultisampledFramebuffer:dt,ee.copy(E.viewport),Q.copy(E.scissor),we=E.scissorTest}else ee.copy(he).multiplyScalar(D).floor(),Q.copy(_e).multiplyScalar(D).floor(),we=$;if(Ce.bindFramebuffer(36160,ae)&&on.drawBuffers&&Z&&Ce.drawBuffers(E,ae),Ce.viewport(ee),Ce.scissor(Q),Ce.setScissorTest(we),ze){let rt=ht.get(E.texture);ke.framebufferTexture2D(36160,36064,34069+V,rt.__webglTexture,X)}else if(et){let rt=ht.get(E.texture);ke.framebufferTextureLayer(36160,36064,rt.__webglTexture,X||0,V||0)}I=-1},this.readRenderTargetPixels=function(E,V,X,Z,ae,ze,et){if(!E||!E.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let qe=ht.get(E).__webglFramebuffer;if(E.isWebGLCubeRenderTarget&&void 0!==et&&(qe=qe[et]),qe){Ce.bindFramebuffer(36160,qe);try{let rt=E.texture,dt=rt.format,St=rt.type;if(dt!==Ca&&hn.convert(dt)!==ke.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");let At=St===q0&&(wt.has("EXT_color_buffer_half_float")||on.isWebGL2&&wt.has("EXT_color_buffer_float"));if(!(St===xp||hn.convert(St)===ke.getParameter(35738)||St===gm&&(on.isWebGL2||wt.has("OES_texture_float")||wt.has("WEBGL_color_buffer_float"))||At))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===ke.checkFramebufferStatus(36160)?V>=0&&V<=E.width-Z&&X>=0&&X<=E.height-ae&&ke.readPixels(V,X,Z,ae,hn.convert(dt),hn.convert(St),ze):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let rt=null!==R?ht.get(R).__webglFramebuffer:null;Ce.bindFramebuffer(36160,rt)}}},this.copyFramebufferToTexture=function(E,V,X=0){if(!0!==V.isFramebufferTexture)return void console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");let Z=Math.pow(2,-X),ae=Math.floor(V.image.width*Z),ze=Math.floor(V.image.height*Z);oe.setTexture2D(V,0),ke.copyTexSubImage2D(3553,X,0,0,E.x,E.y,ae,ze),Ce.unbindTexture()},this.copyTextureToTexture=function(E,V,X,Z=0){let ae=V.image.width,ze=V.image.height,et=hn.convert(X.format),qe=hn.convert(X.type);oe.setTexture2D(X,0),ke.pixelStorei(37440,X.flipY),ke.pixelStorei(37441,X.premultiplyAlpha),ke.pixelStorei(3317,X.unpackAlignment),V.isDataTexture?ke.texSubImage2D(3553,Z,E.x,E.y,ae,ze,et,qe,V.image.data):V.isCompressedTexture?ke.compressedTexSubImage2D(3553,Z,E.x,E.y,V.mipmaps[0].width,V.mipmaps[0].height,et,V.mipmaps[0].data):ke.texSubImage2D(3553,Z,E.x,E.y,et,qe,V.image),0===Z&&X.generateMipmaps&&ke.generateMipmap(3553),Ce.unbindTexture()},this.copyTextureToTexture3D=function(E,V,X,Z,ae=0){if(_.isWebGL1Renderer)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");let St,ze=E.max.x-E.min.x+1,et=E.max.y-E.min.y+1,qe=E.max.z-E.min.z+1,rt=hn.convert(Z.format),dt=hn.convert(Z.type);if(Z.isDataTexture3D)oe.setTexture3D(Z,0),St=32879;else{if(!Z.isDataTexture2DArray)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");oe.setTexture2DArray(Z,0),St=35866}ke.pixelStorei(37440,Z.flipY),ke.pixelStorei(37441,Z.premultiplyAlpha),ke.pixelStorei(3317,Z.unpackAlignment);let At=ke.getParameter(3314),cn=ke.getParameter(32878),qi=ke.getParameter(3316),yi=ke.getParameter(3315),pn=ke.getParameter(32877),Rn=X.isCompressedTexture?X.mipmaps[0]:X.image;ke.pixelStorei(3314,Rn.width),ke.pixelStorei(32878,Rn.height),ke.pixelStorei(3316,E.min.x),ke.pixelStorei(3315,E.min.y),ke.pixelStorei(32877,E.min.z),X.isDataTexture||X.isDataTexture3D?ke.texSubImage3D(St,ae,V.x,V.y,V.z,ze,et,qe,rt,dt,Rn.data):X.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),ke.compressedTexSubImage3D(St,ae,V.x,V.y,V.z,ze,et,qe,rt,Rn.data)):ke.texSubImage3D(St,ae,V.x,V.y,V.z,ze,et,qe,rt,dt,Rn),ke.pixelStorei(3314,At),ke.pixelStorei(32878,cn),ke.pixelStorei(3316,qi),ke.pixelStorei(3315,yi),ke.pixelStorei(32877,pn),0===ae&&Z.generateMipmaps&&ke.generateMipmap(St),Ce.unbindTexture()},this.initTexture=function(E){oe.setTexture2D(E,0),Ce.unbindTexture()},this.resetState=function(){y=0,x=0,R=null,Ce.reset(),ln.reset()},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}Wi.prototype.isWebGLRenderer=!0,class extends Wi{}.prototype.isWebGL1Renderer=!0;var Ax=class{constructor(t,e=25e-5){this.name="",this.color=new sn(t),this.density=e}clone(){return new Ax(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};Ax.prototype.isFogExp2=!0;var Rx=class{constructor(t,e=1,i=1e3){this.name="",this.color=new sn(t),this.near=e,this.far=i}clone(){return new Rx(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};Rx.prototype.isFog=!0;var n_=class extends Ui{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return null!==this.fog&&(e.object.fog=this.fog.toJSON()),e}};n_.prototype.isScene=!0;var Cm=class{constructor(t,e){this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=Cx,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Yl()}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,o=this.stride;r<o;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Yl()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=Yl()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Cm.prototype.isInterleavedBuffer=!0;var Qr=new K,Mm=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=!0===r}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)Qr.x=this.getX(e),Qr.y=this.getY(e),Qr.z=this.getZ(e),Qr.applyMatrix4(t),this.setXYZ(e,Qr.x,Qr.y,Qr.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Qr.x=this.getX(e),Qr.y=this.getY(e),Qr.z=this.getZ(e),Qr.applyNormalMatrix(t),this.setXYZ(e,Qr.x,Qr.y,Qr.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Qr.x=this.getX(e),Qr.y=this.getY(e),Qr.z=this.getZ(e),Qr.transformDirection(t),this.setXYZ(e,Qr.x,Qr.y,Qr.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=o,this}clone(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return new Ar(new this.array.constructor(e),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Mm(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Mm.prototype.isInterleavedBufferAttribute=!0;var FI=class extends Fo{constructor(t){super(),this.type="SpriteMaterial",this.color=new sn(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};FI.prototype.isSpriteMaterial=!0;var B0,cx=new K,V0=new K,H0=new K,z0=new $e,dx=new $e,Ste=new vn,lI=new K,ux=new K,cI=new K,Nee=new $e,H3=new $e,Lee=new $e;function dI(n,t,e,i,r,o){z0.subVectors(n,e).addScalar(.5).multiply(i),void 0!==r?(dx.x=o*z0.x-r*z0.y,dx.y=r*z0.x+o*z0.y):dx.copy(z0),n.copy(t),n.x+=dx.x,n.y+=dx.y,n.applyMatrix4(Ste)}(class extends Ui{constructor(t){if(super(),this.type="Sprite",void 0===B0){B0=new Gi;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Cm(e,5);B0.setIndex([0,1,2,0,2,3]),B0.setAttribute("position",new Mm(i,3,0,!1)),B0.setAttribute("uv",new Mm(i,2,3,!1))}this.geometry=B0,this.material=void 0!==t?t:new FI,this.center=new $e(.5,.5)}raycast(t,e){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),V0.setFromMatrixScale(this.matrixWorld),Ste.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),H0.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&V0.multiplyScalar(-H0.z);let r,o,i=this.material.rotation;0!==i&&(o=Math.cos(i),r=Math.sin(i));let a=this.center;dI(lI.set(-.5,-.5,0),H0,a,V0,r,o),dI(ux.set(.5,-.5,0),H0,a,V0,r,o),dI(cI.set(.5,.5,0),H0,a,V0,r,o),Nee.set(0,0),H3.set(1,0),Lee.set(1,1);let s=t.ray.intersectTriangle(lI,ux,cI,!1,cx);if(null===s&&(dI(ux.set(-.5,.5,0),H0,a,V0,r,o),H3.set(0,1),s=t.ray.intersectTriangle(lI,cI,ux,!1,cx),null===s))return;let l=t.ray.origin.distanceTo(cx);l<t.near||l>t.far||e.push({distance:l,point:cx.clone(),uv:Vr.getUV(cx,lI,ux,cI,Nee,H3,Lee,new $e),face:null,object:this})}copy(t){return super.copy(t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}).prototype.isSprite=!0;var Bee=new K,Vee=new Qi,Hee=new Qi,A2e=new K,zee=new vn,NI=class extends so{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new vn,this.bindMatrixInverse=new vn}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,void 0===e&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Qi,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;Vee.fromBufferAttribute(r.attributes.skinIndex,t),Hee.fromBufferAttribute(r.attributes.skinWeight,t),Bee.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let o=0;o<4;o++){let a=Hee.getComponent(o);if(0!==a){let s=Vee.getComponent(o);zee.multiplyMatrices(i.bones[s].matrixWorld,i.boneInverses[s]),e.addScaledVector(A2e.copy(Bee).applyMatrix4(zee),a)}}return e.applyMatrix4(this.bindMatrixInverse)}};NI.prototype.isSkinnedMesh=!0,class extends Ui{constructor(){super(),this.type="Bone"}}.prototype.isBone=!0,class extends lo{constructor(t=null,e=1,i=1,r,o,a,s,l,c=vo,d=vo,u,p){super(null,a,s,l,c,d,r,o,u,p),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=d,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}}.prototype.isDataTexture=!0;var Px=class extends Ar{constructor(t,e,i,r=1){"number"==typeof i&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};Px.prototype.isInstancedBufferAttribute=!0;var Uee=new vn,jee=new vn,uI=[],px=new so;(class extends so{constructor(t,e,i){super(t,e),this.instanceMatrix=new Px(new Float32Array(16*i),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,3*t)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,16*t)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(px.geometry=this.geometry,px.material=this.material,void 0!==px.material)for(let o=0;o<r;o++){this.getMatrixAt(o,Uee),jee.multiplyMatrices(i,Uee),px.matrixWorld=jee,px.raycast(t,uI);for(let a=0,s=uI.length;a<s;a++){let l=uI[a];l.instanceId=o,l.object=this,e.push(l)}uI.length=0}}setColorAt(t,e){null===this.instanceColor&&(this.instanceColor=new Px(new Float32Array(3*this.instanceMatrix.count),3)),e.toArray(this.instanceColor.array,3*t)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,16*t)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}}).prototype.isInstancedMesh=!0;var Gd=class extends Fo{constructor(t){super(),this.type="LineBasicMaterial",this.color=new sn(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Gd.prototype.isLineBasicMaterial=!0;var Gee=new K,Wee=new K,qee=new vn,z3=new Ep,pI=new Sp,kx=class extends Ui{constructor(t=new Gi,e=new Gd){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[0];for(let r=1,o=e.count;r<o;r++)Gee.fromBufferAttribute(e,r-1),Wee.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=Gee.distanceTo(Wee);t.setAttribute("lineDistance",new Nr(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Line.threshold,a=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),pI.copy(i.boundingSphere),pI.applyMatrix4(r),pI.radius+=o,!1===t.ray.intersectsSphere(pI))return;qee.copy(r).invert(),z3.copy(t.ray).applyMatrix4(qee);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new K,d=new K,u=new K,p=new K,h=this.isLineSegments?2:1;if(i.isBufferGeometry){let m=i.index,M=i.attributes.position;if(null!==m)for(let R=Math.max(0,a.start),I=Math.min(m.count,a.start+a.count)-1;R<I;R+=h){let B=m.getX(R),ee=m.getX(R+1);if(c.fromBufferAttribute(M,B),d.fromBufferAttribute(M,ee),z3.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let we=t.ray.origin.distanceTo(p);we<t.near||we>t.far||e.push({distance:we,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}else for(let R=Math.max(0,a.start),I=Math.min(M.count,a.start+a.count)-1;R<I;R+=h){if(c.fromBufferAttribute(M,R),d.fromBufferAttribute(M,R+1),z3.distanceSqToSegment(c,d,p,u)>l)continue;p.applyMatrix4(this.matrixWorld);let ee=t.ray.origin.distanceTo(p);ee<t.near||ee>t.far||e.push({distance:ee,point:u.clone().applyMatrix4(this.matrixWorld),index:R,face:null,faceIndex:null,object:this})}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};kx.prototype.isLine=!0;var Xee=new K,Yee=new K,Ox=class extends kx{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[];for(let r=0,o=e.count;r<o;r+=2)Xee.fromBufferAttribute(e,r),Yee.fromBufferAttribute(e,r+1),i[r]=0===r?0:i[r-1],i[r+1]=i[r]+Xee.distanceTo(Yee);t.setAttribute("lineDistance",new Nr(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Ox.prototype.isLineSegments=!0,class extends kx{constructor(t,e){super(t,e),this.type="LineLoop"}}.prototype.isLineLoop=!0;var LI=class extends Fo{constructor(t){super(),this.type="PointsMaterial",this.color=new sn(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};LI.prototype.isPointsMaterial=!0;var Qee=new vn,pB=new Ep,hI=new Sp,mI=new K;function Zee(n,t,e,i,r,o,a){let s=pB.distanceSqToPoint(n);if(s<e){let l=new K;pB.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}(class extends Ui{constructor(t=new Gi,e=new LI){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Points.threshold,a=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),hI.copy(i.boundingSphere),hI.applyMatrix4(r),hI.radius+=o,!1===t.ray.intersectsSphere(hI))return;Qee.copy(r).invert(),pB.copy(t.ray).applyMatrix4(Qee);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(i.isBufferGeometry){let c=i.index,u=i.attributes.position;if(null!==c)for(let m=Math.max(0,a.start),_=Math.min(c.count,a.start+a.count);m<_;m++){let M=c.getX(m);mI.fromBufferAttribute(u,M),Zee(mI,M,l,r,t,e,this)}else for(let m=Math.max(0,a.start),_=Math.min(u.count,a.start+a.count);m<_;m++)mI.fromBufferAttribute(u,m),Zee(mI,m,l,r,t,e,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=r.length;o<a;o++){let s=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}).prototype.isPoints=!0,class extends lo{constructor(t,e,i,r,o,a,s,l,c){super(t,e,i,r,o,a,s,l,c),this.minFilter=void 0!==a?a:ia,this.magFilter=void 0!==o?o:ia,this.generateMipmaps=!1;let d=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(function u(){d.needsUpdate=!0,t.requestVideoFrameCallback(u)})}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t==0&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}.prototype.isVideoTexture=!0,class extends lo{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=vo,this.minFilter=vo,this.generateMipmaps=!1,this.needsUpdate=!0}}.prototype.isFramebufferTexture=!0,class extends lo{constructor(t,e,i,r,o,a,s,l,c,d,u,p){super(null,a,s,l,c,d,r,o,u,p),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}.prototype.isCompressedTexture=!0,class extends lo{constructor(t,e,i,r,o,a,s,l,c){super(t,e,i,r,o,a,s,l,c),this.needsUpdate=!0}}.prototype.isCanvasTexture=!0;var i_=class extends Gi{constructor(t=1,e=8,i=0,r=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let o=[],a=[],s=[],l=[],c=new K,d=new $e;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let u=0,p=3;u<=e;u++,p+=3){let h=i+u/e*r;c.x=t*Math.cos(h),c.y=t*Math.sin(h),a.push(c.x,c.y,c.z),s.push(0,0,1),d.x=(a[p]/t+1)/2,d.y=(a[p+1]/t+1)/2,l.push(d.x,d.y)}for(let u=1;u<=e;u++)o.push(u,u+1,0);this.setIndex(o),this.setAttribute("position",new Nr(a,3)),this.setAttribute("normal",new Nr(s,3)),this.setAttribute("uv",new Nr(l,2))}static fromJSON(t){return new i_(t.radius,t.segments,t.thetaStart,t.thetaLength)}},ns=(new K,new K,new K,new Vr,class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let i,e=[],r=this.getPoint(0),o=0;e.push(0);for(let a=1;a<=t;a++)i=this.getPoint(a/t),o+=i.distanceTo(r),e.push(o),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let a,i=this.getLengths(),r=0,o=i.length;a=e||t*i[o-1];let c,s=0,l=o-1;for(;s<=l;)if(r=Math.floor(s+(l-s)/2),c=i[r]-a,c<0)s=r+1;else{if(!(c>0)){l=r;break}l=r-1}if(r=l,i[r]===a)return r/(o-1);let d=i[r];return(r+(a-d)/(i[r+1]-d))/(o-1)}getTangent(t,e){let r=t-1e-4,o=t+1e-4;r<0&&(r=0),o>1&&(o=1);let a=this.getPoint(r),s=this.getPoint(o),l=e||(a.isVector2?new $e:new K);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new K,r=[],o=[],a=[],s=new K,l=new vn;for(let h=0;h<=t;h++)r[h]=this.getTangentAt(h/t,new K);o[0]=new K,a[0]=new K;let c=Number.MAX_VALUE,d=Math.abs(r[0].x),u=Math.abs(r[0].y),p=Math.abs(r[0].z);d<=c&&(c=d,i.set(1,0,0)),u<=c&&(c=u,i.set(0,1,0)),p<=c&&i.set(0,0,1),s.crossVectors(r[0],i).normalize(),o[0].crossVectors(r[0],s),a[0].crossVectors(r[0],o[0]);for(let h=1;h<=t;h++){if(o[h]=o[h-1].clone(),a[h]=a[h-1].clone(),s.crossVectors(r[h-1],r[h]),s.length()>Number.EPSILON){s.normalize();let m=Math.acos(es(r[h-1].dot(r[h]),-1,1));o[h].applyMatrix4(l.makeRotationAxis(s,m))}a[h].crossVectors(r[h],o[h])}if(!0===e){let h=Math.acos(es(o[0].dot(o[t]),-1,1));h/=t,r[0].dot(s.crossVectors(o[0],o[t]))>0&&(h=-h);for(let m=1;m<=t;m++)o[m].applyMatrix4(l.makeRotationAxis(r[m],h*m)),a[m].crossVectors(r[m],o[m])}return{tangents:r,normals:o,binormals:a}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),r_=class extends ns{constructor(t=0,e=0,i=1,r=1,o=0,a=2*Math.PI,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,e){let i=e||new $e,r=2*Math.PI,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=r;for(;o>r;)o-=r;o<Number.EPSILON&&(o=a?0:r),!0===this.aClockwise&&!a&&(o===r?o=-r:o-=r);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(0!==this.aRotation){let d=Math.cos(this.aRotation),u=Math.sin(this.aRotation),p=l-this.aX,h=c-this.aY;l=p*d-h*u+this.aX,c=p*u+h*d+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};r_.prototype.isEllipseCurve=!0;var BI=class extends r_{constructor(t,e,i,r,o,a){super(t,e,i,i,r,o,a),this.type="ArcCurve"}};function uV(){let n=0,t=0,e=0,i=0;function r(o,a,s,l){n=o,t=s,e=-3*o+3*a-2*s-l,i=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){r(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,d,u){let p=(a-o)/c-(s-o)/(c+d)+(s-a)/d,h=(s-a)/d-(l-a)/(d+u)+(l-s)/u;p*=d,h*=d,r(a,s,p,h)},calc:function(o){let a=o*o;return n+t*o+e*a+i*(a*o)}}}BI.prototype.isArcCurve=!0;var fI=new K,U3=new uV,j3=new uV,G3=new uV,VI=class extends ns{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new K){let c,d,i=e,r=this.points,o=r.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:0===l&&s===o-1&&(s=o-2,l=1),this.closed||s>0?c=r[(s-1)%o]:(fI.subVectors(r[0],r[1]).add(r[0]),c=fI);let u=r[s%o],p=r[(s+1)%o];if(this.closed||s+2<o?d=r[(s+2)%o]:(fI.subVectors(r[o-1],r[o-2]).add(r[o-1]),d=fI),"centripetal"===this.curveType||"chordal"===this.curveType){let h="chordal"===this.curveType?.5:.25,m=Math.pow(c.distanceToSquared(u),h),_=Math.pow(u.distanceToSquared(p),h),M=Math.pow(p.distanceToSquared(d),h);_<1e-4&&(_=1),m<1e-4&&(m=_),M<1e-4&&(M=_),U3.initNonuniformCatmullRom(c.x,u.x,p.x,d.x,m,_,M),j3.initNonuniformCatmullRom(c.y,u.y,p.y,d.y,m,_,M),G3.initNonuniformCatmullRom(c.z,u.z,p.z,d.z,m,_,M)}else"catmullrom"===this.curveType&&(U3.initCatmullRom(c.x,u.x,p.x,d.x,this.tension),j3.initCatmullRom(c.y,u.y,p.y,d.y,this.tension),G3.initCatmullRom(c.z,u.z,p.z,d.z,this.tension));return i.set(U3.calc(l),j3.calc(l),G3.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new K).fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};function Kee(n,t,e,i,r){let o=.5*(i-t),a=.5*(r-e),s=n*n;return(2*e-2*i+o+a)*(n*s)+(-3*e+3*i-2*o-a)*s+o*n+e}function bx(n,t,e,i){return function(n,t){let e=1-n;return e*e*t}(n,t)+function(n,t){return 2*(1-n)*n*t}(n,e)+function(n,t){return n*n*t}(n,i)}function vx(n,t,e,i,r){return function(n,t){let e=1-n;return e*e*e*t}(n,t)+function(n,t){let e=1-n;return 3*e*e*n*t}(n,e)+function(n,t){return 3*(1-n)*n*n*t}(n,i)+function(n,t){return n*n*n*t}(n,r)}VI.prototype.isCatmullRomCurve3=!0;var Fx=class extends ns{constructor(t=new $e,e=new $e,i=new $e,r=new $e){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,a=this.v2,s=this.v3;return i.set(vx(t,r.x,o.x,a.x,s.x),vx(t,r.y,o.y,a.y,s.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};Fx.prototype.isCubicBezierCurve=!0;var HI=class extends ns{constructor(t=new K,e=new K,i=new K,r=new K){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new K){let i=e,r=this.v0,o=this.v1,a=this.v2,s=this.v3;return i.set(vx(t,r.x,o.x,a.x,s.x),vx(t,r.y,o.y,a.y,s.y),vx(t,r.z,o.z,a.z,s.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};HI.prototype.isCubicBezierCurve3=!0;var o_=class extends ns{constructor(t=new $e,e=new $e){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new $e){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new $e;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};o_.prototype.isLineCurve=!0;var Nx=class extends ns{constructor(t=new $e,e=new $e,i=new $e){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new $e){let i=e,r=this.v0,o=this.v1,a=this.v2;return i.set(bx(t,r.x,o.x,a.x),bx(t,r.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};Nx.prototype.isQuadraticBezierCurve=!0;var zI=class extends ns{constructor(t=new K,e=new K,i=new K){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new K){let i=e,r=this.v0,o=this.v1,a=this.v2;return i.set(bx(t,r.x,o.x,a.x),bx(t,r.y,o.y,a.y),bx(t,r.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};zI.prototype.isQuadraticBezierCurve3=!0;var Lx=class extends ns{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new $e){let i=e,r=this.points,o=(r.length-1)*t,a=Math.floor(o),s=o-a,l=r[0===a?a:a-1],c=r[a],d=r[a>r.length-2?r.length-1:a+1],u=r[a>r.length-3?r.length-1:a+2];return i.set(Kee(s,l.x,c.x,d.x,u.x),Kee(s,l.y,c.y,d.y,u.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new $e).fromArray(r))}return this}};Lx.prototype.isSplineCurve=!0;var Ete=Object.freeze({__proto__:null,ArcCurve:BI,CatmullRomCurve3:VI,CubicBezierCurve:Fx,CubicBezierCurve3:HI,EllipseCurve:r_,LineCurve:o_,LineCurve3:class extends ns{constructor(t=new K,e=new K){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new K){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},QuadraticBezierCurve:Nx,QuadraticBezierCurve3:zI,SplineCurve:Lx}),vB=class extends ns{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new o_(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),o=0;for(;o<r.length;){if(r[o]>=i){let a=r[o]-i,s=this.curves[o],l=s.getLength();return s.getPointAt(0===l?0:1-a/l,e)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let i,e=[];for(let r=0,o=this.curves;r<o.length;r++){let a=o[r],l=a.getPoints(a&&a.isEllipseCurve?2*t:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t);for(let c=0;c<l.length;c++){let d=l[c];i&&i.equals(d)||(e.push(d),i=d)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++)this.curves.push(t.curves[e].clone());return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++)t.curves.push(this.curves[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push((new Ete[r.type]).fromJSON(r))}return this}},Bx=class extends vB{constructor(t){super(),this.type="Path",this.currentPoint=new $e,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new o_(this.currentPoint.clone(),new $e(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let o=new Nx(this.currentPoint.clone(),new $e(t,e),new $e(i,r));return this.curves.push(o),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,o,a){let s=new Fx(this.currentPoint.clone(),new $e(t,e),new $e(i,r),new $e(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new Lx(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,o,a){return this.absarc(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,a),this}absarc(t,e,i,r,o,a){return this.absellipse(t,e,i,i,r,o,a),this}ellipse(t,e,i,r,o,a,s,l){return this.absellipse(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,a,s,l),this}absellipse(t,e,i,r,o,a,s,l){let c=new r_(t,e,i,r,o,a,s,l);if(this.curves.length>0){let u=c.getPoint(0);u.equals(this.currentPoint)||this.lineTo(u.x,u.y)}this.curves.push(c);let d=c.getPoint(1);return this.currentPoint.copy(d),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Wd=class extends Bx{constructor(t){super(t),this.uuid=Yl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++)this.holes.push(t.holes[e].clone());return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++)t.holes.push(this.holes[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push((new Bx).fromJSON(r))}return this}};function Tte(n,t,e,i,r){let o,a;if(r===function(n,t,e,i){let r=0;for(let o=t,a=e-i;o<e;o+=i)r+=(n[a]-n[o])*(n[o+1]+n[a+1]),a=o;return r}(n,t,e,i)>0)for(o=t;o<e;o+=i)a=Jee(o,n[o],n[o+1],a);else for(o=e-i;o>=t;o-=i)a=Jee(o,n[o],n[o+1],a);return a&&tA(a,a.next)&&(zx(a),a=a.next),a}function Dp(n,t){if(!n)return n;t||(t=n);let i,e=n;do{if(i=!1,e.steiner||!tA(e,e.next)&&0!==Fr(e.prev,e,e.next))e=e.next;else{if(zx(e),e=t=e.prev,e===e.next)break;i=!0}}while(i||e!==t);return t}function Vx(n,t,e,i,r,o,a){if(!n)return;!a&&o&&function(n,t,e,i){let r=n;do{null===r.z&&(r.z=yB(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,function(n){let t,e,i,r,o,a,s,l,c=1;do{for(e=n,n=null,o=null,a=0;e;){for(a++,i=e,s=0,t=0;t<c&&(s++,i=i.nextZ,i);t++);for(l=c;s>0||l>0&&i;)0!==s&&(0===l||!i||e.z<=i.z)?(r=e,e=e.nextZ,s--):(r=i,i=i.nextZ,l--),o?o.nextZ=r:n=r,r.prevZ=o,o=r;e=i}o.nextZ=null,c*=2}while(a>1)}(r)}(n,i,r,o);let l,c,s=n;for(;n.prev!==n.next;)if(l=n.prev,c=n.next,o?H2e(n,i,r,o):V2e(n))t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),zx(n),n=c.next,s=c.next;else if((n=c)===s){a?1===a?Vx(n=z2e(Dp(n),t,e),t,e,i,r,o,2):2===a&&U2e(n,t,e,i,r,o):Vx(Dp(n),t,e,i,r,o,1);break}}function V2e(n){let t=n.prev,e=n,i=n.next;if(Fr(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(W0(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&Fr(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function H2e(n,t,e,i){let r=n.prev,o=n,a=n.next;if(Fr(r,o,a)>=0)return!1;let c=r.x>o.x?r.x>a.x?r.x:a.x:o.x>a.x?o.x:a.x,d=r.y>o.y?r.y>a.y?r.y:a.y:o.y>a.y?o.y:a.y,u=yB(r.x<o.x?r.x<a.x?r.x:a.x:o.x<a.x?o.x:a.x,r.y<o.y?r.y<a.y?r.y:a.y:o.y<a.y?o.y:a.y,t,e,i),p=yB(c,d,t,e,i),h=n.prevZ,m=n.nextZ;for(;h&&h.z>=u&&m&&m.z<=p;){if(h!==n.prev&&h!==n.next&&W0(r.x,r.y,o.x,o.y,a.x,a.y,h.x,h.y)&&Fr(h.prev,h,h.next)>=0||(h=h.prevZ,m!==n.prev&&m!==n.next&&W0(r.x,r.y,o.x,o.y,a.x,a.y,m.x,m.y)&&Fr(m.prev,m,m.next)>=0))return!1;m=m.nextZ}for(;h&&h.z>=u;){if(h!==n.prev&&h!==n.next&&W0(r.x,r.y,o.x,o.y,a.x,a.y,h.x,h.y)&&Fr(h.prev,h,h.next)>=0)return!1;h=h.prevZ}for(;m&&m.z<=p;){if(m!==n.prev&&m!==n.next&&W0(r.x,r.y,o.x,o.y,a.x,a.y,m.x,m.y)&&Fr(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function z2e(n,t,e){let i=n;do{let r=i.prev,o=i.next.next;!tA(r,o)&&Dte(r,i,i.next,o)&&Hx(r,o)&&Hx(o,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(o.i/e),zx(i),zx(i.next),i=n=o),i=i.next}while(i!==n);return Dp(i)}function U2e(n,t,e,i,r,o){let a=n;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&K2e(a,s)){let l=Ite(a,s);return a=Dp(a,a.next),l=Dp(l,l.next),Vx(a,t,e,i,r,o),void Vx(l,t,e,i,r,o)}s=s.next}a=a.next}while(a!==n)}function G2e(n,t){return n.x-t.x}function W2e(n,t){if(t=function(n,t){let a,e=t,i=n.x,r=n.y,o=-1/0;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let p=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(p<=i&&p>o){if(o=p,p===i){if(r===e.y)return e;if(r===e.next.y)return e.next}a=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!a)return null;if(i===o)return a;let u,s=a,l=a.x,c=a.y,d=1/0;e=a;do{i>=e.x&&e.x>=l&&i!==e.x&&W0(r<c?i:o,r,l,c,r<c?o:i,r,e.x,e.y)&&(u=Math.abs(r-e.y)/(i-e.x),Hx(e,n)&&(u<d||u===d&&(e.x>a.x||e.x===a.x&&X2e(a,e)))&&(a=e,d=u)),e=e.next}while(e!==s);return a}(n,t),t){let e=Ite(t,n);Dp(t,t.next),Dp(e,e.next)}}function X2e(n,t){return Fr(n.prev,n,t.prev)<0&&Fr(t.next,n,n.next)<0}function yB(n,t,e,i,r){return(n=1431655765&((n=858993459&((n=252645135&((n=16711935&((n=32767*(n-e)*r)|n<<8))|n<<4))|n<<2))|n<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-i)*r)|t<<8))|t<<4))|t<<2))|t<<1))<<1}function Z2e(n){let t=n,e=n;do{(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next}while(t!==n);return e}function W0(n,t,e,i,r,o,a,s){return(r-a)*(t-s)-(n-a)*(o-s)>=0&&(n-a)*(i-s)-(e-a)*(t-s)>=0&&(e-a)*(o-s)-(r-a)*(i-s)>=0}function K2e(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!function(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&Dte(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}(n,t)&&(Hx(n,t)&&Hx(t,n)&&function(n,t){let e=n,i=!1,r=(n.x+t.x)/2,o=(n.y+t.y)/2;do{e.y>o!=e.next.y>o&&e.next.y!==e.y&&r<(e.next.x-e.x)*(o-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next}while(e!==n);return i}(n,t)&&(Fr(n.prev,n,t.prev)||Fr(n,t.prev,t))||tA(n,t)&&Fr(n.prev,n,n.next)>0&&Fr(t.prev,t,t.next)>0)}function Fr(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function tA(n,t){return n.x===t.x&&n.y===t.y}function Dte(n,t,e,i){let r=_I(Fr(n,t,e)),o=_I(Fr(n,t,i)),a=_I(Fr(e,i,n)),s=_I(Fr(e,i,t));return!!(r!==o&&a!==s||0===r&&gI(n,e,t)||0===o&&gI(n,i,t)||0===a&&gI(e,n,i)||0===s&&gI(e,t,i))}function gI(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function _I(n){return n>0?1:n<0?-1:0}function Hx(n,t){return Fr(n.prev,n,n.next)<0?Fr(n,t,n.next)>=0&&Fr(n,n.prev,t)>=0:Fr(n,t,n.prev)<0||Fr(n,n.next,t)<0}function Ite(n,t){let e=new xB(n.i,n.x,n.y),i=new xB(t.i,t.x,t.y),r=n.next,o=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,o.next=i,i.prev=o,i}function Jee(n,t,e,i){let r=new xB(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function zx(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function xB(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}var Gc=class{static area(t){let e=t.length,i=0;for(let r=e-1,o=0;o<e;r=o++)i+=t[r].x*t[o].y-t[o].x*t[r].y;return.5*i}static isClockWise(t){return Gc.area(t)<0}static triangulateShape(t,e){let i=[],r=[],o=[];$ee(t),ete(i,t);let a=t.length;e.forEach($ee);for(let l=0;l<e.length;l++)r.push(a),a+=e[l].length,ete(i,e[l]);let s=function(n,t,e=2){let s,l,c,d,u,p,h,i=t&&t.length,r=i?t[0]*e:n.length,o=Tte(n,0,r,e,!0),a=[];if(!o||o.next===o.prev)return a;if(i&&(o=function(n,t,e,i){let o,a,s,l,c,r=[];for(o=0,a=t.length;o<a;o++)s=t[o]*i,l=o<a-1?t[o+1]*i:n.length,c=Tte(n,s,l,i,!1),c===c.next&&(c.steiner=!0),r.push(Z2e(c));for(r.sort(G2e),o=0;o<r.length;o++)W2e(r[o],e),e=Dp(e,e.next);return e}(n,t,o,e)),n.length>80*e){s=c=n[0],l=d=n[1];for(let m=e;m<r;m+=e)u=n[m],p=n[m+1],u<s&&(s=u),p<l&&(l=p),u>c&&(c=u),p>d&&(d=p);h=Math.max(c-s,d-l),h=0!==h?1/h:0}return Vx(o,a,e,s,l,h),a}(i,r);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function $ee(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function ete(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var Ip=class extends Gi{constructor(t=new Wd([new $e(.5,.5),new $e(-.5,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],o=[];for(let s=0,l=t.length;s<l;s++)a(t[s]);function a(s){let l=[],c=void 0!==e.curveSegments?e.curveSegments:12,d=void 0!==e.steps?e.steps:1,u=void 0!==e.depth?e.depth:1,p=void 0===e.bevelEnabled||e.bevelEnabled,h=void 0!==e.bevelThickness?e.bevelThickness:.2,m=void 0!==e.bevelSize?e.bevelSize:h-.1,_=void 0!==e.bevelOffset?e.bevelOffset:0,M=void 0!==e.bevelSegments?e.bevelSegments:3,y=e.extrudePath,x=void 0!==e.UVGenerator?e.UVGenerator:tNe;void 0!==e.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),u=e.amount);let R,B,ee,Q,we,I=!1;y&&(R=y.getSpacedPoints(d),I=!0,p=!1,B=y.computeFrenetFrames(d,!1),ee=new K,Q=new K,we=new K),p||(M=0,h=0,m=0,_=0);let Qe=s.extractPoints(c),Ae=Qe.shape,D=Qe.holes;if(!Gc.isClockWise(Ae)){Ae=Ae.reverse();for(let oe=0,at=D.length;oe<at;oe++){let Ye=D[oe];Gc.isClockWise(Ye)&&(D[oe]=Ye.reverse())}}let ce=Gc.triangulateShape(Ae,D),he=Ae;for(let oe=0,at=D.length;oe<at;oe++)Ae=Ae.concat(D[oe]);function _e(oe,at,Ye){return at||console.error("THREE.ExtrudeGeometry: vec does not exist"),at.clone().multiplyScalar(Ye).add(oe)}let $=Ae.length,de=ce.length;function pe(oe,at,Ye){let _t,ut,an,yn=oe.x-at.x,si=oe.y-at.y,Ni=Ye.x-oe.x,Li=Ye.y-oe.y,Y=yn*yn+si*si;if(Math.abs(yn*Li-si*Ni)>Number.EPSILON){let He=Math.sqrt(Y),yt=Math.sqrt(Ni*Ni+Li*Li),en=at.x-si/He,Le=at.y+yn/He,Ft=((Ye.x-Li/yt-en)*Li-(Ye.y+Ni/yt-Le)*Ni)/(yn*Li-si*Ni);_t=en+yn*Ft-oe.x,ut=Le+si*Ft-oe.y;let Ot=_t*_t+ut*ut;if(Ot<=2)return new $e(_t,ut);an=Math.sqrt(Ot/2)}else{let He=!1;yn>Number.EPSILON?Ni>Number.EPSILON&&(He=!0):yn<-Number.EPSILON?Ni<-Number.EPSILON&&(He=!0):Math.sign(si)===Math.sign(Li)&&(He=!0),He?(_t=-si,ut=yn,an=Math.sqrt(Y)):(_t=yn,ut=si,an=Math.sqrt(Y/2))}return new $e(_t/an,ut/an)}let Ge=[];for(let oe=0,at=he.length,Ye=at-1,_t=oe+1;oe<at;oe++,Ye++,_t++)Ye===at&&(Ye=0),_t===at&&(_t=0),Ge[oe]=pe(he[oe],he[Ye],he[_t]);let Fe,Se=[],lt=Ge.concat();for(let oe=0,at=D.length;oe<at;oe++){let Ye=D[oe];Fe=[];for(let _t=0,ut=Ye.length,an=ut-1,yn=_t+1;_t<ut;_t++,an++,yn++)an===ut&&(an=0),yn===ut&&(yn=0),Fe[_t]=pe(Ye[_t],Ye[an],Ye[yn]);Se.push(Fe),lt=lt.concat(Fe)}for(let oe=0;oe<M;oe++){let at=oe/M,Ye=h*Math.cos(at*Math.PI/2),_t=m*Math.sin(at*Math.PI/2)+_;for(let ut=0,an=he.length;ut<an;ut++){let yn=_e(he[ut],Ge[ut],_t);wt(yn.x,yn.y,-Ye)}for(let ut=0,an=D.length;ut<an;ut++){let yn=D[ut];Fe=Se[ut];for(let si=0,Ni=yn.length;si<Ni;si++){let Li=_e(yn[si],Fe[si],_t);wt(Li.x,Li.y,-Ye)}}}let Mt=m+_;for(let oe=0;oe<$;oe++){let at=p?_e(Ae[oe],lt[oe],Mt):Ae[oe];I?(Q.copy(B.normals[0]).multiplyScalar(at.x),ee.copy(B.binormals[0]).multiplyScalar(at.y),we.copy(R[0]).add(Q).add(ee),wt(we.x,we.y,we.z)):wt(at.x,at.y,0)}for(let oe=1;oe<=d;oe++)for(let at=0;at<$;at++){let Ye=p?_e(Ae[at],lt[at],Mt):Ae[at];I?(Q.copy(B.normals[oe]).multiplyScalar(Ye.x),ee.copy(B.binormals[oe]).multiplyScalar(Ye.y),we.copy(R[oe]).add(Q).add(ee),wt(we.x,we.y,we.z)):wt(Ye.x,Ye.y,u/d*oe)}for(let oe=M-1;oe>=0;oe--){let at=oe/M,Ye=h*Math.cos(at*Math.PI/2),_t=m*Math.sin(at*Math.PI/2)+_;for(let ut=0,an=he.length;ut<an;ut++){let yn=_e(he[ut],Ge[ut],_t);wt(yn.x,yn.y,u+Ye)}for(let ut=0,an=D.length;ut<an;ut++){let yn=D[ut];Fe=Se[ut];for(let si=0,Ni=yn.length;si<Ni;si++){let Li=_e(yn[si],Fe[si],_t);I?wt(Li.x,Li.y+R[d-1].y,R[d-1].x+Ye):wt(Li.x,Li.y,u+Ye)}}}function Tn(oe,at){let Ye=oe.length;for(;--Ye>=0;){let _t=Ye,ut=Ye-1;ut<0&&(ut=oe.length-1);for(let an=0,yn=d+2*M;an<yn;an++){let si=$*an,Ni=$*(an+1);Ce(at+_t+si,at+ut+si,at+ut+Ni,at+_t+Ni)}}}function wt(oe,at,Ye){l.push(oe),l.push(at),l.push(Ye)}function on(oe,at,Ye){mt(oe),mt(at),mt(Ye);let _t=r.length/3,ut=x.generateTopUV(i,r,_t-3,_t-2,_t-1);ht(ut[0]),ht(ut[1]),ht(ut[2])}function Ce(oe,at,Ye,_t){mt(oe),mt(at),mt(_t),mt(at),mt(Ye),mt(_t);let ut=r.length/3,an=x.generateSideWallUV(i,r,ut-6,ut-3,ut-2,ut-1);ht(an[0]),ht(an[1]),ht(an[3]),ht(an[1]),ht(an[2]),ht(an[3])}function mt(oe){r.push(l[3*oe+0]),r.push(l[3*oe+1]),r.push(l[3*oe+2])}function ht(oe){o.push(oe.x),o.push(oe.y)}(function(){let oe=r.length/3;if(p){let at=0,Ye=$*at;for(let _t=0;_t<de;_t++){let ut=ce[_t];on(ut[2]+Ye,ut[1]+Ye,ut[0]+Ye)}at=d+2*M,Ye=$*at;for(let _t=0;_t<de;_t++){let ut=ce[_t];on(ut[0]+Ye,ut[1]+Ye,ut[2]+Ye)}}else{for(let at=0;at<de;at++){let Ye=ce[at];on(Ye[2],Ye[1],Ye[0])}for(let at=0;at<de;at++){let Ye=ce[at];on(Ye[0]+$*d,Ye[1]+$*d,Ye[2]+$*d)}}i.addGroup(oe,r.length/3-oe,0)})(),function(){let oe=r.length/3,at=0;Tn(he,at),at+=he.length;for(let Ye=0,_t=D.length;Ye<_t;Ye++){let ut=D[Ye];Tn(ut,at),at+=ut.length}i.addGroup(oe,r.length/3-oe,1)}()}this.setAttribute("position",new Nr(r,3)),this.setAttribute("uv",new Nr(o,2)),this.computeVertexNormals()}toJSON(){let t=super.toJSON();return function(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++)e.shapes.push(n[i].uuid);else e.shapes.push(n.uuid);return void 0!==t.extrudePath&&(e.options.extrudePath=t.extrudePath.toJSON()),e}(this.parameters.shapes,this.parameters.options,t)}static fromJSON(t,e){let i=[];for(let o=0,a=t.shapes.length;o<a;o++)i.push(e[t.shapes[o]]);let r=t.options.extrudePath;return void 0!==r&&(t.options.extrudePath=(new Ete[r.type]).fromJSON(r)),new Ip(i,t.options)}},tNe={generateTopUV:function(n,t,e,i,r){let s=t[3*i],l=t[3*i+1],c=t[3*r],d=t[3*r+1];return[new $e(t[3*e],t[3*e+1]),new $e(s,l),new $e(c,d)]},generateSideWallUV:function(n,t,e,i,r,o){let a=t[3*e],s=t[3*e+1],l=t[3*e+2],c=t[3*i],d=t[3*i+1],u=t[3*i+2],p=t[3*r],h=t[3*r+1],m=t[3*r+2],_=t[3*o],M=t[3*o+1],y=t[3*o+2];return Math.abs(s-d)<Math.abs(a-c)?[new $e(a,1-l),new $e(c,1-u),new $e(p,1-m),new $e(_,1-y)]:[new $e(s,1-l),new $e(d,1-u),new $e(h,1-m),new $e(M,1-y)]}},wm=class extends Gi{constructor(t=new Wd([new $e(0,.5),new $e(-.5,-.5),new $e(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],o=[],a=[],s=0,l=0;if(!1===Array.isArray(t))c(t);else for(let d=0;d<t.length;d++)c(t[d]),this.addGroup(s,l,d),s+=l,l=0;function c(d){let u=r.length/3,p=d.extractPoints(e),h=p.shape,m=p.holes;!1===Gc.isClockWise(h)&&(h=h.reverse());for(let M=0,y=m.length;M<y;M++){let x=m[M];!0===Gc.isClockWise(x)&&(m[M]=x.reverse())}let _=Gc.triangulateShape(h,m);for(let M=0,y=m.length;M<y;M++)h=h.concat(m[M]);for(let M=0,y=h.length;M<y;M++){let x=h[M];r.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let M=0,y=_.length;M<y;M++){let x=_[M];i.push(x[0]+u,x[1]+u,x[2]+u),l+=3}}this.setIndex(i),this.setAttribute("position",new Nr(r,3)),this.setAttribute("normal",new Nr(o,3)),this.setAttribute("uv",new Nr(a,2))}toJSON(){let t=super.toJSON();return function(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++)t.shapes.push(n[e].uuid);else t.shapes.push(n.uuid);return t}(this.parameters.shapes,t)}static fromJSON(t,e){let i=[];for(let r=0,o=t.shapes.length;r<o;r++)i.push(e[t.shapes[r]]);return new wm(i,t.curveSegments)}};(class extends Fo{constructor(t){super(),this.type="ShadowMaterial",this.color=new sn(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}}).prototype.isShadowMaterial=!0;var UI=class extends Fo{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new sn(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new sn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=c_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};UI.prototype.isMeshStandardMaterial=!0,class extends UI{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new $e(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return es(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new sn(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new sn(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new sn(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}.prototype.isMeshPhysicalMaterial=!0,class extends Fo{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new sn(16777215),this.specular=new sn(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new sn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=c_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=KI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}}.prototype.isMeshPhongMaterial=!0,class extends Fo{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new sn(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new sn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=c_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshToonMaterial=!0,class extends Fo{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=c_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}.prototype.isMeshNormalMaterial=!0,class extends Fo{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new sn(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new sn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=KI,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshLambertMaterial=!0,class extends Fo{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new sn(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=c_,this.normalScale=new $e(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}}.prototype.isMeshMatcapMaterial=!0,class extends Gd{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}.prototype.isLineDashedMaterial=!0;var Ir={arraySlice:function(n,t,e){return Ir.isTypedArray(n)?new n.constructor(n.subarray(t,void 0!==e?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:"number"==typeof t.BYTES_PER_ELEMENT?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(function(r,o){return n[r]-n[o]}),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let o=0,a=0;a!==i;++o){let s=e[o]*t;for(let l=0;l!==t;++l)r[a++]=n[s+l]}return r},flattenJSON:function(n,t,e,i){let r=1,o=n[0];for(;void 0!==o&&void 0===o[i];)o=n[r++];if(void 0===o)return;let a=o[i];if(void 0!==a)if(Array.isArray(a))do{a=o[i],void 0!==a&&(t.push(o.time),e.push.apply(e,a)),o=n[r++]}while(void 0!==o);else if(void 0!==a.toArray)do{a=o[i],void 0!==a&&(t.push(o.time),a.toArray(e,e.length)),o=n[r++]}while(void 0!==o);else do{a=o[i],void 0!==a&&(t.push(o.time),e.push(a)),o=n[r++]}while(void 0!==o)},subclip:function(n,t,e,i,r=30){let o=n.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],d=c.getValueSize(),u=[],p=[];for(let h=0;h<c.times.length;++h){let m=c.times[h]*r;if(!(m<e||m>=i)){u.push(c.times[h]);for(let _=0;_<d;++_)p.push(c.values[h*d+_])}}0!==u.length&&(c.times=Ir.convertArray(u,c.times.constructor),c.values=Ir.convertArray(p,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,o=t/i;for(let a=0;a<r;++a){let s=e.tracks[a],l=s.ValueTypeName;if("bool"===l||"string"===l)continue;let c=n.tracks.find(function(y){return y.name===s.name&&y.ValueTypeName===l});if(void 0===c)continue;let d=0,u=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(d=u/3);let p=0,h=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(p=h/3);let _,m=s.times.length-1;if(o<=s.times[0])_=Ir.arraySlice(s.values,d,u-d);else if(o>=s.times[m]){let y=m*u+d;_=Ir.arraySlice(s.values,y,y+u-d)}else{let y=s.createInterpolant(),x=d,R=u-d;y.evaluate(o),_=Ir.arraySlice(y.resultBuffer,x,R)}"quaternion"===l&&(new oa).fromArray(_).normalize().conjugate().toArray(_);let M=c.times.length;for(let y=0;y<M;++y){let x=y*h+p;if("quaternion"===l)oa.multiplyQuaternionsFlat(c.values,x,_,0,c.values,x);else{let R=h-2*p;for(let I=0;I<R;++I)c.values[x+I]-=_[I]}}}return n.blendMode=2501,n}},Wc=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==r?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],o=e[i-1];e:{t:{let a;n:{i:if(!(t<r)){for(let s=i+2;;){if(void 0===r){if(t<o)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,o)}if(i===s)break;if(o=r,r=e[++i],t<r)break t}a=e.length;break n}if(t>=o)break e;{let s=e[1];t<s&&(i=2,o=s);for(let l=i-2;;){if(void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=o,o=e[--i-1],t>=o)break t}a=i,i=0}}for(;i<a;){let s=i+a>>>1;t<e[s]?a=s:i=s+1}if(r=e[i],o=e[i-1],void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(void 0===r)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,o,t)}this._cachedIndex=i,this.intervalChanged_(i,o,r)}return this.interpolate_(i,o,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,o=t*r;for(let a=0;a!==r;++a)e[a]=i[o+a];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};Wc.prototype.beforeStart_=Wc.prototype.copySampleValue_,Wc.prototype.afterEnd_=Wc.prototype.copySampleValue_;var AB=class extends Wc{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:j0,endingEnd:j0}}intervalChanged_(t,e,i){let r=this.parameterPositions,o=t-2,a=t+1,s=r[o],l=r[a];if(void 0===s)switch(this.getSettings_().endingStart){case G0:o=t,s=2*e-i;break;case 2402:o=r.length-2,s=e+r[o]-r[o+1];break;default:o=t,s=i}if(void 0===l)switch(this.getSettings_().endingEnd){case G0:a=t,l=2*i-e;break;case 2402:a=1,l=i+r[1]-r[0];break;default:a=t-1,l=e}let c=.5*(i-e),d=this.valueSize;this._weightPrev=c/(e-s),this._weightNext=c/(l-i),this._offsetPrev=o*d,this._offsetNext=a*d}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,d=this._offsetPrev,u=this._offsetNext,p=this._weightPrev,h=this._weightNext,m=(i-e)/(r-e),_=m*m,M=_*m,y=-p*M+2*p*_-p*m,x=(1+p)*M+(-1.5-2*p)*_+(-.5+p)*m+1,R=(-1-h)*M+(1.5+h)*_+.5*m,I=h*M-h*_;for(let B=0;B!==s;++B)o[B]=y*a[d+B]+x*a[c+B]+R*a[l+B]+I*a[u+B];return o}},jI=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,d=(i-e)/(r-e),u=1-d;for(let p=0;p!==s;++p)o[p]=a[c+p]*u+a[l+p]*d;return o}},RB=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},cl=class{constructor(t,e,i,r){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===e||0===e.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Ir.convertArray(e,this.TimeBufferType),this.values=Ir.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let i,e=t.constructor;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Ir.convertArray(t.times,Array),values:Ir.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new RB(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new jI(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new AB(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case 2300:e=this.InterpolantFactoryMethodDiscrete;break;case 2301:e=this.InterpolantFactoryMethodLinear;break;case 2302:e=this.InterpolantFactoryMethodSmooth}if(void 0===e){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(i);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}}getValueSize(){return this.values.length/this.times.length}shift(t){if(0!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(1!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,o=0,a=r-1;for(;o!==r&&i[o]<t;)++o;for(;-1!==a&&i[a]>e;)--a;if(++a,0!==o||a!==r){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=Ir.arraySlice(i,o,a),this.values=Ir.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,o=i.length;0===o&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=i[s];if("number"==typeof l&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(null!==a&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(void 0!==r&&Ir.isTypedArray(r))for(let s=0,l=r.length;s!==l;++s){let c=r[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=Ir.arraySlice(this.times),e=Ir.arraySlice(this.values),i=this.getValueSize(),r=2302===this.getInterpolation(),o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s];if(c!==t[s+1]&&(1!==s||c!==t[0]))if(r)l=!0;else{let u=s*i,p=u-i,h=u+i;for(let m=0;m!==i;++m){let _=e[u+m];if(_!==e[p+m]||_!==e[h+m]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let u=s*i,p=a*i;for(let h=0;h!==i;++h)e[p+h]=e[u+h]}++a}}if(o>0){t[a]=t[o];for(let s=o*i,l=a*i,c=0;c!==i;++c)e[l+c]=e[s+c];++a}return a!==t.length?(this.times=Ir.arraySlice(t,0,a),this.values=Ir.arraySlice(e,0,a*i)):(this.times=t,this.values=e),this}clone(){let t=Ir.arraySlice(this.times,0),e=Ir.arraySlice(this.values,0),r=new(0,this.constructor)(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};cl.prototype.TimeBufferType=Float32Array,cl.prototype.ValueBufferType=Float32Array,cl.prototype.DefaultInterpolation=2301;var Ap=class extends cl{};Ap.prototype.ValueTypeName="bool",Ap.prototype.ValueBufferType=Array,Ap.prototype.DefaultInterpolation=2300,Ap.prototype.InterpolantFactoryMethodLinear=void 0,Ap.prototype.InterpolantFactoryMethodSmooth=void 0;var GI=class extends cl{};GI.prototype.ValueTypeName="color";var a_=class extends cl{};a_.prototype.ValueTypeName="number";var PB=class extends Wc{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(i-e)/(r-e),c=t*s;for(let d=c+s;c!==d;c+=4)oa.slerpFlat(o,0,a,c-s,a,c,l);return o}},Sm=class extends cl{InterpolantFactoryMethodLinear(t){return new PB(this.times,this.values,this.getValueSize(),t)}};Sm.prototype.ValueTypeName="quaternion",Sm.prototype.DefaultInterpolation=2301,Sm.prototype.InterpolantFactoryMethodSmooth=void 0;var Rp=class extends cl{};Rp.prototype.ValueTypeName="string",Rp.prototype.ValueBufferType=Array,Rp.prototype.DefaultInterpolation=2300,Rp.prototype.InterpolantFactoryMethodLinear=void 0,Rp.prototype.InterpolantFactoryMethodSmooth=void 0;var s_=class extends cl{};s_.prototype.ValueTypeName="vector";var WI=class{constructor(t,e=-1,i,r=2500){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=Yl(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let a=0,s=i.length;a!==s;++a)e.push(oNe(i[a]).scale(r));let o=new this(t.name,t.duration,e,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=i.length;o!==a;++o)e.push(cl.toJSON(i[o]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let o=e.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let d=Ir.getKeyframeOrder(l);l=Ir.sortedArray(l,1,d),c=Ir.sortedArray(c,1,d),!r&&0===l[0]&&(l.push(o),c.push(c[0])),a.push(new a_(".morphTargetInfluences["+e[s].name+"]",l,c).scale(1/i))}return new this(t,-1,a)}static findByName(t,e){let i=t;Array.isArray(t)||(i=t.geometry&&t.geometry.animations||t.animations);for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],d=c.name.match(o);if(d&&d.length>1){let u=d[1],p=r[u];p||(r[u]=p=[]),p.push(c)}}let a=[];for(let s in r)a.push(this.CreateFromMorphTargetSequence(s,r[s],e,i));return a}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(u,p,h,m,_){if(0!==h.length){let M=[],y=[];Ir.flattenJSON(h,M,y,m),0!==M.length&&_.push(new u(p,M,y))}},r=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let u=0;u<c.length;u++){let p=c[u].keys;if(p&&0!==p.length)if(p[0].morphTargets){let m,h={};for(m=0;m<p.length;m++)if(p[m].morphTargets)for(let _=0;_<p[m].morphTargets.length;_++)h[p[m].morphTargets[_]]=-1;for(let _ in h){let M=[],y=[];for(let x=0;x!==p[m].morphTargets.length;++x){let R=p[m];M.push(R.time),y.push(R.morphTarget===_?1:0)}r.push(new a_(".morphTargetInfluence["+_+"]",M,y))}l=h.length*(a||1)}else{let h=".bones["+e[u].name+"]";i(s_,h+".position",p,"pos",r),i(Sm,h+".quaternion",p,"rot",r),i(s_,h+".scale",p,"scl",r)}}return 0===r.length?null:new this(o,l,r,s)}resetDuration(){let e=0;for(let i=0,r=this.tracks.length;i!==r;++i){let o=this.tracks[i];e=Math.max(e,o.times[o.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function oNe(n){if(void 0===n.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=function(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return a_;case"vector":case"vector2":case"vector3":case"vector4":return s_;case"color":return GI;case"quaternion":return Sm;case"bool":case"boolean":return Ap;case"string":return Rp}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}(n.type);if(void 0===n.times){let e=[],i=[];Ir.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return void 0!==t.parse?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var l_={enabled:!1,files:{},add:function(n,t){!1!==this.enabled&&(this.files[n]=t)},get:function(n){if(!1!==this.enabled)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},aNe=new class{constructor(t,e,i){let l,r=this,o=!1,a=0,s=0,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(d){s++,!1===o&&void 0!==r.onStart&&r.onStart(d,a,s),o=!0},this.itemEnd=function(d){a++,void 0!==r.onProgress&&r.onProgress(d,a,s),a===s&&(o=!1,void 0!==r.onLoad&&r.onLoad())},this.itemError=function(d){void 0!==r.onError&&r.onError(d)},this.resolveURL=function(d){return l?l(d):d},this.setURLModifier=function(d){return l=d,this},this.addHandler=function(d,u){return c.push(d,u),this},this.removeHandler=function(d){let u=c.indexOf(d);return-1!==u&&c.splice(u,2),this},this.getHandler=function(d){for(let u=0,p=c.length;u<p;u+=2){let h=c[u],m=c[u+1];if(h.global&&(h.lastIndex=0),h.test(d))return m}return null}}},qc=class{constructor(t){this.manager=void 0!==t?t:aNe,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,o){i.load(t,r,e,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Hd={},OB=class extends qc{constructor(t){super(t)}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=l_.get(t);if(void 0!==o)return this.manager.itemStart(t),setTimeout(()=>{e&&e(o),this.manager.itemEnd(t)},0),o;if(void 0!==Hd[t])return void Hd[t].push({onLoad:e,onProgress:i,onError:r});Hd[t]=[],Hd[t].push({onLoad:e,onProgress:i,onError:r});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(200===c.status||0===c.status){if(0===c.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream>"u"||void 0===c.body.getReader)return c;let d=Hd[t],u=c.body.getReader(),p=c.headers.get("Content-Length"),h=p?parseInt(p):0,m=0!==h,_=0,M=new ReadableStream({start(y){!function x(){u.read().then(({done:R,value:I})=>{if(R)y.close();else{_+=I.byteLength;let B=new ProgressEvent("progress",{lengthComputable:m,loaded:_,total:h});for(let ee=0,Q=d.length;ee<Q;ee++){let we=d[ee];we.onProgress&&we.onProgress(B)}y.enqueue(I),x()}})}()}});return new Response(M)}throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(d=>(new DOMParser).parseFromString(d,s));case"json":return c.json();default:if(void 0===s)return c.text();{let u=/charset="?([^;"\s]*)"?/i.exec(s),p=u&&u[1]?u[1].toLowerCase():void 0,h=new TextDecoder(p);return c.arrayBuffer().then(m=>h.decode(m))}}}).then(c=>{l_.add(t,c);let d=Hd[t];delete Hd[t];for(let u=0,p=d.length;u<p;u++){let h=d[u];h.onLoad&&h.onLoad(c)}}).catch(c=>{let d=Hd[t];if(void 0===d)throw this.manager.itemError(t),c;delete Hd[t];for(let u=0,p=d.length;u<p;u++){let h=d[u];h.onError&&h.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},qI=class extends qc{constructor(t){super(t)}load(t,e,i,r){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=l_.get(t);if(void 0!==a)return o.manager.itemStart(t),setTimeout(function(){e&&e(a),o.manager.itemEnd(t)},0),a;let s=Mx("img");function l(){d(),l_.add(t,this),e&&e(this),o.manager.itemEnd(t)}function c(u){d(),r&&r(u),o.manager.itemError(t),o.manager.itemEnd(t)}function d(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},FB=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=new $0,a=new qI(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(d){o.images[c]=d,s++,6===s&&(o.needsUpdate=!0,e&&e(o))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return o}},NB=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=new lo,a=new qI(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,void 0!==e&&e(o)},i,r),o}},dl=class extends Ui{constructor(t,e=1){super(),this.type="Light",this.color=new sn(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}};dl.prototype.isLight=!0,class extends dl{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(Ui.DefaultUp),this.updateMatrix(),this.groundColor=new sn(e)}copy(t){return dl.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}.prototype.isHemisphereLight=!0;var tte=new vn,nte=new K,ite=new K,Ux=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new $e(512,512),this.map=null,this.mapPass=null,this.matrix=new vn,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new e_,this._frameExtents=new $e(1,1),this._viewportCount=1,this._viewports=[new Qi(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;nte.setFromMatrixPosition(t.matrixWorld),e.position.copy(nte),ite.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(ite),e.updateMatrixWorld(),tte.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(tte),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return(new this.constructor).copy(this)}toJSON(){let t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),(512!==this.mapSize.x||512!==this.mapSize.y)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},XI=class extends Ux{constructor(){super(new ra(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=2*$3*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,o=t.distance||e.far;(i!==e.fov||r!==e.aspect||o!==e.far)&&(e.fov=i,e.aspect=r,e.far=o,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};XI.prototype.isSpotLightShadow=!0,class extends dl{constructor(t,e,i=0,r=Math.PI/3,o=0,a=1){super(t,e),this.type="SpotLight",this.position.copy(Ui.DefaultUp),this.updateMatrix(),this.target=new Ui,this.distance=i,this.angle=r,this.penumbra=o,this.decay=a,this.shadow=new XI}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isSpotLight=!0;var rte=new vn,hx=new K,W3=new K,YI=class extends Ux{constructor(){super(new ra(90,1,.5,500)),this._frameExtents=new $e(4,2),this._viewportCount=6,this._viewports=[new Qi(2,1,1,1),new Qi(0,1,1,1),new Qi(3,1,1,1),new Qi(1,1,1,1),new Qi(3,0,1,1),new Qi(1,0,1,1)],this._cubeDirections=[new K(1,0,0),new K(-1,0,0),new K(0,0,1),new K(0,0,-1),new K(0,1,0),new K(0,-1,0)],this._cubeUps=[new K(0,1,0),new K(0,1,0),new K(0,1,0),new K(0,1,0),new K(0,0,1),new K(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,o=t.distance||i.far;o!==i.far&&(i.far=o,i.updateProjectionMatrix()),hx.setFromMatrixPosition(t.matrixWorld),i.position.copy(hx),W3.copy(i.position),W3.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(W3),i.updateMatrixWorld(),r.makeTranslation(-hx.x,-hx.y,-hx.z),rte.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(rte)}};YI.prototype.isPointLightShadow=!0,class extends dl{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new YI}get power(){return 4*this.intensity*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}.prototype.isPointLight=!0;var QI=class extends Ux{constructor(){super(new xm(-5,5,5,-5,.5,500))}};QI.prototype.isDirectionalLightShadow=!0,class extends dl{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(Ui.DefaultUp),this.updateMatrix(),this.target=new Ui,this.shadow=new QI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isDirectionalLight=!0,class extends dl{constructor(t,e){super(t,e),this.type="AmbientLight"}}.prototype.isAmbientLight=!0,class extends dl{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}}.prototype.isRectAreaLight=!0;var ZI=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new K)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,o=t.z,a=this.coefficients;return e.copy(a[0]).multiplyScalar(.282095),e.addScaledVector(a[1],.488603*r),e.addScaledVector(a[2],.488603*o),e.addScaledVector(a[3],.488603*i),e.addScaledVector(a[4],i*r*1.092548),e.addScaledVector(a[5],r*o*1.092548),e.addScaledVector(a[6],.315392*(3*o*o-1)),e.addScaledVector(a[7],i*o*1.092548),e.addScaledVector(a[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,o=t.z,a=this.coefficients;return e.copy(a[0]).multiplyScalar(.886227),e.addScaledVector(a[1],1.023328*r),e.addScaledVector(a[2],1.023328*o),e.addScaledVector(a[3],1.023328*i),e.addScaledVector(a[4],.858086*i*r),e.addScaledVector(a[5],.858086*r*o),e.addScaledVector(a[6],.743125*o*o-.247708),e.addScaledVector(a[7],.858086*i*o),e.addScaledVector(a[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+3*r);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+3*r);return t}static getBasisAt(t,e){let i=t.x,r=t.y,o=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*o,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*o,e[6]=.315392*(3*o*o-1),e[7]=1.092548*i*o,e[8]=.546274*(i*i-r*r)}};ZI.prototype.isSphericalHarmonics3=!0;var jx=class extends dl{constructor(t=new ZI,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};jx.prototype.isLightProbe=!0;var jB=class{static decodeText(t){if(typeof TextDecoder<"u")return(new TextDecoder).decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch{return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return-1===e?"./":t.substr(0,e+1)}static resolveURL(t,e){return"string"!=typeof t||""===t?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}};(class extends Gi{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return(new this.constructor).copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}).prototype.isInstancedBufferGeometry=!0,class extends qc{constructor(t){super(t),typeof createImageBitmap>"u"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch>"u"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=l_.get(t);if(void 0!==a)return o.manager.itemStart(t),setTimeout(function(){e&&e(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials="anonymous"===this.crossOrigin?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){l_.add(t,l),e&&e(l),o.manager.itemEnd(t)}).catch(function(l){r&&r(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}}.prototype.isImageBitmapLoader=!0;var bI,qB=class extends qc{constructor(t){super(t)}load(t,e,i,r){let o=this,a=new OB(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);(void 0===bI&&(bI=new(window.AudioContext||window.webkitAudioContext)),bI).decodeAudioData(l,function(d){e(d)})}catch(l){r?r(l):console.error(l),o.manager.itemError(t)}},i,r)}};(class extends jx{constructor(t,e,i=1){super(void 0,i);let r=(new sn).set(t),o=(new sn).set(e),a=new K(r.r,r.g,r.b),s=new K(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}}).prototype.isHemisphereLightProbe=!0,class extends jx{constructor(t,e=1){super(void 0,e);let i=(new sn).set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}}.prototype.isAmbientLightProbe=!0;var KB=class{constructor(t,e,i){let r,o,a;switch(this.binding=t,this.valueSize=i,e){case"quaternion":r=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*i),this._workIndex=5;break;case"string":case"bool":r=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(5*i);break;default:r=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*i)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,o=t*r+r,a=this.cumulativeWeight;if(0===a){for(let s=0;s!==r;++s)i[o+s]=i[s];a=e}else a+=e,this._mixBufferRegion(i,o,0,e/a,r);this.cumulativeWeight=a}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1&&this._mixBufferRegion(i,r,e*this._origIndex,1-o,e),a>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){s.setValue(i,r);break}}saveOriginalState(){let e=this.buffer,i=this.valueSize,r=i*this._origIndex;this.binding.getValue(e,r);for(let o=i,a=r;o!==a;++o)e[o]=e[r+o%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){this.binding.setValue(this.buffer,3*this.valueSize)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,o){if(r>=.5)for(let a=0;a!==o;++a)t[e+a]=t[i+a]}_slerp(t,e,i,r){oa.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,o){let a=this._workIndex*o;oa.multiplyQuaternionsFlat(t,a,t,e,t,i),oa.slerpFlat(t,e,t,e,t,a,r)}_lerp(t,e,i,r,o){let a=1-r;for(let s=0;s!==o;++s){let l=e+s;t[l]=t[l]*a+t[i+s]*r}}_lerpAdditive(t,e,i,r,o){for(let a=0;a!==o;++a){let s=e+a;t[s]=t[s]+t[i+a]*r}}},pV="\\[\\]\\.:\\/",lNe=new RegExp("["+pV+"]","g"),hV="[^"+pV+"]",cNe="[^"+pV.replace("\\.","")+"]",dNe=/((?:WC+[\/:])*)/.source.replace("WC",hV),uNe=/(WCOD+)?/.source.replace("WCOD",cNe),pNe=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",hV),hNe=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",hV),mNe=new RegExp("^"+dNe+uNe+pNe+hNe+"$"),fNe=["material","materials","bones"],JB=class{constructor(t,e,i){let r=i||br.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let r=this._bindings[this._targetGroup.nCachedObjects_];void 0!==r&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,o=i.length;r!==o;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},br=(()=>{class n{constructor(e,i,r){this.path=i,this.parsedPath=r||n.parseTrackName(i),this.node=n.findNode(e,this.parsedPath.nodeName)||e,this.rootNode=e,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(e,i,r){return e&&e.isAnimationObjectGroup?new n.Composite(e,i,r):new n(e,i,r)}static sanitizeNodeName(e){return e.replace(/\s/g,"_").replace(lNe,"")}static parseTrackName(e){let i=mNe.exec(e);if(!i)throw new Error("PropertyBinding: Cannot parse trackName: "+e);let r={nodeName:i[2],objectName:i[3],objectIndex:i[4],propertyName:i[5],propertyIndex:i[6]},o=r.nodeName&&r.nodeName.lastIndexOf(".");if(void 0!==o&&-1!==o){let a=r.nodeName.substring(o+1);-1!==fNe.indexOf(a)&&(r.nodeName=r.nodeName.substring(0,o),r.objectName=a)}if(null===r.propertyName||0===r.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+e);return r}static findNode(e,i){if(!i||""===i||"."===i||-1===i||i===e.name||i===e.uuid)return e;if(e.skeleton){let r=e.skeleton.getBoneByName(i);if(void 0!==r)return r}if(e.children){let r=function(a){for(let s=0;s<a.length;s++){let l=a[s];if(l.name===i||l.uuid===i)return l;let c=r(l.children);if(c)return c}return null},o=r(e.children);if(o)return o}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(e,i){e[i]=this.targetObject[this.propertyName]}_getValue_array(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)e[i++]=r[o]}_getValue_arrayElement(e,i){e[i]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(e,i){this.resolvedProperty.toArray(e,i)}_setValue_direct(e,i){this.targetObject[this.propertyName]=e[i]}_setValue_direct_setNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++]}_setValue_array_setNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,a=r.length;o!==a;++o)r[o]=e[i++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(e,i){this.resolvedProperty[this.propertyIndex]=e[i]}_setValue_arrayElement_setNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(e,i){this.resolvedProperty.fromArray(e,i)}_setValue_fromArray_setNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(e,i){this.bind(),this.getValue(e,i)}_setValue_unbound(e,i){this.bind(),this.setValue(e,i)}bind(){let e=this.node,i=this.parsedPath,r=i.objectName,o=i.propertyName,a=i.propertyIndex;if(e||(e=n.findNode(this.rootNode,i.nodeName)||this.rootNode,this.node=e),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!e)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(r){let d=i.objectIndex;switch(r){case"materials":if(!e.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!e.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);e=e.material.materials;break;case"bones":if(!e.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);e=e.skeleton.bones;for(let u=0;u<e.length;u++)if(e[u].name===d){d=u;break}break;default:if(void 0===e[r])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);e=e[r]}if(void 0!==d){if(void 0===e[d])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,e);e=e[d]}}let s=e[o];if(void 0===s)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+i.nodeName+"."+o+" but it wasn't found.",e);let l=this.Versioning.None;this.targetObject=e,void 0!==e.needsUpdate?l=this.Versioning.NeedsUpdate:void 0!==e.matrixWorldNeedsUpdate&&(l=this.Versioning.MatrixWorldNeedsUpdate);let c=this.BindingType.Direct;if(void 0!==a){if("morphTargetInfluences"===o){if(!e.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!e.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!e.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==e.morphTargetDictionary[a]&&(a=e.morphTargetDictionary[a])}c=this.BindingType.ArrayElement,this.resolvedProperty=s,this.propertyIndex=a}else void 0!==s.fromArray&&void 0!==s.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=s):Array.isArray(s)?(c=this.BindingType.EntireArray,this.resolvedProperty=s):this.propertyName=o;this.getValue=this.GetterByBindingType[c],this.setValue=this.SetterByBindingTypeAndVersioning[c][l]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}return n.Composite=JB,n})();br.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},br.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},br.prototype.GetterByBindingType=[br.prototype._getValue_direct,br.prototype._getValue_array,br.prototype._getValue_arrayElement,br.prototype._getValue_toArray],br.prototype.SetterByBindingTypeAndVersioning=[[br.prototype._setValue_direct,br.prototype._setValue_direct_setNeedsUpdate,br.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[br.prototype._setValue_array,br.prototype._setValue_array_setNeedsUpdate,br.prototype._setValue_array_setMatrixWorldNeedsUpdate],[br.prototype._setValue_arrayElement,br.prototype._setValue_arrayElement_setNeedsUpdate,br.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[br.prototype._setValue_fromArray,br.prototype._setValue_fromArray_setNeedsUpdate,br.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]],class extends zd{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,o=r.length,a=t._propertyBindings,s=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,d=c[l];void 0===d&&(d={},c[l]=d);for(let u=0;u!==o;++u){let p=r[u],h=p.name,m=d[h];if(void 0!==m)++m.referenceCount,a[u]=m;else{if(m=a[u],void 0!==m){null===m._cacheIndex&&(++m.referenceCount,this._addInactiveBinding(m,l,h));continue}m=new KB(br.create(i,h,e&&e._propertyBindings[u].binding.parsedPath),p.ValueTypeName,p.getValueSize()),++m.referenceCount,this._addInactiveBinding(m,l,h),a[u]=m}s[u].resultBuffer=m.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,o=this._actionsByClip[r];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==o.useCount++&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.useCount&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return null!==e&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,o=this._actionsByClip,a=o[e];if(void 0===a)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[e]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=r.length,r.push(t),a.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],d=t._byClipCacheIndex;c._byClipCacheIndex=d,l[d]=c,l.pop(),t._byClipCacheIndex=null,delete s.actionByRoot[(t._localRoot||this._root).uuid],0===l.length&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.referenceCount&&this._removeInactiveBinding(o)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,o=this._bindings,a=r[e];void 0===a&&(a={},r[e]=a),a[i]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,o=i.path,a=this._bindingsByRootAndName,s=a[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete s[o],0===Object.keys(s).length&&delete a[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return void 0===i&&(i=new jI(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,o=e[r];t.__cacheIndex=r,e[r]=t,o.__cacheIndex=i,e[i]=o}clipAction(t,e,i){let r=e||this._root,o=r.uuid,a="string"==typeof t?WI.findByName(r,t):t,s=null!==a?a.uuid:t,l=this._actionsByClip[s],c=null;if(void 0===i&&(i=null!==a?a.blendMode:2500),void 0!==l){let u=l.actionByRoot[o];if(void 0!==u&&u.blendMode===i)return u;c=l.knownActions[0],null===a&&(a=c._clip)}if(null===a)return null;let d=new class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let o=e.tracks,a=o.length,s=new Array(a),l={endingStart:j0,endingEnd:j0};for(let c=0;c!==a;++c){let d=o[c].createInterpolant(null);s[c]=d,d.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,o=t._clip.duration,s=r/o;t.warp(1,o/r,e),this.warp(s,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,o=r.time,a=this.timeScale,s=this._timeScaleInterpolant;null===s&&(s=r._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+i,c[0]=t/a,c[1]=e/a,this}stopWarping(){let t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled)return void this._updateWeight(t);let o=this._startTime;if(null!==o){let l=(t-o)*i;if(l<0||0===i)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let a=this._updateTime(e),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;if(2501===this.blendMode)for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(a),c[d].accumulateAdditive(s);else for(let d=0,u=l.length;d!==u;++d)l[d].evaluate(a),c[d].accumulate(r,s)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(null!==i){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),0===r&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;null!==i&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,o=this._loopCount,a=2202===i;if(0===t)return-1===o?r:a&&1==(1&o)?e-r:r;if(2200===i){-1===o&&(this._loopCount=0,this._setEndings(!0,!0,!1));e:{if(r>=e)r=e;else{if(!(r<0)){this.time=r;break e}r=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===o&&(t>=0?(o=0,this._setEndings(!0,0===this.repetitions,a)):this._setEndings(0===this.repetitions,!0,a)),r>=e||r<0){let s=Math.floor(r/e);r-=e*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===l){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=r;if(a&&1==(1&o))return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=G0,r.endingEnd=G0):(r.endingStart=t?this.zeroSlopeAtStart?G0:j0:2402,r.endingEnd=e?this.zeroSlopeAtEnd?G0:j0:2402)}_scheduleFading(t,e,i){let r=this._mixer,o=r.time,a=this._weightInterpolant;null===a&&(a=r._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=e,s[1]=o+t,l[1]=i,this}}(this,a,e,i);return this._bindAction(d,c),this._addInactiveAction(d,s,o),d}existingAction(t,e){let i=e||this._root,r=i.uuid,o="string"==typeof t?WI.findByName(i,t):t,s=this._actionsByClip[o?o.uuid:t];return void 0!==s&&s.actionByRoot[r]||null}stopAllAction(){let t=this._actions;for(let i=this._nActiveActions-1;i>=0;--i)t[i].stop();return this}update(t){let e=this._actions,i=this._nActiveActions,r=this.time+=t*=this.timeScale,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,o=r[i];if(void 0!==o){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let d=c._cacheIndex,u=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,u._cacheIndex=d,e[d]=u,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let a in i){let l=i[a].actionByRoot[e];void 0!==l&&(this._deactivateAction(l),this._removeInactiveAction(l))}let o=this._bindingsByRootAndName[e];if(void 0!==o)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,e){let i=this.existingAction(t,e);null!==i&&(this._deactivateAction(i),this._removeInactiveAction(i))}}.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var Gx=class{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new Gx(void 0===this.value.clone?this.value:this.value.clone())}};(class extends Cm{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}}).prototype.isInstancedInterleavedBuffer=!0;var ote=new $e,Em=class{constructor(t=new $e(1/0,1/0),e=new $e(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=ote.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return ote.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Em.prototype.isBox2=!0;var bp=new K,yI=new vn,q3=new vn;function Ate(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,Ate(n.children[e]));return t}var gNe=new Float32Array(1);function mV(n,t,e){if(1===e)return new sn(t);let i=qh(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new sn(dL(i,n)(1-e))}new Int32Array(gNe.buffer),ns.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(ns.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n},Bx.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)},class extends Ox{constructor(t=10,e=10,i=4473924,r=8947848){i=new sn(i),r=new sn(r);let o=e/2,a=t/e,s=t/2,l=[],c=[];for(let p=0,h=0,m=-s;p<=e;p++,m+=a){l.push(-s,0,m,s,0,m),l.push(m,0,-s,m,0,s);let _=p===o?i:r;_.toArray(c,h),h+=3,_.toArray(c,h),h+=3,_.toArray(c,h),h+=3,_.toArray(c,h),h+=3}let d=new Gi;d.setAttribute("position",new Nr(l,3)),d.setAttribute("color",new Nr(c,3)),super(d,new Gd({vertexColors:!0,toneMapped:!1})),this.type="GridHelper"}}.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")},class extends Ox{constructor(t){let e=Ate(t),i=new Gi,r=[],o=[],a=new sn(0,0,1),s=new sn(0,1,0);for(let c=0;c<e.length;c++){let d=e[c];d.parent&&d.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}i.setAttribute("position",new Nr(r,3)),i.setAttribute("color",new Nr(o,3)),super(i,new Gd({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0})),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");q3.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<e.length;o++){let s=e[o];s.parent&&s.parent.isBone&&(yI.multiplyMatrices(q3,s.matrixWorld),bp.setFromMatrixPosition(yI),r.setXYZ(a,bp.x,bp.y,bp.z),yI.multiplyMatrices(q3,s.parent.matrixWorld),bp.setFromMatrixPosition(yI),r.setXYZ(a+1,bp.x,bp.y,bp.z),a+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}}.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")},qc.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),jB.extractUrlBase(n)},qc.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},Em.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)},Em.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},Em.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Em.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)},Ts.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)},Ts.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},Ts.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Ts.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},Ts.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)},Sp.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()},e_.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)},yo.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},yo.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},yo.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},yo.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},yo.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},yo.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},vn.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)},vn.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},vn.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new K).setFromMatrixColumn(this,3)},vn.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)},vn.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},vn.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},vn.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},vn.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},vn.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)},vn.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},vn.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")},vn.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},vn.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},vn.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},vn.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},vn.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},vn.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},vn.prototype.makeFrustum=function(n,t,e,i,r,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,o)},vn.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},Xl.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)},oa.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)},oa.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()},Ep.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Ep.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)},Ep.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},Vr.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},Vr.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)},Vr.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)},Vr.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)},Vr.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)},Vr.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),Vr.getBarycoord(n,t,e,i,r)},Vr.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),Vr.getNormal(n,t,e,i)},Wd.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)},Wd.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new Ip(this,n)},Wd.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new wm(this,n)},$e.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},$e.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},$e.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},K.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},K.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},K.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)},K.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)},K.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)},K.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)},K.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},K.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},K.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Qi.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},Qi.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Ui.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)},Ui.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},Ui.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)},Ui.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},Ui.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Ui.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),so.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")},Object.defineProperties(so.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),NI.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},ra.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==t&&(this.filmGauge=t),this.setFocalLength(n)},Object.defineProperties(dl.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}}),Object.defineProperties(Ar.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===SI},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(SI)}}}),Ar.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?SI:Cx),this},Ar.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Ar.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Gi.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)},Gi.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),t&&t.isBufferAttribute||t&&t.isInterleavedBufferAttribute?"index"===n?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Ar(arguments[1],arguments[2])))},Gi.prototype.addDrawCall=function(n,t,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)},Gi.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},Gi.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},Gi.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)},Gi.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Gi.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),Cm.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?SI:Cx),this},Cm.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Ip.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},Ip.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},Ip.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")},n_.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")},Gx.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this},Object.defineProperties(Fo.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new sn}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}}),Object.defineProperties(jd.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}}),Wi.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)},Wi.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)},Wi.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},Wi.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},Wi.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},Wi.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},Wi.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},Wi.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},Wi.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},Wi.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},Wi.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},Wi.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},Wi.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},Wi.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},Wi.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)},Wi.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},Wi.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},Wi.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},Wi.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},Wi.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},Wi.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},Wi.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},Wi.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},Wi.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},Wi.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()},Object.defineProperties(Wi.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===n?Dr:wp}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}}),Object.defineProperties(wte.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(ts.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}}),class extends Ui{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return(new qB).load(n,function(i){t.setBuffer(i)}),this},Ex.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)},Ex.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)},Ud.crossOrigin=void 0,Ud.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new NB;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},Ud.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new FB;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},Ud.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},Ud.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:sV}})),typeof window<"u"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=sV);var Ql=(()=>(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"}(Ql||(Ql={})),Ql))();function Pte(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==3*e)&&(i=new Ar(new Float32Array(3*e),3),n.setAttribute("position",i));let r=i.array;for(let o=0;o<e;o++)r[3*o]=t[2*o],r[3*o+1]=t[2*o+1];i.needsUpdate=!0,n.setDrawRange(0,3*e),n.computeBoundingSphere()}function kte(n,t,e){let i=Math.max(t.length/2-1,0),r=2*i*3,o=3*r,a=n.attributes.position;(!a||a.count!==r)&&(a=new Ar(new Float32Array(o),3),n.setAttribute("position",a));let s=a.array;for(let l=0;l<i;l++){let[c,d,u,p]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],h=new $e(c,d),m=new $e(u,p),_=new $e(u-c,p-d),M=new $e(-_.y,_.x).setLength(e/2),y=h.clone().add(M),x=h.clone().sub(M),R=m.clone().add(M),I=m.clone().sub(M),B=[y.x,y.y,0,x.x,x.y,0,R.x,R.y,0,R.x,R.y,0,x.x,x.y,0,I.x,I.y,0];s.set(B,l*B.length)}a.needsUpdate=!0,n.setDrawRange(0,o),n.computeBoundingSphere()}function nA(n,t,e,i){let{visible:r,color:o,opacity:a}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let s=t.material;if(s.visible!==r&&(s.visible=r,s.needsUpdate=!0),!r)return!1;let l=mV(n,o,a??1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),s.color.equals(l)||(s.color.set(l),s.needsUpdate=!0),!0}var rA=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){return this.prevFrameCache.get(t)??null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let o=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);o&&this.renderCache.setToCurrentFrame(t,o)}}(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(2*i.points.length)};for(let r=0;r<i.points.length;r++){let[o,a]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[2*r]=o,this.series[e].polyline[2*r+1]=a}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}},u_=(()=>(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"}(u_||(u_={})),u_))(),oA=class extends rA{recordPartition(t,e,i){return t?{type:u_.NUMBER,polyline:e}:{type:u_.NAN,polyline:e.map((r,o)=>isNaN(r)?o%2==0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,o=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),a={x:o[0],y:o[1]},s=null;for(let l=0;l<t.length;l+=2){let c=t[l],d=t[l+1],u=isNaN(c)||isNaN(d);u!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),null===s?{x:c,y:d}:s)),i=l),u||(s={x:c,y:d}),r=u}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),s??a)),e}redraw(){for(let t of this.series){let i=this.getMetadataMap()[t.id];if(!i)continue;if(t.polyline.length%2!=0)throw new Error(`Cannot have odd length-ed polyline: ${t.polyline.length}`);let r=this.partitionPolyline(t.polyline);for(let[o,{type:a,polyline:s}]of r.entries())if(a===u_.NUMBER)2===s.length?this.paintBrush.setCircle(JSON.stringify(["circle",t.id,o]),{x:s[0],y:s[1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",t.id,o]),s,{color:i.color,visible:i.visible,opacity:i.opacity??1,width:2});else if(!i.aux)for(let l=0;l<s.length;l+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",t.id,s[l],s[l+1]]),{x:s[l],y:s[l+1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,size:12})}}},aA=class extends C0{constructor(){super(...arguments),this.camera=new xm(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}},sA=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Yi.SVG:this.coordinator=new C0,this.renderer=new class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[2*i]},${t[2*i+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=zD(t?.dom,()=>{let o=document.createElementNS("http://www.w3.org/2000/svg","path");o.style.fill="none";let a=this.createPathDString(e);return o.setAttribute("d",a),this.svg.appendChild(o),o},o=>{if(!t?.data||!jl_arePolylinesEqual(e,t?.data)){let a=this.createPathDString(e);o.setAttribute("d",a)}return o},i);return null===r?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:o}=i,a=r*Math.sqrt(3)/2,s=new Float32Array([e.x-r/2,e.y+a/3,e.x+r/2,e.y+a/3,e.x,e.y-2*a/3]),l=zD(t?.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let d=this.createPathDString(s);return c.setAttribute("d",d+"Z"),this.svg.appendChild(c),c},c=>{let d=this.createPathDString(s);return c.setAttribute("d",d+"Z"),c},i);return null===l?null:(l.style.fill=o,{dom:l,data:s})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:o}=i,a=zD(t?.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","circle");return s.style.fill=r,s.setAttribute("cx",String(e.x)),s.setAttribute("cy",String(e.y)),s.setAttribute("r",String(o)),this.svg.appendChild(s),s},s=>(s.style.fill=r,s.setAttribute("cx",String(e.x)),s.setAttribute("cy",String(e.y)),s.setAttribute("r",String(o)),s),i);return null===a?null:{dom:a,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o,color:a}=r,s=2/Math.sqrt(3)*o,l=new Float32Array([e.x-s/2,e.y+o/2,e.x,e.y-o/2,i.x,i.y-o/2,i.x+s/2,i.y+o/2]),c=zD(t?.dom,()=>{let d=document.createElementNS("http://www.w3.org/2000/svg","path");d.classList.add("trapezoid"),d.style.fill="none";let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),this.svg.appendChild(d),d},d=>{let u=this.createPathDString(l);return d.setAttribute("d",u+"Z"),d},r);return null===c?null:(c.style.fill=a,{dom:c,data:l})}dispose(){}}(t.container);break;case Yi.WEBGL:{let e=new aA;this.coordinator=e,this.renderer=new class{constructor(t,e,i,r){this.coordinator=e,this.scene=new n_,this.backgroundColor="#fff",jl_isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new Wi({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof so){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){if(!t&&!i.visible)return null;let{visible:r,width:o}=i;if(!t){let d=mV(this.backgroundColor,i.color,i.opacity??1),u=new Gi,p=new Gd({color:d}),h=new so(u,p);return p.visible=r,kte(u,e,o),this.scene.add(h),{type:Ql.LINE,data:e,obj3d:h,width:o}}let{data:a,obj3d:s,width:l}=t;return nA(this.backgroundColor,s,d=>((o!==l||!a||!jl_arePolylinesEqual(a,e))&&kte(d,e,o),d),i)?{type:Ql.LINE,data:e,obj3d:s,width:o}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:o}=e,a=mV(this.backgroundColor,r,o??1),s=new vm({color:a,visible:i});return new so(t,s)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y-o/3,e.x+r/2,e.y-o/3,e.x,e.y+2*o/3]);if(!t){let l=new Gi;Pte(l,a);let c=this.createMesh(l,i);return null===c?null:(this.scene.add(c),{type:Ql.TRIANGLE,data:e,obj3d:c})}return nA(this.backgroundColor,t.obj3d,l=>(Pte(l,a),l),i)?{type:Ql.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,o=new i_(i.radius);if(!t){let s=this.createMesh(o,i);return null===s?null:(s.position.set(e.x,e.y,0),this.scene.add(s),{type:Ql.CIRCLE,data:{loc:e,radius:r},obj3d:s})}return nA(this.backgroundColor,t.obj3d,()=>o,i)?(t.obj3d.position.set(e.x,e.y,0),{type:Ql.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o}=r,a=2/Math.sqrt(3)*o,s=new Wd([new $e(e.x-a/2,e.y-o/2),new $e(e.x,e.y+o/2),new $e(i.x,i.y+o/2),new $e(i.x+a/2,i.y-o/2)]);s.autoClose=!0;let l=new wm(s);if(!t){let d=this.createMesh(l,r);return null===d?null:(this.scene.add(d),{type:Ql.TRAPEZOID,data:[e,i],obj3d:d})}return nA(this.backgroundColor,t.obj3d,()=>l,r)?{type:Ql.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}}(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new oA({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(Ul(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(Ul(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect({x:0,y:0,...t}),this.renderer.onResize({x:0,y:0,...t}),this.seriesLineView.setLayoutRect({...t,x:0,y:0}),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let o=this.metadataMap[i];(!o||r.color!==o.color||r.visible!==o.visible||r.opacity!==o.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,(n=>{self.requestAnimationFrame(n)})(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}},Ds=(()=>(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"}(Ds||(Ds={})),Ds))(),p_=(()=>(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"}(p_||(p_={})),p_))();function Fte(n){if(n.includes("/"))throw new RangeError("Worker factory only allows file name and no resource path.");return new Worker(n)}var Tm=class{constructor(t){if(this.callbacks=t.callbacks,t.type!==Yi.WEBGL)throw new RangeError(`Cannot use non WEBGL renderer for the offscreen line chart. Received ${Yi[t.type]} `);let e=new MessageChannel;e.port1.onmessage=o=>{this.onMessageFromWorker(o.data)},this.txMessagePort=e.port1;let i=t.container.transferControlToOffscreen();this.workerInstance=Tm.workerPool.getNext();let r={type:Ds.INIT,canvas:i,devicePixelRatio:window.devicePixelRatio,dim:t.domDimension,rendererType:t.type,useDarkMode:t.useDarkMode};this.workerInstance.postMessage(r,[i,e.port2])}dispose(){this.sendMessage({type:Ds.DISPOSED}),this.workerInstance.free(),this.txMessagePort.close()}setXScaleType(t){this.sendMessage({type:Ds.SCALE_UPDATED,axis:"x",scaleType:t})}setYScaleType(t){this.sendMessage({type:Ds.SCALE_UPDATED,axis:"y",scaleType:t})}resize(t){this.sendMessage({type:Ds.DOM_RESIZED,dim:t})}setMetadata(t){this.sendMessage({type:Ds.SERIES_METADATA_CHANGED,metadata:t})}setViewBox(t){this.sendMessage({type:Ds.VIEW_BOX_UPDATED,extent:t})}setData(t){let e=function(n){let t=n.reduce((o,a)=>o+a.points.length,0),e=0,i=new Float64Array(2*t),r=[];for(let o of n){r.push({id:o.id,length:o.points.length});for(let a=0;a<o.points.length;a++)i[e++]=o.points[a].x,i[e++]=o.points[a].y}return{idsAndLengths:r,flattenedSeries:i.buffer}}(t);this.sendMessage({type:Ds.SERIES_DATA_UPDATED,compactDataSeries:e},[e.flattenedSeries])}setUseDarkMode(t){this.sendMessage({type:Ds.DARK_MODE_UPDATED,useDarkMode:t})}sendMessage(t,e){e?this.txMessagePort.postMessage(t,e):this.txMessagePort.postMessage(t)}onMessageFromWorker(t){switch(t.type){case p_.ON_REDRAW_END:this.callbacks.onDrawEnd();break;case p_.ON_CONTEXT_LOST:this.callbacks.onContextLost()}}};function Xc(n,t){return"x"===t?[0,n.width]:[n.height,0]}function Yx(n,t){let e=Math.floor(n/50);return Math.min(e,t)}function cA(n,t,e,i){return{major:[],minor:n.ticks(i,e).map(o=>({value:o,tickFormattedString:t.formatTick(o)}))}}Tm.workerPool=new class{constructor(t,e=10,i=Fte){this.workerResourcePath=t,this.maxPoolSize=e,this.workerFactory=i,this.workers=[]}getNext(){let t;if(this.workers.every(({activeCount:i})=>i>0)&&this.workers.length<this.maxPoolSize){let i=this.workerFactory(this.workerResourcePath);t={activeCount:0,postMessage:(r,o)=>{i.postMessage(r,o)},free:()=>{t.activeCount=Math.max(t.activeCount-1,0)}},this.workers.push(t)}else{let i=this.workers.map(({activeCount:o})=>o),r=i.indexOf(Math.min(...i));t=this.workers[r]}return t.activeCount++,t}}("chart_worker.js?_file_hash=2c1e71c5");var gV=document.createElement("canvas").getContext("2d");function Vte(n){for(let t of n)if(String(t).includes("e"))return!0;return!1}var Qx={getStandardTicks:cA,getTicksForTemporalScale:function(n,t,e,i){let[r,o]=i,a=n.ticks(i,2);if(o-r>=864e5||a.length>2)return cA(n,t,e,i);let s=n.ticks(i,e);return{major:a.map(l=>({start:l,tickFormattedString:t.formatShort(l)})),minor:s.map(l=>({value:l,tickFormattedString:t.formatTick(l)}))}},getTicksForLinearScale:function(n,t,e,i){let[r,o]=i,a=Math.abs(o-r);if(a>.001)return cA(n,t,e,i);let s=n.ticks([r,o],e),l=n.ticks([r,o],2);if(Vte(s)||Vte(l))return cA(n,t,e,i);let c=[],d=function(n){let t=n.toExponential().split("e-",2);return 2===t.length?Number(t[1])-1:0}(a);a<1&&l.every(h=>{let m=Math.abs(h);return m>=0&&m<1})&&(d+=1);let u=new Map;for(let h of l){let[m,_=""]=String(h).split(".",2),M=Number(m+"."+_.slice(0,d));u.set(M,{start:M,tickFormattedString:0===M?"\u2014":t.formatReadable(M)})}let p=10*Math.pow(10,-d);for(let h of s)for(let m of[...u.keys()].reverse()){let _=h-m;if(_>=0&&_<p){if(0===m)c.push({value:h,tickFormattedString:t.formatTick(h)});else{let M=String(h).slice(String(m).length);c.push({value:h,tickFormattedString:`\u2026${M||"0"}`})}break}}return{major:Array.from(u.values()),minor:c}},filterTicksByVisibility:function(n,t,e,i,r=5){if(!n.length||!gV)return n;let o="x"===e?1:-1,a=null;return n.filter(s=>{let l=t(s);gV.font=i;let c=gV.measureText(s.tickFormattedString),d="x"===e?c.width:c.actualBoundingBoxAscent-c.actualBoundingBoxDescent;return null===a?!(l+o*d<0||(a=l+o*d,0)):!(o*(a+o*r-l)>0||(a=l+o*d,0))})}};function MNe(n,t){if(1&n&&(qn(),f(0,"g",17)(1,"text"),T(2),g(),f(3,"title"),T(4),g()()),2&n){let e=t.$implicit,i=w();v(1),Bt("font",i.axisFont),Be("x",i.textXPosition(e.value))("y",i.textYPosition(e.value)),v(1),Ve(" ",e.tickFormattedString," "),v(2),kt(i.getFormatter().formatLong(e.value))}}function wNe(n,t){if(1&n&&(f(0,"span",20)(1,"span"),T(2),g()()),2&n){let e=t.$implicit,i=t.index,r=t.last,o=w(2);Bt("left",o.getMajorXPosition(e),"px")("width",o.getMajorWidthString(e,r,o.majorTicks[i+1]))("bottom",o.getMajorYPosition(e),"px")("height",o.getMajorHeightString(e,r,o.majorTicks[i+1]))("font",o.axisFont),nt("major-label",!0)("last",r),b("title",o.getFormatter().formatLong(e.start)),v(2),kt(e.tickFormattedString)}}function SNe(n,t){if(1&n&&(f(0,"div",18),S(1,wNe,3,16,"span",19),g()),2&n){let e=w();v(1),b("ngForOf",e.majorTicks)("ngForTrackBy",e.trackByMajorTick)}}var Hte=(()=>{class n{constructor(){this.onViewExtentChange=new F,this.editMenuOpened=!1,this.majorTicks=[],this.minorTicks=[]}ngOnChanges(){let e=null,r=Yx("x"===this.axis?this.domDim.width:this.domDim.height,this.gridCount);e=this.scale instanceof nx?Qx.getTicksForLinearScale(this.scale,this.getFormatter(),r,this.axisExtent):this.scale instanceof ix?Qx.getTicksForTemporalScale(this.scale,this.getFormatter(),r,this.axisExtent):Qx.getStandardTicks(this.scale,this.getFormatter(),r,this.axisExtent),this.majorTicks=e.major,this.minorTicks=Qx.filterTicksByVisibility(e.minor,o=>this.getDomPos(o.value),this.axis,"11px Roboto, sans-serif")}getFormatter(){return this.customFormatter??this.scale.defaultFormatter}trackByMinorTick(e){return e.value}trackByMajorTick(e){return e.start}getDomPos(e){return this.scale.forward(this.axisExtent,Xc(this.domDim,this.axis),e)}textXPosition(e){return"x"===this.axis?String(this.getDomPos(e)):"100%"}textYPosition(e){return"x"===this.axis?"":String(this.getDomPos(e))}getMajorXPosition(e){return"y"===this.axis?0:Math.min(this.domDim.width,Math.max(0,this.getDomPos(e.start)))}getMajorWidthString(e,i,r){return"y"===this.axis?"":(i||!r?this.domDim.width:this.getMajorXPosition(r))-this.getMajorXPosition(e)+"px"}getMajorYPosition(e){return"x"===this.axis?0:this.domDim.height-Math.min(this.domDim.height,Math.max(0,this.getDomPos(e.start)))}getMajorHeightString(e,i,r){return"x"===this.axis?"":(i||!r?this.domDim.height:this.getMajorYPosition(r))-this.getMajorYPosition(e)+"px"}keydownPreventClose(e){"Escape"!==e.key&&e.stopPropagation()}extentChanged(e,i){let r=Number(e),o=Number(i);if(o<r){let a=r;r=o,o=a}!Number.isFinite(r)||!Number.isFinite(o)||this.onViewExtentChange.emit([r,o])}onAxisUpdateMenuOpen(e,i,r){e.value=String(r[0]),i.value=String(r[1]),e.focus()}setEditMenuOpened(e){this.editMenuOpened=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["line-chart-axis"]],inputs:{axisExtent:"axisExtent",axis:"axis",scale:"scale",gridCount:"gridCount",domDim:"domDim",customFormatter:"customFormatter"},outputs:{onViewExtentChange:"onViewExtentChange"},features:[qt],decls:26,vars:11,consts:[[1,"line"],[1,"minor"],[1,"ticks"],["class","minor-tick-label",4,"ngFor","ngForOf","ngForTrackBy"],["mat-icon-button","","title","Click to manually set min & max values",1,"extent-edit-button",3,"matMenuTriggerFor","menuOpened","menuClosed"],["matMenuTrigger","matMenuTrigger"],["svgIcon","edit_24px"],["class","major ticks",4,"ngIf"],["xPosition","before",3,"yPosition"],["manualControl","matMenu"],[1,"extent-edit-input",3,"click","keydown"],["type","number",3,"value"],["minInput",""],["maxInput",""],[1,"extent-edit-control",3,"keydown"],["mat-raised-button","","color","primary",1,"extent-edit-change",3,"click"],["mat-stroked-button","",1,"extent-edit-cancel",3,"click"],[1,"minor-tick-label"],[1,"major","ticks"],[3,"major-label","last","left","width","bottom","height","font","title",4,"ngFor","ngForOf","ngForTrackBy"],[3,"title"]],template:function(e,i){if(1&e){let r=Te();f(0,"div"),k(1,"div",0),f(2,"div",1),qn(),f(3,"svg",2),S(4,MNe,5,6,"g",3),g(),ua(),f(5,"button",4,5),A("menuOpened",function(){ne(r);let a=st(15),s=st(20);return i.onAxisUpdateMenuOpen(a,s,i.axisExtent),ie(i.setEditMenuOpened(!0))})("menuClosed",function(){return i.setEditMenuOpened(!1)}),k(7,"mat-icon",6),g()(),S(8,SNe,2,2,"div",7),g(),f(9,"mat-menu",8,9)(11,"div",10),A("click",function(a){return a.stopPropagation()})("keydown",function(a){return i.keydownPreventClose(a)}),f(12,"label"),T(13,"min"),g(),k(14,"input",11,12),g(),f(16,"div",10),A("click",function(a){return a.stopPropagation()})("keydown",function(a){return i.keydownPreventClose(a)}),f(17,"label"),T(18,"max"),g(),k(19,"input",11,13),g(),f(21,"div",14),A("keydown",function(a){return i.keydownPreventClose(a)}),f(22,"button",15),A("click",function(){ne(r);let a=st(15),s=st(20),l=st(6);return i.extentChanged(a.value,s.value),ie(l.closeMenu())}),T(23," Change "),g(),f(24,"button",16),A("click",function(){return ne(r),ie(st(6).closeMenu())}),T(25," Cancel "),g()()()}if(2&e){let r=st(10);Xo(i.axis+"-axis axis"),v(4),b("ngForOf",i.minorTicks)("ngForTrackBy",i.trackByMinorTick),v(1),nt("extent-edit-menu-opened",i.editMenuOpened),b("matMenuTriggerFor",r),v(3),b("ngIf",i.majorTicks.length),v(1),b("yPosition","y"===i.axis?"above":"below"),v(5),b("value",i.axisExtent[0]),v(5),b("value",i.axisExtent[1])}},dependencies:[nn,Ne,ki,Er,bn,Xu,Yu],styles:["[_nghost-%COMP%]{contain:strict;display:flex;overflow:hidden}.major-label[_ngcontent-%COMP%], text[_ngcontent-%COMP%]{fill:currentColor;font-size:11px;user-select:none}.axis[_ngcontent-%COMP%]{display:flex;height:100%;width:100%}.axis[_ngcontent-%COMP%]   .extent-edit-button[_ngcontent-%COMP%]{--tb-icon-width: 16px;--tb-icon-height: 16px;height:24px;position:absolute;right:5px;top:5px;visibility:hidden;width:24px;padding:0}.major[_ngcontent-%COMP%], .minor[_ngcontent-%COMP%]{flex:1 0;overflow:hidden}.line[_ngcontent-%COMP%]{background-color:#aaa;flex:0 0 1px;justify-content:stretch}.ticks[_ngcontent-%COMP%]{height:100%;position:relative;width:100%}.x-axis[_ngcontent-%COMP%]{flex-direction:column}.x-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-bottom:3px}.x-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:text-before-edge;text-anchor:middle}.x-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.y-axis[_ngcontent-%COMP%]{flex-direction:row-reverse}.y-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-left:5px}.y-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:central;text-anchor:end}.y-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.extent-edit-input[_ngcontent-%COMP%]{align-items:center;column-gap:5px;display:grid;font-size:12px;grid-template-columns:30px minmax(auto, 100px);height:30px;margin:10px 20px}.extent-edit-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background-color:inherit;border-radius:4px;border-style:solid;color:inherit}.extent-edit-control[_ngcontent-%COMP%]{align-items:center;display:flex;flex-direction:row-reverse;justify-content:flex-end;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;height:30px;line-height:1.4;margin-left:5px;padding:0 10px}.axis[_ngcontent-%COMP%]:hover   .extent-edit-button[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]:focus-within   .extent-edit-button[_ngcontent-%COMP%], .extent-edit-menu-opened[_ngcontent-%COMP%]{visibility:visible}.major[_ngcontent-%COMP%]{position:relative;overflow:hidden;contain:strict}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;overflow:hidden;position:absolute;white-space:nowrap}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]   span[_ngcontent-%COMP%]{max-width:100%}.x-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-left:1px solid #9e9e9e;padding:0 5px}.x-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-right:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-bottom:1px solid #9e9e9e;height:100%;padding:5px 0;width:100%}.y-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-top:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})();function Zx(n,t){let e=Math.min(Lc(n.map(({x:o})=>o),t),n.length-1),i=Math.max(0,e-1);return Math.abs(n[i].x-t)-Math.abs(n[e].x-t)<=0?i:e}function zte(n,t,e,i,r,o){let a;switch(n.deltaMode){case WheelEvent.DOM_DELTA_PIXEL:a=1;break;case WheelEvent.DOM_DELTA_LINE:a=8;break;case WheelEvent.DOM_DELTA_PAGE:a=20;break;default:a=1,console.warn(`Unknown WheelEvent deltaMode: ${n.deltaMode}.`)}let s=n.deltaY*a,l=s<0?Math.max(s*i,-.95):s*i,{width:c,height:d}=e,u=[r.reverse(t.x,[0,c],-n.offsetX*l),r.reverse(t.x,[0,c],c+(c-n.offsetX)*l)],p=[o.reverse(t.y,[d,0],-n.offsetY*l),o.reverse(t.y,[d,0],d+(d-n.offsetY)*l)];return{x:u[1]<u[0]?[u[1],u[0]]:u,y:p[1]<p[0]?[p[1],p[0]]:p}}var DNe=["dots"];function INe(n,t){if(1&n&&(qn(),k(0,"circle",11)),2&n){let e=w().$implicit,i=w(2);Be("cx",i.getDomX(e.dataPoint.x))("cy",i.getDomY(e.dataPoint.y))("fill",e.metadata.color)}}function ANe(n,t){if(1&n&&(qn(),Gt(0),S(1,INe,1,3,"circle",10),Wt()),2&n){let e=t.$implicit,i=w(2);v(1),b("ngIf",i.shouldRenderTooltipPoint(e.dataPoint))}}function RNe(n,t){if(1&n&&(qn(),Gt(0),S(1,ANe,2,1,"ng-container",9),Wt()),2&n){let e=w();v(1),b("ngForOf",e.cursoredData)("ngForTrackBy",e.trackBySeriesName)}}function PNe(n,t){if(1&n&&(qn(),k(0,"rect",12)),2&n){let e=w();Be("x",e.zoomBoxInUiCoordinate.x)("width",e.zoomBoxInUiCoordinate.width)("y",e.zoomBoxInUiCoordinate.y)("height",e.zoomBoxInUiCoordinate.height)}}var kNe=function(n,t,e){return{data:n,cursorLocationInDataCoord:t,cursorLocation:e}};function ONe(n,t){if(1&n&&(f(0,"div",14),hi(1,15),g()),2&n){let e=w(2),i=st(11);v(1),b("ngTemplateOutlet",e.tooltipTemplate?e.tooltipTemplate:i)("ngTemplateOutletContext",yb(2,kNe,e.cursoredData,e.cursorLocationInDataCoord,e.cursorLocation))}}function FNe(n,t){if(1&n){let e=Te();S(0,ONe,2,6,"ng-template",13),A("detach",function(){return ne(e),ie(w().onTooltipDisplayDetached())})}if(2&n){let e=w();b("cdkConnectedOverlayOrigin",e.tooltipOriginEl)("cdkConnectedOverlayOpen",e.tooltipDisplayAttached&&e.state.getValue()===e.InteractionState.NONE)("cdkConnectedOverlayPositions",e.tooltipPositions)("cdkConnectedOverlayScrollStrategy",e.scrollStrategy)("cdkConnectedOverlayLockPosition",!1)("cdkConnectedOverlayFlexibleDimensions",!0)("cdkConnectedOverlayGrowAfterOpen",!0)}}function NNe(n,t){if(1&n&&(Gt(0),f(1,"tr",17)(2,"td",18),k(3,"span"),g(),f(4,"td",19),T(5),g(),f(6,"td"),T(7),g(),f(8,"td"),T(9),g()(),Wt()),2&n){let e=t.$implicit;v(3),Bt("background-color",e.metadata.color),v(2),kt(e.metadata.displayName),v(2),kt(e.dataPoint.y),v(2),kt(e.dataPoint.x)}}function LNe(n,t){if(1&n&&(f(0,"table")(1,"thead")(2,"tr"),k(3,"th",16),f(4,"th"),T(5,"Name"),g(),f(6,"th"),T(7,"Y"),g(),f(8,"th"),T(9,"X"),g()()(),f(10,"tbody"),S(11,NNe,10,5,"ng-container",9),g()()),2&n){let e=t.data,i=w();v(11),b("ngForOf",e)("ngForTrackBy",i.trackBySeriesName)}}function VNe(n){return n.scrollStrategies.reposition()}var Ute=(()=>{class n{constructor(e,i){this.changeDetector=e,this.scrollStrategy=i,this.onViewExtentChange=new F,this.onViewExtentReset=new F,this.onInteractionStateChange=new F,this.InteractionState=Tr,this.state=new xr(Tr.NONE),this.specialKeyPressed=!1,this.zoomBoxInUiCoordinate={x:0,width:0,height:0,y:0},this.tooltipPositions=[{offsetY:5,originX:"start",overlayX:"start",originY:"bottom",overlayY:"top"},{offsetY:5,originX:"end",overlayX:"end",originY:"bottom",overlayY:"top"},{offsetY:-15,originX:"start",overlayX:"start",originY:"top",overlayY:"bottom"},{offsetY:-15,originX:"end",overlayX:"end",originY:"top",overlayY:"bottom"},{offsetX:5,originX:"end",overlayX:"start",originY:"top",overlayY:"top"},{offsetX:-5,originX:"start",overlayX:"end",originY:"top",overlayY:"top"}],this.cursorLocationInDataCoord=null,this.cursorLocation=null,this.cursoredData=[],this.tooltipDisplayAttached=!1,this.showZoomInstruction=!1,this.dragStartCoord=null,this.isCursorInside=!1,this.ngUnsubscribe=new Ee,this.subscriptions=[]}ngAfterViewInit(){this.subscriptions.push(this.state.subscribe(e=>{this.onInteractionStateChange.emit(e)})),this.ngUnsubscribe.pipe(q(()=>{this.subscriptions.forEach(e=>e.unsubscribe())})),Ei(this.dotsContainer.nativeElement,"dblclick",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(()=>{this.onViewExtentReset.emit(),this.state.next(Tr.NONE),this.changeDetector.markForCheck()}),Ei(window,"keydown",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),Ei(window,"keyup",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),Ei(this.dotsContainer.nativeElement,"mousedown",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{let i=this.state.getValue(),r=this.shouldPan(e)?Tr.PANNING:Tr.DRAG_ZOOMING;i===Tr.NONE&&r===Tr.DRAG_ZOOMING&&(this.dragStartCoord={x:e.offsetX,y:e.offsetY},this.zoomBoxInUiCoordinate={x:e.offsetX,width:0,y:e.offsetY,height:0}),i!==r&&(this.state.next(r),this.changeDetector.markForCheck())}),Ei(this.dotsContainer.nativeElement,"mouseup",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{let i=(e.buttons&Cs.LEFT)===Cs.LEFT;this.dragStartCoord=null;let r=this.zoomBoxInUiCoordinate;if(!i&&this.state.getValue()===Tr.DRAG_ZOOMING&&r.width>0&&r.height>0){let o=this.getDataX(r.x),a=this.getDataX(r.x+r.width),s=this.getDataY(r.y+r.height),l=this.getDataY(r.y);this.onViewExtentChange.emit({dataExtent:{x:[o,a],y:[s,l]}})}this.state.getValue()!==Tr.NONE&&(this.state.next(Tr.NONE),this.changeDetector.markForCheck())}),Ei(this.dotsContainer.nativeElement,"mouseenter",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{this.isCursorInside=!0,this.updateTooltip(e),this.changeDetector.markForCheck()}),Ei(this.dotsContainer.nativeElement,"mouseleave",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{this.dragStartCoord=null,this.isCursorInside=!1,this.updateTooltip(e),this.state.next(Tr.NONE),this.changeDetector.markForCheck()}),Ei(this.dotsContainer.nativeElement,"mousemove",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>{switch(this.state.getValue()){case Tr.SCROLL_ZOOMING:this.state.next(Tr.NONE),this.updateTooltip(e),this.changeDetector.markForCheck();break;case Tr.NONE:this.updateTooltip(e),this.changeDetector.markForCheck();break;case Tr.PANNING:{let i=-e.movementX,r=-e.movementY,{width:o,height:a}=this.domDim,s=this.getDataX(i),l=this.getDataX(o+i),c=this.getDataY(a+r),d=this.getDataY(r);this.onViewExtentChange.emit({dataExtent:{x:[s,l],y:[c,d]}});break}case Tr.DRAG_ZOOMING:{if(!this.dragStartCoord)break;let i=[this.dragStartCoord.x,e.offsetX],r=[this.dragStartCoord.y,e.offsetY];this.zoomBoxInUiCoordinate={x:Math.min(...i),width:Math.max(...i)-Math.min(...i),y:Math.min(...r),height:Math.max(...r)-Math.min(...r)}}this.changeDetector.markForCheck()}}),Ei(this.dotsContainer.nativeElement,"wheel",{passive:!1}).pipe(it(this.ngUnsubscribe),Jn(e=>{let i=!e.ctrlKey&&!e.shiftKey&&e.altKey;return this.showZoomInstruction=!i,this.changeDetector.markForCheck(),i?(e.preventDefault(),$t(e)):rs(3e3).pipe(Dt(()=>{this.showZoomInstruction=!1,this.changeDetector.markForCheck()}),q(()=>null))}),Oe(e=>Boolean(e))).subscribe(e=>{this.onViewExtentChange.emit({dataExtent:zte(e,this.viewExtent,this.domDim,.01,this.xScale,this.yScale)}),this.state.getValue()!==Tr.SCROLL_ZOOMING&&(this.state.next(Tr.SCROLL_ZOOMING),this.changeDetector.markForCheck())})}ngOnChanges(){this.updateCursoredDataAndTooltipVisibility()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}shouldPan(e){let i=e.shiftKey||e.altKey;if(e instanceof KeyboardEvent)return i;let r=(e.buttons&Cs.LEFT)===Cs.LEFT,o=(e.buttons&Cs.MIDDLE)===Cs.MIDDLE;return!(!r&&!o)&&(o&&!r||i)}trackBySeriesName(e,i){return i.id}getDomX(e){return this.xScale.forward(this.viewExtent.x,Xc(this.domDim,"x"),e)}getDataX(e){return this.xScale.reverse(this.viewExtent.x,Xc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Xc(this.domDim,"y"),e)}getDataY(e){return this.yScale.reverse(this.viewExtent.y,Xc(this.domDim,"y"),e)}shouldRenderTooltipPoint(e){return null!==e&&!isNaN(e.x)&&!isNaN(e.y)}updateTooltip(e){this.cursorLocationInDataCoord={x:this.getDataX(e.offsetX),y:this.getDataY(e.offsetY)},this.cursorLocation={x:e.offsetX,y:e.offsetY},this.updateCursoredDataAndTooltipVisibility()}onTooltipDisplayDetached(){this.tooltipDisplayAttached=!1}updateCursoredDataAndTooltipVisibility(){let e=this.cursorLocationInDataCoord;if(null===e)return this.cursoredData=[],void(this.tooltipDisplayAttached=!1);this.cursoredData=this.isCursorInside?this.seriesData.map(i=>({seriesDatum:i,metadata:this.seriesMetadataMap[i.id]})).filter(({metadata:i})=>i&&i.visible&&!Boolean(i.aux)).map(({seriesDatum:i,metadata:r})=>{let o=Zx(i.points,e.x),a=i.points[o];return{id:i.id,closestPointIndex:o,dataPoint:a,domPoint:{x:this.getDomX(a.x),y:this.getDomY(a.y)},metadata:r}}).filter(i=>i):[],this.tooltipDisplayAttached=Boolean(this.cursoredData.length)}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(Ih))},n.\u0275cmp=P({type:n,selectors:[["line-chart-interactive-view"]],viewQuery:function(e,i){if(1&e&&(Ue(DNe,7,xe),Ue(Vu,5)),2&e){let r;be(r=ve())&&(i.dotsContainer=r.first),be(r=ve())&&(i.overlay=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&nt("show-zoom-instruction",i.showZoomInstruction)},inputs:{seriesData:"seriesData",seriesMetadataMap:"seriesMetadataMap",viewExtent:"viewExtent",xScale:"xScale",yScale:"yScale",domDim:"domDim",tooltipOriginEl:"tooltipOriginEl",tooltipTemplate:"tooltipTemplate",disableTooltip:"disableTooltip"},outputs:{onViewExtentChange:"onViewExtentChange",onViewExtentReset:"onViewExtentReset",onInteractionStateChange:"onInteractionStateChange"},features:[Vt([{provide:Ih,useFactory:VNe,deps:[Oi]}]),qt],decls:12,vars:9,consts:[[1,"dots"],["dots",""],[4,"ngIf"],["class","zoom-box",4,"ngIf"],[1,"zoom-instruction"],[1,"instruction-content"],["cdkOverlayOrigin","",1,"tooltip-origin"],["tooltipOrigin","cdkOverlayOrigin"],["defaultTooltip",""],[4,"ngFor","ngForOf","ngForTrackBy"],["r","4",4,"ngIf"],["r","4"],[1,"zoom-box"],["cdkConnectedOverlay","",3,"cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayLockPosition","cdkConnectedOverlayFlexibleDimensions","cdkConnectedOverlayGrowAfterOpen","detach"],[1,"tooltip-container"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"circle-header"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]],template:function(e,i){1&e&&(qn(),f(0,"svg",0,1),S(2,RNe,2,2,"ng-container",2),S(3,PNe,1,4,"rect",3),g(),ua(),f(4,"div",4)(5,"span",5),T(6,"Alt + Scroll to Zoom"),g()(),k(7,"div",6,7),S(9,FNe,1,7,null,2),S(10,LNe,12,2,"ng-template",null,8,jt)),2&e&&(nt("pannable",i.specialKeyPressed)("draggable",i.state.getValue()===i.InteractionState.NONE||i.state.getValue()===i.InteractionState.DRAG_ZOOMING)("panning",i.state.getValue()===i.InteractionState.PANNING),v(2),b("ngIf",i.state.getValue()===i.InteractionState.NONE),v(1),b("ngIf",i.state.getValue()===i.InteractionState.DRAG_ZOOMING),v(6),b("ngIf",!i.disableTooltip))},dependencies:[nn,Ne,eo,Vu,Md],styles:["[_nghost-%COMP%]{display:flex;position:relative;user-select:none}.dots[_ngcontent-%COMP%]{height:100%;width:100%}.dots.draggable[_ngcontent-%COMP%]{cursor:crosshair}.dots.pannable[_ngcontent-%COMP%]{cursor:grab}.dots.panning[_ngcontent-%COMP%]{cursor:grabbing}.tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.6);display:inline-block;height:10px;width:10px}.tooltip-origin[_ngcontent-%COMP%]{bottom:0;left:0;position:absolute;right:0}.tooltip-container[_ngcontent-%COMP%]{background:rgba(0,0,0,.85);border-radius:4px;color:#fff;contain:paint style layout;font-size:.9em;overflow:auto;padding:5px;pointer-events:none;width:100%}th[_ngcontent-%COMP%], td[_ngcontent-%COMP%]{padding:2px 5px;text-align:left}th[_ngcontent-%COMP%]{font-weight:500;padding-bottom:5px}.zoom-box[_ngcontent-%COMP%]{fill-opacity:.03;fill:#000;stroke:#ccc}.zoom-instruction[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;left:0;opacity:0;pointer-events:none;position:absolute;right:0;top:10px;transition:opacity .5s;z-index:1}.instruction-content[_ngcontent-%COMP%]{background:rgba(0,0,0,.6);border-radius:5px;color:#fff;padding:5px 10px;user-select:none}.show-zoom-instruction[_nghost-%COMP%]   .zoom-instruction[_ngcontent-%COMP%]{opacity:1}"],changeDetection:0}),n})();function zNe(n,t){if(1&n&&(qn(),k(0,"line",2)),2&n){let e=t.$implicit,i=w();nt("zero",0===e),Be("x1",i.getDomX(e))("x2",i.getDomX(e))("y2",i.domDim.height)}}function UNe(n,t){if(1&n&&(qn(),k(0,"line",3)),2&n){let e=t.$implicit,i=w();nt("zero",0===e),Be("y1",i.getDomY(e))("x2",i.domDim.width)("y2",i.getDomY(e))}}var jte=(()=>{class n{getDomX(e){return this.xScale.forward(this.viewExtent.x,Xc(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Xc(this.domDim,"y"),e)}getXTicks(){return this.xScale.ticks(this.viewExtent.x,Yx(this.domDim.width,this.xGridCount))}getYTicks(){return this.yScale.ticks(this.viewExtent.y,Yx(this.domDim.height,this.yGridCount))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["line-chart-grid-view"]],inputs:{viewExtent:"viewExtent",xScale:"xScale",xGridCount:"xGridCount",yScale:"yScale",yGridCount:"yGridCount",domDim:"domDim"},decls:3,vars:2,consts:[["y1","0",3,"zero",4,"ngFor","ngForOf"],["x1","0",3,"zero",4,"ngFor","ngForOf"],["y1","0"],["x1","0"]],template:function(e,i){1&e&&(qn(),f(0,"svg"),S(1,zNe,1,5,"line",0),S(2,UNe,1,5,"line",1),g()),2&e&&(v(1),b("ngForOf",i.getXTicks()),v(1),b("ngForOf",i.getYTicks()))},dependencies:[nn],styles:["[_nghost-%COMP%] {\n        display: flex;\n        overflow: hidden;\n      }\n\n      svg[_ngcontent-%COMP%] {\n        height: 100%;\n        width: 100%;\n      }\n\n      line[_ngcontent-%COMP%] {\n        stroke: #ccc;\n        stroke-width: 1px;\n      }\n\n      .zero[_ngcontent-%COMP%] {\n        stroke: #aaa;\n        stroke-width: 1.5px;\n      }"],changeDetection:0}),n})(),GNe=["seriesView"],WNe=["xAxis"],qNe=["yAxis"],XNe=["chartEl"];function YNe(n,t){if(1&n&&k(0,"line-chart-grid-view",16),2&n){let e=w();b("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("xGridCount",e.X_GRID_COUNT)("yGridCount",e.Y_GRID_COUNT)("domDim",e.domDimensions.main)}}function QNe(n,t){1&n&&(qn(),k(0,"svg",null,17))}function ZNe(n,t){1&n&&k(0,"canvas",null,17)}function KNe(n,t){if(1&n&&(Gt(0),S(1,QNe,2,0,"svg",5),S(2,ZNe,2,0,"canvas",5),Wt()),2&n){let e=w();v(1),b("ngIf",e.getRendererType()===e.RendererType.SVG),v(1),b("ngIf",e.getRendererType()===e.RendererType.WEBGL)}}function JNe(n,t){if(1&n){let e=Te();f(0,"line-chart-interactive-view",18),A("onViewExtentChange",function(r){return ne(e),ie(w().onViewBoxChanged(r))})("onViewExtentReset",function(){return ne(e),ie(w().viewBoxReset())})("onInteractionStateChange",function(r){return ne(e),ie(w().onInteractionStateChange(r))}),g()}if(2&n){let e=w(),i=st(1);b("seriesData",e.seriesData)("seriesMetadataMap",e.seriesMetadataMap)("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("tooltipOriginEl",i)("domDim",e.domDimensions.main)("tooltipTemplate",e.tooltipTemplate)("disableTooltip",e.disableTooltip)}}var $Ne=function(n,t,e,i){return{xScale:n,yScale:t,domDimension:e,viewExtent:i}};function eLe(n,t){if(1&n&&(f(0,"div",19),hi(1,20),g()),2&n){let e=w();v(1),b("ngTemplateOutlet",e.customVisTemplate)("ngTemplateOutletContext",Rk(2,$Ne,e.xScale,e.yScale,e.domDimensions.main,e.viewBox))}}function tLe(n,t){if(1&n){let e=Te();f(0,"line-chart-axis",21),A("onViewExtentChange",function(r){return ne(e),ie(w().onViewBoxChangedFromAxis(r,"y"))}),g()}if(2&n){let e=w();b("axisExtent",e.viewBox.y)("customFormatter",e.customYFormatter)("domDim",e.domDimensions.yAxis)("gridCount",e.Y_GRID_COUNT)("scale",e.yScale)}}function nLe(n,t){if(1&n){let e=Te();f(0,"line-chart-axis",22),A("onViewExtentChange",function(r){return ne(e),ie(w().onViewBoxChangedFromAxis(r,"x"))}),g()}if(2&n){let e=w();b("axisExtent",e.viewBox.x)("customFormatter",e.customXFormatter)("domDim",e.domDimensions.xAxis)("gridCount",e.X_GRID_COUNT)("scale",e.xScale)}}function iLe(n,t){1&n&&(f(0,"div",23),k(1,"span",24),g())}var rLe=function(n,t,e,i,r){return{xScale:n,yScale:t,domDimension:e,viewExtent:i,interactionState:r}};function oLe(n,t){if(1&n&&(f(0,"div",25,26),hi(2,20),g()),2&n){let e=w();v(2),b("ngTemplateOutlet",e.customChartOverlayTemplate)("ngTemplateOutletContext",Pk(2,rLe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox,e.interactionState))}}var aLe=function(n,t){return{container:!0,"dark-mode":n,"line-only-mode":t,"line-chart":!0}},_V={x:[0,1],y:[0,1]},h_=(()=>{class n{constructor(e){this.changeDetector=e,this.RendererType=Yi,this.useDarkMode=!1,this.preferredRendererType=Yi.WEBGL,this.xScaleType=tr.LINEAR,this.yScaleType=tr.LINEAR,this.userViewBox=null,this.lineOnly=!1,this.disableTooltip=!1,this.viewBoxChanged=new F,this.onViewBoxOverridden=new Lp(1),this.ignoreYOutliers=!1,this.Y_GRID_COUNT=6,this.X_GRID_COUNT=10,this.xScale=Ul(this.xScaleType),this.yScale=Ul(this.xScaleType),this.viewBox=_V,this.domDimensions={main:{width:0,height:0},xAxis:{width:0,height:0},yAxis:{width:0,height:0}},this.showChartRendererElement=!0,this.interactionState=Tr.NONE,this.lineChart=null,this.isDataUpdated=!1,this.isMetadataUpdated=!1,this.isFixedViewBoxUpdated=!1,this.isViewBoxOverridden=!1,this.useDarkModeUpdated=!1,this.userViewBoxUpdated=!1,this.isViewBoxChanged=!0,this.scaleUpdated=!0,this.isRenderingContextLost=!1}ngOnInit(){this.onViewBoxOverridden.next(this.isViewBoxOverridden)}ngOnChanges(e){e.xScaleType&&(this.xScale=Ul(this.xScaleType),this.scaleUpdated=!0),e.yScaleType&&(this.yScale=Ul(this.yScaleType),this.scaleUpdated=!0),e.seriesData&&(this.isDataUpdated=!0),e.fixedViewBox&&(this.isFixedViewBoxUpdated=!0),e.seriesMetadataMap&&(this.isMetadataUpdated=!0),e.useDarkMode&&(this.useDarkModeUpdated=!0),e.userViewBox&&(this.userViewBoxUpdated=!0),this.userViewBoxUpdated?this.setIsViewBoxOverridden(!!this.userViewBox):this.scaleUpdated&&this.setIsViewBoxOverridden(!1),this.isViewBoxChanged=this.isViewBoxChanged||this.userViewBoxUpdated||this.scaleUpdated||!this.isViewBoxOverridden&&this.shouldUpdateDefaultViewBox(e),this.updateLineChart()}ngAfterViewInit(){this.initializeChart(),this.updateLineChart(),this.changeDetector.detectChanges()}recoverRendererIfNeeded(){!this.isRenderingContextLost||this.disableUpdate||(this.showChartRendererElement=!1,this.changeDetector.detectChanges(),this.showChartRendererElement=!0,this.changeDetector.detectChanges(),this.initializeChart(),this.scaleUpdated=!0,this.isMetadataUpdated=!0,this.isDataUpdated=!0,this.useDarkModeUpdated=!0,this.isFixedViewBoxUpdated=!0,this.isViewBoxChanged=!0,this.isRenderingContextLost=!1)}onViewResize(){!this.lineChart||(this.readAndUpdateDomDimensions(),this.lineChart.resize(this.domDimensions.main),this.changeDetector.detectChanges())}shouldUpdateDefaultViewBox(e){if(e.xScaleType||e.yScaleType||e.ignoreYOutliers||e.seriesData)return!0;let r=e.seriesMetadataMap;if(r){let o=r.previousValue;if(Object.keys(this.seriesMetadataMap).length!==Object.keys(o??{}).length)return!0;for(let[a,s]of Object.entries(this.seriesMetadataMap)){let l=o&&o[a];if(!l||s.visible!==l.visible)return!0}}return!1}onContextLost(){this.isRenderingContextLost=!0,this.lineChart&&(this.lineChart.dispose(),this.lineChart=null)}triggerContextLostForTest(){this.onContextLost()}getLineChartForTest(){return this.lineChart}initializeChart(){this.lineChart&&this.lineChart.dispose();let e=this.getRendererType(),i={onDrawEnd:()=>{},onContextLost:this.onContextLost.bind(this)},r=null;switch(this.readAndUpdateDomDimensions(),e){case Yi.SVG:r={type:Yi.SVG,container:this.chartEl.nativeElement,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;case Yi.WEBGL:r={type:Yi.WEBGL,container:this.chartEl.nativeElement,devicePixelRatio:window.devicePixelRatio,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;default:throw new Error(`<line-chart> does not yet support rendererType: ${e}`)}let a=e!==Yi.SVG&&jl_isWebGl2OffscreenCanvasSupported()?Tm:sA;this.lineChart=new a(r)}ngOnDestroy(){this.lineChart&&this.lineChart.dispose()}getRendererType(){return function(n){switch(n){case Yi.SVG:return Yi.SVG;case Yi.WEBGL:return jl_isWebGl2Supported()?Yi.WEBGL:Yi.SVG;default:throw new Error(`Unknown rendererType: ${n}`)}}(this.preferredRendererType)}readAndUpdateDomDimensions(){this.domDimensions={main:{width:this.seriesView.nativeElement.clientWidth,height:this.seriesView.nativeElement.clientHeight},xAxis:{width:this.xAxis.nativeElement.clientWidth,height:this.xAxis.nativeElement.clientHeight},yAxis:{width:this.yAxis.nativeElement.clientWidth,height:this.yAxis.nativeElement.clientHeight}}}updateLineChart(){if(this.recoverRendererIfNeeded(),this.lineChart&&!this.disableUpdate){if(this.scaleUpdated&&(this.scaleUpdated=!1,this.lineChart.setXScaleType(this.xScaleType),this.lineChart.setYScaleType(this.yScaleType)),this.isMetadataUpdated&&(this.isMetadataUpdated=!1,this.lineChart.setMetadata(this.seriesMetadataMap)),this.isDataUpdated&&(this.isDataUpdated=!1,this.lineChart.setData(this.seriesData)),this.useDarkModeUpdated&&(this.useDarkModeUpdated=!1,this.lineChart.setUseDarkMode(this.useDarkMode)),this.userViewBoxUpdated&&(this.userViewBoxUpdated=!1),this.isViewBoxOverridden&&this.userViewBox)this.viewBox=this.userViewBox;else if(!this.isViewBoxOverridden&&this.fixedViewBox)this.viewBox=this.fixedViewBox;else if(!this.isViewBoxOverridden&&this.isViewBoxChanged){let i=function(n,t,e,i,r){let o=null,a=null,s=[];for(let{id:u,points:p}of n){let h=t[u];if(h&&!h.aux&&h.visible)for(let m=0;m<p.length;m++){let{x:_,y:M}=p[m];i(_)&&(o=null===o||_<o?_:o,a=null===a||_>a?_:a),r(M)&&s.push(M)}}s.sort(al);let c=s[0],d=s[s.length-1];return e&&s.length>2&&(c=s[Math.ceil(.05*(s.length-1))],d=s[Math.floor(.95*(s.length-1))]),{x:null!==o&&null!==a?[o,a]:void 0,y:void 0!==c&&void 0!==d?[c,d]:void 0}}(this.seriesData,this.seriesMetadataMap,this.ignoreYOutliers,this.xScale.isSafeNumber,this.yScale.isSafeNumber);this.viewBox={x:this.xScale.niceDomain(i.x??_V.x),y:this.yScale.niceDomain(i.y??_V.y)}}(this.isFixedViewBoxUpdated||this.isViewBoxChanged)&&(this.isFixedViewBoxUpdated=!1,this.isViewBoxChanged=!1,this.lineChart.setViewBox(this.viewBox),this.changeDetector.detectChanges())}}onViewBoxChanged({dataExtent:e}){this.viewBoxChanged.emit(e)}viewBoxReset(){this.viewBoxChanged.emit(null)}setIsViewBoxOverridden(e){let i=this.isViewBoxOverridden;this.isViewBoxOverridden=e,i!==e&&this.onViewBoxOverridden.next(e)}onInteractionStateChange(e){this.interactionState=e}getIsViewBoxOverridden(){return this.onViewBoxOverridden}onViewBoxChangedFromAxis(e,i){let r={...this.viewBox,[i]:e};this.onViewBoxChanged({dataExtent:r})}}return n.\u0275fac=function(e){return new(e||n)(C(Qt))},n.\u0275cmp=P({type:n,selectors:[["line-chart"]],viewQuery:function(e,i){if(1&e&&(Ue(GNe,7,xe),Ue(WNe,7,xe),Ue(qNe,7,xe),Ue(XNe,5,xe)),2&e){let r;be(r=ve())&&(i.seriesView=r.first),be(r=ve())&&(i.xAxis=r.first),be(r=ve())&&(i.yAxis=r.first),be(r=ve())&&(i.chartEl=r.first)}},inputs:{customVisTemplate:"customVisTemplate",customChartOverlayTemplate:"customChartOverlayTemplate",useDarkMode:"useDarkMode",preferredRendererType:"preferredRendererType",seriesData:"seriesData",fixedViewBox:"fixedViewBox",seriesMetadataMap:"seriesMetadataMap",xScaleType:"xScaleType",yScaleType:"yScaleType",customXFormatter:"customXFormatter",customYFormatter:"customYFormatter",tooltipTemplate:"tooltipTemplate",userViewBox:"userViewBox",lineOnly:"lineOnly",disableTooltip:"disableTooltip",disableUpdate:"disableUpdate",ignoreYOutliers:"ignoreYOutliers"},outputs:{viewBoxChanged:"viewBoxChanged"},features:[qt],decls:16,vars:13,consts:[["detectResize","","cdkOverlayOrigin","",3,"ngClass","resizeEventDebouncePeriodInMs","onResize"],["overlayTarget","cdkOverlayOrigin"],[1,"series-view"],["seriesView",""],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim",4,"ngIf"],[4,"ngIf"],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange",4,"ngIf"],["class","custom-vis",4,"ngIf"],[1,"y-axis"],["yAxis",""],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],[1,"x-axis"],["xAxis",""],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],["class","dot",4,"ngIf"],["class","custom-vis custom-chart-overlay-vis",4,"ngIf"],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim"],["chartEl",""],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","disableTooltip","onViewExtentChange","onViewExtentReset","onInteractionStateChange"],[1,"custom-vis"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],[1,"dot"],[1,"rect"],[1,"custom-vis","custom-chart-overlay-vis"],["customChartOverlay",""]],template:function(e,i){1&e&&(f(0,"div",0,1),A("onResize",function(){return i.onViewResize()}),f(2,"div",2,3),S(4,YNe,1,6,"line-chart-grid-view",4),S(5,KNe,3,2,"ng-container",5),S(6,JNe,1,9,"line-chart-interactive-view",6),S(7,eLe,2,7,"div",7),g(),f(8,"div",8,9),S(10,tLe,1,5,"line-chart-axis",10),g(),f(11,"div",11,12),S(13,nLe,1,5,"line-chart-axis",13),g(),S(14,iLe,2,0,"div",14),S(15,oLe,3,8,"div",15),g()),2&e&&(b("ngClass",So(10,aLe,i.useDarkMode,i.lineOnly))("resizeEventDebouncePeriodInMs",0),v(4),b("ngIf",!i.lineOnly),v(1),b("ngIf",i.showChartRendererElement),v(1),b("ngIf",!i.lineOnly),v(1),b("ngIf",i.customVisTemplate),v(3),b("ngIf",!i.lineOnly),v(3),b("ngIf",!i.lineOnly),v(1),b("ngIf",!i.lineOnly),v(1),b("ngIf",i.customChartOverlayTemplate))},dependencies:[wn,Ne,eo,Md,Hte,Ute,jte,Vh],styles:['[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column}[_nghost-%COMP%]     .line-chart:has(.horizontal-prospective-area:hover) .x-axis .extent-edit-button{visibility:visible}[_nghost-%COMP%]   .custom-vis[_ngcontent-%COMP%]{pointer-events:none}.container[_ngcontent-%COMP%]{background:inherit;display:grid;flex-grow:1;height:100%;overflow:hidden;width:100%;grid-template-areas:"yaxis series" "dot xaxis" ". customChartOverlay";grid-template-columns:50px 1fr;grid-auto-rows:1fr 30px 0px}.container.dark-mode[_ngcontent-%COMP%]{color:#fff}.container.line-only-mode[_ngcontent-%COMP%]{grid-template-columns:0 1fr;grid-auto-rows:1fr 0}.series-view[_ngcontent-%COMP%]{grid-area:series;position:relative;overflow:hidden}.series-view[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   svg[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-grid-view[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-interactive-view[_ngcontent-%COMP%]{height:100%;left:0;position:absolute;top:0;width:100%}.x-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%]{height:100%;left:0;overflow:hidden;position:absolute;top:0;width:100%;-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.x-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%]{height:100%}.x-axis[_ngcontent-%COMP%]{grid-area:xaxis;position:relative}.y-axis[_ngcontent-%COMP%]{grid-area:yaxis}.dot[_ngcontent-%COMP%]{align-items:flex-start;display:flex;grid-area:dot;justify-content:flex-end}.dot[_ngcontent-%COMP%]   .rect[_ngcontent-%COMP%]{height:1px;width:1px;background-color:#aaa}.custom-chart-overlay-vis[_ngcontent-%COMP%]{grid-area:customChartOverlay;grid-row-end:2;grid-row-start:1}'],changeDetection:0}),n})();function sLe(n,t){1&n&&hi(0)}var Wte=function(n){return{$implicit:n}};function lLe(n,t){if(1&n&&(f(0,"div",4),S(1,sLe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=st(6);v(1),b("ngTemplateOutlet",i)("ngTemplateOutletContext",Un(3,Wte,e.datum)),v(1),Ve(" ",e.getFormattedDataForColumn()," ")}}function cLe(n,t){1&n&&hi(0)}function dLe(n,t){if(1&n&&(f(0,"div",4),S(1,cLe,1,0,"ng-container",5),T(2),g()),2&n){let e=w(),i=st(6);v(1),b("ngTemplateOutlet",i)("ngTemplateOutletContext",Un(3,Wte,e.datum)),v(1),Ve(" ",e.getFormattedDataForColumn()," ")}}function uLe(n,t){if(1&n&&(f(0,"div",6),T(1),g()),2&n){let e=w();v(1),Ve(" ",e.getFormattedDataForColumn()," ")}}function pLe(n,t){1&n&&k(0,"mat-icon",9)}function hLe(n,t){1&n&&k(0,"mat-icon",10)}function mLe(n,t){if(1&n&&(S(0,pLe,1,0,"mat-icon",7),S(1,hLe,1,0,"mat-icon",8)),2&n){let e=t.$implicit;b("ngIf",e>=0),v(1),b("ngIf",e<0)}}var fLe=["*"],m_=(()=>{class n{constructor(){this.contextMenuOpened=new F,this.ColumnHeaderType=gt}getFormattedDataForColumn(){if(void 0===this.datum)return"";switch(this.header.type){case gt.RUN:return this.datum;case gt.VALUE:case gt.STEP:case gt.SMOOTHED:case gt.START_STEP:case gt.END_STEP:case gt.START_VALUE:case gt.END_VALUE:case gt.MIN_VALUE:case gt.MAX_VALUE:case gt.STEP_AT_MAX:case gt.STEP_AT_MIN:case gt.MEAN:case gt.HPARAM:return"number"==typeof this.datum?y0.formatShort(this.datum):this.datum;case gt.TIME:return new Date(this.datum).toISOString();case gt.RELATIVE_TIME:return x0.formatReadable(this.datum);case gt.VALUE_CHANGE:return y0.formatShort(Math.abs(this.datum));case gt.PERCENTAGE_CHANGE:return Math.round(100*this.datum).toString()+"%";case gt.RAW_CHANGE:return dp.formatShort(Math.abs(this.datum));default:return""}}onContextMenuOpened(e){this.contextMenuOpened.emit(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-content-cell"]],hostBindings:function(e,i){1&e&&A("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",datum:"datum"},outputs:{contextMenuOpened:"contextMenuOpened"},ngContentSelectors:fLe,decls:7,vars:3,consts:[[3,"ngSwitch"],["class","cell",4,"ngSwitchCase"],["class","cell extra-right-padding",4,"ngSwitchDefault"],["arrow",""],[1,"cell"],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"cell","extra-right-padding"],["svgIcon","arrow_upward_24px",4,"ngIf"],["svgIcon","arrow_downward_24px",4,"ngIf"],["svgIcon","arrow_upward_24px"],["svgIcon","arrow_downward_24px"]],template:function(e,i){1&e&&(fn(),Gt(0,0),S(1,lLe,3,5,"div",1),S(2,dLe,3,5,"div",1),S(3,uLe,2,1,"div",2),Tt(4),Wt(),S(5,mLe,2,2,"ng-template",null,3,jt)),2&e&&(b("ngSwitch",i.header.type),v(1),b("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),v(1),b("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE))},dependencies:[Ne,eo,mr,kr,du,bn],styles:["[_nghost-%COMP%]{display:table-cell}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]     path{fill:unset}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}"],changeDetection:0}),n})(),gLe=["*"],dA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-content-row"]],ngContentSelectors:gLe,decls:1,vars:0,template:function(e,i){1&e&&(fn(),Tt(0))},styles:["[_nghost-%COMP%] {\n        display: table-row;\n      }"],changeDetection:0}),n})();function _Le(n,t){if(1&n&&k(0,"mat-icon",7),2&n){let e=w(2);b("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function bLe(n,t){if(1&n&&k(0,"mat-icon",8),2&n){let e=w(2);b("ngClass",e.header.name===e.sortingInfo.name?"show":"show-on-hover")}}function vLe(n,t){if(1&n){let e=Te();f(0,"button",4),A("click",function(r){ne(e);let o=w();return r.stopPropagation(),ie(o.headerClickedHandler())}),S(1,_Le,1,1,"mat-icon",5),S(2,bLe,1,1,"mat-icon",6),g()}if(2&n){let e=w();v(1),b("ngIf",e.sortingInfo.order===e.SortingOrder.ASCENDING||e.header.name!==e.sortingInfo.name),v(1),b("ngIf",e.sortingInfo.order===e.SortingOrder.DESCENDING&&e.header.name===e.sortingInfo.name)}}function yLe(n,t){if(1&n){let e=Te();f(0,"button",9),A("click",function(r){return ne(e),ie(w().onContextMenuOpened(r))}),k(1,"mat-icon",10),g()}}var xLe=["*"],f_=(()=>{class n{constructor(){this.disableContextMenu=!1,this.dragStart=new F,this.dragEnd=new F,this.dragEnter=new F,this.headerClicked=new F,this.contextMenuOpened=new F,this.highlightStyle$=new xr({}),this.SortingOrder=Lr}onContextMenuOpened(e){this.disableContextMenu||this.contextMenuOpened.emit(e)}headerClickedHandler(){this.header.sortable&&this.headerClicked.emit(this.header.name)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-header-cell"]],hostBindings:function(e,i){1&e&&A("contextmenu",function(o){return i.onContextMenuOpened(o)})},inputs:{header:"header",sortingInfo:"sortingInfo",disableContextMenu:"disableContextMenu"},outputs:{dragStart:"dragStart",dragEnd:"dragEnd",dragEnter:"dragEnter",headerClicked:"headerClicked",contextMenuOpened:"contextMenuOpened"},ngContentSelectors:xLe,decls:6,vars:7,consts:[[1,"cell",3,"draggable","ngClass","dragstart","dragend","dragenter","click"],[3,"header"],["mat-icon-button","","class","sorting-icon-container",3,"click",4,"ngIf"],["mat-icon-button","","class","context-menu-container show-on-hover",3,"click",4,"ngIf"],["mat-icon-button","",1,"sorting-icon-container",3,"click"],["svgIcon","arrow_upward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_downward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_upward_24px",3,"ngClass"],["svgIcon","arrow_downward_24px",3,"ngClass"],["mat-icon-button","",1,"context-menu-container","show-on-hover",3,"click"],["svgIcon","more_vert_24px"]],template:function(e,i){1&e&&(fn(),f(0,"div",0),A("dragstart",function(){return i.dragStart.emit(i.header)})("dragend",function(){return i.dragEnd.emit()})("dragenter",function(){return i.dragEnter.emit(i.header)})("click",function(){return i.headerClickedHandler()}),U(1,"async"),Tt(2),k(3,"tb-data-table-header",1),S(4,vLe,3,2,"button",2),S(5,yLe,2,0,"button",3),g()),2&e&&(b("draggable",i.header.movable)("ngClass",G(1,5,i.highlightStyle$)),v(3),b("header",i.header),v(1),b("ngIf",i.header.sortable),v(1),b("ngIf",(i.header.removable||i.header.sortable)&&!i.disableContextMenu))},dependencies:[wn,Ne,bn,Er,WT,ct],styles:["[_nghost-%COMP%]{display:table-cell;vertical-align:bottom}[_nghost-%COMP%]:hover   .show-on-hover[_ngcontent-%COMP%]{opacity:.3}[_nghost-%COMP%]   .show-on-hover[_ngcontent-%COMP%]:hover{opacity:1}[_nghost-%COMP%]   .show-on-hover[_ngcontent-%COMP%]:focus{opacity:1}.cell[_ngcontent-%COMP%]{align-items:center;display:flex}.cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px;line-height:1}.cell[_ngcontent-%COMP%]   button[mat-icon-button].mat-mdc-icon-button.sorting-icon-container[_ngcontent-%COMP%], .cell[_ngcontent-%COMP%]   button[mat-icon-button].mat-mdc-icon-button.context-menu-container[_ngcontent-%COMP%]{width:16px;height:16px;--tb-icon-width: 12px;--tb-icon-height: 12px;border-radius:5px;font-size:12px;padding:4px}.cell[_ngcontent-%COMP%]   .sorting-icon-container[_ngcontent-%COMP%]     path{fill:unset}.show[_ngcontent-%COMP%]{opacity:1}.show-on-hover[_ngcontent-%COMP%]{opacity:0}.highlight[_ngcontent-%COMP%]{background-color:#eee}.highlight-border-right[_ngcontent-%COMP%]{border-right:2px solid #ff9800}.highlight-border-left[_ngcontent-%COMP%]{border-left:2px solid #ff9800}"],changeDetection:0}),n})(),uA=(()=>{class n{constructor(e){this.overlay=e,this.customModalRefs=[]}createNextToElement(e,i,r,o={originX:"end",originY:"top",overlayX:"start",overlayY:"top"}){let a=this.overlay.position().flexibleConnectedTo(i);o&&(a=a.withPositions([o]));let s=this.overlay.create({positionStrategy:a,hasBackdrop:!1});s.attach(new To(e,r));let l=new class{constructor(t){this.subscriptions=[],this.onClose=new Ee,this.overlayRef=t}}(s);this.customModalRefs.push(l);let c=s.outsidePointerEvents().subscribe(u=>{"auxclick"!==u.type&&this.customModalRefs.every(p=>!function(n,t){let e=t.getBoundingClientRect();return e.x<=n.clientX&&n.clientX<=e.x+e.width&&e.y<=n.clientY&&n.clientY<=e.y+e.height}(u,p.overlayRef.overlayElement))&&this.closeAll()});l.subscriptions.push(c);let d=s.keydownEvents().subscribe(u=>{"Escape"===u.key&&this.closeAll()});return l.subscriptions.push(d),l}close(e){let i=this.customModalRefs.findIndex(r=>r===e);-1!==i?(e.subscriptions.forEach(r=>{r.unsubscribe()}),e.subscriptions=[],e.overlayRef?.dispose(),this.customModalRefs.splice(i,1),e.onClose.next(),e.onClose.complete()):console.warn("Could not find customModalRef",e)}closeAll(){for(;this.customModalRefs.length;)this.close(this.customModalRefs[0])}}return n.\u0275fac=function(e){return new(e||n)(O(Oi))},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),CLe=["search"],MLe=["columnList"];function wLe(n,t){if(1&n){let e=Te();f(0,"div",10)(1,"label"),T(2," Warning: There were too many columns to load all of them efficiently. "),g(),f(3,"button",11),A("click",function(){return ne(e),ie(w().loadAllColumnsClicked())}),T(4," Load all anyway "),g()()}}function SLe(n,t){if(1&n&&(f(0,"span",14),T(1),g()),2&n){let e=t.$implicit;v(1),Ve(" ",e," ")}}var ELe=function(n){return{selected:n}},TLe=function(){return{sensitivity:"accent"}};function DLe(n,t){if(1&n){let e=Te();f(0,"button",12),A("click",function(){let o=ne(e).$implicit;return ie(w().selectColumn(o))}),U(1,"async"),T(2),S(3,SLe,2,1,"span",13),g()}if(2&n){let e=t.$implicit,i=t.index,r=w();b("ngClass",Un(7,ELe,i===G(1,5,r.selectedIndex$)))("matTooltip",e.name)("matTooltipDisabled",0===e.name.localeCompare(e.displayName,void 0,mc(9,TLe))),v(2),Ve(" ",e.displayName," "),v(1),b("ngForOf",e.tags)}}var Zte=(()=>{class n{constructor(){this.selectableColumns=[],this.columnSelected=new F,this.loadAllColumns=new F,this.searchInput="",this.selectedIndex$=new xr(0),this.isActive=!1}ngOnInit(){this.selectedIndex$.subscribe(()=>{if(!this.columnList)return;let e=this.columnList.nativeElement.querySelector("button.selected");if(!e)return;let i=this.columnList.nativeElement.getBoundingClientRect().height,r=e.getBoundingClientRect().height,o=this.columnList.nativeElement.scrollTop;this.selectedIndex$.getValue()*r<o&&(this.columnList.nativeElement.scrollTop=this.selectedIndex$.getValue()*r),(this.selectedIndex$.getValue()+1)*r>o+i&&(this.columnList.nativeElement.scrollTop=(this.selectedIndex$.getValue()+1)*r-i)})}ngAfterViewInit(){this.searchInput="",this.selectedIndex$.next(0),this.activate(),setTimeout(()=>{this.searchField?.nativeElement.focus()})}getFilteredColumns(){return this.selectableColumns.filter(e=>e.name.toLowerCase().match(this.searchInput.toLowerCase())||e.displayName.toLowerCase().match(this.searchInput.toLowerCase()))}searchInputChanged(){this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue(),this.selectableColumns.length-1))}selectColumn(e){this.selectedIndex$.next(0),this.columnSelected.emit(e)}loadAllColumnsClicked(){this.loadAllColumns.emit()}activate(){this.isActive=!0}deactivate(){this.isActive=!1}onUpArrow(){!this.isActive||this.selectedIndex$.next(Math.max(this.selectedIndex$.getValue()-1,0))}onDownArrow(){!this.isActive||this.selectedIndex$.next(Math.min(this.selectedIndex$.getValue()+1,this.getFilteredColumns().length-1))}onEnterPressed(){!this.isActive||this.selectColumn(this.getFilteredColumns()[this.selectedIndex$.getValue()])}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-column-selector-component"]],viewQuery:function(e,i){if(1&e&&(Ue(CLe,5),Ue(MLe,5)),2&e){let r;be(r=ve())&&(i.searchField=r.first),be(r=ve())&&(i.columnList=r.first)}},hostBindings:function(e,i){1&e&&A("keydown.arrowup",function(o){return i.onUpArrow(o)},0,su)("keydown.arrowdown",function(o){return i.onDownArrow(o)},!1,su)("keydown.enter",function(o){return i.onEnterPressed(o)},!1,su)},inputs:{selectableColumns:"selectableColumns",numColumnsLoaded:"numColumnsLoaded",hasMoreColumnsToLoad:"hasMoreColumnsToLoad"},outputs:{columnSelected:"columnSelected",loadAllColumns:"loadAllColumns"},decls:14,vars:4,consts:[[1,"contents"],["subscriptSizing","dynamic",1,"search-area"],["matPrefix","","svgIcon","search_24px",1,"search-icon"],["matInput","",3,"ngModel","ngModelChange"],["search",""],[1,"column-load-info"],["class","load-more-columns",4,"ngIf"],[1,"column-list"],["columnList",""],["mat-button","","class","column-button",3,"ngClass","matTooltip","matTooltipDisabled","click",4,"ngFor","ngForOf"],[1,"load-more-columns"],["mat-stroked-button","",3,"click"],["mat-button","",1,"column-button",3,"ngClass","matTooltip","matTooltipDisabled","click"],["class","tag",4,"ngFor","ngForOf"],[1,"tag"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"mat-form-field",1),k(2,"mat-icon",2),f(3,"mat-label"),T(4,"Search"),g(),f(5,"input",3,4),A("ngModelChange",function(o){return i.searchInput=o})("ngModelChange",function(){return i.searchInputChanged()}),g()(),f(7,"div",5)(8,"label"),T(9),g(),S(10,wLe,5,0,"div",6),g(),f(11,"div",7,8),S(13,DLe,4,10,"button",9),g()()),2&e&&(v(5),b("ngModel",i.searchInput),v(4),Ve("",i.numColumnsLoaded," columns loaded."),v(1),b("ngIf",i.hasMoreColumnsToLoad),v(3),b("ngForOf",i.getFilteredColumns()))},dependencies:[wn,nn,Ne,bn,qu,Pc,nl,F9,ki,Uu,xg,iy,GT,ct],styles:[".contents[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:flex-start;padding:8px;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.contents[_ngcontent-%COMP%]   .search-area[_ngcontent-%COMP%]{margin-bottom:12px}.contents[_ngcontent-%COMP%]   .column-load-info[_ngcontent-%COMP%]{display:flex;flex-direction:column;font-size:13px;font-style:italic;margin-bottom:12px}.contents[_ngcontent-%COMP%]   .load-more-columns[_ngcontent-%COMP%]{color:#e53935;display:flex;flex-direction:column;margin-top:6px}.contents[_ngcontent-%COMP%]   .load-more-columns[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{color:inherit;font-size:inherit;height:24px;margin-top:8px}.contents[_ngcontent-%COMP%]   .column-list[_ngcontent-%COMP%]{display:flex;flex-direction:column;width:100%;max-height:300px;overflow-y:auto}.contents[_ngcontent-%COMP%]   .column-button[_ngcontent-%COMP%]{flex-shrink:0;height:48px;justify-content:left;width:100%}.contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#eee}body.dark-mode[_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .contents[_ngcontent-%COMP%]   .column-button.selected[_ngcontent-%COMP%]{background-color:#bdbdbd}.contents[_ngcontent-%COMP%]   .tag[_ngcontent-%COMP%]{background-color:#ff9800;border-radius:8px;font-size:12px;font-style:italic;font-weight:normal;padding:4px}"],changeDetection:0}),n})(),ALe=["panel"];function RLe(n,t){if(1&n&&(f(0,"div",0,1),Tt(2),g()),2&n){let e=t.id,i=w();b("id",i.id)("ngClass",i._classList)("@panelAnimation",i.isOpen?"visible":"hidden"),Be("aria-label",i.ariaLabel||null)("aria-labelledby",i._getPanelAriaLabelledby(e))}}var PLe=["*"],kLe=fr("panelAnimation",[Si("void, hidden",rn({opacity:0,transform:"scaleY(0.8)"})),bi(":enter, hidden => visible",[Lb([Mi("0.03s linear",rn({opacity:1})),Mi("0.12s cubic-bezier(0, 0, 0.2, 1)",rn({transform:"scaleY(1)"}))])]),bi(":leave, visible => hidden",[Mi("0.075s linear",rn({opacity:0}))])]),OLe=0,FLe=go(class{}),Kte=new te("mat-autocomplete-default-options",{providedIn:"root",factory:function(){return{autoActiveFirstOption:!1,autoSelectActiveOption:!1,hideSingleSelectionIndicator:!1}}}),LLe=(()=>{class n extends FLe{get isOpen(){return this._isOpen&&this.showPanel}_setColor(e){this._color=e,this._setThemeClasses(this._classList)}get autoActiveFirstOption(){return this._autoActiveFirstOption}set autoActiveFirstOption(e){this._autoActiveFirstOption=vt(e)}get autoSelectActiveOption(){return this._autoSelectActiveOption}set autoSelectActiveOption(e){this._autoSelectActiveOption=vt(e)}set classList(e){this._classList=e&&e.length?function(n,t=/\s+/){let e=[];if(null!=n){let i=Array.isArray(n)?n:`${n}`.split(t);for(let r of i){let o=`${r}`.trim();o&&e.push(o)}}return e}(e).reduce((i,r)=>(i[r]=!0,i),{}):{},this._setVisibilityClasses(this._classList),this._setThemeClasses(this._classList),this._elementRef.nativeElement.className=""}constructor(e,i,r,o){super(),this._changeDetectorRef=e,this._elementRef=i,this._defaults=r,this._activeOptionChanges=En.EMPTY,this.showPanel=!1,this._isOpen=!1,this.displayWith=null,this._autoActiveFirstOption=!!this._defaults.autoActiveFirstOption,this._autoSelectActiveOption=!!this._defaults.autoSelectActiveOption,this.optionSelected=new F,this.opened=new F,this.closed=new F,this.optionActivated=new F,this._classList={},this.id="mat-autocomplete-"+OLe++,this.inertGroups=o?.SAFARI||!1}ngAfterContentInit(){this._keyManager=new lg(this.options).withWrap(),this._activeOptionChanges=this._keyManager.change.subscribe(e=>{this.isOpen&&this.optionActivated.emit({source:this,option:this.options.toArray()[e]||null})}),this._setVisibility()}ngOnDestroy(){this._keyManager?.destroy(),this._activeOptionChanges.unsubscribe()}_setScrollTop(e){this.panel&&(this.panel.nativeElement.scrollTop=e)}_getScrollTop(){return this.panel?this.panel.nativeElement.scrollTop:0}_setVisibility(){this.showPanel=!!this.options.length,this._setVisibilityClasses(this._classList),this._changeDetectorRef.markForCheck()}_emitSelectEvent(e){let i=new class{constructor(t,e){this.source=t,this.option=e}}(this,e);this.optionSelected.emit(i)}_getPanelAriaLabelledby(e){return this.ariaLabel?null:this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_setVisibilityClasses(e){e[this._visibleClass]=this.showPanel,e[this._hiddenClass]=!this.showPanel}_setThemeClasses(e){e["mat-primary"]="primary"===this._color,e["mat-warn"]="warn"===this._color,e["mat-accent"]="accent"===this._color}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(xe),C(Kte),C(Vn))},n.\u0275dir=Me({type:n,viewQuery:function(e,i){if(1&e&&(Ue(oi,7),Ue(ALe,5)),2&e){let r;be(r=ve())&&(i.template=r.first),be(r=ve())&&(i.panel=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],displayWith:"displayWith",autoActiveFirstOption:"autoActiveFirstOption",autoSelectActiveOption:"autoSelectActiveOption",panelWidth:"panelWidth",classList:["class","classList"]},outputs:{optionSelected:"optionSelected",opened:"opened",closed:"closed",optionActivated:"optionActivated"},features:[Xe]}),n})(),Jte=(()=>{class n extends LLe{constructor(){super(...arguments),this._visibleClass="mat-mdc-autocomplete-visible",this._hiddenClass="mat-mdc-autocomplete-hidden",this._hideSingleSelectionIndicator=this._defaults.hideSingleSelectionIndicator??!1}get hideSingleSelectionIndicator(){return this._hideSingleSelectionIndicator}set hideSingleSelectionIndicator(e){this._hideSingleSelectionIndicator=vt(e),this._syncParentProperties()}_syncParentProperties(){if(this.options)for(let e of this.options)e._changeDetectorRef.markForCheck()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-autocomplete"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,jv,5),Bn(r,ja,5)),2&e){let o;be(o=ve())&&(i.optionGroups=o),be(o=ve())&&(i.options=o)}},hostAttrs:[1,"mat-mdc-autocomplete"],inputs:{disableRipple:"disableRipple",hideSingleSelectionIndicator:"hideSingleSelectionIndicator"},exportAs:["matAutocomplete"],features:[Vt([{provide:Uv,useExisting:n}]),Xe],ngContentSelectors:PLe,decls:1,vars:0,consts:[["role","listbox",1,"mat-mdc-autocomplete-panel","mdc-menu-surface","mdc-menu-surface--open",3,"id","ngClass"],["panel",""]],template:function(e,i){1&e&&(fn(),S(0,RLe,3,5,"ng-template"))},dependencies:[wn],styles:[".mdc-menu-surface{display:none;position:absolute;box-sizing:border-box;max-width:calc(100vw - 32px);max-width:var(--mdc-menu-max-width, calc(100vw - 32px));max-height:calc(100vh - 32px);max-height:var(--mdc-menu-max-height, calc(100vh - 32px));margin:0;padding:0;transform:scale(1);transform-origin:top left;opacity:0;overflow:auto;will-change:transform,opacity;z-index:8;border-radius:4px;border-radius:var(--mdc-shape-medium, 4px);transform-origin-left:top left;transform-origin-right:top right}.mdc-menu-surface:focus{outline:none}.mdc-menu-surface--animating-open{display:inline-block;transform:scale(0.8);opacity:0}.mdc-menu-surface--open{display:inline-block;transform:scale(1);opacity:1}.mdc-menu-surface--animating-closed{display:inline-block;opacity:0}[dir=rtl] .mdc-menu-surface,.mdc-menu-surface[dir=rtl]{transform-origin-left:top right;transform-origin-right:top left}.mdc-menu-surface--anchor{position:relative;overflow:visible}.mdc-menu-surface--fixed{position:fixed}.mdc-menu-surface--fullwidth{width:100%}.mdc-menu-surface.mat-mdc-autocomplete-panel{width:100%;max-height:256px;position:static;visibility:hidden;transform-origin:center top;margin:0;padding:8px 0;list-style-type:none}.mdc-menu-surface.mat-mdc-autocomplete-panel:focus{outline:none}.cdk-high-contrast-active .mdc-menu-surface.mat-mdc-autocomplete-panel{outline:solid 1px}.cdk-overlay-pane:not(.mat-mdc-autocomplete-panel-above) .mdc-menu-surface.mat-mdc-autocomplete-panel{border-top-left-radius:0;border-top-right-radius:0}.mat-mdc-autocomplete-panel-above .mdc-menu-surface.mat-mdc-autocomplete-panel{border-bottom-left-radius:0;border-bottom-right-radius:0;transform-origin:center bottom}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-visible{visibility:visible}.mdc-menu-surface.mat-mdc-autocomplete-panel.mat-mdc-autocomplete-hidden{visibility:hidden}mat-autocomplete{display:none}"],encapsulation:2,data:{animation:[kLe]},changeDetection:0}),n})(),BLe={provide:Xr,useExisting:Wn(()=>Kx),multi:!0},$te=new te("mat-autocomplete-scroll-strategy"),HLe={provide:$te,deps:[Oi],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},zLe=(()=>{class n{get autocompleteDisabled(){return this._autocompleteDisabled}set autocompleteDisabled(e){this._autocompleteDisabled=vt(e)}constructor(e,i,r,o,a,s,l,c,d,u,p){this._element=e,this._overlay=i,this._viewContainerRef=r,this._zone=o,this._changeDetectorRef=a,this._dir=l,this._formField=c,this._document=d,this._viewportRuler=u,this._defaults=p,this._componentDestroyed=!1,this._autocompleteDisabled=!1,this._manuallyFloatingLabel=!1,this._viewportSubscription=En.EMPTY,this._canOpenOnNextFocus=!0,this._closeKeyEventStream=new Ee,this._windowBlurHandler=()=>{this._canOpenOnNextFocus=this._document.activeElement!==this._element.nativeElement||this.panelOpen},this._onChange=()=>{},this._onTouched=()=>{},this.position="auto",this.autocompleteAttribute="off",this._overlayAttached=!1,this.optionSelections=is(()=>{let h=this.autocomplete?this.autocomplete.options:null;return h?h.changes.pipe(kn(h),Jn(()=>tn(...h.map(m=>m.onSelectionChange)))):this._zone.onStable.pipe(Lt(1),Jn(()=>this.optionSelections))}),this._scrollStrategy=s}ngAfterViewInit(){let e=this._getWindow();typeof e<"u"&&this._zone.runOutsideAngular(()=>e.addEventListener("blur",this._windowBlurHandler))}ngOnChanges(e){e.position&&this._positionStrategy&&(this._setStrategyPositions(this._positionStrategy),this.panelOpen&&this._overlayRef.updatePosition())}ngOnDestroy(){let e=this._getWindow();typeof e<"u"&&e.removeEventListener("blur",this._windowBlurHandler),this._viewportSubscription.unsubscribe(),this._componentDestroyed=!0,this._destroyPanel(),this._closeKeyEventStream.complete()}get panelOpen(){return this._overlayAttached&&this.autocomplete.showPanel}openPanel(){this._attachOverlay(),this._floatLabel()}closePanel(){this._resetLabel(),this._overlayAttached&&(this.panelOpen&&this._zone.run(()=>{this.autocomplete.closed.emit()}),this.autocomplete._isOpen=this._overlayAttached=!1,this._pendingAutoselectedOption=null,this._overlayRef&&this._overlayRef.hasAttached()&&(this._overlayRef.detach(),this._closingActionsSubscription.unsubscribe()),this._componentDestroyed||this._changeDetectorRef.detectChanges())}updatePosition(){this._overlayAttached&&this._overlayRef.updatePosition()}get panelClosingActions(){return tn(this.optionSelections,this.autocomplete._keyManager.tabOut.pipe(Oe(()=>this._overlayAttached)),this._closeKeyEventStream,this._getOutsideClickStream(),this._overlayRef?this._overlayRef.detachments().pipe(Oe(()=>this._overlayAttached)):$t()).pipe(q(e=>e instanceof zv?e:null))}get activeOption(){return this.autocomplete&&this.autocomplete._keyManager?this.autocomplete._keyManager.activeItem:null}_getOutsideClickStream(){return tn(Ei(this._document,"click"),Ei(this._document,"auxclick"),Ei(this._document,"touchend")).pipe(Oe(e=>{let i=bs(e),r=this._formField?this._formField._elementRef.nativeElement:null,o=this.connectedTo?this.connectedTo.elementRef.nativeElement:null;return this._overlayAttached&&i!==this._element.nativeElement&&this._document.activeElement!==this._element.nativeElement&&(!r||!r.contains(i))&&(!o||!o.contains(i))&&!!this._overlayRef&&!this._overlayRef.overlayElement.contains(i)}))}writeValue(e){Promise.resolve(null).then(()=>this._assignOptionValue(e))}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this._element.nativeElement.disabled=e}_handleKeydown(e){let i=e.keyCode,r=Or(e);if(27===i&&!r&&e.preventDefault(),this.activeOption&&13===i&&this.panelOpen&&!r)this.activeOption._selectViaInteraction(),this._resetActiveItem(),e.preventDefault();else if(this.autocomplete){let o=this.autocomplete._keyManager.activeItem,a=38===i||40===i;9===i||a&&!r&&this.panelOpen?this.autocomplete._keyManager.onKeydown(e):a&&this._canOpen()&&this.openPanel(),(a||this.autocomplete._keyManager.activeItem!==o)&&(this._scrollToOption(this.autocomplete._keyManager.activeItemIndex||0),this.autocomplete.autoSelectActiveOption&&this.activeOption&&(this._pendingAutoselectedOption||(this._valueBeforeAutoSelection=this._element.nativeElement.value),this._pendingAutoselectedOption=this.activeOption,this._assignOptionValue(this.activeOption.value)))}}_handleInput(e){let i=e.target,r=i.value;"number"===i.type&&(r=""==r?null:parseFloat(r)),this._previousValue!==r&&(this._previousValue=r,this._pendingAutoselectedOption=null,this._onChange(r),this._canOpen()&&this._document.activeElement===e.target&&this.openPanel())}_handleFocus(){this._canOpenOnNextFocus?this._canOpen()&&(this._previousValue=this._element.nativeElement.value,this._attachOverlay(),this._floatLabel(!0)):this._canOpenOnNextFocus=!0}_handleClick(){this._canOpen()&&!this.panelOpen&&this.openPanel()}_floatLabel(e=!1){this._formField&&"auto"===this._formField.floatLabel&&(e?this._formField._animateAndLockLabel():this._formField.floatLabel="always",this._manuallyFloatingLabel=!0)}_resetLabel(){this._manuallyFloatingLabel&&(this._formField&&(this._formField.floatLabel="auto"),this._manuallyFloatingLabel=!1)}_subscribeToClosingActions(){return tn(this._zone.onStable.pipe(Lt(1)),this.autocomplete.options.changes.pipe(Dt(()=>this._positionStrategy.reapplyLastPosition()),Rs(0))).pipe(Jn(()=>(this._zone.run(()=>{let r=this.panelOpen;this._resetActiveItem(),this.autocomplete._setVisibility(),this._changeDetectorRef.detectChanges(),this.panelOpen&&this._overlayRef.updatePosition(),r!==this.panelOpen&&(this.panelOpen?this.autocomplete.opened.emit():this.autocomplete.closed.emit())}),this.panelClosingActions)),Lt(1)).subscribe(r=>this._setValueAndClose(r))}_destroyPanel(){this._overlayRef&&(this.closePanel(),this._overlayRef.dispose(),this._overlayRef=null)}_assignOptionValue(e){let i=this.autocomplete&&this.autocomplete.displayWith?this.autocomplete.displayWith(e):e;this._updateNativeInputValue(i??"")}_updateNativeInputValue(e){this._formField?this._formField._control.value=e:this._element.nativeElement.value=e,this._previousValue=e}_setValueAndClose(e){let i=e?e.source:this._pendingAutoselectedOption;i&&(this._clearPreviousSelectedOption(i),this._assignOptionValue(i.value),this._onChange(i.value),this.autocomplete._emitSelectEvent(i),this._element.nativeElement.focus()),this.closePanel()}_clearPreviousSelectedOption(e){this.autocomplete.options.forEach(i=>{i!==e&&i.selected&&i.deselect()})}_attachOverlay(){let e=this._overlayRef;e?(this._positionStrategy.setOrigin(this._getConnectedElement()),e.updateSize({width:this._getPanelWidth()})):(this._portal=new To(this.autocomplete.template,this._viewContainerRef,{id:this._formField?.getLabelId()}),e=this._overlay.create(this._getOverlayConfig()),this._overlayRef=e,this._handleOverlayEvents(e),this._viewportSubscription=this._viewportRuler.change().subscribe(()=>{this.panelOpen&&e&&e.updateSize({width:this._getPanelWidth()})})),e&&!e.hasAttached()&&(e.attach(this._portal),this._closingActionsSubscription=this._subscribeToClosingActions());let i=this.panelOpen;this.autocomplete._setVisibility(),this.autocomplete._isOpen=this._overlayAttached=!0,this.autocomplete._setColor(this._formField?.color),this.panelOpen&&i!==this.panelOpen&&this.autocomplete.opened.emit()}_getOverlayConfig(){return new el({positionStrategy:this._getOverlayPosition(),scrollStrategy:this._scrollStrategy(),width:this._getPanelWidth(),direction:this._dir??void 0,panelClass:this._defaults?.overlayPanelClass})}_getOverlayPosition(){let e=this._overlay.position().flexibleConnectedTo(this._getConnectedElement()).withFlexibleDimensions(!1).withPush(!1);return this._setStrategyPositions(e),this._positionStrategy=e,e}_setStrategyPositions(e){let a,i=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],r=this._aboveClass,o=[{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:r},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom",panelClass:r}];a="above"===this.position?o:"below"===this.position?i:[...i,...o],e.withPositions(a)}_getConnectedElement(){return this.connectedTo?this.connectedTo.elementRef:this._formField?this._formField.getConnectedOverlayOrigin():this._element}_getPanelWidth(){return this.autocomplete.panelWidth||this._getHostWidth()}_getHostWidth(){return this._getConnectedElement().nativeElement.getBoundingClientRect().width}_resetActiveItem(){let e=this.autocomplete;e.autoActiveFirstOption?e._keyManager.setFirstItemActive():e._keyManager.setActiveItem(-1)}_canOpen(){let e=this._element.nativeElement;return!e.readOnly&&!e.disabled&&!this._autocompleteDisabled}_getWindow(){return this._document?.defaultView||window}_scrollToOption(e){let i=this.autocomplete,r=z1(e,i.options,i.optionGroups);if(0===e&&1===r)i._setScrollTop(0);else if(i.panel){let o=i.options.toArray()[e];if(o){let a=o._getHostElement(),s=U1(a.offsetTop,a.offsetHeight,i._getScrollTop(),i.panel.nativeElement.offsetHeight);i._setScrollTop(s)}}}_handleOverlayEvents(e){e.keydownEvents().subscribe(i=>{(27===i.keyCode&&!Or(i)||38===i.keyCode&&Or(i,"altKey"))&&(this._pendingAutoselectedOption&&(this._updateNativeInputValue(this._valueBeforeAutoSelection??""),this._pendingAutoselectedOption=null),this._closeKeyEventStream.next(),this._resetActiveItem(),i.stopPropagation(),i.preventDefault())}),e.outsidePointerEvents().subscribe()}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Oi),C(ei),C(ot),C(Qt),C($te),C(zi,8),C(Ph,9),C(Nt,8),C(Wa),C(Kte,8))},n.\u0275dir=Me({type:n,inputs:{autocomplete:["matAutocomplete","autocomplete"],position:["matAutocompletePosition","position"],connectedTo:["matAutocompleteConnectedTo","connectedTo"],autocompleteAttribute:["autocomplete","autocompleteAttribute"],autocompleteDisabled:["matAutocompleteDisabled","autocompleteDisabled"]},features:[qt]}),n})(),Kx=(()=>{class n extends zLe{constructor(){super(...arguments),this._aboveClass="mat-mdc-autocomplete-panel-above"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-mdc-autocomplete-trigger"],hostVars:7,hostBindings:function(e,i){1&e&&A("focusin",function(){return i._handleFocus()})("blur",function(){return i._onTouched()})("input",function(o){return i._handleInput(o)})("keydown",function(o){return i._handleKeydown(o)})("click",function(){return i._handleClick()}),2&e&&Be("autocomplete",i.autocompleteAttribute)("role",i.autocompleteDisabled?null:"combobox")("aria-autocomplete",i.autocompleteDisabled?null:"list")("aria-activedescendant",i.panelOpen&&i.activeOption?i.activeOption.id:null)("aria-expanded",i.autocompleteDisabled?null:i.panelOpen.toString())("aria-owns",i.autocompleteDisabled||!i.panelOpen||null==i.autocomplete?null:i.autocomplete.id)("aria-haspopup",i.autocompleteDisabled?null:"listbox")},exportAs:["matAutocompleteTrigger"],features:[Vt([BLe]),Xe]}),n})(),pA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[HLe],imports:[Do,mg,dn,De,Ic,mg,dn]}),n})(),g_=(()=>{class n{constructor(){this.value="",this.placeholder=""}onInputKeyUp(e){"Enter"===e.key&&this.autocompleteTrigger.closePanel()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-filter-input"]],viewQuery:function(e,i){if(1&e&&Ue(Kx,5),2&e){let r;be(r=ve())&&(i.autocompleteTrigger=r.first)}},inputs:{value:"value",matAutocomplete:"matAutocomplete",placeholder:"placeholder"},decls:2,vars:4,consts:[["svgIcon","search_24px"],["type","text","autocomplete","off",3,"placeholder","matAutocomplete","matAutocompleteDisabled","value","keyup"]],template:function(e,i){1&e&&(k(0,"mat-icon",0),f(1,"input",1),A("keyup",function(o){return i.onInputKeyUp(o)}),g()),2&e&&(v(1),b("placeholder",i.placeholder)("matAutocomplete",i.matAutocomplete)("matAutocompleteDisabled",!i.matAutocomplete)("value",i.value))},dependencies:[Kx,bn],styles:["[_nghost-%COMP%]{display:flex;font-size:13px;min-width:210px}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}input[_ngcontent-%COMP%]{background-color:inherit;caret-color:currentColor;color:currentColor;font:inherit;border:none;outline:none;padding:0;flex-grow:1}"]}),n})(),ULe=["container"],Jx=(()=>(function(n){n[n.NONE=0]="NONE",n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT"}(Jx||(Jx={})),Jx))(),tne=(()=>{class n{constructor(){this.tickCount=20,this.enabled=!0,this.rangeValuesChanged=new F,this.singleValueChanged=new F,this.Position=Jx}thumbDrag(){this.rangeValuesChanged.emit({lowerValue:this.lowerValue,upperValue:this.upperValue,source:"SLIDER"})}calculateStepSize(){return null===this.tickCount||this.tickCount<=0?1:(this.max-this.min)/this.tickCount}getClippedValue(e){return Math.min(Math.max(e,this.min),this.max)}maybeNotifyNextRangeValues(e,i){let[r,o]=e.sort((a,s)=>a-s);(this.lowerValue!==r||this.upperValue!==o)&&this.rangeValuesChanged.emit({lowerValue:r,upperValue:o,source:i})}handleInputChange(e,i){let o=this.getClippedValue(Number(e.target.value));isNaN(o)||this.maybeNotifyNextRangeValues(i===Jx.LEFT?[o,this.upperValue]:[this.lowerValue,o],"TEXT")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-range-input"]],viewQuery:function(e,i){if(1&e&&Ue(ULe,5,xe),2&e){let r;be(r=ve())&&(i.container=r.first)}},inputs:{min:"min",max:"max",lowerValue:"lowerValue",upperValue:"upperValue",tickCount:"tickCount",enabled:"enabled"},outputs:{rangeValuesChanged:"rangeValuesChanged",singleValueChanged:"singleValueChanged"},decls:5,vars:9,consts:[["type","number",1,"lower-input",3,"disabled","value","change"],["type","number",1,"upper-input",3,"disabled","value","change"],[1,"slider",3,"min","max","step"],["matSliderStartThumb","",3,"ngModel","valueChange","ngModelChange"],["matSliderEndThumb","",3,"ngModel","valueChange","ngModelChange"]],template:function(e,i){1&e&&(f(0,"input",0),A("change",function(o){return i.handleInputChange(o,i.Position.LEFT)}),g(),f(1,"input",1),A("change",function(o){return i.handleInputChange(o,i.Position.RIGHT)}),g(),f(2,"mat-slider",2)(3,"input",3),A("valueChange",function(){return i.thumbDrag()})("ngModelChange",function(o){return i.lowerValue=o}),g(),f(4,"input",4),A("valueChange",function(){return i.thumbDrag()})("ngModelChange",function(o){return i.upperValue=o}),g()()),2&e&&(b("disabled",!i.enabled)("value",i.lowerValue),v(1),b("disabled",!i.enabled)("value",i.upperValue),v(1),b("min",i.min)("max",i.max)("step",i.calculateStepSize()),v(1),b("ngModel",i.lowerValue),v(1),b("ngModel",i.upperValue))},dependencies:[Ju,vN,Uu,xg,iy],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:inline-grid;grid-gap:10px;grid-template-areas:"lower-input upper-input" "slider slider";grid-template-columns:1fr 1fr;font-size:0;min-width:100px}input[_ngcontent-%COMP%]{background-color:inherit;border-style:solid;box-sizing:border-box;color:inherit;overflow:hidden;width:100%}.lower-input[_ngcontent-%COMP%]{grid-area:lower-input}.upper-input[_ngcontent-%COMP%]{grid-area:upper-input;justify-self:flex-end}.slider[_ngcontent-%COMP%]{grid-area:slider}'],changeDetection:0}),n})();function GLe(n,t){if(1&n){let e=Te();f(0,"tb-filter-input",9),A("keyup",function(r){return ne(e),ie(w(2).discreteValueKeyUp(r))}),g()}2&n&&b("value",w(2).discreteValueFilter)}function WLe(n,t){1&n&&(f(0,"div",10),T(1," No Matching Values "),g())}function qLe(n,t){if(1&n){let e=Te();f(0,"div",13),A("click",function(r){return r.stopPropagation()}),f(1,"mat-checkbox",3),A("change",function(){let o=ne(e).$implicit;return ie(w(3).discreteFilterChanged.emit(o))}),f(2,"span"),T(3),g()()()}if(2&n){let e=t.$implicit,i=w(3);v(1),b("checked",i.filter.filterValues.includes(e)),v(2),kt(e)}}function XLe(n,t){if(1&n&&(f(0,"div",11),S(1,qLe,4,2,"div",12),g()),2&n){let e=w(2);v(1),b("ngForOf",e.getPossibleValues())}}function YLe(n,t){if(1&n&&(f(0,"div",4)(1,"div",5),S(2,GLe,1,1,"tb-filter-input",6),g(),S(3,WLe,2,0,"div",7),S(4,XLe,2,1,"div",8),g()),2&n){let e=w();v(2),b("ngIf",e.filter.possibleValues),v(1),b("ngIf",!e.getPossibleValues().length),v(1),b("ngIf",e.getPossibleValues().length)}}function QLe(n,t){if(1&n){let e=Te();f(0,"div",14),A("click",function(r){return r.stopPropagation()}),f(1,"tb-range-input",15),A("rangeValuesChanged",function(r){return ne(e),ie(w().intervalFilterChanged.emit(r))}),g()()}if(2&n){let e=w();v(1),b("min",e.filter.minValue)("max",e.filter.maxValue)("lowerValue",e.filter.filterLowerValue)("upperValue",e.filter.filterUpperValue)}}var hA=(()=>{class n{constructor(){this.DomainType=io,this.discreteValueFilter="",this.discreteFilterChanged=new F,this.intervalFilterChanged=new F,this.includeUndefinedToggled=new F}getPossibleValues(){let e=this.filter.possibleValues??[];return this.discreteValueFilter?e.filter(i=>i.toString().match(this.discreteValueFilter)):e}discreteValueKeyUp(e){this.discreteValueFilter=e.target.value}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-filter"]],inputs:{filter:"filter"},outputs:{discreteFilterChanged:"discreteFilterChanged",intervalFilterChanged:"intervalFilterChanged",includeUndefinedToggled:"includeUndefinedToggled"},decls:5,vars:3,consts:[[1,"filter-dialog"],["class","filter-container",4,"ngIf"],["class","filter-container","disableRipple","",3,"click",4,"ngIf"],[3,"checked","change"],[1,"filter-container"],[1,"input-container"],["placeholder","Filter Discrete Values (regex)",3,"value","keyup",4,"ngIf"],["class","no-matches",4,"ngIf"],["class","discrete-filters-container",4,"ngIf"],["placeholder","Filter Discrete Values (regex)",3,"value","keyup"],[1,"no-matches"],[1,"discrete-filters-container"],["class","discrete-value",3,"click",4,"ngFor","ngForIndex","ngForOf"],[1,"discrete-value",3,"click"],["disableRipple","",1,"filter-container",3,"click"],[1,"range-input",3,"min","max","lowerValue","upperValue","rangeValuesChanged"]],template:function(e,i){1&e&&(f(0,"div",0),S(1,YLe,5,3,"div",1),S(2,QLe,2,4,"div",2),f(3,"mat-checkbox",3),A("change",function(){return i.includeUndefinedToggled.emit()}),T(4,"Include Undefined"),g()()),2&e&&(v(1),b("ngIf",i.filter.type===i.DomainType.DISCRETE),v(1),b("ngIf",i.filter.type===i.DomainType.INTERVAL),v(1),b("checked",i.filter.includeUndefined))},dependencies:[nn,Ne,xs,g_,tne],styles:[".filter-dialog[_ngcontent-%COMP%]{padding:16px 8px;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .filter-dialog[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-dialog[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.input-container[_ngcontent-%COMP%]{margin-bottom:8px}.discrete-filters-container[_ngcontent-%COMP%]{max-height:300px;overflow-y:auto}.no-matches[_ngcontent-%COMP%]{padding:8px 12px}.filter-container[_ngcontent-%COMP%]{padding-bottom:8px;margin-bottom:8px;border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-container[_ngcontent-%COMP%]{border-bottom-color:#555}.range-input[_ngcontent-%COMP%]{padding:4px 8px;width:200px}.discrete-value[_ngcontent-%COMP%]{overflow:hidden}.discrete-value[_ngcontent-%COMP%]     mat-checkbox, .discrete-value[_ngcontent-%COMP%]     .mdc-form-field, .discrete-value[_ngcontent-%COMP%]     label{width:100%}"]}),n})();function ZLe(n,t){1&n&&(f(0,"div",5),T(1," No Actions Available "),g())}function KLe(n,t){if(1&n){let e=Te();f(0,"button",6),A("click",function(){return ne(e),ie(w().contextMenuRemoveColumn())}),k(1,"mat-icon",7),T(2,"Remove "),g()}}function JLe(n,t){if(1&n){let e=Te();f(0,"button",8),A("click",function(){ne(e);let r=w();return ie(r.sortByHeader.emit(null==r.contextMenuHeader?null:r.contextMenuHeader.name))}),k(1,"mat-icon",9),T(2,"Sort Descending "),g()}}function $Le(n,t){if(1&n){let e=Te();f(0,"button",8),A("click",function(){ne(e);let r=w();return ie(r.sortByHeader.emit(null==r.contextMenuHeader?null:r.contextMenuHeader.name))}),k(1,"mat-icon",10),T(2,"Sort Ascending "),g()}}function e3e(n,t){if(1&n){let e=Te();f(0,"button",6),A("click",function(r){return ne(e),ie(w().openFilterMenu.emit(r))}),k(1,"mat-icon",11),T(2," Filter "),g()}}function t3e(n,t){if(1&n){let e=Te();f(0,"button",6),A("click",function(r){ne(e);let o=w();return ie(o.openColumnSelector.emit({event:r,insertTo:o.Side.LEFT,isSubMenu:!0}))}),k(1,"mat-icon",12),T(2,"Insert Column Left "),g()}}function n3e(n,t){if(1&n){let e=Te();f(0,"button",6),A("click",function(r){ne(e);let o=w();return ie(o.openColumnSelector.emit({event:r,insertTo:o.Side.RIGHT,isSubMenu:!0}))}),k(1,"mat-icon",12),T(2,"Insert Column Right "),g()}}var ine=(()=>{class n{constructor(){this.contextMenuHeader=void 0,this.removeColumn=new F,this.sortByHeader=new F,this.openFilterMenu=new F,this.openColumnSelector=new F,this.Side=mo,this.SortingOrder=Lr}isContextMenuEmpty(){return!(this.contextMenuHeader?.removable||this.contextMenuHeader?.sortable||this.canContextMenuInsert()||this.contextMenuHeader?.filterable)}canContextMenuInsert(){return this.selectableColumns?.length&&this.contextMenuHeader?.movable&&"HPARAM"===this.contextMenuHeader?.type}contextMenuRemoveColumn(){void 0!==this.contextMenuHeader&&this.removeColumn.emit(this.contextMenuHeader)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tb-data-table-context-menu"]],inputs:{contextMenuHeader:"contextMenuHeader",selectableColumns:"selectableColumns",sortingInfo:"sortingInfo"},outputs:{removeColumn:"removeColumn",sortByHeader:"sortByHeader",openFilterMenu:"openFilterMenu",openColumnSelector:"openColumnSelector"},decls:8,vars:7,consts:[[1,"context-menu"],["class","no-actions-message",4,"ngIf"],["class","context-menu-button","mat-button","",3,"click",4,"ngIf"],["class","context-menu-button sort-button","mat-button","",3,"click",4,"ngIf"],["mat-button","","class","context-menu-button",3,"click",4,"ngIf"],[1,"no-actions-message"],["mat-button","",1,"context-menu-button",3,"click"],["svgIcon","close_24px"],["mat-button","",1,"context-menu-button","sort-button",3,"click"],["svgIcon","arrow_downward_24px"],["svgIcon","arrow_upward_24px"],["svgIcon","filter_alt_24px"],["svgIcon","add_24px"]],template:function(e,i){1&e&&(f(0,"div",0),S(1,ZLe,2,0,"div",1),S(2,KLe,3,0,"button",2),S(3,JLe,3,0,"button",3),S(4,$Le,3,0,"button",3),S(5,e3e,3,0,"button",2),S(6,t3e,3,0,"button",4),S(7,n3e,3,0,"button",4),g()),2&e&&(v(1),b("ngIf",i.isContextMenuEmpty()),v(1),b("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.removable),v(1),b("ngIf",(null==i.contextMenuHeader?null:i.contextMenuHeader.sortable)&&i.sortingInfo.order===i.SortingOrder.ASCENDING&&i.sortingInfo.name===(null==i.contextMenuHeader?null:i.contextMenuHeader.name)),v(1),b("ngIf",(null==i.contextMenuHeader?null:i.contextMenuHeader.sortable)&&(i.sortingInfo.order!==i.SortingOrder.ASCENDING||i.sortingInfo.name!==(null==i.contextMenuHeader?null:i.contextMenuHeader.name))),v(1),b("ngIf",null==i.contextMenuHeader?null:i.contextMenuHeader.filterable),v(1),b("ngIf",i.canContextMenuInsert()),v(1),b("ngIf",i.canContextMenuInsert()))},dependencies:[Ne,bn,ki],styles:[".context-menu[_ngcontent-%COMP%]{display:flex;flex-direction:column;border-radius:4px;border:1px solid;box-shadow:0px 4px 4px rgba(0,0,0,.25);border-color:#ebebeb;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .context-menu[_ngcontent-%COMP%]{border-color:#555;background-color:#303030}.context-menu[_ngcontent-%COMP%]   .context-menu-button[_ngcontent-%COMP%]{justify-content:left;width:100%;text-wrap:nowrap}.context-menu[_ngcontent-%COMP%]   .no-actions-message[_ngcontent-%COMP%]{padding:8px;text-wrap:nowrap}.context-menu[_ngcontent-%COMP%]   .sort-button[_ngcontent-%COMP%]     path{fill:unset}"],changeDetection:0}),n})(),r3e=["contextMenuTemplate"],o3e=["filterModalTemplate"],a3e=["columnSelectorModalTemplate"];function s3e(n,t){if(1&n){let e=Te();f(0,"tb-data-table-context-menu",9),A("removeColumn",function(r){return ne(e),ie(w().onRemoveColumn(r))})("sortByHeader",function(r){return ne(e),ie(w().sortByHeader(r))})("openFilterMenu",function(r){return ne(e),ie(w().openFilterMenu(r))})("openColumnSelector",function(r){return ne(e),ie(w().openColumnSelector(r))}),g()}if(2&n){let e=w();b("contextMenuHeader",e.contextMenuHeader)("selectableColumns",e.selectableColumns)("sortingInfo",e.sortingInfo)}}function l3e(n,t){if(1&n){let e=Te();f(0,"tb-data-table-column-selector-component",10),A("columnSelected",function(r){return ne(e),ie(w().onColumnAdded(r))})("loadAllColumns",function(){return ne(e),ie(w().loadAllColumns.emit())}),g()}if(2&n){let e=w();b("selectableColumns",e.selectableColumns)("numColumnsLoaded",e.numColumnsLoaded)("hasMoreColumnsToLoad",e.hasMoreColumnsToLoad)}}function c3e(n,t){if(1&n){let e=Te();f(0,"tb-data-table-filter",11),A("intervalFilterChanged",function(r){return ne(e),ie(w().intervalFilterChanged(r))})("discreteFilterChanged",function(r){return ne(e),ie(w().discreteFilterChanged(r))})("includeUndefinedToggled",function(){return ne(e),ie(w().includeUndefinedToggled())}),g()}2&n&&b("filter",w().getCurrentColumnFilter())}function d3e(n,t){if(1&n){let e=Te();f(0,"div",12)(1,"div",13)(2,"button",14),A("click",function(r){return ne(e),ie(w().openColumnSelector({event:r}))}),k(3,"mat-icon",15),g()()()}if(2&n){let e=w();v(1),nt("small-add-button",e.addColumnSize===e.AddColumnSize.SMALL)}}function u3e(n,t){1&n&&(f(0,"div",16),k(1,"mat-spinner",17),g())}var p3e=[[["","header",""]],[["","content",""]]],h3e=["[header]","[content]"],xV=function(n){n.preventDefault()},mA=(()=>{class n{constructor(e,i){this.customModal=e,this.viewContainerRef=i,this.loading=!1,this.shouldAddBorders=!1,this.addColumnSize=vu.DEFAULT,this.headerCellSubscriptions=[],this.contentCellSubscriptions=[],this.contextMenuHeader=void 0,this.insertColumnTo=void 0,this.filterColumn=void 0,this.sortDataBy=new F,this.orderColumns=new F,this.removeColumn=new F,this.addColumn=new F,this.addFilter=new F,this.loadAllColumns=new F,this.highlightSide=mo.RIGHT,this.SortingOrder=Lr,this.Side=mo,this.AddColumnSize=vu}ngOnDestroy(){document.removeEventListener("dragover",xV),this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()})}ngAfterContentInit(){this.syncHeaders(),this.headerCells.changes.subscribe(this.syncHeaders.bind(this)),this.syncContent(),this.contentCells.changes.subscribe(this.syncContent.bind(this))}syncHeaders(){this.headerCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.headerCellSubscriptions=[],this.headerCells.forEach(e=>{this.headerCellSubscriptions.push(e.dragStart.subscribe(this.dragStart.bind(this)),e.dragEnter.subscribe(this.dragEnter.bind(this)),e.dragEnd.subscribe(this.dragEnd.bind(this)),e.headerClicked.subscribe(this.sortByHeader.bind(this)),e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header)))})}syncContent(){this.contentCellSubscriptions.forEach(e=>{e.unsubscribe()}),this.contentCellSubscriptions=this.contentCells.map(e=>[e.contextMenuOpened.subscribe(this.openContextMenu.bind(this,e.header))]).flat()}sortByHeader(e){this.sortDataBy.emit(this.sortingInfo.name!==e||this.sortingInfo.order!==Lr.ASCENDING?{name:e,order:Lr.ASCENDING}:{name:e,order:Lr.DESCENDING})}dragStart(e){this.draggingHeaderName=e.name,document.addEventListener("dragover",xV)}dragEnd(){if(!this.draggingHeaderName||!this.highlightedColumnName)return;let e=this.getHeaderByName(this.draggingHeaderName),i=this.getHeaderByName(this.highlightedColumnName);e&&i&&e!==i&&this.orderColumns.emit({source:e,destination:i,side:this.highlightSide}),this.draggingHeaderName=void 0,this.highlightedColumnName=void 0,document.removeEventListener("dragover",xV),this.headerCells.forEach(r=>{r.highlightStyle$.next({})})}dragEnter(e){if(!this.draggingHeaderName||-1===this.getIndexOfHeaderWithName(e.name))return;let i=this.getHeaderByName(this.draggingHeaderName);i&&kl.columnToGroup(e)!==kl.columnToGroup(i)||(this.highlightSide=this.getIndexOfHeaderWithName(e.name)<this.getIndexOfHeaderWithName(this.draggingHeaderName)?mo.LEFT:mo.RIGHT,this.highlightedColumnName=e.name,this.headerCells.forEach(r=>{r.highlightStyle$.next(this.getHeaderHighlightStyle(r.header.name))}))}moveHeader(e,i){let r=[...this.headers];return r.splice(e,1),r.splice(i,0,this.headers[e]),r}getHeaderHighlightStyle(e){return e!==this.highlightedColumnName?{}:{highlight:!0,"highlight-border-right":this.highlightSide===mo.RIGHT,"highlight-border-left":this.highlightSide===mo.LEFT}}getHeaderByName(e){return this.headers.find(i=>i.name===e)}getIndexOfHeaderWithName(e){return this.headers.findIndex(i=>e===i.name)}openContextMenu(e,i){i.stopPropagation(),i.preventDefault(),this.contextMenuHeader=e;let o=i.target.querySelector("button.context-menu-container")??i.target;this.customModal.createNextToElement(this.contextMenuTemplate,o,this.viewContainerRef)}openColumnSelector({event:e,insertTo:i}){e.stopPropagation(),this.closeSubmenus(),this.insertColumnTo=i,this.columnSelectorModalRef=this.customModal.createNextToElement(this.columnSelectorModalTemplate,e.target.closest("button"),this.viewContainerRef),this.columnSelectorModalRef?.onClose.pipe(zm()).subscribe(()=>{this.columnSelectorModalRef=void 0})}canContextMenuRemoveColumn(){return this.contextMenuHeader?.removable}onRemoveColumn(e){this.removeColumn.emit(e),this.customModal.closeAll()}onColumnAdded(e){this.addColumn.emit({column:e,nextTo:this.contextMenuHeader,side:this.insertColumnTo})}closeSubmenus(){this.filterModalRef&&this.customModal.close(this.filterModalRef),this.columnSelectorModalRef&&this.customModal.close(this.columnSelectorModalRef)}openFilterMenu(e){e.stopPropagation(),this.closeSubmenus(),this.filterColumn=this.contextMenuHeader,this.filterModalRef=this.customModal.createNextToElement(this.filterModalTemplate,e.target.closest("button"),this.viewContainerRef),this.filterModalRef?.onClose.pipe(zm()).subscribe(()=>{this.filterModalRef=void 0})}getCurrentColumnFilter(){if(this.filterColumn)return this.columnFilters.get(this.filterColumn.name)}intervalFilterChanged(e){if(!this.filterColumn)return;let i=this.getCurrentColumnFilter();!i||this.addFilter.emit({name:this.filterColumn.name,value:{...i,filterLowerValue:e.lowerValue,filterUpperValue:e.upperValue}})}discreteFilterChanged(e){if(!this.filterColumn)return;let i=this.getCurrentColumnFilter();if(!i)return;let r=new Set([...i.filterValues]);r.has(e)?r.delete(e):r.add(e),this.addFilter.emit({name:this.filterColumn.name,value:{...i,filterValues:Array.from(r)}})}includeUndefinedToggled(){if(!this.filterColumn)return;let e=this.getCurrentColumnFilter();!e||this.addFilter.emit({name:this.filterColumn.name,value:{...e,includeUndefined:!e.includeUndefined}})}}return n.\u0275fac=function(e){return new(e||n)(C(uA),C(ei))},n.\u0275cmp=P({type:n,selectors:[["tb-data-table"]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,f_,4),Bn(r,m_,5)),2&e){let o;be(o=ve())&&(i.headerCells=o),be(o=ve())&&(i.contentCells=o)}},viewQuery:function(e,i){if(1&e&&(Ue(r3e,5,oi),Ue(o3e,5,oi),Ue(a3e,5,oi)),2&e){let r;be(r=ve())&&(i.contextMenuTemplate=r.first),be(r=ve())&&(i.filterModalTemplate=r.first),be(r=ve())&&(i.columnSelectorModalTemplate=r.first)}},inputs:{headers:"headers",sortingInfo:"sortingInfo",selectableColumns:"selectableColumns",numColumnsLoaded:"numColumnsLoaded",hasMoreColumnsToLoad:"hasMoreColumnsToLoad",columnFilters:"columnFilters",loading:"loading",shouldAddBorders:"shouldAddBorders",addColumnSize:"addColumnSize"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",removeColumn:"removeColumn",addColumn:"addColumn",addFilter:"addFilter",loadAllColumns:"loadAllColumns"},ngContentSelectors:h3e,decls:14,vars:4,consts:[["contextMenuTemplate",""],["columnSelectorModalTemplate",""],["filterModalTemplate",""],[1,"data-table-wrapper"],[1,"left-section"],[1,"data-table"],[1,"header"],["class","right-section",4,"ngIf"],["class","loading",4,"ngIf"],[3,"contextMenuHeader","selectableColumns","sortingInfo","removeColumn","sortByHeader","openFilterMenu","openColumnSelector"],[3,"selectableColumns","numColumnsLoaded","hasMoreColumnsToLoad","columnSelected","loadAllColumns"],[3,"filter","intervalFilterChanged","discreteFilterChanged","includeUndefinedToggled"],[1,"right-section"],[1,"add-button-column"],["mat-icon-button","","title","Add Column",1,"add-button",3,"click"],["svgIcon","add_24px"],[1,"loading"],["mode","indeterminate","diameter","28"]],template:function(e,i){1&e&&(fn(p3e),S(0,s3e,1,3,"ng-template",null,0,jt),S(2,l3e,1,3,"ng-template",null,1,jt),S(4,c3e,1,1,"ng-template",null,2,jt),f(6,"div",3)(7,"div",4)(8,"div",5)(9,"div",6),Tt(10),g(),Tt(11,1),g()(),S(12,d3e,4,2,"div",7),g(),S(13,u3e,2,0,"div",8)),2&e&&(v(6),nt("should-add-borders",i.shouldAddBorders),v(6),b("ngIf",i.selectableColumns&&i.selectableColumns.length),v(1),b("ngIf",i.loading))},dependencies:[Ne,bn,Er,Nc,Zte,hA,ine],styles:[".data-table-wrapper[_ngcontent-%COMP%]{display:flex}.data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .left-section[_ngcontent-%COMP%], .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .right-section[_ngcontent-%COMP%]{border-top:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .left-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .left-section[_ngcontent-%COMP%]{border-top:1px solid #555}body.dark-mode[_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .right-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .right-section[_ngcontent-%COMP%]{border-top:1px solid #555}.data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .add-button-column[_ngcontent-%COMP%]{border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .add-button-column[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table-wrapper.should-add-borders[_ngcontent-%COMP%]   .add-button-column[_ngcontent-%COMP%]{border-left:1px solid #555}.data-table[_ngcontent-%COMP%]{font-size:13px;display:table;width:100%}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#fff;display:table-row;font-weight:bold;position:sticky;text-align:left;top:0;vertical-align:bottom;z-index:1}.data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]:hover{cursor:pointer}body.dark-mode[_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{background-color:#303030}.loading[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px;justify-content:center}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}.left-section[_ngcontent-%COMP%]{flex-grow:1}.right-section[_ngcontent-%COMP%]{background-color:#fff;position:sticky;right:-1px;z-index:1}body.dark-mode[_nghost-%COMP%]   .right-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .right-section[_ngcontent-%COMP%]{background-color:#303030}.right-section[_ngcontent-%COMP%]   .add-button-column[_ngcontent-%COMP%]{width:40px;height:100%}.right-section[_ngcontent-%COMP%]   .add-button-column[_ngcontent-%COMP%]   .add-button[_ngcontent-%COMP%]{position:sticky;top:0}.right-section[_ngcontent-%COMP%]   .add-button-column.small-add-button[_ngcontent-%COMP%]{display:flex;justify-content:center;width:24px}.right-section[_ngcontent-%COMP%]   .add-button-column.small-add-button[_ngcontent-%COMP%]   .add-button[_ngcontent-%COMP%]{--tb-icon-button-width: 20px;--tb-icon-button-height: 20px}"],changeDetection:0}),n})();function m3e(n,t){if(1&n&&k(0,"tb-data-table-header-cell",5),2&n){let e=w().$implicit,i=w();b("header",e)("sortingInfo",i.sortingInfo)("disableContextMenu",!i.columnContextMenusEnabled)}}function f3e(n,t){if(1&n&&(Gt(0),S(1,m3e,1,3,"tb-data-table-header-cell",4),Wt()),2&n){let e=t.$implicit,i=w();v(1),b("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function g3e(n,t){if(1&n&&(f(0,"div",9),k(1,"span"),g()),2&n){let e=w(3).$implicit;v(1),Bt("background-color",e.color)}}function _3e(n,t){if(1&n&&(f(0,"tb-data-table-content-cell",7),S(1,g3e,2,2,"div",8),g()),2&n){let e=w().$implicit,i=w().$implicit,r=w();b("header",e)("datum",i[e.name]),v(1),b("ngIf",e.type===r.ColumnHeaderType.COLOR)}}function b3e(n,t){if(1&n&&(Gt(0),S(1,_3e,2,3,"tb-data-table-content-cell",6),Wt()),2&n){let e=t.$implicit,i=w(2);v(1),b("ngIf",e.enabled&&(e.type!==i.ColumnHeaderType.SMOOTHED||i.smoothingEnabled))}}function v3e(n,t){if(1&n&&(Gt(0),f(1,"tb-data-table-content-row"),S(2,b3e,2,1,"ng-container",2),g(),Wt()),2&n){let e=w();v(2),b("ngForOf",e.extendHeaders(e.columnHeaders))}}var ane=(()=>{class n{constructor(){this.sortDataBy=new F,this.editColumnHeaders=new F,this.addColumn=new F,this.removeColumn=new F,this.addFilter=new F,this.loadAllColumns=new F,this.ColumnHeaderType=gt,this.AddColumnSize=vu,this.extendHeaders=_s(this.internalExtendHeaders)}internalExtendHeaders(e){return[].concat([{name:"color",displayName:"",type:gt.COLOR,enabled:!0}],e)}getMinPointInRange(e,i,r){let o=e[i].y,a=e[i];for(let s=i;s<=r;s++)o>e[s].y&&(o=e[s].y,a=e[s]);return a}getMaxPointInRange(e,i,r){let o=e[i].y,a=e[i];for(let s=i;s<=r;s++)o<e[s].y&&(o=e[s].y,a=e[s]);return a}getMean(e,i,r){let o=0;for(let a=i;a<=r;a++)o+=e[a].value;return o/(r-i+1)}getTimeSelectionTableData(){if(!this.stepOrLinkedTimeSelection)return[];let e=this.stepOrLinkedTimeSelection.start.step,i=this.stepOrLinkedTimeSelection.end?.step,r=this.dataSeries.filter(a=>GS(a,this.chartMetadataMap)).map(a=>{let s=this.chartMetadataMap[a.id],l=Zx(a.points,e),c=a.points[l],d=null,u=null;null!=i&&(u=Zx(a.points,i),d=a.points[u]);let p={id:a.id,color:s.color};for(let h of this.columnHeaders)switch(h.type){case gt.RUN:let m="";s.alias&&(m=`${s.alias.aliasNumber} ${s.alias.aliasText}/`),p[h.name]=`${m}${s.displayName}`;continue;case gt.STEP:p[h.name]=c.step;continue;case gt.VALUE:p[h.name]=c.value;continue;case gt.RELATIVE_TIME:p[h.name]=c.relativeTimeInMs;continue;case gt.SMOOTHED:p[h.name]=c.y;continue;case gt.VALUE_CHANGE:if(!d)continue;p[h.name]=d.y-c.y;continue;case gt.START_STEP:p[h.name]=c.step;continue;case gt.END_STEP:if(!d)continue;p[h.name]=d.step;continue;case gt.START_VALUE:p[h.name]=c.y;continue;case gt.END_VALUE:if(!d)continue;p[h.name]=d.y;continue;case gt.MIN_VALUE:if(!u)continue;p[h.name]=this.getMinPointInRange(a.points,l,u).y;continue;case gt.MAX_VALUE:if(!u)continue;p[h.name]=this.getMaxPointInRange(a.points,l,u).y;continue;case gt.PERCENTAGE_CHANGE:if(!d)continue;p[h.name]=(d.y-c.y)/c.y;continue;case gt.STEP_AT_MAX:if(!u)continue;p[h.name]=this.getMaxPointInRange(a.points,l,u).step;continue;case gt.STEP_AT_MIN:if(!u)continue;p[h.name]=this.getMinPointInRange(a.points,l,u).step;continue;case gt.MEAN:if(!u)continue;p[h.name]=this.getMean(a.points,l,u);continue;case gt.RAW_CHANGE:if(!d)continue;p[h.name]=d.value-c.value;continue;case gt.HPARAM:p[h.name]=this.runToHparamMap?.[s.originalSeriesId||s.id]?.get(h.name)??"";continue;default:continue}return p}),o=this.columnHeaders.find(a=>a.name===this.sortingInfo.name);return void 0!==o&&r.sort((a,s)=>{if(!o)return 0;let l=this.getSortableValue(a,o),c=this.getSortableValue(s,o);return l<c?this.sortingInfo.order===Lr.ASCENDING?-1:1:l>c?this.sortingInfo.order===Lr.ASCENDING?1:-1:0}),r}getSortableValue(e,i){return function(n){return"object"==typeof n||Number.isNaN(n)||"NaN"===n||null==n?-1/0:n}(i.type===gt.RUN?this.chartMetadataMap[e.id].displayName:e[i.name])}getDataTableMode(){return this.stepOrLinkedTimeSelection.end?Wr.RANGE:Wr.SINGLE}onOrderColumns({source:e,destination:i,side:r}){this.editColumnHeaders.emit({source:e,destination:i,side:r,dataTableMode:this.getDataTableMode()})}onRemoveColumn(e){this.removeColumn.emit({header:e,dataTableMode:this.getDataTableMode()})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["scalar-card-data-table"]],inputs:{chartMetadataMap:"chartMetadataMap",dataSeries:"dataSeries",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",columnHeaders:"columnHeaders",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",columnContextMenusEnabled:"columnContextMenusEnabled",smoothingEnabled:"smoothingEnabled",columnFilters:"columnFilters",selectableColumns:"selectableColumns",numColumnsLoaded:"numColumnsLoaded",numColumnsToLoad:"numColumnsToLoad",runToHparamMap:"runToHparamMap"},outputs:{sortDataBy:"sortDataBy",editColumnHeaders:"editColumnHeaders",addColumn:"addColumn",removeColumn:"removeColumn",addFilter:"addFilter",loadAllColumns:"loadAllColumns"},decls:5,vars:9,consts:[[3,"headers","sortingInfo","columnFilters","selectableColumns","numColumnsLoaded","hasMoreColumnsToLoad","addColumnSize","sortDataBy","orderColumns","addColumn","removeColumn","addFilter","loadAllColumns"],["header",""],[4,"ngFor","ngForOf"],["content",""],[3,"header","sortingInfo","disableContextMenu",4,"ngIf"],[3,"header","sortingInfo","disableContextMenu"],[3,"header","datum",4,"ngIf"],[3,"header","datum"],["class","row-circle",4,"ngIf"],[1,"row-circle"]],template:function(e,i){1&e&&(f(0,"tb-data-table",0),A("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.onOrderColumns(o)})("addColumn",function(o){return i.addColumn.emit(o)})("removeColumn",function(o){return i.onRemoveColumn(o)})("addFilter",function(o){return i.addFilter.emit(o)})("loadAllColumns",function(){return i.loadAllColumns.emit()}),Gt(1,1),S(2,f3e,2,1,"ng-container",2),Wt(),Gt(3,3),S(4,v3e,3,1,"ng-container",2),Wt(),g()),2&e&&(b("headers",i.columnHeaders)("sortingInfo",i.sortingInfo)("columnFilters",i.columnFilters)("selectableColumns",i.selectableColumns)("numColumnsLoaded",i.numColumnsLoaded)("hasMoreColumnsToLoad",i.numColumnsLoaded===i.numColumnsToLoad)("addColumnSize",i.AddColumnSize.SMALL),v(2),b("ngForOf",i.extendHeaders(i.columnHeaders)),v(2),b("ngForOf",i.getTimeSelectionTableData()))},dependencies:[nn,Ne,m_,dA,mA,f_],styles:["tb-data-table-content-cell[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{padding:4px}.row-circle[_ngcontent-%COMP%]{height:12px;width:12px}.row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px;vertical-align:middle}"],changeDetection:0}),n})();var x3e=["stepSpan"];function C3e(n,t){if(1&n){let e=Te();f(0,"button",4),A("click",function(){return ne(e),ie(w().fobRemoved.emit())}),k(1,"mat-icon",5),g()}}function M3e(n,t){if(1&n){let e=Te();f(0,"button",4),A("click",function(){return ne(e),ie(w().fobRemoved.emit())}),k(1,"mat-icon",6),g()}}var w3e=function(n,t){return{fob:!0,unremovable:n,prospective:t}},sne=(()=>{class n{constructor(){this.allowRemoval=!0,this.isProspective=!1,this.stepChanged=new F,this.fobRemoved=new F}ngOnChanges(e){e.step&&document.activeElement===this.stepSpan.nativeElement&&this.stepSpan.nativeElement.blur()}validateStep(e){let i=String.fromCharCode(e.which);(" "===e.key||isNaN(Number(i)))&&e.preventDefault()}stepTyped(e){e.preventDefault();let i=e.target.innerText;this.stepChanged.emit(""!==i?Number(i):null)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["card-fob"]],viewQuery:function(e,i){if(1&e&&Ue(x3e,7,xe),2&e){let r;be(r=ve())&&(i.stepSpan=r.first)}},inputs:{step:"step",allowRemoval:"allowRemoval",isProspective:"isProspective"},outputs:{stepChanged:"stepChanged",fobRemoved:"fobRemoved"},features:[qt],decls:5,vars:7,consts:[[3,"ngClass"],["contenteditable","","role","textbox","aria-label","Edit step",3,"innerHTML","blur","keypress","keydown.enter","keydown.shift.enter"],["stepSpan",""],["aria-label","Deselect fob",3,"click",4,"ngIf"],["aria-label","Deselect fob",3,"click"],["svgIcon","close_24px"],["svgIcon","keep_24px"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"span",1,2),A("blur",function(o){return i.stepTyped(o)})("keypress",function(o){return i.validateStep(o)})("keydown.enter",function(o){return i.stepTyped(o)})("keydown.shift.enter",function(o){return o.preventDefault()}),g(),S(3,C3e,2,0,"button",3),S(4,M3e,2,0,"button",3),g()),2&e&&(b("ngClass",So(4,w3e,!i.allowRemoval,i.isProspective)),v(1),b("innerHTML",i.step,mk),v(2),b("ngIf",i.allowRemoval),v(1),b("ngIf",i.isProspective))},dependencies:[wn,Ne,bn],styles:["[_nghost-%COMP%]{display:inline-block}.fob[_ngcontent-%COMP%]{display:inline-flex;background-color:#e0e0e0;border-radius:25px;padding:2px 2px 2px 4px;font-size:11px;text-align:center;width:min-content}.fob[_ngcontent-%COMP%] > .prospective[_ngcontent-%COMP%]{padding-top:1px}.fob[_ngcontent-%COMP%]:hover{cursor:grab}.fob[_ngcontent-%COMP%]:hover.prospective{cursor:pointer}.fob[_ngcontent-%COMP%]:active{cursor:grabbing}.fob.unremovable[_ngcontent-%COMP%]{padding:2px 4px}.fob.prospective[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;border:1px dashed #9e9e9e;font-weight:bold;height:17px}span[_ngcontent-%COMP%]{color:inherit;display:inline-block}body.dark-mode[_nghost-%COMP%]   span[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   span[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]{margin-left:2px;padding:0;border:0;border-radius:50%;font-size:11px;width:11px;height:11px;background-color:inherit;color:inherit}button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%;height:110%}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]:hover{background-color:#9e9e9e;color:#eee;cursor:pointer}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover{background-color:#616161;color:#e0e0e0}"],changeDetection:0}),n})(),E3e=["startFobWrapper"],T3e=["endFobWrapper"],D3e=["prospectiveFobWrapper"];function I3e(n,t){1&n&&k(0,"div",6)}function A3e(n,t){if(1&n&&(f(0,"div",2,3),S(2,I3e,1,0,"div",4),k(3,"card-fob",5),g()),2&n){let e=w();Bt("transform",e.getCssTranslatePxForProspectiveFob()),v(2),b("ngIf",e.showExtendedLine),v(1),b("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("allowRemoval",!1)("isProspective",!0)("step",e.prospectiveStep)}}function R3e(n,t){if(1&n){let e=Te();f(0,"div",10),A("mousedown",function(r){ne(e);let o=w(2);return ie(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function P3e(n,t){if(1&n){let e=Te();f(0,"div",2,7),S(2,R3e,1,0,"div",8),f(3,"card-fob",9),A("mousedown",function(r){ne(e);let o=w();return ie(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){ne(e);let o=w();return ie(o.stepTyped(o.Fob.START,r))})("fobRemoved",function(){ne(e);let r=w();return ie(r.onFobRemoved(r.Fob.START))}),g()()}if(2&n){let e=w();Bt("transform",e.getCssTranslatePxForStartFob()),v(2),b("ngIf",e.showExtendedLine),v(1),b("allowRemoval",!!e.allowFobRemoval||e.timeSelection.end)("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.start.step)}}function k3e(n,t){if(1&n){let e=Te();f(0,"div",10),A("mousedown",function(r){ne(e);let o=w(2);return ie(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),g()}}function O3e(n,t){if(1&n){let e=Te();f(0,"div",2,11),S(2,k3e,1,0,"div",8),f(3,"card-fob",12),A("mousedown",function(r){ne(e);let o=w();return ie(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){ne(e);let o=w();return ie(o.stepTyped(o.Fob.END,r))})("fobRemoved",function(){ne(e);let r=w();return ie(r.onFobRemoved(r.Fob.END))}),g()()}if(2&n){let e=w();Bt("transform",e.getCssTranslatePxForEndFob()),v(2),b("ngIf",e.showExtendedLine),v(1),b("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.end.step)}}var Rr=(()=>(function(n){n[n.NONE=0]="NONE",n[n.START=1]="START",n[n.END=2]="END"}(Rr||(Rr={})),Rr))(),F3e={start:Rr.START,end:Rr.END},fA=(()=>{class n{constructor(e){this.root=e,this.showExtendedLine=!1,this.prospectiveStep=null,this.prospectiveStepAxisPosition=null,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.onProspectiveStepChanged=new F,this.hasFobMoved=!1,this.currentDraggingFob=Rr.NONE,this.affordance=Qa.NONE,this.mouseListener=this.mouseMove.bind(this),this.stopListener=this.stopDrag.bind(this),this.Fob=Rr,this.TimeSelectionAffordance=Qa}getCssTranslatePxForStartFob(){return this.axisDirection===va.VERTICAL?`translate(0px, ${this.startStepAxisPosition}px)`:`translate(${this.startStepAxisPosition}px, 0px)`}getCssTranslatePxForEndFob(){return null===this.endStepAxisPosition?"":this.axisDirection===va.VERTICAL?`translate(0px, ${this.endStepAxisPosition}px)`:`translate(${this.endStepAxisPosition}px, 0px)`}getCssTranslatePxForProspectiveFob(){return null===this.prospectiveStep?"":this.axisDirection===va.VERTICAL?`translate(0px, ${this.prospectiveStepAxisPosition}px)`:`translate(${this.prospectiveStepAxisPosition}px, 0px)`}stopEventPropagation(e){e.stopPropagation(),e.preventDefault()}startDrag(e,i,r){i!==Qa.FOB&&this.stopEventPropagation(r),document.addEventListener("mousemove",this.mouseListener),document.addEventListener("mouseup",this.stopListener),this.currentDraggingFob=e,this.affordance=i}stopDrag(){document.removeEventListener("mousemove",this.mouseListener),document.removeEventListener("mouseup",this.stopListener),this.currentDraggingFob=Rr.NONE,this.hasFobMoved&&this.timeSelection&&this.onTimeSelectionChanged.emit({timeSelection:this.timeSelection,affordance:this.affordance}),this.affordance=Qa.NONE,this.hasFobMoved=!1}isVertical(){return this.axisDirection===va.VERTICAL}shouldSwapFobs(e){return!(!this.timeSelection||!this.timeSelection.end)&&(this.currentDraggingFob===Rr.END?e<this.timeSelection.start.step:this.currentDraggingFob===Rr.START&&e>this.timeSelection.end.step)}getNewTimeSelection(e,i){let r={...i};if(!this.timeSelection)return r;if(!this.timeSelection.end)return r.start={step:e},r;if(this.shouldSwapFobs(e)){let[o,a]=this.currentDraggingFob===Rr.END?["end","start"]:["start","end"];return this.currentDraggingFob=F3e[a],r[o]=this.timeSelection[a],r[a]={step:e},r}return this.currentDraggingFob===Rr.END?(r.end={step:e},r):(r.start={step:e},r)}getNewStepFromMouseEvent(e){let i=null,r=this.getMousePositionFromEvent(e),o=this.axisDirection===va.VERTICAL?e.movementY:e.movementX;return this.isMovingHigher(r,o)?i=this.cardFobHelper.getStepHigherThanAxisPosition(r):this.isMovingLower(r,o)&&(i=this.cardFobHelper.getStepLowerThanAxisPosition(r)),null===i?null:i}mouseMove(e){if(this.currentDraggingFob===Rr.NONE)return;let i=this.getNewStepFromMouseEvent(e);if(null===i||!this.timeSelection)return;let r=this.getNewTimeSelection(i,this.timeSelection);this.onTimeSelectionChanged.emit({timeSelection:r}),this.hasFobMoved=!0}mouseOverProspectiveFobArea(e){if(null!=this.timeSelection?.end)return;let i=this.getNewStepFromMouseEvent(e);null!==i&&this.onProspectiveStepChanged.emit(i)}isMovingLower(e,i){if(this.currentDraggingFob===Rr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e<this.getDraggingFobCenter()&&i<0&&r>this.lowestStep}isMovingHigher(e,i){if(this.currentDraggingFob===Rr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e>this.getDraggingFobCenter()&&i>0&&r<this.highestStep}getDraggingFobCenter(){let e=this.getCurrentFob()?.nativeElement;if(!e)return 0;let i=e.getBoundingClientRect().top,r=e.getBoundingClientRect().left;return this.axisDirection===va.VERTICAL?i-this.root.nativeElement.getBoundingClientRect().top:r-this.root.nativeElement.getBoundingClientRect().left}getCurrentFob(){switch(this.currentDraggingFob){case Rr.START:return this.startFobWrapper;case Rr.END:return this.endFobWrapper;case Rr.NONE:return this.prospectiveFobWrapper}}getCurrentFobStep(){switch(this.currentDraggingFob){case Rr.START:return this.timeSelection?.start.step;case Rr.END:return this.timeSelection?.end?.step;case Rr.NONE:return this.prospectiveStep??void 0}}getMousePositionFromEvent(e){return this.axisDirection===va.VERTICAL?e.clientY-this.root.nativeElement.getBoundingClientRect().top:e.clientX-this.root.nativeElement.getBoundingClientRect().left}stepTyped(e,i){if(null===i)return void(null!==this.timeSelection.end&&this.onFobRemoved(e));let r={...this.timeSelection};e===Rr.START?r.start={step:i}:e===Rr.END&&(r.end={step:i}),null!==r.end&&r.start.step>r.end.step&&(r={start:r.end,end:r.start}),this.onTimeSelectionChanged.emit({timeSelection:r,affordance:Qa.FOB_TEXT})}prospectiveFobClicked(e){e.stopPropagation();let i=this.getProspectiveTimeSelection();!i||(this.onTimeSelectionChanged.emit({affordance:Qa.FOB_ADDED,timeSelection:i}),this.onProspectiveStepChanged.emit(null))}getProspectiveTimeSelection(){if(this.prospectiveStep)return this.timeSelection?{start:{step:Math.min(this.timeSelection.start.step,this.prospectiveStep)},end:{step:Math.max(this.timeSelection.start.step,this.prospectiveStep)}}:{start:{step:this.prospectiveStep},end:null}}onFobRemoved(e){e!==Rr.END?null===this.timeSelection.end?this.onTimeSelectionToggled.emit():this.onTimeSelectionChanged.emit({affordance:Qa.FOB_REMOVED,timeSelection:{start:this.timeSelection.end,end:null}}):this.onTimeSelectionChanged.emit({affordance:Qa.FOB_REMOVED,timeSelection:{...this.timeSelection,end:null}})}onProspectiveAreaMouseLeave(){this.onProspectiveStepChanged.emit(null)}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275cmp=P({type:n,selectors:[["card-fob-controller"]],viewQuery:function(e,i){if(1&e&&(Ue(E3e,5),Ue(T3e,5),Ue(D3e,5)),2&e){let r;be(r=ve())&&(i.startFobWrapper=r.first),be(r=ve())&&(i.endFobWrapper=r.first),be(r=ve())&&(i.prospectiveFobWrapper=r.first)}},inputs:{axisDirection:"axisDirection",timeSelection:"timeSelection",cardFobHelper:"cardFobHelper",startStepAxisPosition:"startStepAxisPosition",endStepAxisPosition:"endStepAxisPosition",highestStep:"highestStep",lowestStep:"lowestStep",showExtendedLine:"showExtendedLine",prospectiveStep:"prospectiveStep",prospectiveStepAxisPosition:"prospectiveStepAxisPosition",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled",onProspectiveStepChanged:"onProspectiveStepChanged"},decls:6,vars:4,consts:[["class","time-fob-wrapper",3,"transform",4,"ngIf"],[1,"prospective-fob-area",3,"ngClass","mousemove","click","mouseleave"],[1,"time-fob-wrapper"],["prospectiveFobWrapper",""],["class","extended-line",4,"ngIf"],[3,"ngClass","allowRemoval","isProspective","step"],[1,"extended-line"],["startFobWrapper",""],["class","extended-line",3,"mousedown",4,"ngIf"],[1,"startFob",3,"allowRemoval","ngClass","step","mousedown","stepChanged","fobRemoved"],[1,"extended-line",3,"mousedown"],["endFobWrapper",""],[1,"endFob",3,"ngClass","step","mousedown","stepChanged","fobRemoved"]],template:function(e,i){1&e&&(f(0,"div"),Gt(1),S(2,A3e,4,7,"div",0),f(3,"div",1),A("mousemove",function(o){return i.mouseOverProspectiveFobArea(o)})("click",function(o){return i.prospectiveFobClicked(o)})("mouseleave",function(){return i.onProspectiveAreaMouseLeave()}),g(),Wt(),S(4,P3e,4,6,"div",0),S(5,O3e,4,5,"div",0),g()),2&e&&(v(2),b("ngIf",null!==i.prospectiveStep),v(1),b("ngClass",i.isVertical()?"vertical-prospective-area":"horizontal-prospective-area"),v(1),b("ngIf",i.timeSelection),v(1),b("ngIf",i.timeSelection&&i.timeSelection.end))},dependencies:[wn,Ne,sne],styles:["[_nghost-%COMP%]{pointer-events:all}.time-fob-wrapper[_ngcontent-%COMP%]{display:inline-block;position:absolute;top:0;width:0}.vertical-fob[_ngcontent-%COMP%]{transform:translateY(-50%)}.horizontal-fob[_ngcontent-%COMP%]{transform:translateX(-50%)}.extended-line[_ngcontent-%COMP%]{border-style:dashed;border-width:0 1px;height:calc(100% - 30px)}.extended-line[_ngcontent-%COMP%]:hover{background:linear-gradient(to right, transparent 18px, #ccc 19px, #ccc 21px, transparent 22px);border:0;cursor:ew-resize;margin-left:-20px;padding:0 20px}.horizontal-prospective-area[_ngcontent-%COMP%]{bottom:0;cursor:pointer;position:absolute;height:30px;width:calc(100% - 74px)}.prospective-area[_ngcontent-%COMP%]{display:block}"],changeDetection:0}),n})(),CV=(()=>{class n{constructor(){this.disableInteraction=!1,this.allowFobRemoval=!0,this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.axisDirection=va.HORIZONTAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)},this.prospectiveStep=null}getAxisPositionFromStartStep(){return this.timeSelection?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection.start.step):""}getAxisPositionFromEndStep(){return this.timeSelection?.end?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection?.end.step??this.minMaxStep.maxStep):null}getAxisPositionFromProspectiveStep(){return null===this.prospectiveStep?null:this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.prospectiveStep)}onProspectiveStepChanged(e){this.prospectiveStep=e}getHighestStep(){return this.minMaxStep.maxStep}getLowestStep(){return this.minMaxStep.minStep}getStepHigherThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepLowerThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepAtMousePostion(e){let i=Math.round(this.scale.reverse(this.minMaxHorizontalViewExtend,[0,this.axisSize],e));return i>this.getHighestStep()?this.getHighestStep():i<this.getLowestStep()?this.getLowestStep():i}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["scalar-card-fob-controller"]],inputs:{timeSelection:"timeSelection",scale:"scale",minMaxHorizontalViewExtend:"minMaxHorizontalViewExtend",minMaxStep:"minMaxStep",axisSize:"axisSize",disableInteraction:"disableInteraction",allowFobRemoval:"allowFobRemoval"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:13,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","prospectiveStepAxisPosition","highestStep","lowestStep","prospectiveStep","cardFobHelper","showExtendedLine","allowFobRemoval","onProspectiveStepChanged","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(f(0,"card-fob-controller",0),A("onProspectiveStepChanged",function(o){return i.onProspectiveStepChanged(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(o){return i.onTimeSelectionToggled.emit(o)}),g()),2&e&&(Bt("pointer-events",i.disableInteraction?"none":"all"),b("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("prospectiveStepAxisPosition",i.getAxisPositionFromProspectiveStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("prospectiveStep",i.prospectiveStep)("cardFobHelper",i.cardFobHelper)("showExtendedLine",!0)("allowFobRemoval",i.allowFobRemoval))},dependencies:[fA],styles:["scalar-card-fob-controller .time-fob-wrapper{height:100%}"],changeDetection:0}),n})(),N3e=["dataTableContainer"];function L3e(n,t){if(1&n){let e=Te();f(0,"button",27),A("click",function(){return ne(e),ie(w().openTableEditMenu())}),k(1,"mat-icon",28),f(2,"span"),T(3,"Edit Table Columns"),g()()}}function B3e(n,t){1&n&&k(0,"mat-spinner",29)}function V3e(n,t){1&n&&(f(0,"th"),T(1,"Smoothed"),g())}function H3e(n,t){if(1&n&&(Gt(0),k(1,"tb-experiment-alias",35),T(2,"/"),Wt()),2&n){let e=w().$implicit;v(1),b("alias",e.metadata.alias)}}function z3e(n,t){if(1&n&&(f(0,"td"),T(1),g()),2&n){let e=w().$implicit,i=w(2);v(1),Ve(" ",i.valueFormatter.formatShort(e.dataPoint.y)," ")}}function U3e(n,t){if(1&n&&(Gt(0),f(1,"tr",33)(2,"td",34),k(3,"span"),g(),f(4,"td",2),S(5,H3e,3,1,"ng-container",24),T(6),g(),S(7,z3e,2,1,"td",24),f(8,"td"),T(9),g(),f(10,"td"),T(11),g(),f(12,"td"),T(13),U(14,"date"),g(),f(15,"td"),T(16),g()(),Wt()),2&n){let e=t.$implicit,i=w(2);v(1),nt("closest",e.metadata.closest),v(2),Bt("background-color",e.metadata.color),v(2),b("ngIf",e.metadata.alias),v(1),Ve("",e.metadata.displayName," "),v(1),b("ngIf",i.smoothingEnabled),v(2),kt(i.valueFormatter.formatShort(e.dataPoint.value)),v(2),kt(i.stepFormatter.formatShort(e.dataPoint.step)),v(2),kt(Jp(14,11,e.dataPoint.wallTime,"short")),v(3),Ve(" ",i.relativeXFormatter.formatReadable(e.dataPoint.relativeTimeInMs)," ")}}function j3e(n,t){if(1&n&&(f(0,"table",30)(1,"thead")(2,"tr"),k(3,"th",31),f(4,"th"),T(5,"Run"),g(),S(6,V3e,2,0,"th",24),f(7,"th"),T(8,"Value"),g(),f(9,"th"),T(10,"Step"),g(),f(11,"th"),T(12,"Time"),g(),f(13,"th"),T(14,"Relative"),g()()(),f(15,"tbody"),S(16,U3e,17,14,"ng-container",32),g()()),2&n){let e=t.data,i=t.cursorLocationInDataCoord,r=t.cursorLocation,o=w();v(6),b("ngIf",o.smoothingEnabled),v(10),b("ngForOf",o.getCursorAwareTooltipData(e,i,r))("ngForTrackBy",o.trackByTooltipDatum)}}function G3e(n,t){if(1&n){let e=Te();f(0,"button",41),A("click",function(){return ne(e),ie(w(2).toggleTableExpanded())}),k(1,"mat-icon",9),g()}if(2&n){let e=w(2);b("title",e.shouldExpandTable()?"Expand Table":"Collapse Table"),v(1),b("svgIcon",e.shouldExpandTable()?"expand_more_24px":"expand_less_24px")}}var W3e=function(n){return{"data-table-container":!0,expanded:n}};function q3e(n,t){if(1&n){let e=Te();Gt(0),f(1,"div",36,37)(3,"scalar-card-data-table",38),A("sortDataBy",function(r){return ne(e),ie(w().sortDataBy(r))})("editColumnHeaders",function(r){return ne(e),ie(w().editColumnHeaders.emit(r))})("addColumn",function(r){return ne(e),ie(w().addColumn.emit(r))})("removeColumn",function(r){return ne(e),ie(w().removeColumn.emit(r))})("hideColumn",function(r){return ne(e),ie(w().hideColumn.emit(r))})("addFilter",function(r){return ne(e),ie(w().addFilter.emit(r))})("loadAllColumns",function(){return ne(e),ie(w().loadAllColumns.emit())}),g()(),f(4,"div",39),S(5,G3e,2,2,"button",40),g(),Wt()}if(2&n){let e=w();v(1),b("ngClass",Un(15,W3e,e.cardState.tableExpanded)),v(2),b("chartMetadataMap",e.chartMetadataMap)("dataSeries",e.dataSeries)("stepOrLinkedTimeSelection",e.stepOrLinkedTimeSelection)("columnHeaders",e.columnHeaders)("sortingInfo",e.sortingInfo)("columnCustomizationEnabled",e.columnCustomizationEnabled)("columnContextMenusEnabled",e.columnContextMenusEnabled)("smoothingEnabled",e.smoothingEnabled)("columnFilters",e.columnFilters)("runToHparamMap",e.runToHparamMap)("selectableColumns",e.selectableColumns)("numColumnsLoaded",e.numColumnsLoaded)("numColumnsToLoad",e.numColumnsToLoad),v(2),b("ngIf",e.canExpandTable())}}var X3e=function(n){return[0,n]},Y3e=function(){return{"out-of-selected-time":!0,end:!0,range:!0}};function Q3e(n,t){if(1&n&&k(0,"div",36),2&n){let e=w(2),i=e.viewExtent,r=e.domDimension,o=e.xScale,a=w();Bt("left",o.forward(i.x,Un(3,X3e,r.width),null==a.stepOrLinkedTimeSelection.end?null:a.stepOrLinkedTimeSelection.end.step)+"px"),b("ngClass",mc(5,Y3e))}}var Z3e=function(n){return[n,0]},K3e=function(n){return{"out-of-selected-time":!0,start:!0,range:n}};function J3e(n,t){if(1&n&&(Gt(0),k(1,"div",36),S(2,Q3e,1,6,"div",42),Wt()),2&n){let e=w(),i=e.viewExtent,r=e.domDimension,o=e.xScale,a=w();v(1),Bt("right",o.forward(i.x,Un(4,Z3e,r.width),a.stepOrLinkedTimeSelection.start.step)+"px"),b("ngClass",Un(6,K3e,!(null==a.stepOrLinkedTimeSelection.end||!a.stepOrLinkedTimeSelection.end.step))),v(1),b("ngIf",null==a.stepOrLinkedTimeSelection.end?null:a.stepOrLinkedTimeSelection.end.step)}}function $3e(n,t){1&n&&S(0,J3e,3,8,"ng-container",24),2&n&&b("ngIf",w().stepOrLinkedTimeSelection)}function eBe(n,t){if(1&n){let e=Te();Gt(0),f(1,"scalar-card-fob-controller",43),A("onTimeSelectionChanged",function(r){return ne(e),ie(w(2).onTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return ne(e),ie(w(2).onFobRemoved())}),g(),Wt()}if(2&n){let e=w(),i=e.interactionState,r=e.xScale,o=e.viewExtent,a=e.domDimension,s=w();v(1),b("disableInteraction","NONE"!==i)("timeSelection",s.stepOrLinkedTimeSelection)("scale",r)("minMaxHorizontalViewExtend",o.x)("minMaxStep",s.minMaxStep)("axisSize",a.width)}}function tBe(n,t){1&n&&S(0,eBe,2,6,"ng-container",24),2&n&&b("ngIf",w().showFobController())}var dne=(()=>{class n{constructor(e,i){this.ref=e,this.dialog=i,this.DataLoadState=Re,this.RendererType=Yi,this.ScaleType=tr,this.onFullSizeToggle=new F,this.onPinClicked=new F,this.onTimeSelectionChanged=new F,this.onStepSelectorToggled=new F,this.onDataTableSorting=new F,this.editColumnHeaders=new F,this.openTableEditMenuToMode=new F,this.addColumn=new F,this.removeColumn=new F,this.addFilter=new F,this.loadAllColumns=new F,this.onLineChartZoom=new F,this.onCardStateChanged=new F,this.sortingInfo={name:"run",order:Lr.ASCENDING},this.yScaleType=tr.LINEAR,this.isViewBoxOverridden=!1,this.relativeXFormatter=x0,this.valueFormatter=dp,this.stepFormatter=y0}toggleYScaleType(){this.yScaleType=this.yScaleType===tr.LINEAR?tr.LOG10:tr.LINEAR}sortDataBy(e){this.sortingInfo=e,this.onDataTableSorting.emit(e)}resetDomain(){this.lineChart&&this.lineChart.viewBoxReset()}trackByTooltipDatum(e,i){return i.id}getCustomXFormatter(){switch(this.xAxisType){case Pi.RELATIVE:return x0;case Pi.STEP:return o3;default:return}}getCursorAwareTooltipData(e,i,r){let o=e.map(l=>({...l,metadata:{...l.metadata,closest:!1,distToCursorPixels:Math.hypot(l.domPoint.x-r.x,l.domPoint.y-r.y),distToCursorX:l.dataPoint.x-i.x,distToCursorY:l.dataPoint.y-i.y}})),a=1/0,s=0;for(let l=0;l<o.length;l++)a>o[l].metadata.distToCursorPixels&&(a=o[l].metadata.distToCursorPixels,s=l);switch(o.length&&(o[s].metadata.closest=!0),this.tooltipSort){case oo.ASCENDING:return o.sort((l,c)=>l.dataPoint.y-c.dataPoint.y);case oo.DESCENDING:return o.sort((l,c)=>c.dataPoint.y-l.dataPoint.y);case oo.NEAREST:return o.sort((l,c)=>l.metadata.distToCursorPixels-c.metadata.distToCursorPixels);case oo.NEAREST_Y:return o.sort((l,c)=>l.metadata.distToCursorY-c.metadata.distToCursorY);case oo.DEFAULT:case oo.ALPHABETICAL:return o.sort((l,c)=>l.metadata.displayName<c.metadata.displayName?-1:l.metadata.displayName>c.metadata.displayName?1:0)}}openDataDownloadDialog(){this.dialog.open(this.DataDownloadComponent,{data:{cardId:this.cardId}})}onFobRemoved(){this.onStepSelectorToggled.emit(Za.FOB_DESELECT)}showDataTable(){return this.xAxisType===Pi.STEP&&this.stepOrLinkedTimeSelection}showFobController(){return this.xAxisType===Pi.STEP&&this.minMaxStep}canExpandTable(){return this.dataSeries.filter(i=>GS(i,this.chartMetadataMap)).length>3}shouldExpandTable(){return Boolean(this.dataTableContainer?.nativeElement.style.height||!this.cardState?.tableExpanded)}toggleTableExpanded(){this.onCardStateChanged.emit({...this.cardState,tableExpanded:this.shouldExpandTable()}),this.dataTableContainer&&(this.dataTableContainer.nativeElement.style.height="")}openTableEditMenu(){this.openTableEditMenuToMode.emit(this.rangeEnabled?Wr.RANGE:Wr.SINGLE)}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(ys))},n.\u0275cmp=P({type:n,selectors:[["scalar-card-component"]],viewQuery:function(e,i){if(1&e&&(Ue(h_,5),Ue(N3e,5)),2&e){let r;be(r=ve())&&(i.lineChart=r.first),be(r=ve())&&(i.dataTableContainer=r.first)}},inputs:{cardId:"cardId",chartMetadataMap:"chartMetadataMap",cardState:"cardState",DataDownloadComponent:"DataDownloadComponent",dataSeries:"dataSeries",ignoreOutliers:"ignoreOutliers",isCardVisible:"isCardVisible",isPinned:"isPinned",loadState:"loadState",showFullWidth:"showFullWidth",smoothingEnabled:"smoothingEnabled",tag:"tag",title:"title",tooltipSort:"tooltipSort",xAxisType:"xAxisType",xScaleType:"xScaleType",useDarkMode:"useDarkMode",forceSvg:"forceSvg",columnCustomizationEnabled:"columnCustomizationEnabled",columnContextMenusEnabled:"columnContextMenusEnabled",linkedTimeSelection:"linkedTimeSelection",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",minMaxStep:"minMaxStep",userViewBox:"userViewBox",columnHeaders:"columnHeaders",rangeEnabled:"rangeEnabled",columnFilters:"columnFilters",selectableColumns:"selectableColumns",numColumnsLoaded:"numColumnsLoaded",numColumnsToLoad:"numColumnsToLoad",runToHparamMap:"runToHparamMap"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onTimeSelectionChanged:"onTimeSelectionChanged",onStepSelectorToggled:"onStepSelectorToggled",onDataTableSorting:"onDataTableSorting",editColumnHeaders:"editColumnHeaders",openTableEditMenuToMode:"openTableEditMenuToMode",addColumn:"addColumn",removeColumn:"removeColumn",addFilter:"addFilter",loadAllColumns:"loadAllColumns",onLineChartZoom:"onLineChartZoom",onCardStateChanged:"onCardStateChanged"},decls:38,vars:29,consts:function(){let t,e,i,r,o,a;return t=$localize`:A button that resets line chart domain to the data␟e68a552941ab427a99e7437e08443f30ac71ccd6␟3830646521058268558:Fit line chart domains to data`,e=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,i=$localize`:A button on line chart that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,r=$localize`:An overflow menu button that opens more line chart options␟b260fab946a3077ce20fd28e336979f586720e8d␟878053740210336435:More line chart options`,o=$localize`:A button that toggles log scale on y-axis on a line chart␟fe91f96ab9b3baca5a48913f2b0fae84483d93e3␟3374645620638883926:Toggle Y-axis log scale on line chart`,a=$localize`:Expand Table␟9e59ff50bfcb479272e2b103e1e9b11518e2e4ce␟6374880341393020610:Expand Table`,[[1,"always-visible"],[1,"heading"],[1,"name"],[1,"tag",3,"title","value"],[3,"isClipped"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"disabled","title","click"],["svgIcon","settings_overscan_24px"],["mat-icon-button","","aria-label",e,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",i,"title","Toggle full size mode",3,"click"],["mat-icon-button","","aria-label",r,"title","More line chart options",3,"matMenuTriggerFor"],["svgIcon","more_vert_24px"],["menu","matMenu"],["mat-menu-item","","aria-label",o,3,"click"],["svgIcon","line_weight_24px"],["mat-menu-item","","aria-label","Open dialog to download data",3,"click"],["svgIcon","get_app_24px"],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click",4,"ngIf"],[1,"chart-container"],["chartContainer",""],["diameter","18",4,"ngIf"],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate","useDarkMode","userViewBox","customVisTemplate","customChartOverlayTemplate","onViewBoxOverridden","viewBoxChanged"],["tooltip",""],[4,"ngIf"],["lineChartCustomVis",""],["lineChartCustomXAxisVis",""],["mat-menu-item","","aria-label","Open menu to edit data table columns",3,"click"],["svgIcon","edit_24px"],["diameter","18"],[1,"tooltip"],[1,"circle-header"],[4,"ngFor","ngForOf","ngForTrackBy"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[3,"alias"],[3,"ngClass"],["dataTableContainer",""],[3,"chartMetadataMap","dataSeries","stepOrLinkedTimeSelection","columnHeaders","sortingInfo","columnCustomizationEnabled","columnContextMenusEnabled","smoothingEnabled","columnFilters","runToHparamMap","selectableColumns","numColumnsLoaded","numColumnsToLoad","sortDataBy","editColumnHeaders","addColumn","removeColumn","hideColumn","addFilter","loadAllColumns"],[1,"bottom-area"],["mat-icon-button","","class","expand-button","aria-label",a,3,"title","click",4,"ngIf"],["mat-icon-button","","aria-label",a,1,"expand-button",3,"title","click"],[3,"ngClass","left",4,"ngIf"],[3,"disableInteraction","timeSelection","scale","minMaxHorizontalViewExtend","minMaxStep","axisSize","onTimeSelectionChanged","onTimeSelectionToggled"]]},template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1)(2,"span",2),k(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),g(),f(5,"span",5)(6,"button",6),A("click",function(){return i.resetDomain()}),U(7,"async"),U(8,"async"),k(9,"mat-icon",7),g(),f(10,"button",8),A("click",function(){return i.onPinClicked.emit(!i.isPinned)}),k(11,"mat-icon",9),g(),f(12,"button",10),A("click",function(){return i.onFullSizeToggle.emit()}),k(13,"mat-icon",9),g(),f(14,"button",11),k(15,"mat-icon",12),g(),f(16,"mat-menu",null,13)(18,"button",14),A("click",function(){return i.toggleYScaleType()}),k(19,"mat-icon",15),f(20,"span"),T(21,"Toggle Y-axis log scale"),g()(),f(22,"button",16),A("click",function(){return i.openDataDownloadDialog()}),k(23,"mat-icon",17),f(24,"span"),T(25,"Download data"),g()(),S(26,L3e,4,0,"button",18),g()()(),f(27,"div",19,20),S(29,B3e,1,0,"mat-spinner",21),f(30,"line-chart",22),A("onViewBoxOverridden",function(o){return i.isViewBoxOverridden=o})("viewBoxChanged",function(o){return i.onLineChartZoom.emit(o)}),g(),S(31,j3e,17,3,"ng-template",null,23,jt),g()(),S(33,q3e,6,17,"ng-container",24),S(34,$3e,1,1,"ng-template",null,25,jt),S(36,tBe,1,1,"ng-template",null,26,jt)),2&e){let r=st(17),o=st(32),a=st(35),s=st(37);v(3),Zi("title",i.tag),Zi("value",i.title),v(1),b("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped),v(2),b("disabled",!i.lineChart||!G(7,25,i.lineChart.getIsViewBoxOverridden()))("title",i.lineChart&&G(8,27,i.lineChart.getIsViewBoxOverridden())?"Line chart is already fitted to data. When data updates, the line chart will auto fit to its domain.":"Fit line chart domains to data"),v(4),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),b("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(2),b("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),v(1),b("matMenuTriggerFor",r),v(12),b("ngIf",i.columnCustomizationEnabled),v(3),b("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),b("disableUpdate",!i.isCardVisible)("preferredRendererType",i.forceSvg?i.RendererType.SVG:i.RendererType.WEBGL)("seriesData",i.dataSeries)("seriesMetadataMap",i.chartMetadataMap)("xScaleType",i.xScaleType)("yScaleType",i.yScaleType)("customXFormatter",i.getCustomXFormatter())("ignoreYOutliers",i.ignoreOutliers)("tooltipTemplate",o)("useDarkMode",i.useDarkMode)("userViewBox",i.userViewBox)("customVisTemplate",a)("customChartOverlayTemplate",s),v(3),b("ngIf",i.showDataTable())}},dependencies:[wn,nn,Ne,Kg,h_,Er,bn,Xu,Ed,Yu,Nc,ane,CV,Jg,$g,ct,wf],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;padding:16px;padding-top:4px}[_nghost-%COMP%]:has(.expand-button){padding:4px 16px 0}.always-visible[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-basis:298px}.always-visible[_ngcontent-%COMP%]:not(:has(.expand-button)){flex-grow:1}.heading[_ngcontent-%COMP%]{align-items:center;display:flex;font-size:14px;justify-content:space-between;margin-bottom:4px;position:relative}.heading[_ngcontent-%COMP%]   .name[_ngcontent-%COMP%]{align-items:center;display:grid;gap:5px;grid-template-columns:auto auto}.heading[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{font-size:1.2em;line-height:0}.tag[_ngcontent-%COMP%]{overflow:hidden}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.chart-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex-grow:1;overflow:hidden;resize:vertical}.chart-container[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{position:absolute;right:11px;top:11px}.chart-container[_ngcontent-%COMP%]   line-chart[_ngcontent-%COMP%]{flex-grow:1}.tooltip[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.tooltip[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.tooltip[_ngcontent-%COMP%]   .tooltip-row[_ngcontent-%COMP%]{white-space:nowrap}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.tooltip[_ngcontent-%COMP%]   .closest[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-color:#fff;box-shadow:inset 0 0 0 1px #fff}.out-of-selected-time[_ngcontent-%COMP%]{height:100%;position:absolute}.out-of-selected-time.start[_ngcontent-%COMP%]{border-right-width:2px;margin-left:-1px}.out-of-selected-time.start.range[_ngcontent-%COMP%]{left:0}.out-of-selected-time.end[_ngcontent-%COMP%]{border-left-width:2px;margin-right:-1px;right:0}.out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.5)}body.dark-mode[_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.4)}.data-table-container[_ngcontent-%COMP%]{height:100px;min-height:100px;max-height:50em;overflow:auto;resize:vertical}.data-table-container.expanded[_ngcontent-%COMP%]{height:auto}.bottom-area[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:center}.bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-area[_ngcontent-%COMP%]   .expand-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background-color:#303030}"],changeDetection:0}),n})();function iBe(n,t){return n.length===t.length&&n.every((e,i)=>{let r=t[i],o=e.points,a=r.points;return e.runId===r.runId&&o.length===a.length&&o.every((s,l)=>{let c=a[l];return s.x===c.x&&s.y===c.y})})}var une=(()=>{class n{constructor(e){this.store=e,this.DataDownloadComponent=JQ,this.pinStateChanged=new F,this.isVisible=!1,this.columnFilters$=this.store.select(XT),this.numColumnsLoaded$=this.store.select(Mc.getNumDashboardHparamsLoaded),this.numColumnsToLoad$=this.store.select(Mc.getNumDashboardHparamsToLoad),this.useDarkMode$=this.store.select(Pl),this.ignoreOutliers$=this.store.select(Ch),this.tooltipSort$=this.store.select(xh),this.xAxisType$=this.store.select(Ol),this.forceSvg$=this.store.select(yF),this.columnCustomizationEnabled$=this.store.select(uS),this.columnContextMenusEnabled$=this.store.select(T6),this.xScaleType$=this.store.select(Ol).pipe(q(i=>{switch(i){case Pi.STEP:case Pi.RELATIVE:return tr.LINEAR;case Pi.WALL_TIME:return tr.TIME;default:throw new Error(`Invalid xAxisType for line chart. ${i}`)}})),this.scalarSmoothing$=this.store.select(_d),this.smoothingEnabled$=this.store.select(_d).pipe(q(i=>i>0)),this.showFullWidth$=this.store.select(Js).pipe(q(i=>i[this.cardId]?.fullWidth)),this.ngUnsubscribe=new Ee}onVisibilityChange({visible:e}){this.isVisible=e}isScalarCardMetadata(e){let{plugin:i}=e;return i===An.SCALARS}onFullSizeToggle(){this.store.dispatch(zg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Ks,this.cardId).pipe(Oe(l=>!!l&&this.isScalarCardMetadata(l)),q(l=>l));function a(l){return JSON.stringify(["smoothed",l])}let s=this.store.select(wu,this.cardId).pipe(it(this.ngUnsubscribe),Oe(l=>Boolean(l)),q(l=>l),Da(1)).pipe(Vi(this.store.select(Ol)),q(([l,c])=>Object.keys(l).map(p=>({runId:p,points:this.stepSeriesToLineSeries(l[p],c)}))),ri(iBe)).pipe(Vi(this.store.select(s1)),it(this.ngUnsubscribe),q(([l,c])=>c?function(n){let t=[];for(let e of n){let i=[],r=Number.isFinite(e.points[0]?.x)?e.points[0].x:-1/0,o=[];for(let a of e.points)Number.isFinite(a.x)?(a.x<r&&(i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o}),o=[]),o.push(a),r=a.x):o.push(a);i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o});for(let a=0;a<i.length;a++)t.push({...i[a],partitionIndex:a,partitionSize:i.length})}return t}(l):l.map(d=>({...d,seriesId:d.runId,partitionIndex:0,partitionSize:1}))),q(l=>l.map(c=>{let d=c.points[0]?.wallTime;return{...c,points:c.points.map(u=>({...u,relativeTimeInMs:u.wallTime-d}))}})),Vi(this.store.select(Ol)),q(([l,c])=>l.map(d=>({...d,points:d.points.map(u=>{let p;switch(c){case Pi.RELATIVE:p=u.relativeTimeInMs;break;case Pi.WALL_TIME:p=u.wallTime;break;default:p=u.step}return{...u,x:p}})}))),Da(1));this.userViewBox$=this.store.select($F,this.cardId),this.minMaxSteps$=In([this.store.select(BW,this.cardId),this.store.select(VW,this.cardId)]).pipe(q(([l,c])=>{if(l&&c)return{minStep:Math.max(l?.minStep,c?.minStep),maxStep:Math.min(l?.maxStep,c?.maxStep)}})),this.dataSeries$=s.pipe(Vi(this.store.select(_d)),Jn(([l,c])=>{let d=l.map(({seriesId:u,points:p})=>({id:u,points:p}));return c<=0?$t(d):Jr(async function(n,t){Number.isFinite(t)||(t=0),t=Math.max(0,Math.min(t,1));let e=[];for(let i of n){let r=i.points[0]?.y;if(i.points.every(c=>c.y==r)){e.push(i);continue}let a=i.points.length>0?0:NaN,s=0,l=i.points.map(c=>{let d=c.y;if(Number.isFinite(d)){a=a*t+(1-t)*d,s++;let u=1===t?1:1-Math.pow(t,s);return{x:c.x,y:a/u}}return{x:c.x,y:d}});e.push({id:i.id,points:l})}return e}(d,c)).pipe(q(u=>{let p=d.map((h,m)=>({id:a(h.id),points:u[m].points.map(({y:_},M)=>({...h.points[M],y:_}))}));return[...d,...p]}))}),kn([])),this.linkedTimeSelection$=In([this.minMaxSteps$,this.store.select(Eu),this.store.select(Du),this.store.select(Ol)]).pipe(q(([l,c,d,u])=>l&&c&&u===Pi.STEP&&d?Yf(d,l.minStep,l.maxStep):null)),this.stepOrLinkedTimeSelection$=this.store.select(HW,this.cardId),this.columnHeaders$=this.store.select(zW(this.cardId)),this.chartMetadataMap$=s.pipe(Jn(l=>In(l.map(c=>this.getRunDisplayNameAndAlias(c.runId).pipe(q(d=>({...c,...d})))))),Vi(this.store.select(Ru),this.store.select(zQ),this.store.select(Pu),this.store.select(_d)),Cr(0),q(([l,c,d,u,p])=>{let h={},m=p>0;for(let _ of l){let{seriesId:M,runId:y,displayName:x,alias:R,partitionIndex:I,partitionSize:B}=_;h[M]={type:Yg.ORIGINAL,id:M,alias:R,displayName:B>1?`${x}: ${I}`:x,visible:Boolean(c&&c.get(y)&&d.has(y)),color:u[y]??"#fff",aux:!1,opacity:1}}if(!m)return h;for(let[_,M]of Object.entries(h)){let y=a(_);h[y]={...M,id:y,type:Yg.DERIVED,aux:!1,originalSeriesId:_},M.aux=!0,M.opacity=.25}return h}),kn({})),this.loadState$=this.store.select(gd,this.cardId),this.tag$=i.pipe(q(l=>l.tag)),this.cardState$=this.store.select(Js).pipe(q(l=>l[this.cardId]||{})),this.title$=this.tag$.pipe(q(l=>Zg(l,this.groupName))),this.isPinned$=this.store.select(Su,this.cardId),this.rangeEnabled$=this.store.select(m1(this.cardId)),this.runToHparamMap$=this.store.select(XW),this.selectableColumns$=this.store.select(YT)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getRunDisplayNameAndAlias(e){return In([this.store.select(_1,{runId:e}),this.store.select(qs),this.store.select(b1,{runId:e})]).pipe(q(([i,r,o])=>{let a=null!==i?r[i]??null:null;return{displayName:o||a?o?.name??"...":e,alias:a}}))}stepSeriesToLineSeries(e,i){let r=i===Pi.STEP;return e.map(o=>{let a=1e3*o.wallTime;return{...o,x:r?o.step:a,y:o.value,wallTime:a,relativeTimeInMs:0}})}onDataTableSorting(e){this.store.dispatch(rQ(e))}onCardStateChanged(e){this.store.dispatch(fT({cardId:this.cardId,settings:e}))}onTimeSelectionChanged(e){this.store.dispatch(Hh({...e,cardId:this.cardId}))}onStepSelectorToggled(e){this.store.dispatch(Td({affordance:e,cardId:this.cardId}))}onLineChartZoom(e){this.store.dispatch(_y({userViewBox:e,cardId:this.cardId}))}editColumnHeaders({source:e,destination:i,side:r,dataTableMode:o}){this.store.dispatch("HPARAM"===e.type?ro.dashboardHparamColumnOrderChanged({source:e,destination:i,side:r}):jg({source:e,destination:i,side:r,dataTableMode:o}))}openTableEditMenuToMode(e){this.store.dispatch(cT({mode:e}))}onAddColumn(e){this.store.dispatch(ro.dashboardHparamColumnAdded(e))}onRemoveColumn({header:e,dataTableMode:i}){this.store.dispatch("HPARAM"===e.type?ro.dashboardHparamColumnRemoved({column:e}):Gg({header:e,cardId:this.cardId,dataTableMode:i}))}addHparamFilter(e){this.store.dispatch(ro.dashboardHparamFilterAdded({name:e.name,filter:e.value}))}loadAllColumns(){this.store.dispatch(ro.loadAllDashboardHparams())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["scalar-card"]],inputs:{DataDownloadComponent:"DataDownloadComponent",cardId:"cardId",groupName:"groupName"},outputs:{pinStateChanged:"pinStateChanged"},decls:29,vars:87,consts:[["observeIntersection","",3,"cardId","chartMetadataMap","DataDownloadComponent","dataSeries","ignoreOutliers","isCardVisible","isPinned","loadState","showFullWidth","smoothingEnabled","tag","title","cardState","tooltipSort","xAxisType","xScaleType","useDarkMode","linkedTimeSelection","stepOrLinkedTimeSelection","forceSvg","columnCustomizationEnabled","columnContextMenusEnabled","minMaxStep","userViewBox","columnHeaders","rangeEnabled","columnFilters","runToHparamMap","selectableColumns","numColumnsLoaded","numColumnsToLoad","onFullSizeToggle","onPinClicked","onVisibilityChange","onTimeSelectionChanged","onStepSelectorToggled","onDataTableSorting","onLineChartZoom","editColumnHeaders","onCardStateChanged","openTableEditMenuToMode","addColumn","removeColumn","addFilter","loadAllColumns"]],template:function(e,i){1&e&&(f(0,"scalar-card-component",0),A("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onVisibilityChange",function(o){return i.onVisibilityChange(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged(o)})("onStepSelectorToggled",function(o){return i.onStepSelectorToggled(o)})("onDataTableSorting",function(o){return i.onDataTableSorting(o)})("onLineChartZoom",function(o){return i.onLineChartZoom(o)})("editColumnHeaders",function(o){return i.editColumnHeaders(o)})("onCardStateChanged",function(o){return i.onCardStateChanged(o)})("openTableEditMenuToMode",function(o){return i.openTableEditMenuToMode(o)})("addColumn",function(o){return i.onAddColumn(o)})("removeColumn",function(o){return i.onRemoveColumn(o)})("addFilter",function(o){return i.addHparamFilter(o)})("loadAllColumns",function(){return i.loadAllColumns()}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),U(10,"async"),U(11,"async"),U(12,"async"),U(13,"async"),U(14,"async"),U(15,"async"),U(16,"async"),U(17,"async"),U(18,"async"),U(19,"async"),U(20,"async"),U(21,"async"),U(22,"async"),U(23,"async"),U(24,"async"),U(25,"async"),U(26,"async"),U(27,"async"),U(28,"async"),g()),2&e&&b("cardId",i.cardId)("chartMetadataMap",G(1,31,i.chartMetadataMap$))("DataDownloadComponent",i.DataDownloadComponent)("dataSeries",G(2,33,i.dataSeries$))("ignoreOutliers",G(3,35,i.ignoreOutliers$))("isCardVisible",i.isVisible)("isPinned",G(4,37,i.isPinned$))("loadState",G(5,39,i.loadState$))("showFullWidth",G(6,41,i.showFullWidth$))("smoothingEnabled",G(7,43,i.smoothingEnabled$))("tag",G(8,45,i.tag$))("title",G(9,47,i.title$))("cardState",G(10,49,i.cardState$))("tooltipSort",G(11,51,i.tooltipSort$))("xAxisType",G(12,53,i.xAxisType$))("xScaleType",G(13,55,i.xScaleType$))("useDarkMode",G(14,57,i.useDarkMode$))("linkedTimeSelection",G(15,59,i.linkedTimeSelection$))("stepOrLinkedTimeSelection",G(16,61,i.stepOrLinkedTimeSelection$))("forceSvg",G(17,63,i.forceSvg$))("columnCustomizationEnabled",G(18,65,i.columnCustomizationEnabled$))("columnContextMenusEnabled",G(19,67,i.columnContextMenusEnabled$))("minMaxStep",G(20,69,i.minMaxSteps$))("userViewBox",G(21,71,i.userViewBox$))("columnHeaders",G(22,73,i.columnHeaders$))("rangeEnabled",G(23,75,i.rangeEnabled$))("columnFilters",G(24,77,i.columnFilters$))("runToHparamMap",G(25,79,i.runToHparamMap$))("selectableColumns",G(26,81,i.selectableColumns$))("numColumnsLoaded",G(27,83,i.numColumnsLoaded$))("numColumnsToLoad",G(28,85,i.numColumnsToLoad$))},dependencies:[Qg,dne,ct],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0}),n})();function aBe(n,t,e){let i=[],{left:r,right:o}=t,a=(o-r)/e,s=0,l=0;for(let c=0;c<e;c++){let d=r+c*a,u=d+a,p=c===e-1,h=l;for(l=0;s<n.length;){let m=n[s],_=sBe(m,d,u,!p);if(h+=_.curr,l+=_.next,m.x+m.dx>u)break;s++}i.push({x:d,dx:a,y:h})}return i}function sBe(n,t,e,i){let r=n.x,o=n.x+n.dx;if(r>e||o<t)return{curr:0,next:0};if(0===n.dx)return i&&o>=e?{curr:0,next:n.y}:{curr:n.y,next:0};let a=Math.min(o,e)-Math.max(r,t);return{curr:n.y*a/n.dx,next:0}}var lBe=1e4,cBe=.001,dBe=Yr(".2~s"),uBe=Yr(".4~r"),pBe=Yr(".2~e");function hne(n){if(0===n)return"0";let t=Math.abs(n);return t>=lBe?dBe(n):t<cBe?pBe(n):uBe(n)}var hBe=["main"],mBe=["xAxis"],fBe=["yAxis"],gBe=["content"],_Be=["histograms"];function bBe(n,t){if(1&n&&(qn(),f(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Bt("transform",e.getCssTranslatePx(e.tooltipData.xAxis.position,9)),v(2),kt(e.tooltipData.xAxis.label)}}function vBe(n,t){if(1&n&&(qn(),f(0,"g")(1,"text"),T(2),g()()),2&n){let e=w();Bt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),v(1),Be("y",e.tooltipData.yAxis.position),v(1),Ve(" ",e.tooltipData.yAxis.label," ")}}function yBe(n,t){if(1&n){let e=Te();qn(),ua(),Gt(0),f(1,"histogram-card-fob-controller",16),A("onTimeSelectionChanged",function(r){return ne(e),ie(w().onLinkedTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return ne(e),ie(w().onLinkedTimeToggled.emit())}),g(),Wt()}if(2&n){let e=w();v(1),b("timeSelection",e.timeSelection)("steps",e.getSteps())("temporalScale",e.scales.temporalScale)}}function xBe(n,t){if(1&n&&(qn(),f(0,"g"),k(1,"line",17),g()),2&n){let e=t.$implicit;Bt("transform",w().getCssTranslatePx(0,e))}}function CBe(n,t){1&n&&(qn(),k(0,"line",21))}function MBe(n,t){if(1&n&&(qn(),k(0,"circle",22)),2&n){let e=w().$implicit,i=w();Bt("transform",i.getCssTranslatePx(i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).x,i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).y))}}function wBe(n,t){if(1&n){let e=Te();qn(),f(0,"g",18),A("mouseenter",function(r){let a=ne(e).$implicit;return ie(w().updateColorOnHover(r,a,!0))})("mouseleave",function(r){let a=ne(e).$implicit;return ie(w().updateColorOnHover(r,a,!1))})("click",function(){let o=ne(e).$implicit;return ie(w().onLinkedTimeRangeChanged(o))}),S(1,CBe,1,0,"line",19),k(2,"path"),S(3,MBe,1,2,"circle",20),g()}if(2&n){let e=t.$implicit,i=w();Bt("transform",i.getGroupTransform(e))("color",i.getHistogramFill(e)),nt("histogram",!0)("no-color",!i.isDatumInTimeSelectionRange(e)),v(1),b("ngIf",i.mode===i.HistogramMode.OFFSET),v(1),Be("d",i.getHistogramPath(e)),v(1),b("ngIf",i.tooltipData)}}function SBe(n,t){if(1&n&&(qn(),k(0,"circle",22)),2&n){let e=w(2);Be("cx",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).x)("cy",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).y)}}function EBe(n,t){if(1&n&&(qn(),f(0,"g",4)(1,"g"),k(2,"path"),S(3,SBe,1,2,"circle",23),g(),f(4,"g",24)(5,"text",25),T(6),g()()()),2&n){let e=w();v(1),Bt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),v(1),Be("d",e.getHistogramPath(e.tooltipData.closestDatum)),v(1),b("ngIf",e.tooltipData.closestBin),v(1),Bt("transform",e.getCssTranslatePx(e.tooltipData.value.position.x,e.tooltipData.value.position.y)),v(2),kt(e.tooltipData.value.label)}}var gA=(()=>{class n{constructor(e){this.changeDetector=e,this.mode=Sr.OFFSET,this.timeProperty=no.STEP,this.timeSelection=null,this.onLinkedTimeSelectionChanged=new F,this.onLinkedTimeToggled=new F,this.HistogramMode=Sr,this.TimeProperty=no,this.tooltipData=null,this.ngUnsubscribe=new Ee,this.layout={histogramHeight:0,contentClientRect:{height:0,width:0}},this.scales=null,this.formatters={binNumber:hne,count:Yr(".3n"),wallTime:m0("%m/%d %X"),step:Yr(".0f"),relative:i=>Yr(".1r")(i/36e5)+"h"},this.domVisible=!1}ngOnChanges(){this.updateChartIfVisible()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngAfterViewInit(){Ei(this.main.nativeElement,"mousemove",{passive:!0}).pipe(it(this.ngUnsubscribe)).subscribe(e=>this.onMouseMove(e))}getCssTranslatePx(e,i){return`translate(${e}px, ${i}px)`}getClosestBinFromBinCoordinate(e,i){if(!e.bins.length)return{x:0,dx:0,y:0};let r=e.bins[0],o=e.bins.slice(-1)[0];return i<r.x?r:i>=o.x+o.dx?o:e.bins.find(s=>s.x<=i&&i<s.x+s.dx)}getUiCoordFromBinForContent(e){return this.scales?{x:this.scales.binScale($x(e)),y:this.scales.countScale(e.y)}:{x:0,y:0}}getHistogramPath(e){if(!this.scales||!e.bins.length)return"";let i=this.scales.binScale,r=this.scales.countScale,o=e.bins[0],a=e.bins.slice(-1)[0],s=[`M${i($x(o))},${r(0)}`];for(let l of e.bins)s.push(`L${i($x(l))},${r(l.y)}`);return s.push(`L${i($x(a))},${r(0)}`),s.join("")}trackByWallTime(e){return e.wallTime}getGroupTransform(e){return this.scales&&this.mode!==Sr.OVERLAY?this.getCssTranslatePx(0,this.scales.temporalScale(this.getTimeValue(e))):""}getSteps(){return this.data.map(e=>e.step)}isTimeSelectionEnabled(e){return Boolean(this.mode===Sr.OFFSET&&this.timeProperty===no.STEP&&this.scales&&e)}isDatumInTimeSelectionRange(e){return!this.isTimeSelectionEnabled(this.timeSelection)||(null===this.timeSelection.end?this.timeSelection.start.step===e.step:this.timeSelection.start.step<=e.step&&this.timeSelection.end.step>=e.step)}getHistogramFill(e){return this.scales?this.scales.d3ColorScale(this.getTimeValue(e)):""}updateColorOnHover(e,i,r){!this.isTimeSelectionEnabled(this.timeSelection)||this.isDatumInTimeSelectionRange(i)||(r?e.target.classList.remove("no-color"):e.target.classList.add("no-color"))}getGridTickYLocs(){if(!this.scales||this.mode===Sr.OFFSET)return[];let e=this.scales.countScale;return e.ticks().map(i=>e(i))}onResize(){this.updateClientRects(),this.updateChartIfVisible()}onVisibilityChange({visible:e}){this.domVisible=e,e&&(this.updateClientRects(),this.updateChartIfVisible())}onLinkedTimeRangeChanged(e){if(!this.isTimeSelectionEnabled(this.timeSelection))return;let i=this.timeSelection.start.step,r=this.timeSelection.end?.step,o=e.step<i?e.step:i,a=r;a=void 0===a?e.step>i?e.step:i:e.step>a?e.step:a,(o!==i||a!==r)&&o!==a&&this.onLinkedTimeSelectionChanged.emit({timeSelection:{start:{step:o},end:{step:a}},affordance:Qa.HISTOGRAM_CLICK_TO_RANGE})}getTimeValue(e){switch(this.timeProperty){case no.WALL_TIME:return e.wallTime;case no.STEP:return e.step;case no.RELATIVE:return e.wallTime-this.data[0].wallTime}}updateClientRects(){this.content&&(this.layout.contentClientRect=this.content.nativeElement.getBoundingClientRect(),this.layout.histogramHeight=this.layout.contentClientRect.height/2.5)}updateChartIfVisible(){!this.domVisible||(this.scales=this.computeScales(this.data),this.renderXAxis(),this.renderYAxis(),this.changeDetector.detectChanges())}computeScales(e){let{width:i,height:r}=this.layout.contentClientRect,{min:o,max:a}=mne(e,y=>function(n,t){return n.reduce((e,i)=>Math.min(e,i.x),1/0)}(y.bins),y=>MV(y.bins,({x:x,dx:R})=>x+R)),s=MV(e,y=>MV(y.bins,({y:x})=>x)),l=zl().domain([o,a]).nice(),c=this.mode!==Sr.OVERLAY&&this.timeProperty==no.WALL_TIME?sm():zl(),d=e.map(y=>this.getTimeValue(y)),{min:u,max:p}=mne(d,y=>y),h=[u,p];c.domain(h);let m=zl();m.domain([0,s]);let _=Xh(this.color||"#000"),M=zl();return M.domain(h),l.range([0,i]),M.range([_.brighter(),_.darker()]),M.interpolate(uL),this.mode===Sr.OVERLAY?(c.range([r,r]),m.range([r,0])):(c.range([r-(this.mode===Sr.OFFSET?r-this.layout.histogramHeight:0),r]),m.range([0,-this.layout.histogramHeight])),{binScale:l,d3ColorScale:M,countScale:m,temporalScale:c}}renderXAxis(){if(!this.scales)return;let{width:e}=this.layout.contentClientRect,i=function(n){return aZ(HN,n)}(this.scales.binScale).ticks(Math.max(2,e/20));i.tickFormat(this.formatters.binNumber),i(aD(this.xAxis.nativeElement))}getYAxisFormatter(){if(this.mode===Sr.OVERLAY)return this.formatters.count;switch(this.timeProperty){case no.WALL_TIME:return this.formatters.wallTime;case no.STEP:return this.formatters.step;case no.RELATIVE:return this.formatters.relative;default:throw RangeError(`Y axis formatter for ${this.timeProperty} must be implemented`)}}getMaxTicks(e){let{height:i}=this.layout.contentClientRect,r=i/15;if(this.timeProperty===no.STEP){let[o,a]=e.domain(),s=Math.max(a-o+1,1);return Math.min(s,r)}return r}renderYAxis(){if(!this.scales)return;let e=this.mode===Sr.OVERLAY?this.scales.countScale:this.scales.temporalScale,i=this.getMaxTicks(e),r=function(n){return aZ(eD,n)}(e).ticks(Math.max(2,i));r.tickFormat(this.getYAxisFormatter()),r(aD(this.yAxis.nativeElement))}findClosestDatumIndex(e){let i=e.target,r=i;for(;i&&i!==this.histograms.nativeElement;)r=i,i=i.parentElement;return i?Array.from(i.children).indexOf(r):-1}onMouseMoveForTestOnly(e){return this.onMouseMove(e)}onMouseMove(e){if(!this.scales)return;let i=e.offsetX,r=e.offsetY,o=this.findClosestDatumIndex(e);if(o<0)return;let a=this.scales.binScale.invert(i),s=this.data[o],l=this.getClosestBinFromBinCoordinate(s,a);this.tooltipData={value:{position:{x:i,y:r},label:this.mode===Sr.OFFSET?this.formatters.count(l.y):`Step: ${this.formatters.step(s.step)}`},xAxis:{position:this.getUiCoordFromBinForContent(l).x,label:this.formatters.binNumber($x(l))},yAxis:{position:this.scales.countScale(this.mode===Sr.OFFSET?0:l.y),label:this.mode===Sr.OFFSET?this.getYAxisFormatter()(this.getTimeValue(s)):this.formatters.binNumber(l.y)},xPositionInBinCoord:a,closestDatum:s,closestBin:l},this.changeDetector.detectChanges()}}return n.\u0275fac=function(e){return new(e||n)(C(Qt))},n.\u0275cmp=P({type:n,selectors:[["tb-histogram"]],viewQuery:function(e,i){if(1&e&&(Ue(hBe,5),Ue(mBe,5),Ue(fBe,5),Ue(gBe,5),Ue(_Be,5)),2&e){let r;be(r=ve())&&(i.main=r.first),be(r=ve())&&(i.xAxis=r.first),be(r=ve())&&(i.yAxis=r.first),be(r=ve())&&(i.content=r.first),be(r=ve())&&(i.histograms=r.first)}},inputs:{mode:"mode",timeProperty:"timeProperty",color:"color",data:"data",timeSelection:"timeSelection"},outputs:{onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},features:[qt],decls:22,vars:15,consts:[["detectResize","","observeIntersection","",3,"onResize","onVisibilityChange"],["main",""],[1,"axis","x-axis"],["xAxis",""],[1,"tooltip"],[3,"transform",4,"ngIf"],[1,"axis","y-axis"],["yAxis",""],[4,"ngIf"],[1,"content"],["content",""],[1,"grid"],[3,"transform",4,"ngFor","ngForOf"],["histograms",""],[3,"transform","histogram","no-color","color","mouseenter","mouseleave","click",4,"ngFor","ngForOf","ngForTrackBy"],["class","tooltip",4,"ngIf"],[1,"histogram-card-fob",3,"timeSelection","steps","temporalScale","onTimeSelectionChanged","onTimeSelectionToggled"],["x2","100%",1,"tick"],[3,"mouseenter","mouseleave","click"],["class","baseline","x2","100%",4,"ngIf"],["r","2",3,"transform",4,"ngIf"],["x2","100%",1,"baseline"],["r","2"],["r","2",4,"ngIf"],[1,"value-label"],["x","3","y","-3"]],template:function(e,i){1&e&&(f(0,"div",0,1),A("onResize",function(){return i.onResize()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),qn(),f(2,"svg",2),k(3,"g",null,3),f(5,"g",4),S(6,bBe,3,3,"g",5),g()(),ua(),f(7,"div",6),qn(),f(8,"svg"),k(9,"g",null,7),f(11,"g",4),S(12,vBe,3,4,"g",5),g()(),S(13,yBe,2,3,"ng-container",8),g(),f(14,"svg",9,10)(16,"g",11),S(17,xBe,2,2,"g",12),g(),f(18,"g",null,13),S(20,wBe,4,11,"g",14),g(),S(21,EBe,7,7,"g",15),g()()),2&e&&(Xo("main "+i.mode+" "+i.timeProperty),v(6),b("ngIf",i.tooltipData),v(5),Bt("transform",i.getCssTranslatePx(9,0)),v(1),b("ngIf",i.tooltipData),v(1),b("ngIf",i.isTimeSelectionEnabled(i.timeSelection)),v(4),b("ngForOf",i.getGridTickYLocs()),v(1),nt("histograms",!0)("linked-time-single-step",i.timeSelection&&!i.timeSelection.end),v(2),b("ngForOf",i.data)("ngForTrackBy",i.trackByWallTime),v(1),b("ngIf",i.tooltipData))},styles:['[_nghost-%COMP%], .main[_ngcontent-%COMP%]{display:inline-block;height:100%;width:100%}[_nghost-%COMP%]{box-sizing:border-box;padding:10px}.main[_ngcontent-%COMP%]{display:grid;grid-template-areas:"content y-axis" "x-axis .";grid-template-columns:1fr 50px;grid-template-rows:1fr 30px}.main.wall_time[_ngcontent-%COMP%]{grid-template-columns:1fr 75px}.tooltip[_ngcontent-%COMP%], .baseline[_ngcontent-%COMP%]{color:#000}body.dark-mode[_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%]{color:#fff}body.dark-mode[_nghost-%COMP%]   .baseline[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .baseline[_ngcontent-%COMP%]{color:#fff}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{font-weight:bold;font-size:10px}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .linked-time-fob[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{fill:currentColor}.linked-time-fob[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%]{dominant-baseline:ideographic;text-anchor:start}.axis[_ngcontent-%COMP%]    {color:#616161;position:relative;overflow:hidden}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    , body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    {color:rgba(255,255,255,.7)}.axis[_ngcontent-%COMP%]     .domain, .axis[_ngcontent-%COMP%]     .tick text{display:none}.axis[_ngcontent-%COMP%]     .tick:nth-child(2n+1) text{display:initial}svg[_ngcontent-%COMP%]{height:100%;width:100%;pointer-events:visiblePainted}svg[_ngcontent-%COMP%]   line[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{pointer-events:none}svg[_ngcontent-%COMP%]   g[_ngcontent-%COMP%]{will-change:transform}.x-axis[_ngcontent-%COMP%]{grid-area:x-axis}.x-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:hanging;text-anchor:middle}.y-axis[_ngcontent-%COMP%]{grid-area:y-axis;overflow:clip visible}.y-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:middle;text-anchor:start}.histogram-card-fob[_ngcontent-%COMP%]{left:9px;position:absolute}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]     .tick line{stroke:#ddd}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke:#555}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line, body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line{stroke:#555}.content[_ngcontent-%COMP%]{grid-area:content;overflow:visible;z-index:1}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke-width:1px;stroke-dasharray:2}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill:currentColor;stroke-opacity:.6;stroke-width:1px}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{filter:drop-shadow(0 0 1px rgba(0, 0, 0, 0.6));stroke:#fff;will-change:transform}.content[_ngcontent-%COMP%]   .baseline[_ngcontent-%COMP%]{stroke-opacity:.1;stroke-width:1px;stroke:currentColor;width:100%}.content[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:1;stroke:currentColor;fill:rgba(0,0,0,0)}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(221,221,221,.4) !important}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:.2}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(51,51,51,.4) !important}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#fff}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#555}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#000}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#fff}.overlay[_ngcontent-%COMP%]   .x-axis[_ngcontent-%COMP%]     .tick line{display:none}.overlay[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill-opacity:0;stroke:currentColor}.tooltip[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{display:none}.main[_ngcontent-%COMP%]:hover   .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]:hover   .tooltip[_ngcontent-%COMP%]{display:block}'],changeDetection:0}),n})();function MV(n,t){return n.reduce((e,i)=>Math.max(e,t(i)),-1/0)}function mne(n,t,e){e||(e=t);let i=1/0,r=-1/0;for(let o of n)i=Math.min(i,t(o)),r=Math.max(r,e(o));return{min:i,max:r}}function $x(n){return n.x+.5*n.dx}function IBe(n,t){1&n&&(f(0,"span",14),k(1,"mat-spinner",15),g())}function ABe(n,t){if(1&n){let e=Te();f(0,"tb-histogram",16),A("onLinkedTimeSelectionChanged",function(r){return ne(e),ie(w().onLinkedTimeSelectionChanged.emit(r))})("onLinkedTimeToggled",function(){return ne(e),ie(w().onLinkedTimeToggled.emit())}),g()}if(2&n){let e=w();b("data",e.data)("mode",e.mode)("timeProperty",e.timeProperty(e.xAxisType))("color",e.runColorScale(e.runId))("timeSelection",e.convertToTimeSelection(e.linkedTimeSelection))}}function RBe(n,t){1&n&&(f(0,"div",18),T(1," Data failed to load. "),g())}function PBe(n,t){if(1&n&&S(0,RBe,2,0,"div",17),2&n){let e=w();b("ngIf",e.loadState===e.DataLoadState.FAILED)}}var kBe=function(n){return{backgroundColor:n}},fne=(()=>{class n{constructor(){this.DataLoadState=Re,this.onFullSizeToggle=new F,this.onPinClicked=new F,this.onLinkedTimeSelectionChanged=new F,this.onLinkedTimeToggled=new F}timeProperty(e){switch(e){case Pi.STEP:return no.STEP;case Pi.WALL_TIME:return no.WALL_TIME;case Pi.RELATIVE:return no.RELATIVE;default:throw new Error("Invalid xAxisType for histogram time property.")}}convertToTimeSelection(e){return null===e?null:{start:{step:e.startStep},end:e.endStep?{step:e.endStep}:null}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["histogram-card-component"]],inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",data:"data",mode:"mode",xAxisType:"xAxisType",runColorScale:"runColorScale",showFullWidth:"showFullWidth",isPinned:"isPinned",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},decls:16,vars:14,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on a histogram card that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,[[1,"heading"],[1,"tag"],[3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle full size mode",3,"click"],["class","spinner",4,"ngIf"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled",4,"ngIf","ngIfElse"],["noData",""],[1,"spinner"],["diameter","18"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1),k(2,"tb-truncated-path",2)(3,"vis-linked-time-selection-warning",3),g(),f(4,"div",4),k(5,"span",5)(6,"card-run-name",6),g(),f(7,"span",7)(8,"button",8),A("click",function(){return i.onPinClicked.emit(!i.isPinned)}),k(9,"mat-icon",9),g(),f(10,"button",10),A("click",function(){return i.onFullSizeToggle.emit()}),k(11,"mat-icon",9),g()(),S(12,IBe,2,0,"span",11),g(),S(13,ABe,1,5,"tb-histogram",12),S(14,PBe,1,1,"ng-template",null,13,jt)),2&e){let r=st(15);v(2),b("title",i.tag)("value",i.title),v(1),b("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),v(2),b("ngStyle",Un(12,kBe,i.runColorScale(i.runId))),v(1),b("runId",i.runId),v(2),Be("title",i.isPinned?"Unpin card":"Pin card"),v(1),b("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),v(2),b("svgIcon",i.showFullWidth?"fullscreen_exit_24px":"fullscreen_24px"),v(1),b("ngIf",i.loadState===i.DataLoadState.LOADING),v(1),b("ngIf",i.data&&i.data.length)("ngIfElse",r)}},dependencies:[Ne,Mf,gA,Er,bn,Nc,ZT,Jg,$g],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run spinner";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px;grid-area:tag;overflow:hidden}.tag[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{line-height:0}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap;font-size:13px}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.spinner[_ngcontent-%COMP%]{display:flex;grid-area:spinner;height:100%;justify-content:center;position:relative}mat-spinner[_ngcontent-%COMP%]{top:0;right:0;position:absolute}tb-histogram[_ngcontent-%COMP%]{flex-grow:1}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0}),n})(),gne=(()=>{class n{constructor(e){this.store=e,this.pinStateChanged=new F,this.mode$=this.store.select(a1),this.xAxisType$=this.store.select(Ol),this.showFullWidth$=this.store.select(Js).pipe(q(i=>i[this.cardId]?.fullWidth))}isHistogramCardMetadata(e){let{plugin:i}=e;return i===An.HISTOGRAMS}onFullSizeToggle(){this.store.dispatch(zg({cardId:this.cardId}))}ngOnInit(){let i=this.store.select(Ks,this.cardId).pipe(Oe(o=>!!o&&this.isHistogramCardMetadata(o)),q(o=>o)),r=In([i,this.store.select(wu,this.cardId)]);this.data$=r.pipe(q(([o,a])=>{let s=o.runId;return a&&a.hasOwnProperty(s)?function(n,t=30){if(!n.length||t<1)return[];let e=function(n){let t=null,e=null;for(let{bins:i}of n){if(!i.length)continue;let r=i[i.length-1],o=i[0].x,a=r.x+r.dx;(null===t||o<t)&&(t=o),(null===e||a>e)&&(e=a)}return null===t||null===e?null:{left:t,right:e}}(n);return e&&e.left===e.right&&(e.right=1.1*e.right+1,e.left=e.left/1.1-1),n.map(i=>({step:i.step,wallTime:i.wallTime,bins:e?aBe(i.bins,e,t):[]}))}(a[s].map(d=>{let{wallTime:u,step:p}=d;return{wallTime:u,step:p,bins:d.bins.map(m=>({x:m.min,dx:m.max-m.min,y:m.count}))}})):[]})),this.steps$=this.data$.pipe(q(o=>o.map(a=>a.step))),this.linkedTimeSelection$=In([this.store.select(Du),this.steps$,this.store.select(Tu)]).pipe(q(([o,a,s])=>{if(!o)return null;let l=1/0,c=-1/0;for(let p of a)l=Math.min(p,l),c=Math.max(p,c);return function(n,t){if(null!==n.endStep)return n;let e=function(n,t){let e=1/0,i=null;for(let r of t){let o=Math.abs(n-r);o<e&&(e=o,i=r)}return i}(n.startStep,t);return null!==e?{...n,startStep:e}:n}(Yf(OF(o,s),l,c),a)})),this.isClosestStepHighlighted$=In([this.store.select(Du),this.linkedTimeSelection$]).pipe(q(([o,a])=>o&&a&&!a.clipped&&null===o.end&&o.start.step!==a.startStep)),this.loadState$=this.store.select(gd,this.cardId),this.tag$=i.pipe(q(o=>o.tag)),this.title$=this.tag$.pipe(q(o=>Zg(o,this.groupName))),this.runId$=i.pipe(q(o=>o.runId)),this.isPinned$=this.store.select(Su,this.cardId)}onLinkedTimeSelectionChanged(e){this.store.dispatch(Hh(e))}onLinkedTimeToggled(){this.store.dispatch(Td({affordance:Za.FOB_DESELECT}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["histogram-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{pinStateChanged:"pinStateChanged"},decls:12,vars:34,consts:[[3,"loadState","title","tag","runId","data","mode","xAxisType","runColorScale","showFullWidth","isPinned","isClosestStepHighlighted","linkedTimeSelection","onFullSizeToggle","onPinClicked","onLinkedTimeSelectionChanged","onLinkedTimeToggled"]],template:function(e,i){1&e&&(f(0,"histogram-card-component",0),A("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onLinkedTimeSelectionChanged",function(o){return i.onLinkedTimeSelectionChanged(o)})("onLinkedTimeToggled",function(){return i.onLinkedTimeToggled()}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),U(10,"async"),U(11,"async"),g()),2&e&&b("loadState",G(1,12,i.loadState$))("title",G(2,14,i.title$))("tag",G(3,16,i.tag$))("runId",G(4,18,i.runId$))("data",G(5,20,i.data$))("mode",G(6,22,i.mode$))("xAxisType",G(7,24,i.xAxisType$))("runColorScale",i.runColorScale)("showFullWidth",G(8,26,i.showFullWidth$))("isPinned",G(9,28,i.isPinned$))("isClosestStepHighlighted",G(10,30,i.isClosestStepHighlighted$))("linkedTimeSelection",G(11,32,i.linkedTimeSelection$))},dependencies:[fne,ct],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})();function NBe(n,t){if(1&n){let e=Te();f(0,"image-card",6),A("fullWidthChanged",function(r){return ne(e),ie(w(2).onFullWidthChanged(r))})("pinStateChanged",function(){return ne(e),ie(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);b("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function LBe(n,t){if(1&n){let e=Te();f(0,"scalar-card",7),A("pinStateChanged",function(){return ne(e),ie(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);b("cardId",e.cardId)("groupName",e.groupName)}}function BBe(n,t){if(1&n){let e=Te();f(0,"histogram-card",8),A("pinStateChanged",function(){return ne(e),ie(w(2).onPinStateChanged())}),g()}if(2&n){let e=w(2);b("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function VBe(n,t){if(1&n&&(f(0,"div"),T(1),g()),2&n){let e=w(2);v(1),Ve("Placeholder error for: ",e.cardId,"")}}function HBe(n,t){if(1&n&&(Gt(0,1),S(1,NBe,1,3,"image-card",2),S(2,LBe,1,2,"scalar-card",3),S(3,BBe,1,3,"histogram-card",4),S(4,VBe,2,1,"div",5),Wt()),2&n){let e=w();b("ngSwitch",e.pluginType),v(1),b("ngSwitchCase",e.PluginType.IMAGES),v(1),b("ngSwitchCase",e.PluginType.SCALARS),v(1),b("ngSwitchCase",e.PluginType.HISTOGRAMS)}}var _ne=(()=>{class n{constructor(){this.PluginType=An,this.fullWidthChanged=new F,this.fullHeightChanged=new F,this.pinStateChanged=new F}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.pinStateChanged.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["card-view-component"]],inputs:{isEverVisible:"isEverVisible",cardId:"cardId",groupName:"groupName",pluginType:"pluginType",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:1,vars:1,consts:[[3,"ngSwitch",4,"ngIf"],[3,"ngSwitch"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","runColorScale","pinStateChanged",4,"ngSwitchCase"],[4,"ngSwitchDefault"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged"],[3,"cardId","groupName","pinStateChanged"],[3,"cardId","groupName","runColorScale","pinStateChanged"]],template:function(e,i){1&e&&S(0,HBe,5,4,"ng-container",0),2&e&&b("ngIf",i.isEverVisible)},dependencies:[Ne,mr,kr,du,QQ,une,gne],encapsulation:2,changeDetection:0}),n})(),bne=(()=>{class n{constructor(e){this.store=e,this.isEverVisible=!1,this.fullWidthChanged=new F,this.fullHeightChanged=new F,this.runColorScale$=this.store.select(Pu).pipe(ic(350,void 0,{leading:!0,trailing:!0}),q(i=>r=>i.hasOwnProperty(r)?i[r]:"#fff"))}onVisibilityChange({visible:e}){this.isEverVisible=this.isEverVisible||e}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.store.select(Su,this.cardId).pipe(Lt(1),It(this.store.select(kW))).subscribe(([e,i])=>{this.store.dispatch(np({cardId:this.cardId,canCreateNewPins:i,wasPinned:e}))})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["card-view"]],inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged"},decls:2,vars:7,consts:[["observeIntersection","","intersectionObserverMargin","200px 200px 200px 200px",3,"isEverVisible","cardId","groupName","pluginType","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged","onVisibilityChange"]],template:function(e,i){1&e&&(f(0,"card-view-component",0),A("fullWidthChanged",function(o){return i.onFullWidthChanged(o)})("fullHeightChanged",function(o){return i.onFullHeightChanged(o)})("pinStateChanged",function(){return i.onPinStateChanged()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),U(1,"async"),g()),2&e&&b("isEverVisible",i.isEverVisible)("cardId",i.cardId)("groupName",i.groupName)("pluginType",i.pluginType)("runColorScale",G(1,5,i.runColorScale$))},dependencies:[Qg,_ne,ct],styles:["[_nghost-%COMP%]{background-color:#fff}body.dark-mode   [_nghost-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function GBe(n,t){1&n&&hi(0)}var WBe=function(n,t){return{"full-width":n,"full-height":t}};function qBe(n,t){if(1&n){let e=Te();f(0,"div",5)(1,"card-view",6),A("fullWidthChanged",function(r){let a=ne(e).$implicit;return ie(w(2).onFullWidthChanged(a.cardId,r))})("fullHeightChanged",function(r){let a=ne(e).$implicit;return ie(w(2).onFullHeightChanged(a.cardId,r))}),g()()}if(2&n){let e=t.$implicit,i=w(2);b("ngClass",So(6,WBe,i.cardsAtFullWidth.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].fullWidth),i.cardsAtFullHeight.has(e.cardId)||(null==i.cardStateMap[e.cardId]?null:i.cardStateMap[e.cardId].tableExpanded))),v(1),b("cardId",e.cardId)("groupName",i.groupName)("pluginType",e.plugin)("cardObserver",i.cardObserver)("cardLazyLoader",e.cardId)}}function XBe(n,t){1&n&&hi(0)}var YBe=function(){return{isBottomControl:!1}},QBe=function(){return{isBottomControl:!0}};function ZBe(n,t){if(1&n&&(f(0,"div"),S(1,GBe,1,0,"ng-container",2),f(2,"div",3),S(3,qBe,2,9,"div",4),g(),S(4,XBe,1,0,"ng-container",2),g()),2&n){let e=w(),i=st(2);v(1),b("ngTemplateOutlet",i)("ngTemplateOutletContext",mc(8,YBe)),v(1),Bt("grid-template-columns",e.gridTemplateColumn),v(1),b("ngForOf",e.cardIdsWithMetadata)("ngForTrackBy",e.trackByCards),v(1),b("ngTemplateOutlet",i)("ngTemplateOutletContext",mc(9,QBe))}}function KBe(n,t){if(1&n){let e=Te();f(0,"button",12),A("click",function(r){ne(e);let o=w(3);return ie(o.handlePageChange(o.pageIndex-1,r.target))}),T(1," Previous "),g()}2&n&&b("disabled",0===w(3).pageIndex)}function JBe(n,t){if(1&n){let e=Te();f(0,"span",15)(1,"input",16),A("input",function(r){return ne(e),ie(w(4).onPaginationInputChange(r))})("change",function(r){return ne(e),ie(w(4).onPaginationInputChange(r))}),g(),T(2),g()}if(2&n){let e=w(4);v(1),b("value",e.pageIndex+1)("max",e.numPages),v(1),Ve(" of ",e.numPages,"")}}function $Be(n,t){if(1&n){let e=Te();f(0,"span"),S(1,JBe,3,3,"span",13),f(2,"button",14),A("click",function(r){ne(e);let o=w(3);return ie(o.handlePageChange(o.pageIndex+1,r.target))}),T(3," Next "),g()()}if(2&n){let e=w(2).isBottomControl,i=w();v(1),b("ngIf",i.showPaginationInput(e)),v(1),b("disabled",i.pageIndex+1>=i.numPages)}}function eVe(n,t){if(1&n&&(f(0,"div",8)(1,"span",9),S(2,KBe,2,1,"button",10),g(),f(3,"span",11),S(4,$Be,4,2,"span",0),g()()),2&n){let e=w(2);v(2),b("ngIf",e.showPaginationControls),v(2),b("ngIf",e.showPaginationControls)}}function tVe(n,t){1&n&&S(0,eVe,5,2,"div",7),2&n&&b("ngIf",w().showPaginationControls)}var vne=(()=>{class n{constructor(e){this.cdkScrollable=e,this.PluginType=An,this.gridTemplateColumn="",this.cardsAtFullWidth=new Set,this.cardsAtFullHeight=new Set,this.pageIndexChanged=new F}ngOnInit(){this.isCardWidthValid(this.cardMinWidth)&&(this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`)}ngOnChanges(e){if(e.cardMinWidth){let i=e.cardMinWidth.currentValue;this.isCardWidthValid(i)?(this.cardMinWidth=i,this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`):this.gridTemplateColumn=""}}isCardWidthValid(e){return e&&e>=335&&e<=735}showPaginationInput(e){return e}handlePageChange(e,i){let r=i.getBoundingClientRect().top;setTimeout(()=>{this.scrollToKeepTargetPosition(i,r)},0),this.pageIndexChanged.emit(e)}scrollToKeepTargetPosition(e,i){let r=this.cdkScrollable?.getElementRef().nativeElement;r&&r.scrollTo(0,e.getBoundingClientRect().top-i+r.scrollTop)}trackByCards(e,i){return i.cardId}onPaginationInputChange(e){let i=e.target;if("input"===e.type&&""===i.value)return;let r=Number(i.value)-1,o=Math.min(Math.max(0,r),this.numPages-1);i.value!==String(o+1)&&(i.value=String(o+1)),this.handlePageChange(o,i)}onFullWidthChanged(e,i){i?this.cardsAtFullWidth.add(e):this.cardsAtFullWidth.delete(e)}onFullHeightChanged(e,i){i?this.cardsAtFullHeight.add(e):this.cardsAtFullHeight.delete(e)}}return n.\u0275fac=function(e){return new(e||n)(C(xd,8))},n.\u0275cmp=P({type:n,selectors:[["metrics-card-grid-component"]],inputs:{isGroupExpanded:"isGroupExpanded",pageIndex:"pageIndex",numPages:"numPages",cardIdsWithMetadata:"cardIdsWithMetadata",cardMinWidth:"cardMinWidth",cardObserver:"cardObserver",showPaginationControls:"showPaginationControls",cardStateMap:"cardStateMap"},outputs:{pageIndexChanged:"pageIndexChanged"},features:[qt],decls:3,vars:1,consts:function(){let t,e;return t=$localize`:A button that sets a group to the previous page.␟575e782fd27f2ee70a034a775efe9ad162472250␟3629960544875360046:Previous page`,e=$localize`:A button that sets a group to the next page.␟ce3cefb1cd0099aa5003dda16ec9eb21fd8ba789␟3337301694210287595:Next page`,[[4,"ngIf"],["groupControls",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"card-grid"],["class","card-space",3,"ngClass",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-space",3,"ngClass"],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader","fullWidthChanged","fullHeightChanged"],["class","group-controls",4,"ngIf"],[1,"group-controls"],[1,"prev-container"],["class","prev pagination-button","mat-button","","aria-label",t,3,"disabled","click",4,"ngIf"],[1,"input-and-next-container"],["mat-button","","aria-label",t,1,"prev","pagination-button",3,"disabled","click"],["class","pagination-input",4,"ngIf"],["mat-button","","aria-label",e,1,"next","pagination-button",3,"disabled","click"],[1,"pagination-input"],["type","number","min","1",3,"value","max","input","change"]]},template:function(e,i){1&e&&(S(0,ZBe,5,10,"div",0),S(1,tVe,1,1,"ng-template",null,1,jt)),2&e&&b("ngIf",i.isGroupExpanded)},dependencies:[bQ,bne,wn,nn,Ne,eo,ki],styles:["[_nghost-%COMP%]{contain:content}.card-grid[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill, minmax(335px, 1fr));gap:16px;padding:16px}.card-space.full-width[_ngcontent-%COMP%]{grid-column-start:1;grid-column-end:-1}.card-space.full-height[_ngcontent-%COMP%]{min-height:480px}.card-space.full-height[_ngcontent-%COMP%]   card-view[_ngcontent-%COMP%]{height:100%}card-view[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:4px;box-sizing:border-box;contain:layout paint;display:block;min-height:320px}body.dark-mode[_nghost-%COMP%]   card-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   card-view[_ngcontent-%COMP%]{border:1px solid #555}.group-controls[_ngcontent-%COMP%]{color:#616161;display:grid;align-items:center;grid-template-columns:1fr 1fr;gap:16px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-controls[_ngcontent-%COMP%]:first-of-type{padding-top:16px}.group-controls[_ngcontent-%COMP%]:last-of-type{padding-bottom:16px}.prev-container[_ngcontent-%COMP%]{justify-self:flex-start}.input-and-next-container[_ngcontent-%COMP%]{justify-self:flex-end}.pagination-input[_ngcontent-%COMP%]{margin-right:16px}.pagination-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background:rgba(0,0,0,0);border:1px solid currentColor;color:inherit;font:inherit}.pagination-button[_ngcontent-%COMP%]{background-color:#fff}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0)}"],changeDetection:0}),n})(),__=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.groupName$=new xr(null),this.pageIndex$=new xr(0),this.items$=new xr([]),this.ngUnsubscribe=new Ee,this.cardStateMap$=this.store.select(Js),this.numPages$=In([this.items$,this.store.select(Ha.getPageSize)]).pipe(q(([i,r])=>Math.ceil(i.length/r))),this.isGroupExpanded$=this.groupName$.pipe(Jn(i=>null!==i?this.store.select(u1,i):$t(!0))),this.showPaginationControls$=this.numPages$.pipe(q(i=>i>1)),this.normalizedPageIndex$=In([this.pageIndex$,this.numPages$]).pipe(it(this.ngUnsubscribe),Dt(([i,r])=>{0!==r&&(i>=r?this.pageIndex$.next(r-1):i<0&&this.pageIndex$.next(0))}),q(([i,r])=>Math.min(Math.max(i,0),r-1)),Da(1)),this.pagedItems$=In([this.items$,this.store.select(Ha.getPageSize),this.normalizedPageIndex$,this.isGroupExpanded$]).pipe(q(([i,r,o,a])=>i.slice(r*o,r*o+(a?r:0)))),this.cardMinWidth$=this.store.select(Jf)}ngOnChanges(e){e.cardIdsWithMetadata&&this.items$.next(this.cardIdsWithMetadata),e.groupName&&this.groupName$.next(this.groupName)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}onPageIndexChanged(e){this.pageIndex$.next(e)}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-card-grid"]],inputs:{groupName:"groupName",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver"},features:[qt],decls:8,vars:22,consts:[[3,"isGroupExpanded","pageIndex","numPages","showPaginationControls","cardIdsWithMetadata","cardMinWidth","cardObserver","cardStateMap","pageIndexChanged"]],template:function(e,i){1&e&&(f(0,"metrics-card-grid-component",0),A("pageIndexChanged",function(o){return i.onPageIndexChanged(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),g()),2&e&&b("isGroupExpanded",G(1,8,i.isGroupExpanded$))("pageIndex",G(2,10,i.normalizedPageIndex$))("numPages",G(3,12,i.numPages$))("showPaginationControls",G(4,14,i.showPaginationControls$))("cardIdsWithMetadata",G(5,16,i.pagedItems$))("cardMinWidth",G(6,18,i.cardMinWidth$))("cardObserver",i.cardObserver)("cardStateMap",G(7,20,i.cardStateMap$))},dependencies:[vne,ct],encapsulation:2,changeDetection:0}),n})();function oVe(n,t){if(1&n&&(f(0,"span",7),T(1),U(2,"number"),g()),2&n){let e=w();v(1),Ve("",G(2,1,e.numberOfCards)," cards")}}function aVe(n,t){1&n&&k(0,"mat-icon",8)}function sVe(n,t){1&n&&k(0,"mat-icon",9)}var yne=(()=>{class n{constructor(){this.groupExpansionToggled=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-card-group-toolbar-component"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards",isGroupExpanded:"isGroupExpanded"},outputs:{groupExpansionToggled:"groupExpansionToggled"},decls:9,vars:5,consts:function(){let t;return t=$localize`:A button that allows user to expand a tag group.␟ffaa11471b878a6dffe2e68c6f37064a9e074853␟5386054325274779258:Expand group`,[["aria-label",t,1,"group-toolbar",3,"click"],[1,"group-title-wrapper"],["aria-role","heading","aria-level","3",1,"group-title",3,"title"],["class","group-card-count",4,"ngIf"],[1,"expand-group-icon"],["svgIcon","expand_less_24px",4,"ngIf","ngIfElse"],["expandMore",""],[1,"group-card-count"],["svgIcon","expand_less_24px"],["svgIcon","expand_more_24px"]]},template:function(e,i){if(1&e&&(f(0,"button",0),A("click",function(){return i.groupExpansionToggled.emit()}),f(1,"span",1)(2,"span",2),T(3),g(),S(4,oVe,3,3,"span",3),g(),f(5,"span",4),S(6,aVe,1,0,"mat-icon",5),S(7,sVe,1,0,"ng-template",null,6,jt),g()()),2&e){let r=st(8);v(2),Zi("title",i.groupName),v(1),kt(i.groupName),v(1),b("ngIf",i.numberOfCards>1),v(2),b("ngIf",i.isGroupExpanded)("ngIfElse",r)}},dependencies:[Ne,bn,Us],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border:0;border-top:1px solid #ebebeb;color:#212121;top:-1px;display:flex;width:100%;font:inherit}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{color:#fff}.card-group:first-of-type   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:0}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]:hover{cursor:pointer}.expand-group-icon[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.expand-group-icon[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled{color:#616161}.group-title-wrapper[_ngcontent-%COMP%]{flex-grow:1;text-align:left}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),xne=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.isGroupExpanded$=$t(!1)}ngOnInit(){this.isGroupExpanded$=null!==this.groupName?this.store.select(u1,this.groupName):$t(!1)}onGroupExpansionToggled(){if(null===this.groupName)throw new RangeError("Invariant error: expansion cannot be toggled when groupName is null");this.store.dispatch(OT({tagGroup:this.groupName}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-card-group-toolbar"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards"},decls:2,vars:5,consts:[[3,"numberOfCards","isGroupExpanded","groupName","groupExpansionToggled"]],template:function(e,i){1&e&&(f(0,"metrics-card-group-toolbar-component",0),A("groupExpansionToggled",function(){return i.onGroupExpansionToggled()}),U(1,"async"),g()),2&e&&b("numberOfCards",i.numberOfCards)("isGroupExpanded",G(1,3,i.isGroupExpanded$))("groupName",i.groupName)},dependencies:[yne,ct],encapsulation:2,changeDetection:0}),n})();function dVe(n,t){if(1&n&&(f(0,"div",1),k(1,"metrics-card-group-toolbar",2)(2,"metrics-card-grid",3),g()),2&n){let e=t.$implicit,i=w();v(1),b("numberOfCards",e.items.length)("groupName",e.groupName),v(1),b("cardIdsWithMetadata",e.items)("cardObserver",i.cardObserver)("groupName",e.groupName)}}var Cne=(()=>{class n{constructor(){this.PluginType=An}trackByGroup(e,i){return i.groupName}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-card-groups-component"]],inputs:{cardGroups:"cardGroups",cardObserver:"cardObserver"},decls:1,vars:2,consts:[["class","card-group",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-group"],[3,"numberOfCards","groupName"],[3,"cardIdsWithMetadata","cardObserver","groupName"]],template:function(e,i){1&e&&S(0,dVe,3,5,"div",0),2&e&&b("ngForOf",i.cardGroups)("ngForTrackBy",i.trackByGroup)},dependencies:[nn,__,xne],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}"],changeDetection:0}),n})(),Mne=(()=>{class n{constructor(e){this.store=e,this.cardGroups$=this.store.select(jh).pipe(Vi(this.store.select(Sc)),q(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),q(i=>HT(i)))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-card-groups"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardGroups","cardObserver"]],template:function(e,i){1&e&&(k(0,"metrics-card-groups-component",0),U(1,"async")),2&e&&b("cardGroups",G(1,2,i.cardGroups$))("cardObserver",i.cardObserver)},dependencies:[Cne,ct],encapsulation:2,changeDetection:0}),n})();function hVe(n,t){if(1&n&&(f(0,"span"),T(1),g()),2&n){let e=w();v(1),Ve(" and ",e.getPluginTypeFilterString(e.pluginTypes)," visualization filter")}}var wne=(()=>{class n{constructor(){this.PluginType=An,this.listFormatter=new Intl.ListFormat(void 0,{style:"long",type:"disjunction"})}getPluginTypeFilterString(e){let i=[...e].map(r=>{switch(r){case An.SCALARS:return"scalar";case An.IMAGES:return"image";case An.HISTOGRAMS:return"histogram";default:throw new RangeError(`Please implement human readable name for plugin type: ${r}`)}});return this.listFormatter.format(i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-empty-tag-match-component"]],inputs:{pluginTypes:"pluginTypes",tagFilterRegex:"tagFilterRegex",tagCounts:"tagCounts"},decls:6,vars:5,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(T(0,"No matches for tag filter "),f(1,"code"),T(2),g(),S(3,hVe,2,1,"span",0),T(4),U(5,"number")),2&e&&(v(2),Ve("/",i.tagFilterRegex,"/"),v(1),b("ngIf",i.pluginTypes.size),v(1),Ve(" out of ",G(5,3,i.tagCounts)," tags."))},dependencies:[Ne,Us],encapsulation:2,changeDetection:0}),n})(),Sne=(()=>{class n{constructor(e){this.store=e,this.pluginTypes$=this.store.select(Sc),this.tagFilterRegex$=this.store.select(Fl),this.tagCounts$=this.store.select(jh).pipe(q(i=>new Set(i.map(({tag:r})=>r)).size))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-empty-tag-match"]],decls:4,vars:9,consts:[[3,"pluginTypes","tagFilterRegex","tagCounts"]],template:function(e,i){1&e&&(k(0,"metrics-empty-tag-match-component",0),U(1,"async"),U(2,"async"),U(3,"async")),2&e&&b("pluginTypes",G(1,3,i.pluginTypes$))("tagFilterRegex",G(2,5,i.tagFilterRegex$))("tagCounts",G(3,7,i.tagCounts$))},dependencies:[wne,ct],encapsulation:2,changeDetection:0}),n})();function gVe(n,t){if(1&n&&(f(0,"span",6),T(1),U(2,"number"),g()),2&n){let e=w();v(1),Ve("",G(2,1,e.cardIdsWithMetadata.length)," cards")}}function _Ve(n,t){1&n&&k(0,"metrics-empty-tag-match",7)}var Ene=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-filtered-view-component"]],inputs:{isEmptyMatch:"isEmptyMatch",cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:7,vars:4,consts:[[1,"group-toolbar"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","warn",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver"],[1,"group-card-count"],[1,"warn"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"span",1)(2,"span",2),T(3,"Tags matching filter"),g(),S(4,gVe,3,3,"span",3),g()(),S(5,_Ve,1,0,"metrics-empty-tag-match",4),k(6,"metrics-card-grid",5)),2&e&&(v(4),b("ngIf",i.cardIdsWithMetadata.length>1),v(1),b("ngIf",i.isEmptyMatch),v(1),b("cardIdsWithMetadata",i.cardIdsWithMetadata)("cardObserver",i.cardObserver))},dependencies:[Ne,__,Sne,Us],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}metrics-empty-tag-match[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center;display:block}body.dark-mode[_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Tne=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(jh).pipe(Vi(this.store.select(Sc)),q(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),Vi(this.store.select(Fl)),Cr(200),q(([i,r])=>{try{return{cardList:i,regex:new RegExp(r,"i")}}catch{return{cardList:i,regex:null}}}),Oe(({regex:i})=>null!==i),q(({cardList:i,regex:r})=>i.filter(({tag:o})=>r.test(o))),ri((i,r)=>i.length===r.length&&i.every((o,a)=>o.cardId===r[a].cardId)),Ta(),kn([])),this.isEmptyMatch$=this.cardIdsWithMetadata$.pipe(Vi(this.store.select(jh)),q(([i,r])=>Boolean(r.length)&&0===i.length))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-filtered-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"isEmptyMatch","cardIdsWithMetadata","cardObserver"]],template:function(e,i){1&e&&(k(0,"metrics-filtered-view-component",0),U(1,"async"),U(2,"async")),2&e&&b("isEmptyMatch",G(1,3,i.isEmptyMatch$))("cardIdsWithMetadata",G(2,5,i.cardIdsWithMetadata$))("cardObserver",i.cardObserver)},dependencies:[Ene,ct],encapsulation:2,changeDetection:0}),n})();function xVe(n,t){1&n&&k(0,"mat-icon",7)}function CVe(n,t){if(1&n&&(f(0,"mat-option",8),T(1),g()),2&n){let e=t.$implicit;b("value",e),Be("title",e),v(1),kt(e)}}function MVe(n,t){if(1&n&&(f(0,"div",9)(1,"em"),T(2),U(3,"number"),g()()),2&n){let e=w();v(2),Ve("and ",G(3,1,e.completions.length-25)," more tags matched")}}var Dne=(()=>{class n{constructor(){this.onRegexFilterValueChange=new F}onCompletionAccepted(e){this.onRegexFilterValueChange.emit(function(n){return n.replace(Ebe,"\\$&")}(e))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-tag-filter-component"]],hostVars:2,hostBindings:function(e,i){2&e&&nt("valid",i.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid",completions:"completions"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:7,vars:5,consts:[[1,"tag-filter"],["placeholder","Filter tags (regex)",3,"value","matAutocomplete","input"],["svgIcon","error_24px","class","error-icon","title","Invalid regex filter. The result may be stale.",4,"ngIf"],[1,"tag-options",3,"optionSelected"],["filterMatches","matAutocomplete"],["class","option",3,"value",4,"ngFor","ngForOf"],["class","and-more",4,"ngIf"],["svgIcon","error_24px","title","Invalid regex filter. The result may be stale.",1,"error-icon"],[1,"option",3,"value"],[1,"and-more"]],template:function(e,i){if(1&e&&(f(0,"div",0)(1,"tb-filter-input",1),A("input",function(o){return i.onRegexFilterValueChange.emit(o.target.value)}),g(),S(2,xVe,1,0,"mat-icon",2),g(),f(3,"mat-autocomplete",3,4),A("optionSelected",function(o){return i.onCompletionAccepted(o.option.value)}),S(5,CVe,2,3,"mat-option",5),S(6,MVe,4,3,"div",6),g()),2&e){let r=st(4);v(1),b("value",i.regexFilterValue)("matAutocomplete",r),v(1),b("ngIf",!i.isRegexFilterValid),v(3),b("ngForOf",null==i.completions?null:i.completions.slice(0,25)),v(1),b("ngIf",(null==i.completions?null:i.completions.length)>25)}},dependencies:[nn,Ne,g_,Jte,ja,bn,Us],styles:[".tag-filter[_ngcontent-%COMP%]{display:flex;position:relative}tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}[_nghost-%COMP%]{color:#212121}body.dark-mode   [_nghost-%COMP%]{color:#fff}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}  .tag-options .option,   .tag-options .and-more{-webkit-box-orient:vertical;-webkit-line-clamp:3;display:-webkit-box;font-size:14px;line-height:1.4;padding:8px 16px}  .tag-options .and-more{color:#616161}body.dark-mode[_nghost-%COMP%]     .tag-options .and-more, body.dark-mode   [_nghost-%COMP%]     .tag-options .and-more{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Ine=(()=>{class n{constructor(e){this.store=e,this.tagFilter$=this.store.select(Fl),this.isTagFilterRegexValid$=this.tagFilter$.pipe(q(i=>{try{return new RegExp(i),!0}catch{return!1}})),this.completions$=this.store.select(o1).pipe(Vi(this.store.select(Sc)),q(([i,r])=>i.filter(({plugin:o})=>!r.size||r.has(o)).map(({tag:o})=>o)),q(i=>[...new Set(i)]),q(i=>i.sort(vy)),Vi(this.store.select(Fl)),q(([i,r])=>{try{return[i,new RegExp(r,"i")]}catch{return[i,null]}}),Oe(([,i])=>null!==i),q(([i,r])=>i.filter(o=>r.test(o))))}onTagFilterChange(e){this.store.dispatch(kT({tagFilter:e}))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-tag-filter"]],decls:4,vars:9,consts:[[3,"regexFilterValue","isRegexFilterValid","completions","onRegexFilterValueChange"]],template:function(e,i){1&e&&(f(0,"metrics-tag-filter-component",0),A("onRegexFilterValueChange",function(o){return i.onTagFilterChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("regexFilterValue",G(1,3,i.tagFilter$))("isRegexFilterValid",G(2,5,i.isTagFilterRegexValid$))("completions",G(3,7,i.completions$))},dependencies:[Dne,ct],encapsulation:2,changeDetection:0}),n})();function EVe(n,t){if(1&n&&(f(0,"span",10),T(1),g()),2&n){let e=w();v(1),Ve("",e.cardIdsWithMetadata.length," cards")}}function TVe(n,t){1&n&&(f(0,"span",12),T(1,"New card pinned"),g()),2&n&&Be("data-id",t.$implicit)}var DVe=function(n){return[n]};function IVe(n,t){if(1&n&&(f(0,"span"),S(1,TVe,2,1,"span",11),g()),2&n){let e=w();v(1),b("ngForOf",Un(1,DVe,e.lastPinnedCardTime))}}function AVe(n,t){if(1&n){let e=Te();f(0,"div",13)(1,"button",14),A("click",function(){return ne(e),ie(w().onClearAllPinsClicked.emit())}),T(2," Clear all pins "),g()()}}function RVe(n,t){if(1&n&&k(0,"metrics-card-grid",15),2&n){let e=w();b("cardIdsWithMetadata",e.cardIdsWithMetadata)("cardObserver",e.cardObserver)}}function PVe(n,t){1&n&&(f(0,"div",16),T(1,"Pin cards for a quick view and comparison"),g())}var Ane=(()=>{class n{constructor(){this.globalPinsEnabled=!1,this.onClearAllPinsClicked=new F}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["metrics-pinned-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata",lastPinnedCardTime:"lastPinnedCardTime",globalPinsEnabled:"globalPinsEnabled"},outputs:{onClearAllPinsClicked:"onClearAllPinsClicked"},decls:12,vars:5,consts:[[1,"group-toolbar"],[1,"left-items"],["svgIcon","keep_24px"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],[4,"ngIf"],["class","right-items",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver",4,"ngIf","ngIfElse"],["emptyPinnedView",""],[1,"group-card-count"],["class","new-card-pinned",4,"ngFor","ngForOf"],[1,"new-card-pinned"],[1,"right-items"],["mat-stroked-button","","aria-label","Clear all pinned cards",3,"click"],[3,"cardIdsWithMetadata","cardObserver"],[1,"empty-message"]],template:function(e,i){if(1&e&&(f(0,"div",0)(1,"div",1),k(2,"mat-icon",2),f(3,"span",3)(4,"span",4),T(5,"Pinned"),g(),S(6,EVe,2,1,"span",5),S(7,IVe,2,3,"span",6),g()(),S(8,AVe,3,0,"div",7),g(),S(9,RVe,1,2,"metrics-card-grid",8),S(10,PVe,2,0,"ng-template",null,9,jt)),2&e){let r=st(11);v(6),b("ngIf",i.cardIdsWithMetadata.length>1),v(1),b("ngIf",i.lastPinnedCardTime),v(1),b("ngIf",i.cardIdsWithMetadata.length>0&&i.globalPinsEnabled),v(1),b("ngIf",i.cardIdsWithMetadata.length)("ngIfElse",r)}},dependencies:[nn,Ne,ki,bn,__],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-toolbar[_ngcontent-%COMP%]{justify-content:space-between}.left-items[_ngcontent-%COMP%]{display:flex;align-items:center}.right-items[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;font-weight:normal;height:25px;line-height:25px}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline;gap:6px}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.empty-message[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center}body.dark-mode[_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.new-card-pinned[_ngcontent-%COMP%]{animation:_ngcontent-%COMP%_pinned-view-fade-out 3s linear;background:#f44336;border-radius:5px;color:#fff;display:inline-block;font-size:13px;opacity:0;padding:3px 5px}@keyframes _ngcontent-%COMP%_pinned-view-fade-out{from{opacity:1}66%{opacity:.99}to{opacity:0}}"],changeDetection:0}),n})(),Rne=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(Kf).pipe(kn([])),this.lastPinnedCardTime$=this.store.select(OW).pipe(os(1)),this.globalPinsEnabled$=this.store.select(pd)}onClearAllPinsClicked(){this.store.dispatch(Wg())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-pinned-view"]],inputs:{cardObserver:"cardObserver"},decls:4,vars:10,consts:[[3,"cardIdsWithMetadata","lastPinnedCardTime","cardObserver","globalPinsEnabled","onClearAllPinsClicked"]],template:function(e,i){1&e&&(f(0,"metrics-pinned-view-component",0),A("onClearAllPinsClicked",function(){return i.onClearAllPinsClicked()}),U(1,"async"),U(2,"async"),U(3,"async"),g()),2&e&&b("cardIdsWithMetadata",G(1,4,i.cardIdsWithMetadata$))("lastPinnedCardTime",G(2,6,i.lastPinnedCardTime$))("cardObserver",i.cardObserver)("globalPinsEnabled",G(3,8,i.globalPinsEnabled$))},dependencies:[Ane,ct],encapsulation:2,changeDetection:0}),n})();function FVe(n,t){1&n&&k(0,"metrics-filtered-view",13),2&n&&b("cardObserver",w().cardObserver)}function NVe(n,t){1&n&&(f(0,"div",17),k(1,"mat-spinner",18),g())}var LVe=function(n){return{"slide-out-menu-expanded":n}};function BVe(n,t){if(1&n&&(f(0,"div",19),k(1,"metrics-scalar-column-editor"),g()),2&n){let e=w();b("ngClass",Un(1,LVe,e.slideOutMenuOpen))}}function VVe(n,t){if(1&n){let e=Te();f(0,"div",20)(1,"div",21)(2,"h2",22),T(3,"Settings"),g(),f(4,"button",23),A("click",function(){return ne(e),ie(w().onCloseSidepaneButtonClicked.emit())}),k(5,"mat-icon",24),g()(),k(6,"metrics-dashboard-right-pane"),g()}}var HVe=function(n){return{checked:n,"settings-button":!0}},zVe=new te("Customizable Share Button"),Pne=(()=>{class n{constructor(e,i){this.host=e,this.customShareButton=i,this.onSettingsButtonClicked=new F,this.onCloseSidepaneButtonClicked=new F,this.onPluginTypeToggled=new F,this.onPluginTypeAllToggled=new F,this.PluginType=An,this.cardObserver=new yy(this.host.nativeElement,"600px 0px 600px 0px")}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(zVe,8))},n.\u0275cmp=P({type:n,selectors:[["metrics-main-view-component"]],inputs:{showFilteredView:"showFilteredView",isSidepaneOpen:"isSidepaneOpen",filteredPluginTypes:"filteredPluginTypes",initialTagsLoading:"initialTagsLoading",slideOutMenuOpen:"slideOutMenuOpen"},outputs:{onSettingsButtonClicked:"onSettingsButtonClicked",onCloseSidepaneButtonClicked:"onCloseSidepaneButtonClicked",onPluginTypeToggled:"onPluginTypeToggled",onPluginTypeAllToggled:"onPluginTypeAllToggled"},decls:24,vars:23,consts:function(){let t,e;return t=$localize`:Label on a toolbar button to toggle the settings side pane.␟d3516db6bbe6860a55beab66e4969dac625b8d72␟7659285445580838925:Toggle settings side pane`,e=$localize`:Label on a button to close the settings side pane.␟04521dc0b6a65cf5c382944c9a8b4b844a3e9598␟8156766997747165871:Close side pane`,[[1,"toolbar"],["multiple","","appearance","standard",1,"filter-view"],["mat-button","","role","checkbox","data-value","all",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","scalars",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","image",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","histogram",1,"filter-view-button",3,"click"],[3,"customizableComponent"],[1,"right-items"],["mat-stroked-button","","aria-label",t,3,"ngClass","click"],["svgIcon","settings_24px"],[1,"split-content"],["cdkScrollable",""],[3,"cardObserver",4,"ngIf"],[3,"cardObserver"],["class","loading-container",4,"ngIf"],["class","slide-out-menu",3,"ngClass",4,"ngIf"],["class","sidebar",4,"ngIf"],[1,"loading-container"],["diameter","36"],[1,"slide-out-menu",3,"ngClass"],[1,"sidebar"],[1,"header"],[1,"title"],["mat-icon-button","","aria-label",e,3,"click"],["svgIcon","close_24px"]]},template:function(e,i){1&e&&(f(0,"div",0),k(1,"metrics-tag-filter"),f(2,"mat-button-toggle-group",1)(3,"button",2),A("click",function(){return i.onPluginTypeAllToggled.emit()}),T(4," All "),g(),f(5,"button",3),A("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.SCALARS)}),T(6," Scalars "),g(),f(7,"button",4),A("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.IMAGES)}),T(8," Image "),g(),f(9,"button",5),A("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.HISTOGRAMS)}),T(10," Histogram "),g()(),k(11,"tb-customization",6),f(12,"div",7)(13,"button",8),A("click",function(){return i.onSettingsButtonClicked.emit()}),k(14,"mat-icon",9),T(15," Settings "),g()()(),f(16,"div",10)(17,"div",11),S(18,FVe,1,1,"metrics-filtered-view",12),k(19,"metrics-pinned-view",13),S(20,NVe,2,0,"div",14),k(21,"metrics-card-groups",13),g(),S(22,BVe,2,3,"div",15),S(23,VVe,7,0,"div",16),g()),2&e&&(v(3),Be("aria-checked",0===i.filteredPluginTypes.size),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.SCALARS)),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.IMAGES)),v(2),Be("aria-checked",i.filteredPluginTypes.has(i.PluginType.HISTOGRAMS)),v(2),b("customizableComponent",i.customShareButton),v(2),b("ngClass",Un(21,HVe,i.isSidepaneOpen)),Be("aria-pressed",i.isSidepaneOpen),v(4),nt("main",!0)("filter-view",i.showFilteredView),v(1),b("ngIf",i.showFilteredView),v(1),Bt("display",i.showFilteredView?"none":""),b("cardObserver",i.cardObserver),v(1),b("ngIf",i.initialTagsLoading),v(1),Bt("display",i.showFilteredView?"none":""),b("cardObserver",i.cardObserver),v(1),b("ngIf",i.isSidepaneOpen),v(1),b("ngIf",i.isSidepaneOpen))},dependencies:[wn,Ne,vQ,xd,ki,Er,DN,bn,Nc,AQ,HQ,Mne,Tne,Ine,Rne],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;flex:none;display:flex;align-items:center;justify-content:space-between;height:48px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}.toolbar[_ngcontent-%COMP%]   metrics-tag-filter[_ngcontent-%COMP%]{flex:1 1 100px}.toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;margin-left:16px;padding-left:16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #555}mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-button-toggle-group.filter-view[_ngcontent-%COMP%]{border:1px solid #555}.filter-view[_ngcontent-%COMP%]{border-radius:4px;flex:none;margin-right:5px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{border-radius:0;font-size:12px;font-weight:normal;height:25px;line-height:25px;min-width:unset;padding:0 12px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #555}.filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#e0e0e0}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#212121}.split-content[_ngcontent-%COMP%]{display:flex;overflow-y:auto;flex:1}.main[_ngcontent-%COMP%], .sidebar[_ngcontent-%COMP%]{contain:strict;background-color:#fff;overflow-x:hidden;overflow-y:auto;will-change:transform,scroll-position}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{background-color:#303030}.main[_ngcontent-%COMP%]{background-color:#f5f6f7;flex:1 1;display:flex;flex-direction:column}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#3a3a3a}.main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}.main.filter-view[_ngcontent-%COMP%]{overflow:hidden}.main.filter-view[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{contain:content;overflow:auto;will-change:transform,scroll-position}.loading-container[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;margin:20px 0}.sidebar[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;flex:0 0 250px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{border-left:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;justify-content:space-between;height:42px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   .title[_ngcontent-%COMP%]{font-size:18px;font-weight:400;line-height:normal;margin:0}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:#616161;display:inline-flex}body.dark-mode   [_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}[_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#e0e0e0;border-color:#e0e0e0}body.dark-mode   [_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#212121}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]     .mat-button-wrapper{display:inline-flex;align-items:center}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:4px}.slide-out-menu[_ngcontent-%COMP%]{background-color:#fff;height:calc(100% - 49px);position:absolute;right:50px;top:49px;transition:all .75s ease;visibility:hidden;width:200px;border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{border-left:1px solid #555}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{background-color:#303030}.slide-out-menu-expanded[_ngcontent-%COMP%]{right:250px;visibility:visible}"],changeDetection:0}),n})(),kne=(()=>{class n{constructor(e){this.store=e,this.isSidepaneOpen$=this.store.select(p1),this.initialTagsLoading$=this.store.select(xv).pipe(O_(i=>null===i.lastLoadedTimeInMs,!0),q(i=>i.state===Re.LOADING&&null===i.lastLoadedTimeInMs)),this.showFilteredView$=this.store.select(Fl).pipe(q(i=>i.length>0)),this.filteredPluginTypes$=this.store.select(Sc),this.isSlideoutMenuOpen$=this.store.select(h1)}onSettingsButtonClicked(){this.store.dispatch(sT())}onCloseSidepaneButtonClicked(){this.store.dispatch(aT())}onPluginVisibilityToggled(e){this.store.dispatch(FT({plugin:e}))}onShowAllPlugins(){this.store.dispatch(NT())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-main-view"]],decls:6,vars:15,consts:[[3,"showFilteredView","isSidepaneOpen","initialTagsLoading","filteredPluginTypes","slideOutMenuOpen","onSettingsButtonClicked","onCloseSidepaneButtonClicked","onPluginTypeToggled","onPluginTypeAllToggled"]],template:function(e,i){1&e&&(f(0,"metrics-main-view-component",0),A("onSettingsButtonClicked",function(){return i.onSettingsButtonClicked()})("onCloseSidepaneButtonClicked",function(){return i.onCloseSidepaneButtonClicked()})("onPluginTypeToggled",function(o){return i.onPluginVisibilityToggled(o)})("onPluginTypeAllToggled",function(){return i.onShowAllPlugins()}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),g()),2&e&&b("showFilteredView",G(1,5,i.showFilteredView$))("isSidepaneOpen",G(2,7,i.isSidepaneOpen$))("initialTagsLoading",G(3,9,i.initialTagsLoading$))("filteredPluginTypes",G(4,11,i.filteredPluginTypes$))("slideOutMenuOpen",G(5,13,i.isSlideoutMenuOpen$))},dependencies:[Pne,ct],encapsulation:2,changeDetection:0}),n})(),Zl=(()=>(function(n){n.CHECKBOX="checkbox",n.RUN_NAME="run_name",n.EXPERIMENT_NAME="experiment_name",n.RUN_COLOR="run_color"}(Zl||(Zl={})),Zl))(),Pp=(()=>(function(n){n[n.BEFORE=0]="BEFORE",n[n.AFTER=1]="AFTER"}(Pp||(Pp={})),Pp))(),One=new Set(["string","number"]),GVe={insertUndefined:Pp.AFTER};function Fne(n){if("number"==typeof n)return isNaN(n)?void 0:n;if(!isNaN(parseInt(n)))return parseInt(n);for(let t=0;t<n.length;t++)if(isNaN(parseInt(n[t])))return 0===t?void 0:parseInt(n.slice(0,t))}var WVe=["dialogPopup"],qVe=["hueSlider"],XVe=["alphaSlider"];function YVe(n,t){if(1&n&&k(0,"div"),2&n){let e=w();bb("arrow arrow-",e.cpUsePosition,""),Bt("top",e.arrowTop,"px")}}function QVe(n,t){if(1&n){let e=Te();f(0,"div",28),A("newValue",function(r){return ne(e),ie(w().onColorChange(r))})("dragStart",function(){return ne(e),ie(w().onDragStart("saturation-lightness"))})("dragEnd",function(){return ne(e),ie(w().onDragEnd("saturation-lightness"))}),k(1,"div",14),g()}if(2&n){let e=w();Bt("background-color",e.hueSliderColor),b("rgX",1)("rgY",1),v(1),Bt("top",null==e.slider?null:e.slider.v,"px")("left",null==e.slider?null:e.slider.s,"px")}}function ZVe(n,t){1&n&&(qn(),f(0,"svg",29),k(1,"path",30)(2,"path",31),g())}function KVe(n,t){if(1&n){let e=Te();f(0,"button",32),A("click",function(r){ne(e);let o=w();return ie(o.onAddPresetColor(r,o.selectedColor))}),T(1),g()}if(2&n){let e=w();Xo(e.cpAddColorButtonClass),b("disabled",e.cpPresetColors&&e.cpPresetColors.length>=e.cpMaxPresetColorsLength),v(1),Ve(" ",e.cpAddColorButtonText," ")}}function JVe(n,t){1&n&&k(0,"div",33)}function $Ve(n,t){if(1&n){let e=Te();f(0,"input",39),A("keyup.enter",function(r){return ne(e),ie(w(2).onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);b("rg",1)("value",null==e.cmykText?null:e.cmykText.a)}}function e4e(n,t){1&n&&(f(0,"div"),T(1,"A"),g())}function t4e(n,t){if(1&n){let e=Te();f(0,"div",34)(1,"div",35)(2,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onCyanInput(r))}),g(),f(3,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onMagentaInput(r))}),g(),f(4,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onYellowInput(r))}),g(),f(5,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onBlackInput(r))}),g(),S(6,$Ve,1,2,"input",37),g(),f(7,"div",35)(8,"div"),T(9,"C"),g(),f(10,"div"),T(11,"M"),g(),f(12,"div"),T(13,"Y"),g(),f(14,"div"),T(15,"K"),g(),S(16,e4e,2,0,"div",38),g()()}if(2&n){let e=w();Bt("display",3!==e.format?"none":"block"),v(2),b("rg",100)("value",null==e.cmykText?null:e.cmykText.c),v(1),b("rg",100)("value",null==e.cmykText?null:e.cmykText.m),v(1),b("rg",100)("value",null==e.cmykText?null:e.cmykText.y),v(1),b("rg",100)("value",null==e.cmykText?null:e.cmykText.k),v(1),b("ngIf","disabled"!==e.cpAlphaChannel),v(10),b("ngIf","disabled"!==e.cpAlphaChannel)}}function n4e(n,t){if(1&n){let e=Te();f(0,"input",39),A("keyup.enter",function(r){return ne(e),ie(w(2).onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);b("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function i4e(n,t){1&n&&(f(0,"div"),T(1,"A"),g())}function r4e(n,t){if(1&n){let e=Te();f(0,"div",40)(1,"div",35)(2,"input",41),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onHueInput(r))}),g(),f(3,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onSaturationInput(r))}),g(),f(4,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onLightnessInput(r))}),g(),S(5,n4e,1,2,"input",37),g(),f(6,"div",35)(7,"div"),T(8,"H"),g(),f(9,"div"),T(10,"S"),g(),f(11,"div"),T(12,"L"),g(),S(13,i4e,2,0,"div",38),g()()}if(2&n){let e=w();Bt("display",2!==e.format?"none":"block"),v(2),b("rg",360)("value",null==e.hslaText?null:e.hslaText.h),v(1),b("rg",100)("value",null==e.hslaText?null:e.hslaText.s),v(1),b("rg",100)("value",null==e.hslaText?null:e.hslaText.l),v(1),b("ngIf","disabled"!==e.cpAlphaChannel),v(8),b("ngIf","disabled"!==e.cpAlphaChannel)}}function o4e(n,t){if(1&n){let e=Te();f(0,"input",39),A("keyup.enter",function(r){return ne(e),ie(w(2).onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);b("rg",1)("value",null==e.rgbaText?null:e.rgbaText.a)}}function a4e(n,t){1&n&&(f(0,"div"),T(1,"A"),g())}function s4e(n,t){if(1&n){let e=Te();f(0,"div",42)(1,"div",35)(2,"input",43),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onRedInput(r))}),g(),f(3,"input",43),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onGreenInput(r))}),g(),f(4,"input",43),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onBlueInput(r))}),g(),S(5,o4e,1,2,"input",37),g(),f(6,"div",35)(7,"div"),T(8,"R"),g(),f(9,"div"),T(10,"G"),g(),f(11,"div"),T(12,"B"),g(),S(13,a4e,2,0,"div",38),g()()}if(2&n){let e=w();Bt("display",1!==e.format?"none":"block"),v(2),b("rg",255)("value",null==e.rgbaText?null:e.rgbaText.r),v(1),b("rg",255)("value",null==e.rgbaText?null:e.rgbaText.g),v(1),b("rg",255)("value",null==e.rgbaText?null:e.rgbaText.b),v(1),b("ngIf","disabled"!==e.cpAlphaChannel),v(8),b("ngIf","disabled"!==e.cpAlphaChannel)}}function l4e(n,t){if(1&n){let e=Te();f(0,"input",39),A("keyup.enter",function(r){return ne(e),ie(w(2).onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);b("rg",1)("value",e.hexAlpha)}}function c4e(n,t){1&n&&(f(0,"div"),T(1,"A"),g())}function d4e(n,t){if(1&n){let e=Te();f(0,"div",44)(1,"div",35)(2,"input",45),A("blur",function(){return ne(e),ie(w().onHexInput(null))})("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onHexInput(r))}),g(),S(3,l4e,1,2,"input",37),g(),f(4,"div",35)(5,"div"),T(6,"Hex"),g(),S(7,c4e,2,0,"div",38),g()()}if(2&n){let e=w();Bt("display",0!==e.format?"none":"block"),nt("hex-alpha","forced"===e.cpAlphaChannel),v(2),b("value",e.hexText),v(1),b("ngIf","forced"===e.cpAlphaChannel),v(4),b("ngIf","forced"===e.cpAlphaChannel)}}function u4e(n,t){if(1&n){let e=Te();f(0,"input",39),A("keyup.enter",function(r){return ne(e),ie(w(2).onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w(2).onAlphaInput(r))}),g()}if(2&n){let e=w(2);b("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function p4e(n,t){if(1&n){let e=Te();f(0,"div",46)(1,"div",35)(2,"input",36),A("keyup.enter",function(r){return ne(e),ie(w().onAcceptColor(r))})("newValue",function(r){return ne(e),ie(w().onValueInput(r))}),g(),S(3,u4e,1,2,"input",37),g(),f(4,"div",35)(5,"div"),T(6,"V"),g(),f(7,"div"),T(8,"A"),g()()()}if(2&n){let e=w();v(2),b("rg",100)("value",null==e.hslaText?null:e.hslaText.l),v(1),b("ngIf","disabled"!==e.cpAlphaChannel)}}function h4e(n,t){if(1&n){let e=Te();f(0,"div",47)(1,"span",48),A("click",function(){return ne(e),ie(w().onFormatToggle(-1))}),g(),f(2,"span",48),A("click",function(){return ne(e),ie(w().onFormatToggle(1))}),g()()}}function m4e(n,t){if(1&n){let e=Te();f(0,"span",55),A("click",function(r){ne(e);let o=w().$implicit;return ie(w(3).onRemovePresetColor(r,o))}),g()}2&n&&Xo(w(4).cpRemoveColorButtonClass)}function f4e(n,t){if(1&n){let e=Te();f(0,"div",53),A("click",function(){let o=ne(e).$implicit;return ie(w(3).setColorFromString(o))}),S(1,m4e,1,3,"span",54),g()}if(2&n){let e=t.$implicit,i=w(3);Bt("background-color",e),v(1),b("ngIf",i.cpAddColorButton)}}function g4e(n,t){if(1&n&&(f(0,"div"),S(1,f4e,2,3,"div",52),g()),2&n){let e=w(2);Xo(e.cpPresetColorsClass),v(1),b("ngForOf",e.cpPresetColors)}}function _4e(n,t){if(1&n&&(f(0,"div"),T(1),g()),2&n){let e=w(2);Xo(e.cpPresetEmptyMessageClass),v(1),kt(e.cpPresetEmptyMessage)}}function b4e(n,t){if(1&n&&(f(0,"div",49),k(1,"hr"),f(2,"div",50),T(3),g(),S(4,g4e,2,4,"div",51),S(5,_4e,2,4,"div",51),g()),2&n){let e=w();v(3),kt(e.cpPresetLabel),v(1),b("ngIf",null==e.cpPresetColors?null:e.cpPresetColors.length),v(1),b("ngIf",!(null!=e.cpPresetColors&&e.cpPresetColors.length)&&e.cpAddColorButton)}}function v4e(n,t){if(1&n){let e=Te();f(0,"button",58),A("click",function(r){return ne(e),ie(w(2).onCancelColor(r))}),T(1),g()}if(2&n){let e=w(2);Xo(e.cpCancelButtonClass),v(1),kt(e.cpCancelButtonText)}}function y4e(n,t){if(1&n){let e=Te();f(0,"button",58),A("click",function(r){return ne(e),ie(w(2).onAcceptColor(r))}),T(1),g()}if(2&n){let e=w(2);Xo(e.cpOKButtonClass),v(1),kt(e.cpOKButtonText)}}function x4e(n,t){if(1&n&&(f(0,"div",56),S(1,v4e,2,4,"button",57),S(2,y4e,2,4,"button",57),g()),2&n){let e=w();v(1),b("ngIf",e.cpCancelButton),v(1),b("ngIf",e.cpOKButton)}}function C4e(n,t){1&n&&hi(0)}function M4e(n,t){if(1&n&&(f(0,"div",59),S(1,C4e,1,0,"ng-container",60),g()),2&n){let e=w();v(1),b("ngTemplateOutlet",e.cpExtraTemplate)}}var Go=(()=>(function(n){n[n.HEX=0]="HEX",n[n.RGBA=1]="RGBA",n[n.HSLA=2]="HSLA",n[n.CMYK=3]="CMYK"}(Go||(Go={})),Go))(),Kl=class{constructor(t,e,i,r){this.r=t,this.g=e,this.b=i,this.a=r}},b_=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},qd=class{constructor(t,e,i,r){this.h=t,this.s=e,this.l=i,this.a=r}},Dm=class{constructor(t,e,i,r,o=1){this.c=t,this.m=e,this.y=i,this.k=r,this.a=o}},E4e=(()=>{class n{constructor(){this.newValue=new F}inputChange(e){let i=e.target.value;if(void 0===this.rg)this.newValue.emit(i);else{let r=parseFloat(i);this.newValue.emit({v:r,rg:this.rg})}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=Me({type:n,selectors:[["","text",""]],hostBindings:function(e,i){1&e&&A("input",function(o){return i.inputChange(o)})},inputs:{rg:"rg",text:"text"},outputs:{newValue:"newValue"}}),n})(),T4e=(()=>{class n{constructor(e){this.elRef=e,this.dragEnd=new F,this.dragStart=new F,this.newValue=new F,this.listenerMove=i=>this.move(i),this.listenerStop=()=>this.stop()}mouseDown(e){this.start(e)}touchStart(e){this.start(e)}move(e){e.preventDefault(),this.setCursor(e)}start(e){this.setCursor(e),e.stopPropagation(),document.addEventListener("mouseup",this.listenerStop),document.addEventListener("touchend",this.listenerStop),document.addEventListener("mousemove",this.listenerMove),document.addEventListener("touchmove",this.listenerMove),this.dragStart.emit()}stop(){document.removeEventListener("mouseup",this.listenerStop),document.removeEventListener("touchend",this.listenerStop),document.removeEventListener("mousemove",this.listenerMove),document.removeEventListener("touchmove",this.listenerMove),this.dragEnd.emit()}getX(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageX?e.pageX:e.touches[0].pageX)-i.left-window.pageXOffset}getY(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageY?e.pageY:e.touches[0].pageY)-i.top-window.pageYOffset}setCursor(e){let i=this.elRef.nativeElement.offsetWidth,r=this.elRef.nativeElement.offsetHeight,o=Math.max(0,Math.min(this.getX(e),i)),a=Math.max(0,Math.min(this.getY(e),r));void 0!==this.rgX&&void 0!==this.rgY?this.newValue.emit({s:o/i,v:1-a/r,rgX:this.rgX,rgY:this.rgY}):void 0===this.rgX&&void 0!==this.rgY?this.newValue.emit({v:a/r,rgY:this.rgY}):void 0!==this.rgX&&void 0===this.rgY&&this.newValue.emit({v:o/i,rgX:this.rgX})}}return n.\u0275fac=function(e){return new(e||n)(C(xe))},n.\u0275dir=Me({type:n,selectors:[["","slider",""]],hostBindings:function(e,i){1&e&&A("mousedown",function(o){return i.mouseDown(o)})("touchstart",function(o){return i.touchStart(o)})},inputs:{rgX:"rgX",rgY:"rgY",slider:"slider"},outputs:{dragEnd:"dragEnd",dragStart:"dragStart",newValue:"newValue"}}),n})(),_A=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},bA=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},SV=(()=>{class n{constructor(){this.active=null}setActive(e){this.active&&this.active!==e&&"inline"!==this.active.cpDialogDisplay&&this.active.closeDialog(),this.active=e}hsva2hsla(e){let i=e.h,r=e.s,o=e.v,a=e.a;if(0===o)return new qd(i,0,0,a);if(0===r&&1===o)return new qd(i,1,1,a);{let s=o*(2-r)/2;return new qd(i,o*r/(1-Math.abs(2*s-1)),s,a)}}hsla2hsva(e){let i=Math.min(e.h,1),r=Math.min(e.s,1),o=Math.min(e.l,1),a=Math.min(e.a,1);if(0===o)return new b_(i,0,0,a);{let s=o+r*(1-Math.abs(2*o-1))/2;return new b_(i,2*(s-o)/s,s,a)}}hsvaToRgba(e){let i,r,o,a=e.h,s=e.s,l=e.v,c=e.a,d=Math.floor(6*a),u=6*a-d,p=l*(1-s),h=l*(1-u*s),m=l*(1-(1-u)*s);switch(d%6){case 0:i=l,r=m,o=p;break;case 1:i=h,r=l,o=p;break;case 2:i=p,r=l,o=m;break;case 3:i=p,r=h,o=l;break;case 4:i=m,r=p,o=l;break;case 5:i=l,r=p,o=h;break;default:i=0,r=0,o=0}return new Kl(i,r,o,c)}cmykToRgb(e){return new Kl((1-e.c)*(1-e.k),(1-e.m)*(1-e.k),(1-e.y)*(1-e.k),e.a)}rgbaToCmyk(e){let i=1-Math.max(e.r,e.g,e.b);return 1===i?new Dm(0,0,0,1,e.a):new Dm((1-e.r-i)/(1-i),(1-e.g-i)/(1-i),(1-e.b-i)/(1-i),i,e.a)}rgbaToHsva(e){let i,r,o=Math.min(e.r,1),a=Math.min(e.g,1),s=Math.min(e.b,1),l=Math.min(e.a,1),c=Math.max(o,a,s),d=Math.min(o,a,s),u=c,p=c-d;if(r=0===c?0:p/c,c===d)i=0;else{switch(c){case o:i=(a-s)/p+(a<s?6:0);break;case a:i=(s-o)/p+2;break;case s:i=(o-a)/p+4;break;default:i=0}i/=6}return new b_(i,r,u,l)}rgbaToHex(e,i){let r="#"+(16777216|e.r<<16|e.g<<8|e.b).toString(16).substr(1);return i&&(r+=(256|Math.round(255*e.a)).toString(16).substr(1)),r}normalizeCMYK(e){return new Dm(e.c/100,e.m/100,e.y/100,e.k/100,e.a)}denormalizeCMYK(e){return new Dm(Math.floor(100*e.c),Math.floor(100*e.m),Math.floor(100*e.y),Math.floor(100*e.k),e.a)}denormalizeRGBA(e){return new Kl(Math.round(255*e.r),Math.round(255*e.g),Math.round(255*e.b),e.a)}stringToHsva(e="",i=!1){let r=null;e=(e||"").toLowerCase();let o=[{re:/(rgb)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*%?,\s*(\d{1,3})\s*%?(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(a){return new Kl(parseInt(a[2],10)/255,parseInt(a[3],10)/255,parseInt(a[4],10)/255,isNaN(parseFloat(a[5]))?1:parseFloat(a[5]))}},{re:/(hsl)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(a){return new qd(parseInt(a[2],10)/360,parseInt(a[3],10)/100,parseInt(a[4],10)/100,isNaN(parseFloat(a[5]))?1:parseFloat(a[5]))}}];o.push(i?{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})?$/,parse:function(a){return new Kl(parseInt(a[1],16)/255,parseInt(a[2],16)/255,parseInt(a[3],16)/255,parseInt(a[4]||"FF",16)/255)}}:{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/,parse:function(a){return new Kl(parseInt(a[1],16)/255,parseInt(a[2],16)/255,parseInt(a[3],16)/255,1)}}),o.push({re:/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/,parse:function(a){return new Kl(parseInt(a[1]+a[1],16)/255,parseInt(a[2]+a[2],16)/255,parseInt(a[3]+a[3],16)/255,1)}});for(let a in o)if(o.hasOwnProperty(a)){let s=o[a],l=s.re.exec(e),c=l&&s.parse(l);if(c)return c instanceof Kl?r=this.rgbaToHsva(c):c instanceof qd&&(r=this.hsla2hsva(c)),r}return r}outputFormat(e,i,r){switch("auto"===i&&(i=e.a<1?"rgba":"hex"),i){case"hsla":let o=this.hsva2hsla(e),a=new qd(Math.round(360*o.h),Math.round(100*o.s),Math.round(100*o.l),Math.round(100*o.a)/100);return e.a<1||"always"===r?"hsla("+a.h+","+a.s+"%,"+a.l+"%,"+a.a+")":"hsl("+a.h+","+a.s+"%,"+a.l+"%)";case"rgba":let s=this.denormalizeRGBA(this.hsvaToRgba(e));return e.a<1||"always"===r?"rgba("+s.r+","+s.g+","+s.b+","+Math.round(100*s.a)/100+")":"rgb("+s.r+","+s.g+","+s.b+")";default:let l="always"===r||"forced"===r;return this.rgbaToHex(this.denormalizeRGBA(this.hsvaToRgba(e)),l)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),Lne=typeof window<"u"&&"ontouchstart"in window,D4e=(()=>{class n{constructor(e,i,r,o,a,s){this.ngZone=e,this.elRef=i,this.cdRef=r,this.document=o,this.platformId=a,this.service=s,this.isIE10=!1,this.dialogArrowSize=10,this.dialogArrowOffset=15,this.dialogInputFields=[Go.HEX,Go.RGBA,Go.HSLA,Go.CMYK],this.useRootViewContainer=!1,this.eyeDropperSupported=_w(this.platformId)&&"EyeDropper"in this.document.defaultView}handleEsc(e){this.show&&"popup"===this.cpDialogDisplay&&this.onCancelColor(e)}handleEnter(e){this.show&&"popup"===this.cpDialogDisplay&&this.onAcceptColor(e)}ngOnInit(){this.slider=new _A(0,0,0,0),this.sliderDimMax=new bA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.format=this.cpCmykEnabled?Go.CMYK:"rgba"===this.cpOutputFormat?Go.RGBA:"hsla"===this.cpOutputFormat?Go.HSLA:Go.HEX,this.listenerMouseDown=r=>{this.onMouseDown(r)},this.listenerResize=()=>{this.onResize()},this.openDialog(this.initialColor,!1)}ngOnDestroy(){this.closeDialog()}ngAfterViewInit(){230===this.cpWidth&&"inline"!==this.cpDialogDisplay||(this.sliderDimMax=new bA(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.updateColorPicker(!1),this.cdRef.detectChanges())}openDialog(e,i=!0){this.service.setActive(this),this.width||(this.cpWidth=this.directiveElementRef.nativeElement.offsetWidth),this.height||(this.height=320),this.setInitialColor(e),this.setColorFromString(e,i),this.openColorPicker()}closeDialog(){this.closeColorPicker()}setupDialog(e,i,r,o,a,s,l,c,d,u,p,h,m,_,M,y,x,R,I,B,ee,Q,we,Qe,Ae,D,re,ce,he,_e,$,de,pe,Ge,Se,Fe,lt,Mt){this.setInitialColor(r),this.setColorMode(c),this.isIE10=10===function(){let n="";typeof navigator<"u"&&(n=navigator.userAgent.toLowerCase());let t=n.indexOf("msie ");return t>0&&parseInt(n.substring(t+5,n.indexOf(".",t)),10)}(),this.directiveInstance=e,this.directiveElementRef=i,this.cpDisableInput=h,this.cpCmykEnabled=d,this.cpAlphaChannel=u,this.cpOutputFormat=p,this.cpDialogDisplay=s,this.cpIgnoredElements=m,this.cpSaveClickOutside=_,this.cpCloseClickOutside=M,this.useRootViewContainer=y,this.width=this.cpWidth=parseInt(o,10),this.height=this.cpHeight=parseInt(a,10),this.cpPosition=x,this.cpPositionOffset=parseInt(R,10),this.cpOKButton=D,this.cpOKButtonText=ce,this.cpOKButtonClass=re,this.cpCancelButton=he,this.cpCancelButtonText=$,this.cpCancelButtonClass=_e,this.cpEyeDropper=Fe,this.fallbackColor=l||"#fff",this.setPresetConfig(B,ee),this.cpPresetColorsClass=Q,this.cpMaxPresetColorsLength=we,this.cpPresetEmptyMessage=Qe,this.cpPresetEmptyMessageClass=Ae,this.cpAddColorButton=de,this.cpAddColorButtonText=Ge,this.cpAddColorButtonClass=pe,this.cpRemoveColorButtonClass=Se,this.cpTriggerElement=lt,this.cpExtraTemplate=Mt,I||(this.dialogArrowOffset=0),"inline"===s&&(this.dialogArrowSize=0,this.dialogArrowOffset=0),"hex"===p&&"always"!==u&&"forced"!==u&&(this.cpAlphaChannel="disabled")}setColorMode(e){switch(e.toString().toUpperCase()){case"1":case"C":case"COLOR":default:this.cpColorMode=1;break;case"2":case"G":case"GRAYSCALE":this.cpColorMode=2;break;case"3":case"P":case"PRESETS":this.cpColorMode=3}}setInitialColor(e){this.initialColor=e}setPresetConfig(e,i){this.cpPresetLabel=e,this.cpPresetColors=i}setColorFromString(e,i=!0,r=!0){let o;"always"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel?(o=this.service.stringToHsva(e,!0),!o&&!this.hsva&&(o=this.service.stringToHsva(e,!1))):o=this.service.stringToHsva(e,!1),!o&&!this.hsva&&(o=this.service.stringToHsva(this.fallbackColor,!1)),o&&(this.hsva=o,this.sliderH=this.hsva.h,"hex"===this.cpOutputFormat&&"disabled"===this.cpAlphaChannel&&(this.hsva.a=1),this.updateColorPicker(i,r))}onResize(){"fixed"===this.position?this.setDialogPosition():"inline"!==this.cpDialogDisplay&&this.closeColorPicker()}onDragEnd(e){this.directiveInstance.sliderDragEnd({slider:e,color:this.outputColor})}onDragStart(e){this.directiveInstance.sliderDragStart({slider:e,color:this.outputColor})}onMouseDown(e){this.show&&!this.isIE10&&"popup"===this.cpDialogDisplay&&e.target!==this.directiveElementRef.nativeElement&&!this.isDescendant(this.elRef.nativeElement,e.target)&&!this.isDescendant(this.directiveElementRef.nativeElement,e.target)&&0===this.cpIgnoredElements.filter(i=>i===e.target).length&&this.ngZone.run(()=>{this.cpSaveClickOutside?this.directiveInstance.colorSelected(this.outputColor):(this.hsva=null,this.setColorFromString(this.initialColor,!1),this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor),this.directiveInstance.colorCanceled()),this.cpCloseClickOutside&&this.closeColorPicker()})}onAcceptColor(e){e.stopPropagation(),this.outputColor&&this.directiveInstance.colorSelected(this.outputColor),"popup"===this.cpDialogDisplay&&this.closeColorPicker()}onCancelColor(e){this.hsva=null,e.stopPropagation(),this.directiveInstance.colorCanceled(),this.setColorFromString(this.initialColor,!0),"popup"===this.cpDialogDisplay&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor,!0),this.closeColorPicker())}onEyeDropper(){this.eyeDropperSupported&&(new window.EyeDropper).open().then(i=>{this.setColorFromString(i.sRGBHex,!0)})}onFormatToggle(e){let i=this.dialogInputFields.length-(this.cpCmykEnabled?0:1),r=((this.dialogInputFields.indexOf(this.format)+e)%i+i)%i;this.format=this.dialogInputFields[r]}onColorChange(e){this.hsva.s=e.s/e.rgX,this.hsva.v=e.v/e.rgY,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"lightness",value:this.hsva.v,color:this.outputColor}),this.directiveInstance.sliderChanged({slider:"saturation",value:this.hsva.s,color:this.outputColor})}onHueChange(e){this.hsva.h=e.v/e.rgX,this.sliderH=this.hsva.h,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"hue",value:this.hsva.h,color:this.outputColor})}onValueChange(e){this.hsva.v=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"value",value:this.hsva.v,color:this.outputColor})}onAlphaChange(e){this.hsva.a=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"alpha",value:this.hsva.a,color:this.outputColor})}onHexInput(e){if(null===e)this.updateColorPicker();else{e&&"#"!==e[0]&&(e="#"+e);let i=/^#([a-f0-9]{3}|[a-f0-9]{6})$/gi;"always"===this.cpAlphaChannel&&(i=/^#([a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/gi);let r=i.test(e);r&&(e.length<5&&(e="#"+e.substring(1).split("").map(o=>o+o).join("")),"forced"===this.cpAlphaChannel&&(e+=Math.round(255*this.hsva.a).toString(16)),this.setColorFromString(e,!0,!1)),this.directiveInstance.inputChanged({input:"hex",valid:r,value:e,color:this.outputColor})}}onRedInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.r=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"red",valid:r,value:i.r,color:this.outputColor})}onBlueInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.b=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"blue",valid:r,value:i.b,color:this.outputColor})}onGreenInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.g=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"green",valid:r,value:i.g,color:this.outputColor})}onHueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.h=e.v/e.rg,this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"hue",valid:i,value:this.hsva.h,color:this.outputColor})}onValueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.v=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"value",valid:i,value:this.hsva.v,color:this.outputColor})}onAlphaInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.a=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"alpha",valid:i,value:this.hsva.a,color:this.outputColor})}onLightnessInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.l=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"lightness",valid:r,value:i.l,color:this.outputColor})}onSaturationInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.s=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"saturation",valid:r,value:i.s,color:this.outputColor})}onCyanInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.c=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"cyan",valid:!0,value:this.cmyk.c,color:this.outputColor})}onMagentaInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.m=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"magenta",valid:!0,value:this.cmyk.m,color:this.outputColor})}onYellowInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.y=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"yellow",valid:!0,value:this.cmyk.y,color:this.outputColor})}onBlackInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.k=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"black",valid:!0,value:this.cmyk.k,color:this.outputColor})}onAddPresetColor(e,i){e.stopPropagation(),this.cpPresetColors.filter(r=>r===i).length||(this.cpPresetColors=this.cpPresetColors.concat(i),this.directiveInstance.presetColorsChanged(this.cpPresetColors))}onRemovePresetColor(e,i){e.stopPropagation(),this.cpPresetColors=this.cpPresetColors.filter(r=>r!==i),this.directiveInstance.presetColorsChanged(this.cpPresetColors)}openColorPicker(){this.show||(this.show=!0,this.hidden=!0,setTimeout(()=>{this.hidden=!1,this.setDialogPosition(),this.cdRef.detectChanges()},0),this.directiveInstance.stateChanged(!0),this.isIE10||this.ngZone.runOutsideAngular(()=>{Lne?document.addEventListener("touchstart",this.listenerMouseDown):document.addEventListener("mousedown",this.listenerMouseDown)}),window.addEventListener("resize",this.listenerResize))}closeColorPicker(){this.show&&(this.show=!1,this.directiveInstance.stateChanged(!1),this.isIE10||(Lne?document.removeEventListener("touchstart",this.listenerMouseDown):document.removeEventListener("mousedown",this.listenerMouseDown)),window.removeEventListener("resize",this.listenerResize),this.cdRef.destroyed||this.cdRef.detectChanges())}updateColorPicker(e=!0,i=!0,r=!1){if(this.sliderDimMax){2===this.cpColorMode&&(this.hsva.s=0);let o,a,s,l=this.outputColor;if(a=this.service.hsva2hsla(this.hsva),this.cpCmykEnabled?(r?(s=this.service.cmykToRgb(this.service.normalizeCMYK(this.cmyk)),this.hsva=this.service.rgbaToHsva(s)):(s=this.service.hsvaToRgba(this.hsva),this.cmyk=this.service.denormalizeCMYK(this.service.rgbaToCmyk(s))),s=this.service.denormalizeRGBA(s),this.sliderH=this.hsva.h):s=this.service.denormalizeRGBA(this.service.hsvaToRgba(this.hsva)),o=this.service.denormalizeRGBA(this.service.hsvaToRgba(new b_(this.sliderH||this.hsva.h,1,1,1))),i&&(this.hslaText=new qd(Math.round(360*a.h),Math.round(100*a.s),Math.round(100*a.l),Math.round(100*a.a)/100),this.rgbaText=new Kl(s.r,s.g,s.b,Math.round(100*s.a)/100),this.cpCmykEnabled&&(this.cmykText=new Dm(this.cmyk.c,this.cmyk.m,this.cmyk.y,this.cmyk.k,Math.round(100*this.cmyk.a)/100)),this.hexText=this.service.rgbaToHex(s,"always"===this.cpAlphaChannel),this.hexAlpha=this.rgbaText.a),"auto"===this.cpOutputFormat&&this.format!==Go.RGBA&&this.format!==Go.CMYK&&this.format!==Go.HSLA&&this.hsva.a<1&&(this.format=this.hsva.a<1?Go.RGBA:Go.HEX),this.hueSliderColor="rgb("+o.r+","+o.g+","+o.b+")",this.alphaSliderColor="rgb("+s.r+","+s.g+","+s.b+")",this.outputColor=this.service.outputFormat(this.hsva,this.cpOutputFormat,this.cpAlphaChannel),this.selectedColor=this.service.outputFormat(this.hsva,"rgba",null),this.format!==Go.CMYK)this.cmykColor="";else if("always"===this.cpAlphaChannel||"enabled"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel){let c=Math.round(100*this.cmyk.a)/100;this.cmykColor=`cmyka(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k},${c})`}else this.cmykColor=`cmyk(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k})`;this.slider=new _A((this.sliderH||this.hsva.h)*this.sliderDimMax.h-8,this.hsva.s*this.sliderDimMax.s-8,(1-this.hsva.v)*this.sliderDimMax.v-8,this.hsva.a*this.sliderDimMax.a-8),e&&l!==this.outputColor&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.outputColor))}}setDialogPosition(){if("inline"===this.cpDialogDisplay)this.position="relative";else{let r,e="static",i="",o=null,a=null,s=this.directiveElementRef.nativeElement.parentNode,l=this.dialogElement.nativeElement.offsetHeight;for(;null!==s&&"HTML"!==s.tagName;){if(r=window.getComputedStyle(s),e=r.getPropertyValue("position"),i=r.getPropertyValue("transform"),"static"!==e&&null===o&&(o=s),i&&"none"!==i&&null===a&&(a=s),"fixed"===e){o=a;break}s=s.parentNode}let c=this.createDialogBox(this.directiveElementRef.nativeElement,"fixed"!==e);if(this.useRootViewContainer||"fixed"===e&&(!o||o instanceof HTMLUnknownElement))this.top=c.top,this.left=c.left;else{null===o&&(o=s);let u=this.createDialogBox(o,"fixed"!==e);this.top=c.top-u.top,this.left=c.left-u.left}"fixed"===e&&(this.position="fixed");let d=this.cpPosition;"auto"===this.cpPosition&&(d=function(n,t){let e="right",i="bottom",{height:r,width:o}=n,{top:a,left:s}=t,l=a+t.height,c=s+t.width,d=a-r<0,u=l+r>(window.innerHeight||document.documentElement.clientHeight),p=s-o<0,h=c+o>(window.innerWidth||document.documentElement.clientWidth);return u&&(i="top"),d&&(i="bottom"),p&&(e="right"),h&&(e="left"),d&&u&&p&&h?["left","right","top","bottom"].reduce((M,y)=>n[M]>n[y]?M:y):p&&h?d?"bottom":u||a>l?"top":"bottom":d&&u?p?"right":h||s>c?"left":"right":`${i}-${e}`}(this.dialogElement.nativeElement.getBoundingClientRect(),this.cpTriggerElement.nativeElement.getBoundingClientRect())),"top"===d?(this.arrowTop=l-1,this.top-=l+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"bottom"===d?(this.top+=c.height+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"top-left"===d||"left-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left-=this.cpWidth+this.dialogArrowSize-2-this.dialogArrowOffset):"top-right"===d||"right-top"===d?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left+=c.width+this.dialogArrowSize-2-this.dialogArrowOffset):"left"===d||"bottom-left"===d||"left-bottom"===d?(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left-=this.cpWidth+this.dialogArrowSize-2):(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left+=c.width+this.dialogArrowSize-2),this.cpUsePosition=d}}isDescendant(e,i){let r=i.parentNode;for(;null!==r;){if(r===e)return!0;r=r.parentNode}return!1}createDialogBox(e,i){let{top:r,left:o}=e.getBoundingClientRect();return{top:r+(i?window.pageYOffset:0),left:o+(i?window.pageXOffset:0),width:e.offsetWidth,height:e.offsetHeight}}}return n.\u0275fac=function(e){return new(e||n)(C(ot),C(xe),C(Qt),C(Nt),C(fc),C(SV))},n.\u0275cmp=P({type:n,selectors:[["color-picker"]],viewQuery:function(e,i){if(1&e&&(Ue(WVe,7),Ue(qVe,7),Ue(XVe,7)),2&e){let r;be(r=ve())&&(i.dialogElement=r.first),be(r=ve())&&(i.hueSlider=r.first),be(r=ve())&&(i.alphaSlider=r.first)}},hostBindings:function(e,i){1&e&&A("keyup.esc",function(o){return i.handleEsc(o)},0,su)("keyup.enter",function(o){return i.handleEnter(o)},!1,su)},decls:30,vars:51,consts:[[1,"color-picker",3,"click"],["dialogPopup",""],[3,"class","top",4,"ngIf"],["class","saturation-lightness",3,"slider","rgX","rgY","background-color","newValue","dragStart","dragEnd",4,"ngIf"],[1,"hue-alpha","box"],[1,"left"],[1,"selected-color-background"],[1,"selected-color",3,"click"],["class","eyedropper-icon","xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",4,"ngIf"],["type","button",3,"class","disabled","click",4,"ngIf"],[1,"right"],["style","height: 16px;",4,"ngIf"],[1,"hue",3,"slider","rgX","newValue","dragStart","dragEnd"],["hueSlider",""],[1,"cursor"],[1,"value",3,"slider","rgX","newValue","dragStart","dragEnd"],["valueSlider",""],[1,"alpha",3,"slider","rgX","newValue","dragStart","dragEnd"],["alphaSlider",""],["class","cmyk-text",3,"display",4,"ngIf"],["class","hsla-text",3,"display",4,"ngIf"],["class","rgba-text",3,"display",4,"ngIf"],["class","hex-text",3,"hex-alpha","display",4,"ngIf"],["class","value-text",4,"ngIf"],["class","type-policy",4,"ngIf"],["class","preset-area",4,"ngIf"],["class","button-area",4,"ngIf"],["class","extra-template",4,"ngIf"],[1,"saturation-lightness",3,"slider","rgX","rgY","newValue","dragStart","dragEnd"],["xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",1,"eyedropper-icon"],["d","M0 0h24v24H0V0z","fill","none"],["d","M17.66 5.41l.92.92-2.69 2.69-.92-.92 2.69-2.69M17.67 3c-.26 0-.51.1-.71.29l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42l-2.34-2.34c-.2-.19-.45-.29-.7-.29zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"],["type","button",3,"disabled","click"],[2,"height","16px"],[1,"cmyk-text"],[1,"box"],["type","number","pattern","[0-9]*","min","0","max","100",3,"text","rg","value","keyup.enter","newValue"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue",4,"ngIf"],[4,"ngIf"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue"],[1,"hsla-text"],["type","number","pattern","[0-9]*","min","0","max","360",3,"text","rg","value","keyup.enter","newValue"],[1,"rgba-text"],["type","number","pattern","[0-9]*","min","0","max","255",3,"text","rg","value","keyup.enter","newValue"],[1,"hex-text"],[3,"text","value","blur","keyup.enter","newValue"],[1,"value-text"],[1,"type-policy"],[1,"type-policy-arrow",3,"click"],[1,"preset-area"],[1,"preset-label"],[3,"class",4,"ngIf"],["class","preset-color",3,"backgroundColor","click",4,"ngFor","ngForOf"],[1,"preset-color",3,"click"],[3,"class","click",4,"ngIf"],[3,"click"],[1,"button-area"],["type","button",3,"class","click",4,"ngIf"],["type","button",3,"click"],[1,"extra-template"],[4,"ngTemplateOutlet"]],template:function(e,i){1&e&&(f(0,"div",0,1),A("click",function(o){return o.stopPropagation()}),S(2,YVe,1,5,"div",2),S(3,QVe,2,8,"div",3),f(4,"div",4)(5,"div",5),k(6,"div",6),f(7,"div",7),A("click",function(){return i.eyeDropperSupported&&i.cpEyeDropper&&i.onEyeDropper()}),S(8,ZVe,3,0,"svg",8),g(),S(9,KVe,2,5,"button",9),g(),f(10,"div",10),S(11,JVe,1,0,"div",11),f(12,"div",12,13),A("newValue",function(o){return i.onHueChange(o)})("dragStart",function(){return i.onDragStart("hue")})("dragEnd",function(){return i.onDragEnd("hue")}),k(14,"div",14),g(),f(15,"div",15,16),A("newValue",function(o){return i.onValueChange(o)})("dragStart",function(){return i.onDragStart("value")})("dragEnd",function(){return i.onDragEnd("value")}),k(17,"div",14),g(),f(18,"div",17,18),A("newValue",function(o){return i.onAlphaChange(o)})("dragStart",function(){return i.onDragStart("alpha")})("dragEnd",function(){return i.onDragEnd("alpha")}),k(20,"div",14),g()()(),S(21,t4e,17,12,"div",19),S(22,r4e,14,10,"div",20),S(23,s4e,14,10,"div",21),S(24,d4e,8,7,"div",22),S(25,p4e,9,3,"div",23),S(26,h4e,3,0,"div",24),S(27,b4e,6,3,"div",25),S(28,x4e,3,2,"div",26),S(29,M4e,2,1,"div",27),g()),2&e&&(Bt("display",i.show?"block":"none")("visibility",i.hidden?"hidden":"visible")("top",i.top,"px")("left",i.left,"px")("position",i.position)("height",i.cpHeight,"px")("width",i.cpWidth,"px"),nt("open",i.show),v(2),b("ngIf","popup"===i.cpDialogDisplay),v(1),b("ngIf",1===(i.cpColorMode||1)),v(4),Bt("background-color",i.selectedColor)("cursor",i.eyeDropperSupported&&i.cpEyeDropper?"pointer":null),v(1),b("ngIf",i.eyeDropperSupported&&i.cpEyeDropper),v(1),b("ngIf",i.cpAddColorButton),v(2),b("ngIf","disabled"===i.cpAlphaChannel),v(1),Bt("display",1===(i.cpColorMode||1)?"block":"none"),b("rgX",1),v(2),Bt("left",null==i.slider?null:i.slider.h,"px"),v(1),Bt("display",2===(i.cpColorMode||1)?"block":"none"),b("rgX",1),v(2),Bt("right",null==i.slider?null:i.slider.v,"px"),v(1),Bt("display","disabled"===i.cpAlphaChannel?"none":"block")("background-color",i.alphaSliderColor),b("rgX",1),v(2),Bt("left",null==i.slider?null:i.slider.a,"px"),v(1),b("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),b("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),b("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),b("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),b("ngIf",!i.cpDisableInput&&2===(i.cpColorMode||1)),v(1),b("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),v(1),b("ngIf",(null==i.cpPresetColors?null:i.cpPresetColors.length)||i.cpAddColorButton),v(1),b("ngIf",i.cpOKButton||i.cpCancelButton),v(1),b("ngIf",i.cpExtraTemplate))},dependencies:[nn,Ne,eo,E4e,T4e],styles:['.color-picker{position:absolute;z-index:1000;width:230px;height:auto;border:#777 solid 1px;cursor:default;-webkit-user-select:none;user-select:none;background-color:#fff}.color-picker *{box-sizing:border-box;margin:0;font-size:11px}.color-picker input{width:0;height:26px;min-width:0;font-size:13px;text-align:center;color:#000}.color-picker input:invalid,.color-picker input:-moz-ui-invalid,.color-picker input:-moz-submit-invalid{box-shadow:none}.color-picker input::-webkit-inner-spin-button,.color-picker input::-webkit-outer-spin-button{margin:0;-webkit-appearance:none}.color-picker .arrow{position:absolute;z-index:999999;width:0;height:0;border-style:solid}.color-picker .arrow.arrow-top{left:8px;border-width:10px 5px;border-color:#777 rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-bottom{top:-20px;left:8px;border-width:10px 5px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) #777 rgba(0,0,0,0)}.color-picker .arrow.arrow-top-left,.color-picker .arrow.arrow-left-top{right:-21px;bottom:8px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-top-right,.color-picker .arrow.arrow-right-top{bottom:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-left,.color-picker .arrow.arrow-left-bottom,.color-picker .arrow.arrow-bottom-left{top:8px;right:-21px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-right,.color-picker .arrow.arrow-right-bottom,.color-picker .arrow.arrow-bottom-right{top:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .cursor{position:relative;width:16px;height:16px;border:#222 solid 2px;border-radius:50%;cursor:default}.color-picker .box{display:flex;padding:4px 8px}.color-picker .left{position:relative;padding:16px 8px}.color-picker .right{flex:1 1 auto;padding:12px 8px}.color-picker .button-area{padding:0 16px 16px;text-align:right}.color-picker .button-area button{margin-left:8px}.color-picker .preset-area{padding:4px 15px}.color-picker .preset-area .preset-label{overflow:hidden;width:100%;padding:4px;font-size:11px;white-space:nowrap;text-align:left;text-overflow:ellipsis;color:#555}.color-picker .preset-area .preset-color{position:relative;display:inline-block;width:18px;height:18px;margin:4px 6px 8px;border:#a9a9a9 solid 1px;border-radius:25%;cursor:pointer}.color-picker .preset-area .preset-empty-message{min-height:18px;margin-top:4px;margin-bottom:8px;font-style:italic;text-align:center}.color-picker .hex-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .hex-text .box{padding:0 24px 8px 8px}.color-picker .hex-text .box div{float:left;flex:1 1 auto;text-align:center;color:#555;clear:left}.color-picker .hex-text .box input{flex:1 1 auto;padding:1px;border:#a9a9a9 solid 1px}.color-picker .hex-alpha .box div:first-child,.color-picker .hex-alpha .box input:first-child{flex-grow:3;margin-right:8px}.color-picker .cmyk-text,.color-picker .hsla-text,.color-picker .rgba-text,.color-picker .value-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .cmyk-text .box,.color-picker .hsla-text .box,.color-picker .rgba-text .box{padding:0 24px 8px 8px}.color-picker .value-text .box{padding:0 8px 8px}.color-picker .cmyk-text .box div,.color-picker .hsla-text .box div,.color-picker .rgba-text .box div,.color-picker .value-text .box div{flex:1 1 auto;margin-right:8px;text-align:center;color:#555}.color-picker .cmyk-text .box div:last-child,.color-picker .hsla-text .box div:last-child,.color-picker .rgba-text .box div:last-child,.color-picker .value-text .box div:last-child{margin-right:0}.color-picker .cmyk-text .box input,.color-picker .hsla-text .box input,.color-picker .rgba-text .box input,.color-picker .value-text .box input{float:left;flex:1;padding:1px;margin:0 8px 0 0;border:#a9a9a9 solid 1px}.color-picker .cmyk-text .box input:last-child,.color-picker .hsla-text .box input:last-child,.color-picker .rgba-text .box input:last-child,.color-picker .value-text .box input:last-child{margin-right:0}.color-picker .hue-alpha{align-items:center;margin-bottom:3px}.color-picker .hue{direction:ltr;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwkUFWbCCAAAAFxJREFUaN7t0kEKg0AQAME2x83/n2qu5qCgD1iDhCoYdpnbQC9bbY1qVO/jvc6k3ad91s7/7F1/csgPrujuQ17BDYSFsBAWwgJhISyEBcJCWAgLhIWwEBYIi2f7Ar/1TCgFH2X9AAAAAElFTkSuQmCC)}.color-picker .value{direction:rtl;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAACTklEQVR42u3SYUcrABhA4U2SkmRJMmWSJklKJiWZZpKUJJskKUmaTFImKZOUzMySpGRmliRNJilJSpKSJEtmSpIpmWmSdO736/6D+x7OP3gUCoWCv1cqlSQlJZGcnExKSgqpqamkpaWRnp5ORkYGmZmZqFQqsrKyyM7OJicnh9zcXNRqNXl5eeTn56PRaCgoKKCwsJCioiK0Wi3FxcWUlJRQWlpKWVkZ5eXlVFRUUFlZiU6no6qqiurqampqaqitraWurg69Xk99fT0GgwGj0UhDQwONjY00NTXR3NxMS0sLra2ttLW10d7ejslkwmw209HRQWdnJ11dXXR3d9PT00Nvby99fX309/czMDDA4OAgFouFoaEhrFYrw8PDjIyMMDo6ytjYGDabjfHxcSYmJpicnGRqagq73c709DQzMzPMzs4yNzfH/Pw8DocDp9OJy+XC7XazsLDA4uIiS0tLLC8vs7KywurqKmtra3g8HrxeLz6fD7/fz/r6OhsbG2xubrK1tcX29jaBQICdnR2CwSC7u7vs7e2xv7/PwcEBh4eHHB0dcXx8zMnJCaenp5ydnXF+fs7FxQWXl5dcXV1xfX3Nzc0Nt7e33N3dEQqFuL+/5+HhgXA4TCQS4fHxkaenJ56fn3l5eeH19ZVoNMrb2xvv7+98fHwQi8WIx+N8fn6SSCT4+vri+/ubn58ffn9/+VcKgSWwBJbAElgCS2AJLIElsASWwBJYAktgCSyBJbAElsASWAJLYAksgSWwBJbAElgCS2AJLIElsP4/WH8AmJ5Z6jHS4h8AAAAASUVORK5CYII=)}.color-picker .alpha{direction:ltr;width:100%;height:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwYQlZMa3gAAAWVJREFUaN7tmEGO6jAQRCsOArHgBpyAJYGjcGocxAm4A2IHpmoWE0eBH+ezmFlNvU06shJ3W6VEelWMUQAIIF9f6qZpimsA1LYtS2uF51/u27YVAFZVRUkEoGHdPV/sIcbIEIIkUdI/9Xa7neyv61+SWFUVAVCSct00TWn2fv6u3+Ecfd3tXzy/0+nEUu+SPjo/kqzrmiQpScN6v98XewfA8/lMkiLJ2WxGSUopcT6fM6U0NX9/frfbjev1WtfrlZfLhYfDQQHG/AIOlnGwjINlHCxjHCzjYJm/TJWdCwquJXseFFzGwDNNeiKMOJTO8xQdDQaeB29+K9efeLaBo9J7vdvtJj1RjFFjfiv7qv95tjx/7leSQgh93e1ffMeIp6O+YQjho/N791t1XVOSSI7N//K+4/GoxWLBx+PB5/Op5XLJ+/3OlJJWqxU3m83ovv5iGf8KjYNlHCxjHCzjYBkHy5gf5gusvQU7U37jTAAAAABJRU5ErkJggg==)}.color-picker .type-policy{position:absolute;top:218px;right:12px;width:16px;height:24px;background-size:8px 16px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAgCAYAAAAffCjxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACewAAAnsB01CO3AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIASURBVEiJ7ZY9axRRFIafsxMStrLQJpAgpBFhi+C9w1YSo00I6RZ/g9vZpBf/QOr4GyRgkSKNSrAadsZqQGwCkuAWyRZJsySwvhZ7N/vhzrgbLH3Ld8597jlzz50zJokyxXH8DqDVar0qi6v8BbItqSGpEcfxdlmsFWXkvX8AfAVWg3UKPEnT9GKujMzsAFgZsVaCN1VTQd77XUnrgE1kv+6935268WRpzrnHZvYRWC7YvC3pRZZl3wozqtVqiyH9IgjAspkd1Gq1xUJQtVrdB9ZKIAOthdg/Qc65LUk7wNIMoCVJO865rYFhkqjX6/d7vV4GPJwBMqofURS5JEk6FYBer/eeYb/Mo9WwFnPOvQbeAvfuAAK4BN4sAJtAG/gJIElmNuiJyba3EGNmZiPeZuEVmVell/Y/6N+CzDn3AXhEOOo7Hv/3BeAz8IzQkMPnJbuPx1wC+yYJ7/0nYIP5S/0FHKdp+rwCEEXRS/rf5Hl1Gtb2M0iSpCOpCZzPATmX1EySpHMLAsiy7MjMDoHrGSDXZnaYZdnRwBh7J91utwmczAA6CbG3GgPleX4jqUH/a1CktqRGnuc3hSCAMB32gKspkCtgb3KCQMmkjeP4WNJThrNNZval1WptTIsv7JtQ4tmIdRa8qSoEpWl6YWZNoAN0zKxZNPehpLSBZv2t+Q0CJ9lLnARQLAAAAABJRU5ErkJggg==);background-repeat:no-repeat;background-position:center}.color-picker .type-policy .type-policy-arrow{display:block;width:100%;height:50%}.color-picker .selected-color{position:absolute;top:16px;left:8px;width:40px;height:40px;border:1px solid #a9a9a9;border-radius:50%}.color-picker .selected-color-background{width:40px;height:40px;border-radius:50%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAh0lEQVRYR+2W0QlAMQgD60zdfwOdqa8TmI/wQMr5K0I5bZLIzLOa2nt37VVVbd+dDx5obgCC3KBLwJ2ff4PnVidkf+ucIhw80HQaCLo3DMH3CRK3iFsmAWVl6hPNDwt8EvNE5q+YuEXcMgkonVM6SdyCoEvAnZ8v1Hjx817MilmxSUB5rdLJDycZgUAZUch/AAAAAElFTkSuQmCC)}.color-picker .saturation-lightness{direction:ltr;width:100%;height:130px;border:none;cursor:pointer;touch-action:manipulation;background-size:100% 100%;background-image:url(data:image/png;base64,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)}.color-picker .cp-add-color-button-class{position:absolute;display:inline;padding:0;margin:3px -3px;border:0;cursor:pointer;background:transparent}.color-picker .cp-add-color-button-class:hover{text-decoration:underline}.color-picker .cp-add-color-button-class:disabled{cursor:not-allowed;color:#999}.color-picker .cp-add-color-button-class:disabled:hover{text-decoration:none}.color-picker .cp-remove-color-button-class{position:absolute;top:-5px;right:-5px;display:block;width:10px;height:10px;border-radius:50%;cursor:pointer;text-align:center;background:#fff;box-shadow:1px 1px 5px #333}.color-picker .cp-remove-color-button-class:before{content:"x";position:relative;bottom:3.5px;display:inline-block;font-size:10px}.color-picker .eyedropper-icon{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);fill:#fff;mix-blend-mode:exclusion}\n'],encapsulation:2}),n})(),Bne=(()=>{class n{constructor(e,i,r,o,a,s){this.injector=e,this.cfr=i,this.appRef=r,this.vcRef=o,this.elRef=a,this._service=s,this.dialogCreated=!1,this.ignoreChanges=!1,this.viewAttachedToAppRef=!1,this.cpWidth="230px",this.cpHeight="auto",this.cpToggle=!1,this.cpDisabled=!1,this.cpIgnoredElements=[],this.cpFallbackColor="",this.cpColorMode="color",this.cpCmykEnabled=!1,this.cpOutputFormat="auto",this.cpAlphaChannel="enabled",this.cpDisableInput=!1,this.cpDialogDisplay="popup",this.cpSaveClickOutside=!0,this.cpCloseClickOutside=!0,this.cpUseRootViewContainer=!1,this.cpPosition="auto",this.cpPositionOffset="0%",this.cpPositionRelativeToArrow=!1,this.cpOKButton=!1,this.cpOKButtonText="OK",this.cpOKButtonClass="cp-ok-button-class",this.cpCancelButton=!1,this.cpCancelButtonText="Cancel",this.cpCancelButtonClass="cp-cancel-button-class",this.cpEyeDropper=!1,this.cpPresetLabel="Preset colors",this.cpPresetColorsClass="cp-preset-colors-class",this.cpMaxPresetColorsLength=6,this.cpPresetEmptyMessage="No colors added",this.cpPresetEmptyMessageClass="preset-empty-message",this.cpAddColorButton=!1,this.cpAddColorButtonText="Add color",this.cpAddColorButtonClass="cp-add-color-button-class",this.cpRemoveColorButtonClass="cp-remove-color-button-class",this.cpInputChange=new F(!0),this.cpToggleChange=new F(!0),this.cpSliderChange=new F(!0),this.cpSliderDragEnd=new F(!0),this.cpSliderDragStart=new F(!0),this.colorPickerOpen=new F(!0),this.colorPickerClose=new F(!0),this.colorPickerCancel=new F(!0),this.colorPickerSelect=new F(!0),this.colorPickerChange=new F(!1),this.cpCmykColorChange=new F(!0),this.cpPresetColorsChange=new F(!0)}handleClick(){this.inputFocus()}handleFocus(){this.inputFocus()}handleInput(e){this.inputChange(e)}ngOnDestroy(){null!=this.cmpRef&&(this.viewAttachedToAppRef&&this.appRef.detachView(this.cmpRef.hostView),this.cmpRef.destroy(),this.cmpRef=null,this.dialog=null)}ngOnChanges(e){e.cpToggle&&!this.cpDisabled&&(e.cpToggle.currentValue?this.openDialog():e.cpToggle.currentValue||this.closeDialog()),e.colorPicker&&(this.dialog&&!this.ignoreChanges&&("inline"===this.cpDialogDisplay&&this.dialog.setInitialColor(e.colorPicker.currentValue),this.dialog.setColorFromString(e.colorPicker.currentValue,!1),this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay&&this.cmpRef.changeDetectorRef.detectChanges()),this.ignoreChanges=!1),(e.cpPresetLabel||e.cpPresetColors)&&this.dialog&&this.dialog.setPresetConfig(this.cpPresetLabel,this.cpPresetColors)}openDialog(){if(this.dialogCreated)this.dialog&&this.dialog.openDialog(this.colorPicker);else{let e=this.vcRef;if(this.dialogCreated=!0,this.viewAttachedToAppRef=!1,this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay){let o=this.injector.get(this.appRef.componentTypes[0],wi.NULL);o!==wi.NULL?e=o.vcRef||o.viewContainerRef||this.vcRef:this.viewAttachedToAppRef=!0}let i=this.cfr.resolveComponentFactory(D4e);if(this.viewAttachedToAppRef)this.cmpRef=i.create(this.injector),this.appRef.attachView(this.cmpRef.hostView),document.body.appendChild(this.cmpRef.hostView.rootNodes[0]);else{let r=wi.create({providers:[],parent:e.injector});this.cmpRef=e.createComponent(i,0,r,[])}this.cmpRef.instance.setupDialog(this,this.elRef,this.colorPicker,this.cpWidth,this.cpHeight,this.cpDialogDisplay,this.cpFallbackColor,this.cpColorMode,this.cpCmykEnabled,this.cpAlphaChannel,this.cpOutputFormat,this.cpDisableInput,this.cpIgnoredElements,this.cpSaveClickOutside,this.cpCloseClickOutside,this.cpUseRootViewContainer,this.cpPosition,this.cpPositionOffset,this.cpPositionRelativeToArrow,this.cpPresetLabel,this.cpPresetColors,this.cpPresetColorsClass,this.cpMaxPresetColorsLength,this.cpPresetEmptyMessage,this.cpPresetEmptyMessageClass,this.cpOKButton,this.cpOKButtonClass,this.cpOKButtonText,this.cpCancelButton,this.cpCancelButtonClass,this.cpCancelButtonText,this.cpAddColorButton,this.cpAddColorButtonClass,this.cpAddColorButtonText,this.cpRemoveColorButtonClass,this.cpEyeDropper,this.elRef,this.cpExtraTemplate),this.dialog=this.cmpRef.instance,this.vcRef!==e&&this.cmpRef.changeDetectorRef.detectChanges()}}closeDialog(){this.dialog&&"popup"===this.cpDialogDisplay&&this.dialog.closeDialog()}cmykChanged(e){this.cpCmykColorChange.emit(e)}stateChanged(e){this.cpToggleChange.emit(e),e?this.colorPickerOpen.emit(this.colorPicker):this.colorPickerClose.emit(this.colorPicker)}colorChanged(e,i=!0){this.ignoreChanges=i,this.colorPickerChange.emit(e)}colorSelected(e){this.colorPickerSelect.emit(e)}colorCanceled(){this.colorPickerCancel.emit()}inputFocus(){let e=this.elRef.nativeElement,i=this.cpIgnoredElements.filter(r=>r===e);!this.cpDisabled&&!i.length&&(typeof document<"u"&&e===document.activeElement?this.openDialog():this.dialog&&this.dialog.show?this.closeDialog():this.openDialog())}inputChange(e){this.dialog?this.dialog.setColorFromString(e.target.value,!0):(this.colorPicker=e.target.value,this.colorPickerChange.emit(this.colorPicker))}inputChanged(e){this.cpInputChange.emit(e)}sliderChanged(e){this.cpSliderChange.emit(e)}sliderDragEnd(e){this.cpSliderDragEnd.emit(e)}sliderDragStart(e){this.cpSliderDragStart.emit(e)}presetColorsChanged(e){this.cpPresetColorsChange.emit(e)}}return n.\u0275fac=function(e){return new(e||n)(C(wi),C(ho),C(gc),C(ei),C(xe),C(SV))},n.\u0275dir=Me({type:n,selectors:[["","colorPicker",""]],hostBindings:function(e,i){1&e&&A("click",function(){return i.handleClick()})("focus",function(){return i.handleFocus()})("input",function(o){return i.handleInput(o)})},inputs:{colorPicker:"colorPicker",cpWidth:"cpWidth",cpHeight:"cpHeight",cpToggle:"cpToggle",cpDisabled:"cpDisabled",cpIgnoredElements:"cpIgnoredElements",cpFallbackColor:"cpFallbackColor",cpColorMode:"cpColorMode",cpCmykEnabled:"cpCmykEnabled",cpOutputFormat:"cpOutputFormat",cpAlphaChannel:"cpAlphaChannel",cpDisableInput:"cpDisableInput",cpDialogDisplay:"cpDialogDisplay",cpSaveClickOutside:"cpSaveClickOutside",cpCloseClickOutside:"cpCloseClickOutside",cpUseRootViewContainer:"cpUseRootViewContainer",cpPosition:"cpPosition",cpPositionOffset:"cpPositionOffset",cpPositionRelativeToArrow:"cpPositionRelativeToArrow",cpOKButton:"cpOKButton",cpOKButtonText:"cpOKButtonText",cpOKButtonClass:"cpOKButtonClass",cpCancelButton:"cpCancelButton",cpCancelButtonText:"cpCancelButtonText",cpCancelButtonClass:"cpCancelButtonClass",cpEyeDropper:"cpEyeDropper",cpPresetLabel:"cpPresetLabel",cpPresetColors:"cpPresetColors",cpPresetColorsClass:"cpPresetColorsClass",cpMaxPresetColorsLength:"cpMaxPresetColorsLength",cpPresetEmptyMessage:"cpPresetEmptyMessage",cpPresetEmptyMessageClass:"cpPresetEmptyMessageClass",cpAddColorButton:"cpAddColorButton",cpAddColorButtonText:"cpAddColorButtonText",cpAddColorButtonClass:"cpAddColorButtonClass",cpRemoveColorButtonClass:"cpRemoveColorButtonClass",cpExtraTemplate:"cpExtraTemplate"},outputs:{cpInputChange:"cpInputChange",cpToggleChange:"cpToggleChange",cpSliderChange:"cpSliderChange",cpSliderDragEnd:"cpSliderDragEnd",cpSliderDragStart:"cpSliderDragStart",colorPickerOpen:"colorPickerOpen",colorPickerClose:"colorPickerClose",colorPickerCancel:"colorPickerCancel",colorPickerSelect:"colorPickerSelect",colorPickerChange:"colorPickerChange",cpCmykColorChange:"cpCmykColorChange",cpPresetColorsChange:"cpPresetColorsChange"},exportAs:["ngxColorPicker"],features:[qt]}),n})(),Vne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[SV],imports:[De]}),n})();function R4e(n,t){1&n&&(f(0,"span",8),Tt(1,1),g())}function P4e(n,t){1&n&&(f(0,"span",9),Tt(1,2),g())}var Une=["*",[["mat-chip-avatar"],["","matChipAvatar",""]],[["mat-chip-trailing-icon"],["","matChipRemove",""],["","matChipTrailingIcon",""]]],jne=["*","mat-chip-avatar, [matChipAvatar]","mat-chip-trailing-icon,[matChipRemove],[matChipTrailingIcon]"];function k4e(n,t){1&n&&(f(0,"span",9),Tt(1,1),f(2,"span",10),qn(),f(3,"svg",11),k(4,"path",12),g()()())}function O4e(n,t){1&n&&(f(0,"span",13),Tt(1,2),g())}var Gne=["*"],RV=new te("mat-chips-default-options"),Hne=new te("MatChipAvatar"),zne=new te("MatChipTrailingIcon"),EV=new te("MatChipRemove"),PV=new te("MatChip"),L4e=Dc(class{},-1),vA=(()=>{class n extends L4e{get disabled(){return this._disabled||this._parentChip.disabled}set disabled(e){this._disabled=vt(e)}_getDisabledAttribute(){return this.disabled&&!this._allowFocusWhenDisabled?"":null}_getTabindex(){return this.disabled&&!this._allowFocusWhenDisabled||!this.isInteractive?null:this.tabIndex.toString()}constructor(e,i){super(),this._elementRef=e,this._parentChip=i,this.isInteractive=!0,this._isPrimary=!0,this._disabled=!1,this._allowFocusWhenDisabled=!1,"BUTTON"===e.nativeElement.nodeName&&e.nativeElement.setAttribute("type","button")}focus(){this._elementRef.nativeElement.focus()}_handleClick(e){!this.disabled&&this.isInteractive&&this._isPrimary&&(e.preventDefault(),this._parentChip._handlePrimaryActionInteraction())}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!this.disabled&&this.isInteractive&&this._isPrimary&&!this._parentChip._isEditing&&(e.preventDefault(),this._parentChip._handlePrimaryActionInteraction())}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(PV))},n.\u0275dir=Me({type:n,selectors:[["","matChipAction",""]],hostAttrs:[1,"mdc-evolution-chip__action","mat-mdc-chip-action"],hostVars:9,hostBindings:function(e,i){1&e&&A("click",function(o){return i._handleClick(o)})("keydown",function(o){return i._handleKeydown(o)}),2&e&&(Be("tabindex",i._getTabindex())("disabled",i._getDisabledAttribute())("aria-disabled",i.disabled),nt("mdc-evolution-chip__action--primary",i._isPrimary)("mdc-evolution-chip__action--presentational",!i.isInteractive)("mdc-evolution-chip__action--trailing",!i._isPrimary))},inputs:{disabled:"disabled",tabIndex:"tabIndex",isInteractive:"isInteractive",_allowFocusWhenDisabled:"_allowFocusWhenDisabled"},features:[Xe]}),n})(),Wne=(()=>{class n extends vA{constructor(){super(...arguments),this._isPrimary=!1}_handleClick(e){this.disabled||(e.stopPropagation(),e.preventDefault(),this._parentChip.remove())}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!this.disabled&&(e.stopPropagation(),e.preventDefault(),this._parentChip.remove())}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275dir=Me({type:n,selectors:[["","matChipRemove",""]],hostAttrs:["role","button",1,"mat-mdc-chip-remove","mat-mdc-chip-trailing-icon","mat-mdc-focus-indicator","mdc-evolution-chip__icon","mdc-evolution-chip__icon--trailing"],hostVars:1,hostBindings:function(e,i){2&e&&Be("aria-hidden",null)},features:[Vt([{provide:EV,useExisting:n}]),Xe]}),n})(),B4e=0,V4e=Dc(Ko(go(ao(class{constructor(n){this._elementRef=n}})),"primary"),-1),eC=(()=>{class n extends V4e{_hasFocus(){return this._hasFocusInternal}get value(){return void 0!==this._value?this._value:this._textElement.textContent.trim()}set value(e){this._value=e}get removable(){return this._removable}set removable(e){this._removable=vt(e)}get highlighted(){return this._highlighted}set highlighted(e){this._highlighted=vt(e)}constructor(e,i,r,o,a,s,l,c){super(i),this._changeDetectorRef=e,this._ngZone=r,this._focusMonitor=o,this._globalRippleOptions=l,this._isRippleCentered=!1,this._onFocus=new Ee,this._onBlur=new Ee,this.role=null,this._hasFocusInternal=!1,this.id="mat-mdc-chip-"+B4e++,this.ariaLabel=null,this.ariaDescription=null,this._ariaDescriptionId=`${this.id}-aria-description`,this._removable=!0,this._highlighted=!1,this.removed=new F,this.destroyed=new F,this.basicChipAttrName="mat-basic-chip",this._document=a,this._animationsDisabled="NoopAnimations"===s,null!=c&&(this.tabIndex=parseInt(c)??this.defaultTabIndex),this._monitorFocus()}ngOnInit(){let e=this._elementRef.nativeElement;this._isBasicChip=e.hasAttribute(this.basicChipAttrName)||e.tagName.toLowerCase()===this.basicChipAttrName}ngAfterViewInit(){this._textElement=this._elementRef.nativeElement.querySelector(".mat-mdc-chip-action-label"),this._pendingFocus&&(this._pendingFocus=!1,this.focus())}ngAfterContentInit(){this._actionChanges=tn(this._allLeadingIcons.changes,this._allTrailingIcons.changes,this._allRemoveIcons.changes).subscribe(()=>this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._actionChanges?.unsubscribe(),this.destroyed.emit({chip:this}),this.destroyed.complete()}remove(){this.removable&&this.removed.emit({chip:this})}_isRippleDisabled(){return this.disabled||this.disableRipple||this._animationsDisabled||this._isBasicChip||!!this._globalRippleOptions?.disabled}_hasTrailingIcon(){return!(!this.trailingIcon&&!this.removeIcon)}_handleKeydown(e){(8===e.keyCode||46===e.keyCode)&&(e.preventDefault(),this.remove())}focus(){this.disabled||(this.primaryAction?this.primaryAction.focus():this._pendingFocus=!0)}_getSourceAction(e){return this._getActions().find(i=>{let r=i._elementRef.nativeElement;return r===e||r.contains(e)})}_getActions(){let e=[];return this.primaryAction&&e.push(this.primaryAction),this.removeIcon&&e.push(this.removeIcon),this.trailingIcon&&e.push(this.trailingIcon),e}_handlePrimaryActionInteraction(){}_monitorFocus(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{let i=null!==e;i!==this._hasFocusInternal&&(this._hasFocusInternal=i,i?this._onFocus.next({chip:this}):this._ngZone.onStable.pipe(Lt(1)).subscribe(()=>this._ngZone.run(()=>this._onBlur.next({chip:this}))))})}}return n.\u0275fac=function(e){return new(e||n)(C(Qt),C(xe),C(ot),C(fo),C(Nt),C(pi,8),C(Th,8),Mo("tabindex"))},n.\u0275cmp=P({type:n,selectors:[["mat-basic-chip"],["","mat-basic-chip",""],["mat-chip"],["","mat-chip",""]],contentQueries:function(e,i,r){if(1&e&&(Bn(r,Hne,5),Bn(r,zne,5),Bn(r,EV,5),Bn(r,Hne,5),Bn(r,zne,5),Bn(r,EV,5)),2&e){let o;be(o=ve())&&(i.leadingIcon=o.first),be(o=ve())&&(i.trailingIcon=o.first),be(o=ve())&&(i.removeIcon=o.first),be(o=ve())&&(i._allLeadingIcons=o),be(o=ve())&&(i._allTrailingIcons=o),be(o=ve())&&(i._allRemoveIcons=o)}},viewQuery:function(e,i){if(1&e&&(Ue(Ki,5),Ue(vA,5)),2&e){let r;be(r=ve())&&(i.ripple=r.first),be(r=ve())&&(i.primaryAction=r.first)}},hostAttrs:[1,"mat-mdc-chip"],hostVars:30,hostBindings:function(e,i){1&e&&A("keydown",function(o){return i._handleKeydown(o)}),2&e&&(wo("id",i.id),Be("role",i.role)("tabindex",i.role?i.tabIndex:null)("aria-label",i.ariaLabel),nt("mdc-evolution-chip",!i._isBasicChip)("mdc-evolution-chip--disabled",i.disabled)("mdc-evolution-chip--with-trailing-action",i._hasTrailingIcon())("mdc-evolution-chip--with-primary-graphic",i.leadingIcon)("mdc-evolution-chip--with-primary-icon",i.leadingIcon)("mdc-evolution-chip--with-avatar",i.leadingIcon)("mat-mdc-chip-with-avatar",i.leadingIcon)("mat-mdc-chip-highlighted",i.highlighted)("mat-mdc-chip-disabled",i.disabled)("mat-mdc-basic-chip",i._isBasicChip)("mat-mdc-standard-chip",!i._isBasicChip)("mat-mdc-chip-with-trailing-icon",i._hasTrailingIcon())("_mat-animation-noopable",i._animationsDisabled))},inputs:{color:"color",disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex",role:"role",id:"id",ariaLabel:["aria-label","ariaLabel"],ariaDescription:["aria-description","ariaDescription"],value:"value",removable:"removable",highlighted:"highlighted"},outputs:{removed:"removed",destroyed:"destroyed"},exportAs:["matChip"],features:[Vt([{provide:PV,useExisting:n}]),Xe],ngContentSelectors:jne,decls:9,vars:6,consts:[["matRipple","",1,"mat-mdc-chip-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-mdc-chip-focus-overlay"],[1,"mdc-evolution-chip__cell","mdc-evolution-chip__cell--primary"],["matChipAction","",3,"isInteractive"],["class","mdc-evolution-chip__graphic mat-mdc-chip-graphic",4,"ngIf"],[1,"mdc-evolution-chip__text-label","mat-mdc-chip-action-label"],[1,"mat-mdc-chip-primary-focus-indicator","mat-mdc-focus-indicator"],["class","mdc-evolution-chip__cell mdc-evolution-chip__cell--trailing",4,"ngIf"],[1,"mdc-evolution-chip__graphic","mat-mdc-chip-graphic"],[1,"mdc-evolution-chip__cell","mdc-evolution-chip__cell--trailing"]],template:function(e,i){1&e&&(fn(Une),k(0,"span",0)(1,"span",1),f(2,"span",2)(3,"span",3),S(4,R4e,2,0,"span",4),f(5,"span",5),Tt(6),k(7,"span",6),g()()(),S(8,P4e,2,0,"span",7)),2&e&&(b("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i._isRippleCentered)("matRippleTrigger",i._elementRef.nativeElement),v(3),b("isInteractive",!1),v(1),b("ngIf",i.leadingIcon),v(4),b("ngIf",i._hasTrailingIcon()))},dependencies:[Ne,Ki,vA],styles:['.mdc-evolution-chip,.mdc-evolution-chip__cell,.mdc-evolution-chip__action{display:inline-flex;align-items:center}.mdc-evolution-chip{position:relative;max-width:100%}.mdc-evolution-chip .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-evolution-chip__cell,.mdc-evolution-chip__action{height:100%}.mdc-evolution-chip__cell--primary{overflow-x:hidden}.mdc-evolution-chip__cell--trailing{flex:1 0 auto}.mdc-evolution-chip__action{align-items:center;background:none;border:none;box-sizing:content-box;cursor:pointer;display:inline-flex;justify-content:center;outline:none;padding:0;text-decoration:none;color:inherit}.mdc-evolution-chip__action--presentational{cursor:auto}.mdc-evolution-chip--disabled,.mdc-evolution-chip__action:disabled{pointer-events:none}.mdc-evolution-chip__action--primary{overflow-x:hidden}.mdc-evolution-chip__action--trailing{position:relative;overflow:visible}.mdc-evolution-chip__action--primary:before{box-sizing:border-box;content:"";height:100%;left:0;position:absolute;pointer-events:none;top:0;width:100%;z-index:1}.mdc-evolution-chip--touch{margin-top:8px;margin-bottom:8px}.mdc-evolution-chip__action-touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-evolution-chip__text-label{white-space:nowrap;user-select:none;text-overflow:ellipsis;overflow:hidden}.mdc-evolution-chip__graphic{align-items:center;display:inline-flex;justify-content:center;overflow:hidden;pointer-events:none;position:relative;flex:1 0 auto}.mdc-evolution-chip__checkmark{position:absolute;opacity:0;top:50%;left:50%}.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--selected):not(.mdc-evolution-chip--with-primary-icon) .mdc-evolution-chip__graphic{width:0}.mdc-evolution-chip__checkmark-background{opacity:0}.mdc-evolution-chip__checkmark-svg{display:block}.mdc-evolution-chip__checkmark-path{stroke-width:2px;stroke-dasharray:29.7833385;stroke-dashoffset:29.7833385;stroke:currentColor}.mdc-evolution-chip--selecting .mdc-evolution-chip__graphic{transition:width 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--selecting .mdc-evolution-chip__checkmark{transition:transform 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-75%, -50%)}.mdc-evolution-chip--selecting .mdc-evolution-chip__checkmark-path{transition:stroke-dashoffset 150ms 45ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__graphic{transition:width 100ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__checkmark{transition:opacity 50ms 0ms linear,transform 100ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-75%, -50%)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}.mdc-evolution-chip--selecting-with-primary-icon .mdc-evolution-chip__icon--primary{transition:opacity 75ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--selecting-with-primary-icon .mdc-evolution-chip__checkmark-path{transition:stroke-dashoffset 150ms 75ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__icon--primary{transition:opacity 150ms 75ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__checkmark{transition:opacity 75ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-50%, -50%)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}.mdc-evolution-chip--selected .mdc-evolution-chip__icon--primary{opacity:0}.mdc-evolution-chip--selected .mdc-evolution-chip__checkmark{transform:translate(-50%, -50%);opacity:1}.mdc-evolution-chip--selected .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}@keyframes mdc-evolution-chip-enter{from{transform:scale(0.8);opacity:.4}to{transform:scale(1);opacity:1}}.mdc-evolution-chip--enter{animation:mdc-evolution-chip-enter 100ms 0ms cubic-bezier(0, 0, 0.2, 1)}@keyframes mdc-evolution-chip-exit{from{opacity:1}to{opacity:0}}.mdc-evolution-chip--exit{animation:mdc-evolution-chip-exit 75ms 0ms cubic-bezier(0.4, 0, 1, 1)}.mdc-evolution-chip--hidden{opacity:0;pointer-events:none;transition:width 150ms 0ms cubic-bezier(0.4, 0, 1, 1)}.mat-mdc-standard-chip .mdc-evolution-chip__checkmark{height:20px;width:20px}.mat-mdc-standard-chip .mdc-evolution-chip__icon--trailing{height:18px;width:18px;font-size:18px}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary{padding-left:12px;padding-right:12px}[dir=rtl] .mat-mdc-standard-chip .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:12px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic{padding-left:6px;padding-right:6px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic[dir=rtl]{padding-left:6px;padding-right:6px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary{padding-left:0;padding-right:12px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:0}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:12px;padding-right:0}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:12px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic{padding-left:6px;padding-right:6px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic[dir=rtl]{padding-left:6px;padding-right:6px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:0;padding-right:0}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:0}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-selected-icon-color, currentColor)}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic{padding-left:4px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic[dir=rtl]{padding-left:8px;padding-right:4px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary{padding-left:0;padding-right:12px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:0}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic{padding-left:4px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic[dir=rtl]{padding-left:8px;padding-right:4px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:0;padding-right:0}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:0}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--with-primary-icon){--mdc-chip-graphic-selected-width:24px}.mdc-evolution-chip--with-avatar .mdc-evolution-chip__graphic{height:24px;width:24px;font-size:24px}.mdc-evolution-chip--with-avatar .mdc-evolution-chip__icon--primary{height:24px;width:24px;font-size:24px}.mat-mdc-standard-chip{-webkit-tap-highlight-color:rgba(0,0,0,0);border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px);height:var(--mdc-chip-container-height, 32px)}.mat-mdc-standard-chip .mdc-evolution-chip__ripple{border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px)}.mat-mdc-standard-chip .mdc-evolution-chip__icon--primary{border-radius:var(--mdc-chip-with-avatar-avatar-shape-radius, 14px 14px 14px 14px)}.mat-mdc-standard-chip.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--with-primary-icon){--mdc-chip-graphic-selected-width:var(--mdc-chip-with-avatar-avatar-size, 28px)}.mat-mdc-standard-chip .mdc-evolution-chip__graphic{height:var(--mdc-chip-with-avatar-avatar-size, 28px);width:var(--mdc-chip-with-avatar-avatar-size, 28px);font-size:var(--mdc-chip-with-avatar-avatar-size, 28px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-outline-width, 1px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-outline-width, 1px)}.mat-mdc-standard-chip.mdc-evolution-chip--selected .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-selected-outline-width, 0)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--selected) .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-unselected-outline-width, 1px)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled){background-color:var(--mdc-chip-elevated-container-color, transparent)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled{background-color:var(--mdc-chip-elevated-disabled-container-color, transparent)}.mat-mdc-standard-chip.mdc-evolution-chip--selected.mdc-evolution-chip--disabled{background-color:var(--mdc-chip-elevated-disabled-container-color, transparent)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__text-label{color:var(--mdc-chip-label-text-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__text-label{color:var(--mdc-chip-disabled-label-text-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--selected.mdc-evolution-chip--disabled .mdc-evolution-chip__text-label{color:var(--mdc-chip-disabled-label-text-color, currentColor)}.mat-mdc-standard-chip .mdc-evolution-chip__icon--primary{height:var(--mdc-chip-with-icon-icon-size, 18px);width:var(--mdc-chip-with-icon-icon-size, 18px);font-size:var(--mdc-chip-with-icon-icon-size, 18px)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__icon--primary{color:var(--mdc-chip-with-icon-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__icon--primary{color:var(--mdc-chip-with-icon-disabled-icon-color, currentColor)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-selected-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-disabled-icon-color, currentColor)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__icon--trailing{color:var(--mdc-chip-with-trailing-icon-trailing-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__icon--trailing{color:var(--mdc-chip-with-trailing-icon-disabled-trailing-icon-color, currentColor)}.cdk-high-contrast-active .mat-mdc-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-mdc-standard-chip .mdc-evolution-chip__checkmark-path{stroke:CanvasText !important}.mat-mdc-standard-chip.mdc-evolution-chip--disabled{opacity:.4}.mat-mdc-standard-chip .mdc-evolution-chip__cell--primary,.mat-mdc-standard-chip .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip .mat-mdc-chip-action-label{overflow:visible}.mat-mdc-standard-chip .mdc-evolution-chip__cell--primary{width:100%}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary{font:inherit;letter-spacing:inherit;white-space:inherit}.mat-mdc-standard-chip .mat-mdc-chip-graphic,.mat-mdc-standard-chip .mat-mdc-chip-trailing-icon{box-sizing:content-box}.mat-mdc-standard-chip._mat-animation-noopable,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__graphic,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__checkmark,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__checkmark-path{transition-duration:1ms;animation-duration:1ms}.mat-mdc-basic-chip .mdc-evolution-chip__action--primary{font:inherit}.mat-mdc-chip-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;opacity:0;border-radius:inherit;transition:opacity 150ms linear}._mat-animation-noopable .mat-mdc-chip-focus-overlay{transition:none}.mat-mdc-basic-chip .mat-mdc-chip-focus-overlay{display:none}.mat-mdc-chip:hover .mat-mdc-chip-focus-overlay{opacity:.04}.mat-mdc-chip.cdk-focused .mat-mdc-chip-focus-overlay{opacity:.12}.mat-mdc-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-chip-avatar{text-align:center;line-height:1;color:var(--mdc-chip-with-icon-icon-color, currentColor)}.mat-mdc-chip{position:relative;z-index:0}.mat-mdc-chip-action-label{text-align:left;z-index:1}[dir=rtl] .mat-mdc-chip-action-label{text-align:right}.mat-mdc-chip.mdc-evolution-chip--with-trailing-action .mat-mdc-chip-action-label{position:relative}.mat-mdc-chip-action-label .mat-mdc-chip-primary-focus-indicator{position:absolute;top:0;right:0;bottom:0;left:0;pointer-events:none}.mat-mdc-chip-action-label .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-chip-remove{opacity:.54}.mat-mdc-chip-remove:focus{opacity:1}.mat-mdc-chip-remove::before{margin:calc(var(--mat-mdc-focus-indicator-border-width, 3px) * -1);left:8px;right:8px}.mat-mdc-chip-remove .mat-icon{width:inherit;height:inherit;font-size:inherit;box-sizing:content-box}.mat-chip-edit-input{cursor:text;display:inline-block;color:inherit;outline:0}.cdk-high-contrast-active .mat-mdc-chip-selected:not(.mat-mdc-chip-multiple){outline-width:3px}.mat-mdc-chip-action:focus .mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),H4e=(()=>{class n extends eC{constructor(){super(...arguments),this._defaultOptions=$n(RV,{optional:!0}),this.chipListSelectable=!0,this._chipListMultiple=!1,this._chipListHideSingleSelectionIndicator=this._defaultOptions?.hideSingleSelectionIndicator??!1,this._selectable=!0,this._selected=!1,this.basicChipAttrName="mat-basic-chip-option",this.selectionChange=new F}get selectable(){return this._selectable&&this.chipListSelectable}set selectable(e){this._selectable=vt(e),this._changeDetectorRef.markForCheck()}get selected(){return this._selected}set selected(e){this._setSelectedState(vt(e),!1,!0)}get ariaSelected(){return this.selectable?this.selected.toString():null}ngOnInit(){super.ngOnInit(),this.role="presentation"}select(){this._setSelectedState(!0,!1,!0)}deselect(){this._setSelectedState(!1,!1,!0)}selectViaInteraction(){this._setSelectedState(!0,!0,!0)}toggleSelected(e=!1){return this._setSelectedState(!this.selected,e,!0),this.selected}_handlePrimaryActionInteraction(){this.selectable&&!this.disabled&&this.toggleSelected(!0)}_hasLeadingGraphic(){return!!this.leadingIcon||!this._chipListHideSingleSelectionIndicator||this._chipListMultiple}_setSelectedState(e,i,r){e!==this.selected&&(this._selected=e,r&&this.selectionChange.emit({source:this,isUserInput:i,selected:this.selected}),this._changeDetectorRef.markForCheck())}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-basic-chip-option"],["","mat-basic-chip-option",""],["mat-chip-option"],["","mat-chip-option",""]],hostAttrs:[1,"mat-mdc-chip","mat-mdc-chip-option"],hostVars:37,hostBindings:function(e,i){2&e&&(wo("id",i.id),Be("tabindex",null)("aria-label",null)("aria-description",null)("role",i.role),nt("mdc-evolution-chip",!i._isBasicChip)("mdc-evolution-chip--filter",!i._isBasicChip)("mdc-evolution-chip--selectable",!i._isBasicChip)("mat-mdc-chip-selected",i.selected)("mat-mdc-chip-multiple",i._chipListMultiple)("mat-mdc-chip-disabled",i.disabled)("mat-mdc-chip-with-avatar",i.leadingIcon)("mdc-evolution-chip--disabled",i.disabled)("mdc-evolution-chip--selected",i.selected)("mdc-evolution-chip--selecting",!i._animationsDisabled)("mdc-evolution-chip--with-trailing-action",i._hasTrailingIcon())("mdc-evolution-chip--with-primary-icon",i.leadingIcon)("mdc-evolution-chip--with-primary-graphic",i._hasLeadingGraphic())("mdc-evolution-chip--with-avatar",i.leadingIcon)("mat-mdc-chip-highlighted",i.highlighted)("mat-mdc-chip-with-trailing-icon",i._hasTrailingIcon()))},inputs:{color:"color",disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex",selectable:"selectable",selected:"selected"},outputs:{selectionChange:"selectionChange"},features:[Vt([{provide:eC,useExisting:n},{provide:PV,useExisting:n}]),Xe],ngContentSelectors:jne,decls:11,vars:12,consts:[["matRipple","",1,"mat-mdc-chip-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-mdc-chip-focus-overlay"],[1,"mdc-evolution-chip__cell","mdc-evolution-chip__cell--primary"],["matChipAction","","role","option",3,"tabIndex","_allowFocusWhenDisabled"],["class","mdc-evolution-chip__graphic mat-mdc-chip-graphic",4,"ngIf"],[1,"mdc-evolution-chip__text-label","mat-mdc-chip-action-label"],[1,"mat-mdc-chip-primary-focus-indicator","mat-mdc-focus-indicator"],["class","mdc-evolution-chip__cell mdc-evolution-chip__cell--trailing",4,"ngIf"],[1,"cdk-visually-hidden",3,"id"],[1,"mdc-evolution-chip__graphic","mat-mdc-chip-graphic"],[1,"mdc-evolution-chip__checkmark"],["viewBox","-2 -3 30 30","focusable","false",1,"mdc-evolution-chip__checkmark-svg"],["fill","none","stroke","currentColor","d","M1.73,12.91 8.1,19.28 22.79,4.59",1,"mdc-evolution-chip__checkmark-path"],[1,"mdc-evolution-chip__cell","mdc-evolution-chip__cell--trailing"]],template:function(e,i){1&e&&(fn(Une),k(0,"span",0)(1,"span",1),f(2,"span",2)(3,"button",3),S(4,k4e,5,0,"span",4),f(5,"span",5),Tt(6),k(7,"span",6),g()()(),S(8,O4e,2,0,"span",7),f(9,"span",8),T(10),g()),2&e&&(b("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i._isRippleCentered)("matRippleTrigger",i._elementRef.nativeElement),v(3),b("tabIndex",i.tabIndex)("_allowFocusWhenDisabled",!0),Be("aria-selected",i.ariaSelected)("aria-label",i.ariaLabel)("aria-describedby",i._ariaDescriptionId),v(1),b("ngIf",i._hasLeadingGraphic()),v(4),b("ngIf",i._hasTrailingIcon()),v(1),b("id",i._ariaDescriptionId),v(1),kt(i.ariaDescription))},dependencies:[Ne,Ki,vA],styles:['.mdc-evolution-chip,.mdc-evolution-chip__cell,.mdc-evolution-chip__action{display:inline-flex;align-items:center}.mdc-evolution-chip{position:relative;max-width:100%}.mdc-evolution-chip .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}.mdc-evolution-chip__cell,.mdc-evolution-chip__action{height:100%}.mdc-evolution-chip__cell--primary{overflow-x:hidden}.mdc-evolution-chip__cell--trailing{flex:1 0 auto}.mdc-evolution-chip__action{align-items:center;background:none;border:none;box-sizing:content-box;cursor:pointer;display:inline-flex;justify-content:center;outline:none;padding:0;text-decoration:none;color:inherit}.mdc-evolution-chip__action--presentational{cursor:auto}.mdc-evolution-chip--disabled,.mdc-evolution-chip__action:disabled{pointer-events:none}.mdc-evolution-chip__action--primary{overflow-x:hidden}.mdc-evolution-chip__action--trailing{position:relative;overflow:visible}.mdc-evolution-chip__action--primary:before{box-sizing:border-box;content:"";height:100%;left:0;position:absolute;pointer-events:none;top:0;width:100%;z-index:1}.mdc-evolution-chip--touch{margin-top:8px;margin-bottom:8px}.mdc-evolution-chip__action-touch{position:absolute;top:50%;height:48px;left:0;right:0;transform:translateY(-50%)}.mdc-evolution-chip__text-label{white-space:nowrap;user-select:none;text-overflow:ellipsis;overflow:hidden}.mdc-evolution-chip__graphic{align-items:center;display:inline-flex;justify-content:center;overflow:hidden;pointer-events:none;position:relative;flex:1 0 auto}.mdc-evolution-chip__checkmark{position:absolute;opacity:0;top:50%;left:50%}.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--selected):not(.mdc-evolution-chip--with-primary-icon) .mdc-evolution-chip__graphic{width:0}.mdc-evolution-chip__checkmark-background{opacity:0}.mdc-evolution-chip__checkmark-svg{display:block}.mdc-evolution-chip__checkmark-path{stroke-width:2px;stroke-dasharray:29.7833385;stroke-dashoffset:29.7833385;stroke:currentColor}.mdc-evolution-chip--selecting .mdc-evolution-chip__graphic{transition:width 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--selecting .mdc-evolution-chip__checkmark{transition:transform 150ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-75%, -50%)}.mdc-evolution-chip--selecting .mdc-evolution-chip__checkmark-path{transition:stroke-dashoffset 150ms 45ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__graphic{transition:width 100ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__checkmark{transition:opacity 50ms 0ms linear,transform 100ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-75%, -50%)}.mdc-evolution-chip--deselecting .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}.mdc-evolution-chip--selecting-with-primary-icon .mdc-evolution-chip__icon--primary{transition:opacity 75ms 0ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--selecting-with-primary-icon .mdc-evolution-chip__checkmark-path{transition:stroke-dashoffset 150ms 75ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__icon--primary{transition:opacity 150ms 75ms cubic-bezier(0.4, 0, 0.2, 1)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__checkmark{transition:opacity 75ms 0ms cubic-bezier(0.4, 0, 0.2, 1);transform:translate(-50%, -50%)}.mdc-evolution-chip--deselecting-with-primary-icon .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}.mdc-evolution-chip--selected .mdc-evolution-chip__icon--primary{opacity:0}.mdc-evolution-chip--selected .mdc-evolution-chip__checkmark{transform:translate(-50%, -50%);opacity:1}.mdc-evolution-chip--selected .mdc-evolution-chip__checkmark-path{stroke-dashoffset:0}@keyframes mdc-evolution-chip-enter{from{transform:scale(0.8);opacity:.4}to{transform:scale(1);opacity:1}}.mdc-evolution-chip--enter{animation:mdc-evolution-chip-enter 100ms 0ms cubic-bezier(0, 0, 0.2, 1)}@keyframes mdc-evolution-chip-exit{from{opacity:1}to{opacity:0}}.mdc-evolution-chip--exit{animation:mdc-evolution-chip-exit 75ms 0ms cubic-bezier(0.4, 0, 1, 1)}.mdc-evolution-chip--hidden{opacity:0;pointer-events:none;transition:width 150ms 0ms cubic-bezier(0.4, 0, 1, 1)}.mat-mdc-standard-chip .mdc-evolution-chip__checkmark{height:20px;width:20px}.mat-mdc-standard-chip .mdc-evolution-chip__icon--trailing{height:18px;width:18px;font-size:18px}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary{padding-left:12px;padding-right:12px}[dir=rtl] .mat-mdc-standard-chip .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:12px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic{padding-left:6px;padding-right:6px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic[dir=rtl]{padding-left:6px;padding-right:6px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary{padding-left:0;padding-right:12px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:0}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:12px;padding-right:0}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:12px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic{padding-left:6px;padding-right:6px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic[dir=rtl]{padding-left:6px;padding-right:6px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:0;padding-right:0}[dir=rtl] .mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:0}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-selected-icon-color, currentColor)}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic{padding-left:4px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__graphic[dir=rtl]{padding-left:8px;padding-right:4px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary{padding-left:0;padding-right:12px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:12px;padding-right:0}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic{padding-left:4px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__graphic[dir=rtl]{padding-left:8px;padding-right:4px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing{padding-left:8px;padding-right:8px}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--trailing[dir=rtl]{padding-left:8px;padding-right:8px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing{left:8px;right:initial}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__ripple--trailing[dir=rtl]{left:initial;right:8px}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary{padding-left:0;padding-right:0}[dir=rtl] .mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary,.mdc-evolution-chip--with-avatar.mdc-evolution-chip--with-primary-graphic.mdc-evolution-chip--with-trailing-action .mdc-evolution-chip__action--primary[dir=rtl]{padding-left:0;padding-right:0}.mdc-evolution-chip--with-avatar.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--with-primary-icon){--mdc-chip-graphic-selected-width:24px}.mdc-evolution-chip--with-avatar .mdc-evolution-chip__graphic{height:24px;width:24px;font-size:24px}.mdc-evolution-chip--with-avatar .mdc-evolution-chip__icon--primary{height:24px;width:24px;font-size:24px}.mat-mdc-standard-chip{-webkit-tap-highlight-color:rgba(0,0,0,0);border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px);height:var(--mdc-chip-container-height, 32px)}.mat-mdc-standard-chip .mdc-evolution-chip__ripple{border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-radius:var(--mdc-chip-container-shape-radius, 16px 16px 16px 16px)}.mat-mdc-standard-chip .mdc-evolution-chip__icon--primary{border-radius:var(--mdc-chip-with-avatar-avatar-shape-radius, 14px 14px 14px 14px)}.mat-mdc-standard-chip.mdc-evolution-chip--selectable:not(.mdc-evolution-chip--with-primary-icon){--mdc-chip-graphic-selected-width:var(--mdc-chip-with-avatar-avatar-size, 28px)}.mat-mdc-standard-chip .mdc-evolution-chip__graphic{height:var(--mdc-chip-with-avatar-avatar-size, 28px);width:var(--mdc-chip-with-avatar-avatar-size, 28px);font-size:var(--mdc-chip-with-avatar-avatar-size, 28px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-outline-width, 1px)}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-outline-width, 1px)}.mat-mdc-standard-chip.mdc-evolution-chip--selected .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-selected-outline-width, 0)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--selected) .mdc-evolution-chip__action--primary:before{border-width:var(--mdc-chip-flat-unselected-outline-width, 1px)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled){background-color:var(--mdc-chip-elevated-container-color, transparent)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled{background-color:var(--mdc-chip-elevated-disabled-container-color, transparent)}.mat-mdc-standard-chip.mdc-evolution-chip--selected.mdc-evolution-chip--disabled{background-color:var(--mdc-chip-elevated-disabled-container-color, transparent)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__text-label{color:var(--mdc-chip-label-text-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__text-label{color:var(--mdc-chip-disabled-label-text-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--selected.mdc-evolution-chip--disabled .mdc-evolution-chip__text-label{color:var(--mdc-chip-disabled-label-text-color, currentColor)}.mat-mdc-standard-chip .mdc-evolution-chip__icon--primary{height:var(--mdc-chip-with-icon-icon-size, 18px);width:var(--mdc-chip-with-icon-icon-size, 18px);font-size:var(--mdc-chip-with-icon-icon-size, 18px)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__icon--primary{color:var(--mdc-chip-with-icon-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__icon--primary{color:var(--mdc-chip-with-icon-disabled-icon-color, currentColor)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-selected-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__checkmark{color:var(--mdc-chip-with-icon-disabled-icon-color, currentColor)}.mat-mdc-standard-chip:not(.mdc-evolution-chip--disabled) .mdc-evolution-chip__icon--trailing{color:var(--mdc-chip-with-trailing-icon-trailing-icon-color, currentColor)}.mat-mdc-standard-chip.mdc-evolution-chip--disabled .mdc-evolution-chip__icon--trailing{color:var(--mdc-chip-with-trailing-icon-disabled-trailing-icon-color, currentColor)}.cdk-high-contrast-active .mat-mdc-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-mdc-standard-chip .mdc-evolution-chip__checkmark-path{stroke:CanvasText !important}.mat-mdc-standard-chip.mdc-evolution-chip--disabled{opacity:.4}.mat-mdc-standard-chip .mdc-evolution-chip__cell--primary,.mat-mdc-standard-chip .mdc-evolution-chip__action--primary,.mat-mdc-standard-chip .mat-mdc-chip-action-label{overflow:visible}.mat-mdc-standard-chip .mdc-evolution-chip__cell--primary{width:100%}.mat-mdc-standard-chip .mdc-evolution-chip__action--primary{font:inherit;letter-spacing:inherit;white-space:inherit}.mat-mdc-standard-chip .mat-mdc-chip-graphic,.mat-mdc-standard-chip .mat-mdc-chip-trailing-icon{box-sizing:content-box}.mat-mdc-standard-chip._mat-animation-noopable,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__graphic,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__checkmark,.mat-mdc-standard-chip._mat-animation-noopable .mdc-evolution-chip__checkmark-path{transition-duration:1ms;animation-duration:1ms}.mat-mdc-basic-chip .mdc-evolution-chip__action--primary{font:inherit}.mat-mdc-chip-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;opacity:0;border-radius:inherit;transition:opacity 150ms linear}._mat-animation-noopable .mat-mdc-chip-focus-overlay{transition:none}.mat-mdc-basic-chip .mat-mdc-chip-focus-overlay{display:none}.mat-mdc-chip:hover .mat-mdc-chip-focus-overlay{opacity:.04}.mat-mdc-chip.cdk-focused .mat-mdc-chip-focus-overlay{opacity:.12}.mat-mdc-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-mdc-chip-avatar{text-align:center;line-height:1;color:var(--mdc-chip-with-icon-icon-color, currentColor)}.mat-mdc-chip{position:relative;z-index:0}.mat-mdc-chip-action-label{text-align:left;z-index:1}[dir=rtl] .mat-mdc-chip-action-label{text-align:right}.mat-mdc-chip.mdc-evolution-chip--with-trailing-action .mat-mdc-chip-action-label{position:relative}.mat-mdc-chip-action-label .mat-mdc-chip-primary-focus-indicator{position:absolute;top:0;right:0;bottom:0;left:0;pointer-events:none}.mat-mdc-chip-action-label .mat-mdc-focus-indicator::before{margin:calc(calc(var(--mat-mdc-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-mdc-chip-remove{opacity:.54}.mat-mdc-chip-remove:focus{opacity:1}.mat-mdc-chip-remove::before{margin:calc(var(--mat-mdc-focus-indicator-border-width, 3px) * -1);left:8px;right:8px}.mat-mdc-chip-remove .mat-icon{width:inherit;height:inherit;font-size:inherit;box-sizing:content-box}.mat-chip-edit-input{cursor:text;display:inline-block;color:inherit;outline:0}.cdk-high-contrast-active .mat-mdc-chip-selected:not(.mat-mdc-chip-multiple){outline-width:3px}.mat-mdc-chip-action:focus .mat-mdc-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),z4e=Dc(class{constructor(t){}}),yA=(()=>{class n extends z4e{get chipFocusChanges(){return this._getChipStream(e=>e._onFocus)}get chipDestroyedChanges(){return this._getChipStream(e=>e.destroyed)}get disabled(){return this._disabled}set disabled(e){this._disabled=vt(e),this._syncChipsState()}get empty(){return 0===this._chips.length}get role(){return this._explicitRole?this._explicitRole:this.empty?null:this._defaultRole}set role(e){this._explicitRole=e}get focused(){return this._hasFocusedChip()}constructor(e,i,r){super(e),this._elementRef=e,this._changeDetectorRef=i,this._dir=r,this._lastDestroyedFocusedChipIndex=null,this._destroyed=new Ee,this._defaultRole="presentation",this._disabled=!1,this._explicitRole=null,this._chipActions=new Pa}ngAfterViewInit(){this._setUpFocusManagement(),this._trackChipSetChanges(),this._trackDestroyedFocusedChip()}ngOnDestroy(){this._keyManager?.destroy(),this._chipActions.destroy(),this._destroyed.next(),this._destroyed.complete()}_hasFocusedChip(){return this._chips&&this._chips.some(e=>e._hasFocus())}_syncChipsState(){this._chips&&this._chips.forEach(e=>{e.disabled=this._disabled,e._changeDetectorRef.markForCheck()})}focus(){}_handleKeydown(e){this._originatesFromChip(e)&&this._keyManager.onKeydown(e)}_isValidIndex(e){return e>=0&&e<this._chips.length}_allowFocusEscape(){if(-1!==this.tabIndex){let e=this.tabIndex;this.tabIndex=-1,setTimeout(()=>this.tabIndex=e)}}_getChipStream(e){return this._chips.changes.pipe(kn(null),Jn(()=>tn(...this._chips.map(e))))}_originatesFromChip(e){let i=e.target;for(;i&&i!==this._elementRef.nativeElement;){if(i.classList.contains("mat-mdc-chip"))return!0;i=i.parentElement}return!1}_setUpFocusManagement(){this._chips.changes.pipe(kn(this._chips)).subscribe(e=>{let i=[];e.forEach(r=>r._getActions().forEach(o=>i.push(o))),this._chipActions.reset(i),this._chipActions.notifyOnChanges()}),this._keyManager=new ku(this._chipActions).withVerticalOrientation().withHorizontalOrientation(this._dir?this._dir.value:"ltr").withHomeAndEnd().skipPredicate(e=>this._skipPredicate(e)),this.chipFocusChanges.pipe(it(this._destroyed)).subscribe(({chip:e})=>{let i=e._getSourceAction(document.activeElement);i&&this._keyManager.updateActiveItem(i)}),this._dir?.change.pipe(it(this._destroyed)).subscribe(e=>this._keyManager.withHorizontalOrientation(e))}_skipPredicate(e){return!e.isInteractive||e.disabled}_trackChipSetChanges(){this._chips.changes.pipe(kn(null),it(this._destroyed)).subscribe(()=>{this.disabled&&Promise.resolve().then(()=>this._syncChipsState()),this._redirectDestroyedChipFocus()})}_trackDestroyedFocusedChip(){this.chipDestroyedChanges.pipe(it(this._destroyed)).subscribe(e=>{let r=this._chips.toArray().indexOf(e.chip);this._isValidIndex(r)&&e.chip._hasFocus()&&(this._lastDestroyedFocusedChipIndex=r)})}_redirectDestroyedChipFocus(){if(null!=this._lastDestroyedFocusedChipIndex){if(this._chips.length){let e=Math.min(this._lastDestroyedFocusedChipIndex,this._chips.length-1),i=this._chips.toArray()[e];i.disabled?1===this._chips.length?this.focus():this._keyManager.setPreviousItemActive():i.focus()}else this.focus();this._lastDestroyedFocusedChipIndex=null}}}return n.\u0275fac=function(e){return new(e||n)(C(xe),C(Qt),C(zi,8))},n.\u0275cmp=P({type:n,selectors:[["mat-chip-set"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,eC,5),2&e){let o;be(o=ve())&&(i._chips=o)}},hostAttrs:[1,"mat-mdc-chip-set","mdc-evolution-chip-set"],hostVars:1,hostBindings:function(e,i){1&e&&A("keydown",function(o){return i._handleKeydown(o)}),2&e&&Be("role",i.role)},inputs:{disabled:"disabled",role:"role"},features:[Xe],ngContentSelectors:Gne,decls:2,vars:0,consts:[["role","presentation",1,"mdc-evolution-chip-set__chips"]],template:function(e,i){1&e&&(fn(),f(0,"div",0),Tt(1),g())},styles:[".mdc-evolution-chip-set{display:flex}.mdc-evolution-chip-set:focus{outline:none}.mdc-evolution-chip-set__chips{display:flex;flex-flow:wrap;min-width:0}.mdc-evolution-chip-set--overflow .mdc-evolution-chip-set__chips{flex-flow:nowrap}.mdc-evolution-chip-set .mdc-evolution-chip-set__chips{margin-left:-8px;margin-right:0}[dir=rtl] .mdc-evolution-chip-set .mdc-evolution-chip-set__chips,.mdc-evolution-chip-set .mdc-evolution-chip-set__chips[dir=rtl]{margin-left:0;margin-right:-8px}.mdc-evolution-chip-set .mdc-evolution-chip{margin-left:8px;margin-right:0}[dir=rtl] .mdc-evolution-chip-set .mdc-evolution-chip,.mdc-evolution-chip-set .mdc-evolution-chip[dir=rtl]{margin-left:0;margin-right:8px}.mdc-evolution-chip-set .mdc-evolution-chip{margin-top:4px;margin-bottom:4px}.mat-mdc-chip-set .mdc-evolution-chip-set__chips{min-width:100%}.mat-mdc-chip-set-stacked{flex-direction:column;align-items:flex-start}.mat-mdc-chip-set-stacked .mat-mdc-chip{width:100%}input.mat-mdc-chip-input{flex:1 0 150px;margin-left:8px}[dir=rtl] input.mat-mdc-chip-input{margin-left:0;margin-right:8px}"],encapsulation:2,changeDetection:0}),n})(),U4e={provide:Xr,useExisting:Wn(()=>j4e),multi:!0},j4e=(()=>{class n extends yA{constructor(){super(...arguments),this._onTouched=()=>{},this._onChange=()=>{},this._defaultRole="listbox",this._defaultOptions=$n(RV,{optional:!0}),this._multiple=!1,this.ariaOrientation="horizontal",this._selectable=!0,this.compareWith=(e,i)=>e===i,this._required=!1,this._hideSingleSelectionIndicator=this._defaultOptions?.hideSingleSelectionIndicator??!1,this.change=new F}get multiple(){return this._multiple}set multiple(e){this._multiple=vt(e),this._syncListboxProperties()}get selected(){let e=this._chips.toArray().filter(i=>i.selected);return this.multiple?e:e[0]}get selectable(){return this._selectable}set selectable(e){this._selectable=vt(e),this._syncListboxProperties()}get required(){return this._required}set required(e){this._required=vt(e)}get hideSingleSelectionIndicator(){return this._hideSingleSelectionIndicator}set hideSingleSelectionIndicator(e){this._hideSingleSelectionIndicator=vt(e),this._syncListboxProperties()}get chipSelectionChanges(){return this._getChipStream(e=>e.selectionChange)}get chipBlurChanges(){return this._getChipStream(e=>e._onBlur)}get value(){return this._value}set value(e){this.writeValue(e),this._value=e}ngAfterContentInit(){void 0!==this._pendingInitialValue&&Promise.resolve().then(()=>{this._setSelectionByValue(this._pendingInitialValue,!1),this._pendingInitialValue=void 0}),this._chips.changes.pipe(kn(null),it(this._destroyed)).subscribe(()=>{this._syncListboxProperties()}),this.chipBlurChanges.pipe(it(this._destroyed)).subscribe(()=>this._blur()),this.chipSelectionChanges.pipe(it(this._destroyed)).subscribe(e=>{this.multiple||this._chips.forEach(i=>{i!==e.source&&i._setSelectedState(!1,!1,!1)}),e.isUserInput&&this._propagateChanges()})}focus(){if(this.disabled)return;let e=this._getFirstSelectedChip();e&&!e.disabled?e.focus():this._chips.length>0?this._keyManager.setFirstItemActive():this._elementRef.nativeElement.focus()}writeValue(e){this._chips?this._setSelectionByValue(e,!1):null!=e&&(this._pendingInitialValue=e)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_setSelectionByValue(e,i=!0){this._clearSelection(),Array.isArray(e)?e.forEach(r=>this._selectValue(r,i)):this._selectValue(e,i)}_blur(){this.disabled||setTimeout(()=>{this.focused||this._markAsTouched()})}_keydown(e){9===e.keyCode&&super._allowFocusEscape()}_markAsTouched(){this._onTouched(),this._changeDetectorRef.markForCheck()}_propagateChanges(){let e=null;e=Array.isArray(this.selected)?this.selected.map(i=>i.value):this.selected?this.selected.value:void 0,this._value=e,this.change.emit(new class{constructor(t,e){this.source=t,this.value=e}}(this,e)),this._onChange(e),this._changeDetectorRef.markForCheck()}_clearSelection(e){this._chips.forEach(i=>{i!==e&&i.deselect()})}_selectValue(e,i){let r=this._chips.find(o=>null!=o.value&&this.compareWith(o.value,e));return r&&(i?r.selectViaInteraction():r.select()),r}_syncListboxProperties(){this._chips&&Promise.resolve().then(()=>{this._chips.forEach(e=>{e._chipListMultiple=this.multiple,e.chipListSelectable=this._selectable,e._chipListHideSingleSelectionIndicator=this.hideSingleSelectionIndicator,e._changeDetectorRef.markForCheck()})})}_getFirstSelectedChip(){return Array.isArray(this.selected)?this.selected.length?this.selected[0]:void 0:this.selected}_skipPredicate(e){return!e.isInteractive}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=Xn(n)))(i||n)}}(),n.\u0275cmp=P({type:n,selectors:[["mat-chip-listbox"]],contentQueries:function(e,i,r){if(1&e&&Bn(r,H4e,5),2&e){let o;be(o=ve())&&(i._chips=o)}},hostAttrs:[1,"mdc-evolution-chip-set","mat-mdc-chip-listbox"],hostVars:11,hostBindings:function(e,i){1&e&&A("focus",function(){return i.focus()})("blur",function(){return i._blur()})("keydown",function(o){return i._keydown(o)}),2&e&&(wo("tabIndex",i.empty?-1:i.tabIndex),Be("role",i.role)("aria-describedby",i._ariaDescribedby||null)("aria-required",i.role?i.required:null)("aria-disabled",i.disabled.toString())("aria-multiselectable",i.multiple)("aria-orientation",i.ariaOrientation),nt("mat-mdc-chip-list-disabled",i.disabled)("mat-mdc-chip-list-required",i.required))},inputs:{tabIndex:"tabIndex",multiple:"multiple",ariaOrientation:["aria-orientation","ariaOrientation"],selectable:"selectable",compareWith:"compareWith",required:"required",hideSingleSelectionIndicator:"hideSingleSelectionIndicator",value:"value"},outputs:{change:"change"},features:[Vt([U4e]),Xe],ngContentSelectors:Gne,decls:2,vars:0,consts:[["role","presentation",1,"mdc-evolution-chip-set__chips"]],template:function(e,i){1&e&&(fn(),f(0,"div",0),Tt(1),g())},styles:[".mdc-evolution-chip-set{display:flex}.mdc-evolution-chip-set:focus{outline:none}.mdc-evolution-chip-set__chips{display:flex;flex-flow:wrap;min-width:0}.mdc-evolution-chip-set--overflow .mdc-evolution-chip-set__chips{flex-flow:nowrap}.mdc-evolution-chip-set .mdc-evolution-chip-set__chips{margin-left:-8px;margin-right:0}[dir=rtl] .mdc-evolution-chip-set .mdc-evolution-chip-set__chips,.mdc-evolution-chip-set .mdc-evolution-chip-set__chips[dir=rtl]{margin-left:0;margin-right:-8px}.mdc-evolution-chip-set .mdc-evolution-chip{margin-left:8px;margin-right:0}[dir=rtl] .mdc-evolution-chip-set .mdc-evolution-chip,.mdc-evolution-chip-set .mdc-evolution-chip[dir=rtl]{margin-left:0;margin-right:8px}.mdc-evolution-chip-set .mdc-evolution-chip{margin-top:4px;margin-bottom:4px}.mat-mdc-chip-set .mdc-evolution-chip-set__chips{min-width:100%}.mat-mdc-chip-set-stacked{flex-direction:column;align-items:flex-start}.mat-mdc-chip-set-stacked .mat-mdc-chip{width:100%}input.mat-mdc-chip-input{flex:1 0 150px;margin-left:8px}[dir=rtl] input.mat-mdc-chip-input{margin-left:0;margin-right:8px}"],encapsulation:2,changeDetection:0}),n})(),qne=(hg(class extends yA{constructor(t,e,i,r,o,a,s){super(t,e,i),this._defaultErrorStateMatcher=r,this._parentForm=o,this._parentFormGroup=a,this.ngControl=s,this.stateChanges=new Ee}}),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[Eh,{provide:RV,useValue:{separatorKeyCodes:[13]}}],imports:[dn,De,_a,dn]}),n})()),W4e=["filterModalTemplate"];function q4e(n,t){if(1&n){let e=Te();f(0,"mat-chip",5),A("removed",function(){let o=ne(e).$implicit;return ie(w(2).removeHparamFilter.emit(o))})("click",function(r){let a=ne(e).$implicit;return ie(w(2).openFilterMenu(r,a))}),T(1),f(2,"button",6),k(3,"mat-icon",7),g()()}if(2&n){let e=t.$implicit;v(1),Ve(" ",e," ")}}function X4e(n,t){if(1&n&&(f(0,"div",2),k(1,"mat-icon",3),f(2,"mat-chip-set"),S(3,q4e,4,1,"mat-chip",4),g()()),2&n){let e=w();v(3),b("ngForOf",e.filters.keys())}}function Y4e(n,t){if(1&n){let e=Te();f(0,"tb-data-table-filter",8),A("intervalFilterChanged",function(r){return ne(e),ie(w().emitIntervalFilterChanged(r))})("discreteFilterChanged",function(r){return ne(e),ie(w().emitDiscreteFilterChanged(r))})("includeUndefinedToggled",function(){return ne(e),ie(w().emitIncludeUndefinedToggled())}),g()}2&n&&b("filter",w().selectedFilter)}var Xne=(()=>{class n{get selectedFilterName(){return this.internalSelectedFilterName}set selectedFilterName(e){this.internalSelectedFilterName=e}get selectedFilter(){return this.filters.get(this.selectedFilterName)}constructor(e,i){this.customModal=e,this.viewContainerRef=i,this.removeHparamFilter=new F,this.addFilter=new F,this.internalSelectedFilterName=""}openFilterMenu(e,i){this.selectedFilterName=i,this.customModal.createNextToElement(this.filterModalTemplate,e.target.closest("mat-chip"),this.viewContainerRef)}emitIntervalFilterChanged(e){!this.selectedFilter||this.addFilter.emit({name:this.selectedFilterName,value:{...this.selectedFilter,filterLowerValue:e.lowerValue,filterUpperValue:e.upperValue}})}emitDiscreteFilterChanged(e){if(!this.selectedFilter)return;let i=new Set([...this.selectedFilter.filterValues]);i.has(e)?i.delete(e):i.add(e),this.addFilter.emit({name:this.selectedFilterName,value:{...this.selectedFilter,filterValues:Array.from(i)}})}emitIncludeUndefinedToggled(){!this.selectedFilter||this.addFilter.emit({name:this.selectedFilterName,value:{...this.selectedFilter,includeUndefined:!this.selectedFilter.includeUndefined}})}}return n.\u0275fac=function(e){return new(e||n)(C(uA),C(ei))},n.\u0275cmp=P({type:n,selectors:[["filterbar-component"]],viewQuery:function(e,i){if(1&e&&Ue(W4e,5,oi),2&e){let r;be(r=ve())&&(i.filterModalTemplate=r.first)}},inputs:{filters:"filters"},outputs:{removeHparamFilter:"removeHparamFilter",addFilter:"addFilter"},decls:3,vars:1,consts:[["class","filterbar",4,"ngIf"],["filterModalTemplate",""],[1,"filterbar"],["svgIcon","filter_list_24px",1,"filterbar-icon"],["class","filterbar-chip",3,"removed","click",4,"ngFor","ngForOf"],[1,"filterbar-chip",3,"removed","click"],["matChipRemove",""],["svgIcon","close_24px"],[3,"filter","intervalFilterChanged","discreteFilterChanged","includeUndefinedToggled"]],template:function(e,i){1&e&&(S(0,X4e,4,1,"div",0),S(1,Y4e,1,1,"ng-template",null,1,jt)),2&e&&b("ngIf",i.filters.size)},dependencies:[nn,Ne,hA,bn,eC,Wne,yA],styles:[".filterbar[_ngcontent-%COMP%]{display:flex;align-items:center;padding:10px 14px 0px 14px}.filterbar[_ngcontent-%COMP%]   .filterbar-icon[_ngcontent-%COMP%]{margin-right:10px}.filterbar[_ngcontent-%COMP%]   .filterbar-chip[_ngcontent-%COMP%]{height:24px}"],changeDetection:0}),n})(),Yne=(()=>{class n{constructor(e){this.store=e,this.filters$=this.store.select(Mc.getDashboardHparamFilterMap),this.ngUnsubscribe=new Ee}addHparamFilter(e){this.store.dispatch(ro.dashboardHparamFilterAdded({name:e.name,filter:e.value}))}removeHparamFilter(e){this.store.dispatch(ro.dashboardHparamFilterRemoved({name:e}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["filterbar"]],decls:2,vars:3,consts:[[3,"filters","removeHparamFilter","addFilter"]],template:function(e,i){1&e&&(f(0,"filterbar-component",0),A("removeHparamFilter",function(o){return i.removeHparamFilter(o)})("addFilter",function(o){return i.addHparamFilter(o)}),U(1,"async"),g()),2&e&&b("filters",G(1,1,i.filters$))},dependencies:[Xne,ct],changeDetection:0}),n})(),K4e=["regexStringInput"];function J4e(n,t){1&n&&(f(0,"mat-option",3),T(1,"Experiment Name"),g()),2&n&&Zi("value",w().REGEX_BY_EXP_STR)}function $4e(n,t){if(1&n&&(Gt(0),f(1,"li",25),T(2),g(),Wt()),2&n){let e=t.$implicit;v(1),b("title",e.name),v(1),kt(e.name)}}function eHe(n,t){if(1&n&&(f(0,"li",26)(1,"em"),T(2),U(3,"number"),g()()),2&n){let e=w().$implicit;v(2),Ve("and ",G(3,1,e.runs.length-5)," more")}}function tHe(n,t){1&n&&(f(0,"li",27)(1,"em"),T(2,"No runs are in the group"),g()())}var nHe=function(n){return{borderColor:n}},iHe=function(n){return{backgroundColor:n}};function rHe(n,t){if(1&n&&(f(0,"ul",19)(1,"li")(2,"label"),k(3,"span",20),f(4,"code",21),T(5),g()(),f(6,"ul"),S(7,$4e,3,2,"ng-container",22),U(8,"slice"),S(9,eHe,4,3,"li",23),S(10,tHe,3,0,"li",24),g()()()),2&n){let e=t.$implicit;b("ngStyle",Un(11,nHe,e.color)),v(3),b("ngStyle",Un(13,iHe,e.color)),v(1),b("title",e.groupId),v(1),kt(e.groupId),v(2),b("ngForOf",kk(8,7,e.runs,0,5)),v(2),b("ngIf",e.runs.length>5),v(1),b("ngIf",0===e.runs.length)}}function oHe(n,t){if(1&n&&(f(0,"div",17),S(1,rHe,11,15,"ul",18),g()),2&n){let e=w(2);v(1),b("ngForOf",e.colorRunPairList)}}function aHe(n,t){if(1&n&&(f(0,"div",28),T(1," There are no runs matching the regex, "),f(2,"code"),T(3),g(),T(4,". Please check if your regex string is correct. "),g()),2&n){let e=w(2);v(3),Ve("/",e.regexString,"/")}}function sHe(n,t){if(1&n&&(f(0,"div",13)(1,"h4"),T(2,"Color group preview"),g(),f(3,"div",14),S(4,oHe,2,1,"div",15),S(5,aHe,5,1,"ng-template",null,16,jt),g()()),2&n){let e=st(6),i=w();v(4),b("ngIf",i.colorRunPairList.length)("ngIfElse",e)}}var Qne=(()=>{class n{constructor(e,i){this.dialogRef=e,this.hostElRef=i,this.onSave=new F,this.regexInputOnChange=new F,this.regexTypeOnChange=new F,this.REGEX_BY_RUN_STR="regex_by_run",this.REGEX_BY_EXP_STR="regex_by_exp",this.timeOutId=0,this.regexTypeFn=_s(this.internalRegexTypeFn.bind(this))}internalRegexTypeFn(e){return e===Yn.REGEX_BY_EXP?this.REGEX_BY_EXP_STR:this.REGEX_BY_RUN_STR}resetFocus(){this.hostElRef.nativeElement.contains(document.activeElement)||this.regexStringInput.nativeElement.focus()}onEnter(){this.onSaveClick(),this.dialogRef.close()}onSaveClick(){this.onSave.emit()}fillExample(e){this.regexString=e,this.regexInputChange(e)}regexInputChange(e){this.regexInputOnChange.emit(e)}handleFocusOut(){clearTimeout(this.timeOutId),this.timeOutId=setTimeout(this.resetFocus.bind(this),0)}regexTypeChange(e){this.regexTypeOnChange.emit(e.value===this.REGEX_BY_RUN_STR?Yn.REGEX:Yn.REGEX_BY_EXP)}}return n.\u0275fac=function(e){return new(e||n)(C(Vl),C(xe))},n.\u0275cmp=P({type:n,selectors:[["regex-edit-dialog-component"]],viewQuery:function(e,i){if(1&e&&Ue(K4e,7),2&e){let r;be(r=ve())&&(i.regexStringInput=r.first)}},inputs:{regexString:"regexString",colorRunPairList:"colorRunPairList",selectedGroupBy:"selectedGroupBy",enableColorByExperiment:"enableColorByExperiment"},outputs:{onSave:"onSave",regexInputOnChange:"regexInputOnChange",regexTypeOnChange:"regexTypeOnChange"},decls:37,vars:5,consts:function(){let t;return t=$localize`:Color Runs by Regex Query␟15ed9f6fd2d4906a4803fc1255de3c5db2c56530␟9088985113960312808:Color Runs by Regex Query`,[[1,"regex-edit-dialog",3,"focusout"],["mat-dialog-title",""],[3,"value","selectionChange"],[3,"value"],[3,"value",4,"ngIf"],["matInput","","aria-label",t,"cdkFocusInitial","",3,"value","keydown.enter","input"],["regexStringInput",""],[1,"example-details"],[3,"click"],["class","group-container",4,"ngIf"],["mat-dialog-actions","","align","end"],["mat-button","","mat-dialog-close",""],["mat-raised-button","","color","primary","mat-dialog-close","",1,"save-button",3,"click"],[1,"group-container"],[1,"grouping-preview"],["class","match-container",4,"ngIf","ngIfElse"],["empty",""],[1,"match-container"],["class","group",3,"ngStyle",4,"ngFor","ngForOf"],[1,"group",3,"ngStyle"],[1,"color-swatch",3,"ngStyle"],[1,"group-id",3,"title"],[4,"ngFor","ngForOf"],["class","more",4,"ngIf"],["class","no-match",4,"ngIf"],[3,"title"],[1,"more"],[1,"no-match"],[1,"warning"]]},template:function(e,i){1&e&&(f(0,"div",0),A("focusout",function(){return i.handleFocusOut()}),f(1,"h1",1),T(2,"Color runs by regex"),g(),f(3,"mat-dialog-content")(4,"p"),T(5,"Enter a regex with capturing groups to match against run names:"),g(),f(6,"mat-form-field")(7,"mat-label"),T(8,"Regex type"),g(),f(9,"mat-select",2),A("selectionChange",function(o){return i.regexTypeChange(o)}),f(10,"mat-option",3),T(11,"Run Name"),g(),S(12,J4e,2,1,"mat-option",4),g()(),f(13,"mat-form-field")(14,"input",5,6),A("keydown.enter",function(){return i.onEnter()})("input",function(o){return i.regexInputChange(o.target.value)}),g()()(),f(16,"div",7)(17,"p"),T(18,' Each matching run will be assigned a color based on the "key" formed by its matches to the capturing groups. '),k(19,"br"),f(20,"button",8),A("click",function(){return i.fillExample("(train|eval)")}),T(21," Try "),f(22,"code"),T(23,"(train|eval)"),g()(),T(24," to assign all runs containing "),f(25,"code"),T(26,"train"),g(),T(27," to one color and all runs containing "),f(28,"code"),T(29,"eval"),g(),T(30," to another color. "),g()(),S(31,sHe,7,2,"div",9),f(32,"div",10)(33,"button",11),T(34,"Cancel"),g(),f(35,"button",12),A("click",function(){return i.onSaveClick()}),T(36," Save "),g()()()),2&e&&(v(9),b("value",i.regexTypeFn(i.selectedGroupBy)),v(1),Zi("value",i.REGEX_BY_RUN_STR),v(2),b("ngIf",i.enableColorByExperiment),v(2),Zi("value",i.regexString),v(17),b("ngIf",i.regexString))},dependencies:[nn,Ne,Mf,ki,Z1,C9,K1,J1,qu,Pc,nl,Wu,ja,Kj,Us],styles:[".example-details[_ngcontent-%COMP%]{padding:16px}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);padding:0;border:none;cursor:pointer;text-decoration:underline;color:#1976d2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{color:#42a5f5}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#7b1fa2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited, body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#ba68c8}.group-container[_ngcontent-%COMP%]{margin:16px}.group-container[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{margin-bottom:16px}.group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#616161;font-size:.9em}body.dark-mode[_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.grouping-preview[_ngcontent-%COMP%]{border:1px solid #ebebeb;max-height:50vh;overflow-y:auto;padding:16px}body.dark-mode[_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%]{border:1px solid #555}.match-container[_ngcontent-%COMP%]{align-items:flex-start;display:grid;flex-wrap:wrap;gap:10px;grid-template-columns:repeat(2, minmax(50%, 1fr))}.color-swatch[_ngcontent-%COMP%]{border-radius:50%;box-shadow:0 0 2px #000;display:inline-block;height:15px;width:15px}ul[_ngcontent-%COMP%]{list-style-type:none;padding:0}mat-form-field[_ngcontent-%COMP%]{width:100%}.group[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:3px;margin:0;padding:16px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]{border:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;align-items:center;display:grid;gap:10px;grid-template-columns:max-content auto;padding:16px 0}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]   .group-id[_ngcontent-%COMP%]{font-size:.95em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]{font-size:.9em}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:#616161;margin-top:16px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Zne=(()=>{class n{constructor(e,i,r){this.store=e,this.dialogRef=i,this.expNameByExpId$=this.store.select(yu),this.enableColorByExperiment$=this.store.select(D6),this.tentativeRegexString$=new Ee,this.tentativeRegexType$=new Ee,this.groupByRegexString$=is(()=>tn(this.store.select(y1).pipe(Lt(1)),this.tentativeRegexString$)).pipe(kn(""),Da(1)),this.groupByRegexType$=tn(this.store.select(Dv).pipe(Lt(1),q(o=>o.key)),this.tentativeRegexType$).pipe(kn(Yn.REGEX),Oe(o=>o===Yn.REGEX||o===Yn.REGEX_BY_EXP),Da(1)),this.colorRunPairList$=is(()=>this.groupByRegexString$.pipe(Cr(500),Oe(o=>{try{let a=new RegExp(o);return Boolean(a)}catch{return!1}}),Vi(this.groupByRegexType$,this.allRuns$,this.runIdToEid$,this.expNameByExpId$,this.store.select(Ha.getColorPalette),this.store.select(Pl)),q(([o,a,s,l,c,d,u])=>{let h=Ev({key:a,regexString:o},s,l,c),m=new Map,_=[];for(let[M,y]of Object.entries(h.matches)){let x=m.get(M);if(!x){let R=d.colors[m.size%d.colors.length];x=u?R.darkHex:R.lightHex,m.set(M,x)}_.push({groupId:M,color:x,runs:y})}return _}))).pipe(kn([])),this.experimentIds=r.experimentIds,this.runIdToEid$=In(this.experimentIds.map(o=>this.store.select(YW,{experimentId:o}).pipe(q(a=>({experimentId:o,runIds:a}))))).pipe(q(o=>{let a={};for(let{runIds:s,experimentId:l}of o)for(let c of s)a[c]=l;return a})),this.allRuns$=In(this.experimentIds.map(o=>this.store.select(Iu,{experimentId:o}))).pipe(q(o=>o.flat()))}onRegexInputOnChange(e){this.tentativeRegexString$.next(e)}onRegexTypeOnChange(e){this.tentativeRegexType$.next(e)}onSave(){In([this.groupByRegexString$,this.groupByRegexType$,this.expNameByExpId$]).subscribe(([e,i,r])=>{e&&this.store.dispatch(Xf({experimentIds:this.experimentIds,groupBy:{key:i,regexString:e},expNameByExpId:r}))})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(Vl),C(Xv))},n.\u0275cmp=P({type:n,selectors:[["regex-edit-dialog"]],decls:5,vars:12,consts:[[3,"regexString","colorRunPairList","selectedGroupBy","enableColorByExperiment","onSave","regexInputOnChange","regexTypeOnChange"]],template:function(e,i){1&e&&(f(0,"regex-edit-dialog-component",0),A("onSave",function(){return i.onSave()})("regexInputOnChange",function(o){return i.onRegexInputOnChange(o)})("regexTypeOnChange",function(o){return i.onRegexTypeOnChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),g()),2&e&&b("regexString",G(1,4,i.groupByRegexString$))("colorRunPairList",G(2,6,i.colorRunPairList$))("selectedGroupBy",G(3,8,i.groupByRegexType$))("enableColorByExperiment",G(4,10,i.enableColorByExperiment$))},dependencies:[Qne,ct],styles:["[_nghost-%COMP%], regex-edit-dialog-component[_ngcontent-%COMP%] {\n        display: block;\n        height: 100%;\n        width: 100%;\n      }"]}),n})();function dHe(n,t){1&n&&k(0,"mat-icon",14)}function uHe(n,t){if(1&n){let e=Te();f(0,"button",13),A("click",function(){ne(e);let r=w();return ie(r.onGroupByChange.emit({key:r.GroupByKey.EXPERIMENT}))}),S(1,dHe,1,0,"mat-icon",7),f(2,"span"),T(3,"Experiment"),g()()}if(2&n){let e=w();Be("aria-checked",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT),v(1),b("ngIf",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT)}}function pHe(n,t){1&n&&k(0,"mat-icon",14)}function hHe(n,t){1&n&&k(0,"mat-icon",14)}function mHe(n,t){1&n&&(f(0,"span")(1,"strong"),T(2," By Run Name"),g()())}function fHe(n,t){1&n&&(f(0,"span")(1,"strong"),T(2," By Experiment Name"),g()())}function gHe(n,t){if(1&n&&(f(0,"span"),T(1),g()),2&n){let e=w();v(1),kt(e.regexString)}}function _He(n,t){1&n&&(f(0,"span",15),T(1,"(none set)"),g())}var Kne=(()=>{class n{constructor(e){this.dialog=e,this.GroupByKey=Yn,this.onGroupByChange=new F}onRegexStringEdit(){this.dialog.open(Zne,{maxHeight:"95vh",maxWidth:"80vw",data:{experimentIds:this.experimentIds}})}onGroupByRegexClick(){this.regexString?this.onGroupByChange.emit({key:this.lastRegexGroupByKey,regexString:this.regexString}):this.onRegexStringEdit()}}return n.\u0275fac=function(e){return new(e||n)(C(ys))},n.\u0275cmp=P({type:n,selectors:[["runs-group-menu-button-component"]],inputs:{showExperimentsGroupBy:"showExperimentsGroupBy",experimentIds:"experimentIds",regexString:"regexString",selectedGroupBy:"selectedGroupBy",lastRegexGroupByKey:"lastRegexGroupByKey"},outputs:{onGroupByChange:"onGroupByChange"},decls:21,vars:10,consts:[["mat-icon-button","","title","Color runs by...",3,"matMenuTriggerFor"],["svgIcon","palette_24px"],[1,"run-table-color-group-by"],["groupByMenu","matMenu"],[1,"label"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","run",3,"click"],["svgIcon","done_24px",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","regex",3,"click"],[4,"ngIf"],["mat-menu-item","","role","menuitem","data-value","regex-edit",1,"display-regex-string",3,"click"],["svgIcon","edit_24px"],["class","none-set-string",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click"],["svgIcon","done_24px"],[1,"none-set-string"]],template:function(e,i){1&e&&(f(0,"button",0),k(1,"mat-icon",1),g(),f(2,"mat-menu",2,3)(4,"div",4),T(5,"Color runs by"),g(),S(6,uHe,4,2,"button",5),f(7,"button",6),A("click",function(){return i.onGroupByChange.emit({key:i.GroupByKey.RUN})}),S(8,pHe,1,0,"mat-icon",7),f(9,"span"),T(10,"Run"),g()(),f(11,"button",8),A("click",function(){return i.onGroupByRegexClick()}),S(12,hHe,1,0,"mat-icon",7),f(13,"span"),T(14,"Regex"),g(),S(15,mHe,3,0,"span",9),S(16,fHe,3,0,"span",9),g(),f(17,"button",10),A("click",function(){return i.onRegexStringEdit()}),k(18,"mat-icon",11),S(19,gHe,2,1,"span",9),S(20,_He,2,0,"span",12),g()()),2&e&&(b("matMenuTriggerFor",st(3)),v(6),b("ngIf",i.showExperimentsGroupBy),v(1),Be("aria-checked",i.selectedGroupBy.key===i.GroupByKey.RUN),v(1),b("ngIf",i.selectedGroupBy.key===i.GroupByKey.RUN),v(3),Be("aria-checked",i.selectedGroupBy.key===i.GroupByKey.REGEX||i.selectedGroupBy.key===i.GroupByKey.REGEX_BY_EXP),v(1),b("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX||i.selectedGroupBy.key===i.GroupByKey.REGEX_BY_EXP),v(3),b("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX),v(1),b("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX_BY_EXP),v(3),b("ngIf",i.regexString),v(1),b("ngIf",!i.regexString))},dependencies:[Ne,Er,bn,Xu,Ed,Yu],styles:[".run-table-color-group-by{font-size:16px}  .run-table-color-group-by .label{color:#616161;font-size:.9em;margin:10px 0;padding:0 16px;pointer-events:none}  .run-table-color-group-by mat-icon{--mat-menu-item-icon-size: 20px}  .run-table-color-group-by .display-regex-string{padding-left:40px}  .run-table-color-group-by .display-regex-string .none-set-string{color:#616161}body.dark-mode[_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string, body.dark-mode   [_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Jne=(()=>{class n{constructor(e){this.store=e,this.showExperimentsGroupBy$=this.store.select(J8).pipe(q(i=>i.has(Cn.COMPARE_EXPERIMENT))),this.selectedGroupBy$=this.store.select(Dv),this.lastRegexGroupByKey$=this.store.select(Dv).pipe(q(i=>i.key),Oe(i=>i===Yn.REGEX||i===Yn.REGEX_BY_EXP),kn(Yn.REGEX)),this.groupByRegexString$=this.store.select(y1),this.expNameByExpId$=this.store.select(yu)}onGroupByChange(e){this.expNameByExpId$.pipe(Lt(1)).subscribe(i=>{this.store.dispatch(Xf({experimentIds:this.experimentIds,groupBy:e,expNameByExpId:i}))})}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["runs-group-menu-button"]],inputs:{experimentIds:"experimentIds"},decls:5,vars:13,consts:[[3,"regexString","selectedGroupBy","lastRegexGroupByKey","showExperimentsGroupBy","experimentIds","onGroupByChange"]],template:function(e,i){1&e&&(f(0,"runs-group-menu-button-component",0),A("onGroupByChange",function(o){return i.onGroupByChange(o)}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),g()),2&e&&b("regexString",G(1,5,i.groupByRegexString$))("selectedGroupBy",G(2,7,i.selectedGroupBy$))("lastRegexGroupByKey",G(3,9,i.lastRegexGroupByKey$))("showExperimentsGroupBy",G(4,11,i.showExperimentsGroupBy$))("experimentIds",i.experimentIds)},dependencies:[Kne,ct],encapsulation:2,changeDetection:0}),n})();function yHe(n,t){if(1&n){let e=Te();f(0,"div")(1,"mat-checkbox",12),A("click",function(r){return ne(e),ie(w(2).handleSelectAll(r))}),g()()}if(2&n){let e=w(2);v(1),b("checked",e.allRowsSelected())("indeterminate",!e.allRowsSelected()&&e.someRowsSelected())}}function xHe(n,t){if(1&n&&(f(0,"span",13),k(1,"runs-group-menu-button",14),g()),2&n){let e=w(2);v(1),b("experimentIds",e.experimentIds)}}var $ne=function(n){return[n]};function CHe(n,t){if(1&n&&(Gt(0),f(1,"tb-data-table-header-cell",8),Gt(2,9),S(3,yHe,2,2,"div",10),S(4,xHe,2,1,"span",11),Wt(),g(),Wt()),2&n){let e=t.$implicit,i=w();v(1),b("header",e)("sortingInfo",i.sortingInfo)("ngClass",Un(6,$ne,"table-column-"+e.name)),v(1),b("ngSwitch",e.name),v(1),b("ngSwitchCase","selected"),v(1),b("ngSwitchCase","color")}}function MHe(n,t){if(1&n){let e=Te();f(0,"span",17)(1,"button",18),A("colorPickerChange",function(r){ne(e);let o=w(2).$implicit;return ie(w().onRunColorChange.emit({runId:o.id,newColor:r}))}),g()()}if(2&n){let e=w(2).$implicit;v(1),Bt("background",e.color),b("colorPicker",e.color)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function wHe(n,t){if(1&n){let e=Te();f(0,"div")(1,"mat-checkbox",19),A("click",function(r){ne(e);let o=w(2).$implicit;return ie(w().selectionClick(r,o.id))}),g()()}if(2&n){let e=w(2).$implicit;v(1),b("checked",e.selected)}}function SHe(n,t){if(1&n&&(f(0,"span"),k(1,"tb-experiment-alias",20),g()),2&n){let e=w(2).$implicit;v(1),b("alias",e.experimentAlias)("title",e.experimentName)}}function EHe(n,t){if(1&n&&(Gt(0),f(1,"tb-data-table-content-cell",15),Gt(2,9),S(3,MHe,2,7,"span",16),S(4,wHe,2,1,"div",10),S(5,SHe,2,2,"span",10),Wt(),g(),Wt()),2&n){let e=t.$implicit,i=w().$implicit;v(1),b("header",e)("datum",i[e.name])("ngClass",Un(7,$ne,"table-column-"+e.name)),v(1),b("ngSwitch",e.name),v(1),b("ngSwitchCase","color"),v(1),b("ngSwitchCase","selected"),v(1),b("ngSwitchCase","experimentAlias")}}function THe(n,t){if(1&n&&(Gt(0),f(1,"tb-data-table-content-row"),S(2,EHe,6,9,"ng-container",5),g(),Wt()),2&n){let e=t.$implicit,i=w();v(1),Be("data-id",e.id),v(1),b("ngForOf",i.extendHeaders(i.headers))}}var eie=(()=>{class n{constructor(){this.ColumnHeaderType=gt,this.sortDataBy=new F,this.orderColumns=new F,this.onSelectionToggle=new F,this.onAllSelectionToggle=new F,this.onRegexFilterChange=new F,this.onRunColorChange=new F,this.addColumn=new F,this.removeColumn=new F,this.onSelectionDblClick=new F,this.addFilter=new F,this.loadAllColumns=new F,this.extendHeaders=_s(this.internalExtendHeaders)}internalExtendHeaders(e){return[].concat([{name:"selected",displayName:"",type:gt.CUSTOM,enabled:!0}],e,[{name:"color",displayName:"",type:gt.COLOR,enabled:!0}])}selectionClick(e,i){e.preventDefault(),1===e.detail&&this.onSelectionToggle.emit(i),2===e.detail&&this.onSelectionDblClick.emit(i)}allRowsSelected(){return this.data?.every(e=>e.selected)}someRowsSelected(){return this.data?.some(e=>e.selected)}handleSelectAll(e){e.preventDefault(),this.onAllSelectionToggle.emit(this.data?.map(i=>i.id))}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}trackByRuns(e,i){let r={...i};return delete r.color,JSON.stringify(r)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["runs-data-table"]],inputs:{headers:"headers",data:"data",sortingInfo:"sortingInfo",experimentIds:"experimentIds",regexFilter:"regexFilter",selectableColumns:"selectableColumns",numColumnsLoaded:"numColumnsLoaded",numColumnsToLoad:"numColumnsToLoad",loading:"loading",columnFilters:"columnFilters"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns",onSelectionToggle:"onSelectionToggle",onAllSelectionToggle:"onAllSelectionToggle",onRegexFilterChange:"onRegexFilterChange",onRunColorChange:"onRunColorChange",addColumn:"addColumn",removeColumn:"removeColumn",onSelectionDblClick:"onSelectionDblClick",addFilter:"addFilter",loadAllColumns:"loadAllColumns"},decls:9,vars:12,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],[1,"table-container"],[3,"headers","sortingInfo","selectableColumns","numColumnsLoaded","hasMoreColumnsToLoad","columnFilters","loading","shouldAddBorders","sortDataBy","orderColumns","addColumn","removeColumn","addFilter","loadAllColumns"],["header",""],[4,"ngFor","ngForOf"],["content",""],[4,"ngFor","ngForOf","ngForTrackBy"],[3,"header","sortingInfo","ngClass"],[3,"ngSwitch"],[4,"ngSwitchCase"],["class","group-menu-container",4,"ngSwitchCase"],[3,"checked","indeterminate","click"],[1,"group-menu-container"],[3,"experimentIds"],[3,"header","datum","ngClass"],["class","color-container",4,"ngSwitchCase"],[1,"color-container"],[1,"run-color-swatch",3,"colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],[3,"checked","click"],[3,"alias","title"]],template:function(e,i){1&e&&(f(0,"div",0)(1,"tb-filter-input",1),A("keyup",function(o){return i.onFilterKeyUp(o)}),g()(),k(2,"filterbar"),f(3,"div",2)(4,"tb-data-table",3),A("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.orderColumns.emit(o)})("addColumn",function(o){return i.addColumn.emit(o)})("removeColumn",function(o){return i.removeColumn.emit(o)})("addFilter",function(o){return i.addFilter.emit(o)})("loadAllColumns",function(){return i.loadAllColumns.emit()}),Gt(5,4),S(6,CHe,5,8,"ng-container",5),Wt(),Gt(7,6),S(8,THe,3,2,"ng-container",7),Wt(),g()()),2&e&&(v(1),Zi("value",i.regexFilter),v(3),b("headers",i.headers)("sortingInfo",i.sortingInfo)("selectableColumns",i.selectableColumns)("numColumnsLoaded",i.numColumnsLoaded)("hasMoreColumnsToLoad",i.numColumnsLoaded===i.numColumnsToLoad)("columnFilters",i.columnFilters)("loading",i.loading)("shouldAddBorders",!0),v(2),b("ngForOf",i.extendHeaders(i.headers)),v(2),b("ngForOf",i.data)("ngForTrackBy",i.trackByRuns))},dependencies:[Bne,wn,nn,mr,kr,m_,dA,mA,f_,Kg,g_,xs,Yne,Jne],styles:["[_nghost-%COMP%]{min-width:100%}.color-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.group-menu-container[_ngcontent-%COMP%]{display:flex;justify-content:center;width:100%}tb-data-table-content-row[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{height:48px}tb-data-table-content-cell[_ngcontent-%COMP%], tb-data-table-header-cell[_ngcontent-%COMP%]{padding:0 4px;vertical-align:middle;border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-content-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tb-data-table-header-cell[_ngcontent-%COMP%]{border-bottom:1px solid #555}.table-column-selected[_ngcontent-%COMP%], .table-column-color[_ngcontent-%COMP%]{width:40px}.filter-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:48px;width:100%}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{padding-left:16px;flex-grow:1}"],changeDetection:0}),n})(),IHe=W(Tv,n=>n.state===Re.LOADING),tie=(()=>{class n{constructor(e){this.store=e,this.sortedRunsTableData$=$t([]),this.loading$=null,this.sortingInfo$=this.store.select($W),this.columns=[Zl.RUN_NAME],this.regexFilter$=this.store.select(Au),this.runsColumns$=this.store.select(e7),this.selectableColumns$=this.store.select(YT),this.numColumnsLoaded$=this.store.select(Mc.getNumDashboardHparamsLoaded),this.numColumnsToLoad$=this.store.select(Mc.getNumDashboardHparamsToLoad),this.columnFilters$=this.store.select(XT),this.allRunsTableData$=this.store.select(AN).pipe(q(i=>i.map(r=>({...Object.fromEntries(r.hparams.entries()),id:r.run.id,run:r.run.name,experimentName:r.experimentName,experimentAlias:r.experimentAlias,selected:r.selected,color:r.runColor})))),this.ngUnsubscribe=new Ee}ngOnInit(){let e=this.experimentIds.map(o=>this.getRunTableItemsForExperiment(o));this.sortedRunsTableData$=In([this.allRunsTableData$,this.sortingInfo$]).pipe(q(([o,a])=>function(n,t){let e=[...n];return e.sort((r,o)=>{let a=r[t.name],s=o[t.name];if("experimentAlias"===t.name&&(a=a.aliasNumber,s=s.aliasNumber),a===s)return 0;if(void 0===a||void 0===s)return i(a,s);if(One.has(typeof a)&&One.has(typeof s)){let l=Fne(a),c=Fne(s);if((void 0===l||void 0===c)&&l!==c)return i(l,c,{insertUndefined:Pp.BEFORE});if(void 0!==l&&void 0!==c)return l===c?i(a.toString().slice(l.toString().length)||void 0,s.toString().slice(c.toString().length)||void 0,{insertUndefined:Pp.BEFORE}):i(l,c)}return i(a,s)}),e;function i(r,o,{insertUndefined:a}=GVe){return r===o?0:void 0===r?a===Pp.AFTER?1:-1:void 0===o?a===Pp.AFTER?-1:1:r<o==(t.order===Lr.ASCENDING)?-1:1}}(o,a)));let i=In(e).pipe(q(o=>[].concat(...o))),r=this.experimentIds.map(o=>this.store.select(IHe,{experimentId:o}));this.loading$=In(r).pipe(q(o=>o.some(a=>a))),this.columns.includes(Zl.CHECKBOX)&&this.store.select(Ho).pipe(it(this.ngUnsubscribe),ri((a,s)=>Vo(a,s)),Jn(()=>i.pipe(Oe(a=>a.length>500),Lt(1)))).subscribe(()=>{this.store.dispatch(tg({localizedMessage:"The number of runs exceeds 500. New runs are unselected for performance reasons."}))})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}sortDataBy(e){this.store.dispatch(VS({sortingInfo:e}))}getRunTableItemsForExperiment(e){return In([this.store.select(Iu,{experimentId:e}),this.store.select(US,{experimentId:e}),this.store.select(Ru),this.store.select(Pu),this.store.select(qs)]).pipe(q(([i,r,o,a,s])=>i.map(l=>{let c=new Map;(l.hparams||[]).forEach(u=>{c.set(u.name,u.value)});let d=new Map;return(l.metrics||[]).forEach(u=>{d.set(u.tag,u.value)}),{run:l,experimentName:r?.name||"",experimentAlias:s[e],selected:Boolean(o&&o.get(l.id)),runColor:a[l.id],hparams:c,metrics:d}})))}onRunSelectionToggle(e){this.store.dispatch(kS({runId:e}))}onRunSelectionDblClick(e){this.store.dispatch(OS({runId:e}))}onAllSelectionToggle(e){this.store.dispatch(FS({runIds:e}))}onRegexFilterChange(e){this.store.dispatch(NS({regexString:e}))}onRunColorChange({runId:e,newColor:i}){this.store.dispatch(LS({runId:e,newColor:i}))}addColumn({column:e,nextTo:i,side:r}){this.store.dispatch(ro.dashboardHparamColumnAdded({column:e,nextTo:i,side:r}))}removeColumn(e){this.store.dispatch(ro.dashboardHparamColumnRemoved({column:e}))}orderColumns(e){this.store.dispatch(ro.dashboardHparamColumnOrderChanged(e))}addHparamFilter(e){this.store.dispatch(ro.dashboardHparamFilterAdded({name:e.name,filter:e.value}))}loadAllColumns(){this.store.dispatch(ro.loadAllDashboardHparams())}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["runs-table"]],inputs:{columns:"columns",experimentIds:"experimentIds"},decls:10,vars:28,consts:[[3,"headers","data","selectableColumns","numColumnsLoaded","numColumnsToLoad","columnFilters","sortingInfo","experimentIds","regexFilter","loading","sortDataBy","orderColumns","onSelectionToggle","onAllSelectionToggle","onRunColorChange","onRegexFilterChange","onSelectionDblClick","addColumn","removeColumn","addFilter","loadAllColumns"]],template:function(e,i){1&e&&(f(0,"runs-data-table",0),A("sortDataBy",function(o){return i.sortDataBy(o)})("orderColumns",function(o){return i.orderColumns(o)})("onSelectionToggle",function(o){return i.onRunSelectionToggle(o)})("onAllSelectionToggle",function(o){return i.onAllSelectionToggle(o)})("onRunColorChange",function(o){return i.onRunColorChange(o)})("onRegexFilterChange",function(o){return i.onRegexFilterChange(o)})("onSelectionDblClick",function(o){return i.onRunSelectionDblClick(o)})("addColumn",function(o){return i.addColumn(o)})("removeColumn",function(o){return i.removeColumn(o)})("addFilter",function(o){return i.addHparamFilter(o)})("loadAllColumns",function(){return i.loadAllColumns()}),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async"),U(9,"async"),g()),2&e&&b("headers",G(1,10,i.runsColumns$))("data",G(2,12,i.sortedRunsTableData$))("selectableColumns",G(3,14,i.selectableColumns$))("numColumnsLoaded",G(4,16,i.numColumnsLoaded$))("numColumnsToLoad",G(5,18,i.numColumnsToLoad$))("columnFilters",G(6,20,i.columnFilters$))("sortingInfo",G(7,22,i.sortingInfo$))("experimentIds",i.experimentIds)("regexFilter",G(8,24,i.regexFilter$))("loading",G(9,26,i.loading$))},dependencies:[eie,ct],styles:["[_nghost-%COMP%] {\n        display: flex;\n        position: relative;\n      }\n\n      tb-data-table[_ngcontent-%COMP%] {\n        overflow-y: scroll;\n        width: 100%;\n      }"],changeDetection:0}),n})(),nie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["runs-selector-component"]],inputs:{experimentIds:"experimentIds",columns:"columns"},decls:1,vars:2,consts:[[3,"columns","experimentIds"]],template:function(e,i){1&e&&k(0,"runs-table",0),2&e&&b("columns",i.columns)("experimentIds",i.experimentIds)},dependencies:[tie],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n        width: 100%;\n        overflow: auto;\n      }\n\n      runs-table[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0}),n})(),iie=(()=>{class n{constructor(e){this.store=e,this.experimentIds$=this.store.select(or).pipe(q(i=>i??[])),this.columns$=this.store.select(or).pipe(q(i=>[Zl.CHECKBOX,Zl.RUN_NAME,i&&i.length>1?Zl.EXPERIMENT_NAME:null,Zl.RUN_COLOR].filter(r=>null!==r)))}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["runs-selector"]],decls:3,vars:6,consts:[[3,"experimentIds","columns"]],template:function(e,i){1&e&&(k(0,"runs-selector-component",0),U(1,"async"),U(2,"async")),2&e&&b("experimentIds",G(1,2,i.experimentIds$))("columns",G(2,4,i.columns$))},dependencies:[nie,ct],encapsulation:2,changeDetection:0}),n})();function kHe(n,t){1&n&&k(0,"metrics-main-view",2)}var rie=(()=>{class n{constructor(e){this.store=e,this.runsTableFullScreen$=this.store.select(wS)}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["metrics-dashboard"]],decls:4,vars:3,consts:[["sidebar",""],["main","",4,"ngIf"],["main",""]],template:function(e,i){1&e&&(f(0,"tb-dashboard-layout"),k(1,"runs-selector",0),S(2,kHe,1,0,"metrics-main-view",1),U(3,"async"),g()),2&e&&(v(2),b("ngIf",!G(3,1,i.runsTableFullScreen$)))},dependencies:[Ne,_Q,kne,iie,ct],styles:["[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column;height:100%;justify-content:stretch;overflow:hidden}.notice[_ngcontent-%COMP%]{background-color:rgba(255,245,157,.85);border-bottom:1px solid #ffeb3b;color:#212121;display:block;flex:0 0}tb-dashboard-layout[_ngcontent-%COMP%]{flex:1 1;overflow:hidden}nav[_ngcontent-%COMP%]{background-color:#fff;border-right:1px solid #ebebeb;flex:none;width:340px}body.dark-mode[_nghost-%COMP%]   nav[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   nav[_ngcontent-%COMP%]{background-color:#303030;border-right-color:#555}metrics-main-view[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})(),kV=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai,Kn]}),n})(),xA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),OV=(()=>{class n{constructor(){this.changes=new Ee,this.itemsPerPageLabel="Items per page:",this.nextPageLabel="Next page",this.previousPageLabel="Previous page",this.firstPageLabel="First page",this.lastPageLabel="Last page",this.getRangeLabel=(e,i,r)=>{if(0==r||0==i)return`0 of ${r}`;let o=e*i;return`${o+1} \u2013 ${o<(r=Math.max(r,0))?Math.min(o+i,r):o+i} of ${r}`}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),FHe={provide:OV,deps:[[new ka,new id,OV]],useFactory:function(n){return n||new OV}},oie=(new te("MAT_PAGINATOR_DEFAULT_OPTIONS"),ao(H1(class{})),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[FHe],imports:[De,Kn,Xa,Xg]}),n})()),kp=(new te("MAT_SORT_DEFAULT_OPTIONS"),H1(ao(class{})),L7.ENTERING+" "+N7.STANDARD_CURVE),FV=(fr("indicator",[Si("active-asc, asc",rn({transform:"translateY(0px)"})),Si("active-desc, desc",rn({transform:"translateY(10px)"})),bi("active-asc <=> active-desc",Mi(kp))]),fr("leftPointer",[Si("active-asc, asc",rn({transform:"rotate(-45deg)"})),Si("active-desc, desc",rn({transform:"rotate(45deg)"})),bi("active-asc <=> active-desc",Mi(kp))]),fr("rightPointer",[Si("active-asc, asc",rn({transform:"rotate(45deg)"})),Si("active-desc, desc",rn({transform:"rotate(-45deg)"})),bi("active-asc <=> active-desc",Mi(kp))]),fr("arrowOpacity",[Si("desc-to-active, asc-to-active, active",rn({opacity:1})),Si("desc-to-hint, asc-to-hint, hint",rn({opacity:.54})),Si("hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void",rn({opacity:0})),bi("* => asc, * => desc, * => active, * => hint, * => void",Mi("0ms")),bi("* <=> *",Mi(kp))]),fr("arrowPosition",[bi("* => desc-to-hint, * => desc-to-active",Mi(kp,Bb([rn({transform:"translateY(-25%)"}),rn({transform:"translateY(0)"})]))),bi("* => hint-to-desc, * => active-to-desc",Mi(kp,Bb([rn({transform:"translateY(0)"}),rn({transform:"translateY(25%)"})]))),bi("* => asc-to-hint, * => asc-to-active",Mi(kp,Bb([rn({transform:"translateY(25%)"}),rn({transform:"translateY(0)"})]))),bi("* => hint-to-asc, * => active-to-asc",Mi(kp,Bb([rn({transform:"translateY(0)"}),rn({transform:"translateY(-25%)"})]))),Si("desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active",rn({transform:"translateY(0)"})),Si("hint-to-desc, active-to-desc, desc",rn({transform:"translateY(-25%)"})),Si("hint-to-asc, active-to-asc, asc",rn({transform:"translateY(25%)"}))]),fr("allowChildren",[bi("* <=> *",[rh("@*",ih(),{optional:!0})])]),(()=>{class n{constructor(){this.changes=new Ee}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac,providedIn:"root"}),n})()),LHe={provide:FV,deps:[[new ka,new id,FV]],useFactory:function(n){return n||new FV}},aie=(ao(class{}),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[LHe],imports:[De,dn]}),n})());function VV(n){return class extends n{get sticky(){return this._sticky}set sticky(t){let e=this._sticky;this._sticky=vt(t),this._hasStickyChanged=e!==this._sticky}hasStickyChanged(){let t=this._hasStickyChanged;return this._hasStickyChanged=!1,t}resetStickyChanged(){this._hasStickyChanged=!1}constructor(...t){super(...t),this._sticky=!1,this._hasStickyChanged=!1}}}var HV=new te("CDK_TABLE"),sie=(new te("text-column-options"),VV(class{}),new te("_COALESCED_STYLE_SCHEDULER"),(()=>{class n{constructor(e,i){this.template=e,this._differs=i}ngOnChanges(e){if(!this._columnsDiffer){let i=e.columns&&e.columns.currentValue||[];this._columnsDiffer=this._differs.find(i).create(),this._columnsDiffer.diff(i)}}getColumnsDiff(){return this._columnsDiffer.diff(this.columns)}extractCellTemplate(e){return this instanceof lie?e.headerCell.template:this instanceof cie?e.footerCell.template:e.cell.template}}return n.\u0275fac=function(e){return new(e||n)(C(oi),C(Tl))},n.\u0275dir=Me({type:n,features:[qt]}),n})()),VHe=VV(class extends sie{}),lie=(()=>{class n extends VHe{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(oi),C(Tl),C(HV,8))},n.\u0275dir=Me({type:n,selectors:[["","cdkHeaderRowDef",""]],inputs:{columns:["cdkHeaderRowDef","columns"],sticky:["cdkHeaderRowDefSticky","sticky"]},features:[Xe,qt]}),n})(),HHe=VV(class extends sie{}),cie=(()=>{class n extends HHe{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(C(oi),C(Tl),C(HV,8))},n.\u0275dir=Me({type:n,selectors:[["","cdkFooterRowDef",""]],inputs:{columns:["cdkFooterRowDef","columns"],sticky:["cdkFooterRowDefSticky","sticky"]},features:[Xe,qt]}),n})(),die=(new te("CDK_SPL"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Cd]}),n})()),uie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[dn,die,dn]}),n})(),CA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai,Xg]}),n})(),pie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai,rl,Kn,Gu,Xg]}),n})(),v_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ep,Gu]}),n})(),y_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,pA,ai]}),n})(),MA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,kc,y_,v_]}),n})(),hie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai,Kn]}),n})(),wA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai,Kn,ol,CA,pie,MA,hie]}),n})(),mie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),x_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,mie]}),n})(),fie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Vne,De,wA,x_,y_,Kn,kc,Hu,rl,MA,ai,Qu,qne,oie,ol,aie,uie,v_,Q1,Xa,uE]}),n})(),gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,fie]}),n})(),C_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),SA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai]}),n})(),_ie=(()=>{class n{constructor(){this.onTimeSelectionChanged=new F,this.onTimeSelectionToggled=new F,this.axisDirection=va.VERTICAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)}}getAxisPositionFromStartStep(){return this.temporalScale(this.timeSelection.start.step)}getAxisPositionFromEndStep(){return null===this.timeSelection.end?null:this.temporalScale(this.timeSelection.end.step)}getHighestStep(){return this.steps[this.steps.length-1]}getLowestStep(){return this.steps[0]}getStepHigherThanAxisPosition(e){let i=0;for(;e>this.temporalScale(this.steps[i])&&i<this.steps.length-1;)i++;return this.steps[i]}getStepLowerThanAxisPosition(e){let i=this.steps.length-1;for(;e<this.temporalScale(this.steps[i])&&i>0;)i--;return this.steps[i]}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["histogram-card-fob-controller"]],inputs:{steps:"steps",timeSelection:"timeSelection",temporalScale:"temporalScale"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:7,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","highestStep","lowestStep","cardFobHelper","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(f(0,"card-fob-controller",0),A("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(){return i.onTimeSelectionToggled.emit()}),g()),2&e&&b("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("cardFobHelper",i.cardFobHelper)},dependencies:[fA],encapsulation:2,changeDetection:0}),n})(),bie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[SA,De,tp,C_]}),n})();sb(gA,[nn,Ne,Vh,Qg,_ie],[]);var M_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De]}),n})(),EA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,x_]}),n})(),w_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,ai]}),n})(),vie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,bie,Kn,ai,ol,EA,M_,w_]}),n})(),TA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),yie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,TA,Kn,ai,ol,ep,EA,M_,w_]}),n})(),xie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Do,Kn,ai,rl,Qu]}),n})(),DA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Do,xie,tp]}),n})(),Cie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,TA,Gu,Kn,Hu,rl,Xa,KS]}),n})(),Mie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,wA]}),n})(),wie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[SA,De,DA]}),n})(),Sie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Cie,x_,C_,DA,Kn,ai,Qu,ol,tp,Mie,wie,M_,w_]}),n})(),Eie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,yie,Sie,vie,C_]}),n})(),Tie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Xa]}),n})(),Die=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Kn,Hu]}),n})(),IA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,Tie,Kn,UT,kc,Die,ai,Xa,ep,Mu,v_]}),n})(),Iie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,CA,kc,yE,ai,Kn]}),n})(),Aie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Eie,De,xA,y_,pA,Kn,UT,ai,rl,ol,IA,Iie,Cd]}),n})(),Rie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,xA,kV,Aie,ai,IA,gie]}),n})(),GHe="Max pin limit exceeded. Remove existing pins before adding more. See https://github.com/tensorflow/tensorboard/issues/4242";function WHe(){return[{actionCreator:np,alertFromAction:n=>{let{wasPinned:t,canCreateNewPins:e}=n;return t||e?null:{localizedMessage:GHe}}}]}function qHe(){return W(_d,n=>({scalarSmoothing:n}))}function XHe(){return W(Ch,n=>({ignoreOutliers:n}))}function YHe(){return W(xh,n=>({tooltipSort:String(n)}))}function QHe(){return W(p1,n=>({timeSeriesSettingsPaneOpened:n}))}function ZHe(){return W(Jf,n=>({timeSeriesCardMinWidth:n}))}function KHe(){return W(Cv,n=>({stepSelectorEnabled:n}))}function JHe(){return W(Tu,n=>({rangeSelectionEnabled:n}))}function $He(){return W(Eu,n=>({linkedTimeEnabled:n}))}function e5e(){return W(bd,n=>({savingPinsEnabled:n}))}function t5e(){return W(Mv,n=>({singleSelectionHeaders:n}))}function n5e(){return W(wv,n=>({rangeSelectionHeaders:n}))}var Pie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:SN,useFactory:hQ,deps:[EN]},{provide:EN,useValue:$S}],imports:[De,Nf,Qs,Oc.forPlugin(_v,rie),KS,Rie,wr.forFeature(JS,uQ,SN),CW,Mu,iv,to.forFeature([pQ]),Cc.registerAlertActions(WHe),Ri.defineGlobalSetting(qHe),Ri.defineGlobalSetting(XHe),Ri.defineGlobalSetting(YHe),Ri.defineGlobalSetting(QHe),Ri.defineGlobalSetting(ZHe),Ri.defineGlobalSetting(KHe),Ri.defineGlobalSetting(JHe),Ri.defineGlobalSetting($He),Ri.defineGlobalSetting(t5e),Ri.defineGlobalSetting(n5e),Ri.defineGlobalSetting(e5e)]}),n})(),kie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[iQ,Pie]}),n})(),Xd=(()=>(function(n){n.CUSTOM_ELEMENT="CUSTOM_ELEMENT",n.IFRAME="IFRAME",n.NG_COMPONENT="NG_COMPONENT",n.NONE="NONE"}(Xd||(Xd={})),Xd))(),i5e=["pluginContainer"],r5e=["ngPluginContainer"];function o5e(n,t){1&n&&hi(0)}function a5e(n,t){if(1&n&&(Gt(0),S(1,o5e,1,0,"ng-container",9),Wt()),2&n){let e=w(2),i=st(6);v(1),b("ngTemplateOutlet",e.environmentFailureNotFoundTemplate?e.environmentFailureNotFoundTemplate:i)}}function s5e(n,t){1&n&&hi(0)}function l5e(n,t){if(1&n&&(Gt(0),S(1,s5e,1,0,"ng-container",9),Wt()),2&n){let e=w(2),i=st(6);v(1),b("ngTemplateOutlet",e.environmentFailurePermissionDeniedTemplate?e.environmentFailurePermissionDeniedTemplate:i)}}function c5e(n,t){1&n&&hi(0)}function d5e(n,t){if(1&n&&(Gt(0),S(1,c5e,1,0,"ng-container",9),Wt()),2&n){let e=w(2),i=st(6);v(1),b("ngTemplateOutlet",e.environmentFailureUnknownTemplate?e.environmentFailureUnknownTemplate:i)}}function u5e(n,t){if(1&n&&(Gt(0),f(1,"h3",10),T(2," There\u2019s no dashboard by the name of \u201c"),f(3,"code"),T(4),g(),T(5,"\u201d. "),g(),f(6,"p"),T(7,"You can select a dashboard from the list above."),g(),f(8,"p"),hi(9,11),g(),Wt()),2&n){let e=w(2),i=st(8);v(4),kt(e.activePluginId),v(5),b("ngTemplateOutlet",i)}}function p5e(n,t){if(1&n&&(Gt(0),f(1,"h3",12),T(2," No dashboards are active for the current data set. "),g(),f(3,"p"),T(4,"Probable causes:"),g(),f(5,"ul")(6,"li"),T(7,"You haven\u2019t written any data to your event files."),g(),f(8,"li"),T(9,"TensorBoard can\u2019t find your event files."),g()(),T(10," If you\u2019re new to using TensorBoard, and want to find out how to add data and set up your event files, check out the "),f(11,"a",13),T(12,"README"),g(),T(13," and perhaps the "),f(14,"a",14),T(15,"TensorBoard tutorial"),g(),T(16,". "),f(17,"p"),T(18," If you think TensorBoard is configured properly, please see "),f(19,"a",15),T(20,"the section of the README devoted to missing data problems"),g(),T(21," and consider filing an issue on GitHub. "),g(),f(22,"p"),hi(23,11),g(),Wt()),2&n){w(2);let e=st(8);v(23),b("ngTemplateOutlet",e)}}function h5e(n,t){if(1&n&&(f(0,"div",6)(1,"div",7),S(2,a5e,2,1,"ng-container",8),S(3,l5e,2,1,"ng-container",8),S(4,d5e,2,1,"ng-container",8),S(5,u5e,10,2,"ng-container",8),S(6,p5e,24,1,"ng-container",8),g()()),2&n){let e=w();b("ngSwitch",e.pluginLoadState),v(2),b("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_NOT_FOUND),v(1),b("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_PERMISSION_DENIED),v(1),b("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_UNKNOWN),v(1),b("ngSwitchCase",e.PluginLoadState.UNKNOWN_PLUGIN_ID),v(1),b("ngSwitchCase",e.PluginLoadState.NO_ENABLED_PLUGINS)}}function m5e(n,t){if(1&n&&(f(0,"h3",16),T(1,"Data could not be loaded."),g(),f(2,"p"),T(3,"The TensorBoard server may be down or inaccessible."),g(),f(4,"p"),hi(5,11),g()),2&n){w();let e=st(8);v(5),b("ngTemplateOutlet",e)}}function f5e(n,t){if(1&n&&(f(0,"p",19)(1,"i"),T(2,"Log directory: "),f(3,"span"),T(4),g()()()),2&n){let e=w(2);v(4),kt(e.dataLocation)}}function g5e(n,t){if(1&n&&(f(0,"span",17),T(1),U(2,"date"),g(),S(3,f5e,5,1,"p",18)),2&n){let e=w();v(1),Ve("Last reload: ",Jp(2,2,e.lastUpdated,"medium"),""),v(2),b("ngIf",e.dataLocation)}}var _5e=function(n){return{plugins:!0,"is-first-party-plugin":n}},ul=(()=>(function(n){n[n.ENVIRONMENT_FAILURE_NOT_FOUND=0]="ENVIRONMENT_FAILURE_NOT_FOUND",n[n.ENVIRONMENT_FAILURE_PERMISSION_DENIED=1]="ENVIRONMENT_FAILURE_PERMISSION_DENIED",n[n.ENVIRONMENT_FAILURE_UNKNOWN=2]="ENVIRONMENT_FAILURE_UNKNOWN",n[n.NO_ENABLED_PLUGINS=3]="NO_ENABLED_PLUGINS",n[n.UNKNOWN_PLUGIN_ID=4]="UNKNOWN_PLUGIN_ID",n[n.LOADED=5]="LOADED",n[n.LOADING=6]="LOADING"}(ul||(ul={})),ul))(),Oie=(()=>{class n{constructor(e,i,r){this.componentFactoryResolver=e,this.pluginRegistry=i,this.pluginApiHost=r,this.PluginLoadState=ul,this.LoadingMechanismType=Xd,this.pluginInstances=new Map}ngOnChanges(e){if(!this.isFeatureFlagsLoaded||!this.activeKnownPlugin||this.settingsLoadState===Re.NOT_LOADED||this.settingsLoadState===Re.LOADING)return;let i=Boolean(this.activeKnownPlugin&&!this.pluginInstances.has(this.activeKnownPlugin.id));if(e.activeKnownPlugin||e.isFeatureFlagsLoaded||e.settingsLoadState){let r=e.activeKnownPlugin?.previousValue;if(r&&r.id!==this.activeKnownPlugin.id&&this.hidePlugin(r),i){let o=this.createPlugin(this.activeKnownPlugin);o&&this.pluginInstances.set(this.activeKnownPlugin.id,o)}else this.showPlugin(this.activeKnownPlugin)}(i||e.lastUpdated)&&this.reload(this.activeKnownPlugin,i)}hidePlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:0,overflow:"hidden",visibility:"hidden",position:"absolute"})}showPlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:null,overflow:null,visibility:null,position:null})}createPlugin(e){let i=null;switch(e.loading_mechanism.type){case Xd.CUSTOM_ELEMENT:i=document.createElement(e.loading_mechanism.element_name),i.reloadOnReady=!1,i.featureFlags=this.featureFlags,this.pluginsContainer.nativeElement.appendChild(i);break;case Xd.IFRAME:if(!this.pluginApiHost)throw Error(`IFRAME-based plugins not supported: ${e.id}`);i=document.createElement("iframe"),i.setAttribute("src",`data/plugin_entry.html?name=${e.id}`),this.pluginApiHost.registerPluginIframe(i,e.id),this.pluginsContainer.nativeElement.appendChild(i);break;case Xd.NG_COMPONENT:let r=this.pluginRegistry.getComponent(e.id);if(r){let o=this.componentFactoryResolver.resolveComponentFactory(r);i=this.ngPluginContainer.createComponent(o).location.nativeElement}else console.error(`No registered Angular component for plugin: ${e.id}`);break;case Xd.NONE:break;default:console.error("Unexpected plugin")}return i}reload(e,i){if(!i&&e.disable_reload)return;let r=this.pluginInstances.get(e.id);r&&r.reload&&r.reload()}}return n.\u0275fac=function(e){return new(e||n)(C(ho),C(Oc),C(R1,8))},n.\u0275cmp=P({type:n,selectors:[["plugins-component"]],viewQuery:function(e,i){if(1&e&&(Ue(i5e,7,xe),Ue(r5e,7,ei)),2&e){let r;be(r=ve())&&(i.pluginsContainer=r.first),be(r=ve())&&(i.ngPluginContainer=r.first)}},inputs:{activePluginId:"activePluginId",activeKnownPlugin:"activeKnownPlugin",pluginLoadState:"pluginLoadState",dataLocation:"dataLocation",isFeatureFlagsLoaded:"isFeatureFlagsLoaded",settingsLoadState:"settingsLoadState",featureFlags:"featureFlags",lastUpdated:"lastUpdated",environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},features:[qt],decls:9,vars:4,consts:[[3,"ngClass"],["pluginContainer",""],["ngPluginContainer",""],["class","warning",3,"ngSwitch",4,"ngIf"],["environmentFailureDefaultTemplate",""],["dateAndDataLocation",""],[1,"warning",3,"ngSwitch"],[1,"warning-message"],[4,"ngSwitchCase"],[4,"ngTemplateOutlet"],[1,"unknown-plugin"],[3,"ngTemplateOutlet"],[1,"no-active-plugin"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md"],["href","https://www.tensorflow.org/get_started/summaries_and_tensorboard"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"],[1,"environment-not-loaded"],[1,"last-reload-time"],["class","data-location",4,"ngIf"],[1,"data-location"]],template:function(e,i){1&e&&(f(0,"div",0,1),hi(2,null,2),g(),S(4,h5e,7,6,"div",3),S(5,m5e,6,1,"ng-template",null,4,jt),S(7,g5e,4,5,"ng-template",null,5,jt)),2&e&&(b("ngClass",Un(2,_5e,(null==i.activeKnownPlugin?null:i.activeKnownPlugin.loading_mechanism.type)!==i.LoadingMechanismType.IFRAME)),v(4),b("ngIf",i.pluginLoadState!==i.PluginLoadState.LOADED&&i.pluginLoadState!==i.PluginLoadState.LOADING))},dependencies:[wn,Ne,eo,mr,kr,wf],styles:["[_nghost-%COMP%]{background-color:#fff;color:#212121;display:block;position:relative}body.dark-mode   [_nghost-%COMP%]   .plugins.is-first-party-plugin[_ngcontent-%COMP%]{background-color:#303030;color:#fff}.plugins[_ngcontent-%COMP%]{height:100%;position:relative}.warning[_ngcontent-%COMP%]{background:#fff;bottom:0;left:0;position:absolute;right:0;top:0}body.dark-mode[_nghost-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning[_ngcontent-%COMP%]{background:#303030}.warning-message[_ngcontent-%COMP%]{color:#212121;margin:80px auto 0;max-width:540px}body.dark-mode[_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%]{color:#fff}.last-reload-time[_ngcontent-%COMP%]{font-style:italic}.plugins[_ngcontent-%COMP%]     iframe{border:0;display:block;height:100%;width:100%}"],changeDetection:0}),n})(),b5e=W(Gf,Zo,(n,t)=>t&&n[t]?Object.assign({id:t},n[t]):null),AA=(()=>{class n{constructor(e){this.store=e,this.activeKnownPlugin$=this.store.select(b5e),this.activePluginId$=this.store.select(Zo),this.pluginLoadState$=In(this.activeKnownPlugin$,this.activePluginId$,this.store.select(xS)).pipe(q(([i,r,o])=>null!==o.failureCode?o.failureCode===Ys.NOT_FOUND?ul.ENVIRONMENT_FAILURE_NOT_FOUND:o.failureCode===Ys.PERMISSION_DENIED?ul.ENVIRONMENT_FAILURE_PERMISSION_DENIED:ul.ENVIRONMENT_FAILURE_UNKNOWN:null!==i?ul.LOADED:null===o.lastLoadedTimeInMs&&o.state===Re.LOADING?ul.LOADING:r?ul.UNKNOWN_PLUGIN_ID:ul.NO_ENABLED_PLUGINS)),this.lastLoadedTimeInMs$=this.store.select(jf),this.dataLocation$=this.store.select(CS).pipe(q(i=>i.data_location)),this.isFeatureFlagsLoaded$=this.store.select(bu),this.featureFlags$=this.store.select(Qo),this.settingsLoadState$=this.store.select(Ha.getSettingsLoadState)}}return n.\u0275fac=function(e){return new(e||n)(C(Ie))},n.\u0275cmp=P({type:n,selectors:[["plugins"]],inputs:{environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},decls:9,vars:27,consts:[[3,"activeKnownPlugin","activePluginId","dataLocation","lastUpdated","pluginLoadState","isFeatureFlagsLoaded","settingsLoadState","featureFlags","environmentFailureNotFoundTemplate","environmentFailurePermissionDeniedTemplate","environmentFailureUnknownTemplate"]],template:function(e,i){1&e&&(k(0,"plugins-component",0),U(1,"async"),U(2,"async"),U(3,"async"),U(4,"async"),U(5,"async"),U(6,"async"),U(7,"async"),U(8,"async")),2&e&&b("activeKnownPlugin",G(1,11,i.activeKnownPlugin$))("activePluginId",G(2,13,i.activePluginId$))("dataLocation",G(3,15,i.dataLocation$))("lastUpdated",G(4,17,i.lastLoadedTimeInMs$))("pluginLoadState",G(5,19,i.pluginLoadState$))("isFeatureFlagsLoaded",G(6,21,i.isFeatureFlagsLoaded$))("settingsLoadState",G(7,23,i.settingsLoadState$))("featureFlags",G(8,25,i.featureFlags$))("environmentFailureNotFoundTemplate",i.environmentFailureNotFoundTemplate)("environmentFailurePermissionDeniedTemplate",i.environmentFailurePermissionDeniedTemplate)("environmentFailureUnknownTemplate",i.environmentFailureUnknownTemplate)},styles:["plugins-component[_ngcontent-%COMP%] { height: 100%; }"],changeDetection:0}),n})(),RA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[Qs,De,Oc]}),n})();sb(AA,[Oie],[ct]);var Fie=(()=>{class n{constructor(e,i){this.store=e,this.document=i,this.onVisibilityChange=this.onVisibilityChangeImpl.bind(this),this.reloadEnabled$=this.store.pipe(un(Ha.getReloadEnabled)),this.reloadPeriodInMs$=this.store.pipe(un(Ha.getReloadPeriodInMs)),this.reloadTimerId=null,this.missedAutoReload=!1,this.ngUnsubscribe=new Ee}ngOnInit(){this.document.addEventListener("visibilitychange",this.onVisibilityChange),In(this.reloadEnabled$.pipe(ri()),this.reloadPeriodInMs$.pipe(ri())).pipe(it(this.ngUnsubscribe)).subscribe(([e,i])=>{this.cancelLoad(),e&&this.load(i)})}onVisibilityChangeImpl(){"visible"===this.document.visibilityState&&this.missedAutoReload&&(this.missedAutoReload=!1,this.store.dispatch(ma()))}load(e){this.reloadTimerId=setTimeout(()=>{"visible"===this.document.visibilityState?this.store.dispatch(ma()):this.missedAutoReload=!0,this.load(e)},e)}cancelLoad(){null!==this.reloadTimerId&&clearTimeout(this.reloadTimerId),this.reloadTimerId=null}ngOnDestroy(){this.cancelLoad(),this.document.removeEventListener("visibilitychange",this.onVisibilityChange),this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(C(Ie),C(Nt))},n.\u0275cmp=P({type:n,selectors:[["reloader"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Nie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=P({type:n,selectors:[["tensorboard-wrapper-component"]],decls:2,vars:0,consts:[[1,"plugins"]],template:function(e,i){1&e&&k(0,"plugins",0)(1,"reloader")},dependencies:[AA,Fie],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        flex: 1 1;\n        overflow: auto;\n        position: relative;\n      }"],changeDetection:0}),n})(),Lie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ue({token:n,factory:n.\u0275fac}),n})(),zV="smoothing",UV="runColorGroup",jV="tagFilter",GV="runFilter",WV="regex:",qV="regex_by_exp:",PA=class extends Lie{getMetricsPinnedCards(t){return In([t.select(Kf),t.select(PW)]).pipe(q(([e,i])=>{if(!e.length&&!i.length)return[];let o=[...e.map(({plugin:a,tag:s,sample:l,runId:c})=>{let d={plugin:a,tag:s};return gs(a)&&(d.runId=c),fs(a)&&(d.sample=l),d}),...i];return[{key:"pinnedCards",value:JSON.stringify(o)}]}))}serializeStateToQueryParams(t){return In([this.getMetricsPinnedCards(t),t.select(Fl).pipe(q(e=>e?[{key:jV,value:e}]:[])),In([t.select(sv),t.select(fh)]).pipe(q(([e,i])=>function(n,t){return Object.entries(n).map(([e,i])=>{if(void 0===i)return{};let r=t[e];return r&&r.queryParamOverride?{key:r.queryParamOverride,value:i?.toString()}:{}}).filter(({key:e,value:i})=>e&&void 0!==i)}(e,i))),t.select(FW).pipe(q(e=>Number.isFinite(e.scalarSmoothing)?[{key:zV,value:String(e.scalarSmoothing)}]:[])),t.select(t2).pipe(q(e=>{if(!e)return[];let i;switch(e.key){case Yn.EXPERIMENT:i="experiment";break;case Yn.RUN:i="run";break;case Yn.REGEX:i=`${WV}${e.regexString}`;break;case Yn.REGEX_BY_EXP:i=`${qV}${e.regexString}`;break;default:throw new RangeError("Serialization not implemented")}return[{key:UV,value:i}]})),t.select(Au).pipe(q(e=>e?[{key:GV,value:e}]:[]))]).pipe(Vi(t.select(B6)),q(([e,i])=>{let r=new Set(e.flat().map(a=>a.key)),o=Object.entries(i).filter(([a])=>!r.has(a)).map(([a,s])=>({key:a,value:s}));return[...e,...o].flat()}))}deserializeQueryParams(t){let e=null,i=null,r=null,o=null,a=null,s={};for(let{key:l,value:c}of t)switch(l){case"pinnedCards":e=x5e(c);break;case zV:i=Number(c);break;case UV:switch(c){case"experiment":o={key:Yn.EXPERIMENT};break;case"run":o={key:Yn.RUN}}if(c.startsWith(WV)){let d=c.slice(WV.length);o={key:Yn.REGEX,regexString:d}}if(c.startsWith(qV)){let d=c.slice(qV.length);o={key:Yn.REGEX_BY_EXP,regexString:d}}break;case jV:r=c;break;case GV:a=c;break;default:s[l]=c}return{unknownQueryParams:s,metrics:{pinnedCards:e||[],smoothing:i,tagFilter:r},runs:{groupBy:o,regexFilter:a}}}};function x5e(n){let t;try{t=JSON.parse(n)}catch{return null}if(!Array.isArray(t))return null;let e=[];for(let i of t){let o="string"==typeof i.runId,a="number"==typeof i.sample;if(!("string"==typeof i.plugin&&"string"==typeof i.tag&&(o||typeof i.runId>"u")&&(a||typeof i.sample>"u")&&aW(i.plugin)&&i.tag))continue;if(gs(i.plugin)){if(!i.runId)continue}else if(i.runId)continue;if(a&&(!fs(i.plugin)||!Number.isInteger(i.sample)||i.sample<0))continue;let d={plugin:i.plugin,tag:i.tag};o&&(d.runId=i.runId),a&&(d.sample=i.sample),e.push(d)}return e}function Vie(){return[{routeKind:Cn.EXPERIMENT,path:"/",ngComponent:Nie,defaultRoute:!0,deepLinkProvider:new PA}]}function Hie(){return n=>(t,e)=>n(t,e)}PA=V4([Oz()],PA);var zie=new te("Root reducers token",{factory:()=>({})}),Uie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({providers:[{provide:Df,useFactory:Hie,multi:!0}],imports:[wr.forRoot(zie,{runtimeChecks:{strictStateImmutability:!0,strictActionImmutability:!0,strictActionSerializability:!1,strictStateSerializability:!1}}),to.forRoot([])]}),n})(),jie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({}),n})(),Gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n}),n.\u0275inj=H({imports:[De,RA,jie]}),n})(),XV=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=z({type:n,bootstrap:[TX]}),n.\u0275inj=H({imports:[Mu,LX,ww,ZG,Nf,DX,Rl.registerRoutes(Vie),Q1,Y1,IX,Gie,Qs,FX,RX,VX,RS,HX,PX,iv,R1,RA,E1,xE,Uie,kie]}),n})();"loading"!==document.readyState?lO().bootstrapModule(XV):window.addEventListener("DOMContentLoaded",()=>{lO().bootstrapModule(XV)})})();
/** vim: et:ts=4:sw=4:sts=4
 * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
 */
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */

var requirejs, require, define;
(function (global, setTimeout) {
    var req, s, head, baseElement, dataMain, src,
        interactiveScript, currentlyAddingScript, mainScript, subPath,
        version = '2.3.6',
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
        jsSuffixRegExp = /\.js$/,
        currDirRegExp = /^\.\//,
        op = Object.prototype,
        ostring = op.toString,
        hasOwn = op.hasOwnProperty,
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
        //PS3 indicates loaded and complete, but need to wait for complete
        //specifically. Sequence is 'loading', 'loaded', execution,
        // then 'complete'. The UA check is unfortunate, but not sure how
        //to feature test w/o causing perf issues.
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                      /^complete$/ : /^(complete|loaded)$/,
        defContextName = '_',
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
        contexts = {},
        cfg = {},
        globalDefQueue = [],
        useInteractive = false;

    //Could match something like ')//comment', do not lose the prefix to comment.
    function commentReplace(match, singlePrefix) {
        return singlePrefix || '';
    }

    function isFunction(it) {
        return ostring.call(it) === '[object Function]';
    }

    function isArray(it) {
        return ostring.call(it) === '[object Array]';
    }

    /**
     * Helper function for iterating over an array. If the func returns
     * a true value, it will break out of the loop.
     */
    function each(ary, func) {
        if (ary) {
            var i;
            for (i = 0; i < ary.length; i += 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    /**
     * Helper function for iterating over an array backwards. If the func
     * returns a true value, it will break out of the loop.
     */
    function eachReverse(ary, func) {
        if (ary) {
            var i;
            for (i = ary.length - 1; i > -1; i -= 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    function hasProp(obj, prop) {
        return hasOwn.call(obj, prop);
    }

    function getOwn(obj, prop) {
        return hasProp(obj, prop) && obj[prop];
    }

    /**
     * Cycles over properties in an object and calls a function for each
     * property value. If the function returns a truthy value, then the
     * iteration is stopped.
     */
    function eachProp(obj, func) {
        var prop;
        for (prop in obj) {
            if (hasProp(obj, prop)) {
                if (func(obj[prop], prop)) {
                    break;
                }
            }
        }
    }

    /**
     * Simple function to mix in properties from source into target,
     * but only if target does not already have a property of the same name.
     */
    function mixin(target, source, force, deepStringMixin) {
        if (source) {
            eachProp(source, function (value, prop) {
                if (force || !hasProp(target, prop)) {
                    if (deepStringMixin && typeof value === 'object' && value &&
                        !isArray(value) && !isFunction(value) &&
                        !(value instanceof RegExp)) {

                        if (!target[prop]) {
                            target[prop] = {};
                        }
                        mixin(target[prop], value, force, deepStringMixin);
                    } else {
                        target[prop] = value;
                    }
                }
            });
        }
        return target;
    }

    //Similar to Function.prototype.bind, but the 'this' object is specified
    //first, since it is easier to read/figure out what 'this' will be.
    function bind(obj, fn) {
        return function () {
            return fn.apply(obj, arguments);
        };
    }

    function scripts() {
        return document.getElementsByTagName('script');
    }

    function defaultOnError(err) {
        throw err;
    }

    //Allow getting a global that is expressed in
    //dot notation, like 'a.b.c'.
    function getGlobal(value) {
        if (!value) {
            return value;
        }
        var g = global;
        each(value.split('.'), function (part) {
            g = g[part];
        });
        return g;
    }

    /**
     * Constructs an error with a pointer to an URL with more information.
     * @param {String} id the error ID that maps to an ID on a web page.
     * @param {String} message human readable error.
     * @param {Error} [err] the original error, if there is one.
     *
     * @returns {Error}
     */
    function makeError(id, msg, err, requireModules) {
        var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
        e.requireType = id;
        e.requireModules = requireModules;
        if (err) {
            e.originalError = err;
        }
        return e;
    }

    if (typeof define !== 'undefined') {
        //If a define is already in play via another AMD loader,
        //do not overwrite.
        return;
    }

    if (typeof requirejs !== 'undefined') {
        if (isFunction(requirejs)) {
            //Do not overwrite an existing requirejs instance.
            return;
        }
        cfg = requirejs;
        requirejs = undefined;
    }

    //Allow for a require config object
    if (typeof require !== 'undefined' && !isFunction(require)) {
        //assume it is a config object.
        cfg = require;
        require = undefined;
    }

    function newContext(contextName) {
        var inCheckLoaded, Module, context, handlers,
            checkLoadedTimeoutId,
            config = {
                //Defaults. Do not set a default for map
                //config to speed up normalize(), which
                //will run faster if there is no default.
                waitSeconds: 7,
                baseUrl: './',
                paths: {},
                bundles: {},
                pkgs: {},
                shim: {},
                config: {}
            },
            registry = {},
            //registry of just enabled modules, to speed
            //cycle breaking code when lots of modules
            //are registered, but not activated.
            enabledRegistry = {},
            undefEvents = {},
            defQueue = [],
            defined = {},
            urlFetched = {},
            bundlesMap = {},
            requireCounter = 1,
            unnormalizedCounter = 1;

        /**
         * Trims the . and .. from an array of path segments.
         * It will keep a leading path segment if a .. will become
         * the first path segment, to help with module name lookups,
         * which act like paths, but can be remapped. But the end result,
         * all paths that use this function should look normalized.
         * NOTE: this method MODIFIES the input array.
         * @param {Array} ary the array of path segments.
         */
        function trimDots(ary) {
            var i, part;
            for (i = 0; i < ary.length; i++) {
                part = ary[i];
                if (part === '.') {
                    ary.splice(i, 1);
                    i -= 1;
                } else if (part === '..') {
                    // If at the start, or previous value is still ..,
                    // keep them so that when converted to a path it may
                    // still work when converted to a path, even though
                    // as an ID it is less than ideal. In larger point
                    // releases, may be better to just kick out an error.
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
                        continue;
                    } else if (i > 0) {
                        ary.splice(i - 1, 2);
                        i -= 2;
                    }
                }
            }
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
        function normalize(name, baseName, applyMap) {
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
                baseParts = (baseName && baseName.split('/')),
                map = config.map,
                starMap = map && map['*'];

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                trimDots(name);
                name = name.join('/');
            }

            //Apply map config if available.
            if (applyMap && map && (baseParts || starMap)) {
                nameParts = name.split('/');

                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join('/');

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));

                            //baseName segment has config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = getOwn(mapValue, nameSegment);
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break outerLoop;
                                }
                            }
                        }
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
                        foundStarMap = getOwn(starMap, nameSegment);
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            // If the name points to a package's name, use
            // the package main instead.
            pkgMain = getOwn(config.pkgs, name);

            return pkgMain ? pkgMain : name;
        }

        function removeScript(name) {
            if (isBrowser) {
                each(scripts(), function (scriptNode) {
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
                        scriptNode.parentNode.removeChild(scriptNode);
                        return true;
                    }
                });
            }
        }

        function hasPathFallback(id) {
            var pathConfig = getOwn(config.paths, id);
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
                //Pop off the first array value, since it failed, and
                //retry
                pathConfig.shift();
                context.require.undef(id);

                //Custom require that does not do map translation, since
                //ID is "absolute", already mapped/resolved.
                context.makeRequire(null, {
                    skipMap: true
                })([id]);

                return true;
            }
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        /**
         * Creates a module mapping that includes plugin prefix, module
         * name, and path. If parentModuleMap is provided it will
         * also normalize the name via require.normalize()
         *
         * @param {String} name the module name
         * @param {String} [parentModuleMap] parent module map
         * for the module name, used to resolve relative names.
         * @param {Boolean} isNormalized: is the ID already normalized.
         * This is true if this call is done for a define() module ID.
         * @param {Boolean} applyMap: apply the map config to the ID.
         * Should only be true if this map is for a dependency.
         *
         * @returns {Object}
         */
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
            var url, pluginModule, suffix, nameParts,
                prefix = null,
                parentName = parentModuleMap ? parentModuleMap.name : null,
                originalName = name,
                isDefine = true,
                normalizedName = '';

            //If no name, then it means it is a require call, generate an
            //internal name.
            if (!name) {
                isDefine = false;
                name = '_@r' + (requireCounter += 1);
            }

            nameParts = splitPrefix(name);
            prefix = nameParts[0];
            name = nameParts[1];

            if (prefix) {
                prefix = normalize(prefix, parentName, applyMap);
                pluginModule = getOwn(defined, prefix);
            }

            //Account for relative paths if there is a base name.
            if (name) {
                if (prefix) {
                    if (isNormalized) {
                        normalizedName = name;
                    } else if (pluginModule && pluginModule.normalize) {
                        //Plugin is loaded, use its normalize method.
                        normalizedName = pluginModule.normalize(name, function (name) {
                            return normalize(name, parentName, applyMap);
                        });
                    } else {
                        // If nested plugin references, then do not try to
                        // normalize, as it will not normalize correctly. This
                        // places a restriction on resourceIds, and the longer
                        // term solution is not to normalize until plugins are
                        // loaded and all normalizations to allow for async
                        // loading of a loader plugin. But for now, fixes the
                        // common uses. Details in #1131
                        normalizedName = name.indexOf('!') === -1 ?
                                         normalize(name, parentName, applyMap) :
                                         name;
                    }
                } else {
                    //A regular module.
                    normalizedName = normalize(name, parentName, applyMap);

                    //Normalized name may be a plugin ID due to map config
                    //application in normalize. The map config values must
                    //already be normalized, so do not need to redo that part.
                    nameParts = splitPrefix(normalizedName);
                    prefix = nameParts[0];
                    normalizedName = nameParts[1];
                    isNormalized = true;

                    url = context.nameToUrl(normalizedName);
                }
            }

            //If the id is a plugin id that cannot be determined if it needs
            //normalization, stamp it with a unique ID so two matching relative
            //ids that may conflict can be separate.
            suffix = prefix && !pluginModule && !isNormalized ?
                     '_unnormalized' + (unnormalizedCounter += 1) :
                     '';

            return {
                prefix: prefix,
                name: normalizedName,
                parentMap: parentModuleMap,
                unnormalized: !!suffix,
                url: url,
                originalName: originalName,
                isDefine: isDefine,
                id: (prefix ?
                        prefix + '!' + normalizedName :
                        normalizedName) + suffix
            };
        }

        function getModule(depMap) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (!mod) {
                mod = registry[id] = new context.Module(depMap);
            }

            return mod;
        }

        function on(depMap, name, fn) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (hasProp(defined, id) &&
                    (!mod || mod.defineEmitComplete)) {
                if (name === 'defined') {
                    fn(defined[id]);
                }
            } else {
                mod = getModule(depMap);
                if (mod.error && name === 'error') {
                    fn(mod.error);
                } else {
                    mod.on(name, fn);
                }
            }
        }

        function onError(err, errback) {
            var ids = err.requireModules,
                notified = false;

            if (errback) {
                errback(err);
            } else {
                each(ids, function (id) {
                    var mod = getOwn(registry, id);
                    if (mod) {
                        //Set error on module, so it skips timeout checks.
                        mod.error = err;
                        if (mod.events.error) {
                            notified = true;
                            mod.emit('error', err);
                        }
                    }
                });

                if (!notified) {
                    req.onError(err);
                }
            }
        }

        /**
         * Internal method to transfer globalQueue items to this context's
         * defQueue.
         */
        function takeGlobalQueue() {
            //Push all the globalDefQueue items into the context's defQueue
            if (globalDefQueue.length) {
                each(globalDefQueue, function(queueItem) {
                    var id = queueItem[0];
                    if (typeof id === 'string') {
                        context.defQueueMap[id] = true;
                    }
                    defQueue.push(queueItem);
                });
                globalDefQueue = [];
            }
        }

        handlers = {
            'require': function (mod) {
                if (mod.require) {
                    return mod.require;
                } else {
                    return (mod.require = context.makeRequire(mod.map));
                }
            },
            'exports': function (mod) {
                mod.usingExports = true;
                if (mod.map.isDefine) {
                    if (mod.exports) {
                        return (defined[mod.map.id] = mod.exports);
                    } else {
                        return (mod.exports = defined[mod.map.id] = {});
                    }
                }
            },
            'module': function (mod) {
                if (mod.module) {
                    return mod.module;
                } else {
                    return (mod.module = {
                        id: mod.map.id,
                        uri: mod.map.url,
                        config: function () {
                            return getOwn(config.config, mod.map.id) || {};
                        },
                        exports: mod.exports || (mod.exports = {})
                    });
                }
            }
        };

        function cleanRegistry(id) {
            //Clean up machinery used for waiting modules.
            delete registry[id];
            delete enabledRegistry[id];
        }

        function breakCycle(mod, traced, processed) {
            var id = mod.map.id;

            if (mod.error) {
                mod.emit('error', mod.error);
            } else {
                traced[id] = true;
                each(mod.depMaps, function (depMap, i) {
                    var depId = depMap.id,
                        dep = getOwn(registry, depId);

                    //Only force things that have not completed
                    //being defined, so still in the registry,
                    //and only if it has not been matched up
                    //in the module already.
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
                        if (getOwn(traced, depId)) {
                            mod.defineDep(i, defined[depId]);
                            mod.check(); //pass false?
                        } else {
                            breakCycle(dep, traced, processed);
                        }
                    }
                });
                processed[id] = true;
            }
        }

        function checkLoaded() {
            var err, usingPathFallback,
                waitInterval = config.waitSeconds * 1000,
                //It is possible to disable the wait interval by using waitSeconds of 0.
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                noLoads = [],
                reqCalls = [],
                stillLoading = false,
                needCycleCheck = true;

            //Do not bother if this call was a result of a cycle break.
            if (inCheckLoaded) {
                return;
            }

            inCheckLoaded = true;

            //Figure out the state of all the modules.
            eachProp(enabledRegistry, function (mod) {
                var map = mod.map,
                    modId = map.id;

                //Skip things that are not enabled or in error state.
                if (!mod.enabled) {
                    return;
                }

                if (!map.isDefine) {
                    reqCalls.push(mod);
                }

                if (!mod.error) {
                    //If the module should be executed, and it has not
                    //been inited and time is up, remember it.
                    if (!mod.inited && expired) {
                        if (hasPathFallback(modId)) {
                            usingPathFallback = true;
                            stillLoading = true;
                        } else {
                            noLoads.push(modId);
                            removeScript(modId);
                        }
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
                        stillLoading = true;
                        if (!map.prefix) {
                            //No reason to keep looking for unfinished
                            //loading. If the only stillLoading is a
                            //plugin resource though, keep going,
                            //because it may be that a plugin resource
                            //is waiting on a non-plugin cycle.
                            return (needCycleCheck = false);
                        }
                    }
                }
            });

            if (expired && noLoads.length) {
                //If wait time expired, throw error of unloaded modules.
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
                err.contextName = context.contextName;
                return onError(err);
            }

            //Not expired, check for a cycle.
            if (needCycleCheck) {
                each(reqCalls, function (mod) {
                    breakCycle(mod, {}, {});
                });
            }

            //If still waiting on loads, and the waiting load is something
            //other than a plugin resource, or there are still outstanding
            //scripts, then just try back later.
            if ((!expired || usingPathFallback) && stillLoading) {
                //Something is still waiting to load. Wait for it, but only
                //if a timeout is not already in effect.
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                    checkLoadedTimeoutId = setTimeout(function () {
                        checkLoadedTimeoutId = 0;
                        checkLoaded();
                    }, 50);
                }
            }

            inCheckLoaded = false;
        }

        Module = function (map) {
            this.events = getOwn(undefEvents, map.id) || {};
            this.map = map;
            this.shim = getOwn(config.shim, map.id);
            this.depExports = [];
            this.depMaps = [];
            this.depMatched = [];
            this.pluginMaps = {};
            this.depCount = 0;

            /* this.exports this.factory
               this.depMaps = [],
               this.enabled, this.fetched
            */
        };

        Module.prototype = {
            init: function (depMaps, factory, errback, options) {
                options = options || {};

                //Do not do more inits if already done. Can happen if there
                //are multiple define calls for the same module. That is not
                //a normal, common case, but it is also not unexpected.
                if (this.inited) {
                    return;
                }

                this.factory = factory;

                if (errback) {
                    //Register for errors on this module.
                    this.on('error', errback);
                } else if (this.events.error) {
                    //If no errback already, but there are error listeners
                    //on this module, set up an errback to pass to the deps.
                    errback = bind(this, function (err) {
                        this.emit('error', err);
                    });
                }

                //Do a copy of the dependency array, so that
                //source inputs are not modified. For example
                //"shim" deps are passed in here directly, and
                //doing a direct modification of the depMaps array
                //would affect that config.
                this.depMaps = depMaps && depMaps.slice(0);

                this.errback = errback;

                //Indicate this module has be initialized
                this.inited = true;

                this.ignore = options.ignore;

                //Could have option to init this module in enabled mode,
                //or could have been previously marked as enabled. However,
                //the dependencies are not known until init is called. So
                //if enabled previously, now trigger dependencies as enabled.
                if (options.enabled || this.enabled) {
                    //Enable this module and dependencies.
                    //Will call this.check()
                    this.enable();
                } else {
                    this.check();
                }
            },

            defineDep: function (i, depExports) {
                //Because of cycles, defined callback for a given
                //export can be called more than once.
                if (!this.depMatched[i]) {
                    this.depMatched[i] = true;
                    this.depCount -= 1;
                    this.depExports[i] = depExports;
                }
            },

            fetch: function () {
                if (this.fetched) {
                    return;
                }
                this.fetched = true;

                context.startTime = (new Date()).getTime();

                var map = this.map;

                //If the manager is for a plugin managed resource,
                //ask the plugin to load it now.
                if (this.shim) {
                    context.makeRequire(this.map, {
                        enableBuildCallback: true
                    })(this.shim.deps || [], bind(this, function () {
                        return map.prefix ? this.callPlugin() : this.load();
                    }));
                } else {
                    //Regular dependency.
                    return map.prefix ? this.callPlugin() : this.load();
                }
            },

            load: function () {
                var url = this.map.url;

                //Regular dependency.
                if (!urlFetched[url]) {
                    urlFetched[url] = true;
                    context.load(this.map.id, url);
                }
            },

            /**
             * Checks if the module is ready to define itself, and if so,
             * define it.
             */
            check: function () {
                if (!this.enabled || this.enabling) {
                    return;
                }

                var err, cjsModule,
                    id = this.map.id,
                    depExports = this.depExports,
                    exports = this.exports,
                    factory = this.factory;

                if (!this.inited) {
                    // Only fetch if not already in the defQueue.
                    if (!hasProp(context.defQueueMap, id)) {
                        this.fetch();
                    }
                } else if (this.error) {
                    this.emit('error', this.error);
                } else if (!this.defining) {
                    //The factory could trigger another require call
                    //that would result in checking this module to
                    //define itself again. If already in the process
                    //of doing that, skip this work.
                    this.defining = true;

                    if (this.depCount < 1 && !this.defined) {
                        if (isFunction(factory)) {
                            //If there is an error listener, favor passing
                            //to that instead of throwing an error. However,
                            //only do it for define()'d  modules. require
                            //errbacks should not be called for failures in
                            //their callbacks (#699). However if a global
                            //onError is set, use that.
                            if ((this.events.error && this.map.isDefine) ||
                                req.onError !== defaultOnError) {
                                try {
                                    exports = context.execCb(id, factory, depExports, exports);
                                } catch (e) {
                                    err = e;
                                }
                            } else {
                                exports = context.execCb(id, factory, depExports, exports);
                            }

                            // Favor return value over exports. If node/cjs in play,
                            // then will not have a return value anyway. Favor
                            // module.exports assignment over exports object.
                            if (this.map.isDefine && exports === undefined) {
                                cjsModule = this.module;
                                if (cjsModule) {
                                    exports = cjsModule.exports;
                                } else if (this.usingExports) {
                                    //exports already set the defined value.
                                    exports = this.exports;
                                }
                            }

                            if (err) {
                                err.requireMap = this.map;
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
                                err.requireType = this.map.isDefine ? 'define' : 'require';
                                return onError((this.error = err));
                            }

                        } else {
                            //Just a literal value
                            exports = factory;
                        }

                        this.exports = exports;

                        if (this.map.isDefine && !this.ignore) {
                            defined[id] = exports;

                            if (req.onResourceLoad) {
                                var resLoadMaps = [];
                                each(this.depMaps, function (depMap) {
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
                                });
                                req.onResourceLoad(context, this.map, resLoadMaps);
                            }
                        }

                        //Clean up
                        cleanRegistry(id);

                        this.defined = true;
                    }

                    //Finished the define stage. Allow calling check again
                    //to allow define notifications below in the case of a
                    //cycle.
                    this.defining = false;

                    if (this.defined && !this.defineEmitted) {
                        this.defineEmitted = true;
                        this.emit('defined', this.exports);
                        this.defineEmitComplete = true;
                    }

                }
            },

            callPlugin: function () {
                var map = this.map,
                    id = map.id,
                    //Map already normalized the prefix.
                    pluginMap = makeModuleMap(map.prefix);

                //Mark this as a dependency for this plugin, so it
                //can be traced for cycles.
                this.depMaps.push(pluginMap);

                on(pluginMap, 'defined', bind(this, function (plugin) {
                    var load, normalizedMap, normalizedMod,
                        bundleId = getOwn(bundlesMap, this.map.id),
                        name = this.map.name,
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
                        localRequire = context.makeRequire(map.parentMap, {
                            enableBuildCallback: true
                        });

                    //If current map is not normalized, wait for that
                    //normalized name to load instead of continuing.
                    if (this.map.unnormalized) {
                        //Normalize the ID if the plugin allows it.
                        if (plugin.normalize) {
                            name = plugin.normalize(name, function (name) {
                                return normalize(name, parentName, true);
                            }) || '';
                        }

                        //prefix and name should already be normalized, no need
                        //for applying map config again either.
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
                                                      this.map.parentMap,
                                                      true);
                        on(normalizedMap,
                            'defined', bind(this, function (value) {
                                this.map.normalizedMap = normalizedMap;
                                this.init([], function () { return value; }, null, {
                                    enabled: true,
                                    ignore: true
                                });
                            }));

                        normalizedMod = getOwn(registry, normalizedMap.id);
                        if (normalizedMod) {
                            //Mark this as a dependency for this plugin, so it
                            //can be traced for cycles.
                            this.depMaps.push(normalizedMap);

                            if (this.events.error) {
                                normalizedMod.on('error', bind(this, function (err) {
                                    this.emit('error', err);
                                }));
                            }
                            normalizedMod.enable();
                        }

                        return;
                    }

                    //If a paths config, then just load that file instead to
                    //resolve the plugin, as it is built into that paths layer.
                    if (bundleId) {
                        this.map.url = context.nameToUrl(bundleId);
                        this.load();
                        return;
                    }

                    load = bind(this, function (value) {
                        this.init([], function () { return value; }, null, {
                            enabled: true
                        });
                    });

                    load.error = bind(this, function (err) {
                        this.inited = true;
                        this.error = err;
                        err.requireModules = [id];

                        //Remove temp unnormalized modules for this module,
                        //since they will never be resolved otherwise now.
                        eachProp(registry, function (mod) {
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
                                cleanRegistry(mod.map.id);
                            }
                        });

                        onError(err);
                    });

                    //Allow plugins to load other code without having to know the
                    //context or how to 'complete' the load.
                    load.fromText = bind(this, function (text, textAlt) {
                        /*jslint evil: true */
                        var moduleName = map.name,
                            moduleMap = makeModuleMap(moduleName),
                            hasInteractive = useInteractive;

                        //As of 2.1.0, support just passing the text, to reinforce
                        //fromText only being called once per resource. Still
                        //support old style of passing moduleName but discard
                        //that moduleName in favor of the internal ref.
                        if (textAlt) {
                            text = textAlt;
                        }

                        //Turn off interactive script matching for IE for any define
                        //calls in the text, then turn it back on at the end.
                        if (hasInteractive) {
                            useInteractive = false;
                        }

                        //Prime the system by creating a module instance for
                        //it.
                        getModule(moduleMap);

                        //Transfer any config to this other module.
                        if (hasProp(config.config, id)) {
                            config.config[moduleName] = config.config[id];
                        }

                        try {
                            req.exec(text);
                        } catch (e) {
                            return onError(makeError('fromtexteval',
                                             'fromText eval for ' + id +
                                            ' failed: ' + e,
                                             e,
                                             [id]));
                        }

                        if (hasInteractive) {
                            useInteractive = true;
                        }

                        //Mark this as a dependency for the plugin
                        //resource
                        this.depMaps.push(moduleMap);

                        //Support anonymous modules.
                        context.completeLoad(moduleName);

                        //Bind the value of that module to the value for this
                        //resource ID.
                        localRequire([moduleName], load);
                    });

                    //Use parentName here since the plugin's name is not reliable,
                    //could be some weird string with no path that actually wants to
                    //reference the parentName's path.
                    plugin.load(map.name, localRequire, load, config);
                }));

                context.enable(pluginMap, this);
                this.pluginMaps[pluginMap.id] = pluginMap;
            },

            enable: function () {
                enabledRegistry[this.map.id] = this;
                this.enabled = true;

                //Set flag mentioning that the module is enabling,
                //so that immediate calls to the defined callbacks
                //for dependencies do not trigger inadvertent load
                //with the depCount still being zero.
                this.enabling = true;

                //Enable each dependency
                each(this.depMaps, bind(this, function (depMap, i) {
                    var id, mod, handler;

                    if (typeof depMap === 'string') {
                        //Dependency needs to be converted to a depMap
                        //and wired up to this module.
                        depMap = makeModuleMap(depMap,
                                               (this.map.isDefine ? this.map : this.map.parentMap),
                                               false,
                                               !this.skipMap);
                        this.depMaps[i] = depMap;

                        handler = getOwn(handlers, depMap.id);

                        if (handler) {
                            this.depExports[i] = handler(this);
                            return;
                        }

                        this.depCount += 1;

                        on(depMap, 'defined', bind(this, function (depExports) {
                            if (this.undefed) {
                                return;
                            }
                            this.defineDep(i, depExports);
                            this.check();
                        }));

                        if (this.errback) {
                            on(depMap, 'error', bind(this, this.errback));
                        } else if (this.events.error) {
                            // No direct errback on this module, but something
                            // else is listening for errors, so be sure to
                            // propagate the error correctly.
                            on(depMap, 'error', bind(this, function(err) {
                                this.emit('error', err);
                            }));
                        }
                    }

                    id = depMap.id;
                    mod = registry[id];

                    //Skip special modules like 'require', 'exports', 'module'
                    //Also, don't call enable if it is already enabled,
                    //important in circular dependency cases.
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
                        context.enable(depMap, this);
                    }
                }));

                //Enable each plugin that is used in
                //a dependency
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
                    var mod = getOwn(registry, pluginMap.id);
                    if (mod && !mod.enabled) {
                        context.enable(pluginMap, this);
                    }
                }));

                this.enabling = false;

                this.check();
            },

            on: function (name, cb) {
                var cbs = this.events[name];
                if (!cbs) {
                    cbs = this.events[name] = [];
                }
                cbs.push(cb);
            },

            emit: function (name, evt) {
                each(this.events[name], function (cb) {
                    cb(evt);
                });
                if (name === 'error') {
                    //Now that the error handler was triggered, remove
                    //the listeners, since this broken Module instance
                    //can stay around for a while in the registry.
                    delete this.events[name];
                }
            }
        };

        function callGetModule(args) {
            //Skip modules already defined.
            if (!hasProp(defined, args[0])) {
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
            }
        }

        function removeListener(node, func, name, ieName) {
            //Favor detachEvent because of IE9
            //issue, see attachEvent/addEventListener comment elsewhere
            //in this file.
            if (node.detachEvent && !isOpera) {
                //Probably IE. If not it will throw an error, which will be
                //useful to know.
                if (ieName) {
                    node.detachEvent(ieName, func);
                }
            } else {
                node.removeEventListener(name, func, false);
            }
        }

        /**
         * Given an event from a script node, get the requirejs info from it,
         * and then removes the event listeners on the node.
         * @param {Event} evt
         * @returns {Object}
         */
        function getScriptData(evt) {
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
            //all old browsers will be supported, but this one was easy enough
            //to support and still makes sense.
            var node = evt.currentTarget || evt.srcElement;

            //Remove the listeners once here.
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
            removeListener(node, context.onScriptError, 'error');

            return {
                node: node,
                id: node && node.getAttribute('data-requiremodule')
            };
        }

        function intakeDefines() {
            var args;

            //Any defined modules in the global queue, intake them now.
            takeGlobalQueue();

            //Make sure any remaining defQueue items get properly processed.
            while (defQueue.length) {
                args = defQueue.shift();
                if (args[0] === null) {
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
                        args[args.length - 1]));
                } else {
                    //args are id, deps, factory. Should be normalized by the
                    //define() function.
                    callGetModule(args);
                }
            }
            context.defQueueMap = {};
        }

        context = {
            config: config,
            contextName: contextName,
            registry: registry,
            defined: defined,
            urlFetched: urlFetched,
            defQueue: defQueue,
            defQueueMap: {},
            Module: Module,
            makeModuleMap: makeModuleMap,
            nextTick: req.nextTick,
            onError: onError,

            /**
             * Set a configuration for the context.
             * @param {Object} cfg config object to integrate.
             */
            configure: function (cfg) {
                //Make sure the baseUrl ends in a slash.
                if (cfg.baseUrl) {
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                        cfg.baseUrl += '/';
                    }
                }

                // Convert old style urlArgs string to a function.
                if (typeof cfg.urlArgs === 'string') {
                    var urlArgs = cfg.urlArgs;
                    cfg.urlArgs = function(id, url) {
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
                    };
                }

                //Save off the paths since they require special processing,
                //they are additive.
                var shim = config.shim,
                    objs = {
                        paths: true,
                        bundles: true,
                        config: true,
                        map: true
                    };

                eachProp(cfg, function (value, prop) {
                    if (objs[prop]) {
                        if (!config[prop]) {
                            config[prop] = {};
                        }
                        mixin(config[prop], value, true, true);
                    } else {
                        config[prop] = value;
                    }
                });

                //Reverse map the bundles
                if (cfg.bundles) {
                    eachProp(cfg.bundles, function (value, prop) {
                        each(value, function (v) {
                            if (v !== prop) {
                                bundlesMap[v] = prop;
                            }
                        });
                    });
                }

                //Merge shim
                if (cfg.shim) {
                    eachProp(cfg.shim, function (value, id) {
                        //Normalize the structure
                        if (isArray(value)) {
                            value = {
                                deps: value
                            };
                        }
                        if ((value.exports || value.init) && !value.exportsFn) {
                            value.exportsFn = context.makeShimExports(value);
                        }
                        shim[id] = value;
                    });
                    config.shim = shim;
                }

                //Adjust packages if necessary.
                if (cfg.packages) {
                    each(cfg.packages, function (pkgObj) {
                        var location, name;

                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                        name = pkgObj.name;
                        location = pkgObj.location;
                        if (location) {
                            config.paths[name] = pkgObj.location;
                        }

                        //Save pointer to main module ID for pkg name.
                        //Remove leading dot in main, so main paths are normalized,
                        //and remove any trailing .js, since different package
                        //envs have different conventions: some use a module name,
                        //some use a file name.
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
                                     .replace(currDirRegExp, '')
                                     .replace(jsSuffixRegExp, '');
                    });
                }

                //If there are any "waiting to execute" modules in the registry,
                //update the maps for them, since their info, like URLs to load,
                //may have changed.
                eachProp(registry, function (mod, id) {
                    //If module already has init called, since it is too
                    //late to modify them, and ignore unnormalized ones
                    //since they are transient.
                    if (!mod.inited && !mod.map.unnormalized) {
                        mod.map = makeModuleMap(id, null, true);
                    }
                });

                //If a deps array or a config callback is specified, then call
                //require with those args. This is useful when require is defined as a
                //config object before require.js is loaded.
                if (cfg.deps || cfg.callback) {
                    context.require(cfg.deps || [], cfg.callback);
                }
            },

            makeShimExports: function (value) {
                function fn() {
                    var ret;
                    if (value.init) {
                        ret = value.init.apply(global, arguments);
                    }
                    return ret || (value.exports && getGlobal(value.exports));
                }
                return fn;
            },

            makeRequire: function (relMap, options) {
                options = options || {};

                function localRequire(deps, callback, errback) {
                    var id, map, requireMod;

                    if (options.enableBuildCallback && callback && isFunction(callback)) {
                        callback.__requireJsBuild = true;
                    }

                    if (typeof deps === 'string') {
                        if (isFunction(callback)) {
                            //Invalid call
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
                        }

                        //If require|exports|module are requested, get the
                        //value for them from the special handlers. Caveat:
                        //this only works while module is being defined.
                        if (relMap && hasProp(handlers, deps)) {
                            return handlers[deps](registry[relMap.id]);
                        }

                        //Synchronous access to one module. If require.get is
                        //available (as in the Node adapter), prefer that.
                        if (req.get) {
                            return req.get(context, deps, relMap, localRequire);
                        }

                        //Normalize module name, if it contains . or ..
                        map = makeModuleMap(deps, relMap, false, true);
                        id = map.id;

                        if (!hasProp(defined, id)) {
                            return onError(makeError('notloaded', 'Module name "' +
                                        id +
                                        '" has not been loaded yet for context: ' +
                                        contextName +
                                        (relMap ? '' : '. Use require([])')));
                        }
                        return defined[id];
                    }

                    //Grab defines waiting in the global queue.
                    intakeDefines();

                    //Mark all the dependencies as needing to be loaded.
                    context.nextTick(function () {
                        //Some defines could have been added since the
                        //require call, collect them.
                        intakeDefines();

                        requireMod = getModule(makeModuleMap(null, relMap));

                        //Store if map config should be applied to this require
                        //call for dependencies.
                        requireMod.skipMap = options.skipMap;

                        requireMod.init(deps, callback, errback, {
                            enabled: true
                        });

                        checkLoaded();
                    });

                    return localRequire;
                }

                mixin(localRequire, {
                    isBrowser: isBrowser,

                    /**
                     * Converts a module name + .extension into an URL path.
                     * *Requires* the use of a module name. It does not support using
                     * plain URLs like nameToUrl.
                     */
                    toUrl: function (moduleNamePlusExt) {
                        var ext,
                            index = moduleNamePlusExt.lastIndexOf('.'),
                            segment = moduleNamePlusExt.split('/')[0],
                            isRelative = segment === '.' || segment === '..';

                        //Have a file extension alias, and it is not the
                        //dots from a relative path.
                        if (index !== -1 && (!isRelative || index > 1)) {
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                        }

                        return context.nameToUrl(normalize(moduleNamePlusExt,
                                                relMap && relMap.id, true), ext,  true);
                    },

                    defined: function (id) {
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
                    },

                    specified: function (id) {
                        id = makeModuleMap(id, relMap, false, true).id;
                        return hasProp(defined, id) || hasProp(registry, id);
                    }
                });

                //Only allow undef on top level require calls
                if (!relMap) {
                    localRequire.undef = function (id) {
                        //Bind any waiting define() calls to this context,
                        //fix for #408
                        takeGlobalQueue();

                        var map = makeModuleMap(id, relMap, true),
                            mod = getOwn(registry, id);

                        mod.undefed = true;
                        removeScript(id);

                        delete defined[id];
                        delete urlFetched[map.url];
                        delete undefEvents[id];

                        //Clean queued defines too. Go backwards
                        //in array so that the splices do not
                        //mess up the iteration.
                        eachReverse(defQueue, function(args, i) {
                            if (args[0] === id) {
                                defQueue.splice(i, 1);
                            }
                        });
                        delete context.defQueueMap[id];

                        if (mod) {
                            //Hold on to listeners in case the
                            //module will be attempted to be reloaded
                            //using a different config.
                            if (mod.events.defined) {
                                undefEvents[id] = mod.events;
                            }

                            cleanRegistry(id);
                        }
                    };
                }

                return localRequire;
            },

            /**
             * Called to enable a module if it is still in the registry
             * awaiting enablement. A second arg, parent, the parent module,
             * is passed in for context, when this method is overridden by
             * the optimizer. Not shown here to keep code compact.
             */
            enable: function (depMap) {
                var mod = getOwn(registry, depMap.id);
                if (mod) {
                    getModule(depMap).enable();
                }
            },

            /**
             * Internal method used by environment adapters to complete a load event.
             * A load event could be a script load or just a load pass from a synchronous
             * load call.
             * @param {String} moduleName the name of the module to potentially complete.
             */
            completeLoad: function (moduleName) {
                var found, args, mod,
                    shim = getOwn(config.shim, moduleName) || {},
                    shExports = shim.exports;

                takeGlobalQueue();

                while (defQueue.length) {
                    args = defQueue.shift();
                    if (args[0] === null) {
                        args[0] = moduleName;
                        //If already found an anonymous module and bound it
                        //to this name, then this is some other anon module
                        //waiting for its completeLoad to fire.
                        if (found) {
                            break;
                        }
                        found = true;
                    } else if (args[0] === moduleName) {
                        //Found matching define call for this script!
                        found = true;
                    }

                    callGetModule(args);
                }
                context.defQueueMap = {};

                //Do this after the cycle of callGetModule in case the result
                //of those calls/init calls changes the registry.
                mod = getOwn(registry, moduleName);

                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
                        if (hasPathFallback(moduleName)) {
                            return;
                        } else {
                            return onError(makeError('nodefine',
                                             'No define call for ' + moduleName,
                                             null,
                                             [moduleName]));
                        }
                    } else {
                        //A script that does not call define(), so just simulate
                        //the call for it.
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
                    }
                }

                checkLoaded();
            },

            /**
             * Converts a module name to a file path. Supports cases where
             * moduleName may actually be just an URL.
             * Note that it **does not** call normalize on the moduleName,
             * it is assumed to have already been normalized. This is an
             * internal API, not a public one. Use toUrl for the public API.
             */
            nameToUrl: function (moduleName, ext, skipExt) {
                var paths, syms, i, parentModule, url,
                    parentPath, bundleId,
                    pkgMain = getOwn(config.pkgs, moduleName);

                if (pkgMain) {
                    moduleName = pkgMain;
                }

                bundleId = getOwn(bundlesMap, moduleName);

                if (bundleId) {
                    return context.nameToUrl(bundleId, ext, skipExt);
                }

                //If a colon is in the URL, it indicates a protocol is used and it is just
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
                //or ends with .js, then assume the user meant to use an url and not a module id.
                //The slash is important for protocol-less URLs as well as full paths.
                if (req.jsExtRegExp.test(moduleName)) {
                    //Just a plain path, not module name lookup, so just return it.
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
                    //an extension, this method probably needs to be reworked.
                    url = moduleName + (ext || '');
                } else {
                    //A module that needs to be converted to a path.
                    paths = config.paths;

                    syms = moduleName.split('/');
                    //For each module name segment, see if there is a path
                    //registered for it. Start with most specific name
                    //and work up from it.
                    for (i = syms.length; i > 0; i -= 1) {
                        parentModule = syms.slice(0, i).join('/');

                        parentPath = getOwn(paths, parentModule);
                        if (parentPath) {
                            //If an array, it means there are a few choices,
                            //Choose the one that is desired
                            if (isArray(parentPath)) {
                                parentPath = parentPath[0];
                            }
                            syms.splice(0, i, parentPath);
                            break;
                        }
                    }

                    //Join the path parts together, then figure out if baseUrl is needed.
                    url = syms.join('/');
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
                }

                return config.urlArgs && !/^blob\:/.test(url) ?
                       url + config.urlArgs(moduleName, url) : url;
            },

            //Delegates to req.load. Broken out as a separate function to
            //allow overriding in the optimizer.
            load: function (id, url) {
                req.load(context, id, url);
            },

            /**
             * Executes a module callback function. Broken out as a separate function
             * solely to allow the build system to sequence the files in the built
             * layer in the right sequence.
             *
             * @private
             */
            execCb: function (name, callback, args, exports) {
                return callback.apply(exports, args);
            },

            /**
             * callback for script loads, used to check status of loading.
             *
             * @param {Event} evt the event from the browser for the script
             * that was loaded.
             */
            onScriptLoad: function (evt) {
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
                //all old browsers will be supported, but this one was easy enough
                //to support and still makes sense.
                if (evt.type === 'load' ||
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
                    //Reset interactive script so a script node is not held onto for
                    //to long.
                    interactiveScript = null;

                    //Pull out the name of the module and the context.
                    var data = getScriptData(evt);
                    context.completeLoad(data.id);
                }
            },

            /**
             * Callback for script errors.
             */
            onScriptError: function (evt) {
                var data = getScriptData(evt);
                if (!hasPathFallback(data.id)) {
                    var parents = [];
                    eachProp(registry, function(value, key) {
                        if (key.indexOf('_@r') !== 0) {
                            each(value.depMaps, function(depMap) {
                                if (depMap.id === data.id) {
                                    parents.push(key);
                                    return true;
                                }
                            });
                        }
                    });
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
                                             (parents.length ?
                                             '", needed by: ' + parents.join(', ') :
                                             '"'), evt, [data.id]));
                }
            }
        };

        context.require = context.makeRequire();
        return context;
    }

    /**
     * Main entry point.
     *
     * If the only argument to require is a string, then the module that
     * is represented by that string is fetched for the appropriate context.
     *
     * If the first argument is an array, then it will be treated as an array
     * of dependency string names to fetch. An optional function callback can
     * be specified to execute when all of those dependencies are available.
     *
     * Make a local req variable to help Caja compliance (it assumes things
     * on a require that are not standardized), and to give a short
     * name for minification/local scope use.
     */
    req = requirejs = function (deps, callback, errback, optional) {

        //Find the right context, use default
        var context, config,
            contextName = defContextName;

        // Determine if have config object in the call.
        if (!isArray(deps) && typeof deps !== 'string') {
            // deps is a config object
            config = deps;
            if (isArray(callback)) {
                // Adjust args if there are dependencies
                deps = callback;
                callback = errback;
                errback = optional;
            } else {
                deps = [];
            }
        }

        if (config && config.context) {
            contextName = config.context;
        }

        context = getOwn(contexts, contextName);
        if (!context) {
            context = contexts[contextName] = req.s.newContext(contextName);
        }

        if (config) {
            context.configure(config);
        }

        return context.require(deps, callback, errback);
    };

    /**
     * Support require.config() to make it easier to cooperate with other
     * AMD loaders on globally agreed names.
     */
    req.config = function (config) {
        return req(config);
    };

    /**
     * Execute something after the current tick
     * of the event loop. Override for other envs
     * that have a better solution than setTimeout.
     * @param  {Function} fn function to execute later.
     */
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
        setTimeout(fn, 4);
    } : function (fn) { fn(); };

    /**
     * Export require as a global, but only if it does not already exist.
     */
    if (!require) {
        require = req;
    }

    req.version = version;

    //Used to filter out dependencies that are already paths.
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
    req.isBrowser = isBrowser;
    s = req.s = {
        contexts: contexts,
        newContext: newContext
    };

    //Create default context.
    req({});

    //Exports some context-sensitive methods on global require.
    each([
        'toUrl',
        'undef',
        'defined',
        'specified'
    ], function (prop) {
        //Reference from contexts instead of early binding to default context,
        //so that during builds, the latest instance of the default context
        //with its config gets used.
        req[prop] = function () {
            var ctx = contexts[defContextName];
            return ctx.require[prop].apply(ctx, arguments);
        };
    });

    if (isBrowser) {
        head = s.head = document.getElementsByTagName('head')[0];
        //If BASE tag is in play, using appendChild is a problem for IE6.
        //When that browser dies, this can be removed. Details in this jQuery bug:
        //http://dev.jquery.com/ticket/2709
        baseElement = document.getElementsByTagName('base')[0];
        if (baseElement) {
            head = s.head = baseElement.parentNode;
        }
    }

    /**
     * Any errors that require explicitly generates will be passed to this
     * function. Intercept/override it if you want custom error handling.
     * @param {Error} err the error object.
     */
    req.onError = defaultOnError;

    /**
     * Creates the node for the load command. Only used in browser envs.
     */
    req.createNode = function (config, moduleName, url) {
        var node = config.xhtml ?
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
                document.createElement('script');
        node.type = config.scriptType || 'text/javascript';
        node.charset = 'utf-8';
        node.async = true;
        return node;
    };

    /**
     * Does the request to load a module for the browser case.
     * Make this a separate function to allow other environments
     * to override it.
     *
     * @param {Object} context the require context to find state.
     * @param {String} moduleName the name of the module.
     * @param {Object} url the URL to the module.
     */
    req.load = function (context, moduleName, url) {
        var config = (context && context.config) || {},
            node;
        if (isBrowser) {
            //In the browser so use a script tag
            node = req.createNode(config, moduleName, url);

            node.setAttribute('data-requirecontext', context.contextName);
            node.setAttribute('data-requiremodule', moduleName);

            //Set up load listener. Test attachEvent first because IE9 has
            //a subtle issue in its addEventListener and script onload firings
            //that do not match the behavior of all other browsers with
            //addEventListener support, which fire the onload event for a
            //script right after the script execution. See:
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
            //script execution mode.
            if (node.attachEvent &&
                    //Check if node.attachEvent is artificially added by custom script or
                    //natively supported by browser
                    //read https://github.com/requirejs/requirejs/issues/187
                    //if we can NOT find [native code] then it must NOT natively supported.
                    //in IE8, node.attachEvent does not have toString()
                    //Note the test for "[native code" with no closing brace, see:
                    //https://github.com/requirejs/requirejs/issues/273
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
                    !isOpera) {
                //Probably IE. IE (at least 6-8) do not fire
                //script onload right after executing the script, so
                //we cannot tie the anonymous define call to a name.
                //However, IE reports the script as being in 'interactive'
                //readyState at the time of the define call.
                useInteractive = true;

                node.attachEvent('onreadystatechange', context.onScriptLoad);
                //It would be great to add an error handler here to catch
                //404s in IE9+. However, onreadystatechange will fire before
                //the error handler, so that does not help. If addEventListener
                //is used, then IE will fire error before load, but we cannot
                //use that pathway given the connect.microsoft.com issue
                //mentioned above about not doing the 'script execute,
                //then fire the script load event listener before execute
                //next script' that other browsers do.
                //Best hope: IE10 fixes the issues,
                //and then destroys all installs of IE 6-9.
                //node.attachEvent('onerror', context.onScriptError);
            } else {
                node.addEventListener('load', context.onScriptLoad, false);
                node.addEventListener('error', context.onScriptError, false);
            }
            node.src = url;

            //Calling onNodeCreated after all properties on the node have been
            //set, but before it is placed in the DOM.
            if (config.onNodeCreated) {
                config.onNodeCreated(node, config, moduleName, url);
            }

            //For some cache cases in IE 6-8, the script executes before the end
            //of the appendChild execution, so to tie an anonymous define
            //call to the module name (which is stored on the node), hold on
            //to a reference to this node, but clear after the DOM insertion.
            currentlyAddingScript = node;
            if (baseElement) {
                head.insertBefore(node, baseElement);
            } else {
                head.appendChild(node);
            }
            currentlyAddingScript = null;

            return node;
        } else if (isWebWorker) {
            try {
                //In a web worker, use importScripts. This is not a very
                //efficient use of importScripts, importScripts will block until
                //its script is downloaded and evaluated. However, if web workers
                //are in play, the expectation is that a build has been done so
                //that only one script needs to be loaded anyway. This may need
                //to be reevaluated if other use cases become common.

                // Post a task to the event loop to work around a bug in WebKit
                // where the worker gets garbage-collected after calling
                // importScripts(): https://webkit.org/b/153317
                setTimeout(function() {}, 0);
                importScripts(url);

                //Account for anonymous modules
                context.completeLoad(moduleName);
            } catch (e) {
                context.onError(makeError('importscripts',
                                'importScripts failed for ' +
                                    moduleName + ' at ' + url,
                                e,
                                [moduleName]));
            }
        }
    };

    function getInteractiveScript() {
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
            return interactiveScript;
        }

        eachReverse(scripts(), function (script) {
            if (script.readyState === 'interactive') {
                return (interactiveScript = script);
            }
        });
        return interactiveScript;
    }

    //Look for a data-main script attribute, which could also adjust the baseUrl.
    if (isBrowser && !cfg.skipDataMain) {
        //Figure out baseUrl. Get it from the script tag with require.js in it.
        eachReverse(scripts(), function (script) {
            //Set the 'head' where we can append children by
            //using the script's parent.
            if (!head) {
                head = script.parentNode;
            }

            //Look for a data-main attribute to set main script for the page
            //to load. If it is there, the path to data main becomes the
            //baseUrl, if it is not already set.
            dataMain = script.getAttribute('data-main');
            if (dataMain) {
                //Preserve dataMain in case it is a path (i.e. contains '?')
                mainScript = dataMain;

                //Set final baseUrl if there is not already an explicit one,
                //but only do so if the data-main value is not a loader plugin
                //module ID.
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
                    //Pull off the directory of data-main for use as the
                    //baseUrl.
                    src = mainScript.split('/');
                    mainScript = src.pop();
                    subPath = src.length ? src.join('/')  + '/' : './';

                    cfg.baseUrl = subPath;
                }

                //Strip off any trailing .js since mainScript is now
                //like a module name.
                mainScript = mainScript.replace(jsSuffixRegExp, '');

                //If mainScript is still a path, fall back to dataMain
                if (req.jsExtRegExp.test(mainScript)) {
                    mainScript = dataMain;
                }

                //Put the data-main script in the files to load.
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];

                return true;
            }
        });
    }

    /**
     * The function that handles definitions of modules. Differs from
     * require() in that a string for the module should be the first argument,
     * and the function to execute after dependencies are loaded should
     * return a value to define the module corresponding to the first argument's
     * name.
     */
    define = function (name, deps, callback) {
        var node, context;

        //Allow for anonymous modules
        if (typeof name !== 'string') {
            //Adjust args appropriately
            callback = deps;
            deps = name;
            name = null;
        }

        //This module may not have dependencies
        if (!isArray(deps)) {
            callback = deps;
            deps = null;
        }

        //If no name, and callback is a function, then figure out if it a
        //CommonJS thing with dependencies.
        if (!deps && isFunction(callback)) {
            deps = [];
            //Remove comments from the callback string,
            //look for require calls, and pull them into the dependencies,
            //but only if there are function args.
            if (callback.length) {
                callback
                    .toString()
                    .replace(commentRegExp, commentReplace)
                    .replace(cjsRequireRegExp, function (match, dep) {
                        deps.push(dep);
                    });

                //May be a CommonJS thing even without require calls, but still
                //could use exports, and module. Avoid doing exports and module
                //work though if it just needs require.
                //REQUIRES the function to expect the CommonJS variables in the
                //order listed below.
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
            }
        }

        //If in IE 6-8 and hit an anonymous define() call, do the interactive
        //work.
        if (useInteractive) {
            node = currentlyAddingScript || getInteractiveScript();
            if (node) {
                if (!name) {
                    name = node.getAttribute('data-requiremodule');
                }
                context = contexts[node.getAttribute('data-requirecontext')];
            }
        }

        //Always save off evaluating the def call until the script onload handler.
        //This allows multiple modules to be in a file without prematurely
        //tracing dependencies, and allows for anonymous module support,
        //where the module name is not known until the script onload event
        //occurs. If no context, use the global queue, and get it processed
        //in the onscript load callback.
        if (context) {
            context.defQueue.push([name, deps, callback]);
            context.defQueueMap[name] = true;
        } else {
            globalDefQueue.push([name, deps, callback]);
        }
    };

    define.amd = {
        jQuery: true
    };

    /**
     * Executes the text. Normally just uses eval, but can be modified
     * to use a better, environment-specific call. Only used for transpiling
     * loader plugins, not for plain JS modules.
     * @param {String} text the text to execute/evaluate.
     */
    req.exec = function (text) {
        /*jslint evil: true */
        return eval(text);
    };

    //Set up with config info.
    req(cfg);
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));

", + "ok": true, + "headers": [ + [ + "content-length", + "1874700" + ], + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/icon_bundle.svg": { + "data": "<?xml version="1.0" ?><svg><defs><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="add_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_back_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_downward_24px"><path fill="#010101" d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="arrow_forward_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_upward_24px"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="brightness_6_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="bug_report_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="cancel_24px"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="change_history_24px"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_left_24px"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_right_24px"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="clear_24px"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="close_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="content_copy_24px"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="dark_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36c-0.98,1.37-2.58,2.26-4.4,2.26 c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="done_24px"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="drag_indicator_24px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M11 18c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm-2-8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0-6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 4c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="edit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="error_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_less_24px"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_more_24px"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="filter_alt_24px"><g><path d="M0,0h24 M24,24H0" fill="none"/><path d="M4.25,5.61C6.27,8.2,10,13,10,13v6c0,0.55,0.45,1,1,1h2c0.55,0,1-0.45,1-1v-6c0,0,3.72-4.8,5.74-7.39 C20.25,4.95,19.78,4,18.95,4H5.04C4.21,4,3.74,4.95,4.25,5.61z"/><path d="M0,0h24v24H0V0z" fill="none"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="filter_list_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="flag_24px"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_exit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="get_app_24px"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="group_work_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="help_outline_24px"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="image_search_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M0 0h24v24H0V0z" fill="none"/><path d="M18 13v7H4V6h5.02c.05-.71.22-1.38.48-2H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-5l-2-2zm-1.5 5h-11l2.75-3.53 1.96 2.36 2.75-3.54zm2.8-9.11c.44-.7.7-1.51.7-2.39C20 4.01 17.99 2 15.5 2S11 4.01 11 6.5s2.01 4.5 4.49 4.5c.88 0 1.7-.26 2.39-.7L21 13.42 22.42 12 19.3 8.89zM15.5 9C14.12 9 13 7.88 13 6.5S14.12 4 15.5 4 18 5.12 18 6.5 16.88 9 15.5 9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="info_outline_24px"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M16,9V4l1,0c0.55,0,1-0.45,1-1v0c0-0.55-0.45-1-1-1H7C6.45,2,6,2.45,6,3v0 c0,0.55,0.45,1,1,1l1,0v5c0,1.66-1.34,3-3,3h0v2h5.97v7l1,1l1-1v-7H19v-2h0C17.34,12,16,10.66,16,9z" fill-rule="evenodd"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_outline_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M14,4v5c0,1.12,0.37,2.16,1,3H9c0.65-0.86,1-1.9,1-3V4H14 M17,2H7C6.45,2,6,2.45,6,3c0,0.55,0.45,1,1,1c0,0,0,0,0,0l1,0v5 c0,1.66-1.34,3-3,3v2h5.97v7l1,1l1-1v-7H19v-2c0,0,0,0,0,0c-1.66,0-3-1.34-3-3V4l1,0c0,0,0,0,0,0c0.55,0,1-0.45,1-1 C18,2.45,17.55,2,17,2L17,2z"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="light_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0 c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2 c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1 C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06 c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41 l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41 c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36 c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="line_weight_24px"><g><rect fill="none" height="24" width="24" x="0"/></g><g><g><g><path d="M3,17h18v-2H3V17z M3,20h18v-1H3V20z M3,13h18v-3H3V13z M3,4v4h18V4H3z"/></g></g></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="more_vert_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="notifications_none_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 22c1.1 0 2-.9 2-2h-4c0 1.1.9 2 2 2zm6-6v-5c0-3.07-1.63-5.64-4.5-6.32V4c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5v.68C7.64 5.36 6 7.92 6 11v5l-2 2v1h16v-1l-2-2zm-2 1H8v-6c0-2.48 1.51-4.5 4-4.5s4 2.02 4 4.5v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="open_in_new_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="palette_24px"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="refresh_24px"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="search_24px"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="settings_24px"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_backup_restore_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_overscan_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="visibility_off_24px"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="warning_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/></svg></defs></svg>
", + "ok": true, + "headers": [ + [ + "content-length", + "4392" + ], + [ + "content-type", + "image/svg+xml; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/data/plugins_listing": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "504" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/hparams/experiment?request=%7B%22experimentName%22:%22defaultExperimentId%22,%22hparamsLimit%22:1000,%22includeMetrics%22:false%7D": { + "data": "ewogICJuYW1lIjogIiIsCiAgImRlc2NyaXB0aW9uIjogIiIsCiAgInVzZXIiOiAiIiwKICAidGltZUNyZWF0ZWRTZWNzIjogMC4wLAogICJocGFyYW1JbmZvcyI6IFtdLAogICJtZXRyaWNJbmZvcyI6IFtdCn0=", + "ok": true, + "headers": [ + [ + "content-length", + "103" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/data/runs": { + "data": "WyIuIl0=", + "ok": true, + "headers": [ + [ + "content-length", + "25" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/runs": { + "data": "WyIuIl0=", + "ok": true, + "headers": [ + [ + "content-length", + "25" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "10811" + ], + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/data/environment": { + "data": "eyJ2ZXJzaW9uIjogIjIuMTcuMSIsICJkYXRhX2xvY2F0aW9uIjogIi9jb250ZW50L291dHB1dC9kZmluZV9oZ25ldHYyX2xfY3VzdG9tL3N1bW1hcnkiLCAid2luZG93X3RpdGxlIjogIiIsICJleHBlcmltZW50X25hbWUiOiAiIiwgImV4cGVyaW1lbnRfZGVzY3JpcHRpb24iOiAiIiwgImNyZWF0aW9uX3RpbWUiOiAwLjAsICJkZWJ1ZyI6IHsiZGF0YV9wcm92aWRlciI6ICJHcnBjRGF0YVByb3ZpZGVyKGFkZHI9J2xvY2FsaG9zdDo0MjE4NScpIiwgImZsYWdzIjogeyJsb2dkaXIiOiAiL2NvbnRlbnQvb3V0cHV0L2RmaW5lX2hnbmV0djJfbF9jdXN0b20vc3VtbWFyeSIsICJsb2dkaXJfc3BlYyI6ICIiLCAiaG9zdCI6IG51bGwsICJiaW5kX2FsbCI6IGZhbHNlLCAicG9ydCI6IG51bGwsICJyZXVzZV9wb3J0IjogZmFsc2UsICJsb2FkX2Zhc3QiOiAiYXV0byIsICJleHRyYV9kYXRhX3NlcnZlcl9mbGFncyI6ICIiLCAiZ3JwY19jcmVkc190eXBlIjogImxvY2FsIiwgImdycGNfZGF0YV9wcm92aWRlciI6ICIiLCAicHVyZ2Vfb3JwaGFuZWRfZGF0YSI6IHRydWUsICJkYiI6ICIiLCAiZGJfaW1wb3J0IjogZmFsc2UsICJpbnNwZWN0IjogZmFsc2UsICJ2ZXJzaW9uX3RiIjogZmFsc2UsICJ0YWciOiAiIiwgImV2ZW50X2ZpbGUiOiAiIiwgInBhdGhfcHJlZml4IjogIiIsICJ3aW5kb3dfdGl0bGUiOiAiIiwgIm1heF9yZWxvYWRfdGhyZWFkcyI6IDEsICJyZWxvYWRfaW50ZXJ2YWwiOiA1LjAsICJyZWxvYWRfdGFzayI6ICJhdXRvIiwgInJlbG9hZF9tdWx0aWZpbGUiOiBudWxsLCAicmVsb2FkX211bHRpZmlsZV9pbmFjdGl2ZV9zZWNzIjogODY0MDAsICJnZW5lcmljX2RhdGEiOiAiYXV0byIsICJzYW1wbGVzX3Blcl9wbHVnaW4iOiB7fSwgImRldGVjdF9maWxlX3JlcGxhY2VtZW50IjogbnVsbCwgIl9fdGVuc29yYm9hcmRfc3ViY29tbWFuZCI6ICJzZXJ2ZSJ9fX0=", + "ok": true, + "headers": [ + [ + "content-length", + "476" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/hparams/session_groups?request=%7B%22experimentName%22:%22defaultExperimentId%22,%22allowedStatuses%22:%5B%22STATUS_FAILURE%22,%22STATUS_RUNNING%22,%22STATUS_SUCCESS%22,%22STATUS_UNKNOWN%22%5D,%22colParams%22:%5B%5D,%22startIndex%22:0,%22sliceSize%22:1000000,%22includeMetrics%22:false%7D": { + "data": "ewogICJzZXNzaW9uR3JvdXBzIjogW10sCiAgInRvdGFsU2l6ZSI6IDAKfQ==", + "ok": true, + "headers": [ + [ + "content-length", + "59" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/tags": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "423" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "12375" + ], + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "10787" + ], + [ + "content-type", + "font/woff2" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox", "runToSeries": {".": [{"wallTime": 1733067631.5372055, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6504858, "step": 10, "value": 2.0798439979553223}, {"wallTime": 1733067660.7826037, "step": 20, "value": 1.8922710418701172}, {"wallTime": 1733067674.1358004, "step": 30, "value": 1.8019249439239502}, {"wallTime": 1733067687.0554821, "step": 40, "value": 2.0305089950561523}, {"wallTime": 1733067699.4913902, "step": 50, "value": 1.2973854541778564}, {"wallTime": 1733067710.6276765, "step": 60, "value": 1.6234772205352783}, {"wallTime": 1733067722.7538784, "step": 70, "value": 1.3985234498977661}, {"wallTime": 1733067733.7237546, "step": 80, "value": 0.9451308846473694}, {"wallTime": 1733067750.944718, "step": 90, "value": 1.2564857006072998}, {"wallTime": 1733067761.9792202, "step": 100, "value": 1.104218602180481}, {"wallTime": 1733067771.604809, "step": 110, "value": 0.7241520881652832}, {"wallTime": 1733067780.545737, "step": 120, "value": 0.6176250576972961}, {"wallTime": 1733067790.4836004, "step": 130, "value": 0.8032745122909546}, {"wallTime": 1733067799.103986, "step": 140, "value": 0.4301645755767822}, {"wallTime": 1733067809.4428759, "step": 150, "value": 0.64487224817276}, {"wallTime": 1733067818.9191175, "step": 160, "value": 0.5931652784347534}, {"wallTime": 1733067836.6479516, "step": 170, "value": 0.4461428225040436}, {"wallTime": 1733067846.389088, "step": 180, "value": 0.6633519530296326}, {"wallTime": 1733067855.6651819, "step": 190, "value": 0.43473172187805176}, {"wallTime": 1733067864.8869436, "step": 200, "value": 0.7815240621566772}, {"wallTime": 1733067873.9999738, "step": 210, "value": 0.6015461087226868}, {"wallTime": 1733067883.7834008, "step": 220, "value": 0.4017960727214813}, {"wallTime": 1733067892.1214995, "step": 230, "value": 0.5110403299331665}, {"wallTime": 1733067901.0676184, "step": 240, "value": 0.5019652843475342}, {"wallTime": 1733067910.0733004, "step": 250, "value": 0.4687551259994507}, {"wallTime": 1733067925.9484336, "step": 260, "value": 0.7717973589897156}, {"wallTime": 1733067935.4589627, "step": 270, "value": 0.4311910569667816}, {"wallTime": 1733067944.012688, "step": 280, "value": 0.4738647937774658}, {"wallTime": 1733067952.5437508, "step": 290, "value": 0.4720813035964966}, {"wallTime": 1733067961.0251024, "step": 300, "value": 0.3266456127166748}, {"wallTime": 1733067970.132803, "step": 310, "value": 0.5342054963111877}, {"wallTime": 1733067980.224121, "step": 320, "value": 0.4504202604293823}, {"wallTime": 1733067988.8144398, "step": 330, "value": 0.5378909111022949}, {"wallTime": 1733068005.0890305, "step": 340, "value": 0.41485774517059326}, {"wallTime": 1733068014.0634856, "step": 350, "value": 0.40115654468536377}, {"wallTime": 1733068022.5513897, "step": 360, "value": 0.46111202239990234}, {"wallTime": 1733068031.823141, "step": 370, "value": 0.4972383975982666}, {"wallTime": 1733068040.7862566, "step": 380, "value": 0.37024372816085815}, {"wallTime": 1733068050.158694, "step": 390, "value": 0.3919593095779419}, {"wallTime": 1733068059.1245172, "step": 400, "value": 0.2970837652683258}, {"wallTime": 1733068068.0885835, "step": 410, "value": 0.6703516244888306}, {"wallTime": 1733068084.8423793, "step": 420, "value": 0.38509470224380493}, {"wallTime": 1733068094.66509, "step": 430, "value": 0.5022711157798767}, {"wallTime": 1733068103.7065876, "step": 440, "value": 0.34303903579711914}, {"wallTime": 1733068112.6982572, "step": 450, "value": 0.4294600486755371}, {"wallTime": 1733068121.499596, "step": 460, "value": 0.5335037708282471}, {"wallTime": 1733068130.726403, "step": 470, "value": 0.39801833033561707}, {"wallTime": 1733068139.854396, "step": 480, "value": 0.404744416475296}, {"wallTime": 1733068149.368774, "step": 490, "value": 0.5330761671066284}, {"wallTime": 1733068158.0687706, "step": 500, "value": 0.5192074179649353}, {"wallTime": 1733068174.11387, "step": 510, "value": 0.48036161065101624}, {"wallTime": 1733068182.7183607, "step": 520, "value": 0.37669843435287476}, {"wallTime": 1733068192.4123833, "step": 530, "value": 0.4040905833244324}, {"wallTime": 1733068201.806917, "step": 540, "value": 0.39164799451828003}, {"wallTime": 1733068210.6533191, "step": 550, "value": 0.5900896191596985}, {"wallTime": 1733068220.1938367, "step": 560, "value": 0.7290679812431335}, {"wallTime": 1733068229.1580894, "step": 570, "value": 0.3154759109020233}, {"wallTime": 1733068238.5902288, "step": 580, "value": 0.2918756306171417}, {"wallTime": 1733068256.071424, "step": 590, "value": 0.42343345284461975}, {"wallTime": 1733068265.4306881, "step": 600, "value": 0.49986493587493896}, {"wallTime": 1733068274.6553655, "step": 610, "value": 0.6637550592422485}, {"wallTime": 1733068283.7688484, "step": 620, "value": 0.5914444923400879}, {"wallTime": 1733068293.3329778, "step": 630, "value": 0.45641428232192993}, {"wallTime": 1733068302.6459835, "step": 640, "value": 0.38311856985092163}, {"wallTime": 1733068311.3869696, "step": 650, "value": 0.3428945243358612}, {"wallTime": 1733068320.3889632, "step": 660, "value": 0.45379799604415894}, {"wallTime": 1733068328.7301204, "step": 670, "value": 0.3715178966522217}, {"wallTime": 1733068344.4600263, "step": 680, "value": 0.3982357978820801}, {"wallTime": 1733068353.7157993, "step": 690, "value": 0.35608792304992676}, {"wallTime": 1733068362.0566642, "step": 700, "value": 0.33049774169921875}, {"wallTime": 1733068371.102928, "step": 710, "value": 0.5223428010940552}, {"wallTime": 1733068380.5319607, "step": 720, "value": 0.40715858340263367}, {"wallTime": 1733068390.0856054, "step": 730, "value": 0.31549903750419617}, {"wallTime": 1733068398.7199185, "step": 740, "value": 0.4641018807888031}, {"wallTime": 1733068407.1229103, "step": 750, "value": 0.4092074930667877}, {"wallTime": 1733068423.0687885, "step": 760, "value": 0.4122332036495209}, {"wallTime": 1733068431.4042282, "step": 770, "value": 0.33002346754074097}, {"wallTime": 1733068440.4238443, "step": 780, "value": 0.35465574264526367}, {"wallTime": 1733068449.0053544, "step": 790, "value": 0.3756709396839142}, {"wallTime": 1733068457.635405, "step": 800, "value": 0.3995027542114258}, {"wallTime": 1733068467.0462162, "step": 810, "value": 0.38058191537857056}, {"wallTime": 1733068475.6193554, "step": 820, "value": 0.37370729446411133}, {"wallTime": 1733068484.9778502, "step": 830, "value": 0.3777523636817932}, {"wallTime": 1733068500.73062, "step": 840, "value": 0.40648382902145386}, {"wallTime": 1733068509.3068578, "step": 850, "value": 0.41725173592567444}, {"wallTime": 1733068519.0212455, "step": 860, "value": 0.4141177237033844}, {"wallTime": 1733068527.49767, "step": 870, "value": 0.3320230543613434}, {"wallTime": 1733068536.919374, "step": 880, "value": 0.4852721691131592}, {"wallTime": 1733068544.9079213, "step": 890, "value": 0.35297486186027527}, {"wallTime": 1733068553.5781617, "step": 900, "value": 0.3758895695209503}, {"wallTime": 1733068562.6852186, "step": 910, "value": 0.41563689708709717}, {"wallTime": 1733068571.2454414, "step": 920, "value": 0.34180474281311035}, {"wallTime": 1733068584.775524, "step": 930, "value": 0.38680288195610046}, {"wallTime": 1733068593.7718568, "step": 940, "value": 0.3716999292373657}, {"wallTime": 1733068602.7660382, "step": 950, "value": 0.4526485204696655}, {"wallTime": 1733068611.0400615, "step": 960, "value": 0.2876213788986206}, {"wallTime": 1733068620.2269406, "step": 970, "value": 0.33500584959983826}, {"wallTime": 1733068628.8419354, "step": 980, "value": 0.40626493096351624}, {"wallTime": 1733068637.630831, "step": 990, "value": 0.3356949985027313}, {"wallTime": 1733068646.6734474, "step": 1000, "value": 0.3923466205596924}, {"wallTime": 1733068662.7572541, "step": 1010, "value": 0.25073903799057007}, {"wallTime": 1733068672.0548236, "step": 1020, "value": 0.3019692301750183}, {"wallTime": 1733068680.5635998, "step": 1030, "value": 0.32950007915496826}, {"wallTime": 1733068690.186306, "step": 1040, "value": 0.3569614291191101}, {"wallTime": 1733068698.8485498, "step": 1050, "value": 0.34091445803642273}, {"wallTime": 1733068707.744023, "step": 1060, "value": 0.7615715265274048}, {"wallTime": 1733068717.3452296, "step": 1070, "value": 0.3397029638290405}, {"wallTime": 1733068726.3619695, "step": 1080, "value": 0.41789230704307556}, {"wallTime": 1733068735.2523952, "step": 1090, "value": 0.448940634727478}, {"wallTime": 1733068749.5485833, "step": 1100, "value": 0.35831624269485474}, {"wallTime": 1733068758.3760068, "step": 1110, "value": 0.4471935033798218}, {"wallTime": 1733068767.0044513, "step": 1120, "value": 0.5261462330818176}, {"wallTime": 1733068776.6194618, "step": 1130, "value": 0.46068161725997925}, {"wallTime": 1733068785.4017935, "step": 1140, "value": 0.24199220538139343}, {"wallTime": 1733068794.2796307, "step": 1150, "value": 0.40722307562828064}, {"wallTime": 1733068802.6979494, "step": 1160, "value": 0.27477508783340454}, {"wallTime": 1733068811.5520773, "step": 1170, "value": 0.39160990715026855}, {"wallTime": 1733068824.966384, "step": 1180, "value": 0.22803238034248352}, {"wallTime": 1733068834.3778389, "step": 1190, "value": 0.37077829241752625}, {"wallTime": 1733068843.5167768, "step": 1200, "value": 0.45248186588287354}, {"wallTime": 1733068852.2290745, "step": 1210, "value": 0.3490559458732605}, {"wallTime": 1733068861.1175616, "step": 1220, "value": 0.3620091378688812}, {"wallTime": 1733068870.0564744, "step": 1230, "value": 0.633430004119873}, {"wallTime": 1733068878.721047, "step": 1240, "value": 0.42505162954330444}, {"wallTime": 1733068887.7387135, "step": 1250, "value": 0.3327828645706177}, {"wallTime": 1733068903.1674209, "step": 1260, "value": 0.48044827580451965}, {"wallTime": 1733068912.4142454, "step": 1270, "value": 0.2727428376674652}, {"wallTime": 1733068921.4728892, "step": 1280, "value": 0.3469138741493225}, {"wallTime": 1733068929.7472937, "step": 1290, "value": 0.38267359137535095}, {"wallTime": 1733068939.5018542, "step": 1300, "value": 0.3381085991859436}, {"wallTime": 1733068948.928114, "step": 1310, "value": 0.3942042887210846}, {"wallTime": 1733068957.2350516, "step": 1320, "value": 0.4909232556819916}, {"wallTime": 1733068966.0776734, "step": 1330, "value": 0.2822086215019226}, {"wallTime": 1733068975.5658057, "step": 1340, "value": 0.5304619073867798}, {"wallTime": 1733068989.798104, "step": 1350, "value": 0.38602215051651}, {"wallTime": 1733068998.2585278, "step": 1360, "value": 0.29109254479408264}, {"wallTime": 1733069007.1481957, "step": 1370, "value": 0.35310450196266174}, {"wallTime": 1733069015.92114, "step": 1380, "value": 0.20352628827095032}, {"wallTime": 1733069025.3038437, "step": 1390, "value": 0.3661477267742157}, {"wallTime": 1733069034.482035, "step": 1400, "value": 0.2723369896411896}, {"wallTime": 1733069042.7935555, "step": 1410, "value": 0.4279208183288574}, {"wallTime": 1733069052.1381223, "step": 1420, "value": 0.25860387086868286}, {"wallTime": 1733069065.0021336, "step": 1430, "value": 0.2990620732307434}, {"wallTime": 1733069074.5244665, "step": 1440, "value": 0.3212093710899353}, {"wallTime": 1733069083.783085, "step": 1450, "value": 0.38475489616394043}, {"wallTime": 1733069092.2580788, "step": 1460, "value": 0.29266515374183655}, {"wallTime": 1733069101.0300384, "step": 1470, "value": 0.3433492183685303}, {"wallTime": 1733069109.9058487, "step": 1480, "value": 0.3017130196094513}, {"wallTime": 1733069119.1182692, "step": 1490, "value": 0.23201075196266174}, {"wallTime": 1733069128.4155602, "step": 1500, "value": 0.3234347403049469}, {"wallTime": 1733069137.6062183, "step": 1510, "value": 0.45861008763313293}, {"wallTime": 1733069150.5429232, "step": 1520, "value": 0.39711642265319824}, {"wallTime": 1733069159.7564633, "step": 1530, "value": 0.4396635591983795}, {"wallTime": 1733069168.1695993, "step": 1540, "value": 0.20041726529598236}, {"wallTime": 1733069176.8403716, "step": 1550, "value": 0.43270742893218994}, {"wallTime": 1733069185.891695, "step": 1560, "value": 0.23380574584007263}, {"wallTime": 1733069194.9232552, "step": 1570, "value": 0.38026148080825806}, {"wallTime": 1733069203.9111724, "step": 1580, "value": 0.31433385610580444}, {"wallTime": 1733069212.7147398, "step": 1590, "value": 0.263048380613327}, {"wallTime": 1733069225.5332994, "step": 1600, "value": 0.28911489248275757}, {"wallTime": 1733069235.4632385, "step": 1610, "value": 0.44468826055526733}, {"wallTime": 1733069244.628642, "step": 1620, "value": 0.4982903301715851}, {"wallTime": 1733069254.2710319, "step": 1630, "value": 0.338423490524292}, {"wallTime": 1733069263.00471, "step": 1640, "value": 0.2578522562980652}, {"wallTime": 1733069271.8660092, "step": 1650, "value": 0.4423326253890991}, {"wallTime": 1733069280.509292, "step": 1660, "value": 0.27485278248786926}, {"wallTime": 1733069289.679131, "step": 1670, "value": 0.3771488666534424}, {"wallTime": 1733069303.6080527, "step": 1680, "value": 0.48900407552719116}, {"wallTime": 1733069312.4789653, "step": 1690, "value": 0.3857921361923218}, {"wallTime": 1733069321.8378298, "step": 1700, "value": 0.4645109176635742}, {"wallTime": 1733069330.3473804, "step": 1710, "value": 0.29589933156967163}, {"wallTime": 1733069339.2444668, "step": 1720, "value": 0.23375844955444336}, {"wallTime": 1733069346.8559864, "step": 1730, "value": 0.24585533142089844}, {"wallTime": 1733069355.651676, "step": 1740, "value": 0.4557649791240692}, {"wallTime": 1733069364.5113704, "step": 1750, "value": 0.35925066471099854}, {"wallTime": 1733069373.7380059, "step": 1760, "value": 0.3196563124656677}, {"wallTime": 1733069387.540407, "step": 1770, "value": 0.30832943320274353}, {"wallTime": 1733069396.4658482, "step": 1780, "value": 0.26232388615608215}, {"wallTime": 1733069405.995693, "step": 1790, "value": 0.20287823677062988}, {"wallTime": 1733069415.0531163, "step": 1800, "value": 0.2525672912597656}, {"wallTime": 1733069423.9068887, "step": 1810, "value": 0.21231859922409058}, {"wallTime": 1733069432.53047, "step": 1820, "value": 0.4156668782234192}, {"wallTime": 1733069441.2161412, "step": 1830, "value": 0.3351864814758301}, {"wallTime": 1733069450.0859416, "step": 1840, "value": 0.24092169106006622}, {"wallTime": 1733069463.105943, "step": 1850, "value": 0.23302540183067322}, {"wallTime": 1733069471.5718448, "step": 1860, "value": 0.26078712940216064}, {"wallTime": 1733069480.4972153, "step": 1870, "value": 0.5189595222473145}, {"wallTime": 1733069489.3838832, "step": 1880, "value": 0.42037785053253174}, {"wallTime": 1733069497.9756882, "step": 1890, "value": 0.42273324728012085}, {"wallTime": 1733069506.7932203, "step": 1900, "value": 0.31963708996772766}, {"wallTime": 1733069515.8236015, "step": 1910, "value": 0.24328751862049103}, {"wallTime": 1733069524.6354165, "step": 1920, "value": 0.2877340018749237}, {"wallTime": 1733069533.5410016, "step": 1930, "value": 0.21759948134422302}, {"wallTime": 1733069550.4768932, "step": 1940, "value": 0.3713931441307068}, {"wallTime": 1733069558.826679, "step": 1950, "value": 0.26182833313941956}, {"wallTime": 1733069567.7568333, "step": 1960, "value": 0.26023679971694946}, {"wallTime": 1733069576.3440895, "step": 1970, "value": 0.2631921172142029}, {"wallTime": 1733069585.5281408, "step": 1980, "value": 0.4087710678577423}, {"wallTime": 1733069594.349149, "step": 1990, "value": 0.3879650831222534}, {"wallTime": 1733069602.4005315, "step": 2000, "value": 0.5761553049087524}, {"wallTime": 1733069610.2487693, "step": 2010, "value": 0.4710686206817627}, {"wallTime": 1733069626.685713, "step": 2020, "value": 0.40762048959732056}, {"wallTime": 1733069635.0298302, "step": 2030, "value": 0.2722232937812805}, {"wallTime": 1733069643.821456, "step": 2040, "value": 0.2545030117034912}, {"wallTime": 1733069652.1933465, "step": 2050, "value": 0.29870542883872986}, {"wallTime": 1733069660.4523275, "step": 2060, "value": 0.4250990152359009}, {"wallTime": 1733069669.590948, "step": 2070, "value": 0.33543649315834045}, {"wallTime": 1733069678.777206, "step": 2080, "value": 0.530162513256073}, {"wallTime": 1733069686.943676, "step": 2090, "value": 0.40082964301109314}, {"wallTime": 1733069700.6009204, "step": 2100, "value": 0.3257569372653961}, {"wallTime": 1733069708.7252247, "step": 2110, "value": 0.24189788103103638}, {"wallTime": 1733069717.4471583, "step": 2120, "value": 0.29808342456817627}, {"wallTime": 1733069726.1400688, "step": 2130, "value": 0.3073674738407135}, {"wallTime": 1733069735.0369647, "step": 2140, "value": 0.3376536965370178}, {"wallTime": 1733069743.3049479, "step": 2150, "value": 0.2792476415634155}, {"wallTime": 1733069752.4996865, "step": 2160, "value": 0.324160635471344}, {"wallTime": 1733069761.4498436, "step": 2170, "value": 0.32001104950904846}, {"wallTime": 1733069770.4320579, "step": 2180, "value": 0.3930163085460663}, {"wallTime": 1733069784.3622518, "step": 2190, "value": 0.3647589683532715}, {"wallTime": 1733069793.121264, "step": 2200, "value": 0.17424437403678894}, {"wallTime": 1733069801.6349728, "step": 2210, "value": 0.29091453552246094}, {"wallTime": 1733069810.6066833, "step": 2220, "value": 0.4201907515525818}, {"wallTime": 1733069819.3405163, "step": 2230, "value": 0.2565470337867737}, {"wallTime": 1733069827.3249388, "step": 2240, "value": 0.3911897838115692}, {"wallTime": 1733069835.8665173, "step": 2250, "value": 0.2813068628311157}, {"wallTime": 1733069844.2346203, "step": 2260, "value": 0.3202509582042694}, {"wallTime": 1733069856.7479925, "step": 2270, "value": 0.26031357049942017}, {"wallTime": 1733069865.2563677, "step": 2280, "value": 0.2133115828037262}, {"wallTime": 1733069874.0038714, "step": 2290, "value": 0.1928642988204956}, {"wallTime": 1733069881.7803795, "step": 2300, "value": 0.3731730878353119}, {"wallTime": 1733069890.412475, "step": 2310, "value": 0.2554512619972229}, {"wallTime": 1733069898.8753242, "step": 2320, "value": 0.27499425411224365}, {"wallTime": 1733069908.3163915, "step": 2330, "value": 0.2681879699230194}, {"wallTime": 1733069917.4138596, "step": 2340, "value": 0.36763620376586914}, {"wallTime": 1733069925.8490794, "step": 2350, "value": 0.23049356043338776}, {"wallTime": 1733069938.700487, "step": 2360, "value": 0.34482404589653015}, {"wallTime": 1733069947.4247825, "step": 2370, "value": 0.37260740995407104}, {"wallTime": 1733069956.204341, "step": 2380, "value": 0.40687835216522217}, {"wallTime": 1733069964.273331, "step": 2390, "value": 0.29622477293014526}, {"wallTime": 1733069973.3247209, "step": 2400, "value": 0.22745293378829956}, {"wallTime": 1733069981.4307907, "step": 2410, "value": 0.25667086243629456}, {"wallTime": 1733069990.1382573, "step": 2420, "value": 0.28280696272850037}, {"wallTime": 1733069998.796275, "step": 2430, "value": 0.30805373191833496}, {"wallTime": 1733070012.454388, "step": 2440, "value": 0.2749473452568054}, {"wallTime": 1733070021.5973952, "step": 2450, "value": 0.24716463685035706}, {"wallTime": 1733070030.1895602, "step": 2460, "value": 0.25903481245040894}, {"wallTime": 1733070039.2178895, "step": 2470, "value": 0.2850903272628784}, {"wallTime": 1733070048.2675126, "step": 2480, "value": 0.3598359525203705}, {"wallTime": 1733070056.1543152, "step": 2490, "value": 0.3875472843647003}, {"wallTime": 1733070064.4491966, "step": 2500, "value": 0.35453853011131287}, {"wallTime": 1733070072.5480614, "step": 2510, "value": 0.24522048234939575}, {"wallTime": 1733070087.6554635, "step": 2520, "value": 0.2909427285194397}, {"wallTime": 1733070095.440251, "step": 2530, "value": 0.26692771911621094}, {"wallTime": 1733070103.7673664, "step": 2540, "value": 0.2437128722667694}, {"wallTime": 1733070113.047606, "step": 2550, "value": 0.2396899163722992}, {"wallTime": 1733070121.036328, "step": 2560, "value": 0.24496965110301971}, {"wallTime": 1733070129.5828762, "step": 2570, "value": 0.2991332411766052}, {"wallTime": 1733070138.359168, "step": 2580, "value": 0.2653912305831909}, {"wallTime": 1733070147.0858307, "step": 2590, "value": 0.3469836413860321}, {"wallTime": 1733070155.4854927, "step": 2600, "value": 0.44257688522338867}, {"wallTime": 1733070172.5758626, "step": 2610, "value": 0.30707624554634094}, {"wallTime": 1733070181.2097738, "step": 2620, "value": 0.33058181405067444}, {"wallTime": 1733070189.6908033, "step": 2630, "value": 0.27697911858558655}, {"wallTime": 1733070198.3976898, "step": 2640, "value": 0.26705828309059143}, {"wallTime": 1733070206.7059221, "step": 2650, "value": 0.21364766359329224}, {"wallTime": 1733070215.5982587, "step": 2660, "value": 0.334720641374588}, {"wallTime": 1733070224.3140733, "step": 2670, "value": 0.32782095670700073}, {"wallTime": 1733070233.537914, "step": 2680, "value": 0.2813352346420288}, {"wallTime": 1733070246.7566774, "step": 2690, "value": 0.259069561958313}, {"wallTime": 1733070256.027371, "step": 2700, "value": 0.3953452408313751}, {"wallTime": 1733070264.9493084, "step": 2710, "value": 0.25977593660354614}, {"wallTime": 1733070273.803275, "step": 2720, "value": 0.3403031527996063}, {"wallTime": 1733070282.957596, "step": 2730, "value": 0.3013741672039032}, {"wallTime": 1733070292.2764492, "step": 2740, "value": 0.28846853971481323}, {"wallTime": 1733070300.3353097, "step": 2750, "value": 0.2759764790534973}, {"wallTime": 1733070309.4106898, "step": 2760, "value": 0.42882564663887024}, {"wallTime": 1733070317.5300484, "step": 2770, "value": 0.4036487936973572}, {"wallTime": 1733070330.4346898, "step": 2780, "value": 0.3276117146015167}, {"wallTime": 1733070339.8211513, "step": 2790, "value": 0.261584997177124}, {"wallTime": 1733070347.9914212, "step": 2800, "value": 0.20327605307102203}, {"wallTime": 1733070356.889567, "step": 2810, "value": 0.29370686411857605}, {"wallTime": 1733070365.575419, "step": 2820, "value": 0.267966091632843}, {"wallTime": 1733070374.391274, "step": 2830, "value": 0.2701551020145416}, {"wallTime": 1733070382.4255688, "step": 2840, "value": 0.3428257703781128}, {"wallTime": 1733070390.9399457, "step": 2850, "value": 0.23698487877845764}, {"wallTime": 1733070406.6773329, "step": 2860, "value": 0.251899391412735}, {"wallTime": 1733070415.0880127, "step": 2870, "value": 0.24445445835590363}, {"wallTime": 1733070422.9185624, "step": 2880, "value": 0.2300599217414856}, {"wallTime": 1733070431.5359323, "step": 2890, "value": 0.2563977837562561}, {"wallTime": 1733070439.979419, "step": 2900, "value": 0.32762664556503296}, {"wallTime": 1733070448.0841324, "step": 2910, "value": 0.41287466883659363}, {"wallTime": 1733070457.4223263, "step": 2920, "value": 0.44049888849258423}, {"wallTime": 1733070466.7214262, "step": 2930, "value": 0.37755560874938965}, {"wallTime": 1733070479.3311691, "step": 2940, "value": 0.3069825768470764}, {"wallTime": 1733070488.7807236, "step": 2950, "value": 0.28873249888420105}, {"wallTime": 1733070497.2233436, "step": 2960, "value": 0.3667128086090088}, {"wallTime": 1733070505.6324072, "step": 2970, "value": 0.24187995493412018}, {"wallTime": 1733070513.3525288, "step": 2980, "value": 0.20398260653018951}, {"wallTime": 1733070522.2997344, "step": 2990, "value": 0.3563939034938812}, {"wallTime": 1733070530.2112858, "step": 3000, "value": 0.19532808661460876}, {"wallTime": 1733070538.2985802, "step": 3010, "value": 0.30385079979896545}, {"wallTime": 1733070547.3988655, "step": 3020, "value": 0.2509574592113495}, {"wallTime": 1733070564.0493548, "step": 3030, "value": 0.23628726601600647}, {"wallTime": 1733070572.3682537, "step": 3040, "value": 0.23652715981006622}, {"wallTime": 1733070580.66939, "step": 3050, "value": 0.27197709679603577}, {"wallTime": 1733070588.6517413, "step": 3060, "value": 0.27369460463523865}, {"wallTime": 1733070597.4192193, "step": 3070, "value": 0.239854633808136}, {"wallTime": 1733070606.135738, "step": 3080, "value": 0.37286922335624695}, {"wallTime": 1733070614.4379108, "step": 3090, "value": 0.33722010254859924}, {"wallTime": 1733070623.9983683, "step": 3100, "value": 0.2798565626144409}, {"wallTime": 1733070637.2505305, "step": 3110, "value": 0.3446204960346222}, {"wallTime": 1733070645.6802254, "step": 3120, "value": 0.29749396443367004}, {"wallTime": 1733070654.2680652, "step": 3130, "value": 0.24158218502998352}, {"wallTime": 1733070663.3188806, "step": 3140, "value": 0.24813959002494812}, {"wallTime": 1733070671.1156836, "step": 3150, "value": 0.33949172496795654}, {"wallTime": 1733070679.7631724, "step": 3160, "value": 0.36885279417037964}, {"wallTime": 1733070687.8425078, "step": 3170, "value": 0.25372421741485596}, {"wallTime": 1733070695.853472, "step": 3180, "value": 0.32282036542892456}, {"wallTime": 1733070704.620047, "step": 3190, "value": 0.2527974545955658}, {"wallTime": 1733070717.1064997, "step": 3200, "value": 0.1986895501613617}, {"wallTime": 1733070726.096278, "step": 3210, "value": 0.2941816747188568}, {"wallTime": 1733070734.7737453, "step": 3220, "value": 0.18446871638298035}, {"wallTime": 1733070744.4095156, "step": 3230, "value": 0.27974969148635864}, {"wallTime": 1733070752.4992135, "step": 3240, "value": 0.4385601282119751}, {"wallTime": 1733070761.7187304, "step": 3250, "value": 0.39150580763816833}, {"wallTime": 1733070770.3741498, "step": 3260, "value": 0.2715342044830322}, {"wallTime": 1733070779.7276254, "step": 3270, "value": 0.258523166179657}, {"wallTime": 1733070793.6759245, "step": 3280, "value": 0.23795491456985474}, {"wallTime": 1733070801.8976727, "step": 3290, "value": 0.38626551628112793}, {"wallTime": 1733070810.1586764, "step": 3300, "value": 0.34349119663238525}, {"wallTime": 1733070818.724004, "step": 3310, "value": 0.1787242591381073}, {"wallTime": 1733070827.0039234, "step": 3320, "value": 0.22800715267658234}, {"wallTime": 1733070835.5713603, "step": 3330, "value": 0.2712724208831787}, {"wallTime": 1733070843.97152, "step": 3340, "value": 0.4058920741081238}, {"wallTime": 1733070853.0891745, "step": 3350, "value": 0.3219963312149048}, {"wallTime": 1733070865.417106, "step": 3360, "value": 0.2079247087240219}, {"wallTime": 1733070873.6592805, "step": 3370, "value": 0.25811004638671875}, {"wallTime": 1733070883.3336594, "step": 3380, "value": 0.2387612760066986}, {"wallTime": 1733070892.3746684, "step": 3390, "value": 0.27149179577827454}, {"wallTime": 1733070900.7200708, "step": 3400, "value": 0.3133973777294159}, {"wallTime": 1733070908.501849, "step": 3410, "value": 0.278580904006958}, {"wallTime": 1733070916.6534226, "step": 3420, "value": 0.3719457983970642}, {"wallTime": 1733070925.2057984, "step": 3430, "value": 0.2567204236984253}, {"wallTime": 1733070933.807957, "step": 3440, "value": 0.21335801482200623}, {"wallTime": 1733070947.4774654, "step": 3450, "value": 0.24061961472034454}, {"wallTime": 1733070956.1848302, "step": 3460, "value": 0.2474675327539444}, {"wallTime": 1733070964.2639554, "step": 3470, "value": 0.2628166377544403}, {"wallTime": 1733070972.3837247, "step": 3480, "value": 0.2686379551887512}, {"wallTime": 1733070980.6448097, "step": 3490, "value": 0.4610642194747925}, {"wallTime": 1733070989.6853228, "step": 3500, "value": 0.2437417209148407}, {"wallTime": 1733070997.7862039, "step": 3510, "value": 0.23286619782447815}, {"wallTime": 1733071006.2690628, "step": 3520, "value": 0.32470703125}, {"wallTime": 1733071018.8937511, "step": 3530, "value": 0.24010196328163147}, {"wallTime": 1733071027.1948357, "step": 3540, "value": 0.17792554199695587}, {"wallTime": 1733071035.318224, "step": 3550, "value": 0.26330775022506714}, {"wallTime": 1733071043.7434542, "step": 3560, "value": 0.21940694749355316}, {"wallTime": 1733071051.869894, "step": 3570, "value": 0.28583821654319763}, {"wallTime": 1733071060.493851, "step": 3580, "value": 0.24736925959587097}, {"wallTime": 1733071068.8771565, "step": 3590, "value": 0.25672951340675354}, {"wallTime": 1733071077.710689, "step": 3600, "value": 0.27803555130958557}, {"wallTime": 1733071086.2100925, "step": 3610, "value": 0.21654760837554932}, {"wallTime": 1733071101.6564438, "step": 3620, "value": 0.23859946429729462}, {"wallTime": 1733071109.6176958, "step": 3630, "value": 0.28321725130081177}, {"wallTime": 1733071118.127013, "step": 3640, "value": 0.255190908908844}, {"wallTime": 1733071126.9909353, "step": 3650, "value": 0.21192994713783264}, {"wallTime": 1733071135.8251936, "step": 3660, "value": 0.31316104531288147}, {"wallTime": 1733071144.2459624, "step": 3670, "value": 0.22160133719444275}, {"wallTime": 1733071152.9622993, "step": 3680, "value": 0.2416713535785675}, {"wallTime": 1733071160.601249, "step": 3690, "value": 0.2575627565383911}, {"wallTime": 1733071173.748098, "step": 3700, "value": 0.2610918879508972}, {"wallTime": 1733071182.8810794, "step": 3710, "value": 0.2661415636539459}, {"wallTime": 1733071191.2078743, "step": 3720, "value": 0.313462495803833}, {"wallTime": 1733071200.3312614, "step": 3730, "value": 0.5737546682357788}, {"wallTime": 1733071208.3635156, "step": 3740, "value": 0.28045061230659485}, {"wallTime": 1733071216.5697334, "step": 3750, "value": 0.20161908864974976}, {"wallTime": 1733071224.6597552, "step": 3760, "value": 0.169964998960495}, {"wallTime": 1733071232.8584807, "step": 3770, "value": 0.1636446714401245}, {"wallTime": 1733071248.5312412, "step": 3780, "value": 0.3570013642311096}, {"wallTime": 1733071257.3896186, "step": 3790, "value": 0.4243074059486389}, {"wallTime": 1733071265.5652218, "step": 3800, "value": 0.19347724318504333}, {"wallTime": 1733071274.176607, "step": 3810, "value": 0.30941155552864075}, {"wallTime": 1733071283.015854, "step": 3820, "value": 0.22897422313690186}, {"wallTime": 1733071291.7276945, "step": 3830, "value": 0.17676621675491333}, {"wallTime": 1733071299.8898196, "step": 3840, "value": 0.2078557163476944}, {"wallTime": 1733071308.4772696, "step": 3850, "value": 0.28450343012809753}, {"wallTime": 1733071316.949397, "step": 3860, "value": 0.30476701259613037}, {"wallTime": 1733071330.2129745, "step": 3870, "value": 0.2234361171722412}, {"wallTime": 1733071338.9869187, "step": 3880, "value": 0.24055792391300201}, {"wallTime": 1733071347.7349083, "step": 3890, "value": 0.21515391767024994}, {"wallTime": 1733071357.032438, "step": 3900, "value": 0.21623648703098297}, {"wallTime": 1733071365.2235355, "step": 3910, "value": 0.29513001441955566}, {"wallTime": 1733071374.1328466, "step": 3920, "value": 0.4591183066368103}, {"wallTime": 1733071382.8120542, "step": 3930, "value": 0.2983337342739105}, {"wallTime": 1733071391.5666738, "step": 3940, "value": 0.2559032440185547}, {"wallTime": 1733071404.4654205, "step": 3950, "value": 0.23281671106815338}, {"wallTime": 1733071412.3370793, "step": 3960, "value": 0.2552999258041382}, {"wallTime": 1733071421.155789, "step": 3970, "value": 0.2731378972530365}, {"wallTime": 1733071430.1187744, "step": 3980, "value": 0.19459205865859985}, {"wallTime": 1733071438.4122202, "step": 3990, "value": 0.3734782934188843}, {"wallTime": 1733071447.727064, "step": 4000, "value": 0.3531933128833771}, {"wallTime": 1733071456.194871, "step": 4010, "value": 0.291717529296875}, {"wallTime": 1733071464.7477252, "step": 4020, "value": 0.2491512894630432}, {"wallTime": 1733071473.394911, "step": 4030, "value": 0.325714647769928}, {"wallTime": 1733071490.284732, "step": 4040, "value": 0.24741651117801666}, {"wallTime": 1733071498.7100124, "step": 4050, "value": 0.23619219660758972}, {"wallTime": 1733071507.0956266, "step": 4060, "value": 0.19156312942504883}, {"wallTime": 1733071515.066096, "step": 4070, "value": 0.2856998145580292}, {"wallTime": 1733071523.8795612, "step": 4080, "value": 0.27212557196617126}, {"wallTime": 1733071532.2835612, "step": 4090, "value": 0.19722682237625122}, {"wallTime": 1733071540.9161367, "step": 4100, "value": 0.21688325703144073}, {"wallTime": 1733071549.174693, "step": 4110, "value": 0.18351317942142487}, {"wallTime": 1733071565.834537, "step": 4120, "value": 0.22607870399951935}, {"wallTime": 1733071573.630262, "step": 4130, "value": 0.16101783514022827}, {"wallTime": 1733071582.0948677, "step": 4140, "value": 0.4200650453567505}, {"wallTime": 1733071590.0212624, "step": 4150, "value": 0.16087454557418823}, {"wallTime": 1733071599.2396185, "step": 4160, "value": 0.7094675302505493}, {"wallTime": 1733071608.0704117, "step": 4170, "value": 0.25399717688560486}, {"wallTime": 1733071616.1826212, "step": 4180, "value": 0.3133142292499542}, {"wallTime": 1733071626.0816722, "step": 4190, "value": 0.15963895618915558}, {"wallTime": 1733071641.0067163, "step": 4200, "value": 0.24511325359344482}, {"wallTime": 1733071649.0396068, "step": 4210, "value": 0.20192238688468933}, {"wallTime": 1733071658.5304193, "step": 4220, "value": 0.28004249930381775}, {"wallTime": 1733071667.9650679, "step": 4230, "value": 0.32409656047821045}, {"wallTime": 1733071676.1077347, "step": 4240, "value": 0.20851385593414307}, {"wallTime": 1733071684.3775172, "step": 4250, "value": 0.3142737150192261}, {"wallTime": 1733071693.1086829, "step": 4260, "value": 0.2889400124549866}, {"wallTime": 1733071702.1829445, "step": 4270, "value": 0.2115767002105713}, {"wallTime": 1733071710.6289804, "step": 4280, "value": 0.3221973776817322}, {"wallTime": 1733071726.6758034, "step": 4290, "value": 0.2637704908847809}, {"wallTime": 1733071735.2145975, "step": 4300, "value": 0.2684173583984375}, {"wallTime": 1733071742.9561474, "step": 4310, "value": 0.2627163231372833}, {"wallTime": 1733071751.584827, "step": 4320, "value": 0.4250064790248871}, {"wallTime": 1733071760.033667, "step": 4330, "value": 0.27650657296180725}, {"wallTime": 1733071768.4304125, "step": 4340, "value": 0.18073239922523499}, {"wallTime": 1733071777.401079, "step": 4350, "value": 0.29686489701271057}, {"wallTime": 1733071785.5464065, "step": 4360, "value": 0.2733723521232605}, {"wallTime": 1733071800.8838658, "step": 4370, "value": 0.3575865626335144}, {"wallTime": 1733071809.2648265, "step": 4380, "value": 0.24133425951004028}, {"wallTime": 1733071817.345488, "step": 4390, "value": 0.20549924671649933}, {"wallTime": 1733071826.429476, "step": 4400, "value": 0.3055674433708191}, {"wallTime": 1733071834.886691, "step": 4410, "value": 0.29346150159835815}, {"wallTime": 1733071843.4459348, "step": 4420, "value": 0.2575070261955261}, {"wallTime": 1733071851.5951128, "step": 4430, "value": 0.24656134843826294}, {"wallTime": 1733071859.9230182, "step": 4440, "value": 0.2583062946796417}, {"wallTime": 1733071868.6722944, "step": 4450, "value": 0.24523112177848816}, {"wallTime": 1733071881.335291, "step": 4460, "value": 0.22680698335170746}, {"wallTime": 1733071889.6352158, "step": 4470, "value": 0.23947957158088684}, {"wallTime": 1733071898.4198775, "step": 4480, "value": 0.26863738894462585}, {"wallTime": 1733071907.335079, "step": 4490, "value": 0.22923780977725983}, {"wallTime": 1733071916.27714, "step": 4500, "value": 0.3288804292678833}, {"wallTime": 1733071925.347806, "step": 4510, "value": 0.36375996470451355}, {"wallTime": 1733071933.3283622, "step": 4520, "value": 0.1522570252418518}, {"wallTime": 1733071941.4817302, "step": 4530, "value": 0.16464196145534515}, {"wallTime": 1733071954.1680534, "step": 4540, "value": 0.23408564925193787}, {"wallTime": 1733071962.3948312, "step": 4550, "value": 0.18837399780750275}, {"wallTime": 1733071970.5123808, "step": 4560, "value": 0.2648421823978424}, {"wallTime": 1733071978.868945, "step": 4570, "value": 0.37134850025177}, {"wallTime": 1733071987.7095094, "step": 4580, "value": 0.29682469367980957}, {"wallTime": 1733071996.4432366, "step": 4590, "value": 0.387570321559906}, {"wallTime": 1733072004.474931, "step": 4600, "value": 0.19253283739089966}, {"wallTime": 1733072012.7436872, "step": 4610, "value": 0.18173080682754517}, {"wallTime": 1733072025.3991096, "step": 4620, "value": 0.1988239288330078}, {"wallTime": 1733072034.1170664, "step": 4630, "value": 0.18916812539100647}, {"wallTime": 1733072043.0361814, "step": 4640, "value": 0.3122105598449707}, {"wallTime": 1733072051.7830715, "step": 4650, "value": 0.2517024278640747}, {"wallTime": 1733072060.1069024, "step": 4660, "value": 0.24410702288150787}, {"wallTime": 1733072068.601572, "step": 4670, "value": 0.2731882929801941}, {"wallTime": 1733072076.8350415, "step": 4680, "value": 0.26848161220550537}, {"wallTime": 1733072085.374518, "step": 4690, "value": 0.2865146994590759}, {"wallTime": 1733072093.7469609, "step": 4700, "value": 0.21438175439834595}, {"wallTime": 1733072106.9881194, "step": 4710, "value": 0.25908687710762024}, {"wallTime": 1733072115.6634924, "step": 4720, "value": 0.4168555438518524}, {"wallTime": 1733072123.9489257, "step": 4730, "value": 0.32428282499313354}, {"wallTime": 1733072132.2789767, "step": 4740, "value": 0.2281583696603775}, {"wallTime": 1733072140.4188395, "step": 4750, "value": 0.1940412074327469}, {"wallTime": 1733072149.0855272, "step": 4760, "value": 0.21351495385169983}, {"wallTime": 1733072157.4100502, "step": 4770, "value": 0.23983800411224365}, {"wallTime": 1733072165.4877243, "step": 4780, "value": 0.2716953754425049}, {"wallTime": 1733072179.6462586, "step": 4790, "value": 0.25917908549308777}, {"wallTime": 1733072188.328058, "step": 4800, "value": 0.1937154233455658}, {"wallTime": 1733072196.8452992, "step": 4810, "value": 0.2588312327861786}, {"wallTime": 1733072204.5606046, "step": 4820, "value": 0.20298603177070618}, {"wallTime": 1733072213.0979977, "step": 4830, "value": 0.36220160126686096}, {"wallTime": 1733072221.6653483, "step": 4840, "value": 0.2649674415588379}, {"wallTime": 1733072229.8923116, "step": 4850, "value": 0.2037760615348816}, {"wallTime": 1733072238.0545282, "step": 4860, "value": 0.24295860528945923}, {"wallTime": 1733072246.3418694, "step": 4870, "value": 0.20098133385181427}, {"wallTime": 1733072261.2657177, "step": 4880, "value": 0.22974130511283875}, {"wallTime": 1733072269.850521, "step": 4890, "value": 0.2208177000284195}, {"wallTime": 1733072278.8597612, "step": 4900, "value": 0.28527650237083435}, {"wallTime": 1733072287.532939, "step": 4910, "value": 0.20157480239868164}, {"wallTime": 1733072295.9455793, "step": 4920, "value": 0.17802177369594574}, {"wallTime": 1733072304.3538334, "step": 4930, "value": 0.26516541838645935}, {"wallTime": 1733072313.5083027, "step": 4940, "value": 0.2641841173171997}, {"wallTime": 1733072321.3238416, "step": 4950, "value": 0.18738216161727905}, {"wallTime": 1733072337.0234559, "step": 4960, "value": 0.16448186337947845}, {"wallTime": 1733072345.5292885, "step": 4970, "value": 0.1768539994955063}, {"wallTime": 1733072353.428351, "step": 4980, "value": 0.22538086771965027}, {"wallTime": 1733072362.411818, "step": 4990, "value": 0.2407333254814148}, {"wallTime": 1733072371.7445326, "step": 5000, "value": 0.22937001287937164}, {"wallTime": 1733072380.528269, "step": 5010, "value": 0.2900051474571228}, {"wallTime": 1733072389.025053, "step": 5020, "value": 0.3048210144042969}, {"wallTime": 1733072397.784116, "step": 5030, "value": 0.19621802866458893}, {"wallTime": 1733072411.2969327, "step": 5040, "value": 0.22021198272705078}, {"wallTime": 1733072419.4726923, "step": 5050, "value": 0.20687685906887054}, {"wallTime": 1733072428.370864, "step": 5060, "value": 0.28781241178512573}, {"wallTime": 1733072437.1150343, "step": 5070, "value": 0.26624199748039246}, {"wallTime": 1733072446.1738439, "step": 5080, "value": 0.2905060350894928}, {"wallTime": 1733072454.4270217, "step": 5090, "value": 0.19897444546222687}, {"wallTime": 1733072462.409107, "step": 5100, "value": 0.2481474131345749}, {"wallTime": 1733072471.148581, "step": 5110, "value": 0.21848848462104797}, {"wallTime": 1733072478.9451547, "step": 5120, "value": 0.30159953236579895}, {"wallTime": 1733072491.320309, "step": 5130, "value": 0.325094610452652}, {"wallTime": 1733072499.2573404, "step": 5140, "value": 0.16797251999378204}, {"wallTime": 1733072507.1107287, "step": 5150, "value": 0.2189875841140747}, {"wallTime": 1733072515.3158185, "step": 5160, "value": 0.6162499189376831}, {"wallTime": 1733072523.4981773, "step": 5170, "value": 0.2742982506752014}, {"wallTime": 1733072531.0858755, "step": 5180, "value": 0.17425358295440674}, {"wallTime": 1733072540.0198476, "step": 5190, "value": 0.23819468915462494}, {"wallTime": 1733072548.6501384, "step": 5200, "value": 0.26440367102622986}, {"wallTime": 1733072561.4132996, "step": 5210, "value": 0.20928063988685608}, {"wallTime": 1733072569.8942292, "step": 5220, "value": 0.28935492038726807}, {"wallTime": 1733072578.676928, "step": 5230, "value": 0.2670828700065613}, {"wallTime": 1733072586.9402106, "step": 5240, "value": 0.2725363075733185}, {"wallTime": 1733072595.0329394, "step": 5250, "value": 0.33465948700904846}, {"wallTime": 1733072603.1720617, "step": 5260, "value": 0.2465970665216446}, {"wallTime": 1733072611.0781033, "step": 5270, "value": 0.2762591540813446}, {"wallTime": 1733072619.9530861, "step": 5280, "value": 0.24406282603740692}, {"wallTime": 1733072628.633221, "step": 5290, "value": 0.2391514927148819}, {"wallTime": 1733072641.3740757, "step": 5300, "value": 0.22545279562473297}, {"wallTime": 1733072649.8561907, "step": 5310, "value": 0.16627785563468933}, {"wallTime": 1733072657.9699411, "step": 5320, "value": 0.18233007192611694}, {"wallTime": 1733072667.0280228, "step": 5330, "value": 0.29431045055389404}, {"wallTime": 1733072675.9416196, "step": 5340, "value": 0.24006959795951843}, {"wallTime": 1733072684.2370837, "step": 5350, "value": 0.37167733907699585}, {"wallTime": 1733072691.8567553, "step": 5360, "value": 0.24792858958244324}, {"wallTime": 1733072700.1466043, "step": 5370, "value": 0.18561898171901703}, {"wallTime": 1733072713.1816409, "step": 5380, "value": 0.188858300447464}, {"wallTime": 1733072721.0233428, "step": 5390, "value": 0.1649843007326126}, {"wallTime": 1733072729.8755789, "step": 5400, "value": 0.22556018829345703}, {"wallTime": 1733072738.3673627, "step": 5410, "value": 0.17909042537212372}, {"wallTime": 1733072746.3812735, "step": 5420, "value": 0.24985212087631226}, {"wallTime": 1733072754.616283, "step": 5430, "value": 0.31300100684165955}, {"wallTime": 1733072762.5448668, "step": 5440, "value": 0.1870119422674179}, {"wallTime": 1733072771.3592625, "step": 5450, "value": 0.2434483766555786}, {"wallTime": 1733072787.1503341, "step": 5460, "value": 0.1786746233701706}, {"wallTime": 1733072795.8010967, "step": 5470, "value": 0.25064364075660706}, {"wallTime": 1733072804.2406192, "step": 5480, "value": 0.16767306625843048}, {"wallTime": 1733072812.3717191, "step": 5490, "value": 0.2651064991950989}, {"wallTime": 1733072821.157843, "step": 5500, "value": 0.27428391575813293}, {"wallTime": 1733072830.02118, "step": 5510, "value": 0.29490622878074646}, {"wallTime": 1733072838.6937118, "step": 5520, "value": 0.20746470987796783}, {"wallTime": 1733072846.90358, "step": 5530, "value": 0.16963672637939453}, {"wallTime": 1733072855.2441375, "step": 5540, "value": 0.19783081114292145}, {"wallTime": 1733072870.6423872, "step": 5550, "value": 0.28324517607688904}, {"wallTime": 1733072878.7270522, "step": 5560, "value": 0.275233656167984}, {"wallTime": 1733072886.6084874, "step": 5570, "value": 0.233289435505867}, {"wallTime": 1733072895.0193129, "step": 5580, "value": 0.8562710285186768}, {"wallTime": 1733072903.4013505, "step": 5590, "value": 0.20864197611808777}, {"wallTime": 1733072911.2083776, "step": 5600, "value": 0.3090501129627228}, {"wallTime": 1733072919.838305, "step": 5610, "value": 0.26025277376174927}, {"wallTime": 1733072928.7313917, "step": 5620, "value": 0.3685661554336548}, {"wallTime": 1733072941.702088, "step": 5630, "value": 0.20350603759288788}, {"wallTime": 1733072949.9782794, "step": 5640, "value": 0.23386049270629883}, {"wallTime": 1733072958.7172565, "step": 5650, "value": 0.3245117664337158}, {"wallTime": 1733072966.8120224, "step": 5660, "value": 0.2030867636203766}, {"wallTime": 1733072974.9594185, "step": 5670, "value": 0.1852007806301117}, {"wallTime": 1733072983.5603137, "step": 5680, "value": 0.23030537366867065}, {"wallTime": 1733072992.226023, "step": 5690, "value": 0.2509457767009735}, {"wallTime": 1733073000.815438, "step": 5700, "value": 0.19814075529575348}, {"wallTime": 1733073009.7816286, "step": 5710, "value": 0.24098269641399384}, {"wallTime": 1733073022.8666227, "step": 5720, "value": 0.36620646715164185}, {"wallTime": 1733073031.532024, "step": 5730, "value": 0.2881223261356354}, {"wallTime": 1733073039.568332, "step": 5740, "value": 0.24317027628421783}, {"wallTime": 1733073047.8413618, "step": 5750, "value": 0.23773206770420074}, {"wallTime": 1733073056.154944, "step": 5760, "value": 0.1837020367383957}, {"wallTime": 1733073064.9534938, "step": 5770, "value": 0.3403690457344055}, {"wallTime": 1733073073.836096, "step": 5780, "value": 0.22209717333316803}, {"wallTime": 1733073082.7235007, "step": 5790, "value": 0.3164755702018738}, {"wallTime": 1733073095.1013854, "step": 5800, "value": 0.2187458574771881}, {"wallTime": 1733073103.314206, "step": 5810, "value": 0.24597391486167908}, {"wallTime": 1733073111.9691513, "step": 5820, "value": 0.16241037845611572}, {"wallTime": 1733073120.3536036, "step": 5830, "value": 0.30500808358192444}, {"wallTime": 1733073128.2076814, "step": 5840, "value": 0.20119048655033112}, {"wallTime": 1733073136.7141767, "step": 5850, "value": 0.1679176241159439}, {"wallTime": 1733073144.926302, "step": 5860, "value": 0.25117912888526917}, {"wallTime": 1733073153.038868, "step": 5870, "value": 0.15652593970298767}, {"wallTime": 1733073166.0010474, "step": 5880, "value": 0.19063246250152588}, {"wallTime": 1733073174.6574717, "step": 5890, "value": 0.15483245253562927}, {"wallTime": 1733073182.5068111, "step": 5900, "value": 0.22695989906787872}, {"wallTime": 1733073191.5580897, "step": 5910, "value": 0.18627020716667175}, {"wallTime": 1733073199.4088893, "step": 5920, "value": 0.10387934744358063}, {"wallTime": 1733073207.4639366, "step": 5930, "value": 0.23292972147464752}, {"wallTime": 1733073215.601369, "step": 5940, "value": 0.2077983021736145}, {"wallTime": 1733073224.356683, "step": 5950, "value": 0.20121656358242035}, {"wallTime": 1733073232.8751924, "step": 5960, "value": 0.281334787607193}, {"wallTime": 1733073245.3723683, "step": 5970, "value": 0.19846515357494354}, {"wallTime": 1733073253.1781867, "step": 5980, "value": 0.24546849727630615}, {"wallTime": 1733073261.7707672, "step": 5990, "value": 0.22090104222297668}, {"wallTime": 1733073270.0584924, "step": 6000, "value": 0.2162797600030899}, {"wallTime": 1733073278.893918, "step": 6010, "value": 0.3622637987136841}, {"wallTime": 1733073287.68086, "step": 6020, "value": 0.24959638714790344}, {"wallTime": 1733073297.2731905, "step": 6030, "value": 0.3887849450111389}, {"wallTime": 1733073305.916946, "step": 6040, "value": 0.29724523425102234}, {"wallTime": 1733073322.3534882, "step": 6050, "value": 0.21498283743858337}, {"wallTime": 1733073331.976002, "step": 6060, "value": 0.15914994478225708}, {"wallTime": 1733073340.5208917, "step": 6070, "value": 0.1874675750732422}, {"wallTime": 1733073349.600746, "step": 6080, "value": 0.300240159034729}, {"wallTime": 1733073359.0699418, "step": 6090, "value": 0.18628525733947754}, {"wallTime": 1733073368.4016378, "step": 6100, "value": 0.2304447591304779}, {"wallTime": 1733073377.6737523, "step": 6110, "value": 0.24309659004211426}, {"wallTime": 1733073386.3989081, "step": 6120, "value": 0.16349318623542786}, {"wallTime": 1733073395.4502494, "step": 6130, "value": 0.2284041941165924}, {"wallTime": 1733073408.1500797, "step": 6140, "value": 0.15270407497882843}, {"wallTime": 1733073417.3224437, "step": 6150, "value": 0.18959097564220428}, {"wallTime": 1733073426.2543626, "step": 6160, "value": 0.1930314153432846}, {"wallTime": 1733073434.8080306, "step": 6170, "value": 0.1683780401945114}, {"wallTime": 1733073444.5114079, "step": 6180, "value": 0.20730845630168915}, {"wallTime": 1733073453.1141105, "step": 6190, "value": 0.24198836088180542}, {"wallTime": 1733073462.564261, "step": 6200, "value": 0.16176623106002808}, {"wallTime": 1733073472.0230157, "step": 6210, "value": 0.2335943877696991}, {"wallTime": 1733073484.4469697, "step": 6220, "value": 0.19843387603759766}, {"wallTime": 1733073493.6586926, "step": 6230, "value": 0.19296234846115112}, {"wallTime": 1733073502.4398737, "step": 6240, "value": 0.2138400375843048}, {"wallTime": 1733073511.2545247, "step": 6250, "value": 0.23674020171165466}, {"wallTime": 1733073520.4836774, "step": 6260, "value": 0.1861676722764969}, {"wallTime": 1733073529.7801037, "step": 6270, "value": 0.2806846797466278}, {"wallTime": 1733073539.6378148, "step": 6280, "value": 0.23302271962165833}, {"wallTime": 1733073548.9093668, "step": 6290, "value": 0.2027401179075241}, {"wallTime": 1733073560.6183877, "step": 6300, "value": 0.2656635642051697}, {"wallTime": 1733073570.0675812, "step": 6310, "value": 0.18881486356258392}, {"wallTime": 1733073579.4797635, "step": 6320, "value": 0.2461768388748169}, {"wallTime": 1733073587.6658924, "step": 6330, "value": 0.1924135684967041}, {"wallTime": 1733073597.2166107, "step": 6340, "value": 0.2035418450832367}, {"wallTime": 1733073606.236806, "step": 6350, "value": 0.19676603376865387}, {"wallTime": 1733073615.0762033, "step": 6360, "value": 0.2948504388332367}, {"wallTime": 1733073624.8331392, "step": 6370, "value": 0.25151124596595764}, {"wallTime": 1733073634.6711385, "step": 6380, "value": 0.2355036735534668}, {"wallTime": 1733073646.5268738, "step": 6390, "value": 0.20095404982566833}, {"wallTime": 1733073655.7440982, "step": 6400, "value": 0.2354840189218521}, {"wallTime": 1733073665.6058195, "step": 6410, "value": 0.2252877950668335}, {"wallTime": 1733073674.6414347, "step": 6420, "value": 0.2831799387931824}, {"wallTime": 1733073683.6689963, "step": 6430, "value": 0.16879332065582275}, {"wallTime": 1733073692.875441, "step": 6440, "value": 0.25563713908195496}, {"wallTime": 1733073702.5178032, "step": 6450, "value": 0.17389191687107086}, {"wallTime": 1733073712.6259992, "step": 6460, "value": 0.2530330717563629}, {"wallTime": 1733073724.0456417, "step": 6470, "value": 0.31858864426612854}, {"wallTime": 1733073732.8270707, "step": 6480, "value": 0.2340160310268402}, {"wallTime": 1733073741.9558282, "step": 6490, "value": 0.2106795459985733}, {"wallTime": 1733073750.7163498, "step": 6500, "value": 0.23795677721500397}, {"wallTime": 1733073760.4867811, "step": 6510, "value": 0.15322110056877136}, {"wallTime": 1733073769.8619761, "step": 6520, "value": 0.17369428277015686}, {"wallTime": 1733073779.125744, "step": 6530, "value": 0.19832894206047058}, {"wallTime": 1733073789.4763782, "step": 6540, "value": 0.31001386046409607}, {"wallTime": 1733073798.1019995, "step": 6550, "value": 0.3339950442314148}, {"wallTime": 1733073810.5515175, "step": 6560, "value": 0.2266998291015625}, {"wallTime": 1733073820.035032, "step": 6570, "value": 0.20274877548217773}, {"wallTime": 1733073828.2372425, "step": 6580, "value": 0.2644144296646118}, {"wallTime": 1733073836.796903, "step": 6590, "value": 0.1744423657655716}, {"wallTime": 1733073845.986199, "step": 6600, "value": 0.21742069721221924}, {"wallTime": 1733073855.2508395, "step": 6610, "value": 0.2051820456981659}, {"wallTime": 1733073864.6924272, "step": 6620, "value": 0.1905326247215271}, {"wallTime": 1733073873.833382, "step": 6630, "value": 0.21263837814331055}, {"wallTime": 1733073887.523363, "step": 6640, "value": 0.25500041246414185}, {"wallTime": 1733073897.3326857, "step": 6650, "value": 0.22583706676959991}, {"wallTime": 1733073906.8755386, "step": 6660, "value": 0.22303399443626404}, {"wallTime": 1733073916.3490758, "step": 6670, "value": 0.2548924684524536}, {"wallTime": 1733073925.6176066, "step": 6680, "value": 0.18785527348518372}, {"wallTime": 1733073934.9156127, "step": 6690, "value": 0.1761217713356018}, {"wallTime": 1733073943.7411523, "step": 6700, "value": 0.16605988144874573}, {"wallTime": 1733073952.475991, "step": 6710, "value": 0.23093022406101227}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15059" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_aux_2%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_aux_2", "runToSeries": {".": [{"wallTime": 1733067631.5382876, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6516273, "step": 10, "value": 2.080695390701294}, {"wallTime": 1733067660.7836413, "step": 20, "value": 1.8953807353973389}, {"wallTime": 1733067674.1368937, "step": 30, "value": 1.809183955192566}, {"wallTime": 1733067687.0565696, "step": 40, "value": 2.0434377193450928}, {"wallTime": 1733067699.492454, "step": 50, "value": 1.3146581649780273}, {"wallTime": 1733067710.6287432, "step": 60, "value": 1.6471138000488281}, {"wallTime": 1733067722.7549515, "step": 70, "value": 1.4186172485351562}, {"wallTime": 1733067733.7248094, "step": 80, "value": 0.9478918313980103}, {"wallTime": 1733067750.9456956, "step": 90, "value": 1.2384134531021118}, {"wallTime": 1733067761.9802809, "step": 100, "value": 1.0930715799331665}, {"wallTime": 1733067771.6058671, "step": 110, "value": 0.7257124185562134}, {"wallTime": 1733067780.546814, "step": 120, "value": 0.6193240880966187}, {"wallTime": 1733067790.4847577, "step": 130, "value": 0.8151551485061646}, {"wallTime": 1733067799.1050785, "step": 140, "value": 0.44010549783706665}, {"wallTime": 1733067809.4440658, "step": 150, "value": 0.641860842704773}, {"wallTime": 1733067818.9200957, "step": 160, "value": 0.5996979475021362}, {"wallTime": 1733067836.6489797, "step": 170, "value": 0.4371119737625122}, {"wallTime": 1733067846.3900993, "step": 180, "value": 0.6667345762252808}, {"wallTime": 1733067855.6662219, "step": 190, "value": 0.43431341648101807}, {"wallTime": 1733067864.8888433, "step": 200, "value": 0.7839441299438477}, {"wallTime": 1733067874.0011742, "step": 210, "value": 0.601776123046875}, {"wallTime": 1733067883.7851422, "step": 220, "value": 0.41202980279922485}, {"wallTime": 1733067892.1225193, "step": 230, "value": 0.5084788203239441}, {"wallTime": 1733067901.0688262, "step": 240, "value": 0.5012519359588623}, {"wallTime": 1733067910.0743113, "step": 250, "value": 0.46905517578125}, {"wallTime": 1733067925.9494529, "step": 260, "value": 0.7765033841133118}, {"wallTime": 1733067935.4749713, "step": 270, "value": 0.4334905743598938}, {"wallTime": 1733067944.0145416, "step": 280, "value": 0.47618356347084045}, {"wallTime": 1733067952.5455897, "step": 290, "value": 0.4721233546733856}, {"wallTime": 1733067961.0261605, "step": 300, "value": 0.3276199400424957}, {"wallTime": 1733067970.133849, "step": 310, "value": 0.5368462204933167}, {"wallTime": 1733067980.2251825, "step": 320, "value": 0.4472130537033081}, {"wallTime": 1733067988.8154924, "step": 330, "value": 0.5387668013572693}, {"wallTime": 1733068005.0900705, "step": 340, "value": 0.4131840169429779}, {"wallTime": 1733068014.0645773, "step": 350, "value": 0.40211355686187744}, {"wallTime": 1733068022.5524428, "step": 360, "value": 0.46374261379241943}, {"wallTime": 1733068031.8241658, "step": 370, "value": 0.4994753301143646}, {"wallTime": 1733068040.7872918, "step": 380, "value": 0.36634355783462524}, {"wallTime": 1733068050.1596901, "step": 390, "value": 0.393658310174942}, {"wallTime": 1733068059.1255639, "step": 400, "value": 0.2990470826625824}, {"wallTime": 1733068068.0895889, "step": 410, "value": 0.6695031523704529}, {"wallTime": 1733068084.8434703, "step": 420, "value": 0.3856527805328369}, {"wallTime": 1733068094.66612, "step": 430, "value": 0.50423264503479}, {"wallTime": 1733068103.7075996, "step": 440, "value": 0.34390881657600403}, {"wallTime": 1733068112.699261, "step": 450, "value": 0.4300403892993927}, {"wallTime": 1733068121.5006242, "step": 460, "value": 0.5348457098007202}, {"wallTime": 1733068130.7274182, "step": 470, "value": 0.3950074017047882}, {"wallTime": 1733068139.8554082, "step": 480, "value": 0.4044496715068817}, {"wallTime": 1733068149.3697932, "step": 490, "value": 0.5335723161697388}, {"wallTime": 1733068158.0698025, "step": 500, "value": 0.5217629671096802}, {"wallTime": 1733068174.1148942, "step": 510, "value": 0.4792400598526001}, {"wallTime": 1733068182.7193718, "step": 520, "value": 0.37991032004356384}, {"wallTime": 1733068192.413387, "step": 530, "value": 0.4013880491256714}, {"wallTime": 1733068201.8079379, "step": 540, "value": 0.39157605171203613}, {"wallTime": 1733068210.6543403, "step": 550, "value": 0.5914566516876221}, {"wallTime": 1733068220.194941, "step": 560, "value": 0.7239978909492493}, {"wallTime": 1733068229.1591513, "step": 570, "value": 0.31697574257850647}, {"wallTime": 1733068238.591392, "step": 580, "value": 0.2926163077354431}, {"wallTime": 1733068256.0731425, "step": 590, "value": 0.42313340306282043}, {"wallTime": 1733068265.4317076, "step": 600, "value": 0.49997782707214355}, {"wallTime": 1733068274.656359, "step": 610, "value": 0.6621768474578857}, {"wallTime": 1733068283.769878, "step": 620, "value": 0.5913312435150146}, {"wallTime": 1733068293.334023, "step": 630, "value": 0.4561178386211395}, {"wallTime": 1733068302.64703, "step": 640, "value": 0.3825964033603668}, {"wallTime": 1733068311.3880196, "step": 650, "value": 0.3426609933376312}, {"wallTime": 1733068320.390002, "step": 660, "value": 0.4515787959098816}, {"wallTime": 1733068328.7311335, "step": 670, "value": 0.36684876680374146}, {"wallTime": 1733068344.4610455, "step": 680, "value": 0.39730530977249146}, {"wallTime": 1733068353.7168472, "step": 690, "value": 0.3553315997123718}, {"wallTime": 1733068362.0578184, "step": 700, "value": 0.3323960304260254}, {"wallTime": 1733068371.1039574, "step": 710, "value": 0.5253123044967651}, {"wallTime": 1733068380.5330782, "step": 720, "value": 0.4072829484939575}, {"wallTime": 1733068390.086629, "step": 730, "value": 0.3146943747997284}, {"wallTime": 1733068398.720949, "step": 740, "value": 0.4645320475101471}, {"wallTime": 1733068407.1239347, "step": 750, "value": 0.4099012017250061}, {"wallTime": 1733068423.0705135, "step": 760, "value": 0.4103791415691376}, {"wallTime": 1733068431.4052966, "step": 770, "value": 0.3307669162750244}, {"wallTime": 1733068440.4249055, "step": 780, "value": 0.35377639532089233}, {"wallTime": 1733068449.0064893, "step": 790, "value": 0.37458157539367676}, {"wallTime": 1733068457.637311, "step": 800, "value": 0.39888277649879456}, {"wallTime": 1733068467.047233, "step": 810, "value": 0.379932701587677}, {"wallTime": 1733068475.6204474, "step": 820, "value": 0.37396910786628723}, {"wallTime": 1733068484.9790273, "step": 830, "value": 0.37659746408462524}, {"wallTime": 1733068500.731624, "step": 840, "value": 0.4060446619987488}, {"wallTime": 1733068509.3079069, "step": 850, "value": 0.41818585991859436}, {"wallTime": 1733068519.0223103, "step": 860, "value": 0.41387635469436646}, {"wallTime": 1733068527.498696, "step": 870, "value": 0.3317413032054901}, {"wallTime": 1733068536.9204211, "step": 880, "value": 0.48514479398727417}, {"wallTime": 1733068544.9089813, "step": 890, "value": 0.3549751341342926}, {"wallTime": 1733068553.5791998, "step": 900, "value": 0.374754399061203}, {"wallTime": 1733068562.686232, "step": 910, "value": 0.41678789258003235}, {"wallTime": 1733068571.2465985, "step": 920, "value": 0.3407939076423645}, {"wallTime": 1733068584.7765868, "step": 930, "value": 0.3867117762565613}, {"wallTime": 1733068593.7729516, "step": 940, "value": 0.37154048681259155}, {"wallTime": 1733068602.7671032, "step": 950, "value": 0.4528048038482666}, {"wallTime": 1733068611.0411282, "step": 960, "value": 0.2866477072238922}, {"wallTime": 1733068620.2279866, "step": 970, "value": 0.3346644639968872}, {"wallTime": 1733068628.84297, "step": 980, "value": 0.4059211015701294}, {"wallTime": 1733068637.6318617, "step": 990, "value": 0.33558475971221924}, {"wallTime": 1733068646.6744666, "step": 1000, "value": 0.3927761912345886}, {"wallTime": 1733068662.7582457, "step": 1010, "value": 0.25262451171875}, {"wallTime": 1733068672.055967, "step": 1020, "value": 0.3016338348388672}, {"wallTime": 1733068680.564605, "step": 1030, "value": 0.3289056122303009}, {"wallTime": 1733068690.1874955, "step": 1040, "value": 0.3575264811515808}, {"wallTime": 1733068698.8498933, "step": 1050, "value": 0.3401120901107788}, {"wallTime": 1733068707.7450576, "step": 1060, "value": 0.7627344727516174}, {"wallTime": 1733068717.3462613, "step": 1070, "value": 0.3401707112789154}, {"wallTime": 1733068726.3630192, "step": 1080, "value": 0.41789713501930237}, {"wallTime": 1733068735.2534366, "step": 1090, "value": 0.44904178380966187}, {"wallTime": 1733068749.5495753, "step": 1100, "value": 0.35770997405052185}, {"wallTime": 1733068758.377043, "step": 1110, "value": 0.4470846354961395}, {"wallTime": 1733068767.0054936, "step": 1120, "value": 0.5262433886528015}, {"wallTime": 1733068776.6204836, "step": 1130, "value": 0.46039822697639465}, {"wallTime": 1733068785.4027932, "step": 1140, "value": 0.24248725175857544}, {"wallTime": 1733068794.2806695, "step": 1150, "value": 0.408734530210495}, {"wallTime": 1733068802.6989954, "step": 1160, "value": 0.27563807368278503}, {"wallTime": 1733068811.5532665, "step": 1170, "value": 0.3917568624019623}, {"wallTime": 1733068824.967374, "step": 1180, "value": 0.22737286984920502}, {"wallTime": 1733068834.3788517, "step": 1190, "value": 0.370757132768631}, {"wallTime": 1733068843.5178127, "step": 1200, "value": 0.4513852596282959}, {"wallTime": 1733068852.2301292, "step": 1210, "value": 0.34924501180648804}, {"wallTime": 1733068861.1185803, "step": 1220, "value": 0.3619726300239563}, {"wallTime": 1733068870.0575333, "step": 1230, "value": 0.6342002153396606}, {"wallTime": 1733068878.7220423, "step": 1240, "value": 0.4254252016544342}, {"wallTime": 1733068887.7397754, "step": 1250, "value": 0.33321934938430786}, {"wallTime": 1733068903.1683936, "step": 1260, "value": 0.4800363779067993}, {"wallTime": 1733068912.4163592, "step": 1270, "value": 0.27384719252586365}, {"wallTime": 1733068921.4748194, "step": 1280, "value": 0.3472641408443451}, {"wallTime": 1733068929.7483156, "step": 1290, "value": 0.38216203451156616}, {"wallTime": 1733068939.5030124, "step": 1300, "value": 0.3377664387226105}, {"wallTime": 1733068948.9293096, "step": 1310, "value": 0.39470091462135315}, {"wallTime": 1733068957.2360976, "step": 1320, "value": 0.48870712518692017}, {"wallTime": 1733068966.0786946, "step": 1330, "value": 0.28279149532318115}, {"wallTime": 1733068975.5668347, "step": 1340, "value": 0.5299948453903198}, {"wallTime": 1733068989.7998044, "step": 1350, "value": 0.3861175775527954}, {"wallTime": 1733068998.2834063, "step": 1360, "value": 0.2912198305130005}, {"wallTime": 1733069007.150217, "step": 1370, "value": 0.35350024700164795}, {"wallTime": 1733069015.9229352, "step": 1380, "value": 0.20359806716442108}, {"wallTime": 1733069025.3048892, "step": 1390, "value": 0.3660353422164917}, {"wallTime": 1733069034.4830666, "step": 1400, "value": 0.2714415490627289}, {"wallTime": 1733069042.7945862, "step": 1410, "value": 0.4277336001396179}, {"wallTime": 1733069052.1391222, "step": 1420, "value": 0.2591265141963959}, {"wallTime": 1733069065.0031836, "step": 1430, "value": 0.2999512255191803}, {"wallTime": 1733069074.5255163, "step": 1440, "value": 0.32082682847976685}, {"wallTime": 1733069083.784105, "step": 1450, "value": 0.38447484374046326}, {"wallTime": 1733069092.2596862, "step": 1460, "value": 0.2936805486679077}, {"wallTime": 1733069101.0311494, "step": 1470, "value": 0.34327274560928345}, {"wallTime": 1733069109.9069889, "step": 1480, "value": 0.3020152151584625}, {"wallTime": 1733069119.1193304, "step": 1490, "value": 0.2324322611093521}, {"wallTime": 1733069128.4165964, "step": 1500, "value": 0.3235621452331543}, {"wallTime": 1733069137.607241, "step": 1510, "value": 0.45852625370025635}, {"wallTime": 1733069150.543989, "step": 1520, "value": 0.39603352546691895}, {"wallTime": 1733069159.75751, "step": 1530, "value": 0.4401102662086487}, {"wallTime": 1733069168.1707656, "step": 1540, "value": 0.20172826945781708}, {"wallTime": 1733069176.8413863, "step": 1550, "value": 0.43283718824386597}, {"wallTime": 1733069185.8927166, "step": 1560, "value": 0.23378564417362213}, {"wallTime": 1733069194.924435, "step": 1570, "value": 0.37933576107025146}, {"wallTime": 1733069203.9131467, "step": 1580, "value": 0.31420981884002686}, {"wallTime": 1733069212.7161067, "step": 1590, "value": 0.2628835141658783}, {"wallTime": 1733069225.5342922, "step": 1600, "value": 0.28920266032218933}, {"wallTime": 1733069235.4642823, "step": 1610, "value": 0.44446396827697754}, {"wallTime": 1733069244.6301591, "step": 1620, "value": 0.4983426630496979}, {"wallTime": 1733069254.2720568, "step": 1630, "value": 0.3386428654193878}, {"wallTime": 1733069263.0057395, "step": 1640, "value": 0.2582284212112427}, {"wallTime": 1733069271.8671172, "step": 1650, "value": 0.44047924876213074}, {"wallTime": 1733069280.5103207, "step": 1660, "value": 0.27518290281295776}, {"wallTime": 1733069289.6801703, "step": 1670, "value": 0.377144455909729}, {"wallTime": 1733069303.610035, "step": 1680, "value": 0.48883700370788574}, {"wallTime": 1733069312.4800236, "step": 1690, "value": 0.3860618472099304}, {"wallTime": 1733069321.839019, "step": 1700, "value": 0.4641936421394348}, {"wallTime": 1733069330.3484063, "step": 1710, "value": 0.29673507809638977}, {"wallTime": 1733069339.2456088, "step": 1720, "value": 0.23402944207191467}, {"wallTime": 1733069346.857799, "step": 1730, "value": 0.2458406686782837}, {"wallTime": 1733069355.6535568, "step": 1740, "value": 0.45618003606796265}, {"wallTime": 1733069364.5124397, "step": 1750, "value": 0.35889601707458496}, {"wallTime": 1733069373.73905, "step": 1760, "value": 0.3201447129249573}, {"wallTime": 1733069387.5414565, "step": 1770, "value": 0.3087303936481476}, {"wallTime": 1733069396.4677157, "step": 1780, "value": 0.2618909478187561}, {"wallTime": 1733069405.996696, "step": 1790, "value": 0.20325668156147003}, {"wallTime": 1733069415.0542004, "step": 1800, "value": 0.25247815251350403}, {"wallTime": 1733069423.9079056, "step": 1810, "value": 0.21179962158203125}, {"wallTime": 1733069432.5315094, "step": 1820, "value": 0.41610902547836304}, {"wallTime": 1733069441.2180326, "step": 1830, "value": 0.33513006567955017}, {"wallTime": 1733069450.0882382, "step": 1840, "value": 0.2411704957485199}, {"wallTime": 1733069463.1070628, "step": 1850, "value": 0.23377172648906708}, {"wallTime": 1733069471.573017, "step": 1860, "value": 0.2607581317424774}, {"wallTime": 1733069480.4982533, "step": 1870, "value": 0.5200584530830383}, {"wallTime": 1733069489.3849282, "step": 1880, "value": 0.42138785123825073}, {"wallTime": 1733069497.976726, "step": 1890, "value": 0.42232421040534973}, {"wallTime": 1733069506.794279, "step": 1900, "value": 0.31997546553611755}, {"wallTime": 1733069515.824631, "step": 1910, "value": 0.24350279569625854}, {"wallTime": 1733069524.636494, "step": 1920, "value": 0.2875710725784302}, {"wallTime": 1733069533.542101, "step": 1930, "value": 0.21778646111488342}, {"wallTime": 1733069550.4779222, "step": 1940, "value": 0.3713792860507965}, {"wallTime": 1733069558.8279557, "step": 1950, "value": 0.2620013654232025}, {"wallTime": 1733069567.7578547, "step": 1960, "value": 0.26055777072906494}, {"wallTime": 1733069576.345143, "step": 1970, "value": 0.26311370730400085}, {"wallTime": 1733069585.5291548, "step": 1980, "value": 0.40736067295074463}, {"wallTime": 1733069594.3501785, "step": 1990, "value": 0.3872552216053009}, {"wallTime": 1733069602.401576, "step": 2000, "value": 0.5763322114944458}, {"wallTime": 1733069610.2499282, "step": 2010, "value": 0.4714934825897217}, {"wallTime": 1733069626.6867523, "step": 2020, "value": 0.407201886177063}, {"wallTime": 1733069635.0308647, "step": 2030, "value": 0.27153411507606506}, {"wallTime": 1733069643.8224714, "step": 2040, "value": 0.25396227836608887}, {"wallTime": 1733069652.1943781, "step": 2050, "value": 0.2990524172782898}, {"wallTime": 1733069660.4533696, "step": 2060, "value": 0.425738126039505}, {"wallTime": 1733069669.5920012, "step": 2070, "value": 0.3363970220088959}, {"wallTime": 1733069678.7782953, "step": 2080, "value": 0.5298561453819275}, {"wallTime": 1733069686.9447484, "step": 2090, "value": 0.40115299820899963}, {"wallTime": 1733069700.6019387, "step": 2100, "value": 0.32642778754234314}, {"wallTime": 1733069708.726263, "step": 2110, "value": 0.24233263731002808}, {"wallTime": 1733069717.4482055, "step": 2120, "value": 0.298852801322937}, {"wallTime": 1733069726.141112, "step": 2130, "value": 0.3076654374599457}, {"wallTime": 1733069735.0380106, "step": 2140, "value": 0.33796870708465576}, {"wallTime": 1733069743.3060358, "step": 2150, "value": 0.2794177830219269}, {"wallTime": 1733069752.5007257, "step": 2160, "value": 0.32477086782455444}, {"wallTime": 1733069761.4508688, "step": 2170, "value": 0.3205968737602234}, {"wallTime": 1733069770.4330676, "step": 2180, "value": 0.3938342332839966}, {"wallTime": 1733069784.3634033, "step": 2190, "value": 0.365341454744339}, {"wallTime": 1733069793.1223545, "step": 2200, "value": 0.17411820590496063}, {"wallTime": 1733069801.6359806, "step": 2210, "value": 0.2906370759010315}, {"wallTime": 1733069810.6077392, "step": 2220, "value": 0.41872498393058777}, {"wallTime": 1733069819.3418725, "step": 2230, "value": 0.2585006356239319}, {"wallTime": 1733069827.3259432, "step": 2240, "value": 0.39148929715156555}, {"wallTime": 1733069835.8677292, "step": 2250, "value": 0.28158050775527954}, {"wallTime": 1733069844.2357147, "step": 2260, "value": 0.32017889618873596}, {"wallTime": 1733069856.7489548, "step": 2270, "value": 0.2611235976219177}, {"wallTime": 1733069865.2574077, "step": 2280, "value": 0.21407657861709595}, {"wallTime": 1733069874.0054333, "step": 2290, "value": 0.19418634474277496}, {"wallTime": 1733069881.7814145, "step": 2300, "value": 0.3735412657260895}, {"wallTime": 1733069890.4135334, "step": 2310, "value": 0.2556115984916687}, {"wallTime": 1733069898.876337, "step": 2320, "value": 0.274768590927124}, {"wallTime": 1733069908.317429, "step": 2330, "value": 0.26886141300201416}, {"wallTime": 1733069917.4148707, "step": 2340, "value": 0.36771345138549805}, {"wallTime": 1733069925.8502526, "step": 2350, "value": 0.23120583593845367}, {"wallTime": 1733069938.702251, "step": 2360, "value": 0.3449189364910126}, {"wallTime": 1733069947.4258332, "step": 2370, "value": 0.37372201681137085}, {"wallTime": 1733069956.2061746, "step": 2380, "value": 0.4069491922855377}, {"wallTime": 1733069964.2744038, "step": 2390, "value": 0.2959591746330261}, {"wallTime": 1733069973.3257642, "step": 2400, "value": 0.22795788943767548}, {"wallTime": 1733069981.4318073, "step": 2410, "value": 0.25708505511283875}, {"wallTime": 1733069990.1393342, "step": 2420, "value": 0.2824762761592865}, {"wallTime": 1733069998.7976296, "step": 2430, "value": 0.3078904151916504}, {"wallTime": 1733070012.455377, "step": 2440, "value": 0.2751883268356323}, {"wallTime": 1733070021.5985591, "step": 2450, "value": 0.24739894270896912}, {"wallTime": 1733070030.1905954, "step": 2460, "value": 0.25922197103500366}, {"wallTime": 1733070039.2189567, "step": 2470, "value": 0.28536340594291687}, {"wallTime": 1733070048.268535, "step": 2480, "value": 0.36017850041389465}, {"wallTime": 1733070056.155332, "step": 2490, "value": 0.3876716196537018}, {"wallTime": 1733070064.4502275, "step": 2500, "value": 0.35487836599349976}, {"wallTime": 1733070072.549877, "step": 2510, "value": 0.2460671067237854}, {"wallTime": 1733070087.65646, "step": 2520, "value": 0.29097944498062134}, {"wallTime": 1733070095.4412909, "step": 2530, "value": 0.2671825587749481}, {"wallTime": 1733070103.768445, "step": 2540, "value": 0.24344685673713684}, {"wallTime": 1733070113.0487857, "step": 2550, "value": 0.23989059031009674}, {"wallTime": 1733070121.037413, "step": 2560, "value": 0.2448614090681076}, {"wallTime": 1733070129.5839252, "step": 2570, "value": 0.29942595958709717}, {"wallTime": 1733070138.360295, "step": 2580, "value": 0.26511210203170776}, {"wallTime": 1733070147.0868542, "step": 2590, "value": 0.3468071222305298}, {"wallTime": 1733070155.486556, "step": 2600, "value": 0.4428101181983948}, {"wallTime": 1733070172.576863, "step": 2610, "value": 0.3074207603931427}, {"wallTime": 1733070181.210814, "step": 2620, "value": 0.3308529853820801}, {"wallTime": 1733070189.691964, "step": 2630, "value": 0.27704471349716187}, {"wallTime": 1733070198.398719, "step": 2640, "value": 0.2676895558834076}, {"wallTime": 1733070206.7069716, "step": 2650, "value": 0.2134418785572052}, {"wallTime": 1733070215.5992916, "step": 2660, "value": 0.3338371217250824}, {"wallTime": 1733070224.3152006, "step": 2670, "value": 0.3282110095024109}, {"wallTime": 1733070233.5389671, "step": 2680, "value": 0.2812475264072418}, {"wallTime": 1733070246.757729, "step": 2690, "value": 0.2590143084526062}, {"wallTime": 1733070256.028412, "step": 2700, "value": 0.3953779339790344}, {"wallTime": 1733070264.9503717, "step": 2710, "value": 0.25926652550697327}, {"wallTime": 1733070273.8042996, "step": 2720, "value": 0.3405478298664093}, {"wallTime": 1733070282.9586601, "step": 2730, "value": 0.301283061504364}, {"wallTime": 1733070292.2774882, "step": 2740, "value": 0.2884443402290344}, {"wallTime": 1733070300.3363457, "step": 2750, "value": 0.2765781283378601}, {"wallTime": 1733070309.4117706, "step": 2760, "value": 0.4287860095500946}, {"wallTime": 1733070317.5310807, "step": 2770, "value": 0.4033634662628174}, {"wallTime": 1733070330.435747, "step": 2780, "value": 0.3278459906578064}, {"wallTime": 1733070339.8224652, "step": 2790, "value": 0.26182425022125244}, {"wallTime": 1733070347.9929206, "step": 2800, "value": 0.2031681090593338}, {"wallTime": 1733070356.8918555, "step": 2810, "value": 0.2942606508731842}, {"wallTime": 1733070365.5764747, "step": 2820, "value": 0.2681368887424469}, {"wallTime": 1733070374.3928125, "step": 2830, "value": 0.27040567994117737}, {"wallTime": 1733070382.426595, "step": 2840, "value": 0.3427635431289673}, {"wallTime": 1733070390.9409597, "step": 2850, "value": 0.23687981069087982}, {"wallTime": 1733070406.6783435, "step": 2860, "value": 0.25277042388916016}, {"wallTime": 1733070415.0895438, "step": 2870, "value": 0.2447420209646225}, {"wallTime": 1733070422.919613, "step": 2880, "value": 0.23025289177894592}, {"wallTime": 1733070431.5370362, "step": 2890, "value": 0.25661584734916687}, {"wallTime": 1733070439.9805102, "step": 2900, "value": 0.32778483629226685}, {"wallTime": 1733070448.0851657, "step": 2910, "value": 0.4128904342651367}, {"wallTime": 1733070457.4233537, "step": 2920, "value": 0.4414340555667877}, {"wallTime": 1733070466.722464, "step": 2930, "value": 0.37734276056289673}, {"wallTime": 1733070479.3321738, "step": 2940, "value": 0.3071369230747223}, {"wallTime": 1733070488.7819545, "step": 2950, "value": 0.28956010937690735}, {"wallTime": 1733070497.2244911, "step": 2960, "value": 0.36711955070495605}, {"wallTime": 1733070505.6334329, "step": 2970, "value": 0.24147020280361176}, {"wallTime": 1733070513.353502, "step": 2980, "value": 0.20447459816932678}, {"wallTime": 1733070522.30076, "step": 2990, "value": 0.35678815841674805}, {"wallTime": 1733070530.2122993, "step": 3000, "value": 0.1977052539587021}, {"wallTime": 1733070538.2996109, "step": 3010, "value": 0.30431243777275085}, {"wallTime": 1733070547.3998864, "step": 3020, "value": 0.2507193982601166}, {"wallTime": 1733070564.0503628, "step": 3030, "value": 0.2368711233139038}, {"wallTime": 1733070572.3693044, "step": 3040, "value": 0.23670288920402527}, {"wallTime": 1733070580.670452, "step": 3050, "value": 0.27253976464271545}, {"wallTime": 1733070588.6528013, "step": 3060, "value": 0.2743288576602936}, {"wallTime": 1733070597.4202695, "step": 3070, "value": 0.23955011367797852}, {"wallTime": 1733070606.13679, "step": 3080, "value": 0.3732152283191681}, {"wallTime": 1733070614.4390817, "step": 3090, "value": 0.337666392326355}, {"wallTime": 1733070623.9994104, "step": 3100, "value": 0.28039950132369995}, {"wallTime": 1733070637.2515874, "step": 3110, "value": 0.34428849816322327}, {"wallTime": 1733070645.681535, "step": 3120, "value": 0.29746198654174805}, {"wallTime": 1733070654.2691555, "step": 3130, "value": 0.24177810549736023}, {"wallTime": 1733070663.3199284, "step": 3140, "value": 0.24877604842185974}, {"wallTime": 1733070671.1167088, "step": 3150, "value": 0.339580237865448}, {"wallTime": 1733070679.7641995, "step": 3160, "value": 0.3702695369720459}, {"wallTime": 1733070687.8438635, "step": 3170, "value": 0.2542412281036377}, {"wallTime": 1733070695.8544533, "step": 3180, "value": 0.32293224334716797}, {"wallTime": 1733070704.6210716, "step": 3190, "value": 0.25320664048194885}, {"wallTime": 1733070717.1074848, "step": 3200, "value": 0.19911843538284302}, {"wallTime": 1733070726.0972962, "step": 3210, "value": 0.2939826250076294}, {"wallTime": 1733070734.7755811, "step": 3220, "value": 0.18568558990955353}, {"wallTime": 1733070744.4109983, "step": 3230, "value": 0.2799058258533478}, {"wallTime": 1733070752.5002856, "step": 3240, "value": 0.4392484426498413}, {"wallTime": 1733070761.7197666, "step": 3250, "value": 0.3916686475276947}, {"wallTime": 1733070770.3752215, "step": 3260, "value": 0.2716422975063324}, {"wallTime": 1733070779.7286913, "step": 3270, "value": 0.258347749710083}, {"wallTime": 1733070793.6770978, "step": 3280, "value": 0.23874296247959137}, {"wallTime": 1733070801.8986652, "step": 3290, "value": 0.38634005188941956}, {"wallTime": 1733070810.1597059, "step": 3300, "value": 0.34360572695732117}, {"wallTime": 1733070818.725149, "step": 3310, "value": 0.17896133661270142}, {"wallTime": 1733070827.0057337, "step": 3320, "value": 0.22808022797107697}, {"wallTime": 1733070835.573203, "step": 3330, "value": 0.27150148153305054}, {"wallTime": 1733070843.973309, "step": 3340, "value": 0.4057391881942749}, {"wallTime": 1733070853.0903046, "step": 3350, "value": 0.32181593775749207}, {"wallTime": 1733070865.418185, "step": 3360, "value": 0.20848482847213745}, {"wallTime": 1733070873.660334, "step": 3370, "value": 0.2587141692638397}, {"wallTime": 1733070883.3346956, "step": 3380, "value": 0.23889261484146118}, {"wallTime": 1733070892.3757029, "step": 3390, "value": 0.27199873328208923}, {"wallTime": 1733070900.7210689, "step": 3400, "value": 0.3139481246471405}, {"wallTime": 1733070908.5028803, "step": 3410, "value": 0.27872031927108765}, {"wallTime": 1733070916.6544735, "step": 3420, "value": 0.3724561929702759}, {"wallTime": 1733070925.2077584, "step": 3430, "value": 0.2567875385284424}, {"wallTime": 1733070933.8089693, "step": 3440, "value": 0.21336816251277924}, {"wallTime": 1733070947.478442, "step": 3450, "value": 0.24019095301628113}, {"wallTime": 1733070956.1859803, "step": 3460, "value": 0.247470885515213}, {"wallTime": 1733070964.2650073, "step": 3470, "value": 0.26268553733825684}, {"wallTime": 1733070972.3848042, "step": 3480, "value": 0.2689904272556305}, {"wallTime": 1733070980.6458163, "step": 3490, "value": 0.46109849214553833}, {"wallTime": 1733070989.6864293, "step": 3500, "value": 0.24358539283275604}, {"wallTime": 1733070997.7872305, "step": 3510, "value": 0.23398685455322266}, {"wallTime": 1733071006.2701197, "step": 3520, "value": 0.32427096366882324}, {"wallTime": 1733071018.8948, "step": 3530, "value": 0.24055424332618713}, {"wallTime": 1733071027.1958735, "step": 3540, "value": 0.1777981072664261}, {"wallTime": 1733071035.3192792, "step": 3550, "value": 0.2634999752044678}, {"wallTime": 1733071043.7444725, "step": 3560, "value": 0.22246053814888}, {"wallTime": 1733071051.8709166, "step": 3570, "value": 0.28662654757499695}, {"wallTime": 1733071060.4948747, "step": 3580, "value": 0.24774500727653503}, {"wallTime": 1733071068.8782153, "step": 3590, "value": 0.25651782751083374}, {"wallTime": 1733071077.7117443, "step": 3600, "value": 0.2784487307071686}, {"wallTime": 1733071086.2111895, "step": 3610, "value": 0.2167762815952301}, {"wallTime": 1733071101.6574886, "step": 3620, "value": 0.23883460462093353}, {"wallTime": 1733071109.619414, "step": 3630, "value": 0.28317803144454956}, {"wallTime": 1733071118.128085, "step": 3640, "value": 0.2550809383392334}, {"wallTime": 1733071126.99197, "step": 3650, "value": 0.21249347925186157}, {"wallTime": 1733071135.8262885, "step": 3660, "value": 0.31356218457221985}, {"wallTime": 1733071144.247165, "step": 3670, "value": 0.22205278277397156}, {"wallTime": 1733071152.963309, "step": 3680, "value": 0.24137236177921295}, {"wallTime": 1733071160.6022875, "step": 3690, "value": 0.25735539197921753}, {"wallTime": 1733071173.7491574, "step": 3700, "value": 0.2613956332206726}, {"wallTime": 1733071182.8821132, "step": 3710, "value": 0.26627588272094727}, {"wallTime": 1733071191.2089434, "step": 3720, "value": 0.31298941373825073}, {"wallTime": 1733071200.3323278, "step": 3730, "value": 0.5735991597175598}, {"wallTime": 1733071208.3645582, "step": 3740, "value": 0.2802477777004242}, {"wallTime": 1733071216.570788, "step": 3750, "value": 0.20120996236801147}, {"wallTime": 1733071224.6607866, "step": 3760, "value": 0.17039068043231964}, {"wallTime": 1733071232.8595543, "step": 3770, "value": 0.16383758187294006}, {"wallTime": 1733071248.5322797, "step": 3780, "value": 0.3572006821632385}, {"wallTime": 1733071257.3906813, "step": 3790, "value": 0.4248903691768646}, {"wallTime": 1733071265.566245, "step": 3800, "value": 0.1934383511543274}, {"wallTime": 1733071274.177623, "step": 3810, "value": 0.30945295095443726}, {"wallTime": 1733071283.0168703, "step": 3820, "value": 0.22914840281009674}, {"wallTime": 1733071291.7287164, "step": 3830, "value": 0.17730706930160522}, {"wallTime": 1733071299.8918192, "step": 3840, "value": 0.20848870277404785}, {"wallTime": 1733071308.4783678, "step": 3850, "value": 0.2848550081253052}, {"wallTime": 1733071316.9504526, "step": 3860, "value": 0.305223673582077}, {"wallTime": 1733071330.2139995, "step": 3870, "value": 0.22342872619628906}, {"wallTime": 1733071338.9879546, "step": 3880, "value": 0.240635484457016}, {"wallTime": 1733071347.7359133, "step": 3890, "value": 0.21511556208133698}, {"wallTime": 1733071357.0336044, "step": 3900, "value": 0.21642905473709106}, {"wallTime": 1733071365.2245579, "step": 3910, "value": 0.2957356870174408}, {"wallTime": 1733071374.1338618, "step": 3920, "value": 0.45952922105789185}, {"wallTime": 1733071382.8130631, "step": 3930, "value": 0.2980629801750183}, {"wallTime": 1733071391.5676644, "step": 3940, "value": 0.2563706338405609}, {"wallTime": 1733071404.4664817, "step": 3950, "value": 0.23289543390274048}, {"wallTime": 1733071412.338123, "step": 3960, "value": 0.2551591694355011}, {"wallTime": 1733071421.1568227, "step": 3970, "value": 0.2737748920917511}, {"wallTime": 1733071430.1198115, "step": 3980, "value": 0.19499319791793823}, {"wallTime": 1733071438.41328, "step": 3990, "value": 0.3724835515022278}, {"wallTime": 1733071447.728118, "step": 4000, "value": 0.35344547033309937}, {"wallTime": 1733071456.1958873, "step": 4010, "value": 0.291775107383728}, {"wallTime": 1733071464.7487543, "step": 4020, "value": 0.2493944764137268}, {"wallTime": 1733071473.3963785, "step": 4030, "value": 0.32596927881240845}, {"wallTime": 1733071490.2857141, "step": 4040, "value": 0.24705979228019714}, {"wallTime": 1733071498.7110267, "step": 4050, "value": 0.23639839887619019}, {"wallTime": 1733071507.0968235, "step": 4060, "value": 0.19201704859733582}, {"wallTime": 1733071515.0671763, "step": 4070, "value": 0.2857978343963623}, {"wallTime": 1733071523.880598, "step": 4080, "value": 0.27199414372444153}, {"wallTime": 1733071532.2847552, "step": 4090, "value": 0.1966116577386856}, {"wallTime": 1733071540.9171438, "step": 4100, "value": 0.21607476472854614}, {"wallTime": 1733071549.175693, "step": 4110, "value": 0.18371713161468506}, {"wallTime": 1733071565.8355591, "step": 4120, "value": 0.22625333070755005}, {"wallTime": 1733071573.6312876, "step": 4130, "value": 0.16083499789237976}, {"wallTime": 1733071582.095892, "step": 4140, "value": 0.419159471988678}, {"wallTime": 1733071590.0223703, "step": 4150, "value": 0.1616106927394867}, {"wallTime": 1733071599.2407436, "step": 4160, "value": 0.709656834602356}, {"wallTime": 1733071608.0714686, "step": 4170, "value": 0.25394928455352783}, {"wallTime": 1733071616.1836267, "step": 4180, "value": 0.3131086230278015}, {"wallTime": 1733071626.082731, "step": 4190, "value": 0.15944050252437592}, {"wallTime": 1733071641.0078616, "step": 4200, "value": 0.2451379895210266}, {"wallTime": 1733071649.0406694, "step": 4210, "value": 0.20220759510993958}, {"wallTime": 1733071658.5314252, "step": 4220, "value": 0.28029319643974304}, {"wallTime": 1733071667.9661205, "step": 4230, "value": 0.3236803412437439}, {"wallTime": 1733071676.1088107, "step": 4240, "value": 0.2085856795310974}, {"wallTime": 1733071684.3785965, "step": 4250, "value": 0.31402990221977234}, {"wallTime": 1733071693.1097035, "step": 4260, "value": 0.288939893245697}, {"wallTime": 1733071702.183973, "step": 4270, "value": 0.21209704875946045}, {"wallTime": 1733071710.630356, "step": 4280, "value": 0.3222774267196655}, {"wallTime": 1733071726.6768053, "step": 4290, "value": 0.2644832730293274}, {"wallTime": 1733071735.2156684, "step": 4300, "value": 0.2665390372276306}, {"wallTime": 1733071742.9572024, "step": 4310, "value": 0.26263007521629333}, {"wallTime": 1733071751.585835, "step": 4320, "value": 0.42445674538612366}, {"wallTime": 1733071760.0347967, "step": 4330, "value": 0.27615591883659363}, {"wallTime": 1733071768.4314291, "step": 4340, "value": 0.1811419427394867}, {"wallTime": 1733071777.4022498, "step": 4350, "value": 0.2973894476890564}, {"wallTime": 1733071785.5474446, "step": 4360, "value": 0.27315112948417664}, {"wallTime": 1733071800.8848677, "step": 4370, "value": 0.358489990234375}, {"wallTime": 1733071809.2659776, "step": 4380, "value": 0.24247843027114868}, {"wallTime": 1733071817.3465004, "step": 4390, "value": 0.20580092072486877}, {"wallTime": 1733071826.4305248, "step": 4400, "value": 0.30540746450424194}, {"wallTime": 1733071834.887735, "step": 4410, "value": 0.29397955536842346}, {"wallTime": 1733071843.4469914, "step": 4420, "value": 0.25798970460891724}, {"wallTime": 1733071851.596158, "step": 4430, "value": 0.24573394656181335}, {"wallTime": 1733071859.9242578, "step": 4440, "value": 0.2581121325492859}, {"wallTime": 1733071868.6733637, "step": 4450, "value": 0.2452678233385086}, {"wallTime": 1733071881.336296, "step": 4460, "value": 0.22653350234031677}, {"wallTime": 1733071889.6366875, "step": 4470, "value": 0.23875437676906586}, {"wallTime": 1733071898.4209495, "step": 4480, "value": 0.268133282661438}, {"wallTime": 1733071907.3361309, "step": 4490, "value": 0.2294231802225113}, {"wallTime": 1733071916.2783017, "step": 4500, "value": 0.3294388949871063}, {"wallTime": 1733071925.3488212, "step": 4510, "value": 0.3630191385746002}, {"wallTime": 1733071933.3294241, "step": 4520, "value": 0.15199193358421326}, {"wallTime": 1733071941.482777, "step": 4530, "value": 0.16434094309806824}, {"wallTime": 1733071954.1690352, "step": 4540, "value": 0.2340191900730133}, {"wallTime": 1733071962.3958452, "step": 4550, "value": 0.18862678110599518}, {"wallTime": 1733071970.5134099, "step": 4560, "value": 0.2650144696235657}, {"wallTime": 1733071978.8699644, "step": 4570, "value": 0.3709266185760498}, {"wallTime": 1733071987.7105308, "step": 4580, "value": 0.29689455032348633}, {"wallTime": 1733071996.4445622, "step": 4590, "value": 0.3876693546772003}, {"wallTime": 1733072004.4759655, "step": 4600, "value": 0.19301578402519226}, {"wallTime": 1733072012.7446988, "step": 4610, "value": 0.1813228726387024}, {"wallTime": 1733072025.4001021, "step": 4620, "value": 0.19947472214698792}, {"wallTime": 1733072034.1181548, "step": 4630, "value": 0.18961092829704285}, {"wallTime": 1733072043.0373642, "step": 4640, "value": 0.3132864832878113}, {"wallTime": 1733072051.784985, "step": 4650, "value": 0.2519547939300537}, {"wallTime": 1733072060.10795, "step": 4660, "value": 0.24502478539943695}, {"wallTime": 1733072068.6026983, "step": 4670, "value": 0.2732715904712677}, {"wallTime": 1733072076.8360798, "step": 4680, "value": 0.2690519094467163}, {"wallTime": 1733072085.375531, "step": 4690, "value": 0.28621989488601685}, {"wallTime": 1733072093.7479913, "step": 4700, "value": 0.21356233954429626}, {"wallTime": 1733072106.989118, "step": 4710, "value": 0.2585289478302002}, {"wallTime": 1733072115.6645691, "step": 4720, "value": 0.4157123267650604}, {"wallTime": 1733072123.9499984, "step": 4730, "value": 0.3246338367462158}, {"wallTime": 1733072132.280059, "step": 4740, "value": 0.22837287187576294}, {"wallTime": 1733072140.419951, "step": 4750, "value": 0.19387537240982056}, {"wallTime": 1733072149.0865386, "step": 4760, "value": 0.21395550668239594}, {"wallTime": 1733072157.4111485, "step": 4770, "value": 0.23979617655277252}, {"wallTime": 1733072165.488721, "step": 4780, "value": 0.27153900265693665}, {"wallTime": 1733072179.6480389, "step": 4790, "value": 0.2586950957775116}, {"wallTime": 1733072188.3290718, "step": 4800, "value": 0.1941979080438614}, {"wallTime": 1733072196.846338, "step": 4810, "value": 0.25993990898132324}, {"wallTime": 1733072204.5616145, "step": 4820, "value": 0.20360791683197021}, {"wallTime": 1733072213.0990224, "step": 4830, "value": 0.36104756593704224}, {"wallTime": 1733072221.6664052, "step": 4840, "value": 0.2645062506198883}, {"wallTime": 1733072229.8933477, "step": 4850, "value": 0.20388968288898468}, {"wallTime": 1733072238.055578, "step": 4860, "value": 0.2428610473871231}, {"wallTime": 1733072246.3429677, "step": 4870, "value": 0.20080767571926117}, {"wallTime": 1733072261.2667463, "step": 4880, "value": 0.2297065556049347}, {"wallTime": 1733072269.8519292, "step": 4890, "value": 0.22165077924728394}, {"wallTime": 1733072278.8797462, "step": 4900, "value": 0.2854766845703125}, {"wallTime": 1733072287.533961, "step": 4910, "value": 0.20162971317768097}, {"wallTime": 1733072295.9466424, "step": 4920, "value": 0.1779416799545288}, {"wallTime": 1733072304.3548815, "step": 4930, "value": 0.2656165361404419}, {"wallTime": 1733072313.5093653, "step": 4940, "value": 0.2640867233276367}, {"wallTime": 1733072321.3248677, "step": 4950, "value": 0.18858569860458374}, {"wallTime": 1733072337.0244768, "step": 4960, "value": 0.16491100192070007}, {"wallTime": 1733072345.5311558, "step": 4970, "value": 0.17772844433784485}, {"wallTime": 1733072353.429356, "step": 4980, "value": 0.2257269322872162}, {"wallTime": 1733072362.412843, "step": 4990, "value": 0.24115517735481262}, {"wallTime": 1733072371.74554, "step": 5000, "value": 0.2294807881116867}, {"wallTime": 1733072380.5293107, "step": 5010, "value": 0.2900298237800598}, {"wallTime": 1733072389.026072, "step": 5020, "value": 0.3043484687805176}, {"wallTime": 1733072397.7851987, "step": 5030, "value": 0.1962883174419403}, {"wallTime": 1733072411.297942, "step": 5040, "value": 0.22015869617462158}, {"wallTime": 1733072419.4737034, "step": 5050, "value": 0.20695382356643677}, {"wallTime": 1733072428.3718824, "step": 5060, "value": 0.28775808215141296}, {"wallTime": 1733072437.1163816, "step": 5070, "value": 0.26663902401924133}, {"wallTime": 1733072446.1749039, "step": 5080, "value": 0.29021960496902466}, {"wallTime": 1733072454.428219, "step": 5090, "value": 0.19847360253334045}, {"wallTime": 1733072462.4101982, "step": 5100, "value": 0.24947968125343323}, {"wallTime": 1733072471.1496425, "step": 5110, "value": 0.22049769759178162}, {"wallTime": 1733072478.9462464, "step": 5120, "value": 0.30170971155166626}, {"wallTime": 1733072491.3213077, "step": 5130, "value": 0.3260016143321991}, {"wallTime": 1733072499.258399, "step": 5140, "value": 0.1683298945426941}, {"wallTime": 1733072507.1117558, "step": 5150, "value": 0.2189948558807373}, {"wallTime": 1733072515.3168812, "step": 5160, "value": 0.617320716381073}, {"wallTime": 1733072523.4999344, "step": 5170, "value": 0.27422910928726196}, {"wallTime": 1733072531.0869133, "step": 5180, "value": 0.17380164563655853}, {"wallTime": 1733072540.0217116, "step": 5190, "value": 0.23838074505329132}, {"wallTime": 1733072548.6519551, "step": 5200, "value": 0.2646218538284302}, {"wallTime": 1733072561.4150748, "step": 5210, "value": 0.2101091891527176}, {"wallTime": 1733072569.8961213, "step": 5220, "value": 0.2899433970451355}, {"wallTime": 1733072578.6787546, "step": 5230, "value": 0.26740553975105286}, {"wallTime": 1733072586.9420376, "step": 5240, "value": 0.2729279398918152}, {"wallTime": 1733072595.0340035, "step": 5250, "value": 0.33576086163520813}, {"wallTime": 1733072603.173087, "step": 5260, "value": 0.24691811203956604}, {"wallTime": 1733072611.0797148, "step": 5270, "value": 0.2773962616920471}, {"wallTime": 1733072619.9548419, "step": 5280, "value": 0.24370288848876953}, {"wallTime": 1733072628.634258, "step": 5290, "value": 0.2396601289510727}, {"wallTime": 1733072641.3751764, "step": 5300, "value": 0.22582150995731354}, {"wallTime": 1733072649.8578022, "step": 5310, "value": 0.16651952266693115}, {"wallTime": 1733072657.9709666, "step": 5320, "value": 0.18312527239322662}, {"wallTime": 1733072667.0291722, "step": 5330, "value": 0.29590001702308655}, {"wallTime": 1733072675.9426918, "step": 5340, "value": 0.24040478467941284}, {"wallTime": 1733072684.2380908, "step": 5350, "value": 0.37127840518951416}, {"wallTime": 1733072691.8578207, "step": 5360, "value": 0.24912984669208527}, {"wallTime": 1733072700.1476662, "step": 5370, "value": 0.1865595430135727}, {"wallTime": 1733072713.1827118, "step": 5380, "value": 0.18900051712989807}, {"wallTime": 1733072721.0243754, "step": 5390, "value": 0.16585253179073334}, {"wallTime": 1733072729.876606, "step": 5400, "value": 0.22591546177864075}, {"wallTime": 1733072738.3693337, "step": 5410, "value": 0.1792842298746109}, {"wallTime": 1733072746.3823109, "step": 5420, "value": 0.25005200505256653}, {"wallTime": 1733072754.6173294, "step": 5430, "value": 0.314105749130249}, {"wallTime": 1733072762.5467281, "step": 5440, "value": 0.18776877224445343}, {"wallTime": 1733072771.3602908, "step": 5450, "value": 0.24387571215629578}, {"wallTime": 1733072787.1513743, "step": 5460, "value": 0.17941327393054962}, {"wallTime": 1733072795.8023064, "step": 5470, "value": 0.2507314682006836}, {"wallTime": 1733072804.241671, "step": 5480, "value": 0.16766129434108734}, {"wallTime": 1733072812.3727481, "step": 5490, "value": 0.2645666003227234}, {"wallTime": 1733072821.1588774, "step": 5500, "value": 0.275199830532074}, {"wallTime": 1733072830.0222769, "step": 5510, "value": 0.2948876917362213}, {"wallTime": 1733072838.6947682, "step": 5520, "value": 0.2079377919435501}, {"wallTime": 1733072846.904606, "step": 5530, "value": 0.16997650265693665}, {"wallTime": 1733072855.2460196, "step": 5540, "value": 0.1977342665195465}, {"wallTime": 1733072870.644076, "step": 5550, "value": 0.2835018038749695}, {"wallTime": 1733072878.7290084, "step": 5560, "value": 0.2754160761833191}, {"wallTime": 1733072886.610327, "step": 5570, "value": 0.23342551290988922}, {"wallTime": 1733072895.0204656, "step": 5580, "value": 0.8556652069091797}, {"wallTime": 1733072903.4023747, "step": 5590, "value": 0.20875243842601776}, {"wallTime": 1733072911.2094152, "step": 5600, "value": 0.30865055322647095}, {"wallTime": 1733072919.8393636, "step": 5610, "value": 0.2594970464706421}, {"wallTime": 1733072928.732435, "step": 5620, "value": 0.3691089153289795}, {"wallTime": 1733072941.703115, "step": 5630, "value": 0.2036145031452179}, {"wallTime": 1733072949.9795253, "step": 5640, "value": 0.23405680060386658}, {"wallTime": 1733072958.719149, "step": 5650, "value": 0.3252425491809845}, {"wallTime": 1733072966.813949, "step": 5660, "value": 0.20296716690063477}, {"wallTime": 1733072974.9613547, "step": 5670, "value": 0.18553854525089264}, {"wallTime": 1733072983.5613818, "step": 5680, "value": 0.23079194128513336}, {"wallTime": 1733072992.2277894, "step": 5690, "value": 0.2510519027709961}, {"wallTime": 1733073000.8165562, "step": 5700, "value": 0.1983039379119873}, {"wallTime": 1733073009.782703, "step": 5710, "value": 0.24025188386440277}, {"wallTime": 1733073022.8676147, "step": 5720, "value": 0.36591458320617676}, {"wallTime": 1733073031.5337446, "step": 5730, "value": 0.28939735889434814}, {"wallTime": 1733073039.5701787, "step": 5740, "value": 0.24437548220157623}, {"wallTime": 1733073047.842356, "step": 5750, "value": 0.23800460994243622}, {"wallTime": 1733073056.1559973, "step": 5760, "value": 0.18418051302433014}, {"wallTime": 1733073064.954561, "step": 5770, "value": 0.3398672342300415}, {"wallTime": 1733073073.8371332, "step": 5780, "value": 0.22247737646102905}, {"wallTime": 1733073082.7245455, "step": 5790, "value": 0.31763947010040283}, {"wallTime": 1733073095.10243, "step": 5800, "value": 0.21818800270557404}, {"wallTime": 1733073103.3152452, "step": 5810, "value": 0.24597126245498657}, {"wallTime": 1733073111.9701443, "step": 5820, "value": 0.16270124912261963}, {"wallTime": 1733073120.3553977, "step": 5830, "value": 0.30561012029647827}, {"wallTime": 1733073128.2087243, "step": 5840, "value": 0.20114171504974365}, {"wallTime": 1733073136.7152126, "step": 5850, "value": 0.16804346442222595}, {"wallTime": 1733073144.9273458, "step": 5860, "value": 0.2511885166168213}, {"wallTime": 1733073153.0405998, "step": 5870, "value": 0.1566406488418579}, {"wallTime": 1733073166.0025537, "step": 5880, "value": 0.1909734159708023}, {"wallTime": 1733073174.6585307, "step": 5890, "value": 0.1550704538822174}, {"wallTime": 1733073182.5078547, "step": 5900, "value": 0.22714881598949432}, {"wallTime": 1733073191.5591078, "step": 5910, "value": 0.1861327737569809}, {"wallTime": 1733073199.4107356, "step": 5920, "value": 0.10401900112628937}, {"wallTime": 1733073207.4651158, "step": 5930, "value": 0.23345667123794556}, {"wallTime": 1733073215.602439, "step": 5940, "value": 0.20822183787822723}, {"wallTime": 1733073224.3577428, "step": 5950, "value": 0.20190510153770447}, {"wallTime": 1733073232.876574, "step": 5960, "value": 0.28193873167037964}, {"wallTime": 1733073245.3733864, "step": 5970, "value": 0.19907903671264648}, {"wallTime": 1733073253.1792028, "step": 5980, "value": 0.24596691131591797}, {"wallTime": 1733073261.7992277, "step": 5990, "value": 0.2209886908531189}, {"wallTime": 1733073270.059516, "step": 6000, "value": 0.21641522645950317}, {"wallTime": 1733073278.895394, "step": 6010, "value": 0.3628058433532715}, {"wallTime": 1733073287.681894, "step": 6020, "value": 0.2502841353416443}, {"wallTime": 1733073297.2742286, "step": 6030, "value": 0.3895273506641388}, {"wallTime": 1733073305.9180722, "step": 6040, "value": 0.2973664104938507}, {"wallTime": 1733073322.354469, "step": 6050, "value": 0.21588020026683807}, {"wallTime": 1733073331.9770868, "step": 6060, "value": 0.16003930568695068}, {"wallTime": 1733073340.5219543, "step": 6070, "value": 0.18832778930664062}, {"wallTime": 1733073349.601808, "step": 6080, "value": 0.2998865842819214}, {"wallTime": 1733073359.0710201, "step": 6090, "value": 0.18697425723075867}, {"wallTime": 1733073368.402743, "step": 6100, "value": 0.23024840652942657}, {"wallTime": 1733073377.6748078, "step": 6110, "value": 0.2433697134256363}, {"wallTime": 1733073386.400173, "step": 6120, "value": 0.16373120248317719}, {"wallTime": 1733073395.4513052, "step": 6130, "value": 0.22830712795257568}, {"wallTime": 1733073408.1510754, "step": 6140, "value": 0.15332593023777008}, {"wallTime": 1733073417.3234944, "step": 6150, "value": 0.189646914601326}, {"wallTime": 1733073426.2562363, "step": 6160, "value": 0.1932472139596939}, {"wallTime": 1733073434.8090923, "step": 6170, "value": 0.1681264042854309}, {"wallTime": 1733073444.5124562, "step": 6180, "value": 0.20726829767227173}, {"wallTime": 1733073453.1159477, "step": 6190, "value": 0.24209833145141602}, {"wallTime": 1733073462.5653493, "step": 6200, "value": 0.16188836097717285}, {"wallTime": 1733073472.0241978, "step": 6210, "value": 0.2335987687110901}, {"wallTime": 1733073484.4480262, "step": 6220, "value": 0.19948747754096985}, {"wallTime": 1733073493.6596842, "step": 6230, "value": 0.1932862251996994}, {"wallTime": 1733073502.4409487, "step": 6240, "value": 0.21354474127292633}, {"wallTime": 1733073511.2558246, "step": 6250, "value": 0.23674993216991425}, {"wallTime": 1733073520.4846938, "step": 6260, "value": 0.1870160549879074}, {"wallTime": 1733073529.7811453, "step": 6270, "value": 0.27992725372314453}, {"wallTime": 1733073539.638871, "step": 6280, "value": 0.23280343413352966}, {"wallTime": 1733073548.910688, "step": 6290, "value": 0.20254316926002502}, {"wallTime": 1733073560.6194086, "step": 6300, "value": 0.2655571401119232}, {"wallTime": 1733073570.068703, "step": 6310, "value": 0.1886235773563385}, {"wallTime": 1733073579.48082, "step": 6320, "value": 0.24662671983242035}, {"wallTime": 1733073587.666951, "step": 6330, "value": 0.19239509105682373}, {"wallTime": 1733073597.217632, "step": 6340, "value": 0.20410113036632538}, {"wallTime": 1733073606.237827, "step": 6350, "value": 0.19615136086940765}, {"wallTime": 1733073615.0772696, "step": 6360, "value": 0.2936471700668335}, {"wallTime": 1733073624.8341975, "step": 6370, "value": 0.2517198622226715}, {"wallTime": 1733073634.672233, "step": 6380, "value": 0.23547931015491486}, {"wallTime": 1733073646.5279055, "step": 6390, "value": 0.20133662223815918}, {"wallTime": 1733073655.7451425, "step": 6400, "value": 0.23645278811454773}, {"wallTime": 1733073665.606836, "step": 6410, "value": 0.22561794519424438}, {"wallTime": 1733073674.6424484, "step": 6420, "value": 0.28351494669914246}, {"wallTime": 1733073683.6700277, "step": 6430, "value": 0.16882845759391785}, {"wallTime": 1733073692.8764706, "step": 6440, "value": 0.25587326288223267}, {"wallTime": 1733073702.5188339, "step": 6450, "value": 0.17398539185523987}, {"wallTime": 1733073712.6270373, "step": 6460, "value": 0.25288230180740356}, {"wallTime": 1733073724.047001, "step": 6470, "value": 0.31833797693252563}, {"wallTime": 1733073732.8281205, "step": 6480, "value": 0.23421280086040497}, {"wallTime": 1733073741.9569714, "step": 6490, "value": 0.21020817756652832}, {"wallTime": 1733073750.7173789, "step": 6500, "value": 0.23746705055236816}, {"wallTime": 1733073760.4878175, "step": 6510, "value": 0.15320150554180145}, {"wallTime": 1733073769.863036, "step": 6520, "value": 0.17372667789459229}, {"wallTime": 1733073779.1267645, "step": 6530, "value": 0.1988549381494522}, {"wallTime": 1733073789.477401, "step": 6540, "value": 0.3093198537826538}, {"wallTime": 1733073798.103051, "step": 6550, "value": 0.3344819247722626}, {"wallTime": 1733073810.5525713, "step": 6560, "value": 0.22693492472171783}, {"wallTime": 1733073820.0360863, "step": 6570, "value": 0.2031938135623932}, {"wallTime": 1733073828.238309, "step": 6580, "value": 0.26344242691993713}, {"wallTime": 1733073836.7979138, "step": 6590, "value": 0.17440570890903473}, {"wallTime": 1733073845.987237, "step": 6600, "value": 0.21719597280025482}, {"wallTime": 1733073855.2518837, "step": 6610, "value": 0.2046840786933899}, {"wallTime": 1733073864.6934648, "step": 6620, "value": 0.19042371213436127}, {"wallTime": 1733073873.8343873, "step": 6630, "value": 0.21237434446811676}, {"wallTime": 1733073887.524395, "step": 6640, "value": 0.2558843791484833}, {"wallTime": 1733073897.3339398, "step": 6650, "value": 0.22637397050857544}, {"wallTime": 1733073906.8765795, "step": 6660, "value": 0.22274038195610046}, {"wallTime": 1733073916.3500743, "step": 6670, "value": 0.25570398569107056}, {"wallTime": 1733073925.6186798, "step": 6680, "value": 0.18809927999973297}, {"wallTime": 1733073934.9166675, "step": 6690, "value": 0.17643392086029053}, {"wallTime": 1733073943.7422192, "step": 6700, "value": 0.1650151014328003}, {"wallTime": 1733073952.4770038, "step": 6710, "value": 0.2312021106481552}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15054" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/chart_worker.js?_file_hash=2c1e71c5": { + "data": "(()=>{var H0=Object.defineProperty,V0=Object.defineProperties;var G0=Object.getOwnPropertyDescriptors;var af=Object.getOwnPropertySymbols;var W0=Object.prototype.hasOwnProperty,q0=Object.prototype.propertyIsEnumerable;var cf=Math.pow,lf=(n,t,e)=>t in n?H0(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,No=(n,t)=>{for(var e in t||(t={}))W0.call(t,e)&&lf(n,e,t[e]);if(af)for(var e of af(t))q0.call(t,e)&&lf(n,e,t[e]);return n},uf=(n,t)=>V0(n,G0(t));var hf=(n,t,e)=>new Promise((i,r)=>{var s=l=>{try{a(e.next(l))}catch(c){r(c)}},o=l=>{try{a(e.throw(l))}catch(c){r(c)}},a=l=>l.done?i(l.value):Promise.resolve(l.value).then(s,o);a((e=e.apply(n,t)).next())});var on;(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"})(on||(on={}));function an(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function is(n){return n.length===1&&(n=X0(n)),{left:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)<0?i=s+1:r=s}return i},right:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)>0?r=s:i=s+1}return i}}}function X0(n){return function(t,e){return an(n(t),e)}}var ff=is(an),df=ff.right,Y0=ff.left,Bn=df;var pf=Array.prototype,J0=pf.slice,$0=pf.map;var kl=Math.sqrt(50),Hl=Math.sqrt(10),Vl=Math.sqrt(2);function rs(n,t,e){var i,r=-1,s,o,a;if(t=+t,n=+n,e=+e,n===t&&e>0)return[n];if((i=t<n)&&(s=n,n=t,t=s),(a=Ji(n,t,e))===0||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),o=new Array(s=Math.ceil(t-n+1));++r<s;)o[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),o=new Array(s=Math.ceil(n-t+1));++r<s;)o[r]=(n-r)/a;return i&&o.reverse(),o}function Ji(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),s=i/Math.pow(10,r);return r>=0?(s>=kl?10:s>=Hl?5:s>=Vl?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(s>=kl?10:s>=Hl?5:s>=Vl?2:1)}function _n(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),s=i/r;return s>=kl?r*=10:s>=Hl?r*=5:s>=Vl&&(r*=2),t<n?-r:r}var ex=Array.prototype.slice;var nx={value:function(){}};function yf(){for(var n=0,t=arguments.length,e={},i;n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new zo(e)}function zo(n){this._=n}function ix(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}zo.prototype=yf.prototype={constructor:zo,on:function(n,t){var e=this._,i=ix(n+"",e),r,s=-1,o=i.length;if(arguments.length<2){for(;++s<o;)if((r=(n=i[s]).type)&&(r=rx(e[r],n.name)))return r;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++s<o;)if(r=(n=i[s]).type)e[r]=xf(e[r],n.name,t);else if(t==null)for(r in e)e[r]=xf(e[r],n.name,null);return this},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new zo(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var e=new Array(r),i=0,r,s;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(s=this._[n],i=0,r=s.length;i<r;++i)s[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,s=i.length;r<s;++r)i[r].value.apply(t,e)}};function rx(n,t){for(var e=0,i=n.length,r;e<i;++e)if((r=n[e]).name===t)return r.value}function xf(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=nx,n=n.slice(0,i).concat(n.slice(i+1));break}return e!=null&&n.push({name:t,value:e}),n}var Wl=yf;var Uo="http://www.w3.org/1999/xhtml",ql={svg:"http://www.w3.org/2000/svg",xhtml:Uo,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function wn(n){var t=n+="",e=t.indexOf(":");return e>=0&&(t=n.slice(0,e))!=="xmlns"&&(n=n.slice(e+1)),ql.hasOwnProperty(t)?{space:ql[t],local:n}:n}function sx(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===Uo&&t.documentElement.namespaceURI===Uo?t.createElement(n):t.createElementNS(e,n)}}function ox(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function Bo(n){var t=wn(n);return(t.local?ox:sx)(t)}function ax(){}function di(n){return n==null?ax:function(){return this.querySelector(n)}}function vf(n){typeof n!="function"&&(n=di(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=new Array(o),l,c,u=0;u<o;++u)(l=s[u])&&(c=n.call(l,l.__data__,u,s))&&("__data__"in l&&(c.__data__=l.__data__),a[u]=c);return new ce(i,this._parents)}function lx(){return[]}function os(n){return n==null?lx:function(){return this.querySelectorAll(n)}}function _f(n){typeof n!="function"&&(n=os(n));for(var t=this._groups,e=t.length,i=[],r=[],s=0;s<e;++s)for(var o=t[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&(i.push(n.call(l,l.__data__,c,o)),r.push(l));return new ce(i,r)}function as(n){return function(){return this.matches(n)}}function wf(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new ce(i,this._parents)}function Oo(n){return new Array(n.length)}function Mf(){return new ce(this._enter||this._groups.map(Oo),this._parents)}function ls(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}ls.prototype={constructor:ls,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function bf(n){return function(){return n}}var Sf="$";function cx(n,t,e,i,r,s){for(var o=0,a,l=t.length,c=s.length;o<c;++o)(a=t[o])?(a.__data__=s[o],i[o]=a):e[o]=new ls(n,s[o]);for(;o<l;++o)(a=t[o])&&(r[o]=a)}function ux(n,t,e,i,r,s,o){var a,l,c={},u=t.length,h=s.length,f=new Array(u),d;for(a=0;a<u;++a)(l=t[a])&&(f[a]=d=Sf+o.call(l,l.__data__,a,t),d in c?r[a]=l:c[d]=l);for(a=0;a<h;++a)d=Sf+o.call(n,s[a],a,s),(l=c[d])?(i[a]=l,l.__data__=s[a],c[d]=null):e[a]=new ls(n,s[a]);for(a=0;a<u;++a)(l=t[a])&&c[f[a]]===l&&(r[a]=l)}function Ef(n,t){if(!n)return d=new Array(this.size()),c=-1,this.each(function(L){d[++c]=L}),d;var e=t?ux:cx,i=this._parents,r=this._groups;typeof n!="function"&&(n=bf(n));for(var s=r.length,o=new Array(s),a=new Array(s),l=new Array(s),c=0;c<s;++c){var u=i[c],h=r[c],f=h.length,d=n.call(u,u&&u.__data__,c,i),g=d.length,x=a[c]=new Array(g),v=o[c]=new Array(g),m=l[c]=new Array(f);e(u,h,x,v,m,d,t);for(var p=0,b=0,_,S;p<g;++p)if(_=x[p]){for(p>=b&&(b=p+1);!(S=v[b])&&++b<g;);_._next=S||null}}return o=new ce(o,i),o._enter=a,o._exit=l,o}function Tf(){return new ce(this._exit||this._groups.map(Oo),this._parents)}function Af(n,t,e){var i=this.enter(),r=this,s=this.exit();return i=typeof n=="function"?n(i):i.append(n+""),t!=null&&(r=t(r)),e==null?s.remove():e(s),i&&r?i.merge(r).order():r}function Cf(n){for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new ce(o,this._parents)}function Rf(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var i=n[t],r=i.length-1,s=i[r],o;--r>=0;)(o=i[r])&&(s&&o.compareDocumentPosition(s)^4&&s.parentNode.insertBefore(o,s),s=o);return this}function Lf(n){n||(n=hx);function t(h,f){return h&&f?n(h.__data__,f.__data__):!h-!f}for(var e=this._groups,i=e.length,r=new Array(i),s=0;s<i;++s){for(var o=e[s],a=o.length,l=r[s]=new Array(a),c,u=0;u<a;++u)(c=o[u])&&(l[u]=c);l.sort(t)}return new ce(r,this._parents).order()}function hx(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Pf(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function Df(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n}function If(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,s=i.length;r<s;++r){var o=i[r];if(o)return o}return null}function Nf(){var n=0;return this.each(function(){++n}),n}function Ff(){return!this.node()}function zf(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var r=t[e],s=0,o=r.length,a;s<o;++s)(a=r[s])&&n.call(a,a.__data__,s,r);return this}function fx(n){return function(){this.removeAttribute(n)}}function dx(n){return function(){this.removeAttributeNS(n.space,n.local)}}function px(n,t){return function(){this.setAttribute(n,t)}}function mx(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function gx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttribute(n):this.setAttribute(n,e)}}function xx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function Uf(n,t){var e=wn(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((t==null?e.local?dx:fx:typeof t=="function"?e.local?xx:gx:e.local?mx:px)(e,t))}function ko(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function yx(n){return function(){this.style.removeProperty(n)}}function vx(n,t,e){return function(){this.style.setProperty(n,t,e)}}function _x(n,t,e){return function(){var i=t.apply(this,arguments);i==null?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Bf(n,t,e){return arguments.length>1?this.each((t==null?yx:typeof t=="function"?_x:vx)(n,t,e==null?"":e)):On(this.node(),n)}function On(n,t){return n.style.getPropertyValue(t)||ko(n).getComputedStyle(n,null).getPropertyValue(t)}function wx(n){return function(){delete this[n]}}function Mx(n,t){return function(){this[n]=t}}function bx(n,t){return function(){var e=t.apply(this,arguments);e==null?delete this[n]:this[n]=e}}function Of(n,t){return arguments.length>1?this.each((t==null?wx:typeof t=="function"?bx:Mx)(n,t)):this.node()[n]}function kf(n){return n.trim().split(/^|\s+/)}function Xl(n){return n.classList||new Hf(n)}function Hf(n){this._node=n,this._names=kf(n.getAttribute("class")||"")}Hf.prototype={add:function(n){var t=this._names.indexOf(n);t<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Vf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function Gf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function Sx(n){return function(){Vf(this,n)}}function Ex(n){return function(){Gf(this,n)}}function Tx(n,t){return function(){(t.apply(this,arguments)?Vf:Gf)(this,n)}}function Wf(n,t){var e=kf(n+"");if(arguments.length<2){for(var i=Xl(this.node()),r=-1,s=e.length;++r<s;)if(!i.contains(e[r]))return!1;return!0}return this.each((typeof t=="function"?Tx:t?Sx:Ex)(e,t))}function Ax(){this.textContent=""}function Cx(n){return function(){this.textContent=n}}function Rx(n){return function(){var t=n.apply(this,arguments);this.textContent=t==null?"":t}}function qf(n){return arguments.length?this.each(n==null?Ax:(typeof n=="function"?Rx:Cx)(n)):this.node().textContent}function Lx(){this.innerHTML=""}function Px(n){return function(){this.innerHTML=n}}function Dx(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t==null?"":t}}function Xf(n){return arguments.length?this.each(n==null?Lx:(typeof n=="function"?Dx:Px)(n)):this.node().innerHTML}function Ix(){this.nextSibling&&this.parentNode.appendChild(this)}function Yf(){return this.each(Ix)}function Nx(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Zf(){return this.each(Nx)}function Jf(n){var t=typeof n=="function"?n:Bo(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function Fx(){return null}function $f(n,t){var e=typeof n=="function"?n:Bo(n),i=t==null?Fx:typeof t=="function"?t:di(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})}function zx(){var n=this.parentNode;n&&n.removeChild(this)}function Kf(){return this.each(zx)}function Ux(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Bx(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Qf(n){return this.select(n?Bx:Ux)}function jf(n){return arguments.length?this.property("__data__",n):this.node().__data__}var ed={},Yl=null;typeof document!="undefined"&&(td=document.documentElement,"onmouseenter"in td||(ed={mouseenter:"mouseover",mouseleave:"mouseout"}));var td;function Ox(n,t,e){return n=nd(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(r.compareDocumentPosition(this)&8))&&n.call(this,i)}}function nd(n,t,e){return function(i){var r=Yl;Yl=i;try{n.call(this,this.__data__,t,e)}finally{Yl=r}}}function kx(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}function Hx(n){return function(){var t=this.__on;if(!!t){for(var e=0,i=-1,r=t.length,s;e<r;++e)s=t[e],(!n.type||s.type===n.type)&&s.name===n.name?this.removeEventListener(s.type,s.listener,s.capture):t[++i]=s;++i?t.length=i:delete this.__on}}}function Vx(n,t,e){var i=ed.hasOwnProperty(n.type)?Ox:nd;return function(r,s,o){var a=this.__on,l,c=i(t,s,o);if(a){for(var u=0,h=a.length;u<h;++u)if((l=a[u]).type===n.type&&l.name===n.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),l.value=t;return}}this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function id(n,t,e){var i=kx(n+""),r,s=i.length,o;if(arguments.length<2){var a=this.node().__on;if(a){for(var l=0,c=a.length,u;l<c;++l)for(r=0,u=a[l];r<s;++r)if((o=i[r]).type===u.type&&o.name===u.name)return u.value}return}for(a=t?Vx:Hx,e==null&&(e=!1),r=0;r<s;++r)this.each(a(i[r],t,e));return this}function rd(n,t,e){var i=ko(n),r=i.CustomEvent;typeof r=="function"?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function Gx(n,t){return function(){return rd(this,n,t)}}function Wx(n,t){return function(){return rd(this,n,t.apply(this,arguments))}}function sd(n,t){return this.each((typeof t=="function"?Wx:Gx)(n,t))}var qx=[null];function ce(n,t){this._groups=n,this._parents=t}function od(){return new ce([[document.documentElement]],qx)}ce.prototype=od.prototype={constructor:ce,select:vf,selectAll:_f,filter:wf,data:Ef,enter:Mf,exit:Tf,join:Af,merge:Cf,order:Rf,sort:Lf,call:Pf,nodes:Df,node:If,size:Nf,empty:Ff,each:zf,attr:Uf,style:Bf,property:Of,classed:Wf,text:qf,html:Xf,raise:Yf,lower:Zf,append:Jf,insert:$f,remove:Kf,clone:Qf,datum:jf,on:id,dispatch:sd};var Mn=od;function Ho(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function Zl(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function hs(){}var cs=.7,Go=1/cs,$i="\\s*([+-]?\\d+)\\s*",us="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",cn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Xx=/^#([0-9a-f]{3,8})$/,Yx=new RegExp("^rgb\\("+[$i,$i,$i]+"\\)$"),Zx=new RegExp("^rgb\\("+[cn,cn,cn]+"\\)$"),Jx=new RegExp("^rgba\\("+[$i,$i,$i,us]+"\\)$"),$x=new RegExp("^rgba\\("+[cn,cn,cn,us]+"\\)$"),Kx=new RegExp("^hsl\\("+[us,cn,cn]+"\\)$"),Qx=new RegExp("^hsla\\("+[us,cn,cn,us]+"\\)$"),ad={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Ho(hs,Je,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:ld,formatHex:ld,formatHsl:jx,formatRgb:cd,toString:cd});function ld(){return this.rgb().formatHex()}function jx(){return pd(this).formatHsl()}function cd(){return this.rgb().formatRgb()}function Je(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=Xx.exec(n))?(e=t[1].length,t=parseInt(t[1],16),e===6?ud(t):e===3?new Ue(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):e===8?Vo(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):e===4?Vo(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=Yx.exec(n))?new Ue(t[1],t[2],t[3],1):(t=Zx.exec(n))?new Ue(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=Jx.exec(n))?Vo(t[1],t[2],t[3],t[4]):(t=$x.exec(n))?Vo(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=Kx.exec(n))?dd(t[1],t[2]/100,t[3]/100,1):(t=Qx.exec(n))?dd(t[1],t[2]/100,t[3]/100,t[4]):ad.hasOwnProperty(n)?ud(ad[n]):n==="transparent"?new Ue(NaN,NaN,NaN,0):null}function ud(n){return new Ue(n>>16&255,n>>8&255,n&255,1)}function Vo(n,t,e,i){return i<=0&&(n=t=e=NaN),new Ue(n,t,e,i)}function ty(n){return n instanceof hs||(n=Je(n)),n?(n=n.rgb(),new Ue(n.r,n.g,n.b,n.opacity)):new Ue}function Ki(n,t,e,i){return arguments.length===1?ty(n):new Ue(n,t,e,i==null?1:i)}function Ue(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}Ho(Ue,Ki,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:hd,formatHex:hd,formatRgb:fd,toString:fd}));function hd(){return"#"+Jl(this.r)+Jl(this.g)+Jl(this.b)}function fd(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(n===1?")":", "+n+")")}function Jl(n){return n=Math.max(0,Math.min(255,Math.round(n)||0)),(n<16?"0":"")+n.toString(16)}function dd(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new ln(n,t,e,i)}function pd(n){if(n instanceof ln)return new ln(n.h,n.s,n.l,n.opacity);if(n instanceof hs||(n=Je(n)),!n)return new ln;if(n instanceof ln)return n;n=n.rgb();var t=n.r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),s=Math.max(t,e,i),o=NaN,a=s-r,l=(s+r)/2;return a?(t===s?o=(e-i)/a+(e<i)*6:e===s?o=(i-t)/a+2:o=(t-e)/a+4,a/=l<.5?s+r:2-s-r,o*=60):a=l>0&&l<1?0:o,new ln(o,a,l,n.opacity)}function pi(n,t,e,i){return arguments.length===1?pd(n):new ln(n,t,e,i==null?1:i)}function ln(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}Ho(ln,pi,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new ln(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new ln(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+(this.h<0)*360,t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Ue($l(n>=240?n-240:n+120,r,i),$l(n,r,i),$l(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(n===1?")":", "+n+")")}}));function $l(n,t,e){return(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)*255}function Kl(n,t,e,i,r){var s=n*n,o=s*n;return((1-3*n+3*s-o)*t+(4-6*s+3*o)*e+(1+3*n+3*s-3*o)*i+o*r)/6}function md(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],s=n[i+1],o=i>0?n[i-1]:2*r-s,a=i<t-1?n[i+2]:2*s-r;return Kl((e-i/t)*t,o,r,s,a)}}function gd(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t),r=n[(i+t-1)%t],s=n[i%t],o=n[(i+1)%t],a=n[(i+2)%t];return Kl((e-i/t)*t,r,s,o,a)}}function Qi(n){return function(){return n}}function xd(n,t){return function(e){return n+e*t}}function ey(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}function yd(n,t){var e=t-n;return e?xd(n,e>180||e<-180?e-360*Math.round(e/360):e):Qi(isNaN(n)?t:n)}function vd(n){return(n=+n)==1?bn:function(t,e){return e-t?ey(t,e,n):Qi(isNaN(t)?e:t)}}function bn(n,t){var e=t-n;return e?xd(n,e):Qi(isNaN(n)?t:n)}var mi=function n(t){var e=vd(t);function i(r,s){var o=e((r=Ki(r)).r,(s=Ki(s)).r),a=e(r.g,s.g),l=e(r.b,s.b),c=bn(r.opacity,s.opacity);return function(u){return r.r=o(u),r.g=a(u),r.b=l(u),r.opacity=c(u),r+""}}return i.gamma=n,i}(1);function _d(n){return function(t){var e=t.length,i=new Array(e),r=new Array(e),s=new Array(e),o,a;for(o=0;o<e;++o)a=Ki(t[o]),i[o]=a.r||0,r[o]=a.g||0,s[o]=a.b||0;return i=n(i),r=n(r),s=n(s),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=s(l),a+""}}}var ny=_d(md),iy=_d(gd);function wd(n,t){t||(t=[]);var e=n?Math.min(t.length,n.length):0,i=t.slice(),r;return function(s){for(r=0;r<e;++r)i[r]=n[r]*(1-s)+t[r]*s;return i}}function Md(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function bd(n,t){var e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),s=new Array(e),o;for(o=0;o<i;++o)r[o]=gi(n[o],t[o]);for(;o<e;++o)s[o]=t[o];return function(a){for(o=0;o<i;++o)s[o]=r[o](a);return s}}function Sd(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function ye(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function Ed(n,t){var e={},i={},r;(n===null||typeof n!="object")&&(n={}),(t===null||typeof t!="object")&&(t={});for(r in t)r in n?e[r]=gi(n[r],t[r]):i[r]=t[r];return function(s){for(r in e)i[r]=e[r](s);return i}}var jl=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ql=new RegExp(jl.source,"g");function ry(n){return function(){return n}}function sy(n){return function(t){return n(t)+""}}function fs(n,t){var e=jl.lastIndex=Ql.lastIndex=0,i,r,s,o=-1,a=[],l=[];for(n=n+"",t=t+"";(i=jl.exec(n))&&(r=Ql.exec(t));)(s=r.index)>e&&(s=t.slice(e,s),a[o]?a[o]+=s:a[++o]=s),(i=i[0])===(r=r[0])?a[o]?a[o]+=r:a[++o]=r:(a[++o]=null,l.push({i:o,x:ye(i,r)})),e=Ql.lastIndex;return e<t.length&&(s=t.slice(e),a[o]?a[o]+=s:a[++o]=s),a.length<2?l[0]?sy(l[0].x):ry(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)a[(h=l[u]).i]=h.x(c);return a.join("")})}function gi(n,t){var e=typeof t,i;return t==null||e==="boolean"?Qi(t):(e==="number"?ye:e==="string"?(i=Je(t))?(t=i,mi):fs:t instanceof Je?mi:t instanceof Date?Sd:Md(t)?wd:Array.isArray(t)?bd:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?Ed:ye)(n,t)}function tc(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Td=180/Math.PI,Wo={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function ec(n,t,e,i,r,s){var o,a,l;return(o=Math.sqrt(n*n+t*t))&&(n/=o,t/=o),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,o=-o),{translateX:r,translateY:s,rotate:Math.atan2(t,n)*Td,skewX:Math.atan(l)*Td,scaleX:o,scaleY:a}}var ds,nc,Ad,qo;function Cd(n){return n==="none"?Wo:(ds||(ds=document.createElement("DIV"),nc=document.documentElement,Ad=document.defaultView),ds.style.transform=n,n=Ad.getComputedStyle(nc.appendChild(ds),null).getPropertyValue("transform"),nc.removeChild(ds),n=n.slice(7,-1).split(","),ec(+n[0],+n[1],+n[2],+n[3],+n[4],+n[5]))}function Rd(n){return n==null?Wo:(qo||(qo=document.createElementNS("http://www.w3.org/2000/svg","g")),qo.setAttribute("transform",n),(n=qo.transform.baseVal.consolidate())?(n=n.matrix,ec(n.a,n.b,n.c,n.d,n.e,n.f)):Wo)}function Ld(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}function s(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push("translate(",null,t,null,e);g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h||f)&&d.push("translate("+h+t+f+e)}function o(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(r(h)+"rotate(",null,i)-2,x:ye(c,u)})):u&&h.push(r(h)+"rotate("+u+i)}function a(c,u,h,f){c!==u?f.push({i:h.push(r(h)+"skewX(",null,i)-2,x:ye(c,u)}):u&&h.push(r(h)+"skewX("+u+i)}function l(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push(r(d)+"scale(",null,",",null,")");g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h!==1||f!==1)&&d.push(r(d)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=n(c),u=n(u),s(c.translateX,c.translateY,u.translateX,u.translateY,h,f),o(c.rotate,u.rotate,h,f),a(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(d){for(var g=-1,x=f.length,v;++g<x;)h[(v=f[g]).i]=v.x(d);return h.join("")}}}var ic=Ld(Cd,"px, ","px)","deg)"),rc=Ld(Rd,", ",")",")");function Pd(n){return function(t,e){var i=n((t=pi(t)).h,(e=pi(e)).h),r=bn(t.s,e.s),s=bn(t.l,e.l),o=bn(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=s(a),t.opacity=o(a),t+""}}}var sc=Pd(yd),oy=Pd(bn);var ji=0,ms=0,ps=0,Id=1e3,Xo,gs,Yo=0,xi=0,Zo=0,xs=typeof performance=="object"&&performance.now?performance:Date,Nd=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function tr(){return xi||(Nd(ay),xi=xs.now()+Zo)}function ay(){xi=0}function ys(){this._call=this._time=this._next=null}ys.prototype=Jo.prototype={constructor:ys,restart:function(n,t,e){if(typeof n!="function")throw new TypeError("callback is not a function");e=(e==null?tr():+e)+(t==null?0:+t),!this._next&&gs!==this&&(gs?gs._next=this:Xo=this,gs=this),this._call=n,this._time=e,oc()},stop:function(){this._call&&(this._call=null,this._time=1/0,oc())}};function Jo(n,t,e){var i=new ys;return i.restart(n,t,e),i}function Fd(){tr(),++ji;for(var n=Xo,t;n;)(t=xi-n._time)>=0&&n._call.call(null,t),n=n._next;--ji}function Dd(){xi=(Yo=xs.now())+Zo,ji=ms=0;try{Fd()}finally{ji=0,cy(),xi=0}}function ly(){var n=xs.now(),t=n-Yo;t>Id&&(Zo-=t,Yo=n)}function cy(){for(var n,t=Xo,e,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:Xo=e);gs=n,oc(i)}function oc(n){if(!ji){ms&&(ms=clearTimeout(ms));var t=n-xi;t>24?(n<1/0&&(ms=setTimeout(Dd,n-xs.now()-Zo)),ps&&(ps=clearInterval(ps))):(ps||(Yo=xs.now(),ps=setInterval(ly,Id)),ji=1,Nd(Dd))}}function $o(n,t,e){var i=new ys;return t=t==null?0:+t,i.restart(function(r){i.stop(),n(r+t)},t,e),i}var uy=Wl("start","end","cancel","interrupt"),hy=[],Ud=0,ac=1,Qo=2,Ko=3,zd=4,jo=5,vs=6;function kn(n,t,e,i,r,s){var o=n.__transition;if(!o)n.__transition={};else if(e in o)return;fy(n,e,{name:t,index:i,group:r,on:uy,tween:hy,time:s.time,delay:s.delay,duration:s.duration,ease:s.ease,timer:null,state:Ud})}function _s(n,t){var e=ue(n,t);if(e.state>Ud)throw new Error("too late; already scheduled");return e}function Ae(n,t){var e=ue(n,t);if(e.state>Ko)throw new Error("too late; already running");return e}function ue(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function fy(n,t,e){var i=n.__transition,r;i[t]=e,e.timer=Jo(s,0,e.time);function s(c){e.state=ac,e.timer.restart(o,e.delay,e.time),e.delay<=c&&o(c-e.delay)}function o(c){var u,h,f,d;if(e.state!==ac)return l();for(u in i)if(d=i[u],d.name===e.name){if(d.state===Ko)return $o(o);d.state===zd?(d.state=vs,d.timer.stop(),d.on.call("interrupt",n,n.__data__,d.index,d.group),delete i[u]):+u<t&&(d.state=vs,d.timer.stop(),d.on.call("cancel",n,n.__data__,d.index,d.group),delete i[u])}if($o(function(){e.state===Ko&&(e.state=zd,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=Qo,e.on.call("start",n,n.__data__,e.index,e.group),e.state===Qo){for(e.state=Ko,r=new Array(f=e.tween.length),u=0,h=-1;u<f;++u)(d=e.tween[u].value.call(n,n.__data__,e.index,e.group))&&(r[++h]=d);r.length=h+1}}function a(c){for(var u=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=jo,1),h=-1,f=r.length;++h<f;)r[h].call(n,u);e.state===jo&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){e.state=vs,e.timer.stop(),delete i[t];for(var c in i)return;delete n.__transition}}function ws(n,t){var e=n.__transition,i,r,s=!0,o;if(!!e){t=t==null?null:t+"";for(o in e){if((i=e[o]).name!==t){s=!1;continue}r=i.state>Qo&&i.state<jo,i.state=vs,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[o]}s&&delete n.__transition}}function Bd(n){return this.each(function(){ws(this,n)})}function dy(n,t){var e,i;return function(){var r=Ae(this,n),s=r.tween;if(s!==e){i=e=s;for(var o=0,a=i.length;o<a;++o)if(i[o].name===t){i=i.slice(),i.splice(o,1);break}}r.tween=i}}function py(n,t,e){var i,r;if(typeof e!="function")throw new Error;return function(){var s=Ae(this,n),o=s.tween;if(o!==i){r=(i=o).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}s.tween=r}}function Od(n,t){var e=this._id;if(n+="",arguments.length<2){for(var i=ue(this.node(),e).tween,r=0,s=i.length,o;r<s;++r)if((o=i[r]).name===n)return o.value;return null}return this.each((t==null?dy:py)(e,n,t))}function er(n,t,e){var i=n._id;return n.each(function(){var r=Ae(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return ue(r,i).value[t]}}function ta(n,t){var e;return(typeof t=="number"?ye:t instanceof Je?mi:(e=Je(t))?(t=e,mi):fs)(n,t)}function my(n){return function(){this.removeAttribute(n)}}function gy(n){return function(){this.removeAttributeNS(n.space,n.local)}}function xy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttribute(n);return o===r?null:o===i?s:s=t(i=o,e)}}function yy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttributeNS(n.space,n.local);return o===r?null:o===i?s:s=t(i=o,e)}}function vy(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttribute(n):(o=this.getAttribute(n),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function _y(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttributeNS(n.space,n.local):(o=this.getAttributeNS(n.space,n.local),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function kd(n,t){var e=wn(n),i=e==="transform"?rc:ta;return this.attrTween(n,typeof t=="function"?(e.local?_y:vy)(e,i,er(this,"attr."+n,t)):t==null?(e.local?gy:my)(e):(e.local?yy:xy)(e,i,t))}function wy(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}function My(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}function by(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&My(n,s)),e}return r._value=t,r}function Sy(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&wy(n,s)),e}return r._value=t,r}function Hd(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(t==null)return this.tween(e,null);if(typeof t!="function")throw new Error;var i=wn(n);return this.tween(e,(i.local?by:Sy)(i,t))}function Ey(n,t){return function(){_s(this,n).delay=+t.apply(this,arguments)}}function Ty(n,t){return t=+t,function(){_s(this,n).delay=t}}function Vd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ey:Ty)(t,n)):ue(this.node(),t).delay}function Ay(n,t){return function(){Ae(this,n).duration=+t.apply(this,arguments)}}function Cy(n,t){return t=+t,function(){Ae(this,n).duration=t}}function Gd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ay:Cy)(t,n)):ue(this.node(),t).duration}function Ry(n,t){if(typeof t!="function")throw new Error;return function(){Ae(this,n).ease=t}}function Wd(n){var t=this._id;return arguments.length?this.each(Ry(t,n)):ue(this.node(),t).ease}function qd(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new we(i,this._parents,this._name,this._id)}function Xd(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new we(o,this._parents,this._name,this._id)}function Ly(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||t==="start"})}function Py(n,t,e){var i,r,s=Ly(t)?_s:Ae;return function(){var o=s(this,n),a=o.on;a!==i&&(r=(i=a).copy()).on(t,e),o.on=r}}function Yd(n,t){var e=this._id;return arguments.length<2?ue(this.node(),e).on.on(n):this.each(Py(e,n,t))}function Dy(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}function Zd(){return this.on("end.remove",Dy(this._id))}function Jd(n){var t=this._name,e=this._id;typeof n!="function"&&(n=di(n));for(var i=this._groups,r=i.length,s=new Array(r),o=0;o<r;++o)for(var a=i[o],l=a.length,c=s[o]=new Array(l),u,h,f=0;f<l;++f)(u=a[f])&&(h=n.call(u,u.__data__,f,a))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,kn(c[f],t,e,f,c,ue(u,e)));return new we(s,this._parents,t,e)}function $d(n){var t=this._name,e=this._id;typeof n!="function"&&(n=os(n));for(var i=this._groups,r=i.length,s=[],o=[],a=0;a<r;++a)for(var l=i[a],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=n.call(u,u.__data__,h,l),d,g=ue(u,e),x=0,v=f.length;x<v;++x)(d=f[x])&&kn(d,t,e,x,f,g);s.push(f),o.push(u)}return new we(s,o,t,e)}var Iy=Mn.prototype.constructor;function Kd(){return new Iy(this._groups,this._parents)}function Ny(n,t){var e,i,r;return function(){var s=On(this,n),o=(this.style.removeProperty(n),On(this,n));return s===o?null:s===e&&o===i?r:r=t(e=s,i=o)}}function Qd(n){return function(){this.style.removeProperty(n)}}function Fy(n,t,e){var i,r=e+"",s;return function(){var o=On(this,n);return o===r?null:o===i?s:s=t(i=o,e)}}function zy(n,t,e){var i,r,s;return function(){var o=On(this,n),a=e(this),l=a+"";return a==null&&(l=a=(this.style.removeProperty(n),On(this,n))),o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a))}}function Uy(n,t){var e,i,r,s="style."+t,o="end."+s,a;return function(){var l=Ae(this,n),c=l.on,u=l.value[s]==null?a||(a=Qd(t)):void 0;(c!==e||r!==u)&&(i=(e=c).copy()).on(o,r=u),l.on=i}}function jd(n,t,e){var i=(n+="")=="transform"?ic:ta;return t==null?this.styleTween(n,Ny(n,i)).on("end.style."+n,Qd(n)):typeof t=="function"?this.styleTween(n,zy(n,i,er(this,"style."+n,t))).each(Uy(this._id,n)):this.styleTween(n,Fy(n,i,t),e).on("end.style."+n,null)}function By(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}function Oy(n,t,e){var i,r;function s(){var o=t.apply(this,arguments);return o!==r&&(i=(r=o)&&By(n,o,e)),i}return s._value=t,s}function tp(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(t==null)return this.tween(i,null);if(typeof t!="function")throw new Error;return this.tween(i,Oy(n,t,e==null?"":e))}function ky(n){return function(){this.textContent=n}}function Hy(n){return function(){var t=n(this);this.textContent=t==null?"":t}}function ep(n){return this.tween("text",typeof n=="function"?Hy(er(this,"text",n)):ky(n==null?"":n+""))}function Vy(n){return function(t){this.textContent=n.call(this,t)}}function Gy(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&Vy(r)),t}return i._value=n,i}function np(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(n==null)return this.tween(t,null);if(typeof n!="function")throw new Error;return this.tween(t,Gy(n))}function ip(){for(var n=this._name,t=this._id,e=ea(),i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)if(l=o[c]){var u=ue(l,t);kn(l,n,e,c,o,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new we(i,this._parents,n,e)}function rp(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(s,o){var a={value:o},l={value:function(){--r===0&&s()}};e.each(function(){var c=Ae(this,i),u=c.on;u!==n&&(t=(n=u).copy(),t._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}var Wy=0;function we(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function lc(n){return Mn().transition(n)}function ea(){return++Wy}var nr=Mn.prototype;we.prototype=lc.prototype={constructor:we,select:Jd,selectAll:$d,filter:qd,merge:Xd,selection:Kd,transition:ip,call:nr.call,nodes:nr.nodes,node:nr.node,size:nr.size,empty:nr.empty,each:nr.each,on:Yd,attr:kd,attrTween:Hd,style:jd,styleTween:tp,text:ep,textTween:np,remove:Zd,tween:Od,delay:Vd,duration:Gd,ease:Wd,end:rp};function na(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var cc={time:null,delay:0,duration:250,ease:na};function qy(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return cc.time=tr(),cc;return e}function sp(n){var t,e;n instanceof we?(t=n._id,n=n._name):(t=ea(),(e=cc).time=tr(),n=n==null?null:n+"");for(var i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&kn(l,n,t,c,o,e||qy(l,t));return new we(i,this._parents,n,t)}Mn.prototype.interrupt=Bd;Mn.prototype.transition=sp;function op(n){return[+n[0],+n[1]]}function Xy(n){return[op(n[0]),op(n[1])]}var GP={name:"x",handles:["w","e"].map(uc),input:function(n,t){return n==null?null:[[+n[0],t[0][1]],[+n[1],t[1][1]]]},output:function(n){return n&&[n[0][0],n[1][0]]}},WP={name:"y",handles:["n","s"].map(uc),input:function(n,t){return n==null?null:[[t[0][0],+n[0]],[t[1][0],+n[1]]]},output:function(n){return n&&[n[0][1],n[1][1]]}},qP={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(uc),input:function(n){return n==null?null:Xy(n)},output:function(n){return n}};function uc(n){return{type:n}}var ap=Math.PI,Yy=ap/2,Zy=ap*2;var Jy=Array.prototype.slice;var Be="$";function ia(){}ia.prototype=lp.prototype={constructor:ia,has:function(n){return Be+n in this},get:function(n){return this[Be+n]},set:function(n,t){return this[Be+n]=t,this},remove:function(n){var t=Be+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Be&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Be&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Be&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Be&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Be&&++n;return n},empty:function(){for(var n in this)if(n[0]===Be)return!1;return!0},each:function(n){for(var t in this)t[0]===Be&&n(this[t],t.slice(1),this)}};function lp(n,t){var e=new ia;if(n instanceof ia)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var i=-1,r=n.length,s;if(t==null)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(s=n[i],i,n),s)}else if(n)for(var o in n)e.set(o,n[o]);return e}var yi=lp;function ra(){}var vi=yi.prototype;ra.prototype=$y.prototype={constructor:ra,has:vi.has,add:function(n){return n+="",this[Be+n]=n,this},remove:vi.remove,clear:vi.clear,values:vi.keys,size:vi.size,empty:vi.empty,each:vi.each};function $y(n,t){var e=new ra;if(n instanceof ra)n.each(function(s){e.add(s)});else if(n){var i=-1,r=n.length;if(t==null)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}var Ky=Array.prototype,cp=Ky.slice;var TI=Math.PI*(3-Math.sqrt(5));function hp(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)}function _i(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function un(n){return n=_i(Math.abs(n)),n?n[1]:NaN}function fp(n,t){return function(e,i){for(var r=e.length,s=[],o=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),s.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[o=(o+1)%n.length];return s.reverse().join(t)}}function dp(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}var tv=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Hn(n){if(!(t=tv.exec(n)))throw new Error("invalid format: "+n);var t;return new sa({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Hn.prototype=sa.prototype;function sa(n){this.fill=n.fill===void 0?" ":n.fill+"",this.align=n.align===void 0?">":n.align+"",this.sign=n.sign===void 0?"-":n.sign+"",this.symbol=n.symbol===void 0?"":n.symbol+"",this.zero=!!n.zero,this.width=n.width===void 0?void 0:+n.width,this.comma=!!n.comma,this.precision=n.precision===void 0?void 0:+n.precision,this.trim=!!n.trim,this.type=n.type===void 0?"":n.type+""}sa.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function pp(n){t:for(var t=n.length,e=1,i=-1,r;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":i===0&&(i=e),r=e;break;default:if(!+n[e])break t;i>0&&(i=0);break}return i>0?n.slice(0,i)+n.slice(r+1):n}var hc;function mp(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1],s=r-(hc=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,o=i.length;return s===o?i:s>o?i+new Array(s-o+1).join("0"):s>0?i.slice(0,s)+"."+i.slice(s):"0."+new Array(1-s).join("0")+_i(n,Math.max(0,t+s-1))[0]}function fc(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}var dc={"%":function(n,t){return(n*100).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:hp,e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return fc(n*100,t)},r:fc,s:mp,X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function pc(n){return n}var gp=Array.prototype.map,xp=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function yp(n){var t=n.grouping===void 0||n.thousands===void 0?pc:fp(gp.call(n.grouping,Number),n.thousands+""),e=n.currency===void 0?"":n.currency[0]+"",i=n.currency===void 0?"":n.currency[1]+"",r=n.decimal===void 0?".":n.decimal+"",s=n.numerals===void 0?pc:dp(gp.call(n.numerals,String)),o=n.percent===void 0?"%":n.percent+"",a=n.minus===void 0?"-":n.minus+"",l=n.nan===void 0?"NaN":n.nan+"";function c(h){h=Hn(h);var f=h.fill,d=h.align,g=h.sign,x=h.symbol,v=h.zero,m=h.width,p=h.comma,b=h.precision,_=h.trim,S=h.type;S==="n"?(p=!0,S="g"):dc[S]||(b===void 0&&(b=12),_=!0,S="g"),(v||f==="0"&&d==="=")&&(v=!0,f="0",d="=");var L=x==="$"?e:x==="#"&&/[boxX]/.test(S)?"0"+S.toLowerCase():"",A=x==="$"?i:/[%p]/.test(S)?o:"",H=dc[S],tt=/[defgprs%]/.test(S);b=b===void 0?6:/[gprs]/.test(S)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function X(y){var R=L,D=A,F,z,N;if(S==="c")D=H(y)+D,y="";else{y=+y;var V=y<0||1/y<0;if(y=isNaN(y)?l:H(Math.abs(y),b),_&&(y=pp(y)),V&&+y==0&&g!=="+"&&(V=!1),R=(V?g==="("?g:a:g==="-"||g==="("?"":g)+R,D=(S==="s"?xp[8+hc/3]:"")+D+(V&&g==="("?")":""),tt){for(F=-1,z=y.length;++F<z;)if(N=y.charCodeAt(F),48>N||N>57){D=(N===46?r+y.slice(F+1):y.slice(F))+D,y=y.slice(0,F);break}}}p&&!v&&(y=t(y,1/0));var Q=R.length+y.length+D.length,at=Q<m?new Array(m-Q+1).join(f):"";switch(p&&v&&(y=t(at+y,at.length?m-D.length:1/0),at=""),d){case"<":y=R+y+D+at;break;case"=":y=R+at+y+D;break;case"^":y=at.slice(0,Q=at.length>>1)+R+y+D+at.slice(Q);break;default:y=at+R+y+D;break}return s(y)}return X.toString=function(){return h+""},X}function u(h,f){var d=c((h=Hn(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(un(f)/3)))*3,x=Math.pow(10,-g),v=xp[8+g/3];return function(m){return d(x*m)+v}}return{format:c,formatPrefix:u}}var oa,Oe,aa;mc({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function mc(n){return oa=yp(n),Oe=oa.format,aa=oa.formatPrefix,oa}function gc(n){return Math.max(0,-un(Math.abs(n)))}function xc(n,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(un(t)/3)))*3-un(Math.abs(n)))}function yc(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,un(t)-un(n))+1}function We(){return Math.random()}var ev=function n(t){function e(i,r){return i=i==null?0:+i,r=r==null?1:+r,arguments.length===1?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(We);var vc=function n(t){function e(i,r){var s,o;return i=i==null?0:+i,r=r==null?1:+r,function(){var a;if(s!=null)a=s,s=null;else do s=t()*2-1,a=t()*2-1,o=s*s+a*a;while(!o||o>1);return i+r*a*Math.sqrt(-2*Math.log(o)/o)}}return e.source=n,e}(We);var nv=function n(t){function e(){var i=vc.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(We);var _c=function n(t){function e(i){return function(){for(var r=0,s=0;s<i;++s)r+=t();return r}}return e.source=n,e}(We);var iv=function n(t){function e(i){var r=_c.source(t)(i);return function(){return r()/i}}return e.source=n,e}(We);var rv=function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(We);function Pe(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n);break}return this}var vp=Array.prototype,bs=vp.map,wi=vp.slice;function _p(n){return function(){return n}}function wc(n){return+n}var wp=[0,1];function De(n){return n}function Mc(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:_p(isNaN(t)?NaN:.5)}function Mp(n){var t=n[0],e=n[n.length-1],i;return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function ov(n,t,e){var i=n[0],r=n[1],s=t[0],o=t[1];return r<i?(i=Mc(r,i),s=e(o,s)):(i=Mc(i,r),s=e(s,o)),function(a){return s(i(a))}}function av(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),s=new Array(i),o=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++o<i;)r[o]=Mc(n[o],n[o+1]),s[o]=e(t[o],t[o+1]);return function(a){var l=Bn(n,a,1,i)-1;return s[l](r[l](a))}}function Vn(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Ss(){var n=wp,t=wp,e=gi,i,r,s,o=De,a,l,c;function u(){return a=Math.min(n.length,t.length)>2?av:ov,l=c=null,h}function h(f){return isNaN(f=+f)?s:(l||(l=a(n.map(i),t,e)))(i(o(f)))}return h.invert=function(f){return o(r((c||(c=a(t,n.map(i),ye)))(f)))},h.domain=function(f){return arguments.length?(n=bs.call(f,wc),o===De||(o=Mp(n)),u()):n.slice()},h.range=function(f){return arguments.length?(t=wi.call(f),u()):t.slice()},h.rangeRound=function(f){return t=wi.call(f),e=tc,u()},h.clamp=function(f){return arguments.length?(o=f?Mp(n):De,h):o!==De},h.interpolate=function(f){return arguments.length?(e=f,u()):e},h.unknown=function(f){return arguments.length?(s=f,h):s},function(f,d){return i=f,r=d,u()}}function Es(n,t){return Ss()(n,t)}function bc(n,t,e,i){var r=_n(n,t,e),s;switch(i=Hn(i==null?",f":i),i.type){case"s":{var o=Math.max(Math.abs(n),Math.abs(t));return i.precision==null&&!isNaN(s=xc(r,o))&&(i.precision=s),aa(i,o)}case"":case"e":case"g":case"p":case"r":{i.precision==null&&!isNaN(s=yc(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=s-(i.type==="e"));break}case"f":case"%":{i.precision==null&&!isNaN(s=gc(r))&&(i.precision=s-(i.type==="%")*2);break}}return Oe(i)}function Mi(n){var t=n.domain;return n.ticks=function(e){var i=t();return rs(i[0],i[i.length-1],e==null?10:e)},n.tickFormat=function(e,i){var r=t();return bc(r[0],r[r.length-1],e==null?10:e,i)},n.nice=function(e){e==null&&(e=10);var i=t(),r=0,s=i.length-1,o=i[r],a=i[s],l;return a<o&&(l=o,o=a,a=l,l=r,r=s,s=l),l=Ji(o,a,e),l>0?(o=Math.floor(o/l)*l,a=Math.ceil(a/l)*l,l=Ji(o,a,e)):l<0&&(o=Math.ceil(o*l)/l,a=Math.floor(a*l)/l,l=Ji(o,a,e)),l>0?(i[r]=Math.floor(o/l)*l,i[s]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(o*l)/l,i[s]=Math.floor(a*l)/l,t(i)),n},n}function ir(){var n=Es(De,De);return n.copy=function(){return Vn(n,ir())},Pe.apply(n,arguments),Mi(n)}function la(n,t){n=n.slice();var e=0,i=n.length-1,r=n[e],s=n[i],o;return s<r&&(o=e,e=i,i=o,o=r,r=s,s=o),n[e]=t.floor(r),n[i]=t.ceil(s),n}function bp(n){return Math.log(n)}function Sp(n){return Math.exp(n)}function lv(n){return-Math.log(-n)}function cv(n){return-Math.exp(-n)}function uv(n){return isFinite(n)?+("1e"+n):n<0?0:n}function hv(n){return n===10?uv:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}function fv(n){return n===Math.E?Math.log:n===10&&Math.log10||n===2&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}function Ep(n){return function(t){return-n(-t)}}function Sc(n){var t=n(bp,Sp),e=t.domain,i=10,r,s;function o(){return r=fv(i),s=hv(i),e()[0]<0?(r=Ep(r),s=Ep(s),n(lv,cv)):n(bp,Sp),t}return t.base=function(a){return arguments.length?(i=+a,o()):i},t.domain=function(a){return arguments.length?(e(a),o()):e()},t.ticks=function(a){var l=e(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=r(c),d=r(u),g,x,v,m=a==null?10:+a,p=[];if(!(i%1)&&d-f<m){if(f=Math.round(f)-1,d=Math.round(d)+1,c>0){for(;f<d;++f)for(x=1,g=s(f);x<i;++x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else for(;f<d;++f)for(x=i-1,g=s(f);x>=1;--x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else p=rs(f,d,Math.min(d-f,m)).map(s);return h?p.reverse():p},t.tickFormat=function(a,l){if(l==null&&(l=i===10?".0e":","),typeof l!="function"&&(l=Oe(l)),a===1/0)return l;a==null&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(u){var h=u/s(Math.round(r(u)));return h*i<i-.5&&(h*=i),h<=c?l(u):""}},t.nice=function(){return e(la(e(),{floor:function(a){return s(Math.floor(r(a)))},ceil:function(a){return s(Math.ceil(r(a)))}}))},t}function Ts(){var n=Sc(Ss()).domain([1,10]);return n.copy=function(){return Vn(n,Ts()).base(n.base())},Pe.apply(n,arguments),n}var Ec=new Date,Tc=new Date;function Yt(n,t,e,i){function r(s){return n(s=arguments.length===0?new Date:new Date(+s)),s}return r.floor=function(s){return n(s=new Date(+s)),s},r.ceil=function(s){return n(s=new Date(s-1)),t(s,1),n(s),s},r.round=function(s){var o=r(s),a=r.ceil(s);return s-o<a-s?o:a},r.offset=function(s,o){return t(s=new Date(+s),o==null?1:Math.floor(o)),s},r.range=function(s,o,a){var l=[],c;if(s=r.ceil(s),a=a==null?1:Math.floor(a),!(s<o)||!(a>0))return l;do l.push(c=new Date(+s)),t(s,a),n(s);while(c<s&&s<o);return l},r.filter=function(s){return Yt(function(o){if(o>=o)for(;n(o),!s(o);)o.setTime(o-1)},function(o,a){if(o>=o)if(a<0)for(;++a<=0;)for(;t(o,-1),!s(o););else for(;--a>=0;)for(;t(o,1),!s(o););})},e&&(r.count=function(s,o){return Ec.setTime(+s),Tc.setTime(+o),n(Ec),n(Tc),Math.floor(e(Ec,Tc))},r.every=function(s){return s=Math.floor(s),!isFinite(s)||!(s>0)?null:s>1?r.filter(i?function(o){return i(o)%s===0}:function(o){return r.count(0,o)%s===0}):r}),r}var ca=Yt(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});ca.every=function(n){return n=Math.floor(n),!isFinite(n)||!(n>0)?null:n>1?Yt(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):ca};var ua=ca,Tp=ca.range;var bi=1e3,Sn=6e4,Ac=36e5,ha=864e5,fa=6048e5;var Ap=Yt(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+t*bi)},function(n,t){return(t-n)/bi},function(n){return n.getUTCSeconds()}),da=Ap,Cp=Ap.range;var Rp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi)},function(n,t){n.setTime(+n+t*Sn)},function(n,t){return(t-n)/Sn},function(n){return n.getMinutes()}),Cc=Rp,dv=Rp.range;var Lp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi-n.getMinutes()*Sn)},function(n,t){n.setTime(+n+t*Ac)},function(n,t){return(t-n)/Ac},function(n){return n.getHours()}),Rc=Lp,pv=Lp.range;var Pp=Yt(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*Sn)/ha},function(n){return n.getDate()-1}),rr=Pp,mv=Pp.range;function Si(n){return Yt(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+e*7)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*Sn)/fa})}var Ei=Si(0),sr=Si(1),Dp=Si(2),Ip=Si(3),Gn=Si(4),Np=Si(5),Fp=Si(6),zp=Ei.range,gv=sr.range,xv=Dp.range,yv=Ip.range,vv=Gn.range,_v=Np.range,wv=Fp.range;var Up=Yt(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+(t.getFullYear()-n.getFullYear())*12},function(n){return n.getMonth()}),Lc=Up,Mv=Up.range;var Pc=Yt(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});Pc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)})};var En=Pc,bv=Pc.range;var Bp=Yt(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/ha},function(n){return n.getUTCDate()-1}),pa=Bp,Sv=Bp.range;function Ti(n){return Yt(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+e*7)},function(t,e){return(e-t)/fa})}var As=Ti(0),or=Ti(1),Op=Ti(2),kp=Ti(3),Wn=Ti(4),Hp=Ti(5),Vp=Ti(6),Gp=As.range,Ev=or.range,Tv=Op.range,Av=kp.range,Cv=Wn.range,Rv=Hp.range,Lv=Vp.range;var Dc=Yt(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()});Dc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)})};var Ai=Dc,Pv=Dc.range;function Ic(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function Nc(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function Cs(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}function Fc(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,s=n.days,o=n.shortDays,a=n.months,l=n.shortMonths,c=Rs(r),u=Ls(r),h=Rs(s),f=Ls(s),d=Rs(o),g=Ls(o),x=Rs(a),v=Ls(a),m=Rs(l),p=Ls(l),b={a:V,A:Q,b:at,B:G,c:null,d:Jp,e:Jp,f:t_,g:u_,G:f_,H:Kv,I:Qv,j:jv,L:tm,m:e_,M:n_,p:$,q:lt,Q:Qp,s:jp,S:i_,u:r_,U:s_,V:o_,w:a_,W:l_,x:null,X:null,y:c_,Y:h_,Z:d_,"%":Kp},_={a:dt,A:xt,b:k,B:Ft,c:null,d:$p,e:$p,f:x_,g:A_,G:R_,H:p_,I:m_,j:g_,L:nm,m:y_,M:v_,p:mt,q:St,Q:Qp,s:jp,S:__,u:w_,U:M_,V:b_,w:S_,W:E_,x:null,X:null,y:T_,Y:C_,Z:L_,"%":Kp},S={a:X,A:y,b:R,B:D,c:F,d:Yp,e:Yp,f:Yv,g:Xp,G:qp,H:Zp,I:Zp,j:Gv,L:Xv,m:Vv,M:Wv,p:tt,q:Hv,Q:Jv,s:$v,S:qv,u:zv,U:Uv,V:Bv,w:Fv,W:Ov,x:z,X:N,y:Xp,Y:qp,Z:kv,"%":Zv};b.x=L(e,b),b.X=L(i,b),b.c=L(t,b),_.x=L(e,_),_.X=L(i,_),_.c=L(t,_);function L(B,st){return function(nt){var C=[],j=-1,J=0,it=B.length,et,vt,bt;for(nt instanceof Date||(nt=new Date(+nt));++j<it;)B.charCodeAt(j)===37&&(C.push(B.slice(J,j)),(vt=Wp[et=B.charAt(++j)])!=null?et=B.charAt(++j):vt=et==="e"?" ":"0",(bt=st[et])&&(et=bt(nt,vt)),C.push(et),J=j+1);return C.push(B.slice(J,j)),C.join("")}}function A(B,st){return function(nt){var C=Cs(1900,void 0,1),j=H(C,B,nt+="",0),J,it;if(j!=nt.length)return null;if("Q"in C)return new Date(C.Q);if("s"in C)return new Date(C.s*1e3+("L"in C?C.L:0));if(st&&!("Z"in C)&&(C.Z=0),"p"in C&&(C.H=C.H%12+C.p*12),C.m===void 0&&(C.m="q"in C?C.q:0),"V"in C){if(C.V<1||C.V>53)return null;"w"in C||(C.w=1),"Z"in C?(J=Nc(Cs(C.y,0,1)),it=J.getUTCDay(),J=it>4||it===0?or.ceil(J):or(J),J=pa.offset(J,(C.V-1)*7),C.y=J.getUTCFullYear(),C.m=J.getUTCMonth(),C.d=J.getUTCDate()+(C.w+6)%7):(J=Ic(Cs(C.y,0,1)),it=J.getDay(),J=it>4||it===0?sr.ceil(J):sr(J),J=rr.offset(J,(C.V-1)*7),C.y=J.getFullYear(),C.m=J.getMonth(),C.d=J.getDate()+(C.w+6)%7)}else("W"in C||"U"in C)&&("w"in C||(C.w="u"in C?C.u%7:"W"in C?1:0),it="Z"in C?Nc(Cs(C.y,0,1)).getUTCDay():Ic(Cs(C.y,0,1)).getDay(),C.m=0,C.d="W"in C?(C.w+6)%7+C.W*7-(it+5)%7:C.w+C.U*7-(it+6)%7);return"Z"in C?(C.H+=C.Z/100|0,C.M+=C.Z%100,Nc(C)):Ic(C)}}function H(B,st,nt,C){for(var j=0,J=st.length,it=nt.length,et,vt;j<J;){if(C>=it)return-1;if(et=st.charCodeAt(j++),et===37){if(et=st.charAt(j++),vt=S[et in Wp?st.charAt(j++):et],!vt||(C=vt(B,nt,C))<0)return-1}else if(et!=nt.charCodeAt(C++))return-1}return C}function tt(B,st,nt){var C=c.exec(st.slice(nt));return C?(B.p=u[C[0].toLowerCase()],nt+C[0].length):-1}function X(B,st,nt){var C=d.exec(st.slice(nt));return C?(B.w=g[C[0].toLowerCase()],nt+C[0].length):-1}function y(B,st,nt){var C=h.exec(st.slice(nt));return C?(B.w=f[C[0].toLowerCase()],nt+C[0].length):-1}function R(B,st,nt){var C=m.exec(st.slice(nt));return C?(B.m=p[C[0].toLowerCase()],nt+C[0].length):-1}function D(B,st,nt){var C=x.exec(st.slice(nt));return C?(B.m=v[C[0].toLowerCase()],nt+C[0].length):-1}function F(B,st,nt){return H(B,t,st,nt)}function z(B,st,nt){return H(B,e,st,nt)}function N(B,st,nt){return H(B,i,st,nt)}function V(B){return o[B.getDay()]}function Q(B){return s[B.getDay()]}function at(B){return l[B.getMonth()]}function G(B){return a[B.getMonth()]}function $(B){return r[+(B.getHours()>=12)]}function lt(B){return 1+~~(B.getMonth()/3)}function dt(B){return o[B.getUTCDay()]}function xt(B){return s[B.getUTCDay()]}function k(B){return l[B.getUTCMonth()]}function Ft(B){return a[B.getUTCMonth()]}function mt(B){return r[+(B.getUTCHours()>=12)]}function St(B){return 1+~~(B.getUTCMonth()/3)}return{format:function(B){var st=L(B+="",b);return st.toString=function(){return B},st},parse:function(B){var st=A(B+="",!1);return st.toString=function(){return B},st},utcFormat:function(B){var st=L(B+="",_);return st.toString=function(){return B},st},utcParse:function(B){var st=A(B+="",!0);return st.toString=function(){return B},st}}}var Wp={"-":"",_:" ",0:"0"},pe=/^\s*\d+/,Dv=/^%/,Iv=/[\\^$*+?|[\]().{}]/g;function Bt(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",s=r.length;return i+(s<e?new Array(e-s+1).join(t)+r:r)}function Nv(n){return n.replace(Iv,"\\$&")}function Rs(n){return new RegExp("^(?:"+n.map(Nv).join("|")+")","i")}function Ls(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function Fv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function zv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function Uv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function Bv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function Ov(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function qp(n,t,e){var i=pe.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function Xp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function kv(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function Hv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.q=i[0]*3-3,e+i[0].length):-1}function Vv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function Yp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function Gv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function Zp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function Wv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function qv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function Xv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function Yv(n,t,e){var i=pe.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function Zv(n,t,e){var i=Dv.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function Jv(n,t,e){var i=pe.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function $v(n,t,e){var i=pe.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function Jp(n,t){return Bt(n.getDate(),t,2)}function Kv(n,t){return Bt(n.getHours(),t,2)}function Qv(n,t){return Bt(n.getHours()%12||12,t,2)}function jv(n,t){return Bt(1+rr.count(En(n),n),t,3)}function tm(n,t){return Bt(n.getMilliseconds(),t,3)}function t_(n,t){return tm(n,t)+"000"}function e_(n,t){return Bt(n.getMonth()+1,t,2)}function n_(n,t){return Bt(n.getMinutes(),t,2)}function i_(n,t){return Bt(n.getSeconds(),t,2)}function r_(n){var t=n.getDay();return t===0?7:t}function s_(n,t){return Bt(Ei.count(En(n)-1,n),t,2)}function em(n){var t=n.getDay();return t>=4||t===0?Gn(n):Gn.ceil(n)}function o_(n,t){return n=em(n),Bt(Gn.count(En(n),n)+(En(n).getDay()===4),t,2)}function a_(n){return n.getDay()}function l_(n,t){return Bt(sr.count(En(n)-1,n),t,2)}function c_(n,t){return Bt(n.getFullYear()%100,t,2)}function u_(n,t){return n=em(n),Bt(n.getFullYear()%100,t,2)}function h_(n,t){return Bt(n.getFullYear()%1e4,t,4)}function f_(n,t){var e=n.getDay();return n=e>=4||e===0?Gn(n):Gn.ceil(n),Bt(n.getFullYear()%1e4,t,4)}function d_(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Bt(t/60|0,"0",2)+Bt(t%60,"0",2)}function $p(n,t){return Bt(n.getUTCDate(),t,2)}function p_(n,t){return Bt(n.getUTCHours(),t,2)}function m_(n,t){return Bt(n.getUTCHours()%12||12,t,2)}function g_(n,t){return Bt(1+pa.count(Ai(n),n),t,3)}function nm(n,t){return Bt(n.getUTCMilliseconds(),t,3)}function x_(n,t){return nm(n,t)+"000"}function y_(n,t){return Bt(n.getUTCMonth()+1,t,2)}function v_(n,t){return Bt(n.getUTCMinutes(),t,2)}function __(n,t){return Bt(n.getUTCSeconds(),t,2)}function w_(n){var t=n.getUTCDay();return t===0?7:t}function M_(n,t){return Bt(As.count(Ai(n)-1,n),t,2)}function im(n){var t=n.getUTCDay();return t>=4||t===0?Wn(n):Wn.ceil(n)}function b_(n,t){return n=im(n),Bt(Wn.count(Ai(n),n)+(Ai(n).getUTCDay()===4),t,2)}function S_(n){return n.getUTCDay()}function E_(n,t){return Bt(or.count(Ai(n)-1,n),t,2)}function T_(n,t){return Bt(n.getUTCFullYear()%100,t,2)}function A_(n,t){return n=im(n),Bt(n.getUTCFullYear()%100,t,2)}function C_(n,t){return Bt(n.getUTCFullYear()%1e4,t,4)}function R_(n,t){var e=n.getUTCDay();return n=e>=4||e===0?Wn(n):Wn.ceil(n),Bt(n.getUTCFullYear()%1e4,t,4)}function L_(){return"+0000"}function Kp(){return"%"}function Qp(n){return+n}function jp(n){return Math.floor(+n/1e3)}var ar,ma,rm,sm,om;zc({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function zc(n){return ar=Fc(n),ma=ar.format,rm=ar.parse,sm=ar.utcFormat,om=ar.utcParse,ar}var Ps=1e3,Ds=Ps*60,Is=Ds*60,Ns=Is*24,P_=Ns*7,am=Ns*30,Uc=Ns*365;function D_(n){return new Date(n)}function I_(n){return n instanceof Date?+n:+new Date(+n)}function Bc(n,t,e,i,r,s,o,a,l){var c=Es(De,De),u=c.invert,h=c.domain,f=l(".%L"),d=l(":%S"),g=l("%I:%M"),x=l("%I %p"),v=l("%a %d"),m=l("%b %d"),p=l("%B"),b=l("%Y"),_=[[o,1,Ps],[o,5,5*Ps],[o,15,15*Ps],[o,30,30*Ps],[s,1,Ds],[s,5,5*Ds],[s,15,15*Ds],[s,30,30*Ds],[r,1,Is],[r,3,3*Is],[r,6,6*Is],[r,12,12*Is],[i,1,Ns],[i,2,2*Ns],[e,1,P_],[t,1,am],[t,3,3*am],[n,1,Uc]];function S(A){return(o(A)<A?f:s(A)<A?d:r(A)<A?g:i(A)<A?x:t(A)<A?e(A)<A?v:m:n(A)<A?p:b)(A)}function L(A,H,tt,X){if(A==null&&(A=10),typeof A=="number"){var y=Math.abs(tt-H)/A,R=is(function(D){return D[2]}).right(_,y);R===_.length?(X=_n(H/Uc,tt/Uc,A),A=n):R?(R=_[y/_[R-1][2]<_[R][2]/y?R-1:R],X=R[1],A=R[0]):(X=Math.max(_n(H,tt,A),1),A=a)}return X==null?A:A.every(X)}return c.invert=function(A){return new Date(u(A))},c.domain=function(A){return arguments.length?h(bs.call(A,I_)):h().map(D_)},c.ticks=function(A,H){var tt=h(),X=tt[0],y=tt[tt.length-1],R=y<X,D;return R&&(D=X,X=y,y=D),D=L(A,X,y,H),D=D?D.range(X,y+1):[],R?D.reverse():D},c.tickFormat=function(A,H){return H==null?S:l(H)},c.nice=function(A,H){var tt=h();return(A=L(A,tt[0],tt[tt.length-1],H))?h(la(tt,A)):c},c.copy=function(){return Vn(c,Bc(n,t,e,i,r,s,o,a,l))},c}function Fs(){return Pe.apply(Bc(En,Lc,Ei,rr,Rc,Cc,da,ua,ma).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Oc(){this._=null}function lr(n){n.U=n.C=n.L=n.R=n.P=n.N=null}Oc.prototype={constructor:Oc,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=cm(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)i=e.U,e===i.L?(r=i.R,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(zs(this,e),n=e,e=n.U),e.C=!1,i.C=!0,Us(this,i))):(r=i.L,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(Us(this,e),n=e,e=n.U),e.C=!1,i.C=!0,zs(this,i))),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var t=n.U,e,i=n.L,r=n.R,s,o;if(i?r?s=cm(r):s=i:s=r,t?t.L===n?t.L=s:t.R=s:this._=s,i&&r?(o=s.C,s.C=n.C,s.L=i,i.U=s,s!==r?(t=s.U,s.U=n.U,n=s.R,t.L=n,s.R=r,r.U=s):(s.U=t,t=s,n=s.R)):(o=n.C,n=s),n&&(n.U=t),!o){if(n&&n.C){n.C=!1;return}do{if(n===this._)break;if(n===t.L){if(e=t.R,e.C&&(e.C=!1,t.C=!0,zs(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,Us(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,zs(this,t),n=this._;break}}else if(e=t.L,e.C&&(e.C=!1,t.C=!0,Us(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,zs(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,Us(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};function zs(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function Us(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function cm(n){for(;n.L;)n=n.L;return n}var kc=Oc;function cr(n,t,e,i){var r=[null,null],s=me.push(r)-1;return r.left=n,r.right=t,e&&Bs(r,n,t,e),i&&Bs(r,t,n,i),Ce[n.index].halfedges.push(s),Ce[t.index].halfedges.push(s),r}function ur(n,t,e){var i=[t,e];return i.left=n,i}function Bs(n,t,e,i){!n[0]&&!n[1]?(n[0]=i,n.left=t,n.right=e):n.left===e?n[1]=i:n[0]=i}function z_(n,t,e,i,r){var s=n[0],o=n[1],a=s[0],l=s[1],c=o[0],u=o[1],h=0,f=1,d=c-a,g=u-l,x;if(x=t-a,!(!d&&x>0)){if(x/=d,d<0){if(x<h)return;x<f&&(f=x)}else if(d>0){if(x>f)return;x>h&&(h=x)}if(x=i-a,!(!d&&x<0)){if(x/=d,d<0){if(x>f)return;x>h&&(h=x)}else if(d>0){if(x<h)return;x<f&&(f=x)}if(x=e-l,!(!g&&x>0)){if(x/=g,g<0){if(x<h)return;x<f&&(f=x)}else if(g>0){if(x>f)return;x>h&&(h=x)}if(x=r-l,!(!g&&x<0)){if(x/=g,g<0){if(x>f)return;x>h&&(h=x)}else if(g>0){if(x<h)return;x<f&&(f=x)}return!(h>0)&&!(f<1)||(h>0&&(n[0]=[a+h*d,l+h*g]),f<1&&(n[1]=[a+f*d,l+f*g])),!0}}}}}function U_(n,t,e,i,r){var s=n[1];if(s)return!0;var o=n[0],a=n.left,l=n.right,c=a[0],u=a[1],h=l[0],f=l[1],d=(c+h)/2,g=(u+f)/2,x,v;if(f===u){if(d<t||d>=i)return;if(c>h){if(!o)o=[d,e];else if(o[1]>=r)return;s=[d,r]}else{if(!o)o=[d,r];else if(o[1]<e)return;s=[d,e]}}else if(x=(c-h)/(f-u),v=g-x*d,x<-1||x>1)if(c>h){if(!o)o=[(e-v)/x,e];else if(o[1]>=r)return;s=[(r-v)/x,r]}else{if(!o)o=[(r-v)/x,r];else if(o[1]<e)return;s=[(e-v)/x,e]}else if(u<f){if(!o)o=[t,x*t+v];else if(o[0]>=i)return;s=[i,x*i+v]}else{if(!o)o=[i,x*i+v];else if(o[0]<t)return;s=[t,x*t+v]}return n[0]=o,n[1]=s,!0}function um(n,t,e,i){for(var r=me.length,s;r--;)(!U_(s=me[r],n,t,e,i)||!z_(s,n,t,e,i)||!(Math.abs(s[0][0]-s[1][0])>Xt||Math.abs(s[0][1]-s[1][1])>Xt))&&delete me[r]}function hm(n){return Ce[n.index]={site:n,halfedges:[]}}function B_(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function Hc(n,t){return t[+(t.left!==n.site)]}function O_(n,t){return t[+(t.left===n.site)]}function fm(){for(var n=0,t=Ce.length,e,i,r,s;n<t;++n)if((e=Ce[n])&&(s=(i=e.halfedges).length)){var o=new Array(s),a=new Array(s);for(r=0;r<s;++r)o[r]=r,a[r]=B_(e,me[i[r]]);for(o.sort(function(l,c){return a[c]-a[l]}),r=0;r<s;++r)a[r]=i[o[r]];for(r=0;r<s;++r)i[r]=a[r]}}function dm(n,t,e,i){var r=Ce.length,s,o,a,l,c,u,h,f,d,g,x,v,m=!0;for(s=0;s<r;++s)if(o=Ce[s]){for(a=o.site,c=o.halfedges,l=c.length;l--;)me[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)g=O_(o,me[c[l]]),x=g[0],v=g[1],h=Hc(o,me[c[++l%u]]),f=h[0],d=h[1],(Math.abs(x-f)>Xt||Math.abs(v-d)>Xt)&&(c.splice(l,0,me.push(ur(a,g,Math.abs(x-n)<Xt&&i-v>Xt?[n,Math.abs(f-n)<Xt?d:i]:Math.abs(v-i)<Xt&&e-x>Xt?[Math.abs(d-i)<Xt?f:e,i]:Math.abs(x-e)<Xt&&v-t>Xt?[e,Math.abs(f-e)<Xt?d:t]:Math.abs(v-t)<Xt&&x-n>Xt?[Math.abs(d-t)<Xt?f:n,t]:null))-1),++u);u&&(m=!1)}if(m){var p,b,_,S=1/0;for(s=0,m=null;s<r;++s)(o=Ce[s])&&(a=o.site,p=a[0]-n,b=a[1]-t,_=p*p+b*b,_<S&&(S=_,m=o));if(m){var L=[n,t],A=[n,i],H=[e,i],tt=[e,t];m.halfedges.push(me.push(ur(a=m.site,L,A))-1,me.push(ur(a,A,H))-1,me.push(ur(a,H,tt))-1,me.push(ur(a,tt,L))-1)}}for(s=0;s<r;++s)(o=Ce[s])&&(o.halfedges.length||delete Ce[s])}var pm=[],ga;function k_(){lr(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ci(n){var t=n.P,e=n.N;if(!(!t||!e)){var i=t.site,r=n.site,s=e.site;if(i!==s){var o=r[0],a=r[1],l=i[0]-o,c=i[1]-a,u=s[0]-o,h=s[1]-a,f=2*(l*h-c*u);if(!(f>=-mm)){var d=l*l+c*c,g=u*u+h*h,x=(h*d-c*g)/f,v=(l*g-u*d)/f,m=pm.pop()||new k_;m.arc=n,m.site=r,m.x=x+o,m.y=(m.cy=v+a)+Math.sqrt(x*x+v*v),n.circle=m;for(var p=null,b=hr._;b;)if(m.y<b.y||m.y===b.y&&m.x<=b.x)if(b.L)b=b.L;else{p=b.P;break}else if(b.R)b=b.R;else{p=b;break}hr.insert(p,m),p||(ga=m)}}}}function Ri(n){var t=n.circle;t&&(t.P||(ga=t.N),hr.remove(t),pm.push(t),lr(t),n.circle=null)}var xm=[];function H_(){lr(this),this.edge=this.site=this.circle=null}function gm(n){var t=xm.pop()||new H_;return t.site=n,t}function Vc(n){Ri(n),Li.remove(n),xm.push(n),lr(n)}function ym(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],s=n.P,o=n.N,a=[n];Vc(n);for(var l=s;l.circle&&Math.abs(e-l.circle.x)<Xt&&Math.abs(i-l.circle.cy)<Xt;)s=l.P,a.unshift(l),Vc(l),l=s;a.unshift(l),Ri(l);for(var c=o;c.circle&&Math.abs(e-c.circle.x)<Xt&&Math.abs(i-c.circle.cy)<Xt;)o=c.N,a.push(c),Vc(c),c=o;a.push(c),Ri(c);var u=a.length,h;for(h=1;h<u;++h)c=a[h],l=a[h-1],Bs(c.edge,l.site,c.site,r);l=a[0],c=a[u-1],c.edge=cr(l.site,c.site,null,r),Ci(l),Ci(c)}function vm(n){for(var t=n[0],e=n[1],i,r,s,o,a=Li._;a;)if(s=_m(a,e)-t,s>Xt)a=a.L;else if(o=t-V_(a,e),o>Xt){if(!a.R){i=a;break}a=a.R}else{s>-Xt?(i=a.P,r=a):o>-Xt?(i=a,r=a.N):i=r=a;break}hm(n);var l=gm(n);if(Li.insert(i,l),!(!i&&!r)){if(i===r){Ri(i),r=gm(i.site),Li.insert(l,r),l.edge=r.edge=cr(i.site,l.site),Ci(i),Ci(r);return}if(!r){l.edge=cr(i.site,l.site);return}Ri(i),Ri(r);var c=i.site,u=c[0],h=c[1],f=n[0]-u,d=n[1]-h,g=r.site,x=g[0]-u,v=g[1]-h,m=2*(f*v-d*x),p=f*f+d*d,b=x*x+v*v,_=[(v*p-d*b)/m+u,(f*b-x*p)/m+h];Bs(r.edge,c,g,_),l.edge=cr(c,n,null,_),r.edge=cr(n,g,null,_),Ci(i),Ci(r)}}function _m(n,t){var e=n.site,i=e[0],r=e[1],s=r-t;if(!s)return i;var o=n.P;if(!o)return-1/0;e=o.site;var a=e[0],l=e[1],c=l-t;if(!c)return a;var u=a-i,h=1/s-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+r-s/2)))/h+i:(i+a)/2}function V_(n,t){var e=n.N;if(e)return _m(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var Xt=1e-6,mm=1e-12,Li,Ce,hr,me;function G_(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function W_(n,t){return t[1]-n[1]||t[0]-n[0]}function xa(n,t){var e=n.sort(W_).pop(),i,r,s;for(me=[],Ce=new Array(n.length),Li=new kc,hr=new kc;;)if(s=ga,e&&(!s||e[1]<s.y||e[1]===s.y&&e[0]<s.x))(e[0]!==i||e[1]!==r)&&(vm(e),i=e[0],r=e[1]),e=n.pop();else if(s)ym(s.arc);else break;if(fm(),t){var o=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];um(o,a,l,c),dm(o,a,l,c)}this.edges=me,this.cells=Ce,Li=hr=me=Ce=null}xa.prototype={constructor:xa,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return Hc(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(!!(a=(s=e.halfedges).length))for(var r=e.site,s,o=-1,a,l,c=t[s[a-1]],u=c.left===r?c.right:c.left;++o<a;)l=u,c=t[s[o]],u=c.left===r?c.right:c.left,l&&u&&i<l.index&&i<u.index&&G_(r,l,u)<0&&n.push([r.data,l.data,u.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var i=this,r,s=i._found||0,o=i.cells.length,a;!(a=i.cells[s]);)if(++s>=o)return null;var l=n-a.site[0],c=t-a.site[1],u=l*l+c*c;do a=i.cells[r=s],s=null,a.halfedges.forEach(function(h){var f=i.edges[h],d=f.left;if(!((d===a.site||!d)&&!(d=f.right))){var g=n-d[0],x=t-d[1],v=g*g+x*x;v<u&&(u=v,s=d.index)}});while(s!==null);return i._found=r,e==null||u<=e*e?a.site:null}};function Pi(n,t,e){this.k=n,this.x=t,this.y=e}Pi.prototype={constructor:Pi,scale:function(n){return n===1?this:new Pi(this.k*n,this.x,this.y)},translate:function(n,t){return n===0&t===0?this:new Pi(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Gc=new Pi(1,0,0);Wc.prototype=Pi.prototype;function Wc(n){for(;!n.__zoom;)if(!(n=n.parentNode))return Gc;return n.__zoom}var bm=1e4,Sm=.001,Em=Oe(".2~e"),q_=Oe(".4~r"),wm=Oe(",~");function Mm(n){if(n===0)return"0";let t=Math.abs(n);return t>=bm||t<Sm?Em(n):q_(n)}var Xc={formatTick:Mm,formatShort:Mm,formatReadable(n){let t=Math.abs(n);return t>=bm||t<Sm?Em(n):wm(n)},formatLong:wm},sk=new Intl.NumberFormat(void 0,{maximumFractionDigits:4});var ok=Oe("0.3~s"),ak=Oe(",.3~f");var X_=1e3,Y_=60*X_,Z_=60*Y_,J_=24*Z_,lk=365*J_,ck=Oe(".4~");var $_=Fs().tickFormat(),qc,Tm={formatTick(n){return $_(new Date(n))},formatShort(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};function fr(n){switch(n){case on.LINEAR:return new Yc;case on.LOG10:return new Zc;case on.TIME:return new Jc;default:let t=n;throw new RangeError(`ScaleType ${t} not supported.`)}}var K_=.05,Yc=class{constructor(){this.defaultFormatter=Xc}transform(t,e,i){let[r,s]=t,o=s-r,[a,l]=e,c=l-a;return o===0?a:c/o*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return e===0?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=ir(),s=(i-e+Number.EPSILON)*K_,[o,a]=r.domain([e-s,i+s]).nice().domain();return[o,a]}ticks(t,e){return ir().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},Zc=class{constructor(){this.defaultFormatter=Xc}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o;return i=this.transform(i),h/(u+Number.EPSILON)*(i-l)+o}reverse(t,e,i){let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o,f=u/(h+Number.EPSILON)*(i-o)+l;return this.untransform(f)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),s=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,r*.5),s*2]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],s=Ts().domain([i,r]).ticks(e);return s.length?s:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Jc=class{constructor(){this.scale=Fs(),this.defaultFormatter=Tm}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}};function Q_(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}}var $c=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{$c=!1});let t=n.getContext("webgl2");$c=Boolean(t)}function j_(){return $c}function tw(){if(!self.hasOwnProperty("OffscreenCanvas"))return!1;let n=new OffscreenCanvas(0,0).getContext("webgl2");return Boolean(n)}function ew(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0}function nw(n,t){return n.x[0]===t.x[0]&&n.x[1]===t.x[1]&&n.y[0]===t.y[0]&&n.y[1]===t.y[1]}var Di={convertRectToExtent:Q_,isWebGl2Supported:j_,isWebGl2OffscreenCanvasSupported:tw,arePolylinesEqual:ew,areExtentsEqual:nw};var dr=class{constructor(){this.xScale=fr(on.LINEAR),this.yScale=fr(on.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Di.convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};var Tn;(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"})(Tn||(Tn={}));function ya(n,t,e,i){let{color:r,visible:s,opacity:o}=i,a=n;return!a&&!s?null:(a=a!=null?a:t(),a=e(a),a.style.display=s?"":"none",a.style.stroke=r,a.style.opacity=String(o!=null?o:1),a)}var Os=class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[i*2]},${t[i*2+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=ya(t==null?void 0:t.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","path");s.style.fill="none";let o=this.createPathDString(e);return s.setAttribute("d",o),this.svg.appendChild(s),s},s=>{if(!(t!=null&&t.data)||!Di.arePolylinesEqual(e,t==null?void 0:t.data)){let o=this.createPathDString(e);s.setAttribute("d",o)}return s},i);return r===null?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:s}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+o/3,e.x+r/2,e.y+o/3,e.x,e.y-o*2/3]),l=ya(t==null?void 0:t.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),this.svg.appendChild(c),c},c=>{let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),c},i);return l===null?null:(l.style.fill=s,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:s}=i,o=ya(t==null?void 0:t.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),a),i);return o===null?null:{dom:o,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s,color:o}=r,a=2/Math.sqrt(3)*s,l=new Float32Array([e.x-a/2,e.y+s/2,e.x,e.y-s/2,i.x,i.y-s/2,i.x+a/2,i.y+s/2]),c=ya(t==null?void 0:t.dom,()=>{let u=document.createElementNS("http://www.w3.org/2000/svg","path");u.classList.add("trapezoid"),u.style.fill="none";let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),this.svg.appendChild(u),u},u=>{let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),u},r);return c===null?null:(c.style.fill=o,{dom:c,data:l})}dispose(){}};var $h="137";var iw=0,Am=1,rw=2;var l0=1,sw=2,Js=3,eo=0,he=1,Hr=2,c0=1;var jn=0,Ks=1,Cm=2,Rm=3,Lm=4,ow=5,Ir=100,aw=101,lw=102,Pm=103,Dm=104,cw=200,uw=201,hw=202,fw=203,u0=204,h0=205,dw=206,pw=207,mw=208,gw=209,xw=210,yw=0,vw=1,_w=2,zu=3,ww=4,Mw=5,bw=6,Sw=7,Cl=0,Ew=1,Tw=2,ti=0,Aw=1,Cw=2,Rw=3,Lw=4,Pw=5,f0=300,Ao=301,Co=302,Uu=303,Bu=304,Rl=306,Kh=307,Ou=1e3,Ve=1001,ku=1002,fe=1003,Im=1004;var Nm=1005;var be=1006,Dw=1007;var Ll=1008;var ei=1009,Iw=1010,Nw=1011,no=1012,Fw=1013,Qa=1014,Ui=1015,Ur=1016,zw=1017,Uw=1018,Br=1020,Bw=1021,Re=1023,Ow=1024,kw=1025,Oi=1026,Vr=1027,Hw=1028,Vw=1029,Gw=1030,Ww=1031,qw=1033,Kc=33776,Qc=33777,jc=33778,tu=33779,Fm=35840,zm=35841,Um=35842,Bm=35843,Xw=36196,Om=37492,km=37496,Hm=37808,Vm=37809,Gm=37810,Wm=37811,qm=37812,Xm=37813,Ym=37814,Zm=37815,Jm=37816,$m=37817,Km=37818,Qm=37819,jm=37820,tg=37821,eg=36492,Yw=2200,Zw=2201,Jw=2202,ja=2300,tl=2301,eu=2302,Nr=2400,Fr=2401,el=2402,Qh=2500,d0=2501,$w=0;var ri=3e3,$t=3001,Kw=3200,Qw=3201,ts=0,jw=1;var nu=7680;var tM=519,io=35044,nl=35048;var ng="300 es",Hu=1035,In=class{addEventListener(t,e){this._listeners===void 0&&(this._listeners={});let i=this._listeners;i[t]===void 0&&(i[t]=[]),i[t].indexOf(e)===-1&&i[t].push(e)}hasEventListener(t,e){if(this._listeners===void 0)return!1;let i=this._listeners;return i[t]!==void 0&&i[t].indexOf(e)!==-1}removeEventListener(t,e){if(this._listeners===void 0)return;let r=this._listeners[t];if(r!==void 0){let s=r.indexOf(e);s!==-1&&r.splice(s,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let i=this._listeners[t.type];if(i!==void 0){t.target=this;let r=i.slice(0);for(let s=0,o=r.length;s<o;s++)r[s].call(this,t);t.target=null}}},ve=[];for(let n=0;n<256;n++)ve[n]=(n<16?"0":"")+n.toString(16);var iu=Math.PI/180,Vu=180/Math.PI;function tn(){let n=Math.random()*4294967295|0,t=Math.random()*4294967295|0,e=Math.random()*4294967295|0,i=Math.random()*4294967295|0;return(ve[n&255]+ve[n>>8&255]+ve[n>>16&255]+ve[n>>24&255]+"-"+ve[t&255]+ve[t>>8&255]+"-"+ve[t>>16&15|64]+ve[t>>24&255]+"-"+ve[e&63|128]+ve[e>>8&255]+"-"+ve[e>>16&255]+ve[e>>24&255]+ve[i&255]+ve[i>>8&255]+ve[i>>16&255]+ve[i>>24&255]).toUpperCase()}function Ie(n,t,e){return Math.max(t,Math.min(e,n))}function eM(n,t){return(n%t+t)%t}function ru(n,t,e){return(1-e)*n+e*t}function ig(n){return(n&n-1)===0&&n!==0}function nM(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var K=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),s=this.x-t.x,o=this.y-t.y;return this.x=s*i-o*r+t.x,this.y=s*r+o*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};K.prototype.isVector2=!0;var de=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c){let u=this.elements;return u[0]=t,u[1]=r,u[2]=a,u[3]=e,u[4]=s,u[5]=l,u[6]=i,u[7]=o,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[3],l=i[6],c=i[1],u=i[4],h=i[7],f=i[2],d=i[5],g=i[8],x=r[0],v=r[3],m=r[6],p=r[1],b=r[4],_=r[7],S=r[2],L=r[5],A=r[8];return s[0]=o*x+a*p+l*S,s[3]=o*v+a*b+l*L,s[6]=o*m+a*_+l*A,s[1]=c*x+u*p+h*S,s[4]=c*v+u*b+h*L,s[7]=c*m+u*_+h*A,s[2]=f*x+d*p+g*S,s[5]=f*v+d*b+g*L,s[8]=f*m+d*_+g*A,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8];return e*o*u-e*a*c-i*s*u+i*a*l+r*s*c-r*o*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=u*o-a*c,f=a*l-u*s,d=c*s-o*l,g=e*h+i*f+r*d;if(g===0)return this.set(0,0,0,0,0,0,0,0,0);let x=1/g;return t[0]=h*x,t[1]=(r*c-u*i)*x,t[2]=(a*i-r*o)*x,t[3]=f*x,t[4]=(u*e-r*l)*x,t[5]=(r*s-a*e)*x,t[6]=d*x,t[7]=(i*l-c*e)*x,t[8]=(o*e-i*s)*x,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,s,o,a){let l=Math.cos(s),c=Math.sin(s);return this.set(i*l,i*c,-i*(l*o+c*a)+o+t,-r*c,r*l,-r*(-c*o+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,s=r[0],o=r[3],a=r[6],l=r[1],c=r[4],u=r[7];return r[0]=e*s+i*l,r[3]=e*o+i*c,r[6]=e*a+i*u,r[1]=-i*s+e*l,r[4]=-i*o+e*c,r[7]=-i*a+e*u,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return new this.constructor().fromArray(this.elements)}};de.prototype.isMatrix3=!0;function p0(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function ro(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}var m0={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},$e={h:0,s:0,l:0},va={h:0,s:0,l:0};function su(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+(t-n)*6*e:e<1/2?t:e<2/3?n+(t-n)*6*(2/3-e):n}function Or(n){return n<.04045?n*.0773993808:Math.pow(n*.9478672986+.0521327014,2.4)}function ou(n){return n<.0031308?n*12.92:1.055*Math.pow(n,.41666)-.055}var ft=class{constructor(t,e,i){return e===void 0&&i===void 0?this.set(t):this.setRGB(t,e,i)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,e,i){return this.r=t,this.g=e,this.b=i,this}setHSL(t,e,i){if(t=eM(t,1),e=Ie(e,0,1),i=Ie(i,0,1),e===0)this.r=this.g=this.b=i;else{let r=i<=.5?i*(1+e):i+e-i*e,s=2*i-r;this.r=su(s,r,t+1/3),this.g=su(s,r,t),this.b=su(s,r,t-1/3)}return this}setStyle(t){function e(r){r!==void 0&&parseFloat(r)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let i;if(i=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let r,s=i[1],o=i[2];switch(s){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(255,parseInt(r[1],10))/255,this.g=Math.min(255,parseInt(r[2],10))/255,this.b=Math.min(255,parseInt(r[3],10))/255,e(r[4]),this;if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(100,parseInt(r[1],10))/100,this.g=Math.min(100,parseInt(r[2],10))/100,this.b=Math.min(100,parseInt(r[3],10))/100,e(r[4]),this;break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o)){let a=parseFloat(r[1])/360,l=parseInt(r[2],10)/100,c=parseInt(r[3],10)/100;return e(r[4]),this.setHSL(a,l,c)}break}}else if(i=/^\#([A-Fa-f\d]+)$/.exec(t)){let r=i[1],s=r.length;if(s===3)return this.r=parseInt(r.charAt(0)+r.charAt(0),16)/255,this.g=parseInt(r.charAt(1)+r.charAt(1),16)/255,this.b=parseInt(r.charAt(2)+r.charAt(2),16)/255,this;if(s===6)return this.r=parseInt(r.charAt(0)+r.charAt(1),16)/255,this.g=parseInt(r.charAt(2)+r.charAt(3),16)/255,this.b=parseInt(r.charAt(4)+r.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let e=m0[t.toLowerCase()];return e!==void 0?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Or(t.r),this.g=Or(t.g),this.b=Or(t.b),this}copyLinearToSRGB(t){return this.r=ou(t.r),this.g=ou(t.g),this.b=ou(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let e=this.r,i=this.g,r=this.b,s=Math.max(e,i,r),o=Math.min(e,i,r),a,l,c=(o+s)/2;if(o===s)a=0,l=0;else{let u=s-o;switch(l=c<=.5?u/(s+o):u/(2-s-o),s){case e:a=(i-r)/u+(i<r?6:0);break;case i:a=(r-e)/u+2;break;case r:a=(e-i)/u+4;break}a/=6}return t.h=a,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,e,i){return this.getHSL($e),$e.h+=t,$e.s+=e,$e.l+=i,this.setHSL($e.h,$e.s,$e.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,e){return this.r=t.r+e.r,this.g=t.g+e.g,this.b=t.b+e.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,e){return this.r+=(t.r-this.r)*e,this.g+=(t.g-this.g)*e,this.b+=(t.b-this.b)*e,this}lerpColors(t,e,i){return this.r=t.r+(e.r-t.r)*i,this.g=t.g+(e.g-t.g)*i,this.b=t.b+(e.b-t.b)*i,this}lerpHSL(t,e){this.getHSL($e),t.getHSL(va);let i=ru($e.h,va.h,e),r=ru($e.s,va.s,e),s=ru($e.l,va.l,e);return this.setHSL(i,r,s),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,e=0){return this.r=t[e],this.g=t[e+1],this.b=t[e+2],this}toArray(t=[],e=0){return t[e]=this.r,t[e+1]=this.g,t[e+2]=this.b,t}fromBufferAttribute(t,e){return this.r=t.getX(e),this.g=t.getY(e),this.b=t.getZ(e),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ft.NAMES=m0;ft.prototype.isColor=!0;ft.prototype.r=1;ft.prototype.g=1;ft.prototype.b=1;var pr,Nn=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{pr===void 0&&(pr=ro("canvas")),pr.width=t.width,pr.height=t.height;let i=pr.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=pr}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let e=ro("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),s=r.data;for(let o=0;o<s.length;o++)s[o]=Or(s[o]/255)*255;return i.putImageData(r,0,0),e}else if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e instanceof Uint8Array||e instanceof Uint8ClampedArray?e[i]=Math.floor(Or(e[i]/255)*255):e[i]=Or(e[i]);return{data:e,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},iM=0,ae=class extends In{constructor(t=ae.DEFAULT_IMAGE,e=ae.DEFAULT_MAPPING,i=Ve,r=Ve,s=be,o=Ll,a=Re,l=ei,c=1,u=ri){super(),Object.defineProperty(this,"id",{value:iM++}),this.uuid=tn(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=s,this.minFilter=o,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new K(0,0),this.repeat=new K(1,1),this.center=new K(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new de,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=t===void 0||typeof t=="string";if(!e&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let r=this.image;if(r.uuid===void 0&&(r.uuid=tn()),!e&&t.images[r.uuid]===void 0){let s;if(Array.isArray(r)){s=[];for(let o=0,a=r.length;o<a;o++)r[o].isDataTexture?s.push(au(r[o].image)):s.push(au(r[o]))}else s=au(r);t.images[r.uuid]={uuid:r.uuid,url:s}}i.image=r.uuid}return JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==f0)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case Ou:t.x=t.x-Math.floor(t.x);break;case Ve:t.x=t.x<0?0:1;break;case ku:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case Ou:t.y=t.y-Math.floor(t.y);break;case Ve:t.y=t.y<0?0:1;break;case ku:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};ae.DEFAULT_IMAGE=void 0;ae.DEFAULT_MAPPING=f0;ae.prototype.isTexture=!0;function au(n){return typeof HTMLImageElement!="undefined"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&n instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&n instanceof ImageBitmap?Nn.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var Wt=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=this.w,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r+o[12]*s,this.y=o[1]*e+o[5]*i+o[9]*r+o[13]*s,this.z=o[2]*e+o[6]*i+o[10]*r+o[14]*s,this.w=o[3]*e+o[7]*i+o[11]*r+o[15]*s,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,s,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],d=l[5],g=l[9],x=l[2],v=l[6],m=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-x)<.01&&Math.abs(g-v)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+x)<.1&&Math.abs(g+v)<.1&&Math.abs(c+d+m-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let b=(c+1)/2,_=(d+1)/2,S=(m+1)/2,L=(u+f)/4,A=(h+x)/4,H=(g+v)/4;return b>_&&b>S?b<.01?(i=0,r=.707106781,s=.707106781):(i=Math.sqrt(b),r=L/i,s=A/i):_>S?_<.01?(i=.707106781,r=0,s=.707106781):(r=Math.sqrt(_),i=L/r,s=H/r):S<.01?(i=.707106781,r=.707106781,s=0):(s=Math.sqrt(S),i=A/s,r=H/s),this.set(i,r,s,e),this}let p=Math.sqrt((v-g)*(v-g)+(h-x)*(h-x)+(f-u)*(f-u));return Math.abs(p)<.001&&(p=1),this.x=(v-g)/p,this.y=(h-x)/p,this.z=(f-u)/p,this.w=Math.acos((c+d+m-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Wt.prototype.isVector4=!0;var Ne=class extends In{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Wt(0,0,t,e),this.scissorTest=!1,this.viewport=new Wt(0,0,t,e),this.texture=new ae(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=i.generateMipmaps!==void 0?i.generateMipmaps:!1,this.texture.internalFormat=i.internalFormat!==void 0?i.internalFormat:null,this.texture.minFilter=i.minFilter!==void 0?i.minFilter:be,this.depthBuffer=i.depthBuffer!==void 0?i.depthBuffer:!0,this.stencilBuffer=i.stencilBuffer!==void 0?i.stencilBuffer:!1,this.depthTexture=i.depthTexture!==void 0?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Ne.prototype.isWebGLRenderTarget=!0;var Gu=class extends Ne{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let s=0;s<i;s++)this.texture[s]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,s=this.texture.length;r<s;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}};Gu.prototype.isWebGLMultipleRenderTargets=!0;var so=class extends Ne{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=i.ignoreDepth!==void 0?i.ignoreDepth:!0,this.useRenderToTexture=i.useRenderToTexture!==void 0?i.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};so.prototype.isWebGLMultisampleRenderTarget=!0;var Ee=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,s,o,a){let l=i[r+0],c=i[r+1],u=i[r+2],h=i[r+3],f=s[o+0],d=s[o+1],g=s[o+2],x=s[o+3];if(a===0){t[e+0]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h;return}if(a===1){t[e+0]=f,t[e+1]=d,t[e+2]=g,t[e+3]=x;return}if(h!==x||l!==f||c!==d||u!==g){let v=1-a,m=l*f+c*d+u*g+h*x,p=m>=0?1:-1,b=1-m*m;if(b>Number.EPSILON){let S=Math.sqrt(b),L=Math.atan2(S,m*p);v=Math.sin(v*L)/S,a=Math.sin(a*L)/S}let _=a*p;if(l=l*v+f*_,c=c*v+d*_,u=u*v+g*_,h=h*v+x*_,v===1-a){let S=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=S,c*=S,u*=S,h*=S}}t[e]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h}static multiplyQuaternionsFlat(t,e,i,r,s,o){let a=i[r],l=i[r+1],c=i[r+2],u=i[r+3],h=s[o],f=s[o+1],d=s[o+2],g=s[o+3];return t[e]=a*g+u*h+l*d-c*f,t[e+1]=l*g+u*f+c*h-a*d,t[e+2]=c*g+u*d+a*f-l*h,t[e+3]=u*g-a*h-l*f-c*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,s=t._z,o=t._order,a=Math.cos,l=Math.sin,c=a(i/2),u=a(r/2),h=a(s/2),f=l(i/2),d=l(r/2),g=l(s/2);switch(o){case"XYZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"YXZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"ZXY":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"ZYX":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"YZX":this._x=f*u*h+c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h-f*d*g;break;case"XZY":this._x=f*u*h-c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h+f*d*g;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+o)}return e!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],s=e[8],o=e[1],a=e[5],l=e[9],c=e[2],u=e[6],h=e[10],f=i+a+h;if(f>0){let d=.5/Math.sqrt(f+1);this._w=.25/d,this._x=(u-l)*d,this._y=(s-c)*d,this._z=(o-r)*d}else if(i>a&&i>h){let d=2*Math.sqrt(1+i-a-h);this._w=(u-l)/d,this._x=.25*d,this._y=(r+o)/d,this._z=(s+c)/d}else if(a>h){let d=2*Math.sqrt(1+a-i-h);this._w=(s-c)/d,this._x=(r+o)/d,this._y=.25*d,this._z=(l+u)/d}else{let d=2*Math.sqrt(1+h-i-a);this._w=(o-r)/d,this._x=(s+c)/d,this._y=(l+u)/d,this._z=.25*d}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ie(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(i===0)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return e!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,s=t._z,o=t._w,a=e._x,l=e._y,c=e._z,u=e._w;return this._x=i*u+o*a+r*c-s*l,this._y=r*u+o*l+s*a-i*c,this._z=s*u+o*c+i*l-r*a,this._w=o*u-i*a-r*l-s*c,this._onChangeCallback(),this}slerp(t,e){if(e===0)return this;if(e===1)return this.copy(t);let i=this._x,r=this._y,s=this._z,o=this._w,a=o*t._w+i*t._x+r*t._y+s*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=o,this._x=i,this._y=r,this._z=s,this;let l=1-a*a;if(l<=Number.EPSILON){let d=1-e;return this._w=d*o+e*this._w,this._x=d*i+e*this._x,this._y=d*r+e*this._y,this._z=d*s+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,a),h=Math.sin((1-e)*u)/c,f=Math.sin(e*u)/c;return this._w=o*h+this._w*f,this._x=i*h+this._x*f,this._y=r*h+this._y*f,this._z=s*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),s=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(s),i*Math.cos(s),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Ee.prototype.isQuaternion=!0;var T=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return i===void 0&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(rg.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(rg.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[3]*i+s[6]*r,this.y=s[1]*e+s[4]*i+s[7]*r,this.z=s[2]*e+s[5]*i+s[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=t.elements,o=1/(s[3]*e+s[7]*i+s[11]*r+s[15]);return this.x=(s[0]*e+s[4]*i+s[8]*r+s[12])*o,this.y=(s[1]*e+s[5]*i+s[9]*r+s[13])*o,this.z=(s[2]*e+s[6]*i+s[10]*r+s[14])*o,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,s=t.x,o=t.y,a=t.z,l=t.w,c=l*e+o*r-a*i,u=l*i+a*e-s*r,h=l*r+s*i-o*e,f=-s*e-o*i-a*r;return this.x=c*l+f*-s+u*-a-h*-o,this.y=u*l+f*-o+h*-s-c*-a,this.z=h*l+f*-a+c*-o-u*-s,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r,this.y=s[1]*e+s[5]*i+s[9]*r,this.z=s[2]*e+s[6]*i+s[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return e!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,s=t.z,o=e.x,a=e.y,l=e.z;return this.x=r*l-s*a,this.y=s*o-i*l,this.z=i*a-r*o,this}projectOnVector(t){let e=t.lengthSq();if(e===0)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return lu.copy(this).projectOnVector(t),this.sub(lu)}reflect(t){return this.sub(lu.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(e===0)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ie(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,e*4)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,e*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,e=Math.random()*Math.PI*2,i=Math.sqrt(1-cf(t,2));return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};T.prototype.isVector3=!0;var lu=new T,rg=new Ee,Ge=class{constructor(t=new T(1/0,1/0,1/0),e=new T(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Ii.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(i!==void 0)if(e&&i.attributes!=null&&i.attributes.position!==void 0){let s=i.attributes.position;for(let o=0,a=s.count;o<a;o++)Ii.fromBufferAttribute(s,o).applyMatrix4(t.matrixWorld),this.expandByPoint(Ii)}else i.boundingBox===null&&i.computeBoundingBox(),cu.copy(i.boundingBox),cu.applyMatrix4(t.matrixWorld),this.union(cu);let r=t.children;for(let s=0,o=r.length;s<o;s++)this.expandByObject(r[s],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Ii),Ii.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ks),_a.subVectors(this.max,ks),mr.subVectors(t.a,ks),gr.subVectors(t.b,ks),xr.subVectors(t.c,ks),qn.subVectors(gr,mr),Xn.subVectors(xr,gr),Ni.subVectors(mr,xr);let e=[0,-qn.z,qn.y,0,-Xn.z,Xn.y,0,-Ni.z,Ni.y,qn.z,0,-qn.x,Xn.z,0,-Xn.x,Ni.z,0,-Ni.x,-qn.y,qn.x,0,-Xn.y,Xn.x,0,-Ni.y,Ni.x,0];return!uu(e,mr,gr,xr,_a)||(e=[1,0,0,0,1,0,0,0,1],!uu(e,mr,gr,xr,_a))?!1:(wa.crossVectors(qn,Xn),e=[wa.x,wa.y,wa.z],uu(e,mr,gr,xr,_a))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Ii.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(Ii).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(An[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),An[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),An[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),An[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),An[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),An[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),An[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),An[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(An),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Ge.prototype.isBox3=!0;var An=[new T,new T,new T,new T,new T,new T,new T,new T],Ii=new T,cu=new Ge,mr=new T,gr=new T,xr=new T,qn=new T,Xn=new T,Ni=new T,ks=new T,_a=new T,wa=new T,Fi=new T;function uu(n,t,e,i,r){for(let s=0,o=n.length-3;s<=o;s+=3){Fi.fromArray(n,s);let a=r.x*Math.abs(Fi.x)+r.y*Math.abs(Fi.y)+r.z*Math.abs(Fi.z),l=t.dot(Fi),c=e.dot(Fi),u=i.dot(Fi);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>a)return!1}return!0}var rM=new Ge,sg=new T,Ma=new T,hu=new T,si=class{constructor(t=new T,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;e!==void 0?i.copy(e):rM.setFromPoints(t).getCenter(i);let r=0;for(let s=0,o=t.length;s<o;s++)r=Math.max(r,i.distanceToSquared(t[s]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){hu.subVectors(t,this.center);let e=hu.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=(i-this.radius)*.5;this.center.add(hu.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return this.center.equals(t.center)===!0?Ma.set(0,0,1).multiplyScalar(t.radius):Ma.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(sg.copy(t.center).add(Ma)),this.expandByPoint(sg.copy(t.center).sub(Ma)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Cn=new T,fu=new T,ba=new T,Yn=new T,du=new T,Sa=new T,pu=new T,oi=class{constructor(t=new T,e=new T(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Cn)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Cn.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Cn.copy(this.direction).multiplyScalar(e).add(this.origin),Cn.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){fu.copy(t).add(e).multiplyScalar(.5),ba.copy(e).sub(t).normalize(),Yn.copy(this.origin).sub(fu);let s=t.distanceTo(e)*.5,o=-this.direction.dot(ba),a=Yn.dot(this.direction),l=-Yn.dot(ba),c=Yn.lengthSq(),u=Math.abs(1-o*o),h,f,d,g;if(u>0)if(h=o*l-a,f=o*a-l,g=s*u,h>=0)if(f>=-g)if(f<=g){let x=1/u;h*=x,f*=x,d=h*(h+o*f+2*a)+f*(o*h+f+2*l)+c}else f=s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f=-s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f<=-g?(h=Math.max(0,-(-o*s+a)),f=h>0?-s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c):f<=g?(h=0,f=Math.min(Math.max(-s,-l),s),d=f*(f+2*l)+c):(h=Math.max(0,-(o*s+a)),f=h>0?s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c);else f=o>0?-s:s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(h).add(this.origin),r&&r.copy(ba).multiplyScalar(f).add(fu),d}intersectSphere(t,e){Cn.subVectors(t.center,this.origin);let i=Cn.dot(this.direction),r=Cn.dot(Cn)-i*i,s=t.radius*t.radius;if(r>s)return null;let o=Math.sqrt(s-r),a=i-o,l=i+o;return a<0&&l<0?null:a<0?this.at(l,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(e===0)return t.distanceToPoint(this.origin)===0?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return i===null?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return e===0||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,s,o,a,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(i=(t.min.x-f.x)*c,r=(t.max.x-f.x)*c):(i=(t.max.x-f.x)*c,r=(t.min.x-f.x)*c),u>=0?(s=(t.min.y-f.y)*u,o=(t.max.y-f.y)*u):(s=(t.max.y-f.y)*u,o=(t.min.y-f.y)*u),i>o||s>r||((s>i||i!==i)&&(i=s),(o<r||r!==r)&&(r=o),h>=0?(a=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(a=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),i>l||a>r)||((a>i||i!==i)&&(i=a),(l<r||r!==r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return this.intersectBox(t,Cn)!==null}intersectTriangle(t,e,i,r,s){du.subVectors(e,t),Sa.subVectors(i,t),pu.crossVectors(du,Sa);let o=this.direction.dot(pu),a;if(o>0){if(r)return null;a=1}else if(o<0)a=-1,o=-o;else return null;Yn.subVectors(this.origin,t);let l=a*this.direction.dot(Sa.crossVectors(Yn,Sa));if(l<0)return null;let c=a*this.direction.dot(du.cross(Yn));if(c<0||l+c>o)return null;let u=-a*Yn.dot(pu);return u<0?null:this.at(u/o,s)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},wt=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c,u,h,f,d,g,x,v){let m=this.elements;return m[0]=t,m[4]=e,m[8]=i,m[12]=r,m[1]=s,m[5]=o,m[9]=a,m[13]=l,m[2]=c,m[6]=u,m[10]=h,m[14]=f,m[3]=d,m[7]=g,m[11]=x,m[15]=v,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new wt().fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/yr.setFromMatrixColumn(t,0).length(),s=1/yr.setFromMatrixColumn(t,1).length(),o=1/yr.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*s,e[5]=i[5]*s,e[6]=i[6]*s,e[7]=0,e[8]=i[8]*o,e[9]=i[9]*o,e[10]=i[10]*o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,s=t.z,o=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),u=Math.cos(s),h=Math.sin(s);if(t.order==="XYZ"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=-l*h,e[8]=c,e[1]=d+g*c,e[5]=f-x*c,e[9]=-a*l,e[2]=x-f*c,e[6]=g+d*c,e[10]=o*l}else if(t.order==="YXZ"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f+x*a,e[4]=g*a-d,e[8]=o*c,e[1]=o*h,e[5]=o*u,e[9]=-a,e[2]=d*a-g,e[6]=x+f*a,e[10]=o*l}else if(t.order==="ZXY"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f-x*a,e[4]=-o*h,e[8]=g+d*a,e[1]=d+g*a,e[5]=o*u,e[9]=x-f*a,e[2]=-o*c,e[6]=a,e[10]=o*l}else if(t.order==="ZYX"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=g*c-d,e[8]=f*c+x,e[1]=l*h,e[5]=x*c+f,e[9]=d*c-g,e[2]=-c,e[6]=a*l,e[10]=o*l}else if(t.order==="YZX"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=x-f*h,e[8]=g*h+d,e[1]=h,e[5]=o*u,e[9]=-a*u,e[2]=-c*u,e[6]=d*h+g,e[10]=f-x*h}else if(t.order==="XZY"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=-h,e[8]=c*u,e[1]=f*h+x,e[5]=o*u,e[9]=d*h-g,e[2]=g*h-d,e[6]=a*u,e[10]=x*h+f}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(sM,t,oM)}lookAt(t,e,i){let r=this.elements;return ke.subVectors(t,e),ke.lengthSq()===0&&(ke.z=1),ke.normalize(),Zn.crossVectors(i,ke),Zn.lengthSq()===0&&(Math.abs(i.z)===1?ke.x+=1e-4:ke.z+=1e-4,ke.normalize(),Zn.crossVectors(i,ke)),Zn.normalize(),Ea.crossVectors(ke,Zn),r[0]=Zn.x,r[4]=Ea.x,r[8]=ke.x,r[1]=Zn.y,r[5]=Ea.y,r[9]=ke.y,r[2]=Zn.z,r[6]=Ea.z,r[10]=ke.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[4],l=i[8],c=i[12],u=i[1],h=i[5],f=i[9],d=i[13],g=i[2],x=i[6],v=i[10],m=i[14],p=i[3],b=i[7],_=i[11],S=i[15],L=r[0],A=r[4],H=r[8],tt=r[12],X=r[1],y=r[5],R=r[9],D=r[13],F=r[2],z=r[6],N=r[10],V=r[14],Q=r[3],at=r[7],G=r[11],$=r[15];return s[0]=o*L+a*X+l*F+c*Q,s[4]=o*A+a*y+l*z+c*at,s[8]=o*H+a*R+l*N+c*G,s[12]=o*tt+a*D+l*V+c*$,s[1]=u*L+h*X+f*F+d*Q,s[5]=u*A+h*y+f*z+d*at,s[9]=u*H+h*R+f*N+d*G,s[13]=u*tt+h*D+f*V+d*$,s[2]=g*L+x*X+v*F+m*Q,s[6]=g*A+x*y+v*z+m*at,s[10]=g*H+x*R+v*N+m*G,s[14]=g*tt+x*D+v*V+m*$,s[3]=p*L+b*X+_*F+S*Q,s[7]=p*A+b*y+_*z+S*at,s[11]=p*H+b*R+_*N+S*G,s[15]=p*tt+b*D+_*V+S*$,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],s=t[12],o=t[1],a=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],d=t[14],g=t[3],x=t[7],v=t[11],m=t[15];return g*(+s*l*h-r*c*h-s*a*f+i*c*f+r*a*d-i*l*d)+x*(+e*l*d-e*c*f+s*o*f-r*o*d+r*c*u-s*l*u)+v*(+e*c*h-e*a*d-s*o*h+i*o*d+s*a*u-i*c*u)+m*(-r*a*u-e*l*h+e*a*f+r*o*h-i*o*f+i*l*u)}transpose(){let t=this.elements,e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],d=t[11],g=t[12],x=t[13],v=t[14],m=t[15],p=h*v*c-x*f*c+x*l*d-a*v*d-h*l*m+a*f*m,b=g*f*c-u*v*c-g*l*d+o*v*d+u*l*m-o*f*m,_=u*x*c-g*h*c+g*a*d-o*x*d-u*a*m+o*h*m,S=g*h*l-u*x*l-g*a*f+o*x*f+u*a*v-o*h*v,L=e*p+i*b+r*_+s*S;if(L===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let A=1/L;return t[0]=p*A,t[1]=(x*f*s-h*v*s-x*r*d+i*v*d+h*r*m-i*f*m)*A,t[2]=(a*v*s-x*l*s+x*r*c-i*v*c-a*r*m+i*l*m)*A,t[3]=(h*l*s-a*f*s-h*r*c+i*f*c+a*r*d-i*l*d)*A,t[4]=b*A,t[5]=(u*v*s-g*f*s+g*r*d-e*v*d-u*r*m+e*f*m)*A,t[6]=(g*l*s-o*v*s-g*r*c+e*v*c+o*r*m-e*l*m)*A,t[7]=(o*f*s-u*l*s+u*r*c-e*f*c-o*r*d+e*l*d)*A,t[8]=_*A,t[9]=(g*h*s-u*x*s-g*i*d+e*x*d+u*i*m-e*h*m)*A,t[10]=(o*x*s-g*a*s+g*i*c-e*x*c-o*i*m+e*a*m)*A,t[11]=(u*a*s-o*h*s-u*i*c+e*h*c+o*i*d-e*a*d)*A,t[12]=S*A,t[13]=(u*x*r-g*h*r+g*i*f-e*x*f-u*i*v+e*h*v)*A,t[14]=(g*a*r-o*x*r-g*i*l+e*x*l+o*i*v-e*a*v)*A,t[15]=(o*h*r-u*a*r+u*i*l-e*h*l-o*i*f+e*a*f)*A,this}scale(t){let e=this.elements,i=t.x,r=t.y,s=t.z;return e[0]*=i,e[4]*=r,e[8]*=s,e[1]*=i,e[5]*=r,e[9]*=s,e[2]*=i,e[6]*=r,e[10]*=s,e[3]*=i,e[7]*=r,e[11]*=s,this}getMaxScaleOnAxis(){let t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],i=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],r=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,i,r))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),s=1-i,o=t.x,a=t.y,l=t.z,c=s*o,u=s*a;return this.set(c*o+i,c*a-r*l,c*l+r*a,0,c*a+r*l,u*a+i,u*l-r*o,0,c*l-r*a,u*l+r*o,s*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,s,o){return this.set(1,i,s,0,t,1,o,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,s=e._x,o=e._y,a=e._z,l=e._w,c=s+s,u=o+o,h=a+a,f=s*c,d=s*u,g=s*h,x=o*u,v=o*h,m=a*h,p=l*c,b=l*u,_=l*h,S=i.x,L=i.y,A=i.z;return r[0]=(1-(x+m))*S,r[1]=(d+_)*S,r[2]=(g-b)*S,r[3]=0,r[4]=(d-_)*L,r[5]=(1-(f+m))*L,r[6]=(v+p)*L,r[7]=0,r[8]=(g+b)*A,r[9]=(v-p)*A,r[10]=(1-(f+x))*A,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,s=yr.set(r[0],r[1],r[2]).length(),o=yr.set(r[4],r[5],r[6]).length(),a=yr.set(r[8],r[9],r[10]).length();this.determinant()<0&&(s=-s),t.x=r[12],t.y=r[13],t.z=r[14],Ke.copy(this);let c=1/s,u=1/o,h=1/a;return Ke.elements[0]*=c,Ke.elements[1]*=c,Ke.elements[2]*=c,Ke.elements[4]*=u,Ke.elements[5]*=u,Ke.elements[6]*=u,Ke.elements[8]*=h,Ke.elements[9]*=h,Ke.elements[10]*=h,e.setFromRotationMatrix(Ke),i.x=s,i.y=o,i.z=a,this}makePerspective(t,e,i,r,s,o){o===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,l=2*s/(e-t),c=2*s/(i-r),u=(e+t)/(e-t),h=(i+r)/(i-r),f=-(o+s)/(o-s),d=-2*o*s/(o-s);return a[0]=l,a[4]=0,a[8]=u,a[12]=0,a[1]=0,a[5]=c,a[9]=h,a[13]=0,a[2]=0,a[6]=0,a[10]=f,a[14]=d,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,s,o){let a=this.elements,l=1/(e-t),c=1/(i-r),u=1/(o-s),h=(e+t)*l,f=(i+r)*c,d=(o+s)*u;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-h,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-f,a[2]=0,a[6]=0,a[10]=-2*u,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};wt.prototype.isMatrix4=!0;var yr=new T,Ke=new wt,sM=new T(0,0,0),oM=new T(1,1,1),Zn=new T,Ea=new T,ke=new T,og=new wt,ag=new Ee,ai=class{constructor(t=0,e=0,i=0,r=ai.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,s=r[0],o=r[4],a=r[8],l=r[1],c=r[5],u=r[9],h=r[2],f=r[6],d=r[10];switch(e){case"XYZ":this._y=Math.asin(Ie(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-u,d),this._z=Math.atan2(-o,s)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ie(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,s),this._z=0);break;case"ZXY":this._x=Math.asin(Ie(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-o,c)):(this._y=0,this._z=Math.atan2(l,s));break;case"ZYX":this._y=Math.asin(-Ie(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,d),this._z=Math.atan2(l,s)):(this._x=0,this._z=Math.atan2(-o,c));break;case"YZX":this._z=Math.asin(Ie(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,s)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-Ie(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(a,s)):(this._x=Math.atan2(-u,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,i===!0&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return og.makeRotationFromQuaternion(t),this.setFromRotationMatrix(og,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return ag.setFromEuler(this),this.setFromQuaternion(ag,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new T(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};ai.prototype.isEuler=!0;ai.DefaultOrder="XYZ";ai.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var il=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},aM=0,lg=new T,vr=new Ee,Rn=new wt,Ta=new T,Hs=new T,lM=new T,cM=new Ee,cg=new T(1,0,0),ug=new T(0,1,0),hg=new T(0,0,1),uM={type:"added"},fg={type:"removed"},kt=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:aM++}),this.uuid=tn(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=kt.DefaultUp.clone();let t=new T,e=new ai,i=new Ee,r=new T(1,1,1);function s(){i.setFromEuler(e,!1)}function o(){e.setFromQuaternion(i,void 0,!1)}e._onChange(s),i._onChange(o),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new wt},normalMatrix:{value:new de}}),this.matrix=new wt,this.matrixWorld=new wt,this.matrixAutoUpdate=kt.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new il,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.multiply(vr),this}rotateOnWorldAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.premultiply(vr),this}rotateX(t){return this.rotateOnAxis(cg,t)}rotateY(t){return this.rotateOnAxis(ug,t)}rotateZ(t){return this.rotateOnAxis(hg,t)}translateOnAxis(t,e){return lg.copy(t).applyQuaternion(this.quaternion),this.position.add(lg.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(cg,t)}translateY(t){return this.translateOnAxis(ug,t)}translateZ(t){return this.translateOnAxis(hg,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Rn.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?Ta.copy(t):Ta.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),Hs.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Rn.lookAt(Hs,Ta,this.up):Rn.lookAt(Ta,Hs,this.up),this.quaternion.setFromRotationMatrix(Rn),r&&(Rn.extractRotation(r.matrixWorld),vr.setFromRotationMatrix(Rn),this.quaternion.premultiply(vr.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(uM)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return e!==-1&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(fg)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(fg)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Rn.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),Rn.multiply(t.parent.matrixWorld)),t.applyMatrix4(Rn),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let o=this.children[i].getObjectByProperty(t,e);if(o!==void 0)return o}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,t,lM),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,cM,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;e!==null&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(t===!0&&i!==null&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),e===!0){let r=this.children;for(let s=0,o=r.length;s<o;s++)r[s].updateWorldMatrix(!1,!0)}}toJSON(t){let e=t===void 0||typeof t=="string",i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};r.uuid=this.uuid,r.type=this.type,this.name!==""&&(r.name=this.name),this.castShadow===!0&&(r.castShadow=!0),this.receiveShadow===!0&&(r.receiveShadow=!0),this.visible===!1&&(r.visible=!1),this.frustumCulled===!1&&(r.frustumCulled=!1),this.renderOrder!==0&&(r.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(r.instanceColor=this.instanceColor.toJSON()));function s(a,l){return a[l.uuid]===void 0&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=s(t.geometries,this.geometry);let a=this.geometry.parameters;if(a!==void 0&&a.shapes!==void 0){let l=a.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];s(t.shapes,h)}else s(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(s(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(s(t.materials,this.material[l]));r.material=a}else r.material=s(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++){let l=this.animations[a];r.animations.push(s(t.animations,l))}}if(e){let a=o(t.geometries),l=o(t.materials),c=o(t.textures),u=o(t.images),h=o(t.shapes),f=o(t.skeletons),d=o(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),u.length>0&&(i.images=u),h.length>0&&(i.shapes=h),f.length>0&&(i.skeletons=f),d.length>0&&(i.animations=d)}return i.object=r,i;function o(a){let l=[];for(let c in a){let u=a[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),e===!0)for(let i=0;i<t.children.length;i++){let r=t.children[i];this.add(r.clone())}return this}};kt.DefaultUp=new T(0,1,0);kt.DefaultMatrixAutoUpdate=!0;kt.prototype.isObject3D=!0;var Qe=new T,Ln=new T,mu=new T,Pn=new T,_r=new T,wr=new T,dg=new T,gu=new T,xu=new T,yu=new T,re=class{constructor(t=new T,e=new T,i=new T){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Qe.subVectors(t,e),r.cross(Qe);let s=r.lengthSq();return s>0?r.multiplyScalar(1/Math.sqrt(s)):r.set(0,0,0)}static getBarycoord(t,e,i,r,s){Qe.subVectors(r,e),Ln.subVectors(i,e),mu.subVectors(t,e);let o=Qe.dot(Qe),a=Qe.dot(Ln),l=Qe.dot(mu),c=Ln.dot(Ln),u=Ln.dot(mu),h=o*c-a*a;if(h===0)return s.set(-2,-1,-1);let f=1/h,d=(c*l-a*u)*f,g=(o*u-a*l)*f;return s.set(1-d-g,g,d)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Pn),Pn.x>=0&&Pn.y>=0&&Pn.x+Pn.y<=1}static getUV(t,e,i,r,s,o,a,l){return this.getBarycoord(t,e,i,r,Pn),l.set(0,0),l.addScaledVector(s,Pn.x),l.addScaledVector(o,Pn.y),l.addScaledVector(a,Pn.z),l}static isFrontFacing(t,e,i,r){return Qe.subVectors(i,e),Ln.subVectors(t,e),Qe.cross(Ln).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Qe.subVectors(this.c,this.b),Ln.subVectors(this.a,this.b),Qe.cross(Ln).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return re.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return re.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,s){return re.getUV(t,this.a,this.b,this.c,e,i,r,s)}containsPoint(t){return re.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return re.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let i=this.a,r=this.b,s=this.c,o,a;_r.subVectors(r,i),wr.subVectors(s,i),gu.subVectors(t,i);let l=_r.dot(gu),c=wr.dot(gu);if(l<=0&&c<=0)return e.copy(i);xu.subVectors(t,r);let u=_r.dot(xu),h=wr.dot(xu);if(u>=0&&h<=u)return e.copy(r);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return o=l/(l-u),e.copy(i).addScaledVector(_r,o);yu.subVectors(t,s);let d=_r.dot(yu),g=wr.dot(yu);if(g>=0&&d<=g)return e.copy(s);let x=d*c-l*g;if(x<=0&&c>=0&&g<=0)return a=c/(c-g),e.copy(i).addScaledVector(wr,a);let v=u*g-d*h;if(v<=0&&h-u>=0&&d-g>=0)return dg.subVectors(s,r),a=(h-u)/(h-u+(d-g)),e.copy(r).addScaledVector(dg,a);let m=1/(v+x+f);return o=x*m,a=f*m,e.copy(i).addScaledVector(_r,o).addScaledVector(wr,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},hM=0,xe=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:hM++}),this.uuid=tn(),this.name="",this.type="Material",this.fog=!0,this.blending=Ks,this.side=eo,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=u0,this.blendDst=h0,this.blendEquation=Ir,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=zu,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=tM,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nu,this.stencilZFail=nu,this.stencilZPass=nu,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let e in t){let i=t[e];if(i===void 0){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if(e==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=i===c0;continue}let r=this[e];if(r===void 0){console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.");continue}r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i}}toJSON(t){let e=t===void 0||typeof t=="string";e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),this.roughness!==void 0&&(i.roughness=this.roughness),this.metalness!==void 0&&(i.metalness=this.metalness),this.sheen!==void 0&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(i.shininess=this.shininess),this.clearcoat!==void 0&&(i.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(i.combine=this.combine)),this.envMapIntensity!==void 0&&(i.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(i.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(i.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(i.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(i.size=this.size),this.shadowSide!==null&&(i.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==Ks&&(i.blending=this.blending),this.side!==eo&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),this.transparent===!0&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(i.rotation=this.rotation),this.polygonOffset===!0&&(i.polygonOffset=!0),this.polygonOffsetFactor!==0&&(i.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(i.linewidth=this.linewidth),this.dashSize!==void 0&&(i.dashSize=this.dashSize),this.gapSize!==void 0&&(i.gapSize=this.gapSize),this.scale!==void 0&&(i.scale=this.scale),this.dithering===!0&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(i.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(i.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(i.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(i.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(i.flatShading=this.flatShading),this.visible===!1&&(i.visible=!1),this.toneMapped===!1&&(i.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData);function r(s){let o=[];for(let a in s){let l=s[a];delete l.metadata,o.push(l)}return o}if(e){let s=r(t.textures),o=r(t.images);s.length>0&&(i.textures=s),o.length>0&&(i.images=o)}return i}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(e!==null){let r=e.length;i=new Array(r);for(let s=0;s!==r;++s)i[s]=e[s].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};xe.prototype.isMaterial=!0;var ki=class extends xe{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ki.prototype.isMeshBasicMaterial=!0;var Jt=new T,Aa=new K,Qt=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=t!==void 0?t.length/e:0,this.normalized=i===!0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,s=this.itemSize;r<s;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),o=new ft),e[i++]=o.r,e[i++]=o.g,e[i++]=o.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),o=new K),e[i++]=o.x,e[i++]=o.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),o=new T),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),o=new Wt),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z,e[i++]=o.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let e=0,i=this.count;e<i;e++)Aa.fromBufferAttribute(this,e),Aa.applyMatrix3(t),this.setXY(e,Aa.x,Aa.y);else if(this.itemSize===3)for(let e=0,i=this.count;e<i;e++)Jt.fromBufferAttribute(this,e),Jt.applyMatrix3(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyMatrix4(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyNormalMatrix(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.transformDirection(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=s,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==io&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Qt.prototype.isBufferAttribute=!0;var rl=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};var sl=class extends Qt{constructor(t,e,i){super(new Uint32Array(t),e,i)}},Wu=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};Wu.prototype.isFloat16BufferAttribute=!0;var ee=class extends Qt{constructor(t,e,i){super(new Float32Array(t),e,i)}};var fM=0,qe=new wt,vu=new kt,Mr=new T,He=new Ge,Vs=new Ge,ge=new T,Ht=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:fM++}),this.uuid=tn(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(p0(t)?sl:rl)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;e!==void 0&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(i!==void 0){let s=new de().getNormalMatrix(t);i.applyNormalMatrix(s),i.needsUpdate=!0}let r=this.attributes.tangent;return r!==void 0&&(r.transformDirection(t),r.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return qe.makeRotationFromQuaternion(t),this.applyMatrix4(qe),this}rotateX(t){return qe.makeRotationX(t),this.applyMatrix4(qe),this}rotateY(t){return qe.makeRotationY(t),this.applyMatrix4(qe),this}rotateZ(t){return qe.makeRotationZ(t),this.applyMatrix4(qe),this}translate(t,e,i){return qe.makeTranslation(t,e,i),this.applyMatrix4(qe),this}scale(t,e,i){return qe.makeScale(t,e,i),this.applyMatrix4(qe),this}lookAt(t){return vu.lookAt(t),vu.updateMatrix(),this.applyMatrix4(vu.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Mr).negate(),this.translate(Mr.x,Mr.y,Mr.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let s=t[i];e.push(s.x,s.y,s.z||0)}return this.setAttribute("position",new ee(e,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new Ge);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new T(-1/0,-1/0,-1/0),new T(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++){let s=e[i];He.setFromBufferAttribute(s),this.morphTargetsRelative?(ge.addVectors(this.boundingBox.min,He.min),this.boundingBox.expandByPoint(ge),ge.addVectors(this.boundingBox.max,He.max),this.boundingBox.expandByPoint(ge)):(this.boundingBox.expandByPoint(He.min),this.boundingBox.expandByPoint(He.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new si);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new T,1/0);return}if(t){let i=this.boundingSphere.center;if(He.setFromBufferAttribute(t),e)for(let s=0,o=e.length;s<o;s++){let a=e[s];Vs.setFromBufferAttribute(a),this.morphTargetsRelative?(ge.addVectors(He.min,Vs.min),He.expandByPoint(ge),ge.addVectors(He.max,Vs.max),He.expandByPoint(ge)):(He.expandByPoint(Vs.min),He.expandByPoint(Vs.max))}He.getCenter(i);let r=0;for(let s=0,o=t.count;s<o;s++)ge.fromBufferAttribute(t,s),r=Math.max(r,i.distanceToSquared(ge));if(e)for(let s=0,o=e.length;s<o;s++){let a=e[s],l=this.morphTargetsRelative;for(let c=0,u=a.count;c<u;c++)ge.fromBufferAttribute(a,c),l&&(Mr.fromBufferAttribute(t,c),ge.add(Mr)),r=Math.max(r,i.distanceToSquared(ge))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(t===null||e.position===void 0||e.normal===void 0||e.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let i=t.array,r=e.position.array,s=e.normal.array,o=e.uv.array,a=r.length/3;e.tangent===void 0&&this.setAttribute("tangent",new Qt(new Float32Array(4*a),4));let l=e.tangent.array,c=[],u=[];for(let X=0;X<a;X++)c[X]=new T,u[X]=new T;let h=new T,f=new T,d=new T,g=new K,x=new K,v=new K,m=new T,p=new T;function b(X,y,R){h.fromArray(r,X*3),f.fromArray(r,y*3),d.fromArray(r,R*3),g.fromArray(o,X*2),x.fromArray(o,y*2),v.fromArray(o,R*2),f.sub(h),d.sub(h),x.sub(g),v.sub(g);let D=1/(x.x*v.y-v.x*x.y);!isFinite(D)||(m.copy(f).multiplyScalar(v.y).addScaledVector(d,-x.y).multiplyScalar(D),p.copy(d).multiplyScalar(x.x).addScaledVector(f,-v.x).multiplyScalar(D),c[X].add(m),c[y].add(m),c[R].add(m),u[X].add(p),u[y].add(p),u[R].add(p))}let _=this.groups;_.length===0&&(_=[{start:0,count:i.length}]);for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)b(i[z+0],i[z+1],i[z+2])}let S=new T,L=new T,A=new T,H=new T;function tt(X){A.fromArray(s,X*3),H.copy(A);let y=c[X];S.copy(y),S.sub(A.multiplyScalar(A.dot(y))).normalize(),L.crossVectors(H,y);let D=L.dot(u[X])<0?-1:1;l[X*4]=S.x,l[X*4+1]=S.y,l[X*4+2]=S.z,l[X*4+3]=D}for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)tt(i[z+0]),tt(i[z+1]),tt(i[z+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(e!==void 0){let i=this.getAttribute("normal");if(i===void 0)i=new Qt(new Float32Array(e.count*3),3),this.setAttribute("normal",i);else for(let f=0,d=i.count;f<d;f++)i.setXYZ(f,0,0,0);let r=new T,s=new T,o=new T,a=new T,l=new T,c=new T,u=new T,h=new T;if(t)for(let f=0,d=t.count;f<d;f+=3){let g=t.getX(f+0),x=t.getX(f+1),v=t.getX(f+2);r.fromBufferAttribute(e,g),s.fromBufferAttribute(e,x),o.fromBufferAttribute(e,v),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),a.fromBufferAttribute(i,g),l.fromBufferAttribute(i,x),c.fromBufferAttribute(i,v),a.add(u),l.add(u),c.add(u),i.setXYZ(g,a.x,a.y,a.z),i.setXYZ(x,l.x,l.y,l.z),i.setXYZ(v,c.x,c.y,c.z)}else for(let f=0,d=e.count;f<d;f+=3)r.fromBufferAttribute(e,f+0),s.fromBufferAttribute(e,f+1),o.fromBufferAttribute(e,f+2),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),i.setXYZ(f+0,u.x,u.y,u.z),i.setXYZ(f+1,u.x,u.y,u.z),i.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}e===void 0&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(t.attributes[r]===void 0)continue;let o=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,u=Math.min(l.length,o.length-c);for(let h=0,f=c;h<u;h++,f++)o[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)ge.fromBufferAttribute(t,e),ge.normalize(),t.setXYZ(e,ge.x,ge.y,ge.z)}toNonIndexed(){function t(a,l){let c=a.array,u=a.itemSize,h=a.normalized,f=new c.constructor(l.length*u),d=0,g=0;for(let x=0,v=l.length;x<v;x++){a.isInterleavedBufferAttribute?d=l[x]*a.data.stride+a.offset:d=l[x]*u;for(let m=0;m<u;m++)f[g++]=c[d++]}return new Qt(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Ht,i=this.index.array,r=this.attributes;for(let a in r){let l=r[a],c=t(l,i);e.setAttribute(a,c)}let s=this.morphAttributes;for(let a in s){let l=[],c=s[a];for(let u=0,h=c.length;u<h;u++){let f=c[u],d=t(f,i);l.push(d)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let o=this.groups;for(let a=0,l=o.length;a<l;a++){let c=o[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;e!==null&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i){let c=i[l];t.data.attributes[l]=c.toJSON(t.data)}let r={},s=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let d=c[h];u.push(d.toJSON(t.data))}u.length>0&&(r[l]=u,s=!0)}s&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let o=this.groups;o.length>0&&(t.data.groups=JSON.parse(JSON.stringify(o)));let a=this.boundingSphere;return a!==null&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;i!==null&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r){let u=r[c];this.setAttribute(c,u.clone(e))}let s=t.morphAttributes;for(let c in s){let u=[],h=s[c];for(let f=0,d=h.length;f<d;f++)u.push(h[f].clone(e));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let o=t.groups;for(let c=0,u=o.length;c<u;c++){let h=o[c];this.addGroup(h.start,h.count,h.materialIndex)}let a=t.boundingBox;a!==null&&(this.boundingBox=a.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Ht.prototype.isBufferGeometry=!0;var pg=new wt,br=new oi,_u=new si,Jn=new T,$n=new T,Kn=new T,wu=new T,Mu=new T,bu=new T,Ca=new T,Ra=new T,La=new T,Pa=new K,Da=new K,Ia=new K,Su=new T,Na=new T,oe=class extends kt{constructor(t=new Ht,e=new ki){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let i=this.geometry,r=this.material,s=this.matrixWorld;if(r===void 0||(i.boundingSphere===null&&i.computeBoundingSphere(),_u.copy(i.boundingSphere),_u.applyMatrix4(s),t.ray.intersectsSphere(_u)===!1)||(pg.copy(s).invert(),br.copy(t.ray).applyMatrix4(pg),i.boundingBox!==null&&br.intersectsBox(i.boundingBox)===!1))return;let o;if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,u=i.morphTargetsRelative,h=i.attributes.uv,f=i.attributes.uv2,d=i.groups,g=i.drawRange;if(a!==null)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(a.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=a.getX(S),H=a.getX(S+1),tt=a.getX(S+2);o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(a.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=a.getX(m),_=a.getX(m+1),S=a.getX(m+2);o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}else if(l!==void 0)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(l.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=S,H=S+1,tt=S+2;o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(l.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=m,_=m+1,S=m+2;o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};oe.prototype.isMesh=!0;function dM(n,t,e,i,r,s,o,a){let l;if(t.side===he?l=i.intersectTriangle(o,s,r,!0,a):l=i.intersectTriangle(r,s,o,t.side!==Hr,a),l===null)return null;Na.copy(a),Na.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(Na);return c<e.near||c>e.far?null:{distance:c,point:Na.clone(),object:n}}function Fa(n,t,e,i,r,s,o,a,l,c,u,h){Jn.fromBufferAttribute(r,c),$n.fromBufferAttribute(r,u),Kn.fromBufferAttribute(r,h);let f=n.morphTargetInfluences;if(s&&f){Ca.set(0,0,0),Ra.set(0,0,0),La.set(0,0,0);for(let g=0,x=s.length;g<x;g++){let v=f[g],m=s[g];v!==0&&(wu.fromBufferAttribute(m,c),Mu.fromBufferAttribute(m,u),bu.fromBufferAttribute(m,h),o?(Ca.addScaledVector(wu,v),Ra.addScaledVector(Mu,v),La.addScaledVector(bu,v)):(Ca.addScaledVector(wu.sub(Jn),v),Ra.addScaledVector(Mu.sub($n),v),La.addScaledVector(bu.sub(Kn),v)))}Jn.add(Ca),$n.add(Ra),Kn.add(La)}n.isSkinnedMesh&&(n.boneTransform(c,Jn),n.boneTransform(u,$n),n.boneTransform(h,Kn));let d=dM(n,t,e,i,Jn,$n,Kn,Su);if(d){a&&(Pa.fromBufferAttribute(a,c),Da.fromBufferAttribute(a,u),Ia.fromBufferAttribute(a,h),d.uv=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K)),l&&(Pa.fromBufferAttribute(l,c),Da.fromBufferAttribute(l,u),Ia.fromBufferAttribute(l,h),d.uv2=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K));let g={a:c,b:u,c:h,normal:new T,materialIndex:0};re.getNormal(Jn,$n,Kn,g.normal),d.face=g}return d}var Hi=class extends Ht{constructor(t=1,e=1,i=1,r=1,s=1,o=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:s,depthSegments:o};let a=this;r=Math.floor(r),s=Math.floor(s),o=Math.floor(o);let l=[],c=[],u=[],h=[],f=0,d=0;g("z","y","x",-1,-1,i,e,t,o,s,0),g("z","y","x",1,-1,i,e,-t,o,s,1),g("x","z","y",1,1,t,i,e,r,o,2),g("x","z","y",1,-1,t,i,-e,r,o,3),g("x","y","z",1,-1,t,e,i,r,s,4),g("x","y","z",-1,-1,t,e,-i,r,s,5),this.setIndex(l),this.setAttribute("position",new ee(c,3)),this.setAttribute("normal",new ee(u,3)),this.setAttribute("uv",new ee(h,2));function g(x,v,m,p,b,_,S,L,A,H,tt){let X=_/A,y=S/H,R=_/2,D=S/2,F=L/2,z=A+1,N=H+1,V=0,Q=0,at=new T;for(let G=0;G<N;G++){let $=G*y-D;for(let lt=0;lt<z;lt++){let dt=lt*X-R;at[x]=dt*p,at[v]=$*b,at[m]=F,c.push(at.x,at.y,at.z),at[x]=0,at[v]=0,at[m]=L>0?1:-1,u.push(at.x,at.y,at.z),h.push(lt/A),h.push(1-G/H),V+=1}}for(let G=0;G<H;G++)for(let $=0;$<A;$++){let lt=f+$+z*G,dt=f+$+z*(G+1),xt=f+($+1)+z*(G+1),k=f+($+1)+z*G;l.push(lt,dt,k),l.push(dt,xt,k),Q+=6}a.addGroup(d,Q,tt),d+=Q,f+=V}}static fromJSON(t){return new Hi(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Gr(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?t[e][i]=r.clone():Array.isArray(r)?t[e][i]=r.slice():t[e][i]=r}}return t}function Me(n){let t={};for(let e=0;e<n.length;e++){let i=Gr(n[e]);for(let r in i)t[r]=i[r]}return t}var pM={clone:Gr,merge:Me},mM=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,gM=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,Fn=class extends xe{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=mM,this.fragmentShader=gM,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Gr(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let o=this.uniforms[r].value;o&&o.isTexture?e.uniforms[r]={type:"t",value:o.toJSON(t).uuid}:o&&o.isColor?e.uniforms[r]={type:"c",value:o.getHex()}:o&&o.isVector2?e.uniforms[r]={type:"v2",value:o.toArray()}:o&&o.isVector3?e.uniforms[r]={type:"v3",value:o.toArray()}:o&&o.isVector4?e.uniforms[r]={type:"v4",value:o.toArray()}:o&&o.isMatrix3?e.uniforms[r]={type:"m3",value:o.toArray()}:o&&o.isMatrix4?e.uniforms[r]={type:"m4",value:o.toArray()}:e.uniforms[r]={value:o}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)this.extensions[r]===!0&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Fn.prototype.isShaderMaterial=!0;var oo=class extends kt{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new wt,this.projectionMatrix=new wt,this.projectionMatrixInverse=new wt}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};oo.prototype.isCamera=!0;var Se=class extends oo{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=Vu*2*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(iu*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return Vu*2*Math.atan(Math.tan(iu*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,s,o){this.aspect=t/e,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(iu*.5*this.fov)/this.zoom,i=2*e,r=this.aspect*i,s=-.5*r,o=this.view;if(this.view!==null&&this.view.enabled){let l=o.fullWidth,c=o.fullHeight;s+=o.offsetX*r/l,e-=o.offsetY*i/c,r*=o.width/l,i*=o.height/c}let a=this.filmOffset;a!==0&&(s+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(s,s+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,this.view!==null&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};Se.prototype.isPerspectiveCamera=!0;var Sr=90,Er=1,ao=class extends kt{constructor(t,e,i){if(super(),this.type="CubeCamera",i.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=i;let r=new Se(Sr,Er,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new T(1,0,0)),this.add(r);let s=new Se(Sr,Er,t,e);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new T(-1,0,0)),this.add(s);let o=new Se(Sr,Er,t,e);o.layers=this.layers,o.up.set(0,0,1),o.lookAt(new T(0,1,0)),this.add(o);let a=new Se(Sr,Er,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new T(0,-1,0)),this.add(a);let l=new Se(Sr,Er,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new T(0,0,1)),this.add(l);let c=new Se(Sr,Er,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new T(0,0,-1)),this.add(c)}update(t,e){this.parent===null&&this.updateMatrixWorld();let i=this.renderTarget,[r,s,o,a,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,s),t.setRenderTarget(i,2),t.render(e,o),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=f,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(h),t.xr.enabled=u,i.texture.needsPMREMUpdate=!0}},Wr=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){t=t!==void 0?t:[],e=e!==void 0?e:Ao,super(t,e,i,r,s,o,a,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};Wr.prototype.isCubeTexture=!0;var ol=class extends Ne{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),e=e||{},this.texture=new Wr(void 0,e.mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=e.generateMipmaps!==void 0?e.generateMipmaps:!1,this.texture.minFilter=e.minFilter!==void 0?e.minFilter:be}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=Re,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},r=new Hi(5,5,5),s=new Fn({name:"CubemapFromEquirect",uniforms:Gr(i.uniforms),vertexShader:i.vertexShader,fragmentShader:i.fragmentShader,side:he,blending:jn});s.uniforms.tEquirect.value=e;let o=new oe(r,s),a=e.minFilter;return e.minFilter===Ll&&(e.minFilter=be),new ao(1,10,this).update(t,o),e.minFilter=a,o.geometry.dispose(),o.material.dispose(),this}clear(t,e,i,r){let s=t.getRenderTarget();for(let o=0;o<6;o++)t.setRenderTarget(this,o),t.clear(e,i,r);t.setRenderTarget(s)}};ol.prototype.isWebGLCubeRenderTarget=!0;var Eu=new T,xM=new T,yM=new de,je=class{constructor(t=new T(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=Eu.subVectors(i,e).cross(xM.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(Eu),r=this.normal.dot(i);if(r===0)return this.distanceToPoint(t.start)===0?e.copy(t.start):null;let s=-(t.start.dot(this.normal)+this.constant)/r;return s<0||s>1?null:e.copy(i).multiplyScalar(s).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||yM.getNormalMatrix(t),r=this.coplanarPoint(Eu).applyMatrix4(t),s=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(s),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};je.prototype.isPlane=!0;var Tr=new si,za=new T,qr=class{constructor(t=new je,e=new je,i=new je,r=new je,s=new je,o=new je){this.planes=[t,e,i,r,s,o]}set(t,e,i,r,s,o){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(s),a[5].copy(o),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],s=i[1],o=i[2],a=i[3],l=i[4],c=i[5],u=i[6],h=i[7],f=i[8],d=i[9],g=i[10],x=i[11],v=i[12],m=i[13],p=i[14],b=i[15];return e[0].setComponents(a-r,h-l,x-f,b-v).normalize(),e[1].setComponents(a+r,h+l,x+f,b+v).normalize(),e[2].setComponents(a+s,h+c,x+d,b+m).normalize(),e[3].setComponents(a-s,h-c,x-d,b-m).normalize(),e[4].setComponents(a-o,h-u,x-g,b-p).normalize(),e[5].setComponents(a+o,h+u,x+g,b+p).normalize(),this}intersectsObject(t){let e=t.geometry;return e.boundingSphere===null&&e.computeBoundingSphere(),Tr.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSprite(t){return Tr.center.set(0,0,0),Tr.radius=.7071067811865476,Tr.applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let s=0;s<6;s++)if(e[s].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(za.x=r.normal.x>0?t.max.x:t.min.x,za.y=r.normal.y>0?t.max.y:t.min.y,za.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(za)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function g0(){let n=null,t=!1,e=null,i=null;function r(s,o){e(s,o),i=n.requestAnimationFrame(r)}return{start:function(){t!==!0&&e!==null&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(s){e=s},setContext:function(s){n=s}}}function vM(n,t){let e=t.isWebGL2,i=new WeakMap;function r(c,u){let h=c.array,f=c.usage,d=n.createBuffer();n.bindBuffer(u,d),n.bufferData(u,h,f),c.onUploadCallback();let g=5126;return h instanceof Float32Array?g=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?e?g=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):g=5123:h instanceof Int16Array?g=5122:h instanceof Uint32Array?g=5125:h instanceof Int32Array?g=5124:h instanceof Int8Array?g=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(g=5121),{buffer:d,type:g,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function s(c,u,h){let f=u.array,d=u.updateRange;n.bindBuffer(h,c),d.count===-1?n.bufferSubData(h,0,f):(e?n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f,d.offset,d.count):n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f.subarray(d.offset,d.offset+d.count)),d.count=-1)}function o(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)}function a(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);u&&(n.deleteBuffer(u.buffer),i.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=i.get(c);(!f||f.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=i.get(c);h===void 0?i.set(c,r(c,u)):h.version<c.version&&(s(h.buffer,c,u),h.version=c.version)}return{get:o,remove:a,update:l}}var lo=class extends Ht{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let s=t/2,o=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,u=l+1,h=t/a,f=e/l,d=[],g=[],x=[],v=[];for(let m=0;m<u;m++){let p=m*f-o;for(let b=0;b<c;b++){let _=b*h-s;g.push(_,-p,0),x.push(0,0,1),v.push(b/a),v.push(1-m/l)}}for(let m=0;m<l;m++)for(let p=0;p<a;p++){let b=p+c*m,_=p+c*(m+1),S=p+1+c*(m+1),L=p+1+c*m;d.push(b,_,L),d.push(_,S,L)}this.setIndex(d),this.setAttribute("position",new ee(g,3)),this.setAttribute("normal",new ee(x,3)),this.setAttribute("uv",new ee(v,2))}static fromJSON(t){return new lo(t.width,t.height,t.widthSegments,t.heightSegments)}},_M=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,wM=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,MM=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,bM=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,SM=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,EM=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,TM="vec3 transformed = vec3( position );",AM=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,CM=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,RM=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,LM=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,PM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,DM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,IM=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,NM=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,FM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,zM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,UM=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,BM=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,OM=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,kM=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,HM=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,VM=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,GM=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,WM=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,qM="gl_FragColor = linearToOutputTexel( gl_FragColor );",XM=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,YM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,ZM=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,JM=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,$M=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,KM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,QM=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,jM=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,tb=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,eb=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,nb=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,ib=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,rb=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,sb=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,ob=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,ab=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,lb=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,cb=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,ub=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,hb=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,fb=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,db=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,pb=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,mb=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,gb=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,xb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,yb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,vb=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,_b=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,wb=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mb=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,bb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Sb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Eb=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Tb=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ab=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Cb=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Rb=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,Lb=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Pb=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Db=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Ib=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Nb=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,Fb=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,zb=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Ub=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Bb=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Ob=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,kb=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,Hb=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Vb=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Gb=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Wb=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,qb=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xb=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,Yb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Zb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Jb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,$b=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Kb=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,Qb=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,jb=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,t1=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,e1=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,n1=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,i1=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,r1=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,s1=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,o1=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,a1=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,l1=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,c1=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,u1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,h1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,f1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,d1=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,p1=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,m1=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,g1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,x1=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,y1=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,v1=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,_1=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,w1=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,M1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,b1=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,S1=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,E1=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,T1=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,A1=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,C1=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,R1=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,L1=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,P1=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,D1=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,I1=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,N1=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,F1=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,z1=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,U1=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,B1=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,O1=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,k1=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,H1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,V1=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,G1=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,W1=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,q1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Pt={alphamap_fragment:_M,alphamap_pars_fragment:wM,alphatest_fragment:MM,alphatest_pars_fragment:bM,aomap_fragment:SM,aomap_pars_fragment:EM,begin_vertex:TM,beginnormal_vertex:AM,bsdfs:CM,bumpmap_pars_fragment:RM,clipping_planes_fragment:LM,clipping_planes_pars_fragment:PM,clipping_planes_pars_vertex:DM,clipping_planes_vertex:IM,color_fragment:NM,color_pars_fragment:FM,color_pars_vertex:zM,color_vertex:UM,common:BM,cube_uv_reflection_fragment:OM,defaultnormal_vertex:kM,displacementmap_pars_vertex:HM,displacementmap_vertex:VM,emissivemap_fragment:GM,emissivemap_pars_fragment:WM,encodings_fragment:qM,encodings_pars_fragment:XM,envmap_fragment:YM,envmap_common_pars_fragment:ZM,envmap_pars_fragment:JM,envmap_pars_vertex:$M,envmap_physical_pars_fragment:ab,envmap_vertex:KM,fog_vertex:QM,fog_pars_vertex:jM,fog_fragment:tb,fog_pars_fragment:eb,gradientmap_pars_fragment:nb,lightmap_fragment:ib,lightmap_pars_fragment:rb,lights_lambert_vertex:sb,lights_pars_begin:ob,lights_toon_fragment:lb,lights_toon_pars_fragment:cb,lights_phong_fragment:ub,lights_phong_pars_fragment:hb,lights_physical_fragment:fb,lights_physical_pars_fragment:db,lights_fragment_begin:pb,lights_fragment_maps:mb,lights_fragment_end:gb,logdepthbuf_fragment:xb,logdepthbuf_pars_fragment:yb,logdepthbuf_pars_vertex:vb,logdepthbuf_vertex:_b,map_fragment:wb,map_pars_fragment:Mb,map_particle_fragment:bb,map_particle_pars_fragment:Sb,metalnessmap_fragment:Eb,metalnessmap_pars_fragment:Tb,morphnormal_vertex:Ab,morphtarget_pars_vertex:Cb,morphtarget_vertex:Rb,normal_fragment_begin:Lb,normal_fragment_maps:Pb,normal_pars_fragment:Db,normal_pars_vertex:Ib,normal_vertex:Nb,normalmap_pars_fragment:Fb,clearcoat_normal_fragment_begin:zb,clearcoat_normal_fragment_maps:Ub,clearcoat_pars_fragment:Bb,output_fragment:Ob,packing:kb,premultiplied_alpha_fragment:Hb,project_vertex:Vb,dithering_fragment:Gb,dithering_pars_fragment:Wb,roughnessmap_fragment:qb,roughnessmap_pars_fragment:Xb,shadowmap_pars_fragment:Yb,shadowmap_pars_vertex:Zb,shadowmap_vertex:Jb,shadowmask_pars_fragment:$b,skinbase_vertex:Kb,skinning_pars_vertex:Qb,skinning_vertex:jb,skinnormal_vertex:t1,specularmap_fragment:e1,specularmap_pars_fragment:n1,tonemapping_fragment:i1,tonemapping_pars_fragment:r1,transmission_fragment:s1,transmission_pars_fragment:o1,uv_pars_fragment:a1,uv_pars_vertex:l1,uv_vertex:c1,uv2_pars_fragment:u1,uv2_pars_vertex:h1,uv2_vertex:f1,worldpos_vertex:d1,background_vert:p1,background_frag:m1,cube_vert:g1,cube_frag:x1,depth_vert:y1,depth_frag:v1,distanceRGBA_vert:_1,distanceRGBA_frag:w1,equirect_vert:M1,equirect_frag:b1,linedashed_vert:S1,linedashed_frag:E1,meshbasic_vert:T1,meshbasic_frag:A1,meshlambert_vert:C1,meshlambert_frag:R1,meshmatcap_vert:L1,meshmatcap_frag:P1,meshnormal_vert:D1,meshnormal_frag:I1,meshphong_vert:N1,meshphong_frag:F1,meshphysical_vert:z1,meshphysical_frag:U1,meshtoon_vert:B1,meshtoon_frag:O1,points_vert:k1,points_frag:H1,shadow_vert:V1,shadow_frag:G1,sprite_vert:W1,sprite_frag:q1},ot={common:{diffuse:{value:new ft(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new de},uv2Transform:{value:new de},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new K(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ft(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ft(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}},sprite:{diffuse:{value:new ft(16777215)},opacity:{value:1},center:{value:new K(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}}},fn={basic:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.fog]),vertexShader:Pt.meshbasic_vert,fragmentShader:Pt.meshbasic_frag},lambert:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshlambert_vert,fragmentShader:Pt.meshlambert_frag},phong:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},specular:{value:new ft(1118481)},shininess:{value:30}}]),vertexShader:Pt.meshphong_vert,fragmentShader:Pt.meshphong_frag},standard:{uniforms:Me([ot.common,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.roughnessmap,ot.metalnessmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag},toon:{uniforms:Me([ot.common,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.gradientmap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshtoon_vert,fragmentShader:Pt.meshtoon_frag},matcap:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,{matcap:{value:null}}]),vertexShader:Pt.meshmatcap_vert,fragmentShader:Pt.meshmatcap_frag},points:{uniforms:Me([ot.points,ot.fog]),vertexShader:Pt.points_vert,fragmentShader:Pt.points_frag},dashed:{uniforms:Me([ot.common,ot.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Pt.linedashed_vert,fragmentShader:Pt.linedashed_frag},depth:{uniforms:Me([ot.common,ot.displacementmap]),vertexShader:Pt.depth_vert,fragmentShader:Pt.depth_frag},normal:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,{opacity:{value:1}}]),vertexShader:Pt.meshnormal_vert,fragmentShader:Pt.meshnormal_frag},sprite:{uniforms:Me([ot.sprite,ot.fog]),vertexShader:Pt.sprite_vert,fragmentShader:Pt.sprite_frag},background:{uniforms:{uvTransform:{value:new de},t2D:{value:null}},vertexShader:Pt.background_vert,fragmentShader:Pt.background_frag},cube:{uniforms:Me([ot.envmap,{opacity:{value:1}}]),vertexShader:Pt.cube_vert,fragmentShader:Pt.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Pt.equirect_vert,fragmentShader:Pt.equirect_frag},distanceRGBA:{uniforms:Me([ot.common,ot.displacementmap,{referencePosition:{value:new T},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Pt.distanceRGBA_vert,fragmentShader:Pt.distanceRGBA_frag},shadow:{uniforms:Me([ot.lights,ot.fog,{color:{value:new ft(0)},opacity:{value:1}}]),vertexShader:Pt.shadow_vert,fragmentShader:Pt.shadow_frag}};fn.physical={uniforms:Me([fn.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new K(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ft(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new K},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ft(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ft(1,1,1)},specularColorMap:{value:null}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag};function X1(n,t,e,i,r,s){let o=new ft(0),a=r===!0?0:1,l,c,u=null,h=0,f=null;function d(x,v){let m=!1,p=v.isScene===!0?v.background:null;p&&p.isTexture&&(p=t.get(p));let b=n.xr,_=b.getSession&&b.getSession();_&&_.environmentBlendMode==="additive"&&(p=null),p===null?g(o,a):p&&p.isColor&&(g(p,1),m=!0),(n.autoClear||m)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),p&&(p.isCubeTexture||p.mapping===Rl)?(c===void 0&&(c=new oe(new Hi(1,1,1),new Fn({name:"BackgroundCubeMaterial",uniforms:Gr(fn.cube.uniforms),vertexShader:fn.cube.vertexShader,fragmentShader:fn.cube.fragmentShader,side:he,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(S,L,A){this.matrixWorld.copyPosition(A.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=p,c.material.uniforms.flipEnvMap.value=p.isCubeTexture&&p.isRenderTargetTexture===!1?-1:1,(u!==p||h!==p.version||f!==n.toneMapping)&&(c.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(c,c.geometry,c.material,0,0,null)):p&&p.isTexture&&(l===void 0&&(l=new oe(new lo(2,2),new Fn({name:"BackgroundMaterial",uniforms:Gr(fn.background.uniforms),vertexShader:fn.background.vertexShader,fragmentShader:fn.background.fragmentShader,side:eo,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=p,p.matrixAutoUpdate===!0&&p.updateMatrix(),l.material.uniforms.uvTransform.value.copy(p.matrix),(u!==p||h!==p.version||f!==n.toneMapping)&&(l.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(l,l.geometry,l.material,0,0,null))}function g(x,v){e.buffers.color.setClear(x.r,x.g,x.b,v,s)}return{getClearColor:function(){return o},setClearColor:function(x,v=1){o.set(x),a=v,g(o,a)},getClearAlpha:function(){return a},setClearAlpha:function(x){a=x,g(o,a)},render:d}}function Y1(n,t,e,i){let r=n.getParameter(34921),s=i.isWebGL2?null:t.get("OES_vertex_array_object"),o=i.isWebGL2||s!==null,a={},l=x(null),c=l;function u(D,F,z,N,V){let Q=!1;if(o){let at=g(N,z,F);c!==at&&(c=at,f(c.object)),Q=v(N,V),Q&&m(N,V)}else{let at=F.wireframe===!0;(c.geometry!==N.id||c.program!==z.id||c.wireframe!==at)&&(c.geometry=N.id,c.program=z.id,c.wireframe=at,Q=!0)}D.isInstancedMesh===!0&&(Q=!0),V!==null&&e.update(V,34963),Q&&(A(D,F,z,N),V!==null&&n.bindBuffer(34963,e.get(V).buffer))}function h(){return i.isWebGL2?n.createVertexArray():s.createVertexArrayOES()}function f(D){return i.isWebGL2?n.bindVertexArray(D):s.bindVertexArrayOES(D)}function d(D){return i.isWebGL2?n.deleteVertexArray(D):s.deleteVertexArrayOES(D)}function g(D,F,z){let N=z.wireframe===!0,V=a[D.id];V===void 0&&(V={},a[D.id]=V);let Q=V[F.id];Q===void 0&&(Q={},V[F.id]=Q);let at=Q[N];return at===void 0&&(at=x(h()),Q[N]=at),at}function x(D){let F=[],z=[],N=[];for(let V=0;V<r;V++)F[V]=0,z[V]=0,N[V]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:N,object:D,attributes:{},index:null}}function v(D,F){let z=c.attributes,N=D.attributes,V=0;for(let Q in N){let at=z[Q],G=N[Q];if(at===void 0||at.attribute!==G||at.data!==G.data)return!0;V++}return c.attributesNum!==V||c.index!==F}function m(D,F){let z={},N=D.attributes,V=0;for(let Q in N){let at=N[Q],G={};G.attribute=at,at.data&&(G.data=at.data),z[Q]=G,V++}c.attributes=z,c.attributesNum=V,c.index=F}function p(){let D=c.newAttributes;for(let F=0,z=D.length;F<z;F++)D[F]=0}function b(D){_(D,0)}function _(D,F){let z=c.newAttributes,N=c.enabledAttributes,V=c.attributeDivisors;z[D]=1,N[D]===0&&(n.enableVertexAttribArray(D),N[D]=1),V[D]!==F&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](D,F),V[D]=F)}function S(){let D=c.newAttributes,F=c.enabledAttributes;for(let z=0,N=F.length;z<N;z++)F[z]!==D[z]&&(n.disableVertexAttribArray(z),F[z]=0)}function L(D,F,z,N,V,Q){i.isWebGL2===!0&&(z===5124||z===5125)?n.vertexAttribIPointer(D,F,z,V,Q):n.vertexAttribPointer(D,F,z,N,V,Q)}function A(D,F,z,N){if(i.isWebGL2===!1&&(D.isInstancedMesh||N.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;p();let V=N.attributes,Q=z.getAttributes(),at=F.defaultAttributeValues;for(let G in Q){let $=Q[G];if($.location>=0){let lt=V[G];if(lt===void 0&&(G==="instanceMatrix"&&D.instanceMatrix&&(lt=D.instanceMatrix),G==="instanceColor"&&D.instanceColor&&(lt=D.instanceColor)),lt!==void 0){let dt=lt.normalized,xt=lt.itemSize,k=e.get(lt);if(k===void 0)continue;let Ft=k.buffer,mt=k.type,St=k.bytesPerElement;if(lt.isInterleavedBufferAttribute){let B=lt.data,st=B.stride,nt=lt.offset;if(B&&B.isInstancedInterleavedBuffer){for(let C=0;C<$.locationSize;C++)_($.location+C,B.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=B.meshPerAttribute*B.count)}else for(let C=0;C<$.locationSize;C++)b($.location+C);n.bindBuffer(34962,Ft);for(let C=0;C<$.locationSize;C++)L($.location+C,xt/$.locationSize,mt,dt,st*St,(nt+xt/$.locationSize*C)*St)}else{if(lt.isInstancedBufferAttribute){for(let B=0;B<$.locationSize;B++)_($.location+B,lt.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let B=0;B<$.locationSize;B++)b($.location+B);n.bindBuffer(34962,Ft);for(let B=0;B<$.locationSize;B++)L($.location+B,xt/$.locationSize,mt,dt,xt*St,xt/$.locationSize*B*St)}}else if(at!==void 0){let dt=at[G];if(dt!==void 0)switch(dt.length){case 2:n.vertexAttrib2fv($.location,dt);break;case 3:n.vertexAttrib3fv($.location,dt);break;case 4:n.vertexAttrib4fv($.location,dt);break;default:n.vertexAttrib1fv($.location,dt)}}}}S()}function H(){y();for(let D in a){let F=a[D];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D]}}function tt(D){if(a[D.id]===void 0)return;let F=a[D.id];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D.id]}function X(D){for(let F in a){let z=a[F];if(z[D.id]===void 0)continue;let N=z[D.id];for(let V in N)d(N[V].object),delete N[V];delete z[D.id]}}function y(){R(),c!==l&&(c=l,f(c.object))}function R(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:y,resetDefaultState:R,dispose:H,releaseStatesOfGeometry:tt,releaseStatesOfProgram:X,initAttributes:p,enableAttribute:b,disableUnusedAttributes:S}}function Z1(n,t,e,i){let r=i.isWebGL2,s;function o(c){s=c}function a(c,u){n.drawArrays(s,c,u),e.update(u,s,1)}function l(c,u,h){if(h===0)return;let f,d;if(r)f=n,d="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),d="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[d](s,c,u,h),e.update(u,s,h)}this.setMode=o,this.render=a,this.renderInstances=l}function J1(n,t,e){let i;function r(){if(i!==void 0)return i;if(t.has("EXT_texture_filter_anisotropic")===!0){let A=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(A.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i}function s(A){if(A==="highp"){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";A="mediump"}return A==="mediump"&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let o=typeof WebGL2RenderingContext!="undefined"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&n instanceof WebGL2ComputeRenderingContext,a=e.precision!==void 0?e.precision:"highp",l=s(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=o||t.has("WEBGL_draw_buffers"),u=e.logarithmicDepthBuffer===!0,h=n.getParameter(34930),f=n.getParameter(35660),d=n.getParameter(3379),g=n.getParameter(34076),x=n.getParameter(34921),v=n.getParameter(36347),m=n.getParameter(36348),p=n.getParameter(36349),b=f>0,_=o||t.has("OES_texture_float"),S=b&&_,L=o?n.getParameter(36183):0;return{isWebGL2:o,drawBuffers:c,getMaxAnisotropy:r,getMaxPrecision:s,precision:a,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:d,maxCubemapSize:g,maxAttributes:x,maxVertexUniforms:v,maxVaryings:m,maxFragmentUniforms:p,vertexTextures:b,floatFragmentTextures:_,floatVertexTextures:S,maxSamples:L}}function $1(n){let t=this,e=null,i=0,r=!1,s=!1,o=new je,a=new de,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,d){let g=h.length!==0||f||i!==0||r;return r=f,e=u(h,d,0),i=h.length,g},this.beginShadows=function(){s=!0,u(null)},this.endShadows=function(){s=!1,c()},this.setState=function(h,f,d){let g=h.clippingPlanes,x=h.clipIntersection,v=h.clipShadows,m=n.get(h);if(!r||g===null||g.length===0||s&&!v)s?u(null):c();else{let p=s?0:i,b=p*4,_=m.clippingState||null;l.value=_,_=u(g,f,b,d);for(let S=0;S!==b;++S)_[S]=e[S];m.clippingState=_,this.numIntersection=x?this.numPlanes:0,this.numPlanes+=p}};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function u(h,f,d,g){let x=h!==null?h.length:0,v=null;if(x!==0){if(v=l.value,g!==!0||v===null){let m=d+x*4,p=f.matrixWorldInverse;a.getNormalMatrix(p),(v===null||v.length<m)&&(v=new Float32Array(m));for(let b=0,_=d;b!==x;++b,_+=4)o.copy(h[b]).applyMatrix4(p,a),o.normal.toArray(v,_),v[_+3]=o.constant}l.value=v,l.needsUpdate=!0}return t.numPlanes=x,t.numIntersection=0,v}}function K1(n){let t=new WeakMap;function e(o,a){return a===Uu?o.mapping=Ao:a===Bu&&(o.mapping=Co),o}function i(o){if(o&&o.isTexture&&o.isRenderTargetTexture===!1){let a=o.mapping;if(a===Uu||a===Bu)if(t.has(o)){let l=t.get(o).texture;return e(l,o.mapping)}else{let l=o.image;if(l&&l.height>0){let c=new ol(l.height/2);return c.fromEquirectangularTexture(n,o),t.set(o,c),o.addEventListener("dispose",r),e(c.texture,o.mapping)}else return null}}return o}function r(o){let a=o.target;a.removeEventListener("dispose",r);let l=t.get(a);l!==void 0&&(t.delete(a),l.dispose())}function s(){t=new WeakMap}return{get:i,dispose:s}}var Vi=class extends oo{constructor(t=-1,e=1,i=1,r=-1,s=.1,o=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=s,this.far=o,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,s,o){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,s=i-t,o=i+t,a=r+e,l=r-e;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;s+=c*this.view.offsetX,o=s+c*this.view.width,a-=u*this.view.offsetY,l=a-u*this.view.height}this.projectionMatrix.makeOrthographic(s,o,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,this.view!==null&&(e.object.view=Object.assign({},this.view)),e}};Vi.prototype.isOrthographicCamera=!0;var Xr=class extends Fn{constructor(t){super(t),this.type="RawShaderMaterial"}};Xr.prototype.isRawShaderMaterial=!0;var kr=4,ni=8,hn=Math.pow(2,ni),x0=[.125,.215,.35,.446,.526,.582],y0=ni-kr+1+x0.length,Ar=20,Tu=new Vi,{_lodPlanes:Gs,_sizeLods:mg,_sigmas:Ua}=Q1(),gg=new ft,Au=null,zi=(1+Math.sqrt(5))/2,Cr=1/zi,xg=[new T(1,1,1),new T(-1,1,1),new T(1,1,-1),new T(-1,1,-1),new T(0,zi,Cr),new T(0,zi,-Cr),new T(Cr,0,zi),new T(-Cr,0,zi),new T(zi,Cr,0),new T(-zi,Cr,0)],al=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=j1(Ar),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){Au=this._renderer.getRenderTarget();let s=this._allocateTargets();return this._sceneToCubeUV(t,i,r,s),e>0&&this._blur(s,0,0,e),this._applyPMREM(s),this._cleanup(s),s}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=_g(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=vg(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<Gs.length;t++)Gs[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(Au),t.scissorTest=!1,Ba(t,0,0,t.width,t.height)}_fromTexture(t,e){Au=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:be,minFilter:be,generateMipmaps:!1,type:Ur,format:Re,encoding:ri,depthBuffer:!1},i=yg(e);return i.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=yg(e)),i}_compileMaterial(t){let e=new oe(Gs[0],t);this._renderer.compile(e,Tu)}_sceneToCubeUV(t,e,i,r){let a=new Se(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(gg),u.toneMapping=ti,u.autoClear=!1;let d=new ki({name:"PMREM.Background",side:he,depthWrite:!1,depthTest:!1}),g=new oe(new Hi,d),x=!1,v=t.background;v?v.isColor&&(d.color.copy(v),t.background=null,x=!0):(d.color.copy(gg),x=!0);for(let m=0;m<6;m++){let p=m%3;p===0?(a.up.set(0,l[m],0),a.lookAt(c[m],0,0)):p===1?(a.up.set(0,0,l[m]),a.lookAt(0,c[m],0)):(a.up.set(0,l[m],0),a.lookAt(0,0,c[m])),Ba(r,p*hn,m>2?hn:0,hn,hn),u.setRenderTarget(r),x&&u.render(g,a),u.render(t,a)}g.geometry.dispose(),g.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=v}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Ao||t.mapping===Co;r?(this._cubemapShader===null&&(this._cubemapShader=_g()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=vg());let s=r?this._cubemapShader:this._equirectShader,o=new oe(Gs[0],s),a=s.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),Ba(e,0,0,3*hn,2*hn),i.setRenderTarget(e),i.render(o,Tu)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<y0;r++){let s=Math.sqrt(Ua[r]*Ua[r]-Ua[r-1]*Ua[r-1]),o=xg[(r-1)%xg.length];this._blur(t,r-1,r,s,o)}e.autoClear=i}_blur(t,e,i,r,s){let o=this._pingPongRenderTarget;this._halfBlur(t,o,e,i,r,"latitudinal",s),this._halfBlur(o,t,i,i,r,"longitudinal",s)}_halfBlur(t,e,i,r,s,o,a){let l=this._renderer,c=this._blurMaterial;o!=="latitudinal"&&o!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new oe(Gs[r],c),f=c.uniforms,d=mg[i]-1,g=isFinite(s)?Math.PI/(2*d):2*Math.PI/(2*Ar-1),x=s/g,v=isFinite(s)?1+Math.floor(u*x):Ar;v>Ar&&console.warn(`sigmaRadians, ${s}, is too large and will clip, as it requested ${v} samples when the maximum is set to ${Ar}`);let m=[],p=0;for(let L=0;L<Ar;++L){let A=L/x,H=Math.exp(-A*A/2);m.push(H),L===0?p+=H:L<v&&(p+=2*H)}for(let L=0;L<m.length;L++)m[L]=m[L]/p;f.envMap.value=t.texture,f.samples.value=v,f.weights.value=m,f.latitudinal.value=o==="latitudinal",a&&(f.poleAxis.value=a),f.dTheta.value=g,f.mipInt.value=ni-i;let b=mg[r],_=3*Math.max(0,hn-2*b),S=(r===0?0:2*hn)+2*b*(r>ni-kr?r-ni+kr:0);Ba(e,_,S,3*b,2*b),l.setRenderTarget(e),l.render(h,Tu)}};function Q1(){let n=[],t=[],e=[],i=ni;for(let r=0;r<y0;r++){let s=Math.pow(2,i);t.push(s);let o=1/s;r>ni-kr?o=x0[r-ni+kr-1]:r===0&&(o=0),e.push(o);let a=1/(s-1),l=-a/2,c=1+a/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,d=3,g=2,x=1,v=new Float32Array(d*f*h),m=new Float32Array(g*f*h),p=new Float32Array(x*f*h);for(let _=0;_<h;_++){let S=_%3*2/3-1,L=_>2?0:-1,A=[S,L,0,S+2/3,L,0,S+2/3,L+1,0,S,L,0,S+2/3,L+1,0,S,L+1,0];v.set(A,d*f*_),m.set(u,g*f*_);let H=[_,_,_,_,_,_];p.set(H,x*f*_)}let b=new Ht;b.setAttribute("position",new Qt(v,d)),b.setAttribute("uv",new Qt(m,g)),b.setAttribute("faceIndex",new Qt(p,x)),n.push(b),i>kr&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function yg(n){let t=new Ne(3*hn,3*hn,n);return t.texture.mapping=Rl,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function Ba(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function j1(n){let t=new Float32Array(n),e=new T(0,1,0);return new Xr({name:"SphericalGaussianBlur",defines:{n},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function vg(){let n=new K(1,1);return new Xr({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function _g(){return new Xr({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function jh(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function tS(n){let t=new WeakMap,e=null;function i(a){if(a&&a.isTexture){let l=a.mapping,c=l===Uu||l===Bu,u=l===Ao||l===Co;if(c||u)if(a.isRenderTargetTexture&&a.needsPMREMUpdate===!0){a.needsPMREMUpdate=!1;let h=t.get(a);return e===null&&(e=new al(n)),h=c?e.fromEquirectangular(a,h):e.fromCubemap(a,h),t.set(a,h),h.texture}else{if(t.has(a))return t.get(a).texture;{let h=a.image;if(c&&h&&h.height>0||u&&h&&r(h)){e===null&&(e=new al(n));let f=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,f),a.addEventListener("dispose",s),f.texture}else return null}}}return a}function r(a){let l=0,c=6;for(let u=0;u<c;u++)a[u]!==void 0&&l++;return l===c}function s(a){let l=a.target;l.removeEventListener("dispose",s);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function o(){t=new WeakMap,e!==null&&(e.dispose(),e=null)}return{get:i,dispose:o}}function eS(n){let t={};function e(i){if(t[i]!==void 0)return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return e(i)!==null},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return r===null&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function nS(n,t,e,i){let r={},s=new WeakMap;function o(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let g in f.attributes)t.remove(f.attributes[g]);f.removeEventListener("dispose",o),delete r[f.id];let d=s.get(f);d&&(t.remove(d),s.delete(f)),i.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,e.memory.geometries--}function a(h,f){return r[f.id]===!0||(f.addEventListener("dispose",o),r[f.id]=!0,e.memory.geometries++),f}function l(h){let f=h.attributes;for(let g in f)t.update(f[g],34962);let d=h.morphAttributes;for(let g in d){let x=d[g];for(let v=0,m=x.length;v<m;v++)t.update(x[v],34962)}}function c(h){let f=[],d=h.index,g=h.attributes.position,x=0;if(d!==null){let p=d.array;x=d.version;for(let b=0,_=p.length;b<_;b+=3){let S=p[b+0],L=p[b+1],A=p[b+2];f.push(S,L,L,A,A,S)}}else{let p=g.array;x=g.version;for(let b=0,_=p.length/3-1;b<_;b+=3){let S=b+0,L=b+1,A=b+2;f.push(S,L,L,A,A,S)}}let v=new(p0(f)?sl:rl)(f,1);v.version=x;let m=s.get(h);m&&t.remove(m),s.set(h,v)}function u(h){let f=s.get(h);if(f){let d=h.index;d!==null&&f.version<d.version&&c(h)}else c(h);return s.get(h)}return{get:a,update:l,getWireframeAttribute:u}}function iS(n,t,e,i){let r=i.isWebGL2,s;function o(f){s=f}let a,l;function c(f){a=f.type,l=f.bytesPerElement}function u(f,d){n.drawElements(s,d,a,f*l),e.update(d,s,1)}function h(f,d,g){if(g===0)return;let x,v;if(r)x=n,v="drawElementsInstanced";else if(x=t.get("ANGLE_instanced_arrays"),v="drawElementsInstancedANGLE",x===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}x[v](s,d,a,f*l,g),e.update(d,s,g)}this.setMode=o,this.setIndex=c,this.render=u,this.renderInstances=h}function rS(n){let t={geometries:0,textures:0},e={frame:0,calls:0,triangles:0,points:0,lines:0};function i(s,o,a){switch(e.calls++,o){case 4:e.triangles+=a*(s/3);break;case 1:e.lines+=a*(s/2);break;case 3:e.lines+=a*(s-1);break;case 2:e.lines+=a*s;break;case 0:e.points+=a*s;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",o);break}}function r(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0}return{memory:t,render:e,programs:null,autoReset:!0,reset:r,update:i}}var co=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};co.prototype.isDataTexture2DArray=!0;function sS(n,t){return n[0]-t[0]}function oS(n,t){return Math.abs(t[1])-Math.abs(n[1])}function wg(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function aS(n,t,e){let i={},r=new Float32Array(8),s=new WeakMap,o=new T,a=[];for(let c=0;c<8;c++)a[c]=[c,0];function l(c,u,h,f){let d=c.morphTargetInfluences;if(t.isWebGL2===!0){let g=u.morphAttributes.position.length,x=s.get(u);if(x===void 0||x.count!==g){let R=function(){X.dispose(),s.delete(u),u.removeEventListener("dispose",R)};x!==void 0&&x.texture.dispose();let p=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,_=u.morphAttributes.normal||[],S=u.attributes.position.count,L=p===!0?2:1,A=S*L,H=1;A>t.maxTextureSize&&(H=Math.ceil(A/t.maxTextureSize),A=t.maxTextureSize);let tt=new Float32Array(A*H*4*g),X=new co(tt,A,H,g);X.format=Re,X.type=Ui,X.needsUpdate=!0;let y=L*4;for(let D=0;D<g;D++){let F=b[D],z=_[D],N=A*H*4*D;for(let V=0;V<F.count;V++){o.fromBufferAttribute(F,V),F.normalized===!0&&wg(o,F);let Q=V*y;tt[N+Q+0]=o.x,tt[N+Q+1]=o.y,tt[N+Q+2]=o.z,tt[N+Q+3]=0,p===!0&&(o.fromBufferAttribute(z,V),z.normalized===!0&&wg(o,z),tt[N+Q+4]=o.x,tt[N+Q+5]=o.y,tt[N+Q+6]=o.z,tt[N+Q+7]=0)}}x={count:g,texture:X,size:new K(A,H)},s.set(u,x),u.addEventListener("dispose",R)}let v=0;for(let p=0;p<d.length;p++)v+=d[p];let m=u.morphTargetsRelative?1:1-v;f.getUniforms().setValue(n,"morphTargetBaseInfluence",m),f.getUniforms().setValue(n,"morphTargetInfluences",d),f.getUniforms().setValue(n,"morphTargetsTexture",x.texture,e),f.getUniforms().setValue(n,"morphTargetsTextureSize",x.size)}else{let g=d===void 0?0:d.length,x=i[u.id];if(x===void 0||x.length!==g){x=[];for(let _=0;_<g;_++)x[_]=[_,0];i[u.id]=x}for(let _=0;_<g;_++){let S=x[_];S[0]=_,S[1]=d[_]}x.sort(oS);for(let _=0;_<8;_++)_<g&&x[_][1]?(a[_][0]=x[_][0],a[_][1]=x[_][1]):(a[_][0]=Number.MAX_SAFE_INTEGER,a[_][1]=0);a.sort(sS);let v=u.morphAttributes.position,m=u.morphAttributes.normal,p=0;for(let _=0;_<8;_++){let S=a[_],L=S[0],A=S[1];L!==Number.MAX_SAFE_INTEGER&&A?(v&&u.getAttribute("morphTarget"+_)!==v[L]&&u.setAttribute("morphTarget"+_,v[L]),m&&u.getAttribute("morphNormal"+_)!==m[L]&&u.setAttribute("morphNormal"+_,m[L]),r[_]=A,p+=A):(v&&u.hasAttribute("morphTarget"+_)===!0&&u.deleteAttribute("morphTarget"+_),m&&u.hasAttribute("morphNormal"+_)===!0&&u.deleteAttribute("morphNormal"+_),r[_]=0)}let b=u.morphTargetsRelative?1:1-p;f.getUniforms().setValue(n,"morphTargetBaseInfluence",b),f.getUniforms().setValue(n,"morphTargetInfluences",r)}}return{update:l}}function lS(n,t,e,i){let r=new WeakMap;function s(l){let c=i.render.frame,u=l.geometry,h=t.get(l,u);return r.get(h)!==c&&(t.update(h),r.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",a)===!1&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),l.instanceColor!==null&&e.update(l.instanceColor,34962)),h}function o(){r=new WeakMap}function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),c.instanceColor!==null&&e.remove(c.instanceColor)}return{update:s,dispose:o}}var ll=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};ll.prototype.isDataTexture3D=!0;var v0=new ae,_0=new co,w0=new ll,M0=new Wr,Mg=[],bg=[],Sg=new Float32Array(16),Eg=new Float32Array(9),Tg=new Float32Array(4);function es(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,s=Mg[r];if(s===void 0&&(s=new Float32Array(r),Mg[r]=s),t!==0){i.toArray(s,0);for(let o=1,a=0;o!==t;++o)a+=e,n[o].toArray(s,a)}return s}function Le(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function Te(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function Pl(n,t){let e=bg[t];e===void 0&&(e=new Int32Array(t),bg[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function cS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function uS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(Le(e,t))return;n.uniform2fv(this.addr,t),Te(e,t)}}function hS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(t.r!==void 0)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(Le(e,t))return;n.uniform3fv(this.addr,t),Te(e,t)}}function fS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(Le(e,t))return;n.uniform4fv(this.addr,t),Te(e,t)}}function dS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Tg.set(i),n.uniformMatrix2fv(this.addr,!1,Tg),Te(e,i)}}function pS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Eg.set(i),n.uniformMatrix3fv(this.addr,!1,Eg),Te(e,i)}}function mS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Sg.set(i),n.uniformMatrix4fv(this.addr,!1,Sg),Te(e,i)}}function gS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function xS(n,t){let e=this.cache;Le(e,t)||(n.uniform2iv(this.addr,t),Te(e,t))}function yS(n,t){let e=this.cache;Le(e,t)||(n.uniform3iv(this.addr,t),Te(e,t))}function vS(n,t){let e=this.cache;Le(e,t)||(n.uniform4iv(this.addr,t),Te(e,t))}function _S(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function wS(n,t){let e=this.cache;Le(e,t)||(n.uniform2uiv(this.addr,t),Te(e,t))}function MS(n,t){let e=this.cache;Le(e,t)||(n.uniform3uiv(this.addr,t),Te(e,t))}function bS(n,t){let e=this.cache;Le(e,t)||(n.uniform4uiv(this.addr,t),Te(e,t))}function SS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||v0,r)}function ES(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||w0,r)}function TS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||M0,r)}function AS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||_0,r)}function CS(n){switch(n){case 5126:return cS;case 35664:return uS;case 35665:return hS;case 35666:return fS;case 35674:return dS;case 35675:return pS;case 35676:return mS;case 5124:case 35670:return gS;case 35667:case 35671:return xS;case 35668:case 35672:return yS;case 35669:case 35673:return vS;case 5125:return _S;case 36294:return wS;case 36295:return MS;case 36296:return bS;case 35678:case 36198:case 36298:case 36306:case 35682:return SS;case 35679:case 36299:case 36307:return ES;case 35680:case 36300:case 36308:case 36293:return TS;case 36289:case 36303:case 36311:case 36292:return AS}}function RS(n,t){n.uniform1fv(this.addr,t)}function LS(n,t){let e=es(t,this.size,2);n.uniform2fv(this.addr,e)}function PS(n,t){let e=es(t,this.size,3);n.uniform3fv(this.addr,e)}function DS(n,t){let e=es(t,this.size,4);n.uniform4fv(this.addr,e)}function IS(n,t){let e=es(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function NS(n,t){let e=es(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function FS(n,t){let e=es(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function zS(n,t){n.uniform1iv(this.addr,t)}function US(n,t){n.uniform2iv(this.addr,t)}function BS(n,t){n.uniform3iv(this.addr,t)}function OS(n,t){n.uniform4iv(this.addr,t)}function kS(n,t){n.uniform1uiv(this.addr,t)}function HS(n,t){n.uniform2uiv(this.addr,t)}function VS(n,t){n.uniform3uiv(this.addr,t)}function GS(n,t){n.uniform4uiv(this.addr,t)}function WS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTexture2D(t[s]||v0,r[s])}function qS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture3D(t[s]||w0,r[s])}function XS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTextureCube(t[s]||M0,r[s])}function YS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture2DArray(t[s]||_0,r[s])}function ZS(n){switch(n){case 5126:return RS;case 35664:return LS;case 35665:return PS;case 35666:return DS;case 35674:return IS;case 35675:return NS;case 35676:return FS;case 5124:case 35670:return zS;case 35667:case 35671:return US;case 35668:case 35672:return BS;case 35669:case 35673:return OS;case 5125:return kS;case 36294:return HS;case 36295:return VS;case 36296:return GS;case 35678:case 36198:case 36298:case 36306:case 35682:return WS;case 35679:case 36299:case 36307:return qS;case 35680:case 36300:case 36308:case 36293:return XS;case 36289:case 36303:case 36311:case 36292:return YS}}function JS(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=CS(t.type)}function b0(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=ZS(t.type)}b0.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),Te(t,n)};function S0(n){this.id=n,this.seq=[],this.map={}}S0.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,s=i.length;r!==s;++r){let o=i[r];o.setValue(n,t[o.id],e)}};var Cu=/(\w+)(\])?(\[|\.)?/g;function Ag(n,t){n.seq.push(t),n.map[t.id]=t}function $S(n,t,e){let i=n.name,r=i.length;for(Cu.lastIndex=0;;){let s=Cu.exec(i),o=Cu.lastIndex,a=s[1],l=s[2]==="]",c=s[3];if(l&&(a=a|0),c===void 0||c==="["&&o+2===r){Ag(e,c===void 0?new JS(a,n,t):new b0(a,n,t));break}else{let h=e.map[a];h===void 0&&(h=new S0(a),Ag(e,h)),e=h}}}function ii(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i),s=n.getUniformLocation(t,r.name);$S(r,s,this)}}ii.prototype.setValue=function(n,t,e,i){let r=this.map[t];r!==void 0&&r.setValue(n,e,i)};ii.prototype.setOptional=function(n,t,e){let i=t[e];i!==void 0&&this.setValue(n,e,i)};ii.upload=function(n,t,e,i){for(let r=0,s=t.length;r!==s;++r){let o=t[r],a=e[o.id];a.needsUpdate!==!1&&o.setValue(n,a.value,i)}};ii.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let s=n[i];s.id in t&&e.push(s)}return e};function Cg(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}var KS=0;function QS(n){let t=n.split(`
`);for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join(`
`)}function jS(n){switch(n){case ri:return["Linear","( value )"];case $t:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}function Rg(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&r===""?"":e.toUpperCase()+`

`+r+`

`+QS(n.getShaderSource(t))}function tE(n,t){let e=jS(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function eE(n,t){let e;switch(t){case Aw:e="Linear";break;case Cw:e="Reinhard";break;case Rw:e="OptimizedCineon";break;case Lw:e="ACESFilmic";break;case Pw:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function nE(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||n.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter($s).join(`
`)}function iE(n){let t=[];for(let e in n){let i=n[e];i!==!1&&t.push("#define "+e+" "+i)}return t.join(`
`)}function rE(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let s=n.getActiveAttrib(t,r),o=s.name,a=1;s.type===35674&&(a=2),s.type===35675&&(a=3),s.type===35676&&(a=4),e[o]={type:s.type,location:n.getAttribLocation(t,o),locationSize:a}}return e}function $s(n){return n!==""}function Lg(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Pg(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sE=/^[ \t]*#include +<([\w\d./]+)>/gm;function qu(n){return n.replace(sE,oE)}function oE(n,t){let e=Pt[t];if(e===void 0)throw new Error("Can not resolve #include <"+t+">");return qu(e)}var aE=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,lE=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Dg(n){return n.replace(lE,E0).replace(aE,cE)}function cE(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),E0(n,t,e,i)}function E0(n,t,e,i){let r="";for(let s=parseInt(t);s<parseInt(e);s++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+s+" ]").replace(/UNROLLED_LOOP_INDEX/g,s);return r}function Ig(n){let t="precision "+n.precision+` float;
precision `+n.precision+" int;";return n.precision==="highp"?t+=`
#define HIGH_PRECISION`:n.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:n.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function uE(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===l0?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===sw?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===Js&&(t="SHADOWMAP_TYPE_VSM"),t}function hE(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Ao:case Co:t="ENVMAP_TYPE_CUBE";break;case Rl:case Kh:t="ENVMAP_TYPE_CUBE_UV";break}return t}function fE(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case Co:case Kh:t="ENVMAP_MODE_REFRACTION";break}return t}function dE(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case Cl:t="ENVMAP_BLENDING_MULTIPLY";break;case Ew:t="ENVMAP_BLENDING_MIX";break;case Tw:t="ENVMAP_BLENDING_ADD";break}return t}function pE(n,t,e,i){let r=n.getContext(),s=e.defines,o=e.vertexShader,a=e.fragmentShader,l=uE(e),c=hE(e),u=fE(e),h=dE(e),f=e.isWebGL2?"":nE(e),d=iE(s),g=r.createProgram(),x,v,m=e.glslVersion?"#version "+e.glslVersion+`
`:"";e.isRawShaderMaterial?(x=[d].filter($s).join(`
`),x.length>0&&(x+=`
`),v=[f,d].filter($s).join(`
`),v.length>0&&(v+=`
`)):(x=[Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&e.flatShading===!1?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter($s).join(`
`),v=[f,Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+u:"",e.envMap?"#define "+h:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==ti?"#define TONE_MAPPING":"",e.toneMapping!==ti?Pt.tonemapping_pars_fragment:"",e.toneMapping!==ti?eE("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",Pt.encodings_pars_fragment,tE("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"",`
`].filter($s).join(`
`)),o=qu(o),o=Lg(o,e),o=Pg(o,e),a=qu(a),a=Lg(a,e),a=Pg(a,e),o=Dg(o),a=Dg(a),e.isWebGL2&&e.isRawShaderMaterial!==!0&&(m=`#version 300 es
`,x=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+x,v=["#define varying in",e.glslVersion===ng?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===ng?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+v);let p=m+x+o,b=m+v+a,_=Cg(r,35633,p),S=Cg(r,35632,b);if(r.attachShader(g,_),r.attachShader(g,S),e.index0AttributeName!==void 0?r.bindAttribLocation(g,0,e.index0AttributeName):e.morphTargets===!0&&r.bindAttribLocation(g,0,"position"),r.linkProgram(g),n.debug.checkShaderErrors){let H=r.getProgramInfoLog(g).trim(),tt=r.getShaderInfoLog(_).trim(),X=r.getShaderInfoLog(S).trim(),y=!0,R=!0;if(r.getProgramParameter(g,35714)===!1){y=!1;let D=Rg(r,_,"vertex"),F=Rg(r,S,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(g,35715)+`

Program Info Log: `+H+`
`+D+`
`+F)}else H!==""?console.warn("THREE.WebGLProgram: Program Info Log:",H):(tt===""||X==="")&&(R=!1);R&&(this.diagnostics={runnable:y,programLog:H,vertexShader:{log:tt,prefix:x},fragmentShader:{log:X,prefix:v}})}r.deleteShader(_),r.deleteShader(S);let L;this.getUniforms=function(){return L===void 0&&(L=new ii(r,g)),L};let A;return this.getAttributes=function(){return A===void 0&&(A=rE(r,g)),A},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(g),this.program=void 0},this.name=e.shaderName,this.id=KS++,this.cacheKey=t,this.usedTimes=1,this.program=g,this.vertexShader=_,this.fragmentShader=S,this}var mE=0,Xu=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let e=t.vertexShader,i=t.fragmentShader,r=this._getShaderStage(e),s=this._getShaderStage(i),o=this._getShaderCacheForMaterial(t);return o.has(r)===!1&&(o.add(r),r.usedTimes++),o.has(s)===!1&&(o.add(s),s.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,i.usedTimes===0&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return e.has(t)===!1&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(e.has(t)===!1){let i=new Yu;e.set(t,i)}return e.get(t)}},Yu=class{constructor(){this.id=mE++,this.usedTimes=0}};function gE(n,t,e,i,r,s,o){let a=new il,l=new Xu,c=[],u=r.isWebGL2,h=r.logarithmicDepthBuffer,f=r.floatVertexTextures,d=r.maxVertexUniforms,g=r.vertexTextures,x=r.precision,v={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function m(y){let D=y.skeleton.bones;if(f)return 1024;{let z=Math.floor((d-20)/4),N=Math.min(z,D.length);return N<D.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+D.length+" bones. This GPU supports "+N+"."),0):N}}function p(y,R,D,F,z){let N=F.fog,V=y.isMeshStandardMaterial?F.environment:null,Q=(y.isMeshStandardMaterial?e:t).get(y.envMap||V),at=v[y.type],G=z.isSkinnedMesh?m(z):0;y.precision!==null&&(x=r.getMaxPrecision(y.precision),x!==y.precision&&console.warn("THREE.WebGLProgram.getParameters:",y.precision,"not supported, using",x,"instead."));let $,lt,dt,xt;if(at){let B=fn[at];$=B.vertexShader,lt=B.fragmentShader}else $=y.vertexShader,lt=y.fragmentShader,l.update(y),dt=l.getVertexShaderID(y),xt=l.getFragmentShaderID(y);let k=n.getRenderTarget(),Ft=y.alphaTest>0,mt=y.clearcoat>0;return{isWebGL2:u,shaderID:at,shaderName:y.type,vertexShader:$,fragmentShader:lt,defines:y.defines,customVertexShaderID:dt,customFragmentShaderID:xt,isRawShaderMaterial:y.isRawShaderMaterial===!0,glslVersion:y.glslVersion,precision:x,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:g,outputEncoding:k===null?n.outputEncoding:k.isXRRenderTarget===!0?k.texture.encoding:ri,map:!!y.map,matcap:!!y.matcap,envMap:!!Q,envMapMode:Q&&Q.mapping,envMapCubeUV:!!Q&&(Q.mapping===Rl||Q.mapping===Kh),lightMap:!!y.lightMap,aoMap:!!y.aoMap,emissiveMap:!!y.emissiveMap,bumpMap:!!y.bumpMap,normalMap:!!y.normalMap,objectSpaceNormalMap:y.normalMapType===jw,tangentSpaceNormalMap:y.normalMapType===ts,decodeVideoTexture:!!y.map&&y.map.isVideoTexture===!0&&y.map.encoding===$t,clearcoat:mt,clearcoatMap:mt&&!!y.clearcoatMap,clearcoatRoughnessMap:mt&&!!y.clearcoatRoughnessMap,clearcoatNormalMap:mt&&!!y.clearcoatNormalMap,displacementMap:!!y.displacementMap,roughnessMap:!!y.roughnessMap,metalnessMap:!!y.metalnessMap,specularMap:!!y.specularMap,specularIntensityMap:!!y.specularIntensityMap,specularColorMap:!!y.specularColorMap,alphaMap:!!y.alphaMap,alphaTest:Ft,alphaWrite:y.alphaWrite||y.transparent,gradientMap:!!y.gradientMap,sheen:y.sheen>0,sheenColorMap:!!y.sheenColorMap,sheenRoughnessMap:!!y.sheenRoughnessMap,transmission:y.transmission>0,transmissionMap:!!y.transmissionMap,thicknessMap:!!y.thicknessMap,combine:y.combine,vertexTangents:!!y.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:y.vertexColors,vertexAlphas:y.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatMap||!!y.clearcoatRoughnessMap||!!y.clearcoatNormalMap||!!y.displacementMap||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||!!y.sheenColorMap||!!y.sheenRoughnessMap,uvsVertexOnly:!(!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatNormalMap||y.transmission>0||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||y.sheen>0||!!y.sheenColorMap||!!y.sheenRoughnessMap)&&!!y.displacementMap,fog:!!N,useFog:y.fog,fogExp2:N&&N.isFogExp2,flatShading:!!y.flatShading,sizeAttenuation:y.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&G>0,maxBones:G,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:R.directional.length,numPointLights:R.point.length,numSpotLights:R.spot.length,numRectAreaLights:R.rectArea.length,numHemiLights:R.hemi.length,numDirLightShadows:R.directionalShadowMap.length,numPointLightShadows:R.pointShadowMap.length,numSpotLightShadows:R.spotShadowMap.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:y.dithering,shadowMapEnabled:n.shadowMap.enabled&&D.length>0,shadowMapType:n.shadowMap.type,toneMapping:y.toneMapped?n.toneMapping:ti,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:y.premultipliedAlpha,doubleSided:y.side===Hr,flipSided:y.side===he,depthPacking:y.depthPacking!==void 0?y.depthPacking:!1,index0AttributeName:y.index0AttributeName,extensionDerivatives:y.extensions&&y.extensions.derivatives,extensionFragDepth:y.extensions&&y.extensions.fragDepth,extensionDrawBuffers:y.extensions&&y.extensions.drawBuffers,extensionShaderTextureLOD:y.extensions&&y.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),customProgramCacheKey:y.customProgramCacheKey()}}function b(y){let R=[];if(y.shaderID?R.push(y.shaderID):(R.push(y.customVertexShaderID),R.push(y.customFragmentShaderID)),y.defines!==void 0)for(let D in y.defines)R.push(D),R.push(y.defines[D]);return y.isRawShaderMaterial===!1&&(_(R,y),S(R,y),R.push(n.outputEncoding)),R.push(y.customProgramCacheKey),R.join()}function _(y,R){y.push(R.precision),y.push(R.outputEncoding),y.push(R.envMapMode),y.push(R.combine),y.push(R.vertexUvs),y.push(R.fogExp2),y.push(R.sizeAttenuation),y.push(R.maxBones),y.push(R.morphTargetsCount),y.push(R.numDirLights),y.push(R.numPointLights),y.push(R.numSpotLights),y.push(R.numHemiLights),y.push(R.numRectAreaLights),y.push(R.numDirLightShadows),y.push(R.numPointLightShadows),y.push(R.numSpotLightShadows),y.push(R.shadowMapType),y.push(R.toneMapping),y.push(R.numClippingPlanes),y.push(R.numClipIntersection),y.push(R.alphaWrite)}function S(y,R){a.disableAll(),R.isWebGL2&&a.enable(0),R.supportsVertexTextures&&a.enable(1),R.instancing&&a.enable(2),R.instancingColor&&a.enable(3),R.map&&a.enable(4),R.matcap&&a.enable(5),R.envMap&&a.enable(6),R.envMapCubeUV&&a.enable(7),R.lightMap&&a.enable(8),R.aoMap&&a.enable(9),R.emissiveMap&&a.enable(10),R.bumpMap&&a.enable(11),R.normalMap&&a.enable(12),R.objectSpaceNormalMap&&a.enable(13),R.tangentSpaceNormalMap&&a.enable(14),R.clearcoat&&a.enable(15),R.clearcoatMap&&a.enable(16),R.clearcoatRoughnessMap&&a.enable(17),R.clearcoatNormalMap&&a.enable(18),R.displacementMap&&a.enable(19),R.specularMap&&a.enable(20),R.roughnessMap&&a.enable(21),R.metalnessMap&&a.enable(22),R.gradientMap&&a.enable(23),R.alphaMap&&a.enable(24),R.alphaTest&&a.enable(25),R.vertexColors&&a.enable(26),R.vertexAlphas&&a.enable(27),R.vertexUvs&&a.enable(28),R.vertexTangents&&a.enable(29),R.uvsVertexOnly&&a.enable(30),R.fog&&a.enable(31),y.push(a.mask),a.disableAll(),R.useFog&&a.enable(0),R.flatShading&&a.enable(1),R.logarithmicDepthBuffer&&a.enable(2),R.skinning&&a.enable(3),R.useVertexTexture&&a.enable(4),R.morphTargets&&a.enable(5),R.morphNormals&&a.enable(6),R.premultipliedAlpha&&a.enable(7),R.shadowMapEnabled&&a.enable(8),R.physicallyCorrectLights&&a.enable(9),R.doubleSided&&a.enable(10),R.flipSided&&a.enable(11),R.depthPacking&&a.enable(12),R.dithering&&a.enable(13),R.specularIntensityMap&&a.enable(14),R.specularColorMap&&a.enable(15),R.transmission&&a.enable(16),R.transmissionMap&&a.enable(17),R.thicknessMap&&a.enable(18),R.sheen&&a.enable(19),R.sheenColorMap&&a.enable(20),R.sheenRoughnessMap&&a.enable(21),R.decodeVideoTexture&&a.enable(22),y.push(a.mask)}function L(y){let R=v[y.type],D;if(R){let F=fn[R];D=pM.clone(F.uniforms)}else D=y.uniforms;return D}function A(y,R){let D;for(let F=0,z=c.length;F<z;F++){let N=c[F];if(N.cacheKey===R){D=N,++D.usedTimes;break}}return D===void 0&&(D=new pE(n,R,y,s),c.push(D)),D}function H(y){if(--y.usedTimes===0){let R=c.indexOf(y);c[R]=c[c.length-1],c.pop(),y.destroy()}}function tt(y){l.remove(y)}function X(){l.dispose()}return{getParameters:p,getProgramCacheKey:b,getUniforms:L,acquireProgram:A,releaseProgram:H,releaseShaderCache:tt,programs:c,dispose:X}}function xE(){let n=new WeakMap;function t(s){let o=n.get(s);return o===void 0&&(o={},n.set(s,o)),o}function e(s){n.delete(s)}function i(s,o,a){n.get(s)[o]=a}function r(){n=new WeakMap}return{get:t,remove:e,update:i,dispose:r}}function yE(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function Ng(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Fg(){let n=[],t=0,e=[],i=[],r=[];function s(){t=0,e.length=0,i.length=0,r.length=0}function o(h,f,d,g,x,v){let m=n[t];return m===void 0?(m={id:h.id,object:h,geometry:f,material:d,groupOrder:g,renderOrder:h.renderOrder,z:x,group:v},n[t]=m):(m.id=h.id,m.object=h,m.geometry=f,m.material=d,m.groupOrder=g,m.renderOrder=h.renderOrder,m.z=x,m.group=v),t++,m}function a(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.push(m):d.transparent===!0?r.push(m):e.push(m)}function l(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.unshift(m):d.transparent===!0?r.unshift(m):e.unshift(m)}function c(h,f){e.length>1&&e.sort(h||yE),i.length>1&&i.sort(f||Ng),r.length>1&&r.sort(f||Ng)}function u(){for(let h=t,f=n.length;h<f;h++){let d=n[h];if(d.id===null)break;d.id=null,d.object=null,d.geometry=null,d.material=null,d.group=null}}return{opaque:e,transmissive:i,transparent:r,init:s,push:a,unshift:l,finish:u,sort:c}}function vE(){let n=new WeakMap;function t(i,r){let s;return n.has(i)===!1?(s=new Fg,n.set(i,[s])):r>=n.get(i).length?(s=new Fg,n.get(i).push(s)):s=n.get(i)[r],s}function e(){n=new WeakMap}return{get:t,dispose:e}}function _E(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new T,color:new ft};break;case"SpotLight":e={position:new T,direction:new T,color:new ft,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new T,color:new ft,distance:0,decay:0};break;case"HemisphereLight":e={direction:new T,skyColor:new ft,groundColor:new ft};break;case"RectAreaLight":e={color:new ft,position:new T,halfWidth:new T,halfHeight:new T};break}return n[t.id]=e,e}}}function wE(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K,shadowCameraNear:1,shadowCameraFar:1e3};break}return n[t.id]=e,e}}}var ME=0;function bE(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function SE(n,t){let e=new _E,i=wE(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)r.probe.push(new T);let s=new T,o=new wt,a=new wt;function l(u,h){let f=0,d=0,g=0;for(let tt=0;tt<9;tt++)r.probe[tt].set(0,0,0);let x=0,v=0,m=0,p=0,b=0,_=0,S=0,L=0;u.sort(bE);let A=h!==!0?Math.PI:1;for(let tt=0,X=u.length;tt<X;tt++){let y=u[tt],R=y.color,D=y.intensity,F=y.distance,z=y.shadow&&y.shadow.map?y.shadow.map.texture:null;if(y.isAmbientLight)f+=R.r*D*A,d+=R.g*D*A,g+=R.b*D*A;else if(y.isLightProbe)for(let N=0;N<9;N++)r.probe[N].addScaledVector(y.sh.coefficients[N],D);else if(y.isDirectionalLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.directionalShadow[x]=Q,r.directionalShadowMap[x]=z,r.directionalShadowMatrix[x]=y.shadow.matrix,_++}r.directional[x]=N,x++}else if(y.isSpotLight){let N=e.get(y);if(N.position.setFromMatrixPosition(y.matrixWorld),N.color.copy(R).multiplyScalar(D*A),N.distance=F,N.coneCos=Math.cos(y.angle),N.penumbraCos=Math.cos(y.angle*(1-y.penumbra)),N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.spotShadow[m]=Q,r.spotShadowMap[m]=z,r.spotShadowMatrix[m]=y.shadow.matrix,L++}r.spot[m]=N,m++}else if(y.isRectAreaLight){let N=e.get(y);N.color.copy(R).multiplyScalar(D),N.halfWidth.set(y.width*.5,0,0),N.halfHeight.set(0,y.height*.5,0),r.rectArea[p]=N,p++}else if(y.isPointLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),N.distance=y.distance,N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,Q.shadowCameraNear=V.camera.near,Q.shadowCameraFar=V.camera.far,r.pointShadow[v]=Q,r.pointShadowMap[v]=z,r.pointShadowMatrix[v]=y.shadow.matrix,S++}r.point[v]=N,v++}else if(y.isHemisphereLight){let N=e.get(y);N.skyColor.copy(y.color).multiplyScalar(D*A),N.groundColor.copy(y.groundColor).multiplyScalar(D*A),r.hemi[b]=N,b++}}p>0&&(t.isWebGL2||n.has("OES_texture_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_FLOAT_1,r.rectAreaLTC2=ot.LTC_FLOAT_2):n.has("OES_texture_half_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_HALF_1,r.rectAreaLTC2=ot.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=f,r.ambient[1]=d,r.ambient[2]=g;let H=r.hash;(H.directionalLength!==x||H.pointLength!==v||H.spotLength!==m||H.rectAreaLength!==p||H.hemiLength!==b||H.numDirectionalShadows!==_||H.numPointShadows!==S||H.numSpotShadows!==L)&&(r.directional.length=x,r.spot.length=m,r.rectArea.length=p,r.point.length=v,r.hemi.length=b,r.directionalShadow.length=_,r.directionalShadowMap.length=_,r.pointShadow.length=S,r.pointShadowMap.length=S,r.spotShadow.length=L,r.spotShadowMap.length=L,r.directionalShadowMatrix.length=_,r.pointShadowMatrix.length=S,r.spotShadowMatrix.length=L,H.directionalLength=x,H.pointLength=v,H.spotLength=m,H.rectAreaLength=p,H.hemiLength=b,H.numDirectionalShadows=_,H.numPointShadows=S,H.numSpotShadows=L,r.version=ME++)}function c(u,h){let f=0,d=0,g=0,x=0,v=0,m=h.matrixWorldInverse;for(let p=0,b=u.length;p<b;p++){let _=u[p];if(_.isDirectionalLight){let S=r.directional[f];S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),f++}else if(_.isSpotLight){let S=r.spot[g];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),g++}else if(_.isRectAreaLight){let S=r.rectArea[x];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),a.identity(),o.copy(_.matrixWorld),o.premultiply(m),a.extractRotation(o),S.halfWidth.set(_.width*.5,0,0),S.halfHeight.set(0,_.height*.5,0),S.halfWidth.applyMatrix4(a),S.halfHeight.applyMatrix4(a),x++}else if(_.isPointLight){let S=r.point[d];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),d++}else if(_.isHemisphereLight){let S=r.hemi[v];S.direction.setFromMatrixPosition(_.matrixWorld),S.direction.transformDirection(m),S.direction.normalize(),v++}}}return{setup:l,setupView:c,state:r}}function zg(n,t){let e=new SE(n,t),i=[],r=[];function s(){i.length=0,r.length=0}function o(h){i.push(h)}function a(h){r.push(h)}function l(h){e.setup(i,h)}function c(h){e.setupView(i,h)}return{init:s,state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:l,setupLightsView:c,pushLight:o,pushShadow:a}}function EE(n,t){let e=new WeakMap;function i(s,o=0){let a;return e.has(s)===!1?(a=new zg(n,t),e.set(s,[a])):o>=e.get(s).length?(a=new zg(n,t),e.get(s).push(a)):a=e.get(s)[o],a}function r(){e=new WeakMap}return{get:i,dispose:r}}var cl=class extends xe{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Kw,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};cl.prototype.isMeshDepthMaterial=!0;var ul=class extends xe{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new T,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};ul.prototype.isMeshDistanceMaterial=!0;var TE=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,AE=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function T0(n,t,e){let i=new qr,r=new K,s=new K,o=new Wt,a=new cl({depthPacking:Qw}),l=new ul,c={},u=e.maxTextureSize,h={0:he,1:eo,2:Hr},f=new Fn({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new K},radius:{value:4}},vertexShader:TE,fragmentShader:AE}),d=f.clone();d.defines.HORIZONTAL_PASS=1;let g=new Ht;g.setAttribute("position",new Qt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let x=new oe(g,f),v=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=l0,this.render=function(_,S,L){if(v.enabled===!1||v.autoUpdate===!1&&v.needsUpdate===!1||_.length===0)return;let A=n.getRenderTarget(),H=n.getActiveCubeFace(),tt=n.getActiveMipmapLevel(),X=n.state;X.setBlending(jn),X.buffers.color.setClear(1,1,1,1),X.buffers.depth.setTest(!0),X.setScissorTest(!1);for(let y=0,R=_.length;y<R;y++){let D=_[y],F=D.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",D,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;r.copy(F.mapSize);let z=F.getFrameExtents();if(r.multiply(z),s.copy(F.mapSize),(r.x>u||r.y>u)&&(r.x>u&&(s.x=Math.floor(u/z.x),r.x=s.x*z.x,F.mapSize.x=s.x),r.y>u&&(s.y=Math.floor(u/z.y),r.y=s.y*z.y,F.mapSize.y=s.y)),F.map===null&&!F.isPointLightShadow&&this.type===Js){let V={minFilter:be,magFilter:be,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.mapPass=new Ne(r.x,r.y,V),F.camera.updateProjectionMatrix()}if(F.map===null){let V={minFilter:fe,magFilter:fe,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.camera.updateProjectionMatrix()}n.setRenderTarget(F.map),n.clear();let N=F.getViewportCount();for(let V=0;V<N;V++){let Q=F.getViewport(V);o.set(s.x*Q.x,s.y*Q.y,s.x*Q.z,s.y*Q.w),X.viewport(o),F.updateMatrices(D,V),i=F.getFrustum(),b(S,L,F.camera,D,this.type)}!F.isPointLightShadow&&this.type===Js&&m(F,L),F.needsUpdate=!1}v.needsUpdate=!1,n.setRenderTarget(A,H,tt)};function m(_,S){let L=t.update(x);f.defines.VSM_SAMPLES!==_.blurSamples&&(f.defines.VSM_SAMPLES=_.blurSamples,d.defines.VSM_SAMPLES=_.blurSamples,f.needsUpdate=!0,d.needsUpdate=!0),f.uniforms.shadow_pass.value=_.map.texture,f.uniforms.resolution.value=_.mapSize,f.uniforms.radius.value=_.radius,n.setRenderTarget(_.mapPass),n.clear(),n.renderBufferDirect(S,null,L,f,x,null),d.uniforms.shadow_pass.value=_.mapPass.texture,d.uniforms.resolution.value=_.mapSize,d.uniforms.radius.value=_.radius,n.setRenderTarget(_.map),n.clear(),n.renderBufferDirect(S,null,L,d,x,null)}function p(_,S,L,A,H,tt,X){let y=null,R=A.isPointLight===!0?_.customDistanceMaterial:_.customDepthMaterial;if(R!==void 0?y=R:y=A.isPointLight===!0?l:a,n.localClippingEnabled&&L.clipShadows===!0&&L.clippingPlanes.length!==0||L.displacementMap&&L.displacementScale!==0||L.alphaMap&&L.alphaTest>0){let D=y.uuid,F=L.uuid,z=c[D];z===void 0&&(z={},c[D]=z);let N=z[F];N===void 0&&(N=y.clone(),z[F]=N),y=N}return y.visible=L.visible,y.wireframe=L.wireframe,X===Js?y.side=L.shadowSide!==null?L.shadowSide:L.side:y.side=L.shadowSide!==null?L.shadowSide:h[L.side],y.alphaMap=L.alphaMap,y.alphaTest=L.alphaTest,y.clipShadows=L.clipShadows,y.clippingPlanes=L.clippingPlanes,y.clipIntersection=L.clipIntersection,y.displacementMap=L.displacementMap,y.displacementScale=L.displacementScale,y.displacementBias=L.displacementBias,y.wireframeLinewidth=L.wireframeLinewidth,y.linewidth=L.linewidth,A.isPointLight===!0&&y.isMeshDistanceMaterial===!0&&(y.referencePosition.setFromMatrixPosition(A.matrixWorld),y.nearDistance=H,y.farDistance=tt),y}function b(_,S,L,A,H){if(_.visible===!1)return;if(_.layers.test(S.layers)&&(_.isMesh||_.isLine||_.isPoints)&&(_.castShadow||_.receiveShadow&&H===Js)&&(!_.frustumCulled||i.intersectsObject(_))){_.modelViewMatrix.multiplyMatrices(L.matrixWorldInverse,_.matrixWorld);let y=t.update(_),R=_.material;if(Array.isArray(R)){let D=y.groups;for(let F=0,z=D.length;F<z;F++){let N=D[F],V=R[N.materialIndex];if(V&&V.visible){let Q=p(_,y,V,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,Q,_,N)}}}else if(R.visible){let D=p(_,y,R,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,D,_,null)}}let X=_.children;for(let y=0,R=X.length;y<R;y++)b(X[y],S,L,A,H)}}function CE(n,t,e){let i=e.isWebGL2;function r(){let P=!1,pt=new Wt,ht=null,Et=new Wt(0,0,0,0);return{setMask:function(Y){ht!==Y&&!P&&(n.colorMask(Y,Y,Y,Y),ht=Y)},setLocked:function(Y){P=Y},setClear:function(Y,Mt,Dt,jt,ze){ze===!0&&(Y*=jt,Mt*=jt,Dt*=jt),pt.set(Y,Mt,Dt,jt),Et.equals(pt)===!1&&(n.clearColor(Y,Mt,Dt,jt),Et.copy(pt))},reset:function(){P=!1,ht=null,Et.set(-1,0,0,0)}}}function s(){let P=!1,pt=null,ht=null,Et=null;return{setTest:function(Y){Y?k(2929):Ft(2929)},setMask:function(Y){pt!==Y&&!P&&(n.depthMask(Y),pt=Y)},setFunc:function(Y){if(ht!==Y){if(Y)switch(Y){case yw:n.depthFunc(512);break;case vw:n.depthFunc(519);break;case _w:n.depthFunc(513);break;case zu:n.depthFunc(515);break;case ww:n.depthFunc(514);break;case Mw:n.depthFunc(518);break;case bw:n.depthFunc(516);break;case Sw:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);ht=Y}},setLocked:function(Y){P=Y},setClear:function(Y){Et!==Y&&(n.clearDepth(Y),Et=Y)},reset:function(){P=!1,pt=null,ht=null,Et=null}}}function o(){let P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null;return{setTest:function(ne){P||(ne?k(2960):Ft(2960))},setMask:function(ne){pt!==ne&&!P&&(n.stencilMask(ne),pt=ne)},setFunc:function(ne,en,yn){(ht!==ne||Et!==en||Y!==yn)&&(n.stencilFunc(ne,en,yn),ht=ne,Et=en,Y=yn)},setOp:function(ne,en,yn){(Mt!==ne||Dt!==en||jt!==yn)&&(n.stencilOp(ne,en,yn),Mt=ne,Dt=en,jt=yn)},setLocked:function(ne){P=ne},setClear:function(ne){ze!==ne&&(n.clearStencil(ne),ze=ne)},reset:function(){P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null}}}let a=new r,l=new s,c=new o,u={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,D=n.getParameter(35661),F=!1,z=0,N=n.getParameter(7938);N.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(N)[1]),F=z>=1):N.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(N)[1]),F=z>=2);let V=null,Q={},at=n.getParameter(3088),G=n.getParameter(2978),$=new Wt().fromArray(at),lt=new Wt().fromArray(G);function dt(P,pt,ht){let Et=new Uint8Array(4),Y=n.createTexture();n.bindTexture(P,Y),n.texParameteri(P,10241,9728),n.texParameteri(P,10240,9728);for(let Mt=0;Mt<ht;Mt++)n.texImage2D(pt+Mt,0,6408,1,1,0,6408,5121,Et);return Y}let xt={};xt[3553]=dt(3553,3553,1),xt[34067]=dt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),k(2929),l.setFunc(zu),J(!1),it(Am),k(2884),C(jn);function k(P){u[P]!==!0&&(n.enable(P),u[P]=!0)}function Ft(P){u[P]!==!1&&(n.disable(P),u[P]=!1)}function mt(P,pt){return h[P]!==pt?(n.bindFramebuffer(P,pt),h[P]=pt,i&&(P===36009&&(h[36160]=pt),P===36160&&(h[36009]=pt)),!0):!1}function St(P,pt){let ht=d,Et=!1;if(P)if(ht=f.get(pt),ht===void 0&&(ht=[],f.set(pt,ht)),P.isWebGLMultipleRenderTargets){let Y=P.texture;if(ht.length!==Y.length||ht[0]!==36064){for(let Mt=0,Dt=Y.length;Mt<Dt;Mt++)ht[Mt]=36064+Mt;ht.length=Y.length,Et=!0}}else ht[0]!==36064&&(ht[0]=36064,Et=!0);else ht[0]!==1029&&(ht[0]=1029,Et=!0);Et&&(e.isWebGL2?n.drawBuffers(ht):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(ht))}function B(P){return g!==P?(n.useProgram(P),g=P,!0):!1}let st={[Ir]:32774,[aw]:32778,[lw]:32779};if(i)st[Pm]=32775,st[Dm]=32776;else{let P=t.get("EXT_blend_minmax");P!==null&&(st[Pm]=P.MIN_EXT,st[Dm]=P.MAX_EXT)}let nt={[cw]:0,[uw]:1,[hw]:768,[u0]:770,[xw]:776,[mw]:774,[dw]:772,[fw]:769,[h0]:771,[gw]:775,[pw]:773};function C(P,pt,ht,Et,Y,Mt,Dt,jt){if(P===jn){x===!0&&(Ft(3042),x=!1);return}if(x===!1&&(k(3042),x=!0),P!==ow){if(P!==v||jt!==A){if((m!==Ir||_!==Ir)&&(n.blendEquation(32774),m=Ir,_=Ir),jt)switch(P){case Ks:n.blendFuncSeparate(1,771,1,771);break;case Cm:n.blendFunc(1,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}else switch(P){case Ks:n.blendFuncSeparate(770,771,1,771);break;case Cm:n.blendFunc(770,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}p=null,b=null,S=null,L=null,v=P,A=jt}return}Y=Y||pt,Mt=Mt||ht,Dt=Dt||Et,(pt!==m||Y!==_)&&(n.blendEquationSeparate(st[pt],st[Y]),m=pt,_=Y),(ht!==p||Et!==b||Mt!==S||Dt!==L)&&(n.blendFuncSeparate(nt[ht],nt[Et],nt[Mt],nt[Dt]),p=ht,b=Et,S=Mt,L=Dt),v=P,A=null}function j(P,pt){P.side===Hr?Ft(2884):k(2884);let ht=P.side===he;pt&&(ht=!ht),J(ht),P.blending===Ks&&P.transparent===!1?C(jn):C(P.blending,P.blendEquation,P.blendSrc,P.blendDst,P.blendEquationAlpha,P.blendSrcAlpha,P.blendDstAlpha,P.premultipliedAlpha),l.setFunc(P.depthFunc),l.setTest(P.depthTest),l.setMask(P.depthWrite),a.setMask(P.colorWrite);let Et=P.stencilWrite;c.setTest(Et),Et&&(c.setMask(P.stencilWriteMask),c.setFunc(P.stencilFunc,P.stencilRef,P.stencilFuncMask),c.setOp(P.stencilFail,P.stencilZFail,P.stencilZPass)),vt(P.polygonOffset,P.polygonOffsetFactor,P.polygonOffsetUnits),P.alphaToCoverage===!0?k(32926):Ft(32926)}function J(P){H!==P&&(P?n.frontFace(2304):n.frontFace(2305),H=P)}function it(P){P!==iw?(k(2884),P!==tt&&(P===Am?n.cullFace(1029):P===rw?n.cullFace(1028):n.cullFace(1032))):Ft(2884),tt=P}function et(P){P!==X&&(F&&n.lineWidth(P),X=P)}function vt(P,pt,ht){P?(k(32823),(y!==pt||R!==ht)&&(n.polygonOffset(pt,ht),y=pt,R=ht)):Ft(32823)}function bt(P){P?k(3089):Ft(3089)}function It(P){P===void 0&&(P=33984+D-1),V!==P&&(n.activeTexture(P),V=P)}function Zt(P,pt){V===null&&It();let ht=Q[V];ht===void 0&&(ht={type:void 0,texture:void 0},Q[V]=ht),(ht.type!==P||ht.texture!==pt)&&(n.bindTexture(P,pt||xt[P]),ht.type=P,ht.texture=pt)}function qt(){let P=Q[V];P!==void 0&&P.type!==void 0&&(n.bindTexture(P.type,null),P.type=void 0,P.texture=void 0)}function E(){try{n.compressedTexImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function w(){try{n.texSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function q(){try{n.texSubImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function rt(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function gt(){try{n.texStorage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function W(){try{n.texStorage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function _t(){try{n.texImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function yt(){try{n.texImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function ut(P){$.equals(P)===!1&&(n.scissor(P.x,P.y,P.z,P.w),$.copy(P))}function ct(P){lt.equals(P)===!1&&(n.viewport(P.x,P.y,P.z,P.w),lt.copy(P))}function At(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),i===!0&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),u={},V=null,Q={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,$.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}return{buffers:{color:a,depth:l,stencil:c},enable:k,disable:Ft,bindFramebuffer:mt,drawBuffers:St,useProgram:B,setBlending:C,setMaterial:j,setFlipSided:J,setCullFace:it,setLineWidth:et,setPolygonOffset:vt,setScissorTest:bt,activeTexture:It,bindTexture:Zt,unbindTexture:qt,compressedTexImage2D:E,texImage2D:_t,texImage3D:yt,texStorage2D:gt,texStorage3D:W,texSubImage2D:w,texSubImage3D:q,compressedTexSubImage2D:rt,scissor:ut,viewport:ct,reset:At}}function RE(n,t,e,i,r,s,o){let a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,h=r.maxSamples,d=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,g=new WeakMap,x,v=!1;try{v=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(E){}function m(E,w){return v?new OffscreenCanvas(E,w):ro("canvas")}function p(E,w,q,rt){let gt=1;if((E.width>rt||E.height>rt)&&(gt=rt/Math.max(E.width,E.height)),gt<1||w===!0)if(typeof HTMLImageElement!="undefined"&&E instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&E instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&E instanceof ImageBitmap){let W=w?nM:Math.floor,_t=W(gt*E.width),yt=W(gt*E.height);x===void 0&&(x=m(_t,yt));let ut=q?m(_t,yt):x;return ut.width=_t,ut.height=yt,ut.getContext("2d").drawImage(E,0,0,_t,yt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+E.width+"x"+E.height+") to ("+_t+"x"+yt+")."),ut}else return"data"in E&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+E.width+"x"+E.height+")."),E;return E}function b(E){return ig(E.width)&&ig(E.height)}function _(E){return a?!1:E.wrapS!==Ve||E.wrapT!==Ve||E.minFilter!==fe&&E.minFilter!==be}function S(E,w){return E.generateMipmaps&&w&&E.minFilter!==fe&&E.minFilter!==be}function L(E){n.generateMipmap(E)}function A(E,w,q,rt,gt=!1){if(a===!1)return w;if(E!==null){if(n[E]!==void 0)return n[E];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+E+"'")}let W=w;return w===6403&&(q===5126&&(W=33326),q===5131&&(W=33325),q===5121&&(W=33321)),w===33319&&(q===5126&&(W=33328),q===5131&&(W=33327),q===5121&&(W=33323)),w===6408&&(q===5126&&(W=34836),q===5131&&(W=34842),q===5121&&(W=rt===$t&&gt===!1?35907:32856),q===32819&&(W=32854),q===32820&&(W=32855)),(W===33325||W===33326||W===33327||W===33328||W===34842||W===34836)&&t.get("EXT_color_buffer_float"),W}function H(E,w,q){return S(E,q)===!0||E.isFramebufferTexture&&E.minFilter!==fe&&E.minFilter!==be?Math.log2(Math.max(w.width,w.height))+1:E.mipmaps!==void 0&&E.mipmaps.length>0?E.mipmaps.length:E.isCompressedTexture&&Array.isArray(E.image)?w.mipmaps.length:1}function tt(E){return E===fe||E===Im||E===Nm?9728:9729}function X(E){let w=E.target;w.removeEventListener("dispose",X),R(w),w.isVideoTexture&&g.delete(w),o.memory.textures--}function y(E){let w=E.target;w.removeEventListener("dispose",y),D(w)}function R(E){let w=i.get(E);w.__webglInit!==void 0&&(n.deleteTexture(w.__webglTexture),i.remove(E))}function D(E){let w=E.texture,q=i.get(E),rt=i.get(w);if(!!E){if(rt.__webglTexture!==void 0&&(n.deleteTexture(rt.__webglTexture),o.memory.textures--),E.depthTexture&&E.depthTexture.dispose(),E.isWebGLCubeRenderTarget)for(let gt=0;gt<6;gt++)n.deleteFramebuffer(q.__webglFramebuffer[gt]),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer[gt]);else n.deleteFramebuffer(q.__webglFramebuffer),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer),q.__webglMultisampledFramebuffer&&n.deleteFramebuffer(q.__webglMultisampledFramebuffer),q.__webglColorRenderbuffer&&n.deleteRenderbuffer(q.__webglColorRenderbuffer),q.__webglDepthRenderbuffer&&n.deleteRenderbuffer(q.__webglDepthRenderbuffer);if(E.isWebGLMultipleRenderTargets)for(let gt=0,W=w.length;gt<W;gt++){let _t=i.get(w[gt]);_t.__webglTexture&&(n.deleteTexture(_t.__webglTexture),o.memory.textures--),i.remove(w[gt])}i.remove(w),i.remove(E)}}let F=0;function z(){F=0}function N(){let E=F;return E>=l&&console.warn("THREE.WebGLTextures: Trying to use "+E+" texture units while this GPU supports only "+l),F+=1,E}function V(E,w){let q=i.get(E);if(E.isVideoTexture&&et(E),E.version>0&&q.__version!==E.version){let rt=E.image;if(rt===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if(rt.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{k(q,E,w);return}}e.activeTexture(33984+w),e.bindTexture(3553,q.__webglTexture)}function Q(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(35866,q.__webglTexture)}function at(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(32879,q.__webglTexture)}function G(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){Ft(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(34067,q.__webglTexture)}let $={[Ou]:10497,[Ve]:33071,[ku]:33648},lt={[fe]:9728,[Im]:9984,[Nm]:9986,[be]:9729,[Dw]:9985,[Ll]:9987};function dt(E,w,q){if(q?(n.texParameteri(E,10242,$[w.wrapS]),n.texParameteri(E,10243,$[w.wrapT]),(E===32879||E===35866)&&n.texParameteri(E,32882,$[w.wrapR]),n.texParameteri(E,10240,lt[w.magFilter]),n.texParameteri(E,10241,lt[w.minFilter])):(n.texParameteri(E,10242,33071),n.texParameteri(E,10243,33071),(E===32879||E===35866)&&n.texParameteri(E,32882,33071),(w.wrapS!==Ve||w.wrapT!==Ve)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(E,10240,tt(w.magFilter)),n.texParameteri(E,10241,tt(w.minFilter)),w.minFilter!==fe&&w.minFilter!==be&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let rt=t.get("EXT_texture_filter_anisotropic");if(w.type===Ui&&t.has("OES_texture_float_linear")===!1||a===!1&&w.type===Ur&&t.has("OES_texture_half_float_linear")===!1)return;(w.anisotropy>1||i.get(w).__currentAnisotropy)&&(n.texParameterf(E,rt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(w.anisotropy,r.getMaxAnisotropy())),i.get(w).__currentAnisotropy=w.anisotropy)}}function xt(E,w){E.__webglInit===void 0&&(E.__webglInit=!0,w.addEventListener("dispose",X),E.__webglTexture=n.createTexture(),o.memory.textures++)}function k(E,w,q){let rt=3553;w.isDataTexture2DArray&&(rt=35866),w.isDataTexture3D&&(rt=32879),xt(E,w),e.activeTexture(33984+q),e.bindTexture(rt,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let gt=_(w)&&b(w.image)===!1,W=p(w.image,gt,!1,u);W=vt(w,W);let _t=b(W)||a,yt=s.convert(w.format,w.encoding),ut=s.convert(w.type),ct=A(w.internalFormat,yt,ut,w.encoding,w.isVideoTexture);dt(rt,w,_t);let At,P=w.mipmaps,pt=a&&w.isVideoTexture!==!0,ht=E.__version===void 0,Et=H(w,W,_t);if(w.isDepthTexture)ct=6402,a?w.type===Ui?ct=36012:w.type===Qa?ct=33190:w.type===Br?ct=35056:ct=33189:w.type===Ui&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),w.format===Oi&&ct===6402&&w.type!==no&&w.type!==Qa&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),w.type=no,ut=s.convert(w.type)),w.format===Vr&&ct===6402&&(ct=34041,w.type!==Br&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),w.type=Br,ut=s.convert(w.type))),pt&&ht?e.texStorage2D(3553,1,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(w.isDataTexture)if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,0,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,W.width,W.height,yt,ut,W.data)):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,W.data);else if(w.isCompressedTexture){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],w.format!==Re?yt!==null?pt?e.compressedTexSubImage2D(3553,Y,0,0,At.width,At.height,yt,At.data):e.compressedTexImage2D(3553,Y,ct,At.width,At.height,0,At.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):pt?e.texSubImage2D(3553,Y,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data)}else if(w.isDataTexture2DArray)pt?(ht&&e.texStorage3D(35866,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(35866,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(35866,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isDataTexture3D)pt?(ht&&e.texStorage3D(32879,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(32879,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(32879,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isFramebufferTexture)pt&&ht?e.texStorage2D(3553,Et,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,Y,0,0,yt,ut,At):e.texImage2D(3553,Y,ct,yt,ut,At);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,yt,ut,W)):e.texImage2D(3553,0,ct,yt,ut,W);S(w,_t)&&L(rt),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function Ft(E,w,q){if(w.image.length!==6)return;xt(E,w),e.activeTexture(33984+q),e.bindTexture(34067,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let rt=w&&(w.isCompressedTexture||w.image[0].isCompressedTexture),gt=w.image[0]&&w.image[0].isDataTexture,W=[];for(let Y=0;Y<6;Y++)!rt&&!gt?W[Y]=p(w.image[Y],!1,!0,c):W[Y]=gt?w.image[Y].image:w.image[Y],W[Y]=vt(w,W[Y]);let _t=W[0],yt=b(_t)||a,ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=a&&w.isVideoTexture!==!0,pt=E.__version===void 0,ht=H(w,_t,yt);dt(34067,w,yt);let Et;if(rt){P&&pt&&e.texStorage2D(34067,ht,At,_t.width,_t.height);for(let Y=0;Y<6;Y++){Et=W[Y].mipmaps;for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];w.format!==Re?ut!==null?P?e.compressedTexSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,Dt.data):e.compressedTexImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,Dt.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):P?e.texSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,ct,Dt.data):e.texImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,ut,ct,Dt.data)}}}else{Et=w.mipmaps,P&&pt&&(Et.length>0&&ht++,e.texStorage2D(34067,ht,At,W[0].width,W[0].height));for(let Y=0;Y<6;Y++)if(gt){P?e.texSubImage2D(34069+Y,0,0,0,W[Y].width,W[Y].height,ut,ct,W[Y].data):e.texImage2D(34069+Y,0,At,W[Y].width,W[Y].height,0,ut,ct,W[Y].data);for(let Mt=0;Mt<Et.length;Mt++){let jt=Et[Mt].image[Y].image;P?e.texSubImage2D(34069+Y,Mt+1,0,0,jt.width,jt.height,ut,ct,jt.data):e.texImage2D(34069+Y,Mt+1,At,jt.width,jt.height,0,ut,ct,jt.data)}}else{P?e.texSubImage2D(34069+Y,0,0,0,ut,ct,W[Y]):e.texImage2D(34069+Y,0,At,ut,ct,W[Y]);for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];P?e.texSubImage2D(34069+Y,Mt+1,0,0,ut,ct,Dt.image[Y]):e.texImage2D(34069+Y,Mt+1,At,ut,ct,Dt.image[Y])}}}S(w,yt)&&L(34067),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function mt(E,w,q,rt,gt){let W=s.convert(q.format,q.encoding),_t=s.convert(q.type),yt=A(q.internalFormat,W,_t,q.encoding);i.get(w).__hasExternalTextures||(gt===32879||gt===35866?e.texImage3D(gt,0,yt,w.width,w.height,w.depth,0,W,_t,null):e.texImage2D(gt,0,yt,w.width,w.height,0,W,_t,null)),e.bindFramebuffer(36160,E),w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,rt,gt,i.get(q).__webglTexture,0,it(w)):n.framebufferTexture2D(36160,rt,gt,i.get(q).__webglTexture,0),e.bindFramebuffer(36160,null)}function St(E,w,q){if(n.bindRenderbuffer(36161,E),w.depthBuffer&&!w.stencilBuffer){let rt=33189;if(q||w.useRenderToTexture){let gt=w.depthTexture;gt&&gt.isDepthTexture&&(gt.type===Ui?rt=36012:gt.type===Qa&&(rt=33190));let W=it(w);w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,W,rt,w.width,w.height):n.renderbufferStorageMultisample(36161,W,rt,w.width,w.height)}else n.renderbufferStorage(36161,rt,w.width,w.height);n.framebufferRenderbuffer(36160,36096,36161,E)}else if(w.depthBuffer&&w.stencilBuffer){let rt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,rt,35056,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,rt,35056,w.width,w.height):n.renderbufferStorage(36161,34041,w.width,w.height),n.framebufferRenderbuffer(36160,33306,36161,E)}else{let rt=w.isWebGLMultipleRenderTargets===!0?w.texture[0]:w.texture,gt=s.convert(rt.format,rt.encoding),W=s.convert(rt.type),_t=A(rt.internalFormat,gt,W,rt.encoding),yt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,_t,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,yt,_t,w.width,w.height):n.renderbufferStorage(36161,_t,w.width,w.height)}n.bindRenderbuffer(36161,null)}function B(E,w){if(w&&w.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,E),!(w.depthTexture&&w.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(w.depthTexture).__webglTexture||w.depthTexture.image.width!==w.width||w.depthTexture.image.height!==w.height)&&(w.depthTexture.image.width=w.width,w.depthTexture.image.height=w.height,w.depthTexture.needsUpdate=!0),V(w.depthTexture,0);let rt=i.get(w.depthTexture).__webglTexture,gt=it(w);if(w.depthTexture.format===Oi)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,36096,3553,rt,0,gt):n.framebufferTexture2D(36160,36096,3553,rt,0);else if(w.depthTexture.format===Vr)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,33306,3553,rt,0,gt):n.framebufferTexture2D(36160,33306,3553,rt,0);else throw new Error("Unknown depthTexture format")}function st(E){let w=i.get(E),q=E.isWebGLCubeRenderTarget===!0;if(E.depthTexture&&!w.__autoAllocateDepthBuffer){if(q)throw new Error("target.depthTexture not supported in Cube render targets");B(w.__webglFramebuffer,E)}else if(q){w.__webglDepthbuffer=[];for(let rt=0;rt<6;rt++)e.bindFramebuffer(36160,w.__webglFramebuffer[rt]),w.__webglDepthbuffer[rt]=n.createRenderbuffer(),St(w.__webglDepthbuffer[rt],E,!1)}else e.bindFramebuffer(36160,w.__webglFramebuffer),w.__webglDepthbuffer=n.createRenderbuffer(),St(w.__webglDepthbuffer,E,!1);e.bindFramebuffer(36160,null)}function nt(E,w,q){let rt=i.get(E);w!==void 0&&mt(rt.__webglFramebuffer,E,E.texture,36064,3553),q!==void 0&&st(E)}function C(E){let w=E.texture,q=i.get(E),rt=i.get(w);E.addEventListener("dispose",y),E.isWebGLMultipleRenderTargets!==!0&&(rt.__webglTexture===void 0&&(rt.__webglTexture=n.createTexture()),rt.__version=w.version,o.memory.textures++);let gt=E.isWebGLCubeRenderTarget===!0,W=E.isWebGLMultipleRenderTargets===!0,_t=w.isDataTexture3D||w.isDataTexture2DArray,yt=b(E)||a;if(gt){q.__webglFramebuffer=[];for(let ut=0;ut<6;ut++)q.__webglFramebuffer[ut]=n.createFramebuffer()}else if(q.__webglFramebuffer=n.createFramebuffer(),W)if(r.drawBuffers){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=i.get(ut[ct]);P.__webglTexture===void 0&&(P.__webglTexture=n.createTexture(),o.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(E.useRenderbuffer)if(a){q.__webglMultisampledFramebuffer=n.createFramebuffer(),q.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,q.__webglColorRenderbuffer);let ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=it(E);n.renderbufferStorageMultisample(36161,P,At,E.width,E.height),e.bindFramebuffer(36160,q.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,q.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),E.depthBuffer&&(q.__webglDepthRenderbuffer=n.createRenderbuffer(),St(q.__webglDepthRenderbuffer,E,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(gt){e.bindTexture(34067,rt.__webglTexture),dt(34067,w,yt);for(let ut=0;ut<6;ut++)mt(q.__webglFramebuffer[ut],E,w,36064,34069+ut);S(w,yt)&&L(34067),e.unbindTexture()}else if(W){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=ut[ct],pt=i.get(P);e.bindTexture(3553,pt.__webglTexture),dt(3553,P,yt),mt(q.__webglFramebuffer,E,P,36064+ct,3553),S(P,yt)&&L(3553)}e.unbindTexture()}else{let ut=3553;_t&&(a?ut=w.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(ut,rt.__webglTexture),dt(ut,w,yt),mt(q.__webglFramebuffer,E,w,36064,ut),S(w,yt)&&L(ut),e.unbindTexture()}E.depthBuffer&&st(E)}function j(E){let w=b(E)||a,q=E.isWebGLMultipleRenderTargets===!0?E.texture:[E.texture];for(let rt=0,gt=q.length;rt<gt;rt++){let W=q[rt];if(S(W,w)){let _t=E.isWebGLCubeRenderTarget?34067:3553,yt=i.get(W).__webglTexture;e.bindTexture(_t,yt),L(_t),e.unbindTexture()}}}function J(E){if(E.useRenderbuffer)if(a){let w=E.width,q=E.height,rt=16384,gt=[36064],W=E.stencilBuffer?33306:36096;E.depthBuffer&&gt.push(W),E.ignoreDepthForMultisampleCopy||(E.depthBuffer&&(rt|=256),E.stencilBuffer&&(rt|=1024));let _t=i.get(E);e.bindFramebuffer(36008,_t.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,_t.__webglFramebuffer),E.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[W]),n.invalidateFramebuffer(36009,[W])),n.blitFramebuffer(0,0,w,q,0,0,w,q,rt,9728),n.invalidateFramebuffer(36008,gt),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,_t.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function it(E){return a&&(E.useRenderbuffer||E.useRenderToTexture)?Math.min(h,E.samples):0}function et(E){let w=o.render.frame;g.get(E)!==w&&(g.set(E,w),E.update())}function vt(E,w){let q=E.encoding,rt=E.format,gt=E.type;return E.isCompressedTexture===!0||E.isVideoTexture===!0||E.format===Hu||q!==ri&&(q===$t?a===!1?t.has("EXT_sRGB")===!0&&rt===Re?(E.format=Hu,E.minFilter=be,E.generateMipmaps=!1):w=Nn.sRGBToLinear(w):(rt!==Re||gt!==ei)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",q)),w}let bt=!1,It=!1;function Zt(E,w){E&&E.isWebGLRenderTarget&&(bt===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),bt=!0),E=E.texture),V(E,w)}function qt(E,w){E&&E.isWebGLCubeRenderTarget&&(It===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),It=!0),E=E.texture),G(E,w)}this.allocateTextureUnit=N,this.resetTextureUnits=z,this.setTexture2D=V,this.setTexture2DArray=Q,this.setTexture3D=at,this.setTextureCube=G,this.rebindTextures=nt,this.setupRenderTarget=C,this.updateRenderTargetMipmap=j,this.updateMultisampleRenderTarget=J,this.setupDepthRenderbuffer=st,this.setupFrameBufferTexture=mt,this.safeSetTexture2D=Zt,this.safeSetTextureCube=qt}function LE(n,t,e){let i=e.isWebGL2;function r(s,o=null){let a;if(s===ei)return 5121;if(s===zw)return 32819;if(s===Uw)return 32820;if(s===Iw)return 5120;if(s===Nw)return 5122;if(s===no)return 5123;if(s===Fw)return 5124;if(s===Qa)return 5125;if(s===Ui)return 5126;if(s===Ur)return i?5131:(a=t.get("OES_texture_half_float"),a!==null?a.HALF_FLOAT_OES:null);if(s===Bw)return 6406;if(s===Re)return 6408;if(s===Ow)return 6409;if(s===kw)return 6410;if(s===Oi)return 6402;if(s===Vr)return 34041;if(s===Hw)return 6403;if(s===Hu)return a=t.get("EXT_sRGB"),a!==null?a.SRGB_ALPHA_EXT:null;if(s===Vw)return 36244;if(s===Gw)return 33319;if(s===Ww)return 33320;if(s===qw)return 36249;if(s===Kc||s===Qc||s===jc||s===tu)if(o===$t)if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),a!==null){if(s===Kc)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(a=t.get("WEBGL_compressed_texture_s3tc"),a!==null){if(s===Kc)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(s===Fm||s===zm||s===Um||s===Bm)if(a=t.get("WEBGL_compressed_texture_pvrtc"),a!==null){if(s===Fm)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(s===zm)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(s===Um)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(s===Bm)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(s===Xw)return a=t.get("WEBGL_compressed_texture_etc1"),a!==null?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(s===Om||s===km)if(a=t.get("WEBGL_compressed_texture_etc"),a!==null){if(s===Om)return o===$t?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(s===km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(s===Hm||s===Vm||s===Gm||s===Wm||s===qm||s===Xm||s===Ym||s===Zm||s===Jm||s===$m||s===Km||s===Qm||s===jm||s===tg)if(a=t.get("WEBGL_compressed_texture_astc"),a!==null){if(s===Hm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(s===Vm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(s===Gm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(s===Wm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(s===qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(s===Xm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(s===Ym)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(s===Zm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(s===Jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(s===$m)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(s===Km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(s===Qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(s===jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(s===tg)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(s===eg)if(a=t.get("EXT_texture_compression_bptc"),a!==null){if(s===eg)return o===$t?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(s===Br)return i?34042:(a=t.get("WEBGL_depth_texture"),a!==null?a.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:r}}var hl=class extends Se{constructor(t=[]){super(),this.cameras=t}};hl.prototype.isArrayCamera=!0;var Bi=class extends kt{constructor(){super(),this.type="Group"}};Bi.prototype.isGroup=!0;var PE={type:"move"},Qs=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Bi,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Bi,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new T,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new T),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Bi,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new T,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new T),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,e,i){let r=null,s=null,o=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&e.session.visibilityState!=="visible-blurred")if(a!==null&&(r=e.getPose(t.targetRaySpace,i),r!==null&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(PE))),c&&t.hand){o=!0;for(let x of t.hand.values()){let v=e.getJointPose(x,i);if(c.joints[x.jointName]===void 0){let p=new Bi;p.matrixAutoUpdate=!1,p.visible=!1,c.joints[x.jointName]=p,c.add(p)}let m=c.joints[x.jointName];v!==null&&(m.matrix.fromArray(v.transform.matrix),m.matrix.decompose(m.position,m.rotation,m.scale),m.jointRadius=v.radius),m.visible=v!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),d=.02,g=.005;c.inputState.pinching&&f>d+g?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=d-g&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(s=e.getPose(t.gripSpace,i),s!==null&&(l.matrix.fromArray(s.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),s.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(s.linearVelocity)):l.hasLinearVelocity=!1,s.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(s.angularVelocity)):l.hasAngularVelocity=!1));return a!==null&&(a.visible=r!==null),l!==null&&(l.visible=s!==null),c!==null&&(c.visible=o!==null),this}},uo=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){if(u=u!==void 0?u:Oi,u!==Oi&&u!==Vr)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");i===void 0&&u===Oi&&(i=no),i===void 0&&u===Vr&&(i=Br),super(null,r,s,o,a,l,u,i,c),this.image={width:t,height:e},this.magFilter=a!==void 0?a:fe,this.minFilter=l!==void 0?l:fe,this.flipY=!1,this.generateMipmaps=!1}};uo.prototype.isDepthTexture=!0;var Zu=class extends In{constructor(t,e){super();let i=this,r=null,s=1,o=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,d=!1,g=null,x=e.getContextAttributes(),v=null,m=null,p=[],b=new Map,_=new Se;_.layers.enable(1),_.viewport=new Wt;let S=new Se;S.layers.enable(2),S.viewport=new Wt;let L=[_,S],A=new hl;A.layers.enable(1),A.layers.enable(2);let H=null,tt=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getTargetRaySpace()},this.getControllerGrip=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getGripSpace()},this.getHand=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getHandSpace()};function X(G){let $=b.get(G.inputSource);$&&$.dispatchEvent({type:G.type,data:G.inputSource})}function y(){b.forEach(function(G,$){G.disconnect($)}),b.clear(),H=null,tt=null,t.setRenderTarget(v),f=null,h=null,u=null,r=null,m=null,at.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(G){s=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(G){a=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return o},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return g},this.getSession=function(){return r},this.setSession=function(G){return hf(this,null,function*(){if(r=G,r!==null){if(v=t.getRenderTarget(),r.addEventListener("select",X),r.addEventListener("selectstart",X),r.addEventListener("selectend",X),r.addEventListener("squeeze",X),r.addEventListener("squeezestart",X),r.addEventListener("squeezeend",X),r.addEventListener("end",y),r.addEventListener("inputsourceschange",R),x.xrCompatible!==!0&&(yield e.makeXRCompatible()),r.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let $={antialias:r.renderState.layers===void 0?x.antialias:!0,alpha:x.alpha,depth:x.depth,stencil:x.stencil,framebufferScaleFactor:s};f=new XRWebGLLayer(r,e,$),r.updateRenderState({baseLayer:f}),m=new Ne(f.framebufferWidth,f.framebufferHeight,{format:Re,type:ei,encoding:t.outputEncoding})}else{d=x.antialias;let $=null,lt=null,dt=null;x.depth&&(dt=x.stencil?35056:33190,$=x.stencil?Vr:Oi,lt=x.stencil?Br:no);let xt={colorFormat:t.outputEncoding===$t?35907:32856,depthFormat:dt,scaleFactor:s};u=new XRWebGLBinding(r,e),h=u.createProjectionLayer(xt),r.updateRenderState({layers:[h]}),d?m=new so(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):m=new Ne(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}m.isXRRenderTarget=!0,this.setFoveation(1),o=yield r.requestReferenceSpace(a),at.setContext(r),at.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}})};function R(G){let $=r.inputSources;for(let lt=0;lt<p.length;lt++)b.set($[lt],p[lt]);for(let lt=0;lt<G.removed.length;lt++){let dt=G.removed[lt],xt=b.get(dt);xt&&(xt.dispatchEvent({type:"disconnected",data:dt}),b.delete(dt))}for(let lt=0;lt<G.added.length;lt++){let dt=G.added[lt],xt=b.get(dt);xt&&xt.dispatchEvent({type:"connected",data:dt})}}let D=new T,F=new T;function z(G,$,lt){D.setFromMatrixPosition($.matrixWorld),F.setFromMatrixPosition(lt.matrixWorld);let dt=D.distanceTo(F),xt=$.projectionMatrix.elements,k=lt.projectionMatrix.elements,Ft=xt[14]/(xt[10]-1),mt=xt[14]/(xt[10]+1),St=(xt[9]+1)/xt[5],B=(xt[9]-1)/xt[5],st=(xt[8]-1)/xt[0],nt=(k[8]+1)/k[0],C=Ft*st,j=Ft*nt,J=dt/(-st+nt),it=J*-st;$.matrixWorld.decompose(G.position,G.quaternion,G.scale),G.translateX(it),G.translateZ(J),G.matrixWorld.compose(G.position,G.quaternion,G.scale),G.matrixWorldInverse.copy(G.matrixWorld).invert();let et=Ft+J,vt=mt+J,bt=C-it,It=j+(dt-it),Zt=St*mt/vt*et,qt=B*mt/vt*et;G.projectionMatrix.makePerspective(bt,It,Zt,qt,et,vt)}function N(G,$){$===null?G.matrixWorld.copy(G.matrix):G.matrixWorld.multiplyMatrices($.matrixWorld,G.matrix),G.matrixWorldInverse.copy(G.matrixWorld).invert()}this.updateCamera=function(G){if(r===null)return;A.near=S.near=_.near=G.near,A.far=S.far=_.far=G.far,(H!==A.near||tt!==A.far)&&(r.updateRenderState({depthNear:A.near,depthFar:A.far}),H=A.near,tt=A.far);let $=G.parent,lt=A.cameras;N(A,$);for(let xt=0;xt<lt.length;xt++)N(lt[xt],$);A.matrixWorld.decompose(A.position,A.quaternion,A.scale),G.position.copy(A.position),G.quaternion.copy(A.quaternion),G.scale.copy(A.scale),G.matrix.copy(A.matrix),G.matrixWorld.copy(A.matrixWorld);let dt=G.children;for(let xt=0,k=dt.length;xt<k;xt++)dt[xt].updateMatrixWorld(!0);lt.length===2?z(A,_,S):A.projectionMatrix.copy(_.projectionMatrix)},this.getCamera=function(){return A},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(G){h!==null&&(h.fixedFoveation=G),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=G)};let V=null;function Q(G,$){if(c=$.getViewerPose(o),g=$,c!==null){let dt=c.views;f!==null&&(t.setRenderTargetFramebuffer(m,f.framebuffer),t.setRenderTarget(m));let xt=!1;dt.length!==A.cameras.length&&(A.cameras.length=0,xt=!0);for(let k=0;k<dt.length;k++){let Ft=dt[k],mt=null;if(f!==null)mt=f.getViewport(Ft);else{let B=u.getViewSubImage(h,Ft);mt=B.viewport,k===0&&(t.setRenderTargetTextures(m,B.colorTexture,h.ignoreDepthValues?void 0:B.depthStencilTexture),t.setRenderTarget(m))}let St=L[k];St.matrix.fromArray(Ft.transform.matrix),St.projectionMatrix.fromArray(Ft.projectionMatrix),St.viewport.set(mt.x,mt.y,mt.width,mt.height),k===0&&A.matrix.copy(St.matrix),xt===!0&&A.cameras.push(St)}}let lt=r.inputSources;for(let dt=0;dt<p.length;dt++){let xt=p[dt],k=lt[dt];xt.update(k,$,o)}V&&V(G,$),g=null}let at=new g0;at.setAnimationLoop(Q),this.setAnimationLoop=function(G){V=G},this.dispose=function(){}}};function DE(n){function t(m,p){m.fogColor.value.copy(p.color),p.isFog?(m.fogNear.value=p.near,m.fogFar.value=p.far):p.isFogExp2&&(m.fogDensity.value=p.density)}function e(m,p,b,_,S){p.isMeshBasicMaterial?i(m,p):p.isMeshLambertMaterial?(i(m,p),l(m,p)):p.isMeshToonMaterial?(i(m,p),u(m,p)):p.isMeshPhongMaterial?(i(m,p),c(m,p)):p.isMeshStandardMaterial?(i(m,p),p.isMeshPhysicalMaterial?f(m,p,S):h(m,p)):p.isMeshMatcapMaterial?(i(m,p),d(m,p)):p.isMeshDepthMaterial?(i(m,p),g(m,p)):p.isMeshDistanceMaterial?(i(m,p),x(m,p)):p.isMeshNormalMaterial?(i(m,p),v(m,p)):p.isLineBasicMaterial?(r(m,p),p.isLineDashedMaterial&&s(m,p)):p.isPointsMaterial?o(m,p,b,_):p.isSpriteMaterial?a(m,p):p.isShadowMaterial?(m.color.value.copy(p.color),m.opacity.value=p.opacity):p.isShaderMaterial&&(p.uniformsNeedUpdate=!1)}function i(m,p){m.opacity.value=p.opacity,p.color&&m.diffuse.value.copy(p.color),p.emissive&&m.emissive.value.copy(p.emissive).multiplyScalar(p.emissiveIntensity),p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.specularMap&&(m.specularMap.value=p.specularMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b=n.get(p).envMap;b&&(m.envMap.value=b,m.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,m.reflectivity.value=p.reflectivity,m.ior.value=p.ior,m.refractionRatio.value=p.refractionRatio),p.lightMap&&(m.lightMap.value=p.lightMap,m.lightMapIntensity.value=p.lightMapIntensity),p.aoMap&&(m.aoMap.value=p.aoMap,m.aoMapIntensity.value=p.aoMapIntensity);let _;p.map?_=p.map:p.specularMap?_=p.specularMap:p.displacementMap?_=p.displacementMap:p.normalMap?_=p.normalMap:p.bumpMap?_=p.bumpMap:p.roughnessMap?_=p.roughnessMap:p.metalnessMap?_=p.metalnessMap:p.alphaMap?_=p.alphaMap:p.emissiveMap?_=p.emissiveMap:p.clearcoatMap?_=p.clearcoatMap:p.clearcoatNormalMap?_=p.clearcoatNormalMap:p.clearcoatRoughnessMap?_=p.clearcoatRoughnessMap:p.specularIntensityMap?_=p.specularIntensityMap:p.specularColorMap?_=p.specularColorMap:p.transmissionMap?_=p.transmissionMap:p.thicknessMap?_=p.thicknessMap:p.sheenColorMap?_=p.sheenColorMap:p.sheenRoughnessMap&&(_=p.sheenRoughnessMap),_!==void 0&&(_.isWebGLRenderTarget&&(_=_.texture),_.matrixAutoUpdate===!0&&_.updateMatrix(),m.uvTransform.value.copy(_.matrix));let S;p.aoMap?S=p.aoMap:p.lightMap&&(S=p.lightMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uv2Transform.value.copy(S.matrix))}function r(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity}function s(m,p){m.dashSize.value=p.dashSize,m.totalSize.value=p.dashSize+p.gapSize,m.scale.value=p.scale}function o(m,p,b,_){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.size.value=p.size*b,m.scale.value=_*.5,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let S;p.map?S=p.map:p.alphaMap&&(S=p.alphaMap),S!==void 0&&(S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uvTransform.value.copy(S.matrix))}function a(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.rotation.value=p.rotation,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b;p.map?b=p.map:p.alphaMap&&(b=p.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),m.uvTransform.value.copy(b.matrix))}function l(m,p){p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap)}function c(m,p){m.specular.value.copy(p.specular),m.shininess.value=Math.max(p.shininess,1e-4),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function u(m,p){p.gradientMap&&(m.gradientMap.value=p.gradientMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function h(m,p){m.roughness.value=p.roughness,m.metalness.value=p.metalness,p.roughnessMap&&(m.roughnessMap.value=p.roughnessMap),p.metalnessMap&&(m.metalnessMap.value=p.metalnessMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),n.get(p).envMap&&(m.envMapIntensity.value=p.envMapIntensity)}function f(m,p,b){h(m,p),m.ior.value=p.ior,p.sheen>0&&(m.sheenColor.value.copy(p.sheenColor).multiplyScalar(p.sheen),m.sheenRoughness.value=p.sheenRoughness,p.sheenColorMap&&(m.sheenColorMap.value=p.sheenColorMap),p.sheenRoughnessMap&&(m.sheenRoughnessMap.value=p.sheenRoughnessMap)),p.clearcoat>0&&(m.clearcoat.value=p.clearcoat,m.clearcoatRoughness.value=p.clearcoatRoughness,p.clearcoatMap&&(m.clearcoatMap.value=p.clearcoatMap),p.clearcoatRoughnessMap&&(m.clearcoatRoughnessMap.value=p.clearcoatRoughnessMap),p.clearcoatNormalMap&&(m.clearcoatNormalScale.value.copy(p.clearcoatNormalScale),m.clearcoatNormalMap.value=p.clearcoatNormalMap,p.side===he&&m.clearcoatNormalScale.value.negate())),p.transmission>0&&(m.transmission.value=p.transmission,m.transmissionSamplerMap.value=b.texture,m.transmissionSamplerSize.value.set(b.width,b.height),p.transmissionMap&&(m.transmissionMap.value=p.transmissionMap),m.thickness.value=p.thickness,p.thicknessMap&&(m.thicknessMap.value=p.thicknessMap),m.attenuationDistance.value=p.attenuationDistance,m.attenuationColor.value.copy(p.attenuationColor)),m.specularIntensity.value=p.specularIntensity,m.specularColor.value.copy(p.specularColor),p.specularIntensityMap&&(m.specularIntensityMap.value=p.specularIntensityMap),p.specularColorMap&&(m.specularColorMap.value=p.specularColorMap)}function d(m,p){p.matcap&&(m.matcap.value=p.matcap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function g(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function x(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),m.referencePosition.value.copy(p.referencePosition),m.nearDistance.value=p.nearDistance,m.farDistance.value=p.farDistance}function v(m,p){p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:e}}function IE(){let n=ro("canvas");return n.style.display="block",n}function Vt(n={}){let t=n.canvas!==void 0?n.canvas:IE(),e=n.context!==void 0?n.context:null,i=n.alpha!==void 0?n.alpha:!1,r=n.depth!==void 0?n.depth:!0,s=n.stencil!==void 0?n.stencil:!0,o=n.antialias!==void 0?n.antialias:!1,a=n.premultipliedAlpha!==void 0?n.premultipliedAlpha:!0,l=n.preserveDrawingBuffer!==void 0?n.preserveDrawingBuffer:!1,c=n.powerPreference!==void 0?n.powerPreference:"default",u=n.failIfMajorPerformanceCaveat!==void 0?n.failIfMajorPerformanceCaveat:!1,h=null,f=null,d=[],g=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=ri,this.physicallyCorrectLights=!1,this.toneMapping=ti,this.toneMappingExposure=1;let x=this,v=!1,m=0,p=0,b=null,_=-1,S=null,L=new Wt,A=new Wt,H=null,tt=t.width,X=t.height,y=1,R=null,D=null,F=new Wt(0,0,tt,X),z=new Wt(0,0,tt,X),N=!1,V=new qr,Q=!1,at=!1,G=null,$=new wt,lt=new T,dt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function xt(){return b===null?y:1}let k=e;function Ft(M,I){for(let O=0;O<M.length;O++){let U=M[O],Z=t.getContext(U,I);if(Z!==null)return Z}return null}try{let M={alpha:!0,depth:r,stencil:s,antialias:o,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${$h}`),t.addEventListener("webglcontextlost",At,!1),t.addEventListener("webglcontextrestored",P,!1),k===null){let I=["webgl2","webgl","experimental-webgl"];if(x.isWebGL1Renderer===!0&&I.shift(),k=Ft(I,M),k===null)throw Ft(I)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}k.getShaderPrecisionFormat===void 0&&(k.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(M){throw console.error("THREE.WebGLRenderer: "+M.message),M}let mt,St,B,st,nt,C,j,J,it,et,vt,bt,It,Zt,qt,E,w,q,rt,gt,W,_t,yt;function ut(){mt=new eS(k),St=new J1(k,mt,n),mt.init(St),_t=new LE(k,mt,St),B=new CE(k,mt,St),st=new rS(k),nt=new xE,C=new RE(k,mt,B,nt,St,_t,st),j=new K1(x),J=new tS(x),it=new vM(k,St),yt=new Y1(k,mt,it,St),et=new nS(k,it,st,yt),vt=new lS(k,et,it,st),rt=new aS(k,St,C),E=new $1(nt),bt=new gE(x,j,J,mt,St,yt,E),It=new DE(nt),Zt=new vE,qt=new EE(mt,St),q=new X1(x,j,B,vt,i,a),w=new T0(x,vt,St),gt=new Z1(k,mt,st,St),W=new iS(k,mt,st,St),st.programs=bt.programs,x.capabilities=St,x.extensions=mt,x.properties=nt,x.renderLists=Zt,x.shadowMap=w,x.state=B,x.info=st}ut();let ct=new Zu(x,k);this.xr=ct,this.getContext=function(){return k},this.getContextAttributes=function(){return k.getContextAttributes()},this.forceContextLoss=function(){let M=mt.get("WEBGL_lose_context");M&&M.loseContext()},this.forceContextRestore=function(){let M=mt.get("WEBGL_lose_context");M&&M.restoreContext()},this.getPixelRatio=function(){return y},this.setPixelRatio=function(M){M!==void 0&&(y=M,this.setSize(tt,X,!1))},this.getSize=function(M){return M.set(tt,X)},this.setSize=function(M,I,O){if(ct.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}tt=M,X=I,t.width=Math.floor(M*y),t.height=Math.floor(I*y),O!==!1&&(t.style.width=M+"px",t.style.height=I+"px"),this.setViewport(0,0,M,I)},this.getDrawingBufferSize=function(M){return M.set(tt*y,X*y).floor()},this.setDrawingBufferSize=function(M,I,O){tt=M,X=I,y=O,t.width=Math.floor(M*O),t.height=Math.floor(I*O),this.setViewport(0,0,M,I)},this.getCurrentViewport=function(M){return M.copy(L)},this.getViewport=function(M){return M.copy(F)},this.setViewport=function(M,I,O,U){M.isVector4?F.set(M.x,M.y,M.z,M.w):F.set(M,I,O,U),B.viewport(L.copy(F).multiplyScalar(y).floor())},this.getScissor=function(M){return M.copy(z)},this.setScissor=function(M,I,O,U){M.isVector4?z.set(M.x,M.y,M.z,M.w):z.set(M,I,O,U),B.scissor(A.copy(z).multiplyScalar(y).floor())},this.getScissorTest=function(){return N},this.setScissorTest=function(M){B.setScissorTest(N=M)},this.setOpaqueSort=function(M){R=M},this.setTransparentSort=function(M){D=M},this.getClearColor=function(M){return M.copy(q.getClearColor())},this.setClearColor=function(){q.setClearColor.apply(q,arguments)},this.getClearAlpha=function(){return q.getClearAlpha()},this.setClearAlpha=function(){q.setClearAlpha.apply(q,arguments)},this.clear=function(M,I,O){let U=0;(M===void 0||M)&&(U|=16384),(I===void 0||I)&&(U|=256),(O===void 0||O)&&(U|=1024),k.clear(U)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",At,!1),t.removeEventListener("webglcontextrestored",P,!1),Zt.dispose(),qt.dispose(),nt.dispose(),j.dispose(),J.dispose(),vt.dispose(),yt.dispose(),bt.dispose(),ct.dispose(),ct.removeEventListener("sessionstart",Dt),ct.removeEventListener("sessionend",jt),G&&(G.dispose(),G=null),ze.stop()};function At(M){M.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),v=!0}function P(){console.log("THREE.WebGLRenderer: Context Restored."),v=!1;let M=st.autoReset,I=w.enabled,O=w.autoUpdate,U=w.needsUpdate,Z=w.type;ut(),st.autoReset=M,w.enabled=I,w.autoUpdate=O,w.needsUpdate=U,w.type=Z}function pt(M){let I=M.target;I.removeEventListener("dispose",pt),ht(I)}function ht(M){Et(M),nt.remove(M)}function Et(M){let I=nt.get(M).programs;I!==void 0&&(I.forEach(function(O){bt.releaseProgram(O)}),M.isShaderMaterial&&bt.releaseShaderCache(M))}this.renderBufferDirect=function(M,I,O,U,Z,Tt){I===null&&(I=dt);let Ct=Z.isMesh&&Z.matrixWorld.determinant()<0,Lt=B0(M,I,O,U,Z);B.setMaterial(U,Ct);let Rt=O.index,Gt=O.attributes.position;if(Rt===null){if(Gt===void 0||Gt.count===0)return}else if(Rt.count===0)return;let zt=1;U.wireframe===!0&&(Rt=et.getWireframeAttribute(O),zt=2),yt.setup(Z,U,Lt,O,Rt);let Ut,ie=gt;Rt!==null&&(Ut=it.get(Rt),ie=W,ie.setIndex(Ut));let fi=Rt!==null?Rt.count:Gt.count,Zi=O.drawRange.start*zt,Ot=O.drawRange.count*zt,nn=Tt!==null?Tt.start*zt:0,le=Tt!==null?Tt.count*zt:1/0,rn=Math.max(Zi,nn),Io=Math.min(fi,Zi+Ot,nn+le)-1,sn=Math.max(0,Io-rn+1);if(sn!==0){if(Z.isMesh)U.wireframe===!0?(B.setLineWidth(U.wireframeLinewidth*xt()),ie.setMode(1)):ie.setMode(4);else if(Z.isLine){let vn=U.linewidth;vn===void 0&&(vn=1),B.setLineWidth(vn*xt()),Z.isLineSegments?ie.setMode(1):Z.isLineLoop?ie.setMode(2):ie.setMode(3)}else Z.isPoints?ie.setMode(0):Z.isSprite&&ie.setMode(4);if(Z.isInstancedMesh)ie.renderInstances(rn,sn,Z.count);else if(O.isInstancedBufferGeometry){let vn=Math.min(O.instanceCount,O._maxInstanceCount);ie.renderInstances(rn,sn,vn)}else ie.render(rn,sn)}},this.compile=function(M,I){f=qt.get(M),f.init(),g.push(f),M.traverseVisible(function(O){O.isLight&&O.layers.test(I.layers)&&(f.pushLight(O),O.castShadow&&f.pushShadow(O))}),f.setupLights(x.physicallyCorrectLights),M.traverse(function(O){let U=O.material;if(U)if(Array.isArray(U))for(let Z=0;Z<U.length;Z++){let Tt=U[Z];Ol(Tt,M,O)}else Ol(U,M,O)}),g.pop(),f=null};let Y=null;function Mt(M){Y&&Y(M)}function Dt(){ze.stop()}function jt(){ze.start()}let ze=new g0;ze.setAnimationLoop(Mt),typeof window!="undefined"&&ze.setContext(window),this.setAnimationLoop=function(M){Y=M,ct.setAnimationLoop(M),M===null?ze.stop():ze.start()},ct.addEventListener("sessionstart",Dt),ct.addEventListener("sessionend",jt),this.render=function(M,I){if(I!==void 0&&I.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(v===!0)return;M.autoUpdate===!0&&M.updateMatrixWorld(),I.parent===null&&I.updateMatrixWorld(),ct.enabled===!0&&ct.isPresenting===!0&&(ct.cameraAutoUpdate===!0&&ct.updateCamera(I),I=ct.getCamera()),M.isScene===!0&&M.onBeforeRender(x,M,I,b),f=qt.get(M,g.length),f.init(),g.push(f),$.multiplyMatrices(I.projectionMatrix,I.matrixWorldInverse),V.setFromProjectionMatrix($),at=this.localClippingEnabled,Q=E.init(this.clippingPlanes,at,I),h=Zt.get(M,d.length),h.init(),d.push(h),ne(M,I,0,x.sortObjects),h.finish(),x.sortObjects===!0&&h.sort(R,D),Q===!0&&E.beginShadows();let O=f.state.shadowsArray;if(w.render(O,M,I),Q===!0&&E.endShadows(),this.info.autoReset===!0&&this.info.reset(),q.render(h,M),f.setupLights(x.physicallyCorrectLights),I.isArrayCamera){let U=I.cameras;for(let Z=0,Tt=U.length;Z<Tt;Z++){let Ct=U[Z];en(h,M,Ct,Ct.viewport)}}else en(h,M,I);b!==null&&(C.updateMultisampleRenderTarget(b),C.updateRenderTargetMipmap(b)),M.isScene===!0&&M.onAfterRender(x,M,I),B.buffers.depth.setTest(!0),B.buffers.depth.setMask(!0),B.buffers.color.setMask(!0),B.setPolygonOffset(!1),yt.resetDefaultState(),_=-1,S=null,g.pop(),g.length>0?f=g[g.length-1]:f=null,d.pop(),d.length>0?h=d[d.length-1]:h=null};function ne(M,I,O,U){if(M.visible===!1)return;if(M.layers.test(I.layers)){if(M.isGroup)O=M.renderOrder;else if(M.isLOD)M.autoUpdate===!0&&M.update(I);else if(M.isLight)f.pushLight(M),M.castShadow&&f.pushShadow(M);else if(M.isSprite){if(!M.frustumCulled||V.intersectsSprite(M)){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}else if((M.isMesh||M.isLine||M.isPoints)&&(M.isSkinnedMesh&&M.skeleton.frame!==st.render.frame&&(M.skeleton.update(),M.skeleton.frame=st.render.frame),!M.frustumCulled||V.intersectsObject(M))){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;if(Array.isArray(Lt)){let Rt=Ct.groups;for(let Gt=0,zt=Rt.length;Gt<zt;Gt++){let Ut=Rt[Gt],ie=Lt[Ut.materialIndex];ie&&ie.visible&&h.push(M,Ct,ie,O,lt.z,Ut)}}else Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}let Tt=M.children;for(let Ct=0,Lt=Tt.length;Ct<Lt;Ct++)ne(Tt[Ct],I,O,U)}function en(M,I,O,U){let Z=M.opaque,Tt=M.transmissive,Ct=M.transparent;f.setupLightsView(O),Tt.length>0&&yn(Z,I,O),U&&B.viewport(L.copy(U)),Z.length>0&&Do(Z,I,O),Tt.length>0&&Do(Tt,I,O),Ct.length>0&&Do(Ct,I,O)}function yn(M,I,O){if(G===null){let Ct=o===!0&&St.isWebGL2===!0?so:Ne;G=new Ct(1024,1024,{generateMipmaps:!0,type:_t.convert(Ur)!==null?Ur:ei,minFilter:Ll,magFilter:fe,wrapS:Ve,wrapT:Ve,useRenderToTexture:mt.has("WEBGL_multisampled_render_to_texture")})}let U=x.getRenderTarget();x.setRenderTarget(G),x.clear();let Z=x.toneMapping;x.toneMapping=ti,Do(M,I,O),x.toneMapping=Z,C.updateMultisampleRenderTarget(G),C.updateRenderTargetMipmap(G),x.setRenderTarget(U)}function Do(M,I,O){let U=I.isScene===!0?I.overrideMaterial:null;for(let Z=0,Tt=M.length;Z<Tt;Z++){let Ct=M[Z],Lt=Ct.object,Rt=Ct.geometry,Gt=U===null?Ct.material:U,zt=Ct.group;Lt.layers.test(O.layers)&&U0(Lt,I,O,Rt,Gt,zt)}}function U0(M,I,O,U,Z,Tt){M.onBeforeRender(x,I,O,U,Z,Tt),M.modelViewMatrix.multiplyMatrices(O.matrixWorldInverse,M.matrixWorld),M.normalMatrix.getNormalMatrix(M.modelViewMatrix),Z.onBeforeRender(x,I,O,U,M,Tt),Z.transparent===!0&&Z.side===Hr?(Z.side=he,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=eo,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=Hr):x.renderBufferDirect(O,I,U,Z,M,Tt),M.onAfterRender(x,I,O,U,Z,Tt)}function Ol(M,I,O){I.isScene!==!0&&(I=dt);let U=nt.get(M),Z=f.state.lights,Tt=f.state.shadowsArray,Ct=Z.state.version,Lt=bt.getParameters(M,Z.state,Tt,I,O),Rt=bt.getProgramCacheKey(Lt),Gt=U.programs;U.environment=M.isMeshStandardMaterial?I.environment:null,U.fog=I.fog,U.envMap=(M.isMeshStandardMaterial?J:j).get(M.envMap||U.environment),Gt===void 0&&(M.addEventListener("dispose",pt),Gt=new Map,U.programs=Gt);let zt=Gt.get(Rt);if(zt!==void 0){if(U.currentProgram===zt&&U.lightsStateVersion===Ct)return of(M,Lt),zt}else Lt.uniforms=bt.getUniforms(M),M.onBuild(O,Lt,x),M.onBeforeCompile(Lt,x),zt=bt.acquireProgram(Lt,Rt),Gt.set(Rt,zt),U.uniforms=Lt.uniforms;let Ut=U.uniforms;(!M.isShaderMaterial&&!M.isRawShaderMaterial||M.clipping===!0)&&(Ut.clippingPlanes=E.uniform),of(M,Lt),U.needsLights=k0(M),U.lightsStateVersion=Ct,U.needsLights&&(Ut.ambientLightColor.value=Z.state.ambient,Ut.lightProbe.value=Z.state.probe,Ut.directionalLights.value=Z.state.directional,Ut.directionalLightShadows.value=Z.state.directionalShadow,Ut.spotLights.value=Z.state.spot,Ut.spotLightShadows.value=Z.state.spotShadow,Ut.rectAreaLights.value=Z.state.rectArea,Ut.ltc_1.value=Z.state.rectAreaLTC1,Ut.ltc_2.value=Z.state.rectAreaLTC2,Ut.pointLights.value=Z.state.point,Ut.pointLightShadows.value=Z.state.pointShadow,Ut.hemisphereLights.value=Z.state.hemi,Ut.directionalShadowMap.value=Z.state.directionalShadowMap,Ut.directionalShadowMatrix.value=Z.state.directionalShadowMatrix,Ut.spotShadowMap.value=Z.state.spotShadowMap,Ut.spotShadowMatrix.value=Z.state.spotShadowMatrix,Ut.pointShadowMap.value=Z.state.pointShadowMap,Ut.pointShadowMatrix.value=Z.state.pointShadowMatrix);let ie=zt.getUniforms(),fi=ii.seqWithValue(ie.seq,Ut);return U.currentProgram=zt,U.uniformsList=fi,zt}function of(M,I){let O=nt.get(M);O.outputEncoding=I.outputEncoding,O.instancing=I.instancing,O.skinning=I.skinning,O.morphTargets=I.morphTargets,O.morphNormals=I.morphNormals,O.morphTargetsCount=I.morphTargetsCount,O.numClippingPlanes=I.numClippingPlanes,O.numIntersection=I.numClipIntersection,O.vertexAlphas=I.vertexAlphas,O.vertexTangents=I.vertexTangents,O.toneMapping=I.toneMapping}function B0(M,I,O,U,Z){I.isScene!==!0&&(I=dt),C.resetTextureUnits();let Tt=I.fog,Ct=U.isMeshStandardMaterial?I.environment:null,Lt=b===null?x.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:ri,Rt=(U.isMeshStandardMaterial?J:j).get(U.envMap||Ct),Gt=U.vertexColors===!0&&!!O.attributes.color&&O.attributes.color.itemSize===4,zt=!!U.normalMap&&!!O.attributes.tangent,Ut=!!O.morphAttributes.position,ie=!!O.morphAttributes.normal,fi=O.morphAttributes.position?O.morphAttributes.position.length:0,Zi=U.toneMapped?x.toneMapping:ti,Ot=nt.get(U),nn=f.state.lights;if(Q===!0&&(at===!0||M!==S)){let Ze=M===S&&U.id===_;E.setState(U,M,Ze)}let le=!1;U.version===Ot.__version?(Ot.needsLights&&Ot.lightsStateVersion!==nn.state.version||Ot.outputEncoding!==Lt||Z.isInstancedMesh&&Ot.instancing===!1||!Z.isInstancedMesh&&Ot.instancing===!0||Z.isSkinnedMesh&&Ot.skinning===!1||!Z.isSkinnedMesh&&Ot.skinning===!0||Ot.envMap!==Rt||U.fog&&Ot.fog!==Tt||Ot.numClippingPlanes!==void 0&&(Ot.numClippingPlanes!==E.numPlanes||Ot.numIntersection!==E.numIntersection)||Ot.vertexAlphas!==Gt||Ot.vertexTangents!==zt||Ot.morphTargets!==Ut||Ot.morphNormals!==ie||Ot.toneMapping!==Zi||St.isWebGL2===!0&&Ot.morphTargetsCount!==fi)&&(le=!0):(le=!0,Ot.__version=U.version);let rn=Ot.currentProgram;le===!0&&(rn=Ol(U,I,Z));let Io=!1,sn=!1,vn=!1,_e=rn.getUniforms(),ns=Ot.uniforms;if(B.useProgram(rn.program)&&(Io=!0,sn=!0,vn=!0),U.id!==_&&(_=U.id,sn=!0),Io||S!==M){if(_e.setValue(k,"projectionMatrix",M.projectionMatrix),St.logarithmicDepthBuffer&&_e.setValue(k,"logDepthBufFC",2/(Math.log(M.far+1)/Math.LN2)),S!==M&&(S=M,sn=!0,vn=!0),U.isShaderMaterial||U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshStandardMaterial||U.envMap){let Ze=_e.map.cameraPosition;Ze!==void 0&&Ze.setValue(k,lt.setFromMatrixPosition(M.matrixWorld))}(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial)&&_e.setValue(k,"isOrthographic",M.isOrthographicCamera===!0),(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial||U.isShadowMaterial||Z.isSkinnedMesh)&&_e.setValue(k,"viewMatrix",M.matrixWorldInverse)}if(Z.isSkinnedMesh){_e.setOptional(k,Z,"bindMatrix"),_e.setOptional(k,Z,"bindMatrixInverse");let Ze=Z.skeleton;Ze&&(St.floatVertexTextures?(Ze.boneTexture===null&&Ze.computeBoneTexture(),_e.setValue(k,"boneTexture",Ze.boneTexture,C),_e.setValue(k,"boneTextureSize",Ze.boneTextureSize)):_e.setOptional(k,Ze,"boneMatrices"))}return!!O&&(O.morphAttributes.position!==void 0||O.morphAttributes.normal!==void 0)&&rt.update(Z,O,U,rn),(sn||Ot.receiveShadow!==Z.receiveShadow)&&(Ot.receiveShadow=Z.receiveShadow,_e.setValue(k,"receiveShadow",Z.receiveShadow)),sn&&(_e.setValue(k,"toneMappingExposure",x.toneMappingExposure),Ot.needsLights&&O0(ns,vn),Tt&&U.fog&&It.refreshFogUniforms(ns,Tt),It.refreshMaterialUniforms(ns,U,y,X,G),ii.upload(k,Ot.uniformsList,ns,C)),U.isShaderMaterial&&U.uniformsNeedUpdate===!0&&(ii.upload(k,Ot.uniformsList,ns,C),U.uniformsNeedUpdate=!1),U.isSpriteMaterial&&_e.setValue(k,"center",Z.center),_e.setValue(k,"modelViewMatrix",Z.modelViewMatrix),_e.setValue(k,"normalMatrix",Z.normalMatrix),_e.setValue(k,"modelMatrix",Z.matrixWorld),rn}function O0(M,I){M.ambientLightColor.needsUpdate=I,M.lightProbe.needsUpdate=I,M.directionalLights.needsUpdate=I,M.directionalLightShadows.needsUpdate=I,M.pointLights.needsUpdate=I,M.pointLightShadows.needsUpdate=I,M.spotLights.needsUpdate=I,M.spotLightShadows.needsUpdate=I,M.rectAreaLights.needsUpdate=I,M.hemisphereLights.needsUpdate=I}function k0(M){return M.isMeshLambertMaterial||M.isMeshToonMaterial||M.isMeshPhongMaterial||M.isMeshStandardMaterial||M.isShadowMaterial||M.isShaderMaterial&&M.lights===!0}this.getActiveCubeFace=function(){return m},this.getActiveMipmapLevel=function(){return p},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(M,I,O){nt.get(M.texture).__webglTexture=I,nt.get(M.depthTexture).__webglTexture=O;let U=nt.get(M);U.__hasExternalTextures=!0,U.__hasExternalTextures&&(U.__autoAllocateDepthBuffer=O===void 0,U.__autoAllocateDepthBuffer||M.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),M.useRenderToTexture=!1,M.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(M,I){let O=nt.get(M);O.__webglFramebuffer=I,O.__useDefaultFramebuffer=I===void 0},this.setRenderTarget=function(M,I=0,O=0){b=M,m=I,p=O;let U=!0;if(M){let Rt=nt.get(M);Rt.__useDefaultFramebuffer!==void 0?(B.bindFramebuffer(36160,null),U=!1):Rt.__webglFramebuffer===void 0?C.setupRenderTarget(M):Rt.__hasExternalTextures&&C.rebindTextures(M,nt.get(M.texture).__webglTexture,nt.get(M.depthTexture).__webglTexture)}let Z=null,Tt=!1,Ct=!1;if(M){let Rt=M.texture;(Rt.isDataTexture3D||Rt.isDataTexture2DArray)&&(Ct=!0);let Gt=nt.get(M).__webglFramebuffer;M.isWebGLCubeRenderTarget?(Z=Gt[I],Tt=!0):M.useRenderbuffer?Z=nt.get(M).__webglMultisampledFramebuffer:Z=Gt,L.copy(M.viewport),A.copy(M.scissor),H=M.scissorTest}else L.copy(F).multiplyScalar(y).floor(),A.copy(z).multiplyScalar(y).floor(),H=N;if(B.bindFramebuffer(36160,Z)&&St.drawBuffers&&U&&B.drawBuffers(M,Z),B.viewport(L),B.scissor(A),B.setScissorTest(H),Tt){let Rt=nt.get(M.texture);k.framebufferTexture2D(36160,36064,34069+I,Rt.__webglTexture,O)}else if(Ct){let Rt=nt.get(M.texture),Gt=I||0;k.framebufferTextureLayer(36160,36064,Rt.__webglTexture,O||0,Gt)}_=-1},this.readRenderTargetPixels=function(M,I,O,U,Z,Tt,Ct){if(!(M&&M.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let Lt=nt.get(M).__webglFramebuffer;if(M.isWebGLCubeRenderTarget&&Ct!==void 0&&(Lt=Lt[Ct]),Lt){B.bindFramebuffer(36160,Lt);try{let Rt=M.texture,Gt=Rt.format,zt=Rt.type;if(Gt!==Re&&_t.convert(Gt)!==k.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Ut=zt===Ur&&(mt.has("EXT_color_buffer_half_float")||St.isWebGL2&&mt.has("EXT_color_buffer_float"));if(zt!==ei&&_t.convert(zt)!==k.getParameter(35738)&&!(zt===Ui&&(St.isWebGL2||mt.has("OES_texture_float")||mt.has("WEBGL_color_buffer_float")))&&!Ut){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}k.checkFramebufferStatus(36160)===36053?I>=0&&I<=M.width-U&&O>=0&&O<=M.height-Z&&k.readPixels(I,O,U,Z,_t.convert(Gt),_t.convert(zt),Tt):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Rt=b!==null?nt.get(b).__webglFramebuffer:null;B.bindFramebuffer(36160,Rt)}}},this.copyFramebufferToTexture=function(M,I,O=0){if(I.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let U=Math.pow(2,-O),Z=Math.floor(I.image.width*U),Tt=Math.floor(I.image.height*U);C.setTexture2D(I,0),k.copyTexSubImage2D(3553,O,0,0,M.x,M.y,Z,Tt),B.unbindTexture()},this.copyTextureToTexture=function(M,I,O,U=0){let Z=I.image.width,Tt=I.image.height,Ct=_t.convert(O.format),Lt=_t.convert(O.type);C.setTexture2D(O,0),k.pixelStorei(37440,O.flipY),k.pixelStorei(37441,O.premultiplyAlpha),k.pixelStorei(3317,O.unpackAlignment),I.isDataTexture?k.texSubImage2D(3553,U,M.x,M.y,Z,Tt,Ct,Lt,I.image.data):I.isCompressedTexture?k.compressedTexSubImage2D(3553,U,M.x,M.y,I.mipmaps[0].width,I.mipmaps[0].height,Ct,I.mipmaps[0].data):k.texSubImage2D(3553,U,M.x,M.y,Ct,Lt,I.image),U===0&&O.generateMipmaps&&k.generateMipmap(3553),B.unbindTexture()},this.copyTextureToTexture3D=function(M,I,O,U,Z=0){if(x.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Tt=M.max.x-M.min.x+1,Ct=M.max.y-M.min.y+1,Lt=M.max.z-M.min.z+1,Rt=_t.convert(U.format),Gt=_t.convert(U.type),zt;if(U.isDataTexture3D)C.setTexture3D(U,0),zt=32879;else if(U.isDataTexture2DArray)C.setTexture2DArray(U,0),zt=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}k.pixelStorei(37440,U.flipY),k.pixelStorei(37441,U.premultiplyAlpha),k.pixelStorei(3317,U.unpackAlignment);let Ut=k.getParameter(3314),ie=k.getParameter(32878),fi=k.getParameter(3316),Zi=k.getParameter(3315),Ot=k.getParameter(32877),nn=O.isCompressedTexture?O.mipmaps[0]:O.image;k.pixelStorei(3314,nn.width),k.pixelStorei(32878,nn.height),k.pixelStorei(3316,M.min.x),k.pixelStorei(3315,M.min.y),k.pixelStorei(32877,M.min.z),O.isDataTexture||O.isDataTexture3D?k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn.data):O.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),k.compressedTexSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,nn.data)):k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn),k.pixelStorei(3314,Ut),k.pixelStorei(32878,ie),k.pixelStorei(3316,fi),k.pixelStorei(3315,Zi),k.pixelStorei(32877,Ot),Z===0&&U.generateMipmaps&&k.generateMipmap(zt),B.unbindTexture()},this.initTexture=function(M){C.setTexture2D(M,0),B.unbindTexture()},this.resetState=function(){m=0,p=0,b=null,B.reset(),yt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}Vt.prototype.isWebGLRenderer=!0;var Ju=class extends Vt{};Ju.prototype.isWebGL1Renderer=!0;var ho=class{constructor(t,e=25e-5){this.name="",this.color=new ft(t),this.density=e}clone(){return new ho(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};ho.prototype.isFogExp2=!0;var fo=class{constructor(t,e=1,i=1e3){this.name="",this.color=new ft(t),this.near=e,this.far=i}clone(){return new fo(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};fo.prototype.isFog=!0;var Yr=class extends kt{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return this.fog!==null&&(e.object.fog=this.fog.toJSON()),e}};Yr.prototype.isScene=!0;var Gi=class{constructor(t,e){this.array=t,this.stride=e,this.count=t!==void 0?t.length/e:0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=tn()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,s=this.stride;r<s;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Gi.prototype.isInterleavedBuffer=!0;var se=new T,Wi=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=r===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyMatrix4(t),this.setXYZ(e,se.x,se.y,se.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyNormalMatrix(t),this.setXYZ(e,se.x,se.y,se.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.transformDirection(t),this.setXYZ(e,se.x,se.y,se.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=s,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return new Qt(new this.array.constructor(e),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Wi(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Wi.prototype.isInterleavedBufferAttribute=!0;var fl=class extends xe{constructor(t){super(),this.type="SpriteMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};fl.prototype.isSpriteMaterial=!0;var Rr,Ws=new T,Lr=new T,Pr=new T,Dr=new K,qs=new K,A0=new wt,Oa=new T,Xs=new T,ka=new T,Ug=new K,Ru=new K,Bg=new K,$u=class extends kt{constructor(t){if(super(),this.type="Sprite",Rr===void 0){Rr=new Ht;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Gi(e,5);Rr.setIndex([0,1,2,0,2,3]),Rr.setAttribute("position",new Wi(i,3,0,!1)),Rr.setAttribute("uv",new Wi(i,2,3,!1))}this.geometry=Rr,this.material=t!==void 0?t:new fl,this.center=new K(.5,.5)}raycast(t,e){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),Lr.setFromMatrixScale(this.matrixWorld),A0.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Pr.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&Lr.multiplyScalar(-Pr.z);let i=this.material.rotation,r,s;i!==0&&(s=Math.cos(i),r=Math.sin(i));let o=this.center;Ha(Oa.set(-.5,-.5,0),Pr,o,Lr,r,s),Ha(Xs.set(.5,-.5,0),Pr,o,Lr,r,s),Ha(ka.set(.5,.5,0),Pr,o,Lr,r,s),Ug.set(0,0),Ru.set(1,0),Bg.set(1,1);let a=t.ray.intersectTriangle(Oa,Xs,ka,!1,Ws);if(a===null&&(Ha(Xs.set(-.5,.5,0),Pr,o,Lr,r,s),Ru.set(0,1),a=t.ray.intersectTriangle(Oa,ka,Xs,!1,Ws),a===null))return;let l=t.ray.origin.distanceTo(Ws);l<t.near||l>t.far||e.push({distance:l,point:Ws.clone(),uv:re.getUV(Ws,Oa,Xs,ka,Ug,Ru,Bg,new K),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};$u.prototype.isSprite=!0;function Ha(n,t,e,i,r,s){Dr.subVectors(n,e).addScalar(.5).multiply(i),r!==void 0?(qs.x=s*Dr.x-r*Dr.y,qs.y=r*Dr.x+s*Dr.y):qs.copy(Dr),n.copy(t),n.x+=qs.x,n.y+=qs.y,n.applyMatrix4(A0)}var Og=new T,kg=new Wt,Hg=new Wt,NE=new T,Vg=new wt,dl=class extends oe{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new wt,this.bindMatrixInverse=new wt}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,e===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Wt,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let s=1/t.manhattanLength();s!==1/0?t.multiplyScalar(s):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;kg.fromBufferAttribute(r.attributes.skinIndex,t),Hg.fromBufferAttribute(r.attributes.skinWeight,t),Og.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let s=0;s<4;s++){let o=Hg.getComponent(s);if(o!==0){let a=kg.getComponent(s);Vg.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(NE.copy(Og).applyMatrix4(Vg),o)}}return e.applyMatrix4(this.bindMatrixInverse)}};dl.prototype.isSkinnedMesh=!0;var Ku=class extends kt{constructor(){super(),this.type="Bone"}};Ku.prototype.isBone=!0;var Qu=class extends ae{constructor(t=null,e=1,i=1,r,s,o,a,l,c=fe,u=fe,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Qu.prototype.isDataTexture=!0;var po=class extends Qt{constructor(t,e,i,r=1){typeof i=="number"&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};po.prototype.isInstancedBufferAttribute=!0;var Gg=new wt,Wg=new wt,Va=[],Ys=new oe,ju=class extends oe{constructor(t,e,i){super(t,e),this.instanceMatrix=new po(new Float32Array(i*16),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,t*16)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(Ys.geometry=this.geometry,Ys.material=this.material,Ys.material!==void 0)for(let s=0;s<r;s++){this.getMatrixAt(s,Gg),Wg.multiplyMatrices(i,Gg),Ys.matrixWorld=Wg,Ys.raycast(t,Va);for(let o=0,a=Va.length;o<a;o++){let l=Va[o];l.instanceId=s,l.object=this,e.push(l)}Va.length=0}}setColorAt(t,e){this.instanceColor===null&&(this.instanceColor=new po(new Float32Array(this.instanceMatrix.count*3),3)),e.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};ju.prototype.isInstancedMesh=!0;var zn=class extends xe{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ft(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};zn.prototype.isLineBasicMaterial=!0;var qg=new T,Xg=new T,Yg=new wt,Lu=new oi,Ga=new si,mo=class extends kt{constructor(t=new Ht,e=new zn){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[0];for(let r=1,s=e.count;r<s;r++)qg.fromBufferAttribute(e,r-1),Xg.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=qg.distanceTo(Xg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Line.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Ga.copy(i.boundingSphere),Ga.applyMatrix4(r),Ga.radius+=s,t.ray.intersectsSphere(Ga)===!1)return;Yg.copy(r).invert(),Lu.copy(t.ray).applyMatrix4(Yg);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new T,u=new T,h=new T,f=new T,d=this.isLineSegments?2:1;if(i.isBufferGeometry){let g=i.index,v=i.attributes.position;if(g!==null){let m=Math.max(0,o.start),p=Math.min(g.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){let S=g.getX(b),L=g.getX(b+1);if(c.fromBufferAttribute(v,S),u.fromBufferAttribute(v,L),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let H=t.ray.origin.distanceTo(f);H<t.near||H>t.far||e.push({distance:H,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let m=Math.max(0,o.start),p=Math.min(v.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){if(c.fromBufferAttribute(v,b),u.fromBufferAttribute(v,b+1),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let L=t.ray.origin.distanceTo(f);L<t.near||L>t.far||e.push({distance:L,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};mo.prototype.isLine=!0;var Zg=new T,Jg=new T,go=class extends mo{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[];for(let r=0,s=e.count;r<s;r+=2)Zg.fromBufferAttribute(e,r),Jg.fromBufferAttribute(e,r+1),i[r]=r===0?0:i[r-1],i[r+1]=i[r]+Zg.distanceTo(Jg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};go.prototype.isLineSegments=!0;var th=class extends mo{constructor(t,e){super(t,e),this.type="LineLoop"}};th.prototype.isLineLoop=!0;var pl=class extends xe{constructor(t){super(),this.type="PointsMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};pl.prototype.isPointsMaterial=!0;var $g=new wt,eh=new oi,Wa=new si,qa=new T,nh=class extends kt{constructor(t=new Ht,e=new pl){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Points.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Wa.copy(i.boundingSphere),Wa.applyMatrix4(r),Wa.radius+=s,t.ray.intersectsSphere(Wa)===!1)return;$g.copy(r).invert(),eh.copy(t.ray).applyMatrix4($g);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,h=i.attributes.position;if(c!==null){let f=Math.max(0,o.start),d=Math.min(c.count,o.start+o.count);for(let g=f,x=d;g<x;g++){let v=c.getX(g);qa.fromBufferAttribute(h,v),Kg(qa,v,l,r,t,e,this)}}else{let f=Math.max(0,o.start),d=Math.min(h.count,o.start+o.count);for(let g=f,x=d;g<x;g++)qa.fromBufferAttribute(h,g),Kg(qa,g,l,r,t,e,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};nh.prototype.isPoints=!0;function Kg(n,t,e,i,r,s,o){let a=eh.distanceSqToPoint(n);if(a<e){let l=new T;eh.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;s.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:o})}}var ih=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.minFilter=o!==void 0?o:be,this.magFilter=s!==void 0?s:be,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};ih.prototype.isVideoTexture=!0;var rh=class extends ae{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=fe,this.minFilter=fe,this.generateMipmaps=!1,this.needsUpdate=!0}};rh.prototype.isFramebufferTexture=!0;var sh=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};sh.prototype.isCompressedTexture=!0;var oh=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.needsUpdate=!0}};oh.prototype.isCanvasTexture=!0;var Zr=class extends Ht{constructor(t=1,e=8,i=0,r=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let s=[],o=[],a=[],l=[],c=new T,u=new K;o.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=e;h++,f+=3){let d=i+h/e*r;c.x=t*Math.cos(d),c.y=t*Math.sin(d),o.push(c.x,c.y,c.z),a.push(0,0,1),u.x=(o[f]/t+1)/2,u.y=(o[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=e;h++)s.push(h,h+1,0);this.setIndex(s),this.setAttribute("position",new ee(o,3)),this.setAttribute("normal",new ee(a,3)),this.setAttribute("uv",new ee(l,2))}static fromJSON(t){return new Zr(t.radius,t.segments,t.thetaStart,t.thetaLength)}};var Sk=new T,Ek=new T,Tk=new T,Ak=new re;var Fe=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let e=[],i,r=this.getPoint(0),s=0;e.push(0);for(let o=1;o<=t;o++)i=this.getPoint(o/t),s+=i.distanceTo(r),e.push(s),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let i=this.getLengths(),r=0,s=i.length,o;e?o=e:o=t*i[s-1];let a=0,l=s-1,c;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-o,c<0)a=r+1;else if(c>0)l=r-1;else{l=r;break}if(r=l,i[r]===o)return r/(s-1);let u=i[r],f=i[r+1]-u,d=(o-u)/f;return(r+d)/(s-1)}getTangent(t,e){let r=t-1e-4,s=t+1e-4;r<0&&(r=0),s>1&&(s=1);let o=this.getPoint(r),a=this.getPoint(s),l=e||(o.isVector2?new K:new T);return l.copy(a).sub(o).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new T,r=[],s=[],o=[],a=new T,l=new wt;for(let d=0;d<=t;d++){let g=d/t;r[d]=this.getTangentAt(g,new T)}s[0]=new T,o[0]=new T;let c=Number.MAX_VALUE,u=Math.abs(r[0].x),h=Math.abs(r[0].y),f=Math.abs(r[0].z);u<=c&&(c=u,i.set(1,0,0)),h<=c&&(c=h,i.set(0,1,0)),f<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),s[0].crossVectors(r[0],a),o[0].crossVectors(r[0],s[0]);for(let d=1;d<=t;d++){if(s[d]=s[d-1].clone(),o[d]=o[d-1].clone(),a.crossVectors(r[d-1],r[d]),a.length()>Number.EPSILON){a.normalize();let g=Math.acos(Ie(r[d-1].dot(r[d]),-1,1));s[d].applyMatrix4(l.makeRotationAxis(a,g))}o[d].crossVectors(r[d],s[d])}if(e===!0){let d=Math.acos(Ie(s[0].dot(s[t]),-1,1));d/=t,r[0].dot(a.crossVectors(s[0],s[t]))>0&&(d=-d);for(let g=1;g<=t;g++)s[g].applyMatrix4(l.makeRotationAxis(r[g],d*g)),o[g].crossVectors(r[g],s[g])}return{tangents:r,normals:s,binormals:o}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},Jr=class extends Fe{constructor(t=0,e=0,i=1,r=1,s=0,o=Math.PI*2,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=s,this.aEndAngle=o,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new K,r=Math.PI*2,s=this.aEndAngle-this.aStartAngle,o=Math.abs(s)<Number.EPSILON;for(;s<0;)s+=r;for(;s>r;)s-=r;s<Number.EPSILON&&(o?s=0:s=r),this.aClockwise===!0&&!o&&(s===r?s=-r:s=s-r);let a=this.aStartAngle+t*s,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,d=c-this.aY;l=f*u-d*h+this.aX,c=f*h+d*u+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};Jr.prototype.isEllipseCurve=!0;var ml=class extends Jr{constructor(t,e,i,r,s,o){super(t,e,i,i,r,s,o),this.type="ArcCurve"}};ml.prototype.isArcCurve=!0;function tf(){let n=0,t=0,e=0,i=0;function r(s,o,a,l){n=s,t=a,e=-3*s+3*o-2*a-l,i=2*s-2*o+a+l}return{initCatmullRom:function(s,o,a,l,c){r(o,a,c*(a-s),c*(l-o))},initNonuniformCatmullRom:function(s,o,a,l,c,u,h){let f=(o-s)/c-(a-s)/(c+u)+(a-o)/u,d=(a-o)/u-(l-o)/(u+h)+(l-a)/h;f*=u,d*=u,r(o,a,f,d)},calc:function(s){let o=s*s,a=o*s;return n+t*s+e*o+i*a}}}var Xa=new T,Pu=new tf,Du=new tf,Iu=new tf,gl=class extends Fe{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new T){let i=e,r=this.points,s=r.length,o=(s-(this.closed?0:1))*t,a=Math.floor(o),l=o-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/s)+1)*s:l===0&&a===s-1&&(a=s-2,l=1);let c,u;this.closed||a>0?c=r[(a-1)%s]:(Xa.subVectors(r[0],r[1]).add(r[0]),c=Xa);let h=r[a%s],f=r[(a+1)%s];if(this.closed||a+2<s?u=r[(a+2)%s]:(Xa.subVectors(r[s-1],r[s-2]).add(r[s-1]),u=Xa),this.curveType==="centripetal"||this.curveType==="chordal"){let d=this.curveType==="chordal"?.5:.25,g=Math.pow(c.distanceToSquared(h),d),x=Math.pow(h.distanceToSquared(f),d),v=Math.pow(f.distanceToSquared(u),d);x<1e-4&&(x=1),g<1e-4&&(g=x),v<1e-4&&(v=x),Pu.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,g,x,v),Du.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,g,x,v),Iu.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,g,x,v)}else this.curveType==="catmullrom"&&(Pu.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),Du.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),Iu.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return i.set(Pu.calc(l),Du.calc(l),Iu.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new T().fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};gl.prototype.isCatmullRomCurve3=!0;function Qg(n,t,e,i,r){let s=(i-t)*.5,o=(r-e)*.5,a=n*n,l=n*a;return(2*e-2*i+s+o)*l+(-3*e+3*i-2*s-o)*a+s*n+e}function FE(n,t){let e=1-n;return e*e*t}function zE(n,t){return 2*(1-n)*n*t}function UE(n,t){return n*n*t}function js(n,t,e,i){return FE(n,t)+zE(n,e)+UE(n,i)}function BE(n,t){let e=1-n;return e*e*e*t}function OE(n,t){let e=1-n;return 3*e*e*n*t}function kE(n,t){return 3*(1-n)*n*n*t}function HE(n,t){return n*n*n*t}function to(n,t,e,i,r){return BE(n,t)+OE(n,e)+kE(n,i)+HE(n,r)}var xo=class extends Fe{constructor(t=new K,e=new K,i=new K,r=new K){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xo.prototype.isCubicBezierCurve=!0;var xl=class extends Fe{constructor(t=new T,e=new T,i=new T,r=new T){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y),to(t,r.z,s.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xl.prototype.isCubicBezierCurve3=!0;var $r=class extends Fe{constructor(t=new K,e=new K){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new K){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new K;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};$r.prototype.isLineCurve=!0;var ah=class extends Fe{constructor(t=new T,e=new T){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new T){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},yo=class extends Fe{constructor(t=new K,e=new K,i=new K){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yo.prototype.isQuadraticBezierCurve=!0;var yl=class extends Fe{constructor(t=new T,e=new T,i=new T){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y),js(t,r.z,s.z,o.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yl.prototype.isQuadraticBezierCurve3=!0;var vo=class extends Fe{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new K){let i=e,r=this.points,s=(r.length-1)*t,o=Math.floor(s),a=s-o,l=r[o===0?o:o-1],c=r[o],u=r[o>r.length-2?r.length-1:o+1],h=r[o>r.length-3?r.length-1:o+2];return i.set(Qg(a,l.x,c.x,u.x,h.x),Qg(a,l.y,c.y,u.y,h.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new K().fromArray(r))}return this}};vo.prototype.isSplineCurve=!0;var C0=Object.freeze({__proto__:null,ArcCurve:ml,CatmullRomCurve3:gl,CubicBezierCurve:xo,CubicBezierCurve3:xl,EllipseCurve:Jr,LineCurve:$r,LineCurve3:ah,QuadraticBezierCurve:yo,QuadraticBezierCurve3:yl,SplineCurve:vo}),lh=class extends Fe{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new $r(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),s=0;for(;s<r.length;){if(r[s]>=i){let o=r[s]-i,a=this.curves[s],l=a.getLength(),c=l===0?0:1-o/l;return a.getPointAt(c,e)}s++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let e=[],i;for(let r=0,s=this.curves;r<s.length;r++){let o=s[r],a=o&&o.isEllipseCurve?t*2:o&&(o.isLineCurve||o.isLineCurve3)?1:o&&o.isSplineCurve?t*o.points.length:t,l=o.getPoints(a);for(let c=0;c<l.length;c++){let u=l[c];i&&i.equals(u)||(e.push(u),i=u)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(r.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++){let r=this.curves[e];t.curves.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(new C0[r.type]().fromJSON(r))}return this}},_o=class extends lh{constructor(t){super(),this.type="Path",this.currentPoint=new K,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new $r(this.currentPoint.clone(),new K(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let s=new yo(this.currentPoint.clone(),new K(t,e),new K(i,r));return this.curves.push(s),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,s,o){let a=new xo(this.currentPoint.clone(),new K(t,e),new K(i,r),new K(s,o));return this.curves.push(a),this.currentPoint.set(s,o),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new vo(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,s,o){let a=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+a,e+l,i,r,s,o),this}absarc(t,e,i,r,s,o){return this.absellipse(t,e,i,i,r,s,o),this}ellipse(t,e,i,r,s,o,a,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,e+u,i,r,s,o,a,l),this}absellipse(t,e,i,r,s,o,a,l){let c=new Jr(t,e,i,r,s,o,a,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Un=class extends _o{constructor(t){super(t),this.uuid=tn(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++){let r=this.holes[e];t.holes.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(new _o().fromJSON(r))}return this}},VE={triangulate:function(n,t,e=2){let i=t&&t.length,r=i?t[0]*e:n.length,s=R0(n,0,r,e,!0),o=[];if(!s||s.next===s.prev)return o;let a,l,c,u,h,f,d;if(i&&(s=YE(n,t,s,e)),n.length>80*e){a=c=n[0],l=u=n[1];for(let g=e;g<r;g+=e)h=n[g],f=n[g+1],h<a&&(a=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);d=Math.max(c-a,u-l),d=d!==0?1/d:0}return wo(s,o,e,a,l,d),o}};function R0(n,t,e,i,r){let s,o;if(r===rT(n,t,e,i)>0)for(s=t;s<e;s+=i)o=jg(s,n[s],n[s+1],o);else for(s=e-i;s>=t;s-=i)o=jg(s,n[s],n[s+1],o);return o&&Dl(o,o.next)&&(bo(o),o=o.next),o}function li(n,t){if(!n)return n;t||(t=n);let e=n,i;do if(i=!1,!e.steiner&&(Dl(e,e.next)||te(e.prev,e,e.next)===0)){if(bo(e),e=t=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==t);return t}function wo(n,t,e,i,r,s,o){if(!n)return;!o&&s&&QE(n,i,r,s);let a=n,l,c;for(;n.prev!==n.next;){if(l=n.prev,c=n.next,s?WE(n,i,r,s):GE(n)){t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),bo(n),n=c.next,a=c.next;continue}if(n=c,n===a){o?o===1?(n=qE(li(n),t,e),wo(n,t,e,i,r,s,2)):o===2&&XE(n,t,e,i,r,s):wo(li(n),t,e,i,r,s,1);break}}}function GE(n){let t=n.prev,e=n,i=n.next;if(te(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(zr(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&te(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function WE(n,t,e,i){let r=n.prev,s=n,o=n.next;if(te(r,s,o)>=0)return!1;let a=r.x<s.x?r.x<o.x?r.x:o.x:s.x<o.x?s.x:o.x,l=r.y<s.y?r.y<o.y?r.y:o.y:s.y<o.y?s.y:o.y,c=r.x>s.x?r.x>o.x?r.x:o.x:s.x>o.x?s.x:o.x,u=r.y>s.y?r.y>o.y?r.y:o.y:s.y>o.y?s.y:o.y,h=ch(a,l,t,e,i),f=ch(c,u,t,e,i),d=n.prevZ,g=n.nextZ;for(;d&&d.z>=h&&g&&g.z<=f;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0||(d=d.prevZ,g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0))return!1;g=g.nextZ}for(;d&&d.z>=h;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;g&&g.z<=f;){if(g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0)return!1;g=g.nextZ}return!0}function qE(n,t,e){let i=n;do{let r=i.prev,s=i.next.next;!Dl(r,s)&&L0(r,i,i.next,s)&&Mo(r,s)&&Mo(s,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(s.i/e),bo(i),bo(i.next),i=n=s),i=i.next}while(i!==n);return li(i)}function XE(n,t,e,i,r,s){let o=n;do{let a=o.next.next;for(;a!==o.prev;){if(o.i!==a.i&&eT(o,a)){let l=P0(o,a);o=li(o,o.next),l=li(l,l.next),wo(o,t,e,i,r,s),wo(l,t,e,i,r,s);return}a=a.next}o=o.next}while(o!==n)}function YE(n,t,e,i){let r=[],s,o,a,l,c;for(s=0,o=t.length;s<o;s++)a=t[s]*i,l=s<o-1?t[s+1]*i:n.length,c=R0(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(tT(c));for(r.sort(ZE),s=0;s<r.length;s++)JE(r[s],e),e=li(e,e.next);return e}function ZE(n,t){return n.x-t.x}function JE(n,t){if(t=$E(n,t),t){let e=P0(t,n);li(t,t.next),li(e,e.next)}}function $E(n,t){let e=t,i=n.x,r=n.y,s=-1/0,o;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let f=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(f<=i&&f>s){if(s=f,f===i){if(r===e.y)return e;if(r===e.next.y)return e.next}o=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!o)return null;if(i===s)return o;let a=o,l=o.x,c=o.y,u=1/0,h;e=o;do i>=e.x&&e.x>=l&&i!==e.x&&zr(r<c?i:s,r,l,c,r<c?s:i,r,e.x,e.y)&&(h=Math.abs(r-e.y)/(i-e.x),Mo(e,n)&&(h<u||h===u&&(e.x>o.x||e.x===o.x&&KE(o,e)))&&(o=e,u=h)),e=e.next;while(e!==a);return o}function KE(n,t){return te(n.prev,n,t.prev)<0&&te(t.next,n,n.next)<0}function QE(n,t,e,i){let r=n;do r.z===null&&(r.z=ch(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,jE(r)}function jE(n){let t,e,i,r,s,o,a,l,c=1;do{for(e=n,n=null,s=null,o=0;e;){for(o++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,!!i);t++);for(l=c;a>0||l>0&&i;)a!==0&&(l===0||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),s?s.nextZ=r:n=r,r.prevZ=s,s=r;e=i}s.nextZ=null,c*=2}while(o>1);return n}function ch(n,t,e,i,r){return n=32767*(n-e)*r,t=32767*(t-i)*r,n=(n|n<<8)&16711935,n=(n|n<<4)&252645135,n=(n|n<<2)&858993459,n=(n|n<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,n|t<<1}function tT(n){let t=n,e=n;do(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next;while(t!==n);return e}function zr(n,t,e,i,r,s,o,a){return(r-o)*(t-a)-(n-o)*(s-a)>=0&&(n-o)*(i-a)-(e-o)*(t-a)>=0&&(e-o)*(s-a)-(r-o)*(i-a)>=0}function eT(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!nT(n,t)&&(Mo(n,t)&&Mo(t,n)&&iT(n,t)&&(te(n.prev,n,t.prev)||te(n,t.prev,t))||Dl(n,t)&&te(n.prev,n,n.next)>0&&te(t.prev,t,t.next)>0)}function te(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function Dl(n,t){return n.x===t.x&&n.y===t.y}function L0(n,t,e,i){let r=Za(te(n,t,e)),s=Za(te(n,t,i)),o=Za(te(e,i,n)),a=Za(te(e,i,t));return!!(r!==s&&o!==a||r===0&&Ya(n,e,t)||s===0&&Ya(n,i,t)||o===0&&Ya(e,n,i)||a===0&&Ya(e,t,i))}function Ya(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function Za(n){return n>0?1:n<0?-1:0}function nT(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&L0(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}function Mo(n,t){return te(n.prev,n,n.next)<0?te(n,t,n.next)>=0&&te(n,n.prev,t)>=0:te(n,t,n.prev)<0||te(n,n.next,t)<0}function iT(n,t){let e=n,i=!1,r=(n.x+t.x)/2,s=(n.y+t.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&r<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==n);return i}function P0(n,t){let e=new uh(n.i,n.x,n.y),i=new uh(t.i,t.x,t.y),r=n.next,s=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function jg(n,t,e,i){let r=new uh(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function bo(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function uh(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function rT(n,t,e,i){let r=0;for(let s=t,o=e-i;s<e;s+=i)r+=(n[o]-n[s])*(n[s+1]+n[o+1]),o=s;return r}var dn=class{static area(t){let e=t.length,i=0;for(let r=e-1,s=0;s<e;r=s++)i+=t[r].x*t[s].y-t[s].x*t[r].y;return i*.5}static isClockWise(t){return dn.area(t)<0}static triangulateShape(t,e){let i=[],r=[],s=[];t0(t),e0(i,t);let o=t.length;e.forEach(t0);for(let l=0;l<e.length;l++)r.push(o),o+=e[l].length,e0(i,e[l]);let a=VE.triangulate(i,r);for(let l=0;l<a.length;l+=3)s.push(a.slice(l,l+3));return s}};function t0(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function e0(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var ci=class extends Ht{constructor(t=new Un([new K(.5,.5),new K(-.5,.5),new K(-.5,-.5),new K(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],s=[];for(let a=0,l=t.length;a<l;a++){let c=t[a];o(c)}this.setAttribute("position",new ee(r,3)),this.setAttribute("uv",new ee(s,2)),this.computeVertexNormals();function o(a){let l=[],c=e.curveSegments!==void 0?e.curveSegments:12,u=e.steps!==void 0?e.steps:1,h=e.depth!==void 0?e.depth:1,f=e.bevelEnabled!==void 0?e.bevelEnabled:!0,d=e.bevelThickness!==void 0?e.bevelThickness:.2,g=e.bevelSize!==void 0?e.bevelSize:d-.1,x=e.bevelOffset!==void 0?e.bevelOffset:0,v=e.bevelSegments!==void 0?e.bevelSegments:3,m=e.extrudePath,p=e.UVGenerator!==void 0?e.UVGenerator:sT;e.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=e.amount);let b,_=!1,S,L,A,H;m&&(b=m.getSpacedPoints(u),_=!0,f=!1,S=m.computeFrenetFrames(u,!1),L=new T,A=new T,H=new T),f||(v=0,d=0,g=0,x=0);let tt=a.extractPoints(c),X=tt.shape,y=tt.holes;if(!dn.isClockWise(X)){X=X.reverse();for(let C=0,j=y.length;C<j;C++){let J=y[C];dn.isClockWise(J)&&(y[C]=J.reverse())}}let D=dn.triangulateShape(X,y),F=X;for(let C=0,j=y.length;C<j;C++){let J=y[C];X=X.concat(J)}function z(C,j,J){return j||console.error("THREE.ExtrudeGeometry: vec does not exist"),j.clone().multiplyScalar(J).add(C)}let N=X.length,V=D.length;function Q(C,j,J){let it,et,vt,bt=C.x-j.x,It=C.y-j.y,Zt=J.x-C.x,qt=J.y-C.y,E=bt*bt+It*It,w=bt*qt-It*Zt;if(Math.abs(w)>Number.EPSILON){let q=Math.sqrt(E),rt=Math.sqrt(Zt*Zt+qt*qt),gt=j.x-It/q,W=j.y+bt/q,_t=J.x-qt/rt,yt=J.y+Zt/rt,ut=((_t-gt)*qt-(yt-W)*Zt)/(bt*qt-It*Zt);it=gt+bt*ut-C.x,et=W+It*ut-C.y;let ct=it*it+et*et;if(ct<=2)return new K(it,et);vt=Math.sqrt(ct/2)}else{let q=!1;bt>Number.EPSILON?Zt>Number.EPSILON&&(q=!0):bt<-Number.EPSILON?Zt<-Number.EPSILON&&(q=!0):Math.sign(It)===Math.sign(qt)&&(q=!0),q?(it=-It,et=bt,vt=Math.sqrt(E)):(it=bt,et=It,vt=Math.sqrt(E/2))}return new K(it/vt,et/vt)}let at=[];for(let C=0,j=F.length,J=j-1,it=C+1;C<j;C++,J++,it++)J===j&&(J=0),it===j&&(it=0),at[C]=Q(F[C],F[J],F[it]);let G=[],$,lt=at.concat();for(let C=0,j=y.length;C<j;C++){let J=y[C];$=[];for(let it=0,et=J.length,vt=et-1,bt=it+1;it<et;it++,vt++,bt++)vt===et&&(vt=0),bt===et&&(bt=0),$[it]=Q(J[it],J[vt],J[bt]);G.push($),lt=lt.concat($)}for(let C=0;C<v;C++){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,-J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);mt(qt.x,qt.y,-J)}}}let dt=g+x;for(let C=0;C<N;C++){let j=f?z(X[C],lt[C],dt):X[C];_?(A.copy(S.normals[0]).multiplyScalar(j.x),L.copy(S.binormals[0]).multiplyScalar(j.y),H.copy(b[0]).add(A).add(L),mt(H.x,H.y,H.z)):mt(j.x,j.y,0)}for(let C=1;C<=u;C++)for(let j=0;j<N;j++){let J=f?z(X[j],lt[j],dt):X[j];_?(A.copy(S.normals[C]).multiplyScalar(J.x),L.copy(S.binormals[C]).multiplyScalar(J.y),H.copy(b[C]).add(A).add(L),mt(H.x,H.y,H.z)):mt(J.x,J.y,h/u*C)}for(let C=v-1;C>=0;C--){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,h+J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);_?mt(qt.x,qt.y+b[u-1].y,b[u-1].x+J):mt(qt.x,qt.y,h+J)}}}xt(),k();function xt(){let C=r.length/3;if(f){let j=0,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[2]+J,et[1]+J,et[0]+J)}j=u+v*2,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[0]+J,et[1]+J,et[2]+J)}}else{for(let j=0;j<V;j++){let J=D[j];St(J[2],J[1],J[0])}for(let j=0;j<V;j++){let J=D[j];St(J[0]+N*u,J[1]+N*u,J[2]+N*u)}}i.addGroup(C,r.length/3-C,0)}function k(){let C=r.length/3,j=0;Ft(F,j),j+=F.length;for(let J=0,it=y.length;J<it;J++){let et=y[J];Ft(et,j),j+=et.length}i.addGroup(C,r.length/3-C,1)}function Ft(C,j){let J=C.length;for(;--J>=0;){let it=J,et=J-1;et<0&&(et=C.length-1);for(let vt=0,bt=u+v*2;vt<bt;vt++){let It=N*vt,Zt=N*(vt+1),qt=j+it+It,E=j+et+It,w=j+et+Zt,q=j+it+Zt;B(qt,E,w,q)}}}function mt(C,j,J){l.push(C),l.push(j),l.push(J)}function St(C,j,J){st(C),st(j),st(J);let it=r.length/3,et=p.generateTopUV(i,r,it-3,it-2,it-1);nt(et[0]),nt(et[1]),nt(et[2])}function B(C,j,J,it){st(C),st(j),st(it),st(j),st(J),st(it);let et=r.length/3,vt=p.generateSideWallUV(i,r,et-6,et-3,et-2,et-1);nt(vt[0]),nt(vt[1]),nt(vt[3]),nt(vt[1]),nt(vt[2]),nt(vt[3])}function st(C){r.push(l[C*3+0]),r.push(l[C*3+1]),r.push(l[C*3+2])}function nt(C){s.push(C.x),s.push(C.y)}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes,i=this.parameters.options;return oT(e,i,t)}static fromJSON(t,e){let i=[];for(let s=0,o=t.shapes.length;s<o;s++){let a=e[t.shapes[s]];i.push(a)}let r=t.options.extrudePath;return r!==void 0&&(t.options.extrudePath=new C0[r.type]().fromJSON(r)),new ci(i,t.options)}},sT={generateTopUV:function(n,t,e,i,r){let s=t[e*3],o=t[e*3+1],a=t[i*3],l=t[i*3+1],c=t[r*3],u=t[r*3+1];return[new K(s,o),new K(a,l),new K(c,u)]},generateSideWallUV:function(n,t,e,i,r,s){let o=t[e*3],a=t[e*3+1],l=t[e*3+2],c=t[i*3],u=t[i*3+1],h=t[i*3+2],f=t[r*3],d=t[r*3+1],g=t[r*3+2],x=t[s*3],v=t[s*3+1],m=t[s*3+2];return Math.abs(a-u)<Math.abs(o-c)?[new K(o,1-l),new K(c,1-h),new K(f,1-g),new K(x,1-m)]:[new K(a,1-l),new K(u,1-h),new K(d,1-g),new K(v,1-m)]}};function oT(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++){let s=n[i];e.shapes.push(s.uuid)}else e.shapes.push(n.uuid);return t.extrudePath!==void 0&&(e.options.extrudePath=t.extrudePath.toJSON()),e}var qi=class extends Ht{constructor(t=new Un([new K(0,.5),new K(-.5,-.5),new K(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],s=[],o=[],a=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(a,l,u),a+=l,l=0;this.setIndex(i),this.setAttribute("position",new ee(r,3)),this.setAttribute("normal",new ee(s,3)),this.setAttribute("uv",new ee(o,2));function c(u){let h=r.length/3,f=u.extractPoints(e),d=f.shape,g=f.holes;dn.isClockWise(d)===!1&&(d=d.reverse());for(let v=0,m=g.length;v<m;v++){let p=g[v];dn.isClockWise(p)===!0&&(g[v]=p.reverse())}let x=dn.triangulateShape(d,g);for(let v=0,m=g.length;v<m;v++){let p=g[v];d=d.concat(p)}for(let v=0,m=d.length;v<m;v++){let p=d[v];r.push(p.x,p.y,0),s.push(0,0,1),o.push(p.x,p.y)}for(let v=0,m=x.length;v<m;v++){let p=x[v],b=p[0]+h,_=p[1]+h,S=p[2]+h;i.push(b,_,S),l+=3}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes;return aT(e,t)}static fromJSON(t,e){let i=[];for(let r=0,s=t.shapes.length;r<s;r++){let o=e[t.shapes[r]];i.push(o)}return new qi(i,t.curveSegments)}};function aT(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++){let r=n[e];t.shapes.push(r.uuid)}else t.shapes.push(n.uuid);return t}var hh=class extends xe{constructor(t){super(),this.type="ShadowMaterial",this.color=new ft(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};hh.prototype.isShadowMaterial=!0;var vl=class extends xe{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ft(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};vl.prototype.isMeshStandardMaterial=!0;var fh=class extends vl{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new K(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ie(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new ft(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ft(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ft(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};fh.prototype.isMeshPhysicalMaterial=!0;var dh=class extends xe{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ft(16777215),this.specular=new ft(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};dh.prototype.isMeshPhongMaterial=!0;var ph=class extends xe{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ft(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ph.prototype.isMeshToonMaterial=!0;var mh=class extends xe{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};mh.prototype.isMeshNormalMaterial=!0;var gh=class extends xe{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};gh.prototype.isMeshLambertMaterial=!0;var xh=class extends xe{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ft(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};xh.prototype.isMeshMatcapMaterial=!0;var yh=class extends zn{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};yh.prototype.isLineDashedMaterial=!0;var Kt={arraySlice:function(n,t,e){return Kt.isTypedArray(n)?new n.constructor(n.subarray(t,e!==void 0?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:typeof t.BYTES_PER_ELEMENT=="number"?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){function t(r,s){return n[r]-n[s]}let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(t),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let s=0,o=0;o!==i;++s){let a=e[s]*t;for(let l=0;l!==t;++l)r[o++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,s=n[0];for(;s!==void 0&&s[i]===void 0;)s=n[r++];if(s===void 0)return;let o=s[i];if(o!==void 0)if(Array.isArray(o))do o=s[i],o!==void 0&&(t.push(s.time),e.push.apply(e,o)),s=n[r++];while(s!==void 0);else if(o.toArray!==void 0)do o=s[i],o!==void 0&&(t.push(s.time),o.toArray(e,e.length)),s=n[r++];while(s!==void 0);else do o=s[i],o!==void 0&&(t.push(s.time),e.push(o)),s=n[r++];while(s!==void 0)},subclip:function(n,t,e,i,r=30){let s=n.clone();s.name=t;let o=[];for(let l=0;l<s.tracks.length;++l){let c=s.tracks[l],u=c.getValueSize(),h=[],f=[];for(let d=0;d<c.times.length;++d){let g=c.times[d]*r;if(!(g<e||g>=i)){h.push(c.times[d]);for(let x=0;x<u;++x)f.push(c.values[d*u+x])}}h.length!==0&&(c.times=Kt.convertArray(h,c.times.constructor),c.values=Kt.convertArray(f,c.values.constructor),o.push(c))}s.tracks=o;let a=1/0;for(let l=0;l<s.tracks.length;++l)a>s.tracks[l].times[0]&&(a=s.tracks[l].times[0]);for(let l=0;l<s.tracks.length;++l)s.tracks[l].shift(-1*a);return s.resetDuration(),s},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,s=t/i;for(let o=0;o<r;++o){let a=e.tracks[o],l=a.ValueTypeName;if(l==="bool"||l==="string")continue;let c=n.tracks.find(function(m){return m.name===a.name&&m.ValueTypeName===l});if(c===void 0)continue;let u=0,h=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,d=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=d/3);let g=a.times.length-1,x;if(s<=a.times[0]){let m=u,p=h-u;x=Kt.arraySlice(a.values,m,p)}else if(s>=a.times[g]){let m=g*h+u,p=m+h-u;x=Kt.arraySlice(a.values,m,p)}else{let m=a.createInterpolant(),p=u,b=h-u;m.evaluate(s),x=Kt.arraySlice(m.resultBuffer,p,b)}l==="quaternion"&&new Ee().fromArray(x).normalize().conjugate().toArray(x);let v=c.times.length;for(let m=0;m<v;++m){let p=m*d+f;if(l==="quaternion")Ee.multiplyQuaternionsFlat(c.values,p,x,0,c.values,p);else{let b=d-f*2;for(let _=0;_<b;++_)c.values[p+_]-=x[_]}}}return n.blendMode=d0,n}},pn=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=r!==void 0?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],s=e[i-1];t:{e:{let o;n:{i:if(!(t<r)){for(let a=i+2;;){if(r===void 0){if(t<s)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,s)}if(i===a)break;if(s=r,r=e[++i],t<r)break e}o=e.length;break n}if(!(t>=s)){let a=e[1];t<a&&(i=2,s=a);for(let l=i-2;;){if(s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=s,s=e[--i-1],t>=s)break e}o=i,i=0;break n}break t}for(;i<o;){let a=i+o>>>1;t<e[a]?o=a:i=a+1}if(r=e[i],s=e[i-1],s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(r===void 0)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,s,t)}this._cachedIndex=i,this.intervalChanged_(i,s,r)}return this.interpolate_(i,s,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,s=t*r;for(let o=0;o!==r;++o)e[o]=i[s+o];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};pn.prototype.beforeStart_=pn.prototype.copySampleValue_;pn.prototype.afterEnd_=pn.prototype.copySampleValue_;var vh=class extends pn{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:Nr,endingEnd:Nr}}intervalChanged_(t,e,i){let r=this.parameterPositions,s=t-2,o=t+1,a=r[s],l=r[o];if(a===void 0)switch(this.getSettings_().endingStart){case Fr:s=t,a=2*e-i;break;case el:s=r.length-2,a=e+r[s]-r[s+1];break;default:s=t,a=i}if(l===void 0)switch(this.getSettings_().endingEnd){case Fr:o=t,l=2*i-e;break;case el:o=1,l=i+r[1]-r[0];break;default:o=t-1,l=e}let c=(i-e)*.5,u=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=s*u,this._offsetNext=o*u}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,d=this._weightNext,g=(i-e)/(r-e),x=g*g,v=x*g,m=-f*v+2*f*x-f*g,p=(1+f)*v+(-1.5-2*f)*x+(-.5+f)*g+1,b=(-1-d)*v+(1.5+d)*x+.5*g,_=d*v-d*x;for(let S=0;S!==a;++S)s[S]=m*o[u+S]+p*o[c+S]+b*o[l+S]+_*o[h+S];return s}},_l=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=(i-e)/(r-e),h=1-u;for(let f=0;f!==a;++f)s[f]=o[c+f]*h+o[l+f]*u;return s}},_h=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},Xe=class{constructor(t,e,i,r){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(e===void 0||e.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Kt.convertArray(e,this.TimeBufferType),this.values=Kt.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let e=t.constructor,i;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Kt.convertArray(t.times,Array),values:Kt.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new _h(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new _l(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new vh(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case ja:e=this.InterpolantFactoryMethodDiscrete;break;case tl:e=this.InterpolantFactoryMethodLinear;break;case eu:e=this.InterpolantFactoryMethodSmooth;break}if(e===void 0){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(i);return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return ja;case this.InterpolantFactoryMethodLinear:return tl;case this.InterpolantFactoryMethodSmooth:return eu}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(t!==1){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,s=0,o=r-1;for(;s!==r&&i[s]<t;)++s;for(;o!==-1&&i[o]>e;)--o;if(++o,s!==0||o!==r){s>=o&&(o=Math.max(o,1),s=o-1);let a=this.getValueSize();this.times=Kt.arraySlice(i,s,o),this.values=Kt.arraySlice(this.values,s*a,o*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,s=i.length;s===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let o=null;for(let a=0;a!==s;a++){let l=i[a];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(o!==null&&o>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,o),t=!1;break}o=l}if(r!==void 0&&Kt.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=Kt.arraySlice(this.times),e=Kt.arraySlice(this.values),i=this.getValueSize(),r=this.getInterpolation()===eu,s=t.length-1,o=1;for(let a=1;a<s;++a){let l=!1,c=t[a],u=t[a+1];if(c!==u&&(a!==1||c!==t[0]))if(r)l=!0;else{let h=a*i,f=h-i,d=h+i;for(let g=0;g!==i;++g){let x=e[h+g];if(x!==e[f+g]||x!==e[d+g]){l=!0;break}}}if(l){if(a!==o){t[o]=t[a];let h=a*i,f=o*i;for(let d=0;d!==i;++d)e[f+d]=e[h+d]}++o}}if(s>0){t[o]=t[s];for(let a=s*i,l=o*i,c=0;c!==i;++c)e[l+c]=e[a+c];++o}return o!==t.length?(this.times=Kt.arraySlice(t,0,o),this.values=Kt.arraySlice(e,0,o*i)):(this.times=t,this.values=e),this}clone(){let t=Kt.arraySlice(this.times,0),e=Kt.arraySlice(this.values,0),i=this.constructor,r=new i(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};Xe.prototype.TimeBufferType=Float32Array;Xe.prototype.ValueBufferType=Float32Array;Xe.prototype.DefaultInterpolation=tl;var ui=class extends Xe{};ui.prototype.ValueTypeName="bool";ui.prototype.ValueBufferType=Array;ui.prototype.DefaultInterpolation=ja;ui.prototype.InterpolantFactoryMethodLinear=void 0;ui.prototype.InterpolantFactoryMethodSmooth=void 0;var wl=class extends Xe{};wl.prototype.ValueTypeName="color";var Kr=class extends Xe{};Kr.prototype.ValueTypeName="number";var wh=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let u=c+a;c!==u;c+=4)Ee.slerpFlat(s,0,o,c-a,o,c,l);return s}},Xi=class extends Xe{InterpolantFactoryMethodLinear(t){return new wh(this.times,this.values,this.getValueSize(),t)}};Xi.prototype.ValueTypeName="quaternion";Xi.prototype.DefaultInterpolation=tl;Xi.prototype.InterpolantFactoryMethodSmooth=void 0;var hi=class extends Xe{};hi.prototype.ValueTypeName="string";hi.prototype.ValueBufferType=Array;hi.prototype.DefaultInterpolation=ja;hi.prototype.InterpolantFactoryMethodLinear=void 0;hi.prototype.InterpolantFactoryMethodSmooth=void 0;var Qr=class extends Xe{};Qr.prototype.ValueTypeName="vector";var Ml=class{constructor(t,e=-1,i,r=Qh){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=tn(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let o=0,a=i.length;o!==a;++o)e.push(cT(i[o]).scale(r));let s=new this(t.name,t.duration,e,t.blendMode);return s.uuid=t.uuid,s}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let s=0,o=i.length;s!==o;++s)e.push(Xe.toJSON(i[s]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let s=e.length,o=[];for(let a=0;a<s;a++){let l=[],c=[];l.push((a+s-1)%s,a,(a+1)%s),c.push(0,1,0);let u=Kt.getKeyframeOrder(l);l=Kt.sortedArray(l,1,u),c=Kt.sortedArray(c,1,u),!r&&l[0]===0&&(l.push(s),c.push(c[0])),o.push(new Kr(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,o)}static findByName(t,e){let i=t;if(!Array.isArray(t)){let r=t;i=r.geometry&&r.geometry.animations||r.animations}for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},s=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],u=c.name.match(s);if(u&&u.length>1){let h=u[1],f=r[h];f||(r[h]=f=[]),f.push(c)}}let o=[];for(let a in r)o.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return o}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(h,f,d,g,x){if(d.length!==0){let v=[],m=[];Kt.flattenJSON(d,v,m,g),v.length!==0&&x.push(new h(f,v,m))}},r=[],s=t.name||"default",o=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let d={},g;for(g=0;g<f.length;g++)if(f[g].morphTargets)for(let x=0;x<f[g].morphTargets.length;x++)d[f[g].morphTargets[x]]=-1;for(let x in d){let v=[],m=[];for(let p=0;p!==f[g].morphTargets.length;++p){let b=f[g];v.push(b.time),m.push(b.morphTarget===x?1:0)}r.push(new Kr(".morphTargetInfluence["+x+"]",v,m))}l=d.length*(o||1)}else{let d=".bones["+e[h].name+"]";i(Qr,d+".position",f,"pos",r),i(Xi,d+".quaternion",f,"rot",r),i(Qr,d+".scale",f,"scl",r)}}return r.length===0?null:new this(s,l,r,a)}resetDuration(){let t=this.tracks,e=0;for(let i=0,r=t.length;i!==r;++i){let s=this.tracks[i];e=Math.max(e,s.times[s.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function lT(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Kr;case"vector":case"vector2":case"vector3":case"vector4":return Qr;case"color":return wl;case"quaternion":return Xi;case"bool":case"boolean":return ui;case"string":return hi}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}function cT(n){if(n.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=lT(n.type);if(n.times===void 0){let e=[],i=[];Kt.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return t.parse!==void 0?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var jr={enabled:!1,files:{},add:function(n,t){this.enabled!==!1&&(this.files[n]=t)},get:function(n){if(this.enabled!==!1)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},Mh=class{constructor(t,e,i){let r=this,s=!1,o=0,a=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(u){a++,s===!1&&r.onStart!==void 0&&r.onStart(u,o,a),s=!0},this.itemEnd=function(u){o++,r.onProgress!==void 0&&r.onProgress(u,o,a),o===a&&(s=!1,r.onLoad!==void 0&&r.onLoad())},this.itemError=function(u){r.onError!==void 0&&r.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let d=c[h],g=c[h+1];if(d.global&&(d.lastIndex=0),d.test(u))return g}return null}}},uT=new Mh,mn=class{constructor(t){this.manager=t!==void 0?t:uT,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,s){i.load(t,r,e,s)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Dn={},bh=class extends mn{constructor(t){super(t)}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=jr.get(t);if(s!==void 0)return this.manager.itemStart(t),setTimeout(()=>{e&&e(s),this.manager.itemEnd(t)},0),s;if(Dn[t]!==void 0){Dn[t].push({onLoad:e,onProgress:i,onError:r});return}Dn[t]=[],Dn[t].push({onLoad:e,onProgress:i,onError:r});let o=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(o).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Dn[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),d=f?parseInt(f):0,g=d!==0,x=0,v=new ReadableStream({start(m){p();function p(){h.read().then(({done:b,value:_})=>{if(b)m.close();else{x+=_.byteLength;let S=new ProgressEvent("progress",{lengthComputable:g,loaded:x,total:d});for(let L=0,A=u.length;L<A;L++){let H=u[L];H.onProgress&&H.onProgress(S)}m.enqueue(_),p()}})}}});return new Response(v)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,a));case"json":return c.json();default:if(a===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(a),f=h&&h[1]?h[1].toLowerCase():void 0,d=new TextDecoder(f);return c.arrayBuffer().then(g=>d.decode(g))}}}).then(c=>{jr.add(t,c);let u=Dn[t];delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onLoad&&d.onLoad(c)}}).catch(c=>{let u=Dn[t];if(u===void 0)throw this.manager.itemError(t),c;delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onError&&d.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}};var bl=class extends mn{constructor(t){super(t)}load(t,e,i,r){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a=ro("img");function l(){u(),jr.add(t,this),e&&e(this),s.manager.itemEnd(t)}function c(h){u(),r&&r(h),s.manager.itemError(t),s.manager.itemEnd(t)}function u(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(a.crossOrigin=this.crossOrigin),s.manager.itemStart(t),a.src=t,a}},Sh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new Wr,o=new bl(this.manager);o.setCrossOrigin(this.crossOrigin),o.setPath(this.path);let a=0;function l(c){o.load(t[c],function(u){s.images[c]=u,a++,a===6&&(s.needsUpdate=!0,e&&e(s))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return s}};var Eh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new ae,o=new bl(this.manager);return o.setCrossOrigin(this.crossOrigin),o.setPath(this.path),o.load(t,function(a){s.image=a,s.needsUpdate=!0,e!==void 0&&e(s)},i,r),s}},Ye=class extends kt{constructor(t,e=1){super(),this.type="Light",this.color=new ft(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,this.groundColor!==void 0&&(e.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(e.object.distance=this.distance),this.angle!==void 0&&(e.object.angle=this.angle),this.decay!==void 0&&(e.object.decay=this.decay),this.penumbra!==void 0&&(e.object.penumbra=this.penumbra),this.shadow!==void 0&&(e.object.shadow=this.shadow.toJSON()),e}};Ye.prototype.isLight=!0;var Th=class extends Ye{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.groundColor=new ft(e)}copy(t){return Ye.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};Th.prototype.isHemisphereLight=!0;var n0=new wt,i0=new T,r0=new T,So=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new K(512,512),this.map=null,this.mapPass=null,this.matrix=new wt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new qr,this._frameExtents=new K(1,1),this._viewportCount=1,this._viewports=[new Wt(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;i0.setFromMatrixPosition(t.matrixWorld),e.position.copy(i0),r0.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(r0),e.updateMatrixWorld(),n0.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(n0),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},Sl=class extends So{constructor(){super(new Se(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=Vu*2*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,s=t.distance||e.far;(i!==e.fov||r!==e.aspect||s!==e.far)&&(e.fov=i,e.aspect=r,e.far=s,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};Sl.prototype.isSpotLightShadow=!0;var Ah=class extends Ye{constructor(t,e,i=0,r=Math.PI/3,s=0,o=1){super(t,e),this.type="SpotLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.distance=i,this.angle=r,this.penumbra=s,this.decay=o,this.shadow=new Sl}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Ah.prototype.isSpotLight=!0;var s0=new wt,Zs=new T,Nu=new T,El=class extends So{constructor(){super(new Se(90,1,.5,500)),this._frameExtents=new K(4,2),this._viewportCount=6,this._viewports=[new Wt(2,1,1,1),new Wt(0,1,1,1),new Wt(3,1,1,1),new Wt(1,1,1,1),new Wt(3,0,1,1),new Wt(1,0,1,1)],this._cubeDirections=[new T(1,0,0),new T(-1,0,0),new T(0,0,1),new T(0,0,-1),new T(0,1,0),new T(0,-1,0)],this._cubeUps=[new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,0,1),new T(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,s=t.distance||i.far;s!==i.far&&(i.far=s,i.updateProjectionMatrix()),Zs.setFromMatrixPosition(t.matrixWorld),i.position.copy(Zs),Nu.copy(i.position),Nu.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(Nu),i.updateMatrixWorld(),r.makeTranslation(-Zs.x,-Zs.y,-Zs.z),s0.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(s0)}};El.prototype.isPointLightShadow=!0;var Ch=class extends Ye{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new El}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};Ch.prototype.isPointLight=!0;var Tl=class extends So{constructor(){super(new Vi(-5,5,5,-5,.5,500))}};Tl.prototype.isDirectionalLightShadow=!0;var Rh=class extends Ye{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.shadow=new Tl}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Rh.prototype.isDirectionalLight=!0;var Lh=class extends Ye{constructor(t,e){super(t,e),this.type="AmbientLight"}};Lh.prototype.isAmbientLight=!0;var Ph=class extends Ye{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}};Ph.prototype.isRectAreaLight=!0;var Al=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new T)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.282095),e.addScaledVector(o[1],.488603*r),e.addScaledVector(o[2],.488603*s),e.addScaledVector(o[3],.488603*i),e.addScaledVector(o[4],1.092548*(i*r)),e.addScaledVector(o[5],1.092548*(r*s)),e.addScaledVector(o[6],.315392*(3*s*s-1)),e.addScaledVector(o[7],1.092548*(i*s)),e.addScaledVector(o[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.886227),e.addScaledVector(o[1],2*.511664*r),e.addScaledVector(o[2],2*.511664*s),e.addScaledVector(o[3],2*.511664*i),e.addScaledVector(o[4],2*.429043*i*r),e.addScaledVector(o[5],2*.429043*r*s),e.addScaledVector(o[6],.743125*s*s-.247708),e.addScaledVector(o[7],2*.429043*i*s),e.addScaledVector(o[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+r*3);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+r*3);return t}static getBasisAt(t,e){let i=t.x,r=t.y,s=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*s,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*s,e[6]=.315392*(3*s*s-1),e[7]=1.092548*i*s,e[8]=.546274*(i*i-r*r)}};Al.prototype.isSphericalHarmonics3=!0;var Eo=class extends Ye{constructor(t=new Al,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};Eo.prototype.isLightProbe=!0;var Dh=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch(i){return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return e===-1?"./":t.substr(0,e+1)}static resolveURL(t,e){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}},Ih=class extends Ht{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};Ih.prototype.isInstancedBufferGeometry=!0;var Nh=class extends mn{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a={};a.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(s.options,{colorSpaceConversion:"none"}))}).then(function(l){jr.add(t,l),e&&e(l),s.manager.itemEnd(t)}).catch(function(l){r&&r(l),s.manager.itemError(t),s.manager.itemEnd(t)}),s.manager.itemStart(t)}};Nh.prototype.isImageBitmapLoader=!0;var Ja,hT={getContext:function(){return Ja===void 0&&(Ja=new(window.AudioContext||window.webkitAudioContext)),Ja},setContext:function(n){Ja=n}},Fh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=this,o=new bh(this.manager);o.setResponseType("arraybuffer"),o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials),o.load(t,function(a){try{let l=a.slice(0);hT.getContext().decodeAudioData(l,function(u){e(u)})}catch(l){r?r(l):console.error(l),s.manager.itemError(t)}},i,r)}},zh=class extends Eo{constructor(t,e,i=1){super(void 0,i);let r=new ft().set(t),s=new ft().set(e),o=new T(r.r,r.g,r.b),a=new T(s.r,s.g,s.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(c)}};zh.prototype.isHemisphereLightProbe=!0;var Uh=class extends Eo{constructor(t,e=1){super(void 0,e);let i=new ft().set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}};Uh.prototype.isAmbientLightProbe=!0;var Bh=class extends kt{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}};var Oh=class{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,e=this.getFrequencyData();for(let i=0;i<e.length;i++)t+=e[i];return t/e.length}},kh=class{constructor(t,e,i){this.binding=t,this.valueSize=i;let r,s,o;switch(e){case"quaternion":r=this._slerp,s=this._slerpAdditive,o=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(i*6),this._workIndex=5;break;case"string":case"bool":r=this._select,s=this._select,o=this._setAdditiveIdentityOther,this.buffer=new Array(i*5);break;default:r=this._lerp,s=this._lerpAdditive,o=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(i*5)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=s,this._setIdentity=o,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,s=t*r+r,o=this.cumulativeWeight;if(o===0){for(let a=0;a!==r;++a)i[s+a]=i[a];o=e}else{o+=e;let a=e/o;this._mixBufferRegion(i,s,0,a,r)}this.cumulativeWeight=o}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,s=this.cumulativeWeight,o=this.cumulativeWeightAdditive,a=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,s<1){let l=e*this._origIndex;this._mixBufferRegion(i,r,l,1-s,e)}o>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let t=this.binding,e=this.buffer,i=this.valueSize,r=i*this._origIndex;t.getValue(e,r);for(let s=i,o=r;s!==o;++s)e[s]=e[r+s%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,s){if(r>=.5)for(let o=0;o!==s;++o)t[e+o]=t[i+o]}_slerp(t,e,i,r){Ee.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,s){let o=this._workIndex*s;Ee.multiplyQuaternionsFlat(t,o,t,e,t,i),Ee.slerpFlat(t,e,t,e,t,o,r)}_lerp(t,e,i,r,s){let o=1-r;for(let a=0;a!==s;++a){let l=e+a;t[l]=t[l]*o+t[i+a]*r}}_lerpAdditive(t,e,i,r,s){for(let o=0;o!==s;++o){let a=e+o;t[a]=t[a]+t[i+o]*r}}},ef="\\[\\]\\.:\\/",fT=new RegExp("["+ef+"]","g"),nf="[^"+ef+"]",dT="[^"+ef.replace("\\.","")+"]",pT=/((?:WC+[\/:])*)/.source.replace("WC",nf),mT=/(WCOD+)?/.source.replace("WCOD",dT),gT=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",nf),xT=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",nf),yT=new RegExp("^"+pT+mT+gT+xT+"$"),vT=["material","materials","bones"],Hh=class{constructor(t,e,i){let r=i||Nt.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let i=this._targetGroup.nCachedObjects_,r=this._bindings[i];r!==void 0&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,s=i.length;r!==s;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},Nt=class{constructor(t,e,i){this.path=e,this.parsedPath=i||Nt.parseTrackName(e),this.node=Nt.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,i){return t&&t.isAnimationObjectGroup?new Nt.Composite(t,e,i):new Nt(t,e,i)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(fT,"")}static parseTrackName(t){let e=yT.exec(t);if(!e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let i={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},r=i.nodeName&&i.nodeName.lastIndexOf(".");if(r!==void 0&&r!==-1){let s=i.nodeName.substring(r+1);vT.indexOf(s)!==-1&&(i.nodeName=i.nodeName.substring(0,r),i.objectName=s)}if(i.propertyName===null||i.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return i}static findNode(t,e){if(!e||e===""||e==="."||e===-1||e===t.name||e===t.uuid)return t;if(t.skeleton){let i=t.skeleton.getBoneByName(e);if(i!==void 0)return i}if(t.children){let i=function(s){for(let o=0;o<s.length;o++){let a=s[o];if(a.name===e||a.uuid===e)return a;let l=i(a.children);if(l)return l}return null},r=i(t.children);if(r)return r}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,e){t[e]=this.targetObject[this.propertyName]}_getValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)t[e++]=i[r]}_getValue_arrayElement(t,e){t[e]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,e){this.resolvedProperty.toArray(t,e)}_setValue_direct(t,e){this.targetObject[this.propertyName]=t[e]}_setValue_direct_setNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++]}_setValue_array_setNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,e){this.resolvedProperty[this.propertyIndex]=t[e]}_setValue_arrayElement_setNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,e){this.resolvedProperty.fromArray(t,e)}_setValue_fromArray_setNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,e){this.bind(),this.getValue(t,e)}_setValue_unbound(t,e){this.bind(),this.setValue(t,e)}bind(){let t=this.node,e=this.parsedPath,i=e.objectName,r=e.propertyName,s=e.propertyIndex;if(t||(t=Nt.findNode(this.rootNode,e.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(i){let c=e.objectIndex;switch(i){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[i]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[i]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let o=t[r];if(o===void 0){let c=e.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+r+" but it wasn't found.",t);return}let a=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?a=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(a=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(s!==void 0){if(r==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[s]!==void 0&&(s=t.morphTargetDictionary[s])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=o,this.propertyIndex=s}else o.fromArray!==void 0&&o.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=o):Array.isArray(o)?(l=this.BindingType.EntireArray,this.resolvedProperty=o):this.propertyName=r;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][a]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Nt.Composite=Hh;Nt.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Nt.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Nt.prototype.GetterByBindingType=[Nt.prototype._getValue_direct,Nt.prototype._getValue_array,Nt.prototype._getValue_arrayElement,Nt.prototype._getValue_toArray];Nt.prototype.SetterByBindingTypeAndVersioning=[[Nt.prototype._setValue_direct,Nt.prototype._setValue_direct_setNeedsUpdate,Nt.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_array,Nt.prototype._setValue_array_setNeedsUpdate,Nt.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_arrayElement,Nt.prototype._setValue_arrayElement_setNeedsUpdate,Nt.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_fromArray,Nt.prototype._setValue_fromArray_setNeedsUpdate,Nt.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var Vh=class{constructor(){this.uuid=tn(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let i=0,r=arguments.length;i!==r;++i)t[arguments[i].uuid]=i;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let e=this;this.stats={objects:{get total(){return e._objects.length},get inUse(){return this.total-e.nCachedObjects_}},get bindingsPerObject(){return e._bindings.length}}}add(){let t=this._objects,e=this._indicesByUUID,i=this._paths,r=this._parsedPaths,s=this._bindings,o=s.length,a,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],d=f.uuid,g=e[d];if(g===void 0){g=l++,e[d]=g,t.push(f);for(let x=0,v=o;x!==v;++x)s[x].push(new Nt(f,i[x],r[x]))}else if(g<c){a=t[g];let x=--c,v=t[x];e[v.uuid]=g,t[g]=v,e[d]=x,t[x]=f;for(let m=0,p=o;m!==p;++m){let b=s[m],_=b[x],S=b[g];b[g]=_,S===void 0&&(S=new Nt(f,i[m],r[m])),b[x]=S}}else t[g]!==a&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_;for(let o=0,a=arguments.length;o!==a;++o){let l=arguments[o],c=l.uuid,u=e[c];if(u!==void 0&&u>=s){let h=s++,f=t[h];e[f.uuid]=u,t[u]=f,e[c]=h,t[h]=l;for(let d=0,g=r;d!==g;++d){let x=i[d],v=x[h],m=x[u];x[u]=v,x[h]=m}}}this.nCachedObjects_=s}uncache(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_,o=t.length;for(let a=0,l=arguments.length;a!==l;++a){let c=arguments[a],u=c.uuid,h=e[u];if(h!==void 0)if(delete e[u],h<s){let f=--s,d=t[f],g=--o,x=t[g];e[d.uuid]=h,t[h]=d,e[x.uuid]=f,t[f]=x,t.pop();for(let v=0,m=r;v!==m;++v){let p=i[v],b=p[f],_=p[g];p[h]=b,p[f]=_,p.pop()}}else{let f=--o,d=t[f];f>0&&(e[d.uuid]=h),t[h]=d,t.pop();for(let g=0,x=r;g!==x;++g){let v=i[g];v[h]=v[f],v.pop()}}}this.nCachedObjects_=s}subscribe_(t,e){let i=this._bindingsIndicesByPath,r=i[t],s=this._bindings;if(r!==void 0)return s[r];let o=this._paths,a=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);r=s.length,i[t]=r,o.push(t),a.push(e),s.push(h);for(let f=u,d=l.length;f!==d;++f){let g=l[f];h[f]=new Nt(g,t,e)}return h}unsubscribe_(t){let e=this._bindingsIndicesByPath,i=e[t];if(i!==void 0){let r=this._paths,s=this._parsedPaths,o=this._bindings,a=o.length-1,l=o[a],c=t[a];e[c]=i,o[i]=l,o.pop(),s[i]=s[a],s.pop(),r[i]=r[a],r.pop()}}};Vh.prototype.isAnimationObjectGroup=!0;var Gh=class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let s=e.tracks,o=s.length,a=new Array(o),l={endingStart:Nr,endingEnd:Nr};for(let c=0;c!==o;++c){let u=s[c].createInterpolant(null);a[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(o),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Zw,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,s=t._clip.duration,o=s/r,a=r/s;t.warp(1,o,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,s=r.time,o=this.timeScale,a=this._timeScaleInterpolant;a===null&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=s,l[1]=s+i,c[0]=t/o,c[1]=e/o,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled){this._updateWeight(t);return}let s=this._startTime;if(s!==null){let l=(t-s)*i;if(l<0||i===0)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let o=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case d0:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulateAdditive(a);break;case Qh:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulate(r,a)}}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(i!==null){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),r===0&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;i!==null&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),e===0?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,s=this._loopCount,o=i===Jw;if(t===0)return s===-1?r:o&&(s&1)===1?e-r:r;if(i===Yw){s===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(r>=e)r=e;else if(r<0)r=0;else{this.time=r;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(s===-1&&(t>=0?(s=0,this._setEndings(!0,this.repetitions===0,o)):this._setEndings(this.repetitions===0,!0,o)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,s+=Math.abs(a);let l=this.repetitions-s;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,o)}else this._setEndings(!1,!1,o);this._loopCount=s,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(o&&(s&1)===1)return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=Fr,r.endingEnd=Fr):(t?r.endingStart=this.zeroSlopeAtStart?Fr:Nr:r.endingStart=el,e?r.endingEnd=this.zeroSlopeAtEnd?Fr:Nr:r.endingEnd=el)}_scheduleFading(t,e,i){let r=this._mixer,s=r.time,o=this._weightInterpolant;o===null&&(o=r._lendControlInterpolant(),this._weightInterpolant=o);let a=o.parameterPositions,l=o.sampleValues;return a[0]=s,l[0]=e,a[1]=s+t,l[1]=i,this}},Wh=class extends In{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,s=r.length,o=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==s;++h){let f=r[h],d=f.name,g=u[d];if(g!==void 0)++g.referenceCount,o[h]=g;else{if(g=o[h],g!==void 0){g._cacheIndex===null&&(++g.referenceCount,this._addInactiveBinding(g,l,d));continue}let x=e&&e._propertyBindings[h].binding.parsedPath;g=new kh(Nt.create(i,d,x),f.ValueTypeName,f.getValueSize()),++g.referenceCount,this._addInactiveBinding(g,l,d),o[h]=g}a[h].resultBuffer=g.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,s=this._actionsByClip[r];this._bindAction(t,s&&s.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];s.useCount++===0&&(this._lendBinding(s),s.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.useCount===0&&(s.restoreOriginalState(),this._takeBackBinding(s))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return e!==null&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,s=this._actionsByClip,o=s[e];if(o===void 0)o={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,s[e]=o;else{let a=o.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),o.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let s=t._clip.uuid,o=this._actionsByClip,a=o[s],l=a.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=a.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete o[s],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.referenceCount===0&&this._removeInactiveBinding(s)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,s=this._bindings,o=r[e];o===void 0&&(o={},r[e]=o),o[i]=t,t._cacheIndex=s.length,s.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,s=i.path,o=this._bindingsByRootAndName,a=o[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[s],Object.keys(a).length===0&&delete o[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return i===void 0&&(i=new _l(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,s=e[r];t.__cacheIndex=r,e[r]=t,s.__cacheIndex=i,e[i]=s}clipAction(t,e,i){let r=e||this._root,s=r.uuid,o=typeof t=="string"?Ml.findByName(r,t):t,a=o!==null?o.uuid:t,l=this._actionsByClip[a],c=null;if(i===void 0&&(o!==null?i=o.blendMode:i=Qh),l!==void 0){let h=l.actionByRoot[s];if(h!==void 0&&h.blendMode===i)return h;c=l.knownActions[0],o===null&&(o=c._clip)}if(o===null)return null;let u=new Gh(this,o,e,i);return this._bindAction(u,c),this._addInactiveAction(u,a,s),u}existingAction(t,e){let i=e||this._root,r=i.uuid,s=typeof t=="string"?Ml.findByName(i,t):t,o=s?s.uuid:t,a=this._actionsByClip[o];return a!==void 0&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions,e=this._nActiveActions;for(let i=e-1;i>=0;--i)t[i].stop();return this}update(t){t*=this.timeScale;let e=this._actions,i=this._nActiveActions,r=this.time+=t,s=Math.sign(t),o=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,s,o);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(o);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,s=r[i];if(s!==void 0){let o=s.knownActions;for(let a=0,l=o.length;a!==l;++a){let c=o[a];this._deactivateAction(c);let u=c._cacheIndex,h=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,e[u]=h,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let o in i){let a=i[o].actionByRoot,l=a[e];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let r=this._bindingsByRootAndName,s=r[e];if(s!==void 0)for(let o in s){let a=s[o];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);i!==null&&(this._deactivateAction(i),this._removeInactiveAction(i))}};Wh.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var To=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new To(this.value.clone===void 0?this.value:this.value.clone())}},qh=class extends Gi{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}};qh.prototype.isInstancedInterleavedBuffer=!0;var Xh=class{constructor(t,e,i,r,s){this.buffer=t,this.type=e,this.itemSize=i,this.elementSize=r,this.count=s,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,e){return this.type=t,this.elementSize=e,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};Xh.prototype.isGLBufferAttribute=!0;var o0=new K,Yi=class{constructor(t=new K(1/0,1/0),e=new K(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=o0.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return o0.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Yi.prototype.isBox2=!0;var a0=new T,$a=new T,Yh=class{constructor(t=new T,e=new T){this.start=t,this.end=e}set(t,e){return this.start.copy(t),this.end.copy(e),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){a0.subVectors(t,this.start),$a.subVectors(this.end,this.start);let i=$a.dot($a),s=$a.dot(a0)/i;return e&&(s=Ie(s,0,1)),s}closestPointToPoint(t,e,i){let r=this.closestPointToPointParameter(t,e);return this.delta(i).multiplyScalar(r).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}};var Qn=new T,Ka=new wt,Fu=new wt,Zh=class extends go{constructor(t){let e=D0(t),i=new Ht,r=[],s=[],o=new ft(0,0,1),a=new ft(0,1,0);for(let c=0;c<e.length;c++){let u=e[c];u.parent&&u.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),s.push(o.r,o.g,o.b),s.push(a.r,a.g,a.b))}i.setAttribute("position",new ee(r,3)),i.setAttribute("color",new ee(s,3));let l=new zn({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(i,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");Fu.copy(this.root.matrixWorld).invert();for(let s=0,o=0;s<e.length;s++){let a=e[s];a.parent&&a.parent.isBone&&(Ka.multiplyMatrices(Fu,a.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o,Qn.x,Qn.y,Qn.z),Ka.multiplyMatrices(Fu,a.parent.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o+1,Qn.x,Qn.y,Qn.z),o+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function D0(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,D0(n.children[e]));return t}var Jh=class extends go{constructor(t=10,e=10,i=4473924,r=8947848){i=new ft(i),r=new ft(r);let s=e/2,o=t/e,a=t/2,l=[],c=[];for(let f=0,d=0,g=-a;f<=e;f++,g+=o){l.push(-a,0,g,a,0,g),l.push(g,0,-a,g,0,a);let x=f===s?i:r;x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3}let u=new Ht;u.setAttribute("position",new ee(l,3)),u.setAttribute("color",new ee(c,3));let h=new zn({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}};var _T=new Float32Array(1),Ck=new Int32Array(_T.buffer);Fe.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(Fe.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n};_o.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)};Jh.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};Zh.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};mn.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),Dh.extractUrlBase(n)};mn.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};Yi.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)};Yi.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Yi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Yi.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)};Ge.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)};Ge.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Ge.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Ge.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};Ge.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)};si.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};qr.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)};Yh.prototype.center=function(n){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(n)};de.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};de.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};de.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};de.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};wt.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)};wt.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};wt.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new T().setFromMatrixColumn(this,3)};wt.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)};wt.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};wt.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};wt.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)};wt.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};wt.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};wt.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};wt.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};wt.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};wt.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};wt.prototype.makeFrustum=function(n,t,e,i,r,s){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,s)};wt.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};je.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)};Ee.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)};Ee.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};oi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};oi.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)};oi.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};re.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};re.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)};re.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)};re.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)};re.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)};re.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),re.getBarycoord(n,t,e,i,r)};re.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),re.getNormal(n,t,e,i)};Un.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)};Un.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new ci(this,n)};Un.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new qi(this,n)};K.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};K.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};K.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};T.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};T.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};T.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)};T.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)};T.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)};T.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)};T.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};T.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};T.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};Wt.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};Wt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};kt.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)};kt.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};kt.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)};kt.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};kt.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(kt.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});oe.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(oe.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),$w},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});dl.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Se.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(n)};Object.defineProperties(Ye.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}});Object.defineProperties(Qt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===nl},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(nl)}}});Qt.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Qt.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Qt.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Ht.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)};Ht.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Qt(arguments[1],arguments[2]))):n==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t)};Ht.prototype.addDrawCall=function(n,t,e){e!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)};Ht.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Ht.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Ht.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)};Ht.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(Ht.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});Gi.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Gi.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};ci.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};ci.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};ci.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};Yr.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};To.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(xe.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ft}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===c0}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(Fn.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}});Vt.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)};Vt.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)};Vt.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};Vt.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};Vt.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};Vt.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};Vt.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};Vt.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};Vt.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};Vt.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};Vt.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};Vt.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};Vt.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};Vt.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};Vt.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)};Vt.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};Vt.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};Vt.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};Vt.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};Vt.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};Vt.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};Vt.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};Vt.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};Vt.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};Vt.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(Vt.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=n===!0?$t:ri}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(T0.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});Object.defineProperties(Ne.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}});Bh.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new Fh().load(n,function(i){t.setBuffer(i)}),this};Oh.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};ao.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)};ao.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)};Nn.crossOrigin=void 0;Nn.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new Eh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new Sh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Nn.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:$h}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=$h);function rf(n,t,e){if(e===1)return new ft(t);let i=pi(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new ft(sc(i,n)(1-e))}var gn;(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"})(gn||(gn={}));function N0(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==e*3)&&(i=new Qt(new Float32Array(e*3),3),n.setAttribute("position",i));let r=i.array;for(let s=0;s<e;s++)r[s*3]=t[s*2],r[s*3+1]=t[s*2+1];i.needsUpdate=!0,n.setDrawRange(0,e*3),n.computeBoundingSphere()}function F0(n,t,e){let i=Math.max(t.length/2-1,0),r=i*2*3,s=r*3,o=n.attributes.position;(!o||o.count!==r)&&(o=new Qt(new Float32Array(s),3),n.setAttribute("position",o));let a=o.array;for(let l=0;l<i;l++){let[c,u,h,f]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],d=new K(c,u),g=new K(h,f),x=new K(h-c,f-u),v=new K(-x.y,x.x).setLength(e/2),m=d.clone().add(v),p=d.clone().sub(v),b=g.clone().add(v),_=g.clone().sub(v),S=[m.x,m.y,0,p.x,p.y,0,b.x,b.y,0,b.x,b.y,0,p.x,p.y,0,_.x,_.y,0];a.set(S,l*S.length)}o.needsUpdate=!0,n.setDrawRange(0,s),n.computeBoundingSphere()}function Il(n,t,e,i){let{visible:r,color:s,opacity:o}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=rf(n,s,o!=null?o:1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var wT={createScene:()=>new Yr},Ro=class{constructor(t,e,i,r){this.coordinator=e,this.scene=wT.createScene(),this.backgroundColor="#fff",Di.isWebGl2OffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new Vt({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof oe){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){var u;if(!t&&!i.visible)return null;let{visible:r,width:s}=i;if(!t){let h=rf(this.backgroundColor,i.color,(u=i.opacity)!=null?u:1),f=new Ht,d=new zn({color:h}),g=new oe(f,d);return d.visible=r,F0(f,e,s),this.scene.add(g),{type:gn.LINE,data:e,obj3d:g,width:s}}let{data:o,obj3d:a,width:l}=t;return Il(this.backgroundColor,a,h=>((s!==l||!o||!Di.arePolylinesEqual(o,e))&&F0(h,e,s),h),i)?{type:gn.LINE,data:e,obj3d:a,width:s}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:s}=e,o=rf(this.backgroundColor,r,s!=null?s:1),a=new ki({color:o,visible:i});return new oe(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,s=r*Math.sqrt(3)/2,o=new Float32Array([e.x-r/2,e.y-s/3,e.x+r/2,e.y-s/3,e.x,e.y+s*2/3]);if(!t){let l=new Ht;N0(l,o);let c=this.createMesh(l,i);return c===null?null:(this.scene.add(c),{type:gn.TRIANGLE,data:e,obj3d:c})}return Il(this.backgroundColor,t.obj3d,l=>(N0(l,o),l),i)?{type:gn.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,s=new Zr(i.radius);if(!t){let a=this.createMesh(s,i);return a===null?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return Il(this.backgroundColor,t.obj3d,()=>s,i)?(t.obj3d.position.set(e.x,e.y,0),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s}=r,o=2/Math.sqrt(3)*s,a=new Un([new K(e.x-o/2,e.y-s/2),new K(e.x,e.y+s/2),new K(i.x,i.y+s/2),new K(i.x+o/2,i.y-s/2)]);a.autoClose=!0;let l=new qi(a);if(!t){let u=this.createMesh(l,r);return u===null?null:(this.scene.add(u),{type:gn.TRAPEZOID,data:[e,i],obj3d:u})}return Il(this.backgroundColor,t.obj3d,()=>l,r)?{type:gn.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}};var Nl=class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let s=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);s&&this.renderCache.setToCurrentFrame(t,s)}};var sf=class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){let e=this.prevFrameCache.get(t);return e!=null?e:null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},Fl=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new sf,this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new Nl(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),!!this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(i.points.length*2)};for(let r=0;r<i.points.length;r++){let[s,o]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[r*2]=s,this.series[e].polyline[r*2+1]=o}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}};var Lo;(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"})(Lo||(Lo={}));var zl=class extends Fl{recordPartition(t,e,i){return t?{type:Lo.NUMBER,polyline:e}:{type:Lo.NAN,polyline:e.map((r,s)=>isNaN(r)?s%2===0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,s=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),o={x:s[0],y:s[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],u=t[l+1],h=isNaN(c)||isNaN(u);h!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),a===null?{x:c,y:u}:a)),i=l),h||(a={x:c,y:u}),r=h}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a!=null?a:o)),e}redraw(){var t,e,i;for(let r of this.series){let o=this.getMetadataMap()[r.id];if(!o)continue;if(r.polyline.length%2!==0)throw new Error(`Cannot have odd length-ed polyline: ${r.polyline.length}`);let a=this.partitionPolyline(r.polyline);for(let[l,{type:c,polyline:u}]of a.entries())if(c===Lo.NUMBER)u.length===2?this.paintBrush.setCircle(JSON.stringify(["circle",r.id,l]),{x:u[0],y:u[1]},{color:o.color,visible:o.visible,opacity:(t=o.opacity)!=null?t:1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",r.id,l]),u,{color:o.color,visible:o.visible,opacity:(e=o.opacity)!=null?e:1,width:2});else if(!o.aux)for(let h=0;h<u.length;h+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",r.id,u[h],u[h+1]]),{x:u[h],y:u[h+1]},{color:o.color,visible:o.visible,opacity:(i=o.opacity)!=null?i:1,size:12})}}};var Ul=class extends dr{constructor(){super(...arguments),this.camera=new Vi(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}};var MT={requestAnimationFrame:n=>self.requestAnimationFrame(n)},Bl=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Tn.SVG:{this.coordinator=new dr,this.renderer=new Os(t.container);break}case Tn.WEBGL:{let e=new Ul;this.coordinator=e,this.renderer=new Ro(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new zl({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(fr(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(fr(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect(No({x:0,y:0},t)),this.renderer.onResize(No({x:0,y:0},t)),this.seriesLineView.setLayoutRect(uf(No({},t),{x:0,y:0})),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let s=this.metadataMap[i];(!s||r.color!==s.color||r.visible!==s.visible||r.opacity!==s.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,MT.requestAnimationFrame(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}};function z0(n){let{flattenedSeries:t,idsAndLengths:e}=n,i=new Float64Array(t),r=[];if(i.length%2!==0)throw new Error("`flattenedSeries` must have even number of elements");let s=0;for(let{id:o,length:a}of e){let l=[];for(let c=0;c<a;c++)l.push({x:i[s++],y:i[s++]});r.push({id:o,points:l})}return r}var xn;(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"})(xn||(xn={}));var Po;(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"})(Po||(Po={}));self.addEventListener("message",n=>{bT(n.ports[0],n.data)});function bT(n,t){let{canvas:e,devicePixelRatio:i,dim:r,rendererType:s,useDarkMode:o}=t,a={onDrawEnd:()=>{n.postMessage({type:Po.ON_REDRAW_END})},onContextLost:()=>{n.postMessage({type:Po.ON_CONTEXT_LOST})}},l;switch(s){case Tn.WEBGL:l={type:Tn.WEBGL,domDimension:r,callbacks:a,container:e,devicePixelRatio:i,useDarkMode:o};break;default:throw new RangeError(`Invariant error: cannot have Offscreen chart for renderer type: ${s}`)}let c=new Bl(l);n.onmessage=function(u){let h=u.data;switch(h.type){case xn.SERIES_DATA_UPDATED:{let f=z0(h.compactDataSeries);c.setData(f);break}case xn.SERIES_METADATA_CHANGED:{c.setMetadata(h.metadata);break}case xn.VIEW_BOX_UPDATED:{c.setViewBox(h.extent);break}case xn.DOM_RESIZED:{c.resize(h.dim);break}case xn.DARK_MODE_UPDATED:{c.setUseDarkMode(h.useDarkMode);break}case xn.SCALE_UPDATED:{switch(h.axis){case"x":c.setXScaleType(h.scaleType);break;case"y":c.setYScaleType(h.scaleType);break;default:let f=h.axis;throw new RangeError(`Unknown axis: ${f}`)}break}case xn.DISPOSED:{c.dispose();break}}}}})();
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
//# sourceMappingURL=chart_worker.js.map
", + "ok": true, + "headers": [ + [ + "content-length", + "186402" + ], + [ + "content-type", + "text/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_aux_1%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_aux_1", "runToSeries": {".": [{"wallTime": 1733067631.5378466, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6512275, "step": 10, "value": 2.080976724624634}, {"wallTime": 1733067660.783306, "step": 20, "value": 1.8964003324508667}, {"wallTime": 1733067674.1365235, "step": 30, "value": 1.8116103410720825}, {"wallTime": 1733067687.0562296, "step": 40, "value": 2.047821044921875}, {"wallTime": 1733067699.4921236, "step": 50, "value": 1.3211959600448608}, {"wallTime": 1733067710.6283953, "step": 60, "value": 1.6567492485046387}, {"wallTime": 1733067722.7545972, "step": 70, "value": 1.4295318126678467}, {"wallTime": 1733067733.7244475, "step": 80, "value": 0.9548348784446716}, {"wallTime": 1733067750.9453568, "step": 90, "value": 1.2374598979949951}, {"wallTime": 1733067761.9799345, "step": 100, "value": 1.0870133638381958}, {"wallTime": 1733067771.6055033, "step": 110, "value": 0.7231400012969971}, {"wallTime": 1733067780.5464525, "step": 120, "value": 0.6172369718551636}, {"wallTime": 1733067790.4844027, "step": 130, "value": 0.8158695101737976}, {"wallTime": 1733067799.1047332, "step": 140, "value": 0.442331999540329}, {"wallTime": 1733067809.4437165, "step": 150, "value": 0.6400600075721741}, {"wallTime": 1733067818.9198103, "step": 160, "value": 0.6037955284118652}, {"wallTime": 1733067836.6485956, "step": 170, "value": 0.4336378574371338}, {"wallTime": 1733067846.3897676, "step": 180, "value": 0.6668165326118469}, {"wallTime": 1733067855.6658711, "step": 190, "value": 0.43272602558135986}, {"wallTime": 1733067864.8882604, "step": 200, "value": 0.7847833633422852}, {"wallTime": 1733067874.0008094, "step": 210, "value": 0.6011791229248047}, {"wallTime": 1733067883.7845647, "step": 220, "value": 0.4155164361000061}, {"wallTime": 1733067892.122186, "step": 230, "value": 0.5058233737945557}, {"wallTime": 1733067901.0684838, "step": 240, "value": 0.5006446838378906}, {"wallTime": 1733067910.0739765, "step": 250, "value": 0.4687657356262207}, {"wallTime": 1733067925.9491198, "step": 260, "value": 0.7785656452178955}, {"wallTime": 1733067935.474581, "step": 270, "value": 0.43378472328186035}, {"wallTime": 1733067944.0139685, "step": 280, "value": 0.477083683013916}, {"wallTime": 1733067952.545044, "step": 290, "value": 0.4721766412258148}, {"wallTime": 1733067961.0258148, "step": 300, "value": 0.3279098868370056}, {"wallTime": 1733067970.1335042, "step": 310, "value": 0.5380382537841797}, {"wallTime": 1733067980.2248383, "step": 320, "value": 0.4463362991809845}, {"wallTime": 1733067988.8151646, "step": 330, "value": 0.5395556688308716}, {"wallTime": 1733068005.0897305, "step": 340, "value": 0.4131142497062683}, {"wallTime": 1733068014.0642214, "step": 350, "value": 0.40386202931404114}, {"wallTime": 1733068022.552108, "step": 360, "value": 0.46442911028862}, {"wallTime": 1733068031.8238254, "step": 370, "value": 0.5013605952262878}, {"wallTime": 1733068040.78696, "step": 380, "value": 0.3609294295310974}, {"wallTime": 1733068050.1593575, "step": 390, "value": 0.3937673270702362}, {"wallTime": 1733068059.1252198, "step": 400, "value": 0.30136269330978394}, {"wallTime": 1733068068.0892677, "step": 410, "value": 0.6681710481643677}, {"wallTime": 1733068084.8431416, "step": 420, "value": 0.3862704336643219}, {"wallTime": 1733068094.665791, "step": 430, "value": 0.5082329511642456}, {"wallTime": 1733068103.7072737, "step": 440, "value": 0.3468035161495209}, {"wallTime": 1733068112.698942, "step": 450, "value": 0.4367893636226654}, {"wallTime": 1733068121.5003002, "step": 460, "value": 0.5340542197227478}, {"wallTime": 1733068130.7270987, "step": 470, "value": 0.4053562581539154}, {"wallTime": 1733068139.8550663, "step": 480, "value": 0.4038271903991699}, {"wallTime": 1733068149.3694503, "step": 490, "value": 0.5325490832328796}, {"wallTime": 1733068158.0694582, "step": 500, "value": 0.5200487971305847}, {"wallTime": 1733068174.1145499, "step": 510, "value": 0.4801502227783203}, {"wallTime": 1733068182.7190423, "step": 520, "value": 0.3777560889720917}, {"wallTime": 1733068192.4130661, "step": 530, "value": 0.401431679725647}, {"wallTime": 1733068201.807577, "step": 540, "value": 0.3941304683685303}, {"wallTime": 1733068210.6540112, "step": 550, "value": 0.5960095524787903}, {"wallTime": 1733068220.1945596, "step": 560, "value": 0.7254388332366943}, {"wallTime": 1733068229.158801, "step": 570, "value": 0.32111796736717224}, {"wallTime": 1733068238.5910587, "step": 580, "value": 0.29398828744888306}, {"wallTime": 1733068256.0725582, "step": 590, "value": 0.42135879397392273}, {"wallTime": 1733068265.4313498, "step": 600, "value": 0.5037056803703308}, {"wallTime": 1733068274.6560428, "step": 610, "value": 0.6606979370117188}, {"wallTime": 1733068283.769519, "step": 620, "value": 0.5929248929023743}, {"wallTime": 1733068293.3336768, "step": 630, "value": 0.45988208055496216}, {"wallTime": 1733068302.6466882, "step": 640, "value": 0.3857255280017853}, {"wallTime": 1733068311.3876684, "step": 650, "value": 0.34370020031929016}, {"wallTime": 1733068320.3896565, "step": 660, "value": 0.4529060423374176}, {"wallTime": 1733068328.7307959, "step": 670, "value": 0.367893248796463}, {"wallTime": 1733068344.4607089, "step": 680, "value": 0.3987342119216919}, {"wallTime": 1733068353.7164898, "step": 690, "value": 0.3556267023086548}, {"wallTime": 1733068362.057482, "step": 700, "value": 0.3349885046482086}, {"wallTime": 1733068371.103598, "step": 710, "value": 0.5314299464225769}, {"wallTime": 1733068380.53272, "step": 720, "value": 0.4164872169494629}, {"wallTime": 1733068390.0862908, "step": 730, "value": 0.3127610385417938}, {"wallTime": 1733068398.720583, "step": 740, "value": 0.46927207708358765}, {"wallTime": 1733068407.1235816, "step": 750, "value": 0.40930336713790894}, {"wallTime": 1733068423.0699527, "step": 760, "value": 0.40901392698287964}, {"wallTime": 1733068431.4049299, "step": 770, "value": 0.33240291476249695}, {"wallTime": 1733068440.4245415, "step": 780, "value": 0.35394740104675293}, {"wallTime": 1733068449.006043, "step": 790, "value": 0.3749704658985138}, {"wallTime": 1733068457.6367202, "step": 800, "value": 0.39805081486701965}, {"wallTime": 1733068467.0468833, "step": 810, "value": 0.3780577778816223}, {"wallTime": 1733068475.6201005, "step": 820, "value": 0.3736826181411743}, {"wallTime": 1733068484.97856, "step": 830, "value": 0.37384507060050964}, {"wallTime": 1733068500.7312894, "step": 840, "value": 0.3993445038795471}, {"wallTime": 1733068509.3075497, "step": 850, "value": 0.41809725761413574}, {"wallTime": 1733068519.0219505, "step": 860, "value": 0.4150007367134094}, {"wallTime": 1733068527.4983504, "step": 870, "value": 0.33232343196868896}, {"wallTime": 1733068536.9200804, "step": 880, "value": 0.48728954792022705}, {"wallTime": 1733068544.9086175, "step": 890, "value": 0.35842299461364746}, {"wallTime": 1733068553.5788589, "step": 900, "value": 0.3739010691642761}, {"wallTime": 1733068562.6858945, "step": 910, "value": 0.4169975519180298}, {"wallTime": 1733068571.246266, "step": 920, "value": 0.33788520097732544}, {"wallTime": 1733068584.7762473, "step": 930, "value": 0.3874629735946655}, {"wallTime": 1733068593.7725313, "step": 940, "value": 0.3711284399032593}, {"wallTime": 1733068602.7667413, "step": 950, "value": 0.45453697443008423}, {"wallTime": 1733068611.04079, "step": 960, "value": 0.2832002639770508}, {"wallTime": 1733068620.227618, "step": 970, "value": 0.33425745368003845}, {"wallTime": 1733068628.8426096, "step": 980, "value": 0.40504300594329834}, {"wallTime": 1733068637.6315026, "step": 990, "value": 0.3347744047641754}, {"wallTime": 1733068646.6741366, "step": 1000, "value": 0.3927091360092163}, {"wallTime": 1733068662.7579024, "step": 1010, "value": 0.2526029646396637}, {"wallTime": 1733068672.055618, "step": 1020, "value": 0.3010721206665039}, {"wallTime": 1733068680.564281, "step": 1030, "value": 0.32597747445106506}, {"wallTime": 1733068690.1871505, "step": 1040, "value": 0.3588096797466278}, {"wallTime": 1733068698.849292, "step": 1050, "value": 0.3400232195854187}, {"wallTime": 1733068707.7447057, "step": 1060, "value": 0.7653819918632507}, {"wallTime": 1733068717.3459241, "step": 1070, "value": 0.3427758514881134}, {"wallTime": 1733068726.362669, "step": 1080, "value": 0.41634246706962585}, {"wallTime": 1733068735.2531126, "step": 1090, "value": 0.44848573207855225}, {"wallTime": 1733068749.5492473, "step": 1100, "value": 0.3570024371147156}, {"wallTime": 1733068758.376697, "step": 1110, "value": 0.44701510667800903}, {"wallTime": 1733068767.005142, "step": 1120, "value": 0.525740385055542}, {"wallTime": 1733068776.6201484, "step": 1130, "value": 0.4598484933376312}, {"wallTime": 1733068785.4024293, "step": 1140, "value": 0.24359382688999176}, {"wallTime": 1733068794.2803257, "step": 1150, "value": 0.40571776032447815}, {"wallTime": 1733068802.698637, "step": 1160, "value": 0.27868208289146423}, {"wallTime": 1733068811.552831, "step": 1170, "value": 0.3879587650299072}, {"wallTime": 1733068824.9670534, "step": 1180, "value": 0.22663623094558716}, {"wallTime": 1733068834.378492, "step": 1190, "value": 0.3696737289428711}, {"wallTime": 1733068843.5174572, "step": 1200, "value": 0.45166295766830444}, {"wallTime": 1733068852.2297804, "step": 1210, "value": 0.3473774790763855}, {"wallTime": 1733068861.118252, "step": 1220, "value": 0.36218494176864624}, {"wallTime": 1733068870.0571957, "step": 1230, "value": 0.6309255361557007}, {"wallTime": 1733068878.721716, "step": 1240, "value": 0.42355048656463623}, {"wallTime": 1733068887.7394161, "step": 1250, "value": 0.3391069173812866}, {"wallTime": 1733068903.168068, "step": 1260, "value": 0.4829920828342438}, {"wallTime": 1733068912.4157147, "step": 1270, "value": 0.2756490111351013}, {"wallTime": 1733068921.474232, "step": 1280, "value": 0.3459252119064331}, {"wallTime": 1733068929.747986, "step": 1290, "value": 0.3815467953681946}, {"wallTime": 1733068939.502665, "step": 1300, "value": 0.3364849388599396}, {"wallTime": 1733068948.928902, "step": 1310, "value": 0.3951975107192993}, {"wallTime": 1733068957.2357445, "step": 1320, "value": 0.48332679271698}, {"wallTime": 1733068966.0783477, "step": 1330, "value": 0.2840600609779358}, {"wallTime": 1733068975.5664773, "step": 1340, "value": 0.5292253494262695}, {"wallTime": 1733068989.799235, "step": 1350, "value": 0.3866269886493683}, {"wallTime": 1733068998.2827919, "step": 1360, "value": 0.29202884435653687}, {"wallTime": 1733069007.1495588, "step": 1370, "value": 0.3543506860733032}, {"wallTime": 1733069015.9223404, "step": 1380, "value": 0.20260292291641235}, {"wallTime": 1733069025.3045287, "step": 1390, "value": 0.3657674193382263}, {"wallTime": 1733069034.4827235, "step": 1400, "value": 0.270691454410553}, {"wallTime": 1733069042.7942598, "step": 1410, "value": 0.42889583110809326}, {"wallTime": 1733069052.1387808, "step": 1420, "value": 0.259716659784317}, {"wallTime": 1733069065.0028474, "step": 1430, "value": 0.3013904094696045}, {"wallTime": 1733069074.5251722, "step": 1440, "value": 0.3210000991821289}, {"wallTime": 1733069083.7837746, "step": 1450, "value": 0.3831854462623596}, {"wallTime": 1733069092.2592142, "step": 1460, "value": 0.29653480648994446}, {"wallTime": 1733069101.0307643, "step": 1470, "value": 0.3454670310020447}, {"wallTime": 1733069109.9065716, "step": 1480, "value": 0.30316781997680664}, {"wallTime": 1733069119.1189976, "step": 1490, "value": 0.23392938077449799}, {"wallTime": 1733069128.4162643, "step": 1500, "value": 0.3235774040222168}, {"wallTime": 1733069137.606904, "step": 1510, "value": 0.45808497071266174}, {"wallTime": 1733069150.5435743, "step": 1520, "value": 0.39481300115585327}, {"wallTime": 1733069159.757147, "step": 1530, "value": 0.4400634467601776}, {"wallTime": 1733069168.1703744, "step": 1540, "value": 0.20444270968437195}, {"wallTime": 1733069176.8410532, "step": 1550, "value": 0.43372777104377747}, {"wallTime": 1733069185.8923652, "step": 1560, "value": 0.23362667858600616}, {"wallTime": 1733069194.9240668, "step": 1570, "value": 0.3793354034423828}, {"wallTime": 1733069203.9125273, "step": 1580, "value": 0.31334948539733887}, {"wallTime": 1733069212.7156715, "step": 1590, "value": 0.2628381848335266}, {"wallTime": 1733069225.533953, "step": 1600, "value": 0.28933343291282654}, {"wallTime": 1733069235.4639533, "step": 1610, "value": 0.4422391653060913}, {"wallTime": 1733069244.6297064, "step": 1620, "value": 0.49685221910476685}, {"wallTime": 1733069254.271715, "step": 1630, "value": 0.3368658423423767}, {"wallTime": 1733069263.005383, "step": 1640, "value": 0.2599034309387207}, {"wallTime": 1733069271.8667848, "step": 1650, "value": 0.43894830346107483}, {"wallTime": 1733069280.5099876, "step": 1660, "value": 0.276809960603714}, {"wallTime": 1733069289.6798136, "step": 1670, "value": 0.3775954246520996}, {"wallTime": 1733069303.6093264, "step": 1680, "value": 0.4882148206233978}, {"wallTime": 1733069312.4796734, "step": 1690, "value": 0.38776856660842896}, {"wallTime": 1733069321.8386333, "step": 1700, "value": 0.46446114778518677}, {"wallTime": 1733069330.3480783, "step": 1710, "value": 0.2974974811077118}, {"wallTime": 1733069339.245227, "step": 1720, "value": 0.2341056764125824}, {"wallTime": 1733069346.857213, "step": 1730, "value": 0.24610750377178192}, {"wallTime": 1733069355.6530004, "step": 1740, "value": 0.4578742980957031}, {"wallTime": 1733069364.5120964, "step": 1750, "value": 0.35827574133872986}, {"wallTime": 1733069373.738694, "step": 1760, "value": 0.32077041268348694}, {"wallTime": 1733069387.5411227, "step": 1770, "value": 0.3086099326610565}, {"wallTime": 1733069396.4671345, "step": 1780, "value": 0.26404044032096863}, {"wallTime": 1733069405.9963608, "step": 1790, "value": 0.20359249413013458}, {"wallTime": 1733069415.0538473, "step": 1800, "value": 0.25205302238464355}, {"wallTime": 1733069423.907558, "step": 1810, "value": 0.21067814528942108}, {"wallTime": 1733069432.5311852, "step": 1820, "value": 0.41559088230133057}, {"wallTime": 1733069441.2174335, "step": 1830, "value": 0.3363778591156006}, {"wallTime": 1733069450.0873775, "step": 1840, "value": 0.24107423424720764}, {"wallTime": 1733069463.106729, "step": 1850, "value": 0.2355038970708847}, {"wallTime": 1733069471.5726805, "step": 1860, "value": 0.26205888390541077}, {"wallTime": 1733069480.4979212, "step": 1870, "value": 0.519013524055481}, {"wallTime": 1733069489.3845494, "step": 1880, "value": 0.4240681231021881}, {"wallTime": 1733069497.9763844, "step": 1890, "value": 0.4214614927768707}, {"wallTime": 1733069506.7939382, "step": 1900, "value": 0.320597767829895}, {"wallTime": 1733069515.8242981, "step": 1910, "value": 0.2432914674282074}, {"wallTime": 1733069524.636154, "step": 1920, "value": 0.289411723613739}, {"wallTime": 1733069533.5417464, "step": 1930, "value": 0.2208029329776764}, {"wallTime": 1733069550.4775662, "step": 1940, "value": 0.3727818727493286}, {"wallTime": 1733069558.82756, "step": 1950, "value": 0.2627505660057068}, {"wallTime": 1733069567.757492, "step": 1960, "value": 0.26128852367401123}, {"wallTime": 1733069576.3447895, "step": 1970, "value": 0.2633413076400757}, {"wallTime": 1733069585.528824, "step": 1980, "value": 0.4030425548553467}, {"wallTime": 1733069594.3498313, "step": 1990, "value": 0.3862055540084839}, {"wallTime": 1733069602.4012318, "step": 2000, "value": 0.5727883577346802}, {"wallTime": 1733069610.2495577, "step": 2010, "value": 0.47217875719070435}, {"wallTime": 1733069626.6864018, "step": 2020, "value": 0.4083960950374603}, {"wallTime": 1733069635.0305018, "step": 2030, "value": 0.27016681432724}, {"wallTime": 1733069643.8221302, "step": 2040, "value": 0.2542892098426819}, {"wallTime": 1733069652.194053, "step": 2050, "value": 0.2995786666870117}, {"wallTime": 1733069660.453023, "step": 2060, "value": 0.4253631830215454}, {"wallTime": 1733069669.5916307, "step": 2070, "value": 0.3370038866996765}, {"wallTime": 1733069678.7779512, "step": 2080, "value": 0.5279788374900818}, {"wallTime": 1733069686.9443614, "step": 2090, "value": 0.40229275822639465}, {"wallTime": 1733069700.6015792, "step": 2100, "value": 0.32630419731140137}, {"wallTime": 1733069708.7259092, "step": 2110, "value": 0.2403770387172699}, {"wallTime": 1733069717.4478364, "step": 2120, "value": 0.2993067800998688}, {"wallTime": 1733069726.1407611, "step": 2130, "value": 0.30852949619293213}, {"wallTime": 1733069735.0376563, "step": 2140, "value": 0.33643507957458496}, {"wallTime": 1733069743.3056233, "step": 2150, "value": 0.2781292200088501}, {"wallTime": 1733069752.5003786, "step": 2160, "value": 0.32609033584594727}, {"wallTime": 1733069761.4505153, "step": 2170, "value": 0.31904369592666626}, {"wallTime": 1733069770.4327283, "step": 2180, "value": 0.39633604884147644}, {"wallTime": 1733069784.3630166, "step": 2190, "value": 0.3670208156108856}, {"wallTime": 1733069793.122013, "step": 2200, "value": 0.17466026544570923}, {"wallTime": 1733069801.6356375, "step": 2210, "value": 0.29097405076026917}, {"wallTime": 1733069810.607359, "step": 2220, "value": 0.42045003175735474}, {"wallTime": 1733069819.3414211, "step": 2230, "value": 0.2610870599746704}, {"wallTime": 1733069827.3256001, "step": 2240, "value": 0.39071810245513916}, {"wallTime": 1733069835.8673234, "step": 2250, "value": 0.28117796778678894}, {"wallTime": 1733069844.2353375, "step": 2260, "value": 0.32075047492980957}, {"wallTime": 1733069856.748606, "step": 2270, "value": 0.26204800605773926}, {"wallTime": 1733069865.2570662, "step": 2280, "value": 0.215452641248703}, {"wallTime": 1733069874.0047016, "step": 2290, "value": 0.1962721347808838}, {"wallTime": 1733069881.7810738, "step": 2300, "value": 0.3731687068939209}, {"wallTime": 1733069890.4132009, "step": 2310, "value": 0.25476372241973877}, {"wallTime": 1733069898.876013, "step": 2320, "value": 0.27482742071151733}, {"wallTime": 1733069908.317099, "step": 2330, "value": 0.2694145143032074}, {"wallTime": 1733069917.4145136, "step": 2340, "value": 0.3677527606487274}, {"wallTime": 1733069925.8498428, "step": 2350, "value": 0.22904875874519348}, {"wallTime": 1733069938.7016742, "step": 2360, "value": 0.34355953335762024}, {"wallTime": 1733069947.4254785, "step": 2370, "value": 0.37508243322372437}, {"wallTime": 1733069956.2056017, "step": 2380, "value": 0.4032178223133087}, {"wallTime": 1733069964.2740567, "step": 2390, "value": 0.2966662347316742}, {"wallTime": 1733069973.3253963, "step": 2400, "value": 0.22960887849330902}, {"wallTime": 1733069981.4314406, "step": 2410, "value": 0.2575603425502777}, {"wallTime": 1733069990.1389682, "step": 2420, "value": 0.28388386964797974}, {"wallTime": 1733069998.7971861, "step": 2430, "value": 0.30790799856185913}, {"wallTime": 1733070012.455048, "step": 2440, "value": 0.27626073360443115}, {"wallTime": 1733070021.5982392, "step": 2450, "value": 0.248032808303833}, {"wallTime": 1733070030.1902592, "step": 2460, "value": 0.2608065903186798}, {"wallTime": 1733070039.2185714, "step": 2470, "value": 0.28537851572036743}, {"wallTime": 1733070048.2681959, "step": 2480, "value": 0.36083993315696716}, {"wallTime": 1733070056.1549995, "step": 2490, "value": 0.38966360688209534}, {"wallTime": 1733070064.4498801, "step": 2500, "value": 0.3546096086502075}, {"wallTime": 1733070072.5492918, "step": 2510, "value": 0.2481178641319275}, {"wallTime": 1733070087.6561341, "step": 2520, "value": 0.29143568873405457}, {"wallTime": 1733070095.4409528, "step": 2530, "value": 0.2675405442714691}, {"wallTime": 1733070103.7681155, "step": 2540, "value": 0.24306996166706085}, {"wallTime": 1733070113.04839, "step": 2550, "value": 0.23983830213546753}, {"wallTime": 1733070121.0370786, "step": 2560, "value": 0.24525612592697144}, {"wallTime": 1733070129.5835578, "step": 2570, "value": 0.30126166343688965}, {"wallTime": 1733070138.3599408, "step": 2580, "value": 0.26473501324653625}, {"wallTime": 1733070147.086511, "step": 2590, "value": 0.3455694913864136}, {"wallTime": 1733070155.4862287, "step": 2600, "value": 0.4398328363895416}, {"wallTime": 1733070172.5765123, "step": 2610, "value": 0.3086743950843811}, {"wallTime": 1733070181.2104669, "step": 2620, "value": 0.3314612805843353}, {"wallTime": 1733070189.6915975, "step": 2630, "value": 0.2776240110397339}, {"wallTime": 1733070198.3983474, "step": 2640, "value": 0.2693990468978882}, {"wallTime": 1733070206.706601, "step": 2650, "value": 0.21547377109527588}, {"wallTime": 1733070215.5989497, "step": 2660, "value": 0.3346098065376282}, {"wallTime": 1733070224.314766, "step": 2670, "value": 0.3320493996143341}, {"wallTime": 1733070233.5385878, "step": 2680, "value": 0.28059759736061096}, {"wallTime": 1733070246.7573593, "step": 2690, "value": 0.25913166999816895}, {"wallTime": 1733070256.0280638, "step": 2700, "value": 0.3967699408531189}, {"wallTime": 1733070264.9500308, "step": 2710, "value": 0.256232887506485}, {"wallTime": 1733070273.8039627, "step": 2720, "value": 0.34074532985687256}, {"wallTime": 1733070282.9583104, "step": 2730, "value": 0.30183348059654236}, {"wallTime": 1733070292.2771578, "step": 2740, "value": 0.28900229930877686}, {"wallTime": 1733070300.3360133, "step": 2750, "value": 0.2777726650238037}, {"wallTime": 1733070309.411394, "step": 2760, "value": 0.42933765053749084}, {"wallTime": 1733070317.5307348, "step": 2770, "value": 0.4037612974643707}, {"wallTime": 1733070330.4353974, "step": 2780, "value": 0.32816144824028015}, {"wallTime": 1733070339.8220406, "step": 2790, "value": 0.26291850209236145}, {"wallTime": 1733070347.9924176, "step": 2800, "value": 0.2032822072505951}, {"wallTime": 1733070356.8911936, "step": 2810, "value": 0.29574355483055115}, {"wallTime": 1733070365.5761359, "step": 2820, "value": 0.26852789521217346}, {"wallTime": 1733070374.3923376, "step": 2830, "value": 0.270966112613678}, {"wallTime": 1733070382.4262707, "step": 2840, "value": 0.3431394696235657}, {"wallTime": 1733070390.9406104, "step": 2850, "value": 0.23812764883041382}, {"wallTime": 1733070406.6780043, "step": 2860, "value": 0.2522517144680023}, {"wallTime": 1733070415.0889657, "step": 2870, "value": 0.24398298561573029}, {"wallTime": 1733070422.9192812, "step": 2880, "value": 0.23108454048633575}, {"wallTime": 1733070431.5366242, "step": 2890, "value": 0.25729456543922424}, {"wallTime": 1733070439.9801586, "step": 2900, "value": 0.3282697796821594}, {"wallTime": 1733070448.0848315, "step": 2910, "value": 0.4142950475215912}, {"wallTime": 1733070457.4230306, "step": 2920, "value": 0.4424773156642914}, {"wallTime": 1733070466.7221274, "step": 2930, "value": 0.37827056646347046}, {"wallTime": 1733070479.3318233, "step": 2940, "value": 0.30757394433021545}, {"wallTime": 1733070488.7814972, "step": 2950, "value": 0.2893810570240021}, {"wallTime": 1733070497.2241516, "step": 2960, "value": 0.3688663840293884}, {"wallTime": 1733070505.633111, "step": 2970, "value": 0.239096000790596}, {"wallTime": 1733070513.3531847, "step": 2980, "value": 0.20375850796699524}, {"wallTime": 1733070522.3004143, "step": 2990, "value": 0.3636297285556793}, {"wallTime": 1733070530.2119687, "step": 3000, "value": 0.20278246700763702}, {"wallTime": 1733070538.2992842, "step": 3010, "value": 0.303661584854126}, {"wallTime": 1733070547.3995352, "step": 3020, "value": 0.2496832311153412}, {"wallTime": 1733070564.0500383, "step": 3030, "value": 0.23743516206741333}, {"wallTime": 1733070572.3689678, "step": 3040, "value": 0.23715999722480774}, {"wallTime": 1733070580.670116, "step": 3050, "value": 0.27497828006744385}, {"wallTime": 1733070588.6524458, "step": 3060, "value": 0.2742341458797455}, {"wallTime": 1733070597.4199271, "step": 3070, "value": 0.2392960488796234}, {"wallTime": 1733070606.136409, "step": 3080, "value": 0.37229228019714355}, {"wallTime": 1733070614.4386723, "step": 3090, "value": 0.3396451473236084}, {"wallTime": 1733070623.9990628, "step": 3100, "value": 0.2842906713485718}, {"wallTime": 1733070637.251242, "step": 3110, "value": 0.3433266580104828}, {"wallTime": 1733070645.681181, "step": 3120, "value": 0.2962092459201813}, {"wallTime": 1733070654.2688234, "step": 3130, "value": 0.24199539422988892}, {"wallTime": 1733070663.319557, "step": 3140, "value": 0.2515237033367157}, {"wallTime": 1733070671.1163535, "step": 3150, "value": 0.34050285816192627}, {"wallTime": 1733070679.7638652, "step": 3160, "value": 0.37218207120895386}, {"wallTime": 1733070687.8434463, "step": 3170, "value": 0.2547055780887604}, {"wallTime": 1733070695.854127, "step": 3180, "value": 0.32318559288978577}, {"wallTime": 1733070704.6207418, "step": 3190, "value": 0.25426021218299866}, {"wallTime": 1733070717.10715, "step": 3200, "value": 0.19944489002227783}, {"wallTime": 1733070726.0969648, "step": 3210, "value": 0.29525017738342285}, {"wallTime": 1733070734.7750156, "step": 3220, "value": 0.19062131643295288}, {"wallTime": 1733070744.410625, "step": 3230, "value": 0.2803632915019989}, {"wallTime": 1733070752.4999154, "step": 3240, "value": 0.4402446448802948}, {"wallTime": 1733070761.719415, "step": 3250, "value": 0.39126184582710266}, {"wallTime": 1733070770.3748672, "step": 3260, "value": 0.27076828479766846}, {"wallTime": 1733070779.728351, "step": 3270, "value": 0.2579626739025116}, {"wallTime": 1733070793.6767528, "step": 3280, "value": 0.24003532528877258}, {"wallTime": 1733070801.8983335, "step": 3290, "value": 0.38795384764671326}, {"wallTime": 1733070810.1593611, "step": 3300, "value": 0.34587058424949646}, {"wallTime": 1733070818.7248003, "step": 3310, "value": 0.18350136280059814}, {"wallTime": 1733070827.0051622, "step": 3320, "value": 0.22869491577148438}, {"wallTime": 1733070835.57262, "step": 3330, "value": 0.27296656370162964}, {"wallTime": 1733070843.9727254, "step": 3340, "value": 0.40508177876472473}, {"wallTime": 1733070853.0899255, "step": 3350, "value": 0.3200839161872864}, {"wallTime": 1733070865.4178083, "step": 3360, "value": 0.2114744782447815}, {"wallTime": 1733070873.6600032, "step": 3370, "value": 0.2597540616989136}, {"wallTime": 1733070883.3343441, "step": 3380, "value": 0.23922070860862732}, {"wallTime": 1733070892.3753607, "step": 3390, "value": 0.27218490839004517}, {"wallTime": 1733070900.7207236, "step": 3400, "value": 0.3166329860687256}, {"wallTime": 1733070908.502513, "step": 3410, "value": 0.2796928286552429}, {"wallTime": 1733070916.6541486, "step": 3420, "value": 0.37376630306243896}, {"wallTime": 1733070925.2071068, "step": 3430, "value": 0.25797438621520996}, {"wallTime": 1733070933.808619, "step": 3440, "value": 0.2140268087387085}, {"wallTime": 1733070947.4781191, "step": 3450, "value": 0.24050816893577576}, {"wallTime": 1733070956.1855826, "step": 3460, "value": 0.24761909246444702}, {"wallTime": 1733070964.2646601, "step": 3470, "value": 0.26265859603881836}, {"wallTime": 1733070972.3844373, "step": 3480, "value": 0.2709575295448303}, {"wallTime": 1733070980.6454685, "step": 3490, "value": 0.46079543232917786}, {"wallTime": 1733070989.6860943, "step": 3500, "value": 0.24387380480766296}, {"wallTime": 1733070997.7868898, "step": 3510, "value": 0.235269233584404}, {"wallTime": 1733071006.2697666, "step": 3520, "value": 0.3228941857814789}, {"wallTime": 1733071018.8944118, "step": 3530, "value": 0.2421220988035202}, {"wallTime": 1733071027.195507, "step": 3540, "value": 0.175516277551651}, {"wallTime": 1733071035.3189335, "step": 3550, "value": 0.2623077630996704}, {"wallTime": 1733071043.7441413, "step": 3560, "value": 0.22546371817588806}, {"wallTime": 1733071051.870543, "step": 3570, "value": 0.2936047911643982}, {"wallTime": 1733071060.4945204, "step": 3580, "value": 0.2494332492351532}, {"wallTime": 1733071068.8778646, "step": 3590, "value": 0.2564501464366913}, {"wallTime": 1733071077.7114034, "step": 3600, "value": 0.28038325905799866}, {"wallTime": 1733071086.2108495, "step": 3610, "value": 0.2168699949979782}, {"wallTime": 1733071101.657147, "step": 3620, "value": 0.2399357408285141}, {"wallTime": 1733071109.6188369, "step": 3630, "value": 0.28263676166534424}, {"wallTime": 1733071118.1277437, "step": 3640, "value": 0.25586047768592834}, {"wallTime": 1733071126.9916315, "step": 3650, "value": 0.21345436573028564}, {"wallTime": 1733071135.8259385, "step": 3660, "value": 0.3147739768028259}, {"wallTime": 1733071144.2467248, "step": 3670, "value": 0.2232719361782074}, {"wallTime": 1733071152.962993, "step": 3680, "value": 0.24191135168075562}, {"wallTime": 1733071160.6019413, "step": 3690, "value": 0.2568429708480835}, {"wallTime": 1733071173.7488089, "step": 3700, "value": 0.26184868812561035}, {"wallTime": 1733071182.8817675, "step": 3710, "value": 0.26742085814476013}, {"wallTime": 1733071191.20857, "step": 3720, "value": 0.31256431341171265}, {"wallTime": 1733071200.3319821, "step": 3730, "value": 0.5744590163230896}, {"wallTime": 1733071208.3642287, "step": 3740, "value": 0.2804695963859558}, {"wallTime": 1733071216.5704322, "step": 3750, "value": 0.20242580771446228}, {"wallTime": 1733071224.6604238, "step": 3760, "value": 0.17038600146770477}, {"wallTime": 1733071232.859216, "step": 3770, "value": 0.16409353911876678}, {"wallTime": 1733071248.5319376, "step": 3780, "value": 0.3577814996242523}, {"wallTime": 1733071257.3903117, "step": 3790, "value": 0.42577657103538513}, {"wallTime": 1733071265.5659015, "step": 3800, "value": 0.1938171535730362}, {"wallTime": 1733071274.177286, "step": 3810, "value": 0.3098228871822357}, {"wallTime": 1733071283.0165284, "step": 3820, "value": 0.23017650842666626}, {"wallTime": 1733071291.7283716, "step": 3830, "value": 0.1779739260673523}, {"wallTime": 1733071299.8912232, "step": 3840, "value": 0.21058648824691772}, {"wallTime": 1733071308.4780295, "step": 3850, "value": 0.28615838289260864}, {"wallTime": 1733071316.9501035, "step": 3860, "value": 0.3073670268058777}, {"wallTime": 1733071330.2136397, "step": 3870, "value": 0.2264631688594818}, {"wallTime": 1733071338.9876027, "step": 3880, "value": 0.24181358516216278}, {"wallTime": 1733071347.7355616, "step": 3890, "value": 0.2157432585954666}, {"wallTime": 1733071357.0332217, "step": 3900, "value": 0.21871434152126312}, {"wallTime": 1733071365.2242231, "step": 3910, "value": 0.29643920063972473}, {"wallTime": 1733071374.1335006, "step": 3920, "value": 0.46030837297439575}, {"wallTime": 1733071382.8127224, "step": 3930, "value": 0.29888394474983215}, {"wallTime": 1733071391.5673265, "step": 3940, "value": 0.2572490870952606}, {"wallTime": 1733071404.4661446, "step": 3950, "value": 0.2338901162147522}, {"wallTime": 1733071412.337779, "step": 3960, "value": 0.25642672181129456}, {"wallTime": 1733071421.1564634, "step": 3970, "value": 0.2758648991584778}, {"wallTime": 1733071430.119452, "step": 3980, "value": 0.19607549905776978}, {"wallTime": 1733071438.412944, "step": 3990, "value": 0.3736478388309479}, {"wallTime": 1733071447.727766, "step": 4000, "value": 0.35250040888786316}, {"wallTime": 1733071456.19554, "step": 4010, "value": 0.292158842086792}, {"wallTime": 1733071464.7483997, "step": 4020, "value": 0.2505805790424347}, {"wallTime": 1733071473.3959298, "step": 4030, "value": 0.3268470764160156}, {"wallTime": 1733071490.285382, "step": 4040, "value": 0.24911241233348846}, {"wallTime": 1733071498.710703, "step": 4050, "value": 0.23571325838565826}, {"wallTime": 1733071507.0963075, "step": 4060, "value": 0.19231738150119781}, {"wallTime": 1733071515.066824, "step": 4070, "value": 0.28249508142471313}, {"wallTime": 1733071523.8802657, "step": 4080, "value": 0.2717181444168091}, {"wallTime": 1733071532.2843988, "step": 4090, "value": 0.19725924730300903}, {"wallTime": 1733071540.916806, "step": 4100, "value": 0.21561765670776367}, {"wallTime": 1733071549.175347, "step": 4110, "value": 0.18479880690574646}, {"wallTime": 1733071565.8352184, "step": 4120, "value": 0.22785118222236633}, {"wallTime": 1733071573.630952, "step": 4130, "value": 0.16080988943576813}, {"wallTime": 1733071582.0955493, "step": 4140, "value": 0.42117446660995483}, {"wallTime": 1733071590.0220294, "step": 4150, "value": 0.16493649780750275}, {"wallTime": 1733071599.2403798, "step": 4160, "value": 0.711288332939148}, {"wallTime": 1733071608.071136, "step": 4170, "value": 0.25473976135253906}, {"wallTime": 1733071616.183285, "step": 4180, "value": 0.319270521402359}, {"wallTime": 1733071626.0823658, "step": 4190, "value": 0.159912571310997}, {"wallTime": 1733071641.0074534, "step": 4200, "value": 0.24502290785312653}, {"wallTime": 1733071649.0403311, "step": 4210, "value": 0.20414233207702637}, {"wallTime": 1733071658.5310912, "step": 4220, "value": 0.2799862325191498}, {"wallTime": 1733071667.9657743, "step": 4230, "value": 0.3228265047073364}, {"wallTime": 1733071676.1084487, "step": 4240, "value": 0.209851935505867}, {"wallTime": 1733071684.378261, "step": 4250, "value": 0.3129146993160248}, {"wallTime": 1733071693.1093676, "step": 4260, "value": 0.289457768201828}, {"wallTime": 1733071702.1836245, "step": 4270, "value": 0.21319061517715454}, {"wallTime": 1733071710.629924, "step": 4280, "value": 0.3231997489929199}, {"wallTime": 1733071726.6764631, "step": 4290, "value": 0.2662006616592407}, {"wallTime": 1733071735.2153187, "step": 4300, "value": 0.2665562033653259}, {"wallTime": 1733071742.9568555, "step": 4310, "value": 0.26421451568603516}, {"wallTime": 1733071751.585489, "step": 4320, "value": 0.42408350110054016}, {"wallTime": 1733071760.034406, "step": 4330, "value": 0.2760047912597656}, {"wallTime": 1733071768.4310932, "step": 4340, "value": 0.1815873682498932}, {"wallTime": 1733071777.4019148, "step": 4350, "value": 0.29811179637908936}, {"wallTime": 1733071785.5470998, "step": 4360, "value": 0.2726636528968811}, {"wallTime": 1733071800.884514, "step": 4370, "value": 0.35923242568969727}, {"wallTime": 1733071809.2656279, "step": 4380, "value": 0.24299801886081696}, {"wallTime": 1733071817.3461673, "step": 4390, "value": 0.20586630702018738}, {"wallTime": 1733071826.4301796, "step": 4400, "value": 0.3029996454715729}, {"wallTime": 1733071834.8873923, "step": 4410, "value": 0.2939841151237488}, {"wallTime": 1733071843.4466352, "step": 4420, "value": 0.25860708951950073}, {"wallTime": 1733071851.5958, "step": 4430, "value": 0.24633893370628357}, {"wallTime": 1733071859.9238923, "step": 4440, "value": 0.25935035943984985}, {"wallTime": 1733071868.6730323, "step": 4450, "value": 0.2457779496908188}, {"wallTime": 1733071881.3359623, "step": 4460, "value": 0.22866177558898926}, {"wallTime": 1733071889.636202, "step": 4470, "value": 0.23953886330127716}, {"wallTime": 1733071898.420557, "step": 4480, "value": 0.2693205773830414}, {"wallTime": 1733071907.3357713, "step": 4490, "value": 0.23040401935577393}, {"wallTime": 1733071916.2779305, "step": 4500, "value": 0.3313356637954712}, {"wallTime": 1733071925.3484771, "step": 4510, "value": 0.3635876774787903}, {"wallTime": 1733071933.3290865, "step": 4520, "value": 0.15370729565620422}, {"wallTime": 1733071941.4824116, "step": 4530, "value": 0.16413718461990356}, {"wallTime": 1733071954.1687026, "step": 4540, "value": 0.236111119389534}, {"wallTime": 1733071962.3954957, "step": 4550, "value": 0.18941763043403625}, {"wallTime": 1733071970.5130866, "step": 4560, "value": 0.2659006118774414}, {"wallTime": 1733071978.869603, "step": 4570, "value": 0.3722306489944458}, {"wallTime": 1733071987.710192, "step": 4580, "value": 0.29826077818870544}, {"wallTime": 1733071996.4441323, "step": 4590, "value": 0.3894510567188263}, {"wallTime": 1733072004.4756043, "step": 4600, "value": 0.1947837918996811}, {"wallTime": 1733072012.7443628, "step": 4610, "value": 0.18240801990032196}, {"wallTime": 1733072025.399757, "step": 4620, "value": 0.19940020143985748}, {"wallTime": 1733072034.1177866, "step": 4630, "value": 0.19018785655498505}, {"wallTime": 1733072043.036983, "step": 4640, "value": 0.3154599964618683}, {"wallTime": 1733072051.784413, "step": 4650, "value": 0.2513565421104431}, {"wallTime": 1733072060.107589, "step": 4660, "value": 0.24570432305335999}, {"wallTime": 1733072068.6023324, "step": 4670, "value": 0.27255910634994507}, {"wallTime": 1733072076.8357484, "step": 4680, "value": 0.27059024572372437}, {"wallTime": 1733072085.3751934, "step": 4690, "value": 0.28711366653442383}, {"wallTime": 1733072093.7476315, "step": 4700, "value": 0.21262341737747192}, {"wallTime": 1733072106.9887726, "step": 4710, "value": 0.25872015953063965}, {"wallTime": 1733072115.664236, "step": 4720, "value": 0.41214898228645325}, {"wallTime": 1733072123.9496095, "step": 4730, "value": 0.32427120208740234}, {"wallTime": 1733072132.279643, "step": 4740, "value": 0.22887824475765228}, {"wallTime": 1733072140.419536, "step": 4750, "value": 0.19363844394683838}, {"wallTime": 1733072149.0862074, "step": 4760, "value": 0.21453142166137695}, {"wallTime": 1733072157.4108114, "step": 4770, "value": 0.24082794785499573}, {"wallTime": 1733072165.488384, "step": 4780, "value": 0.2718524932861328}, {"wallTime": 1733072179.6474588, "step": 4790, "value": 0.2571575343608856}, {"wallTime": 1733072188.3287344, "step": 4800, "value": 0.1945849359035492}, {"wallTime": 1733072196.8460062, "step": 4810, "value": 0.26145991683006287}, {"wallTime": 1733072204.5612803, "step": 4820, "value": 0.20401768386363983}, {"wallTime": 1733072213.0986688, "step": 4830, "value": 0.361634224653244}, {"wallTime": 1733072221.6660616, "step": 4840, "value": 0.26435914635658264}, {"wallTime": 1733072229.8930137, "step": 4850, "value": 0.20475246012210846}, {"wallTime": 1733072238.0552378, "step": 4860, "value": 0.24419933557510376}, {"wallTime": 1733072246.342586, "step": 4870, "value": 0.200677290558815}, {"wallTime": 1733072261.2663941, "step": 4880, "value": 0.2301359921693802}, {"wallTime": 1733072269.851543, "step": 4890, "value": 0.22339671850204468}, {"wallTime": 1733072278.8606753, "step": 4900, "value": 0.2861037850379944}, {"wallTime": 1733072287.533604, "step": 4910, "value": 0.20231476426124573}, {"wallTime": 1733072295.9463258, "step": 4920, "value": 0.1790931671857834}, {"wallTime": 1733072304.3545153, "step": 4930, "value": 0.2667297124862671}, {"wallTime": 1733072313.5090275, "step": 4940, "value": 0.26880794763565063}, {"wallTime": 1733072321.3245032, "step": 4950, "value": 0.19084110856056213}, {"wallTime": 1733072337.0241413, "step": 4960, "value": 0.1650989055633545}, {"wallTime": 1733072345.5305572, "step": 4970, "value": 0.17932724952697754}, {"wallTime": 1733072353.429033, "step": 4980, "value": 0.22690458595752716}, {"wallTime": 1733072362.41249, "step": 4990, "value": 0.24258197844028473}, {"wallTime": 1733072371.7452056, "step": 5000, "value": 0.23153634369373322}, {"wallTime": 1733072380.5289745, "step": 5010, "value": 0.2899473309516907}, {"wallTime": 1733072389.0257344, "step": 5020, "value": 0.30430999398231506}, {"wallTime": 1733072397.7848518, "step": 5030, "value": 0.19650967419147491}, {"wallTime": 1733072411.2975898, "step": 5040, "value": 0.21886460483074188}, {"wallTime": 1733072419.4733565, "step": 5050, "value": 0.20739975571632385}, {"wallTime": 1733072428.3715403, "step": 5060, "value": 0.2876735031604767}, {"wallTime": 1733072437.1160395, "step": 5070, "value": 0.2674838602542877}, {"wallTime": 1733072446.1745427, "step": 5080, "value": 0.29152119159698486}, {"wallTime": 1733072454.4277835, "step": 5090, "value": 0.19960133731365204}, {"wallTime": 1733072462.4098048, "step": 5100, "value": 0.24929994344711304}, {"wallTime": 1733072471.149305, "step": 5110, "value": 0.22239401936531067}, {"wallTime": 1733072478.9458885, "step": 5120, "value": 0.30230242013931274}, {"wallTime": 1733072491.320983, "step": 5130, "value": 0.32693666219711304}, {"wallTime": 1733072499.2580605, "step": 5140, "value": 0.16843968629837036}, {"wallTime": 1733072507.1114194, "step": 5150, "value": 0.21957816183567047}, {"wallTime": 1733072515.3165305, "step": 5160, "value": 0.623793363571167}, {"wallTime": 1733072523.4993477, "step": 5170, "value": 0.2758200466632843}, {"wallTime": 1733072531.0865579, "step": 5180, "value": 0.17543353140354156}, {"wallTime": 1733072540.0211325, "step": 5190, "value": 0.24002885818481445}, {"wallTime": 1733072548.6513782, "step": 5200, "value": 0.26515889167785645}, {"wallTime": 1733072561.4144826, "step": 5210, "value": 0.20977137982845306}, {"wallTime": 1733072569.895518, "step": 5220, "value": 0.29242274165153503}, {"wallTime": 1733072578.6781728, "step": 5230, "value": 0.2667089104652405}, {"wallTime": 1733072586.9414597, "step": 5240, "value": 0.27339211106300354}, {"wallTime": 1733072595.033637, "step": 5250, "value": 0.3377451002597809}, {"wallTime": 1733072603.172747, "step": 5260, "value": 0.24802523851394653}, {"wallTime": 1733072611.079236, "step": 5270, "value": 0.28257864713668823}, {"wallTime": 1733072619.9543083, "step": 5280, "value": 0.2449532449245453}, {"wallTime": 1733072628.6339068, "step": 5290, "value": 0.24002060294151306}, {"wallTime": 1733072641.3748147, "step": 5300, "value": 0.22835396230220795}, {"wallTime": 1733072649.8573477, "step": 5310, "value": 0.16709698736667633}, {"wallTime": 1733072657.9706178, "step": 5320, "value": 0.18480969965457916}, {"wallTime": 1733072667.0288277, "step": 5330, "value": 0.29812073707580566}, {"wallTime": 1733072675.9423265, "step": 5340, "value": 0.2411753535270691}, {"wallTime": 1733072684.2377472, "step": 5350, "value": 0.37146493792533875}, {"wallTime": 1733072691.8574536, "step": 5360, "value": 0.24950730800628662}, {"wallTime": 1733072700.1473172, "step": 5370, "value": 0.18799333274364471}, {"wallTime": 1733072713.1823387, "step": 5380, "value": 0.19227536022663116}, {"wallTime": 1733072721.024044, "step": 5390, "value": 0.16813501715660095}, {"wallTime": 1733072729.876278, "step": 5400, "value": 0.22802279889583588}, {"wallTime": 1733072738.368754, "step": 5410, "value": 0.18010744452476501}, {"wallTime": 1733072746.381981, "step": 5420, "value": 0.2512251138687134}, {"wallTime": 1733072754.6169941, "step": 5430, "value": 0.3163031339645386}, {"wallTime": 1733072762.5461369, "step": 5440, "value": 0.1883208453655243}, {"wallTime": 1733072771.3599565, "step": 5450, "value": 0.2439022958278656}, {"wallTime": 1733072787.1510332, "step": 5460, "value": 0.18070289492607117}, {"wallTime": 1733072795.8019412, "step": 5470, "value": 0.251873642206192}, {"wallTime": 1733072804.2413225, "step": 5480, "value": 0.16730496287345886}, {"wallTime": 1733072812.3723907, "step": 5490, "value": 0.2630946934223175}, {"wallTime": 1733072821.1585202, "step": 5500, "value": 0.2756343483924866}, {"wallTime": 1733072830.021927, "step": 5510, "value": 0.29582479596138}, {"wallTime": 1733072838.694419, "step": 5520, "value": 0.20794393122196198}, {"wallTime": 1733072846.9042912, "step": 5530, "value": 0.172681987285614}, {"wallTime": 1733072855.2454348, "step": 5540, "value": 0.19866125285625458}, {"wallTime": 1733072870.6435056, "step": 5550, "value": 0.2851065695285797}, {"wallTime": 1733072878.7284095, "step": 5560, "value": 0.2756732702255249}, {"wallTime": 1733072886.6097465, "step": 5570, "value": 0.23259387910366058}, {"wallTime": 1733072895.0200913, "step": 5580, "value": 0.8566576838493347}, {"wallTime": 1733072903.4020286, "step": 5590, "value": 0.20871923863887787}, {"wallTime": 1733072911.2090774, "step": 5600, "value": 0.3070879578590393}, {"wallTime": 1733072919.839001, "step": 5610, "value": 0.25985363125801086}, {"wallTime": 1733072928.7321155, "step": 5620, "value": 0.37197384238243103}, {"wallTime": 1733072941.7027707, "step": 5630, "value": 0.20423623919487}, {"wallTime": 1733072949.979059, "step": 5640, "value": 0.23472312092781067}, {"wallTime": 1733072958.7185633, "step": 5650, "value": 0.3257685601711273}, {"wallTime": 1733072966.8133602, "step": 5660, "value": 0.20354235172271729}, {"wallTime": 1733072974.9607613, "step": 5670, "value": 0.18540962040424347}, {"wallTime": 1733072983.5610523, "step": 5680, "value": 0.23138386011123657}, {"wallTime": 1733072992.2272134, "step": 5690, "value": 0.25162163376808167}, {"wallTime": 1733073000.8161395, "step": 5700, "value": 0.1986299604177475}, {"wallTime": 1733073009.782346, "step": 5710, "value": 0.24152106046676636}, {"wallTime": 1733073022.8672876, "step": 5720, "value": 0.36655712127685547}, {"wallTime": 1733073031.5331745, "step": 5730, "value": 0.29284554719924927}, {"wallTime": 1733073039.5695748, "step": 5740, "value": 0.24665696918964386}, {"wallTime": 1733073047.8420155, "step": 5750, "value": 0.24107201397418976}, {"wallTime": 1733073056.1556327, "step": 5760, "value": 0.18497107923030853}, {"wallTime": 1733073064.9541955, "step": 5770, "value": 0.34098929166793823}, {"wallTime": 1733073073.8367867, "step": 5780, "value": 0.22480235993862152}, {"wallTime": 1733073082.7242107, "step": 5790, "value": 0.31853383779525757}, {"wallTime": 1733073095.1020918, "step": 5800, "value": 0.21876463294029236}, {"wallTime": 1733073103.3149023, "step": 5810, "value": 0.24597665667533875}, {"wallTime": 1733073111.9698043, "step": 5820, "value": 0.1638021171092987}, {"wallTime": 1733073120.354832, "step": 5830, "value": 0.30721887946128845}, {"wallTime": 1733073128.2083702, "step": 5840, "value": 0.20185767114162445}, {"wallTime": 1733073136.7148728, "step": 5850, "value": 0.16904878616333008}, {"wallTime": 1733073144.9270134, "step": 5860, "value": 0.25098392367362976}, {"wallTime": 1733073153.040093, "step": 5870, "value": 0.15599358081817627}, {"wallTime": 1733073166.002068, "step": 5880, "value": 0.1916334331035614}, {"wallTime": 1733073174.6581776, "step": 5890, "value": 0.15544311702251434}, {"wallTime": 1733073182.5074847, "step": 5900, "value": 0.22700242698192596}, {"wallTime": 1733073191.558766, "step": 5910, "value": 0.18620046973228455}, {"wallTime": 1733073199.4101245, "step": 5920, "value": 0.10423731058835983}, {"wallTime": 1733073207.4647813, "step": 5930, "value": 0.23431402444839478}, {"wallTime": 1733073215.602106, "step": 5940, "value": 0.20854699611663818}, {"wallTime": 1733073224.357366, "step": 5950, "value": 0.20260211825370789}, {"wallTime": 1733073232.8761356, "step": 5960, "value": 0.2822642922401428}, {"wallTime": 1733073245.3730485, "step": 5970, "value": 0.19898907840251923}, {"wallTime": 1733073253.1788719, "step": 5980, "value": 0.24622181057929993}, {"wallTime": 1733073261.7984803, "step": 5990, "value": 0.2230023443698883}, {"wallTime": 1733073270.0591884, "step": 6000, "value": 0.21681568026542664}, {"wallTime": 1733073278.8949435, "step": 6010, "value": 0.36482709646224976}, {"wallTime": 1733073287.6815329, "step": 6020, "value": 0.250259131193161}, {"wallTime": 1733073297.2738805, "step": 6030, "value": 0.3900523781776428}, {"wallTime": 1733073305.9176211, "step": 6040, "value": 0.29816901683807373}, {"wallTime": 1733073322.3541512, "step": 6050, "value": 0.21679285168647766}, {"wallTime": 1733073331.9767296, "step": 6060, "value": 0.16094130277633667}, {"wallTime": 1733073340.5215857, "step": 6070, "value": 0.18947339057922363}, {"wallTime": 1733073349.6014569, "step": 6080, "value": 0.30137526988983154}, {"wallTime": 1733073359.070609, "step": 6090, "value": 0.18783903121948242}, {"wallTime": 1733073368.402348, "step": 6100, "value": 0.23060405254364014}, {"wallTime": 1733073377.6744444, "step": 6110, "value": 0.24497753381729126}, {"wallTime": 1733073386.3998077, "step": 6120, "value": 0.16375334560871124}, {"wallTime": 1733073395.4509368, "step": 6130, "value": 0.22882437705993652}, {"wallTime": 1733073408.1507297, "step": 6140, "value": 0.154414564371109}, {"wallTime": 1733073417.3231559, "step": 6150, "value": 0.19034719467163086}, {"wallTime": 1733073426.2556374, "step": 6160, "value": 0.19351115822792053}, {"wallTime": 1733073434.8087385, "step": 6170, "value": 0.16813628375530243}, {"wallTime": 1733073444.5121324, "step": 6180, "value": 0.20920303463935852}, {"wallTime": 1733073453.115356, "step": 6190, "value": 0.2426050305366516}, {"wallTime": 1733073462.565002, "step": 6200, "value": 0.16221298277378082}, {"wallTime": 1733073472.0238197, "step": 6210, "value": 0.23388183116912842}, {"wallTime": 1733073484.44767, "step": 6220, "value": 0.2009839415550232}, {"wallTime": 1733073493.6593451, "step": 6230, "value": 0.19431045651435852}, {"wallTime": 1733073502.4405732, "step": 6240, "value": 0.21292513608932495}, {"wallTime": 1733073511.255271, "step": 6250, "value": 0.2365405112504959}, {"wallTime": 1733073520.4843514, "step": 6260, "value": 0.18844449520111084}, {"wallTime": 1733073529.7807984, "step": 6270, "value": 0.28112199902534485}, {"wallTime": 1733073539.6384795, "step": 6280, "value": 0.23329535126686096}, {"wallTime": 1733073548.910297, "step": 6290, "value": 0.20323699712753296}, {"wallTime": 1733073560.6190743, "step": 6300, "value": 0.26662296056747437}, {"wallTime": 1733073570.068365, "step": 6310, "value": 0.18925102055072784}, {"wallTime": 1733073579.4804492, "step": 6320, "value": 0.24760721623897552}, {"wallTime": 1733073587.6665754, "step": 6330, "value": 0.1968691647052765}, {"wallTime": 1733073597.2173111, "step": 6340, "value": 0.2040776014328003}, {"wallTime": 1733073606.2374754, "step": 6350, "value": 0.19527748227119446}, {"wallTime": 1733073615.0769296, "step": 6360, "value": 0.29534444212913513}, {"wallTime": 1733073624.8338566, "step": 6370, "value": 0.2525634765625}, {"wallTime": 1733073634.6718833, "step": 6380, "value": 0.23552359640598297}, {"wallTime": 1733073646.527539, "step": 6390, "value": 0.20260977745056152}, {"wallTime": 1733073655.7447956, "step": 6400, "value": 0.23778559267520905}, {"wallTime": 1733073665.606499, "step": 6410, "value": 0.22686496376991272}, {"wallTime": 1733073674.6421123, "step": 6420, "value": 0.2844448387622833}, {"wallTime": 1733073683.6696732, "step": 6430, "value": 0.1696723848581314}, {"wallTime": 1733073692.8761272, "step": 6440, "value": 0.25723332166671753}, {"wallTime": 1733073702.518479, "step": 6450, "value": 0.17460301518440247}, {"wallTime": 1733073712.6266866, "step": 6460, "value": 0.25361406803131104}, {"wallTime": 1733073724.0465834, "step": 6470, "value": 0.3206992745399475}, {"wallTime": 1733073732.827765, "step": 6480, "value": 0.23667654395103455}, {"wallTime": 1733073741.9565663, "step": 6490, "value": 0.2119840532541275}, {"wallTime": 1733073750.7170537, "step": 6500, "value": 0.23997695744037628}, {"wallTime": 1733073760.4874682, "step": 6510, "value": 0.15458965301513672}, {"wallTime": 1733073769.8626695, "step": 6520, "value": 0.17348863184452057}, {"wallTime": 1733073779.1263976, "step": 6530, "value": 0.1999395191669464}, {"wallTime": 1733073789.4770687, "step": 6540, "value": 0.30897751450538635}, {"wallTime": 1733073798.1026947, "step": 6550, "value": 0.3361678123474121}, {"wallTime": 1733073810.552225, "step": 6560, "value": 0.22732901573181152}, {"wallTime": 1733073820.035739, "step": 6570, "value": 0.20669730007648468}, {"wallTime": 1733073828.2379618, "step": 6580, "value": 0.2626774311065674}, {"wallTime": 1733073836.7975588, "step": 6590, "value": 0.1766311377286911}, {"wallTime": 1733073845.9868875, "step": 6600, "value": 0.21847912669181824}, {"wallTime": 1733073855.2515216, "step": 6610, "value": 0.20639795064926147}, {"wallTime": 1733073864.6931224, "step": 6620, "value": 0.19065958261489868}, {"wallTime": 1733073873.8340647, "step": 6630, "value": 0.21293558180332184}, {"wallTime": 1733073887.5240567, "step": 6640, "value": 0.25706249475479126}, {"wallTime": 1733073897.3334246, "step": 6650, "value": 0.22763536870479584}, {"wallTime": 1733073906.8762531, "step": 6660, "value": 0.22373291850090027}, {"wallTime": 1733073916.3497436, "step": 6670, "value": 0.2566353976726532}, {"wallTime": 1733073925.618314, "step": 6680, "value": 0.1888960897922516}, {"wallTime": 1733073934.9163184, "step": 6690, "value": 0.17884886264801025}, {"wallTime": 1733073943.7418635, "step": 6700, "value": 0.16825732588768005}, {"wallTime": 1733073952.476659, "step": 6710, "value": 0.23107880353927612}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15048" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_aux_0%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_aux_0", "runToSeries": {".": [{"wallTime": 1733067631.537525, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6508608, "step": 10, "value": 2.0812554359436035}, {"wallTime": 1733067660.7829568, "step": 20, "value": 1.8974047899246216}, {"wallTime": 1733067674.136175, "step": 30, "value": 1.8140000104904175}, {"wallTime": 1733067687.0558367, "step": 40, "value": 2.0522878170013428}, {"wallTime": 1733067699.4917343, "step": 50, "value": 1.3280051946640015}, {"wallTime": 1733067710.6280315, "step": 60, "value": 1.6674751043319702}, {"wallTime": 1733067722.7542517, "step": 70, "value": 1.4434654712677002}, {"wallTime": 1733067733.7241087, "step": 80, "value": 0.9679604768753052}, {"wallTime": 1733067750.945034, "step": 90, "value": 1.2482883930206299}, {"wallTime": 1733067761.9795697, "step": 100, "value": 1.090993881225586}, {"wallTime": 1733067771.6051579, "step": 110, "value": 0.7257188558578491}, {"wallTime": 1733067780.546102, "step": 120, "value": 0.6158868670463562}, {"wallTime": 1733067790.4840598, "step": 130, "value": 0.8163788914680481}, {"wallTime": 1733067799.1043673, "step": 140, "value": 0.446186900138855}, {"wallTime": 1733067809.4433522, "step": 150, "value": 0.6383189558982849}, {"wallTime": 1733067818.9194431, "step": 160, "value": 0.609546959400177}, {"wallTime": 1733067836.6482599, "step": 170, "value": 0.43359309434890747}, {"wallTime": 1733067846.389417, "step": 180, "value": 0.6705451011657715}, {"wallTime": 1733067855.6655102, "step": 190, "value": 0.43424421548843384}, {"wallTime": 1733067864.8876371, "step": 200, "value": 0.793768048286438}, {"wallTime": 1733067874.0003436, "step": 210, "value": 0.6051200032234192}, {"wallTime": 1733067883.7839983, "step": 220, "value": 0.4252021908760071}, {"wallTime": 1733067892.1218321, "step": 230, "value": 0.5055435299873352}, {"wallTime": 1733067901.0681334, "step": 240, "value": 0.5015060901641846}, {"wallTime": 1733067910.073625, "step": 250, "value": 0.4702575206756592}, {"wallTime": 1733067925.9487712, "step": 260, "value": 0.7852791547775269}, {"wallTime": 1733067935.4593015, "step": 270, "value": 0.43654340505599976}, {"wallTime": 1733067944.0133722, "step": 280, "value": 0.4815245270729065}, {"wallTime": 1733067952.544428, "step": 290, "value": 0.47543543577194214}, {"wallTime": 1733067961.02545, "step": 300, "value": 0.3322181701660156}, {"wallTime": 1733067970.133166, "step": 310, "value": 0.5435259342193604}, {"wallTime": 1733067980.2244933, "step": 320, "value": 0.45096302032470703}, {"wallTime": 1733067988.8148255, "step": 330, "value": 0.5434011816978455}, {"wallTime": 1733068005.089334, "step": 340, "value": 0.416849285364151}, {"wallTime": 1733068014.063872, "step": 350, "value": 0.40918147563934326}, {"wallTime": 1733068022.5517612, "step": 360, "value": 0.46989601850509644}, {"wallTime": 1733068031.8234673, "step": 370, "value": 0.5062175989151001}, {"wallTime": 1733068040.7865818, "step": 380, "value": 0.36286863684654236}, {"wallTime": 1733068050.1590292, "step": 390, "value": 0.39608749747276306}, {"wallTime": 1733068059.1248734, "step": 400, "value": 0.3047451674938202}, {"wallTime": 1733068068.0889304, "step": 410, "value": 0.6705313920974731}, {"wallTime": 1733068084.8427806, "step": 420, "value": 0.3899928331375122}, {"wallTime": 1733068094.6654084, "step": 430, "value": 0.5150675177574158}, {"wallTime": 1733068103.7069426, "step": 440, "value": 0.35201624035835266}, {"wallTime": 1733068112.6985836, "step": 450, "value": 0.43904250860214233}, {"wallTime": 1733068121.4999647, "step": 460, "value": 0.5341180562973022}, {"wallTime": 1733068130.7267482, "step": 470, "value": 0.41925665736198425}, {"wallTime": 1733068139.854725, "step": 480, "value": 0.4017651677131653}, {"wallTime": 1733068149.3691175, "step": 490, "value": 0.5358281135559082}, {"wallTime": 1733068158.0691102, "step": 500, "value": 0.5249373912811279}, {"wallTime": 1733068174.1142108, "step": 510, "value": 0.48304200172424316}, {"wallTime": 1733068182.718693, "step": 520, "value": 0.37957683205604553}, {"wallTime": 1733068192.4127212, "step": 530, "value": 0.4046887457370758}, {"wallTime": 1733068201.807235, "step": 540, "value": 0.39392903447151184}, {"wallTime": 1733068210.653666, "step": 550, "value": 0.602113664150238}, {"wallTime": 1733068220.1942294, "step": 560, "value": 0.7287052869796753}, {"wallTime": 1733068229.1584249, "step": 570, "value": 0.3275562822818756}, {"wallTime": 1733068238.5906713, "step": 580, "value": 0.29823076725006104}, {"wallTime": 1733068256.0719774, "step": 590, "value": 0.4084402322769165}, {"wallTime": 1733068265.4310234, "step": 600, "value": 0.5106266736984253}, {"wallTime": 1733068274.655702, "step": 610, "value": 0.6565208435058594}, {"wallTime": 1733068283.769148, "step": 620, "value": 0.5959144830703735}, {"wallTime": 1733068293.3333275, "step": 630, "value": 0.46534544229507446}, {"wallTime": 1733068302.6463275, "step": 640, "value": 0.38862013816833496}, {"wallTime": 1733068311.387303, "step": 650, "value": 0.3481963276863098}, {"wallTime": 1733068320.389297, "step": 660, "value": 0.4554746150970459}, {"wallTime": 1733068328.7304423, "step": 670, "value": 0.36553364992141724}, {"wallTime": 1733068344.4603243, "step": 680, "value": 0.4004385769367218}, {"wallTime": 1733068353.7161548, "step": 690, "value": 0.35890889167785645}, {"wallTime": 1733068362.0571296, "step": 700, "value": 0.3436048626899719}, {"wallTime": 1733068371.1032648, "step": 710, "value": 0.5380759239196777}, {"wallTime": 1733068380.5323112, "step": 720, "value": 0.42480844259262085}, {"wallTime": 1733068390.0859592, "step": 730, "value": 0.3112938404083252}, {"wallTime": 1733068398.72025, "step": 740, "value": 0.4800247848033905}, {"wallTime": 1733068407.1232514, "step": 750, "value": 0.4118860065937042}, {"wallTime": 1733068423.0693617, "step": 760, "value": 0.40313664078712463}, {"wallTime": 1733068431.4045594, "step": 770, "value": 0.34059491753578186}, {"wallTime": 1733068440.424181, "step": 780, "value": 0.35266515612602234}, {"wallTime": 1733068449.0057054, "step": 790, "value": 0.37609678506851196}, {"wallTime": 1733068457.636103, "step": 800, "value": 0.39625051617622375}, {"wallTime": 1733068467.0465372, "step": 810, "value": 0.37453678250312805}, {"wallTime": 1733068475.6197307, "step": 820, "value": 0.367070734500885}, {"wallTime": 1733068484.9781811, "step": 830, "value": 0.3734648525714874}, {"wallTime": 1733068500.7309148, "step": 840, "value": 0.3964844346046448}, {"wallTime": 1733068509.3072007, "step": 850, "value": 0.4215632379055023}, {"wallTime": 1733068519.0215762, "step": 860, "value": 0.41897428035736084}, {"wallTime": 1733068527.4980078, "step": 870, "value": 0.33519241213798523}, {"wallTime": 1733068536.9197388, "step": 880, "value": 0.4894644021987915}, {"wallTime": 1733068544.9082713, "step": 890, "value": 0.3653079867362976}, {"wallTime": 1733068553.5784876, "step": 900, "value": 0.3786148428916931}, {"wallTime": 1733068562.6855402, "step": 910, "value": 0.41841328144073486}, {"wallTime": 1733068571.2458699, "step": 920, "value": 0.336664617061615}, {"wallTime": 1733068584.775841, "step": 930, "value": 0.3870795667171478}, {"wallTime": 1733068593.772193, "step": 940, "value": 0.37217456102371216}, {"wallTime": 1733068602.7663846, "step": 950, "value": 0.4597548246383667}, {"wallTime": 1733068611.0404227, "step": 960, "value": 0.2768395245075226}, {"wallTime": 1733068620.2272818, "step": 970, "value": 0.33774957060813904}, {"wallTime": 1733068628.8422408, "step": 980, "value": 0.40329787135124207}, {"wallTime": 1733068637.6311715, "step": 990, "value": 0.33470118045806885}, {"wallTime": 1733068646.6737924, "step": 1000, "value": 0.3921143412590027}, {"wallTime": 1733068662.7575524, "step": 1010, "value": 0.2635074257850647}, {"wallTime": 1733068672.0552616, "step": 1020, "value": 0.30672141909599304}, {"wallTime": 1733068680.5639365, "step": 1030, "value": 0.3235553205013275}, {"wallTime": 1733068690.1866107, "step": 1040, "value": 0.36146995425224304}, {"wallTime": 1733068698.8489337, "step": 1050, "value": 0.3436771333217621}, {"wallTime": 1733068707.7443562, "step": 1060, "value": 0.7736580967903137}, {"wallTime": 1733068717.345564, "step": 1070, "value": 0.3423841595649719}, {"wallTime": 1733068726.3623073, "step": 1080, "value": 0.41962867975234985}, {"wallTime": 1733068735.2527483, "step": 1090, "value": 0.44203492999076843}, {"wallTime": 1733068749.5488958, "step": 1100, "value": 0.3547292947769165}, {"wallTime": 1733068758.3763394, "step": 1110, "value": 0.4437912106513977}, {"wallTime": 1733068767.004792, "step": 1120, "value": 0.5221999883651733}, {"wallTime": 1733068776.619808, "step": 1130, "value": 0.45918968319892883}, {"wallTime": 1733068785.4020882, "step": 1140, "value": 0.24673590064048767}, {"wallTime": 1733068794.2799807, "step": 1150, "value": 0.4059406518936157}, {"wallTime": 1733068802.6982937, "step": 1160, "value": 0.2882084846496582}, {"wallTime": 1733068811.5524268, "step": 1170, "value": 0.38514718413352966}, {"wallTime": 1733068824.9666998, "step": 1180, "value": 0.23257574439048767}, {"wallTime": 1733068834.378158, "step": 1190, "value": 0.36699384450912476}, {"wallTime": 1733068843.5171163, "step": 1200, "value": 0.4465058743953705}, {"wallTime": 1733068852.2294126, "step": 1210, "value": 0.34826093912124634}, {"wallTime": 1733068861.117909, "step": 1220, "value": 0.3627679944038391}, {"wallTime": 1733068870.0568523, "step": 1230, "value": 0.6253167986869812}, {"wallTime": 1733068878.7213712, "step": 1240, "value": 0.4256916046142578}, {"wallTime": 1733068887.7390635, "step": 1250, "value": 0.3401038646697998}, {"wallTime": 1733068903.167723, "step": 1260, "value": 0.49327147006988525}, {"wallTime": 1733068912.4150543, "step": 1270, "value": 0.28747159242630005}, {"wallTime": 1733068921.4736168, "step": 1280, "value": 0.34129029512405396}, {"wallTime": 1733068929.7476296, "step": 1290, "value": 0.383678674697876}, {"wallTime": 1733068939.5022798, "step": 1300, "value": 0.33587414026260376}, {"wallTime": 1733068948.9284601, "step": 1310, "value": 0.3954617381095886}, {"wallTime": 1733068957.2353776, "step": 1320, "value": 0.48029717803001404}, {"wallTime": 1733068966.0780106, "step": 1330, "value": 0.29172849655151367}, {"wallTime": 1733068975.5661345, "step": 1340, "value": 0.528330385684967}, {"wallTime": 1733068989.7986264, "step": 1350, "value": 0.3900383412837982}, {"wallTime": 1733068998.2820039, "step": 1360, "value": 0.28997278213500977}, {"wallTime": 1733069007.1489294, "step": 1370, "value": 0.3568236529827118}, {"wallTime": 1733069015.921753, "step": 1380, "value": 0.21430703997612}, {"wallTime": 1733069025.3041868, "step": 1390, "value": 0.364345908164978}, {"wallTime": 1733069034.4823568, "step": 1400, "value": 0.26459789276123047}, {"wallTime": 1733069042.7939174, "step": 1410, "value": 0.4325443208217621}, {"wallTime": 1733069052.1384254, "step": 1420, "value": 0.2584827244281769}, {"wallTime": 1733069065.0024347, "step": 1430, "value": 0.30329105257987976}, {"wallTime": 1733069074.524826, "step": 1440, "value": 0.3215788006782532}, {"wallTime": 1733069083.7834063, "step": 1450, "value": 0.37712857127189636}, {"wallTime": 1733069092.258725, "step": 1460, "value": 0.3032873868942261}, {"wallTime": 1733069101.0303714, "step": 1470, "value": 0.3437725305557251}, {"wallTime": 1733069109.9061897, "step": 1480, "value": 0.3089768588542938}, {"wallTime": 1733069119.1186037, "step": 1490, "value": 0.2358490377664566}, {"wallTime": 1733069128.4159114, "step": 1500, "value": 0.3241496682167053}, {"wallTime": 1733069137.6065598, "step": 1510, "value": 0.4528183341026306}, {"wallTime": 1733069150.5432334, "step": 1520, "value": 0.4051559865474701}, {"wallTime": 1733069159.7567942, "step": 1530, "value": 0.44571027159690857}, {"wallTime": 1733069168.1699963, "step": 1540, "value": 0.216816246509552}, {"wallTime": 1733069176.84072, "step": 1550, "value": 0.4353058934211731}, {"wallTime": 1733069185.8920348, "step": 1560, "value": 0.22769632935523987}, {"wallTime": 1733069194.9236052, "step": 1570, "value": 0.3885805904865265}, {"wallTime": 1733069203.9119067, "step": 1580, "value": 0.33006465435028076}, {"wallTime": 1733069212.7152026, "step": 1590, "value": 0.263468861579895}, {"wallTime": 1733069225.533602, "step": 1600, "value": 0.29075366258621216}, {"wallTime": 1733069235.4635668, "step": 1610, "value": 0.43989819288253784}, {"wallTime": 1733069244.6291728, "step": 1620, "value": 0.49620455503463745}, {"wallTime": 1733069254.271356, "step": 1630, "value": 0.3480340838432312}, {"wallTime": 1733069263.005053, "step": 1640, "value": 0.2819541394710541}, {"wallTime": 1733069271.8664117, "step": 1650, "value": 0.4434359073638916}, {"wallTime": 1733069280.5096307, "step": 1660, "value": 0.2867530584335327}, {"wallTime": 1733069289.679457, "step": 1670, "value": 0.3747705817222595}, {"wallTime": 1733069303.608751, "step": 1680, "value": 0.4854038953781128}, {"wallTime": 1733069312.479313, "step": 1690, "value": 0.38335418701171875}, {"wallTime": 1733069321.8381593, "step": 1700, "value": 0.4736921191215515}, {"wallTime": 1733069330.3477497, "step": 1710, "value": 0.30995428562164307}, {"wallTime": 1733069339.2448454, "step": 1720, "value": 0.23857912421226501}, {"wallTime": 1733069346.8566108, "step": 1730, "value": 0.24479779601097107}, {"wallTime": 1733069355.6523678, "step": 1740, "value": 0.45650002360343933}, {"wallTime": 1733069364.511728, "step": 1750, "value": 0.36482301354408264}, {"wallTime": 1733069373.7383385, "step": 1760, "value": 0.3343430459499359}, {"wallTime": 1733069387.5407417, "step": 1770, "value": 0.3127133846282959}, {"wallTime": 1733069396.4665313, "step": 1780, "value": 0.2790461480617523}, {"wallTime": 1733069405.9960237, "step": 1790, "value": 0.2112884521484375}, {"wallTime": 1733069415.0534554, "step": 1800, "value": 0.25157755613327026}, {"wallTime": 1733069423.9072227, "step": 1810, "value": 0.21221917867660522}, {"wallTime": 1733069432.5308194, "step": 1820, "value": 0.4226941168308258}, {"wallTime": 1733069441.216833, "step": 1830, "value": 0.34483182430267334}, {"wallTime": 1733069450.086608, "step": 1840, "value": 0.24163168668746948}, {"wallTime": 1733069463.1063652, "step": 1850, "value": 0.23212715983390808}, {"wallTime": 1733069471.5723248, "step": 1860, "value": 0.2618281841278076}, {"wallTime": 1733069480.4975424, "step": 1870, "value": 0.5253908634185791}, {"wallTime": 1733069489.3842154, "step": 1880, "value": 0.43370521068573}, {"wallTime": 1733069497.9760427, "step": 1890, "value": 0.4170630872249603}, {"wallTime": 1733069506.7935472, "step": 1900, "value": 0.32104626297950745}, {"wallTime": 1733069515.823953, "step": 1910, "value": 0.24946045875549316}, {"wallTime": 1733069524.6358051, "step": 1920, "value": 0.28631356358528137}, {"wallTime": 1733069533.5413704, "step": 1930, "value": 0.22710835933685303}, {"wallTime": 1733069550.4772148, "step": 1940, "value": 0.3809865713119507}, {"wallTime": 1733069558.8270266, "step": 1950, "value": 0.2606517970561981}, {"wallTime": 1733069567.7571511, "step": 1960, "value": 0.2621597945690155}, {"wallTime": 1733069576.3444269, "step": 1970, "value": 0.26312512159347534}, {"wallTime": 1733069585.5284705, "step": 1980, "value": 0.40545445680618286}, {"wallTime": 1733069594.349483, "step": 1990, "value": 0.391737699508667}, {"wallTime": 1733069602.4008827, "step": 2000, "value": 0.5687496662139893}, {"wallTime": 1733069610.2491035, "step": 2010, "value": 0.4745218753814697}, {"wallTime": 1733069626.6860666, "step": 2020, "value": 0.4121077358722687}, {"wallTime": 1733069635.0301723, "step": 2030, "value": 0.26333311200141907}, {"wallTime": 1733069643.8217897, "step": 2040, "value": 0.25556182861328125}, {"wallTime": 1733069652.1936994, "step": 2050, "value": 0.29724037647247314}, {"wallTime": 1733069660.4526672, "step": 2060, "value": 0.42416518926620483}, {"wallTime": 1733069669.5912993, "step": 2070, "value": 0.3400903344154358}, {"wallTime": 1733069678.7775397, "step": 2080, "value": 0.5227065682411194}, {"wallTime": 1733069686.944017, "step": 2090, "value": 0.40922194719314575}, {"wallTime": 1733069700.6012406, "step": 2100, "value": 0.33654457330703735}, {"wallTime": 1733069708.725552, "step": 2110, "value": 0.24050243198871613}, {"wallTime": 1733069717.447479, "step": 2120, "value": 0.2970271706581116}, {"wallTime": 1733069726.1404083, "step": 2130, "value": 0.30967020988464355}, {"wallTime": 1733069735.0373056, "step": 2140, "value": 0.33258646726608276}, {"wallTime": 1733069743.305292, "step": 2150, "value": 0.28669992089271545}, {"wallTime": 1733069752.5000453, "step": 2160, "value": 0.3240414261817932}, {"wallTime": 1733069761.4501736, "step": 2170, "value": 0.31197136640548706}, {"wallTime": 1733069770.4323776, "step": 2180, "value": 0.4010736346244812}, {"wallTime": 1733069784.362545, "step": 2190, "value": 0.3743491768836975}, {"wallTime": 1733069793.1216035, "step": 2200, "value": 0.17580874264240265}, {"wallTime": 1733069801.635301, "step": 2210, "value": 0.2949588894844055}, {"wallTime": 1733069810.6070182, "step": 2220, "value": 0.40874820947647095}, {"wallTime": 1733069819.3409674, "step": 2230, "value": 0.2720048129558563}, {"wallTime": 1733069827.325264, "step": 2240, "value": 0.3869110941886902}, {"wallTime": 1733069835.8669055, "step": 2250, "value": 0.28209325671195984}, {"wallTime": 1733069844.2349935, "step": 2260, "value": 0.31651076674461365}, {"wallTime": 1733069856.7482858, "step": 2270, "value": 0.27006796002388}, {"wallTime": 1733069865.256722, "step": 2280, "value": 0.22300079464912415}, {"wallTime": 1733069874.004318, "step": 2290, "value": 0.2032393217086792}, {"wallTime": 1733069881.7807329, "step": 2300, "value": 0.37630948424339294}, {"wallTime": 1733069890.412817, "step": 2310, "value": 0.2611210346221924}, {"wallTime": 1733069898.8756592, "step": 2320, "value": 0.26967400312423706}, {"wallTime": 1733069908.3167417, "step": 2330, "value": 0.2794879972934723}, {"wallTime": 1733069917.4141853, "step": 2340, "value": 0.3711758852005005}, {"wallTime": 1733069925.8494346, "step": 2350, "value": 0.23281677067279816}, {"wallTime": 1733069938.7010658, "step": 2360, "value": 0.34569859504699707}, {"wallTime": 1733069947.42513, "step": 2370, "value": 0.3815654516220093}, {"wallTime": 1733069956.2050066, "step": 2380, "value": 0.40013328194618225}, {"wallTime": 1733069964.273688, "step": 2390, "value": 0.3009762167930603}, {"wallTime": 1733069973.325067, "step": 2400, "value": 0.23618318140506744}, {"wallTime": 1733069981.431107, "step": 2410, "value": 0.25781920552253723}, {"wallTime": 1733069990.138585, "step": 2420, "value": 0.2804896831512451}, {"wallTime": 1733069998.796732, "step": 2430, "value": 0.3096417784690857}, {"wallTime": 1733070012.4547076, "step": 2440, "value": 0.2680822014808655}, {"wallTime": 1733070021.597909, "step": 2450, "value": 0.2500194013118744}, {"wallTime": 1733070030.189899, "step": 2460, "value": 0.26731956005096436}, {"wallTime": 1733070039.2182293, "step": 2470, "value": 0.29155153036117554}, {"wallTime": 1733070048.2678554, "step": 2480, "value": 0.35575851798057556}, {"wallTime": 1733070056.1546338, "step": 2490, "value": 0.38689637184143066}, {"wallTime": 1733070064.4495323, "step": 2500, "value": 0.3611241281032562}, {"wallTime": 1733070072.5487046, "step": 2510, "value": 0.25846508145332336}, {"wallTime": 1733070087.6557918, "step": 2520, "value": 0.2905800938606262}, {"wallTime": 1733070095.4405785, "step": 2530, "value": 0.26748543977737427}, {"wallTime": 1733070103.7677455, "step": 2540, "value": 0.2421325445175171}, {"wallTime": 1733070113.0480113, "step": 2550, "value": 0.24638675153255463}, {"wallTime": 1733070121.03666, "step": 2560, "value": 0.2530367374420166}, {"wallTime": 1733070129.5832226, "step": 2570, "value": 0.3044984042644501}, {"wallTime": 1733070138.3595543, "step": 2580, "value": 0.2689952254295349}, {"wallTime": 1733070147.0861657, "step": 2590, "value": 0.35555940866470337}, {"wallTime": 1733070155.4858844, "step": 2600, "value": 0.4434005916118622}, {"wallTime": 1733070172.576159, "step": 2610, "value": 0.30705684423446655}, {"wallTime": 1733070181.210124, "step": 2620, "value": 0.32751020789146423}, {"wallTime": 1733070189.6912377, "step": 2630, "value": 0.2794531583786011}, {"wallTime": 1733070198.398013, "step": 2640, "value": 0.2756296694278717}, {"wallTime": 1733070206.7062523, "step": 2650, "value": 0.2280011624097824}, {"wallTime": 1733070215.5985897, "step": 2660, "value": 0.3281676769256592}, {"wallTime": 1733070224.314401, "step": 2670, "value": 0.3295283317565918}, {"wallTime": 1733070233.5382462, "step": 2680, "value": 0.28269094228744507}, {"wallTime": 1733070246.7570086, "step": 2690, "value": 0.2615332305431366}, {"wallTime": 1733070256.0277228, "step": 2700, "value": 0.4047757387161255}, {"wallTime": 1733070264.949661, "step": 2710, "value": 0.2585155665874481}, {"wallTime": 1733070273.8035927, "step": 2720, "value": 0.34368836879730225}, {"wallTime": 1733070282.95797, "step": 2730, "value": 0.3033960461616516}, {"wallTime": 1733070292.2768037, "step": 2740, "value": 0.2940215468406677}, {"wallTime": 1733070300.335658, "step": 2750, "value": 0.28063255548477173}, {"wallTime": 1733070309.4110365, "step": 2760, "value": 0.42558038234710693}, {"wallTime": 1733070317.5303812, "step": 2770, "value": 0.39837318658828735}, {"wallTime": 1733070330.4350314, "step": 2780, "value": 0.3288991451263428}, {"wallTime": 1733070339.8215811, "step": 2790, "value": 0.27204635739326477}, {"wallTime": 1733070347.9919682, "step": 2800, "value": 0.202159583568573}, {"wallTime": 1733070356.890365, "step": 2810, "value": 0.30086851119995117}, {"wallTime": 1733070365.5757802, "step": 2820, "value": 0.2692415416240692}, {"wallTime": 1733070374.391858, "step": 2830, "value": 0.27079927921295166}, {"wallTime": 1733070382.4259129, "step": 2840, "value": 0.3484240472316742}, {"wallTime": 1733070390.9402826, "step": 2850, "value": 0.24085989594459534}, {"wallTime": 1733070406.6776347, "step": 2860, "value": 0.2537462115287781}, {"wallTime": 1733070415.088413, "step": 2870, "value": 0.24046830832958221}, {"wallTime": 1733070422.9189322, "step": 2880, "value": 0.24224495887756348}, {"wallTime": 1733070431.5362887, "step": 2890, "value": 0.25497573614120483}, {"wallTime": 1733070439.979799, "step": 2900, "value": 0.32631194591522217}, {"wallTime": 1733070448.08447, "step": 2910, "value": 0.41492339968681335}, {"wallTime": 1733070457.4226959, "step": 2920, "value": 0.44631239771842957}, {"wallTime": 1733070466.7217877, "step": 2930, "value": 0.37758931517601013}, {"wallTime": 1733070479.3314598, "step": 2940, "value": 0.31115227937698364}, {"wallTime": 1733070488.7810624, "step": 2950, "value": 0.2949567437171936}, {"wallTime": 1733070497.2237914, "step": 2960, "value": 0.3751062750816345}, {"wallTime": 1733070505.6327722, "step": 2970, "value": 0.23950068652629852}, {"wallTime": 1733070513.352839, "step": 2980, "value": 0.2049940973520279}, {"wallTime": 1733070522.3000762, "step": 2990, "value": 0.3608936369419098}, {"wallTime": 1733070530.211616, "step": 3000, "value": 0.21556004881858826}, {"wallTime": 1733070538.298934, "step": 3010, "value": 0.30721399188041687}, {"wallTime": 1733070547.399209, "step": 3020, "value": 0.24632440507411957}, {"wallTime": 1733070564.0496798, "step": 3030, "value": 0.24446994066238403}, {"wallTime": 1733070572.368584, "step": 3040, "value": 0.2386486679315567}, {"wallTime": 1733070580.6697586, "step": 3050, "value": 0.28060200810432434}, {"wallTime": 1733070588.6520977, "step": 3060, "value": 0.27665573358535767}, {"wallTime": 1733070597.4195485, "step": 3070, "value": 0.237308070063591}, {"wallTime": 1733070606.136062, "step": 3080, "value": 0.3798118829727173}, {"wallTime": 1733070614.4382658, "step": 3090, "value": 0.34705352783203125}, {"wallTime": 1733070623.9987006, "step": 3100, "value": 0.28690728545188904}, {"wallTime": 1733070637.250895, "step": 3110, "value": 0.3435799181461334}, {"wallTime": 1733070645.6808164, "step": 3120, "value": 0.29399749636650085}, {"wallTime": 1733070654.2684114, "step": 3130, "value": 0.23711411654949188}, {"wallTime": 1733070663.3191843, "step": 3140, "value": 0.2600477337837219}, {"wallTime": 1733070671.1160235, "step": 3150, "value": 0.3457270860671997}, {"wallTime": 1733070679.7634716, "step": 3160, "value": 0.3805222511291504}, {"wallTime": 1733070687.8430488, "step": 3170, "value": 0.2561882734298706}, {"wallTime": 1733070695.8538015, "step": 3180, "value": 0.3203037977218628}, {"wallTime": 1733070704.6203842, "step": 3190, "value": 0.261731892824173}, {"wallTime": 1733070717.106798, "step": 3200, "value": 0.20186764001846313}, {"wallTime": 1733070726.0966, "step": 3210, "value": 0.30174675583839417}, {"wallTime": 1733070734.7743816, "step": 3220, "value": 0.20112904906272888}, {"wallTime": 1733070744.4100983, "step": 3230, "value": 0.2906712293624878}, {"wallTime": 1733070752.499534, "step": 3240, "value": 0.44541245698928833}, {"wallTime": 1733070761.719072, "step": 3250, "value": 0.3842417001724243}, {"wallTime": 1733070770.3744962, "step": 3260, "value": 0.27350443601608276}, {"wallTime": 1733070779.7280002, "step": 3270, "value": 0.26565617322921753}, {"wallTime": 1733070793.6762228, "step": 3280, "value": 0.24219870567321777}, {"wallTime": 1733070801.8980043, "step": 3290, "value": 0.3862617015838623}, {"wallTime": 1733070810.1590214, "step": 3300, "value": 0.34962165355682373}, {"wallTime": 1733070818.7243996, "step": 3310, "value": 0.18415488302707672}, {"wallTime": 1733070827.0045838, "step": 3320, "value": 0.23179902136325836}, {"wallTime": 1733070835.5720425, "step": 3330, "value": 0.2751447856426239}, {"wallTime": 1733070843.972133, "step": 3340, "value": 0.4181686043739319}, {"wallTime": 1733070853.0895362, "step": 3350, "value": 0.32541316747665405}, {"wallTime": 1733070865.4174273, "step": 3360, "value": 0.212095245718956}, {"wallTime": 1733070873.6596124, "step": 3370, "value": 0.2586127817630768}, {"wallTime": 1733070883.3340003, "step": 3380, "value": 0.24597613513469696}, {"wallTime": 1733070892.375014, "step": 3390, "value": 0.27487897872924805}, {"wallTime": 1733070900.7203708, "step": 3400, "value": 0.3110654652118683}, {"wallTime": 1733070908.5021846, "step": 3410, "value": 0.2792987525463104}, {"wallTime": 1733070916.653801, "step": 3420, "value": 0.3782356381416321}, {"wallTime": 1733070925.2064297, "step": 3430, "value": 0.26535555720329285}, {"wallTime": 1733070933.8082833, "step": 3440, "value": 0.21285010874271393}, {"wallTime": 1733070947.4777675, "step": 3450, "value": 0.23928003013134003}, {"wallTime": 1733070956.1852095, "step": 3460, "value": 0.25349679589271545}, {"wallTime": 1733070964.2643065, "step": 3470, "value": 0.2868552803993225}, {"wallTime": 1733070972.3841012, "step": 3480, "value": 0.2707337737083435}, {"wallTime": 1733070980.645124, "step": 3490, "value": 0.45967531204223633}, {"wallTime": 1733070989.6857321, "step": 3500, "value": 0.24456247687339783}, {"wallTime": 1733070997.7865353, "step": 3510, "value": 0.2392851561307907}, {"wallTime": 1733071006.2694044, "step": 3520, "value": 0.3340023159980774}, {"wallTime": 1733071018.8940747, "step": 3530, "value": 0.2450154423713684}, {"wallTime": 1733071027.1951632, "step": 3540, "value": 0.17350637912750244}, {"wallTime": 1733071035.3185647, "step": 3550, "value": 0.26627397537231445}, {"wallTime": 1733071043.7437828, "step": 3560, "value": 0.2445414960384369}, {"wallTime": 1733071051.87021, "step": 3570, "value": 0.29402029514312744}, {"wallTime": 1733071060.4941876, "step": 3580, "value": 0.25586339831352234}, {"wallTime": 1733071068.8774812, "step": 3590, "value": 0.2590298354625702}, {"wallTime": 1733071077.7110364, "step": 3600, "value": 0.28888270258903503}, {"wallTime": 1733071086.2104306, "step": 3610, "value": 0.2204848825931549}, {"wallTime": 1733071101.6567943, "step": 3620, "value": 0.24139323830604553}, {"wallTime": 1733071109.6182566, "step": 3630, "value": 0.2834835946559906}, {"wallTime": 1733071118.1273794, "step": 3640, "value": 0.2618028223514557}, {"wallTime": 1733071126.9912868, "step": 3650, "value": 0.21871423721313477}, {"wallTime": 1733071135.82554, "step": 3660, "value": 0.31898385286331177}, {"wallTime": 1733071144.2463384, "step": 3670, "value": 0.22520232200622559}, {"wallTime": 1733071152.9626358, "step": 3680, "value": 0.2410758137702942}, {"wallTime": 1733071160.6015842, "step": 3690, "value": 0.2605060040950775}, {"wallTime": 1733071173.7483897, "step": 3700, "value": 0.26941728591918945}, {"wallTime": 1733071182.8814178, "step": 3710, "value": 0.2704717516899109}, {"wallTime": 1733071191.2082202, "step": 3720, "value": 0.3125172257423401}, {"wallTime": 1733071200.3316119, "step": 3730, "value": 0.5771499276161194}, {"wallTime": 1733071208.3638816, "step": 3740, "value": 0.2882648706436157}, {"wallTime": 1733071216.570064, "step": 3750, "value": 0.20952999591827393}, {"wallTime": 1733071224.66009, "step": 3760, "value": 0.1769704818725586}, {"wallTime": 1733071232.8588214, "step": 3770, "value": 0.16606540977954865}, {"wallTime": 1733071248.531547, "step": 3780, "value": 0.36004918813705444}, {"wallTime": 1733071257.3899632, "step": 3790, "value": 0.432510644197464}, {"wallTime": 1733071265.5655572, "step": 3800, "value": 0.19420740008354187}, {"wallTime": 1733071274.1769469, "step": 3810, "value": 0.31207358837127686}, {"wallTime": 1733071283.0161905, "step": 3820, "value": 0.23840633034706116}, {"wallTime": 1733071291.7280297, "step": 3830, "value": 0.1807093620300293}, {"wallTime": 1733071299.890521, "step": 3840, "value": 0.21664603054523468}, {"wallTime": 1733071308.4776073, "step": 3850, "value": 0.2840419411659241}, {"wallTime": 1733071316.9497538, "step": 3860, "value": 0.31452086567878723}, {"wallTime": 1733071330.2133067, "step": 3870, "value": 0.2255793660879135}, {"wallTime": 1733071338.9872713, "step": 3880, "value": 0.24702110886573792}, {"wallTime": 1733071347.7352297, "step": 3890, "value": 0.2168770730495453}, {"wallTime": 1733071357.0328102, "step": 3900, "value": 0.21633075177669525}, {"wallTime": 1733071365.2238894, "step": 3910, "value": 0.3044799268245697}, {"wallTime": 1733071374.133173, "step": 3920, "value": 0.4654408097267151}, {"wallTime": 1733071382.8123693, "step": 3930, "value": 0.303838849067688}, {"wallTime": 1733071391.5669978, "step": 3940, "value": 0.2600650191307068}, {"wallTime": 1733071404.4657772, "step": 3950, "value": 0.23404958844184875}, {"wallTime": 1733071412.3374197, "step": 3960, "value": 0.2615945339202881}, {"wallTime": 1733071421.156133, "step": 3970, "value": 0.2828347980976105}, {"wallTime": 1733071430.119099, "step": 3980, "value": 0.19845709204673767}, {"wallTime": 1733071438.4125428, "step": 3990, "value": 0.3672470152378082}, {"wallTime": 1733071447.7274058, "step": 4000, "value": 0.3526824116706848}, {"wallTime": 1733071456.1951952, "step": 4010, "value": 0.29982295632362366}, {"wallTime": 1733071464.7480536, "step": 4020, "value": 0.2536662817001343}, {"wallTime": 1733071473.3954458, "step": 4030, "value": 0.3348757326602936}, {"wallTime": 1733071490.2850473, "step": 4040, "value": 0.24976420402526855}, {"wallTime": 1733071498.710359, "step": 4050, "value": 0.2387746274471283}, {"wallTime": 1733071507.0959706, "step": 4060, "value": 0.19913329184055328}, {"wallTime": 1733071515.0664582, "step": 4070, "value": 0.28109002113342285}, {"wallTime": 1733071523.8799205, "step": 4080, "value": 0.26850730180740356}, {"wallTime": 1733071532.284021, "step": 4090, "value": 0.2052282691001892}, {"wallTime": 1733071540.916459, "step": 4100, "value": 0.21994063258171082}, {"wallTime": 1733071549.175013, "step": 4110, "value": 0.1861858069896698}, {"wallTime": 1733071565.8348641, "step": 4120, "value": 0.22651790082454681}, {"wallTime": 1733071573.6305807, "step": 4130, "value": 0.1605025678873062}, {"wallTime": 1733071582.0952113, "step": 4140, "value": 0.4215356707572937}, {"wallTime": 1733071590.0216293, "step": 4150, "value": 0.17255523800849915}, {"wallTime": 1733071599.2400439, "step": 4160, "value": 0.7184069156646729}, {"wallTime": 1733071608.070792, "step": 4170, "value": 0.24630174040794373}, {"wallTime": 1733071616.1829493, "step": 4180, "value": 0.3134201169013977}, {"wallTime": 1733071626.0820215, "step": 4190, "value": 0.16674000024795532}, {"wallTime": 1733071641.0070424, "step": 4200, "value": 0.2480529099702835}, {"wallTime": 1733071649.0399718, "step": 4210, "value": 0.20846307277679443}, {"wallTime": 1733071658.5307467, "step": 4220, "value": 0.2858808934688568}, {"wallTime": 1733071667.9654257, "step": 4230, "value": 0.3209381103515625}, {"wallTime": 1733071676.1080992, "step": 4240, "value": 0.2180260568857193}, {"wallTime": 1733071684.3778768, "step": 4250, "value": 0.32464489340782166}, {"wallTime": 1733071693.109036, "step": 4260, "value": 0.2867177724838257}, {"wallTime": 1733071702.1832867, "step": 4270, "value": 0.2156117707490921}, {"wallTime": 1733071710.629444, "step": 4280, "value": 0.3226984739303589}, {"wallTime": 1733071726.676101, "step": 4290, "value": 0.2688528001308441}, {"wallTime": 1733071735.2149658, "step": 4300, "value": 0.27491432428359985}, {"wallTime": 1733071742.9564936, "step": 4310, "value": 0.2663354277610779}, {"wallTime": 1733071751.585145, "step": 4320, "value": 0.4276221692562103}, {"wallTime": 1733071760.034014, "step": 4330, "value": 0.2773808240890503}, {"wallTime": 1733071768.4307375, "step": 4340, "value": 0.18837757408618927}, {"wallTime": 1733071777.4015229, "step": 4350, "value": 0.2957301735877991}, {"wallTime": 1733071785.5467556, "step": 4360, "value": 0.28016233444213867}, {"wallTime": 1733071800.884174, "step": 4370, "value": 0.3662753701210022}, {"wallTime": 1733071809.2652805, "step": 4380, "value": 0.2515196204185486}, {"wallTime": 1733071817.3458242, "step": 4390, "value": 0.20075155794620514}, {"wallTime": 1733071826.4298139, "step": 4400, "value": 0.3029239773750305}, {"wallTime": 1733071834.8870301, "step": 4410, "value": 0.30059733986854553}, {"wallTime": 1733071843.4462872, "step": 4420, "value": 0.2640131711959839}, {"wallTime": 1733071851.5954375, "step": 4430, "value": 0.24758747220039368}, {"wallTime": 1733071859.923484, "step": 4440, "value": 0.25758281350135803}, {"wallTime": 1733071868.6726837, "step": 4450, "value": 0.25191035866737366}, {"wallTime": 1733071881.335574, "step": 4460, "value": 0.23111382126808167}, {"wallTime": 1733071889.635708, "step": 4470, "value": 0.24771274626255035}, {"wallTime": 1733071898.4202213, "step": 4480, "value": 0.2720257043838501}, {"wallTime": 1733071907.335407, "step": 4490, "value": 0.23682324588298798}, {"wallTime": 1733071916.2775428, "step": 4500, "value": 0.33237990736961365}, {"wallTime": 1733071925.3481383, "step": 4510, "value": 0.3687223792076111}, {"wallTime": 1733071933.3287206, "step": 4520, "value": 0.16320756077766418}, {"wallTime": 1733071941.4820688, "step": 4530, "value": 0.1645769327878952}, {"wallTime": 1733071954.168361, "step": 4540, "value": 0.2312535047531128}, {"wallTime": 1733071962.395163, "step": 4550, "value": 0.19578085839748383}, {"wallTime": 1733071970.5127428, "step": 4560, "value": 0.27493321895599365}, {"wallTime": 1733071978.8692746, "step": 4570, "value": 0.37229084968566895}, {"wallTime": 1733071987.7098505, "step": 4580, "value": 0.304801881313324}, {"wallTime": 1733071996.4436948, "step": 4590, "value": 0.38777682185173035}, {"wallTime": 1733072004.475269, "step": 4600, "value": 0.19565002620220184}, {"wallTime": 1733072012.744021, "step": 4610, "value": 0.18485845625400543}, {"wallTime": 1733072025.399418, "step": 4620, "value": 0.20455896854400635}, {"wallTime": 1733072034.1174147, "step": 4630, "value": 0.19635535776615143}, {"wallTime": 1733072043.036541, "step": 4640, "value": 0.31436648964881897}, {"wallTime": 1733072051.7837896, "step": 4650, "value": 0.2507314383983612}, {"wallTime": 1733072060.1072443, "step": 4660, "value": 0.2509142756462097}, {"wallTime": 1733072068.601953, "step": 4670, "value": 0.2727836072444916}, {"wallTime": 1733072076.8353865, "step": 4680, "value": 0.2750786542892456}, {"wallTime": 1733072085.3748581, "step": 4690, "value": 0.2802862524986267}, {"wallTime": 1733072093.7472901, "step": 4700, "value": 0.211542546749115}, {"wallTime": 1733072106.9884002, "step": 4710, "value": 0.2604275643825531}, {"wallTime": 1733072115.6638722, "step": 4720, "value": 0.41867461800575256}, {"wallTime": 1733072123.9492638, "step": 4730, "value": 0.3287646770477295}, {"wallTime": 1733072132.2793076, "step": 4740, "value": 0.23287394642829895}, {"wallTime": 1733072140.4191864, "step": 4750, "value": 0.20396441221237183}, {"wallTime": 1733072149.085863, "step": 4760, "value": 0.21819257736206055}, {"wallTime": 1733072157.4104269, "step": 4770, "value": 0.24585458636283875}, {"wallTime": 1733072165.4880474, "step": 4780, "value": 0.27262675762176514}, {"wallTime": 1733072179.646874, "step": 4790, "value": 0.25507912039756775}, {"wallTime": 1733072188.3283844, "step": 4800, "value": 0.2054412066936493}, {"wallTime": 1733072196.8456357, "step": 4810, "value": 0.2586930990219116}, {"wallTime": 1733072204.560948, "step": 4820, "value": 0.20839855074882507}, {"wallTime": 1733072213.0983133, "step": 4830, "value": 0.3502224087715149}, {"wallTime": 1733072221.665711, "step": 4840, "value": 0.27070876955986023}, {"wallTime": 1733072229.8926413, "step": 4850, "value": 0.21344824135303497}, {"wallTime": 1733072238.0548773, "step": 4860, "value": 0.24322548508644104}, {"wallTime": 1733072246.3422391, "step": 4870, "value": 0.19846269488334656}, {"wallTime": 1733072261.2660425, "step": 4880, "value": 0.2300432026386261}, {"wallTime": 1733072269.8509219, "step": 4890, "value": 0.22788771986961365}, {"wallTime": 1733072278.8601272, "step": 4900, "value": 0.28785207867622375}, {"wallTime": 1733072287.533269, "step": 4910, "value": 0.20343998074531555}, {"wallTime": 1733072295.9459817, "step": 4920, "value": 0.17714160680770874}, {"wallTime": 1733072304.354179, "step": 4930, "value": 0.2741086781024933}, {"wallTime": 1733072313.5086236, "step": 4940, "value": 0.2702614963054657}, {"wallTime": 1733072321.324178, "step": 4950, "value": 0.19673404097557068}, {"wallTime": 1733072337.0237617, "step": 4960, "value": 0.17034845054149628}, {"wallTime": 1733072345.5299854, "step": 4970, "value": 0.17783372104167938}, {"wallTime": 1733072353.4286969, "step": 4980, "value": 0.22181294858455658}, {"wallTime": 1733072362.412152, "step": 4990, "value": 0.25329291820526123}, {"wallTime": 1733072371.744865, "step": 5000, "value": 0.23740485310554504}, {"wallTime": 1733072380.5286257, "step": 5010, "value": 0.2896537184715271}, {"wallTime": 1733072389.0253797, "step": 5020, "value": 0.3022981286048889}, {"wallTime": 1733072397.7844532, "step": 5030, "value": 0.19858035445213318}, {"wallTime": 1733072411.2972596, "step": 5040, "value": 0.2219502478837967}, {"wallTime": 1733072419.4730232, "step": 5050, "value": 0.20511449873447418}, {"wallTime": 1733072428.3711994, "step": 5060, "value": 0.2962137758731842}, {"wallTime": 1733072437.1155627, "step": 5070, "value": 0.2733853757381439}, {"wallTime": 1733072446.1741927, "step": 5080, "value": 0.28899097442626953}, {"wallTime": 1733072454.427389, "step": 5090, "value": 0.20384249091148376}, {"wallTime": 1733072462.4094512, "step": 5100, "value": 0.2552222013473511}, {"wallTime": 1733072471.1489592, "step": 5110, "value": 0.22549378871917725}, {"wallTime": 1733072478.945521, "step": 5120, "value": 0.294676810503006}, {"wallTime": 1733072491.320611, "step": 5130, "value": 0.3287197947502136}, {"wallTime": 1733072499.2577047, "step": 5140, "value": 0.17224666476249695}, {"wallTime": 1733072507.1110868, "step": 5150, "value": 0.22596141695976257}, {"wallTime": 1733072515.3161805, "step": 5160, "value": 0.628381073474884}, {"wallTime": 1733072523.4987671, "step": 5170, "value": 0.2764323949813843}, {"wallTime": 1733072531.0862172, "step": 5180, "value": 0.1781214475631714}, {"wallTime": 1733072540.0205183, "step": 5190, "value": 0.23643793165683746}, {"wallTime": 1733072548.6507845, "step": 5200, "value": 0.2676719129085541}, {"wallTime": 1733072561.4138951, "step": 5210, "value": 0.21435049176216125}, {"wallTime": 1733072569.8949373, "step": 5220, "value": 0.286693274974823}, {"wallTime": 1733072578.6775794, "step": 5230, "value": 0.26667115092277527}, {"wallTime": 1733072586.9408581, "step": 5240, "value": 0.27903687953948975}, {"wallTime": 1733072595.03328, "step": 5250, "value": 0.34701016545295715}, {"wallTime": 1733072603.1724052, "step": 5260, "value": 0.25431153178215027}, {"wallTime": 1733072611.0787382, "step": 5270, "value": 0.28964805603027344}, {"wallTime": 1733072619.9537225, "step": 5280, "value": 0.24859899282455444}, {"wallTime": 1733072628.6335495, "step": 5290, "value": 0.2514697313308716}, {"wallTime": 1733072641.37446, "step": 5300, "value": 0.22973474860191345}, {"wallTime": 1733072649.8567631, "step": 5310, "value": 0.16836220026016235}, {"wallTime": 1733072657.9702768, "step": 5320, "value": 0.1895466148853302}, {"wallTime": 1733072667.0284708, "step": 5330, "value": 0.29877346754074097}, {"wallTime": 1733072675.9419637, "step": 5340, "value": 0.2449677586555481}, {"wallTime": 1733072684.2374065, "step": 5350, "value": 0.37028875946998596}, {"wallTime": 1733072691.8571007, "step": 5360, "value": 0.25098299980163574}, {"wallTime": 1733072700.1469674, "step": 5370, "value": 0.19173797965049744}, {"wallTime": 1733072713.181961, "step": 5380, "value": 0.19789166748523712}, {"wallTime": 1733072721.0236871, "step": 5390, "value": 0.1784832626581192}, {"wallTime": 1733072729.8759294, "step": 5400, "value": 0.23331129550933838}, {"wallTime": 1733072738.3681037, "step": 5410, "value": 0.18557943403720856}, {"wallTime": 1733072746.3816009, "step": 5420, "value": 0.2555431127548218}, {"wallTime": 1733072754.6166127, "step": 5430, "value": 0.3168013095855713}, {"wallTime": 1733072762.545535, "step": 5440, "value": 0.19221118092536926}, {"wallTime": 1733072771.3595972, "step": 5450, "value": 0.25191164016723633}, {"wallTime": 1733072787.150635, "step": 5460, "value": 0.18856263160705566}, {"wallTime": 1733072795.8014264, "step": 5470, "value": 0.2536069452762604}, {"wallTime": 1733072804.24097, "step": 5480, "value": 0.16869139671325684}, {"wallTime": 1733072812.3720632, "step": 5490, "value": 0.26680684089660645}, {"wallTime": 1733072821.1581783, "step": 5500, "value": 0.28903326392173767}, {"wallTime": 1733072830.0215125, "step": 5510, "value": 0.29150134325027466}, {"wallTime": 1733072838.6940832, "step": 5520, "value": 0.21303720772266388}, {"wallTime": 1733072846.9039302, "step": 5530, "value": 0.17867624759674072}, {"wallTime": 1733072855.24483, "step": 5540, "value": 0.1958361268043518}, {"wallTime": 1733072870.6429517, "step": 5550, "value": 0.2919183671474457}, {"wallTime": 1733072878.7277668, "step": 5560, "value": 0.2765602767467499}, {"wallTime": 1733072886.6091535, "step": 5570, "value": 0.23573042452335358}, {"wallTime": 1733072895.0196762, "step": 5580, "value": 0.8622426986694336}, {"wallTime": 1733072903.4016914, "step": 5590, "value": 0.21274538338184357}, {"wallTime": 1733072911.208734, "step": 5600, "value": 0.308613121509552}, {"wallTime": 1733072919.8386302, "step": 5610, "value": 0.26272550225257874}, {"wallTime": 1733072928.7317626, "step": 5620, "value": 0.37563556432724}, {"wallTime": 1733072941.7023964, "step": 5630, "value": 0.2071753740310669}, {"wallTime": 1733072949.9786806, "step": 5640, "value": 0.2370111346244812}, {"wallTime": 1733072958.717973, "step": 5650, "value": 0.335493803024292}, {"wallTime": 1733072966.8127408, "step": 5660, "value": 0.20732833445072174}, {"wallTime": 1733072974.9601035, "step": 5670, "value": 0.18430086970329285}, {"wallTime": 1733072983.5606737, "step": 5680, "value": 0.23510487377643585}, {"wallTime": 1733072992.2266145, "step": 5690, "value": 0.2551812529563904}, {"wallTime": 1733073000.815789, "step": 5700, "value": 0.1987333446741104}, {"wallTime": 1733073009.7820034, "step": 5710, "value": 0.24467824399471283}, {"wallTime": 1733073022.8669167, "step": 5720, "value": 0.3679131865501404}, {"wallTime": 1733073031.5325873, "step": 5730, "value": 0.31043103337287903}, {"wallTime": 1733073039.569001, "step": 5740, "value": 0.2538304328918457}, {"wallTime": 1733073047.841675, "step": 5750, "value": 0.24088671803474426}, {"wallTime": 1733073056.155277, "step": 5760, "value": 0.18610236048698425}, {"wallTime": 1733073064.9538307, "step": 5770, "value": 0.34356918931007385}, {"wallTime": 1733073073.8364305, "step": 5780, "value": 0.23649674654006958}, {"wallTime": 1733073082.7238746, "step": 5790, "value": 0.3243183493614197}, {"wallTime": 1733073095.1017458, "step": 5800, "value": 0.22336602210998535}, {"wallTime": 1733073103.314541, "step": 5810, "value": 0.2492346465587616}, {"wallTime": 1733073111.9694676, "step": 5820, "value": 0.16644074022769928}, {"wallTime": 1733073120.3542564, "step": 5830, "value": 0.3093385398387909}, {"wallTime": 1733073128.2080271, "step": 5840, "value": 0.20541730523109436}, {"wallTime": 1733073136.7145264, "step": 5850, "value": 0.1715971827507019}, {"wallTime": 1733073144.9266415, "step": 5860, "value": 0.2566470801830292}, {"wallTime": 1733073153.0395384, "step": 5870, "value": 0.16168303787708282}, {"wallTime": 1733073166.0015597, "step": 5880, "value": 0.19633547961711884}, {"wallTime": 1733073174.657835, "step": 5890, "value": 0.15651963651180267}, {"wallTime": 1733073182.507147, "step": 5900, "value": 0.22512361407279968}, {"wallTime": 1733073191.558418, "step": 5910, "value": 0.18799139559268951}, {"wallTime": 1733073199.4095175, "step": 5920, "value": 0.11206135898828506}, {"wallTime": 1733073207.4643714, "step": 5930, "value": 0.2321678251028061}, {"wallTime": 1733073215.601694, "step": 5940, "value": 0.2097003161907196}, {"wallTime": 1733073224.3570313, "step": 5950, "value": 0.20512117445468903}, {"wallTime": 1733073232.8756733, "step": 5960, "value": 0.2869638204574585}, {"wallTime": 1733073245.3726742, "step": 5970, "value": 0.20909787714481354}, {"wallTime": 1733073253.178511, "step": 5980, "value": 0.25173434615135193}, {"wallTime": 1733073261.7714312, "step": 5990, "value": 0.21697759628295898}, {"wallTime": 1733073270.0588303, "step": 6000, "value": 0.21919624507427216}, {"wallTime": 1733073278.8944218, "step": 6010, "value": 0.3716188371181488}, {"wallTime": 1733073287.6811984, "step": 6020, "value": 0.25819283723831177}, {"wallTime": 1733073297.2735188, "step": 6030, "value": 0.38709312677383423}, {"wallTime": 1733073305.917279, "step": 6040, "value": 0.3028542399406433}, {"wallTime": 1733073322.3538096, "step": 6050, "value": 0.22601288557052612}, {"wallTime": 1733073331.9763331, "step": 6060, "value": 0.16163495182991028}, {"wallTime": 1733073340.5212445, "step": 6070, "value": 0.18855586647987366}, {"wallTime": 1733073349.6011126, "step": 6080, "value": 0.3071572780609131}, {"wallTime": 1733073359.070268, "step": 6090, "value": 0.19058653712272644}, {"wallTime": 1733073368.4019985, "step": 6100, "value": 0.23064620792865753}, {"wallTime": 1733073377.6740928, "step": 6110, "value": 0.2446454018354416}, {"wallTime": 1733073386.3994048, "step": 6120, "value": 0.1682586371898651}, {"wallTime": 1733073395.4505796, "step": 6130, "value": 0.23480214178562164}, {"wallTime": 1733073408.1503794, "step": 6140, "value": 0.15452055633068085}, {"wallTime": 1733073417.3228025, "step": 6150, "value": 0.1936877965927124}, {"wallTime": 1733073426.2550466, "step": 6160, "value": 0.19695468246936798}, {"wallTime": 1733073434.80837, "step": 6170, "value": 0.17115342617034912}, {"wallTime": 1733073444.511771, "step": 6180, "value": 0.2193787395954132}, {"wallTime": 1733073453.1147697, "step": 6190, "value": 0.24677154421806335}, {"wallTime": 1733073462.5645998, "step": 6200, "value": 0.16222819685935974}, {"wallTime": 1733073472.0234096, "step": 6210, "value": 0.24052263796329498}, {"wallTime": 1733073484.4473004, "step": 6220, "value": 0.20572848618030548}, {"wallTime": 1733073493.6590166, "step": 6230, "value": 0.1978212594985962}, {"wallTime": 1733073502.4402313, "step": 6240, "value": 0.21381498873233795}, {"wallTime": 1733073511.2549074, "step": 6250, "value": 0.23761531710624695}, {"wallTime": 1733073520.4840026, "step": 6260, "value": 0.19308747351169586}, {"wallTime": 1733073529.7804308, "step": 6270, "value": 0.28137892484664917}, {"wallTime": 1733073539.6381397, "step": 6280, "value": 0.23704580962657928}, {"wallTime": 1733073548.909743, "step": 6290, "value": 0.20972104370594025}, {"wallTime": 1733073560.6186926, "step": 6300, "value": 0.2711125910282135}, {"wallTime": 1733073570.0679622, "step": 6310, "value": 0.19174030423164368}, {"wallTime": 1733073579.48011, "step": 6320, "value": 0.2524770498275757}, {"wallTime": 1733073587.6662302, "step": 6330, "value": 0.19811147451400757}, {"wallTime": 1733073597.2169688, "step": 6340, "value": 0.2086515724658966}, {"wallTime": 1733073606.2371373, "step": 6350, "value": 0.1954340785741806}, {"wallTime": 1733073615.076534, "step": 6360, "value": 0.29621055722236633}, {"wallTime": 1733073624.8334882, "step": 6370, "value": 0.26005423069000244}, {"wallTime": 1733073634.6714864, "step": 6380, "value": 0.23872384428977966}, {"wallTime": 1733073646.5271995, "step": 6390, "value": 0.20670510828495026}, {"wallTime": 1733073655.7444234, "step": 6400, "value": 0.24011722207069397}, {"wallTime": 1733073665.606155, "step": 6410, "value": 0.229440838098526}, {"wallTime": 1733073674.6417534, "step": 6420, "value": 0.2883463203907013}, {"wallTime": 1733073683.6693125, "step": 6430, "value": 0.1725795567035675}, {"wallTime": 1733073692.8757744, "step": 6440, "value": 0.2598050534725189}, {"wallTime": 1733073702.5181446, "step": 6450, "value": 0.17546908557415009}, {"wallTime": 1733073712.6263406, "step": 6460, "value": 0.25899645686149597}, {"wallTime": 1733073724.045959, "step": 6470, "value": 0.3244149386882782}, {"wallTime": 1733073732.8274102, "step": 6480, "value": 0.23801548779010773}, {"wallTime": 1733073741.9561865, "step": 6490, "value": 0.21672643721103668}, {"wallTime": 1733073750.7167037, "step": 6500, "value": 0.2426186352968216}, {"wallTime": 1733073760.4871235, "step": 6510, "value": 0.1572144776582718}, {"wallTime": 1733073769.862305, "step": 6520, "value": 0.17572782933712006}, {"wallTime": 1733073779.1260598, "step": 6530, "value": 0.20290076732635498}, {"wallTime": 1733073789.4767165, "step": 6540, "value": 0.31493720412254333}, {"wallTime": 1733073798.102332, "step": 6550, "value": 0.34434974193573}, {"wallTime": 1733073810.5518794, "step": 6560, "value": 0.232750803232193}, {"wallTime": 1733073820.0353708, "step": 6570, "value": 0.21319684386253357}, {"wallTime": 1733073828.237595, "step": 6580, "value": 0.2643110156059265}, {"wallTime": 1733073836.797224, "step": 6590, "value": 0.1807798147201538}, {"wallTime": 1733073845.9865305, "step": 6600, "value": 0.22169888019561768}, {"wallTime": 1733073855.2511914, "step": 6610, "value": 0.21398842334747314}, {"wallTime": 1733073864.6927743, "step": 6620, "value": 0.1902652084827423}, {"wallTime": 1733073873.8337073, "step": 6630, "value": 0.20995186269283295}, {"wallTime": 1733073887.5237074, "step": 6640, "value": 0.26212257146835327}, {"wallTime": 1733073897.3330057, "step": 6650, "value": 0.23203076422214508}, {"wallTime": 1733073906.8758967, "step": 6660, "value": 0.2274884581565857}, {"wallTime": 1733073916.349407, "step": 6670, "value": 0.25956493616104126}, {"wallTime": 1733073925.617946, "step": 6680, "value": 0.19344209134578705}, {"wallTime": 1733073934.9159727, "step": 6690, "value": 0.18348020315170288}, {"wallTime": 1733073943.741484, "step": 6700, "value": 0.17646275460720062}, {"wallTime": 1733073952.4763129, "step": 6710, "value": 0.23715859651565552}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15075" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_aux_4%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_aux_4", "runToSeries": {".": [{"wallTime": 1733067631.5389502, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6523256, "step": 10, "value": 2.0801005363464355}, {"wallTime": 1733067660.7843292, "step": 20, "value": 1.89320969581604}, {"wallTime": 1733067674.1375692, "step": 30, "value": 1.8040618896484375}, {"wallTime": 1733067687.0572524, "step": 40, "value": 2.0341522693634033}, {"wallTime": 1733067699.493238, "step": 50, "value": 1.3018274307250977}, {"wallTime": 1733067710.6294403, "step": 60, "value": 1.628924012184143}, {"wallTime": 1733067722.755628, "step": 70, "value": 1.4019253253936768}, {"wallTime": 1733067733.725466, "step": 80, "value": 0.9432393908500671}, {"wallTime": 1733067750.9463696, "step": 90, "value": 1.2490763664245605}, {"wallTime": 1733067761.981011, "step": 100, "value": 1.1014200448989868}, {"wallTime": 1733067771.6065276, "step": 110, "value": 0.7257824540138245}, {"wallTime": 1733067780.5474925, "step": 120, "value": 0.6186822652816772}, {"wallTime": 1733067790.485484, "step": 130, "value": 0.8080881237983704}, {"wallTime": 1733067799.1057513, "step": 140, "value": 0.4334232211112976}, {"wallTime": 1733067809.4447737, "step": 150, "value": 0.643104612827301}, {"wallTime": 1733067818.920858, "step": 160, "value": 0.5931676626205444}, {"wallTime": 1733067836.6496572, "step": 170, "value": 0.4425968527793884}, {"wallTime": 1733067846.3907416, "step": 180, "value": 0.6639668345451355}, {"wallTime": 1733067855.6670036, "step": 190, "value": 0.4344026446342468}, {"wallTime": 1733067864.889986, "step": 200, "value": 0.7814996838569641}, {"wallTime": 1733067874.001948, "step": 210, "value": 0.6015284657478333}, {"wallTime": 1733067883.7862647, "step": 220, "value": 0.4047389626502991}, {"wallTime": 1733067892.1232438, "step": 230, "value": 0.510074257850647}, {"wallTime": 1733067901.069493, "step": 240, "value": 0.5014497637748718}, {"wallTime": 1733067910.0750053, "step": 250, "value": 0.4688933491706848}, {"wallTime": 1733067925.950118, "step": 260, "value": 0.7729651927947998}, {"wallTime": 1733067935.4756374, "step": 270, "value": 0.4315025806427002}, {"wallTime": 1733067944.0157077, "step": 280, "value": 0.4740438163280487}, {"wallTime": 1733067952.546771, "step": 290, "value": 0.4717753529548645}, {"wallTime": 1733067961.0268397, "step": 300, "value": 0.3265664577484131}, {"wallTime": 1733067970.1347163, "step": 310, "value": 0.5343497395515442}, {"wallTime": 1733067980.2258883, "step": 320, "value": 0.4492962062358856}, {"wallTime": 1733067988.8161669, "step": 330, "value": 0.5379629731178284}, {"wallTime": 1733068005.0907319, "step": 340, "value": 0.41427984833717346}, {"wallTime": 1733068014.0652928, "step": 350, "value": 0.4010465741157532}, {"wallTime": 1733068022.553134, "step": 360, "value": 0.4605734944343567}, {"wallTime": 1733068031.824831, "step": 370, "value": 0.4973110854625702}, {"wallTime": 1733068040.7879553, "step": 380, "value": 0.36966773867607117}, {"wallTime": 1733068050.1603687, "step": 390, "value": 0.3921780586242676}, {"wallTime": 1733068059.1262438, "step": 400, "value": 0.2972947061061859}, {"wallTime": 1733068068.090267, "step": 410, "value": 0.6696356534957886}, {"wallTime": 1733068084.8443, "step": 420, "value": 0.38488346338272095}, {"wallTime": 1733068094.666839, "step": 430, "value": 0.5024827122688293}, {"wallTime": 1733068103.7082882, "step": 440, "value": 0.3435438275337219}, {"wallTime": 1733068112.699922, "step": 450, "value": 0.4297410249710083}, {"wallTime": 1733068121.501304, "step": 460, "value": 0.5338745713233948}, {"wallTime": 1733068130.728087, "step": 470, "value": 0.3970489501953125}, {"wallTime": 1733068139.8560736, "step": 480, "value": 0.4047434329986572}, {"wallTime": 1733068149.3704555, "step": 490, "value": 0.5338547229766846}, {"wallTime": 1733068158.070458, "step": 500, "value": 0.5207827091217041}, {"wallTime": 1733068174.115554, "step": 510, "value": 0.4807640612125397}, {"wallTime": 1733068182.720056, "step": 520, "value": 0.3782007098197937}, {"wallTime": 1733068192.4140642, "step": 530, "value": 0.4029928147792816}, {"wallTime": 1733068201.808605, "step": 540, "value": 0.391443133354187}, {"wallTime": 1733068210.6550028, "step": 550, "value": 0.5913569927215576}, {"wallTime": 1733068220.1955993, "step": 560, "value": 0.7253700494766235}, {"wallTime": 1733068229.1598625, "step": 570, "value": 0.3161301612854004}, {"wallTime": 1733068238.5920596, "step": 580, "value": 0.29218587279319763}, {"wallTime": 1733068256.0742748, "step": 590, "value": 0.4238111972808838}, {"wallTime": 1733068265.4323742, "step": 600, "value": 0.4999808967113495}, {"wallTime": 1733068274.6570373, "step": 610, "value": 0.6639851331710815}, {"wallTime": 1733068283.7705643, "step": 620, "value": 0.591464638710022}, {"wallTime": 1733068293.334694, "step": 630, "value": 0.4562852084636688}, {"wallTime": 1733068302.6477122, "step": 640, "value": 0.3832269310951233}, {"wallTime": 1733068311.388736, "step": 650, "value": 0.3428562879562378}, {"wallTime": 1733068320.3907142, "step": 660, "value": 0.45367076992988586}, {"wallTime": 1733068328.7318172, "step": 670, "value": 0.37106168270111084}, {"wallTime": 1733068344.4617224, "step": 680, "value": 0.3979981243610382}, {"wallTime": 1733068353.7175245, "step": 690, "value": 0.3560200035572052}, {"wallTime": 1733068362.058484, "step": 700, "value": 0.33050888776779175}, {"wallTime": 1733068371.1045942, "step": 710, "value": 0.5223235487937927}, {"wallTime": 1733068380.5337672, "step": 720, "value": 0.4070258140563965}, {"wallTime": 1733068390.0872817, "step": 730, "value": 0.31545376777648926}, {"wallTime": 1733068398.7216039, "step": 740, "value": 0.4643862247467041}, {"wallTime": 1733068407.1245856, "step": 750, "value": 0.4093366861343384}, {"wallTime": 1733068423.0719764, "step": 760, "value": 0.4120807647705078}, {"wallTime": 1733068431.4060223, "step": 770, "value": 0.33014777302742004}, {"wallTime": 1733068440.4255893, "step": 780, "value": 0.3545577824115753}, {"wallTime": 1733068449.0072334, "step": 790, "value": 0.37561047077178955}, {"wallTime": 1733068457.6384847, "step": 800, "value": 0.3994455933570862}, {"wallTime": 1733068467.0479083, "step": 810, "value": 0.3805123269557953}, {"wallTime": 1733068475.621137, "step": 820, "value": 0.37375956773757935}, {"wallTime": 1733068484.9797235, "step": 830, "value": 0.37769243121147156}, {"wallTime": 1733068500.7323337, "step": 840, "value": 0.4064442217350006}, {"wallTime": 1733068509.3085728, "step": 850, "value": 0.41732341051101685}, {"wallTime": 1733068519.023017, "step": 860, "value": 0.41419264674186707}, {"wallTime": 1733068527.4993591, "step": 870, "value": 0.3319225311279297}, {"wallTime": 1733068536.9211402, "step": 880, "value": 0.4852724075317383}, {"wallTime": 1733068544.9096582, "step": 890, "value": 0.35307320952415466}, {"wallTime": 1733068553.5799718, "step": 900, "value": 0.3759300708770752}, {"wallTime": 1733068562.6868982, "step": 910, "value": 0.41565048694610596}, {"wallTime": 1733068571.2472737, "step": 920, "value": 0.3417569696903229}, {"wallTime": 1733068584.7773767, "step": 930, "value": 0.3868202865123749}, {"wallTime": 1733068593.7738607, "step": 940, "value": 0.37170323729515076}, {"wallTime": 1733068602.7678065, "step": 950, "value": 0.4526887834072113}, {"wallTime": 1733068611.041924, "step": 960, "value": 0.28750741481781006}, {"wallTime": 1733068620.228663, "step": 970, "value": 0.33505183458328247}, {"wallTime": 1733068628.843785, "step": 980, "value": 0.4063507914543152}, {"wallTime": 1733068637.6325214, "step": 990, "value": 0.33581113815307617}, {"wallTime": 1733068646.6751542, "step": 1000, "value": 0.39242202043533325}, {"wallTime": 1733068662.758928, "step": 1010, "value": 0.2509269714355469}, {"wallTime": 1733068672.0566425, "step": 1020, "value": 0.30198538303375244}, {"wallTime": 1733068680.5652695, "step": 1030, "value": 0.32942888140678406}, {"wallTime": 1733068690.1881843, "step": 1040, "value": 0.35705089569091797}, {"wallTime": 1733068698.8505986, "step": 1050, "value": 0.3408728241920471}, {"wallTime": 1733068707.745743, "step": 1060, "value": 0.7616406083106995}, {"wallTime": 1733068717.3469465, "step": 1070, "value": 0.33989325165748596}, {"wallTime": 1733068726.3637073, "step": 1080, "value": 0.4179559350013733}, {"wallTime": 1733068735.2541132, "step": 1090, "value": 0.44897928833961487}, {"wallTime": 1733068749.5502558, "step": 1100, "value": 0.35829347372055054}, {"wallTime": 1733068758.3776977, "step": 1110, "value": 0.44724172353744507}, {"wallTime": 1733068767.0061765, "step": 1120, "value": 0.526139497756958}, {"wallTime": 1733068776.6211655, "step": 1130, "value": 0.46081966161727905}, {"wallTime": 1733068785.403594, "step": 1140, "value": 0.2420540452003479}, {"wallTime": 1733068794.281395, "step": 1150, "value": 0.40733444690704346}, {"wallTime": 1733068802.6996734, "step": 1160, "value": 0.2748289108276367}, {"wallTime": 1733068811.5540364, "step": 1170, "value": 0.391823410987854}, {"wallTime": 1733068824.9680452, "step": 1180, "value": 0.22798524796962738}, {"wallTime": 1733068834.3795354, "step": 1190, "value": 0.37079960107803345}, {"wallTime": 1733068843.5184894, "step": 1200, "value": 0.45249950885772705}, {"wallTime": 1733068852.2308197, "step": 1210, "value": 0.3491644859313965}, {"wallTime": 1733068861.119264, "step": 1220, "value": 0.3620627224445343}, {"wallTime": 1733068870.058204, "step": 1230, "value": 0.6335436105728149}, {"wallTime": 1733068878.7227144, "step": 1240, "value": 0.4250657260417938}, {"wallTime": 1733068887.7404432, "step": 1250, "value": 0.3328680992126465}, {"wallTime": 1733068903.1690993, "step": 1260, "value": 0.4804067611694336}, {"wallTime": 1733068912.4176288, "step": 1270, "value": 0.2727905809879303}, {"wallTime": 1733068921.475951, "step": 1280, "value": 0.3469541668891907}, {"wallTime": 1733068929.7489767, "step": 1290, "value": 0.3827976882457733}, {"wallTime": 1733068939.5037117, "step": 1300, "value": 0.3381938338279724}, {"wallTime": 1733068948.9301116, "step": 1310, "value": 0.3942698538303375}, {"wallTime": 1733068957.2367778, "step": 1320, "value": 0.49081510305404663}, {"wallTime": 1733068966.079352, "step": 1330, "value": 0.282244473695755}, {"wallTime": 1733068975.5675077, "step": 1340, "value": 0.5304679870605469}, {"wallTime": 1733068989.800938, "step": 1350, "value": 0.3861163556575775}, {"wallTime": 1733068998.2845507, "step": 1360, "value": 0.291095107793808}, {"wallTime": 1733069007.1514878, "step": 1370, "value": 0.35311567783355713}, {"wallTime": 1733069015.9240544, "step": 1380, "value": 0.20337575674057007}, {"wallTime": 1733069025.30555, "step": 1390, "value": 0.3661922812461853}, {"wallTime": 1733069034.4837344, "step": 1400, "value": 0.2723008990287781}, {"wallTime": 1733069042.7952669, "step": 1410, "value": 0.42791154980659485}, {"wallTime": 1733069052.1398067, "step": 1420, "value": 0.25861474871635437}, {"wallTime": 1733069065.0038846, "step": 1430, "value": 0.2991398572921753}, {"wallTime": 1733069074.5262146, "step": 1440, "value": 0.3211688697338104}, {"wallTime": 1733069083.7847993, "step": 1450, "value": 0.3847305476665497}, {"wallTime": 1733069092.2606006, "step": 1460, "value": 0.2926749587059021}, {"wallTime": 1733069101.0319288, "step": 1470, "value": 0.3435589373111725}, {"wallTime": 1733069109.9077475, "step": 1480, "value": 0.3016589879989624}, {"wallTime": 1733069119.120011, "step": 1490, "value": 0.2320409119129181}, {"wallTime": 1733069128.4173164, "step": 1500, "value": 0.3234254717826843}, {"wallTime": 1733069137.6079125, "step": 1510, "value": 0.45853275060653687}, {"wallTime": 1733069150.5446646, "step": 1520, "value": 0.3970544934272766}, {"wallTime": 1733069159.7581942, "step": 1530, "value": 0.43969523906707764}, {"wallTime": 1733069168.171519, "step": 1540, "value": 0.20042957365512848}, {"wallTime": 1733069176.842076, "step": 1550, "value": 0.4327102303504944}, {"wallTime": 1733069185.8933861, "step": 1560, "value": 0.23384979367256165}, {"wallTime": 1733069194.9251988, "step": 1570, "value": 0.3802350163459778}, {"wallTime": 1733069203.9143157, "step": 1580, "value": 0.3143875300884247}, {"wallTime": 1733069212.716992, "step": 1590, "value": 0.263082355260849}, {"wallTime": 1733069225.5351615, "step": 1600, "value": 0.28921517729759216}, {"wallTime": 1733069235.4649935, "step": 1610, "value": 0.44468316435813904}, {"wallTime": 1733069244.6310658, "step": 1620, "value": 0.4983088970184326}, {"wallTime": 1733069254.294584, "step": 1630, "value": 0.3385809361934662}, {"wallTime": 1733069263.0064156, "step": 1640, "value": 0.2579154968261719}, {"wallTime": 1733069271.8677793, "step": 1650, "value": 0.4424391984939575}, {"wallTime": 1733069280.5109956, "step": 1660, "value": 0.2749117612838745}, {"wallTime": 1733069289.680842, "step": 1670, "value": 0.37720128893852234}, {"wallTime": 1733069303.6110845, "step": 1680, "value": 0.4889594316482544}, {"wallTime": 1733069312.480754, "step": 1690, "value": 0.38582444190979004}, {"wallTime": 1733069321.8397279, "step": 1700, "value": 0.4645627439022064}, {"wallTime": 1733069330.3490953, "step": 1710, "value": 0.2961350977420807}, {"wallTime": 1733069339.2463927, "step": 1720, "value": 0.233820840716362}, {"wallTime": 1733069346.8589327, "step": 1730, "value": 0.24583183228969574}, {"wallTime": 1733069355.6546917, "step": 1740, "value": 0.4557925760746002}, {"wallTime": 1733069364.5131502, "step": 1750, "value": 0.3592081367969513}, {"wallTime": 1733069373.7397377, "step": 1760, "value": 0.31969013810157776}, {"wallTime": 1733069387.5421479, "step": 1770, "value": 0.3084768056869507}, {"wallTime": 1733069396.4688632, "step": 1780, "value": 0.2622138559818268}, {"wallTime": 1733069405.9973652, "step": 1790, "value": 0.2029329538345337}, {"wallTime": 1733069415.0549316, "step": 1800, "value": 0.2524908781051636}, {"wallTime": 1733069423.9085567, "step": 1810, "value": 0.2123393714427948}, {"wallTime": 1733069432.5322583, "step": 1820, "value": 0.4157413840293884}, {"wallTime": 1733069441.2192051, "step": 1830, "value": 0.3352617621421814}, {"wallTime": 1733069450.0895321, "step": 1840, "value": 0.2409706860780716}, {"wallTime": 1733069463.1077843, "step": 1850, "value": 0.23310832679271698}, {"wallTime": 1733069471.5737138, "step": 1860, "value": 0.26086702942848206}, {"wallTime": 1733069480.4989212, "step": 1870, "value": 0.5190623998641968}, {"wallTime": 1733069489.385458, "step": 1880, "value": 0.4203605353832245}, {"wallTime": 1733069497.977383, "step": 1890, "value": 0.42279666662216187}, {"wallTime": 1733069506.7949617, "step": 1900, "value": 0.31975165009498596}, {"wallTime": 1733069515.8253145, "step": 1910, "value": 0.24329692125320435}, {"wallTime": 1733069524.6371765, "step": 1920, "value": 0.287766695022583}, {"wallTime": 1733069533.5428355, "step": 1930, "value": 0.2175540328025818}, {"wallTime": 1733069550.4785829, "step": 1940, "value": 0.37147876620292664}, {"wallTime": 1733069558.8286362, "step": 1950, "value": 0.2618522047996521}, {"wallTime": 1733069567.758531, "step": 1960, "value": 0.26026761531829834}, {"wallTime": 1733069576.3458161, "step": 1970, "value": 0.2631397545337677}, {"wallTime": 1733069585.529807, "step": 1980, "value": 0.40867146849632263}, {"wallTime": 1733069594.3508635, "step": 1990, "value": 0.3879091739654541}, {"wallTime": 1733069602.4022949, "step": 2000, "value": 0.576145589351654}, {"wallTime": 1733069610.2506034, "step": 2010, "value": 0.4710655212402344}, {"wallTime": 1733069626.6874304, "step": 2020, "value": 0.40763500332832336}, {"wallTime": 1733069635.0315287, "step": 2030, "value": 0.2722455859184265}, {"wallTime": 1733069643.823179, "step": 2040, "value": 0.2545281946659088}, {"wallTime": 1733069652.1950433, "step": 2050, "value": 0.29879260063171387}, {"wallTime": 1733069660.4540644, "step": 2060, "value": 0.42518186569213867}, {"wallTime": 1733069669.5926762, "step": 2070, "value": 0.3355518579483032}, {"wallTime": 1733069678.7790048, "step": 2080, "value": 0.530267059803009}, {"wallTime": 1733069686.945445, "step": 2090, "value": 0.40103402733802795}, {"wallTime": 1733069700.6026828, "step": 2100, "value": 0.32589319348335266}, {"wallTime": 1733069708.726939, "step": 2110, "value": 0.24194954335689545}, {"wallTime": 1733069717.4488697, "step": 2120, "value": 0.29817280173301697}, {"wallTime": 1733069726.1418283, "step": 2130, "value": 0.3074035048484802}, {"wallTime": 1733069735.038683, "step": 2140, "value": 0.33770647644996643}, {"wallTime": 1733069743.306695, "step": 2150, "value": 0.2793212831020355}, {"wallTime": 1733069752.5013862, "step": 2160, "value": 0.3242279291152954}, {"wallTime": 1733069761.4515276, "step": 2170, "value": 0.3200836777687073}, {"wallTime": 1733069770.4337423, "step": 2180, "value": 0.3930809795856476}, {"wallTime": 1733069784.364237, "step": 2190, "value": 0.36491072177886963}, {"wallTime": 1733069793.1230502, "step": 2200, "value": 0.17427152395248413}, {"wallTime": 1733069801.6366825, "step": 2210, "value": 0.2909710705280304}, {"wallTime": 1733069810.6084208, "step": 2220, "value": 0.42016303539276123}, {"wallTime": 1733069819.3427558, "step": 2230, "value": 0.25675076246261597}, {"wallTime": 1733069827.3265953, "step": 2240, "value": 0.3911977708339691}, {"wallTime": 1733069835.868498, "step": 2250, "value": 0.28133460879325867}, {"wallTime": 1733069844.236378, "step": 2260, "value": 0.3203155994415283}, {"wallTime": 1733069856.7497306, "step": 2270, "value": 0.2604258060455322}, {"wallTime": 1733069865.2580945, "step": 2280, "value": 0.21333636343479156}, {"wallTime": 1733069874.0062425, "step": 2290, "value": 0.19292405247688293}, {"wallTime": 1733069881.7820926, "step": 2300, "value": 0.37322697043418884}, {"wallTime": 1733069890.4142423, "step": 2310, "value": 0.2554754912853241}, {"wallTime": 1733069898.877033, "step": 2320, "value": 0.2749740183353424}, {"wallTime": 1733069908.3181145, "step": 2330, "value": 0.2682393193244934}, {"wallTime": 1733069917.415556, "step": 2340, "value": 0.3676542341709137}, {"wallTime": 1733069925.85117, "step": 2350, "value": 0.2305513322353363}, {"wallTime": 1733069938.703402, "step": 2360, "value": 0.34486645460128784}, {"wallTime": 1733069947.4265053, "step": 2370, "value": 0.37270820140838623}, {"wallTime": 1733069956.2073088, "step": 2380, "value": 0.40689152479171753}, {"wallTime": 1733069964.275105, "step": 2390, "value": 0.2962869703769684}, {"wallTime": 1733069973.3264303, "step": 2400, "value": 0.22747814655303955}, {"wallTime": 1733069981.4324777, "step": 2410, "value": 0.2567540407180786}, {"wallTime": 1733069990.140055, "step": 2420, "value": 0.28278863430023193}, {"wallTime": 1733069998.7985382, "step": 2430, "value": 0.3080814778804779}, {"wallTime": 1733070012.456139, "step": 2440, "value": 0.27497589588165283}, {"wallTime": 1733070021.59925, "step": 2450, "value": 0.2472013533115387}, {"wallTime": 1733070030.1912906, "step": 2460, "value": 0.259063720703125}, {"wallTime": 1733070039.219612, "step": 2470, "value": 0.28507715463638306}, {"wallTime": 1733070048.2692142, "step": 2480, "value": 0.3598293960094452}, {"wallTime": 1733070056.1560364, "step": 2490, "value": 0.3875553011894226}, {"wallTime": 1733070064.4509234, "step": 2500, "value": 0.3545474708080292}, {"wallTime": 1733070072.5511765, "step": 2510, "value": 0.24527855217456818}, {"wallTime": 1733070087.6571336, "step": 2520, "value": 0.29096275568008423}, {"wallTime": 1733070095.4420004, "step": 2530, "value": 0.2669283151626587}, {"wallTime": 1733070103.7691298, "step": 2540, "value": 0.24368567764759064}, {"wallTime": 1733070113.0495303, "step": 2550, "value": 0.23969949781894684}, {"wallTime": 1733070121.0380983, "step": 2560, "value": 0.2449539601802826}, {"wallTime": 1733070129.584831, "step": 2570, "value": 0.2991432547569275}, {"wallTime": 1733070138.3610861, "step": 2580, "value": 0.2653740644454956}, {"wallTime": 1733070147.087542, "step": 2590, "value": 0.3470427095890045}, {"wallTime": 1733070155.487218, "step": 2600, "value": 0.44266581535339355}, {"wallTime": 1733070172.577534, "step": 2610, "value": 0.3071303069591522}, {"wallTime": 1733070181.2114534, "step": 2620, "value": 0.3306722640991211}, {"wallTime": 1733070189.6926267, "step": 2630, "value": 0.2769944369792938}, {"wallTime": 1733070198.39939, "step": 2640, "value": 0.267185240983963}, {"wallTime": 1733070206.707676, "step": 2650, "value": 0.21367695927619934}, {"wallTime": 1733070215.599945, "step": 2660, "value": 0.3347932696342468}, {"wallTime": 1733070224.3163378, "step": 2670, "value": 0.32781821489334106}, {"wallTime": 1733070233.5396318, "step": 2680, "value": 0.28127744793891907}, {"wallTime": 1733070246.758443, "step": 2690, "value": 0.25906455516815186}, {"wallTime": 1733070256.0293474, "step": 2700, "value": 0.39536356925964355}, {"wallTime": 1733070264.9510534, "step": 2710, "value": 0.25972315669059753}, {"wallTime": 1733070273.8272643, "step": 2720, "value": 0.3402111530303955}, {"wallTime": 1733070282.9593306, "step": 2730, "value": 0.3013767600059509}, {"wallTime": 1733070292.2781746, "step": 2740, "value": 0.2884570360183716}, {"wallTime": 1733070300.3370411, "step": 2750, "value": 0.2759387195110321}, {"wallTime": 1733070309.4124653, "step": 2760, "value": 0.4288293421268463}, {"wallTime": 1733070317.5317938, "step": 2770, "value": 0.403673380613327}, {"wallTime": 1733070330.436416, "step": 2780, "value": 0.3275417983531952}, {"wallTime": 1733070339.8233476, "step": 2790, "value": 0.2616131603717804}, {"wallTime": 1733070347.9939342, "step": 2800, "value": 0.20335832238197327}, {"wallTime": 1733070356.8932056, "step": 2810, "value": 0.29364126920700073}, {"wallTime": 1733070365.5772877, "step": 2820, "value": 0.2679373621940613}, {"wallTime": 1733070374.3937907, "step": 2830, "value": 0.27009648084640503}, {"wallTime": 1733070382.4272678, "step": 2840, "value": 0.3427774906158447}, {"wallTime": 1733070390.941604, "step": 2850, "value": 0.23696854710578918}, {"wallTime": 1733070406.6789956, "step": 2860, "value": 0.2518565058708191}, {"wallTime": 1733070415.0902734, "step": 2870, "value": 0.24441200494766235}, {"wallTime": 1733070422.9202814, "step": 2880, "value": 0.23002566397190094}, {"wallTime": 1733070431.5377107, "step": 2890, "value": 0.2563696503639221}, {"wallTime": 1733070439.9812431, "step": 2900, "value": 0.3275858163833618}, {"wallTime": 1733070448.085828, "step": 2910, "value": 0.4128008782863617}, {"wallTime": 1733070457.4240296, "step": 2920, "value": 0.4404677748680115}, {"wallTime": 1733070466.723212, "step": 2930, "value": 0.3774406909942627}, {"wallTime": 1733070479.3329122, "step": 2940, "value": 0.3067168593406677}, {"wallTime": 1733070488.7826407, "step": 2950, "value": 0.28880083560943604}, {"wallTime": 1733070497.225159, "step": 2960, "value": 0.3667230010032654}, {"wallTime": 1733070505.6341248, "step": 2970, "value": 0.2419847548007965}, {"wallTime": 1733070513.354245, "step": 2980, "value": 0.20396970212459564}, {"wallTime": 1733070522.301441, "step": 2990, "value": 0.35640329122543335}, {"wallTime": 1733070530.2129617, "step": 3000, "value": 0.19540047645568848}, {"wallTime": 1733070538.3002808, "step": 3010, "value": 0.3038286864757538}, {"wallTime": 1733070547.4005487, "step": 3020, "value": 0.25092121958732605}, {"wallTime": 1733070564.0510387, "step": 3030, "value": 0.23626744747161865}, {"wallTime": 1733070572.3700025, "step": 3040, "value": 0.23649828135967255}, {"wallTime": 1733070580.6713092, "step": 3050, "value": 0.27203333377838135}, {"wallTime": 1733070588.6534715, "step": 3060, "value": 0.2736620306968689}, {"wallTime": 1733070597.4210377, "step": 3070, "value": 0.2397870272397995}, {"wallTime": 1733070606.1375606, "step": 3080, "value": 0.3728156089782715}, {"wallTime": 1733070614.439874, "step": 3090, "value": 0.3371996283531189}, {"wallTime": 1733070624.0003173, "step": 3100, "value": 0.27989786863327026}, {"wallTime": 1733070637.2522786, "step": 3110, "value": 0.34458133578300476}, {"wallTime": 1733070645.682244, "step": 3120, "value": 0.2974470853805542}, {"wallTime": 1733070654.269826, "step": 3130, "value": 0.241570383310318}, {"wallTime": 1733070663.320588, "step": 3140, "value": 0.24813607335090637}, {"wallTime": 1733070671.1173646, "step": 3150, "value": 0.33949849009513855}, {"wallTime": 1733070679.7648773, "step": 3160, "value": 0.36889004707336426}, {"wallTime": 1733070687.844619, "step": 3170, "value": 0.25370365381240845}, {"wallTime": 1733070695.8551145, "step": 3180, "value": 0.3228009045124054}, {"wallTime": 1733070704.6217725, "step": 3190, "value": 0.25280916690826416}, {"wallTime": 1733070717.108181, "step": 3200, "value": 0.19867025315761566}, {"wallTime": 1733070726.097968, "step": 3210, "value": 0.294192373752594}, {"wallTime": 1733070734.7767243, "step": 3220, "value": 0.18453913927078247}, {"wallTime": 1733070744.4117508, "step": 3230, "value": 0.27973976731300354}, {"wallTime": 1733070752.5009844, "step": 3240, "value": 0.438553124666214}, {"wallTime": 1733070761.7204382, "step": 3250, "value": 0.39146262407302856}, {"wallTime": 1733070770.3759334, "step": 3260, "value": 0.27151045203208923}, {"wallTime": 1733070779.7293541, "step": 3270, "value": 0.25848066806793213}, {"wallTime": 1733070793.6777785, "step": 3280, "value": 0.2379816621541977}, {"wallTime": 1733070801.899328, "step": 3290, "value": 0.38624054193496704}, {"wallTime": 1733070810.1603696, "step": 3300, "value": 0.34349602460861206}, {"wallTime": 1733070818.7258718, "step": 3310, "value": 0.17869515717029572}, {"wallTime": 1733070827.0068448, "step": 3320, "value": 0.22797556221485138}, {"wallTime": 1733070835.5743499, "step": 3330, "value": 0.27126574516296387}, {"wallTime": 1733070843.9744675, "step": 3340, "value": 0.40579649806022644}, {"wallTime": 1733070853.0910685, "step": 3350, "value": 0.32190656661987305}, {"wallTime": 1733070865.4188871, "step": 3360, "value": 0.20786169171333313}, {"wallTime": 1733070873.6610012, "step": 3370, "value": 0.2580796480178833}, {"wallTime": 1733070883.335355, "step": 3380, "value": 0.2386932373046875}, {"wallTime": 1733070892.376359, "step": 3390, "value": 0.2714260220527649}, {"wallTime": 1733070900.7217205, "step": 3400, "value": 0.3131687045097351}, {"wallTime": 1733070908.503548, "step": 3410, "value": 0.27854448556900024}, {"wallTime": 1733070916.6551397, "step": 3420, "value": 0.3719274401664734}, {"wallTime": 1733070925.2090144, "step": 3430, "value": 0.25670763850212097}, {"wallTime": 1733070933.8096154, "step": 3440, "value": 0.21333929896354675}, {"wallTime": 1733070947.4791222, "step": 3450, "value": 0.24057960510253906}, {"wallTime": 1733070956.1867383, "step": 3460, "value": 0.24742993712425232}, {"wallTime": 1733070964.265666, "step": 3470, "value": 0.26291874051094055}, {"wallTime": 1733070972.385476, "step": 3480, "value": 0.2686465084552765}, {"wallTime": 1733070980.646471, "step": 3490, "value": 0.46096569299697876}, {"wallTime": 1733070989.6871262, "step": 3500, "value": 0.2436971515417099}, {"wallTime": 1733070997.7880547, "step": 3510, "value": 0.2328137755393982}, {"wallTime": 1733071006.2708075, "step": 3520, "value": 0.32463309168815613}, {"wallTime": 1733071018.8954668, "step": 3530, "value": 0.24010108411312103}, {"wallTime": 1733071027.1965513, "step": 3540, "value": 0.17788468301296234}, {"wallTime": 1733071035.3200088, "step": 3550, "value": 0.2632558047771454}, {"wallTime": 1733071043.745202, "step": 3560, "value": 0.2195851355791092}, {"wallTime": 1733071051.8715959, "step": 3570, "value": 0.28589242696762085}, {"wallTime": 1733071060.49557, "step": 3580, "value": 0.24733856320381165}, {"wallTime": 1733071068.8789124, "step": 3590, "value": 0.2566823363304138}, {"wallTime": 1733071077.712403, "step": 3600, "value": 0.27799686789512634}, {"wallTime": 1733071086.2118936, "step": 3610, "value": 0.21648702025413513}, {"wallTime": 1733071101.65824, "step": 3620, "value": 0.23855507373809814}, {"wallTime": 1733071109.620554, "step": 3630, "value": 0.28309759497642517}, {"wallTime": 1733071118.1287897, "step": 3640, "value": 0.2551090717315674}, {"wallTime": 1733071126.9926667, "step": 3650, "value": 0.2119126319885254}, {"wallTime": 1733071135.826979, "step": 3660, "value": 0.31313565373420715}, {"wallTime": 1733071144.2478704, "step": 3670, "value": 0.22160260379314423}, {"wallTime": 1733071152.9639914, "step": 3680, "value": 0.24158766865730286}, {"wallTime": 1733071160.602988, "step": 3690, "value": 0.25746822357177734}, {"wallTime": 1733071173.7498436, "step": 3700, "value": 0.26104292273521423}, {"wallTime": 1733071182.882815, "step": 3710, "value": 0.26610130071640015}, {"wallTime": 1733071191.209635, "step": 3720, "value": 0.3133733570575714}, {"wallTime": 1733071200.332992, "step": 3730, "value": 0.5736743807792664}, {"wallTime": 1733071208.3652582, "step": 3740, "value": 0.28038954734802246}, {"wallTime": 1733071216.5714664, "step": 3750, "value": 0.2016022801399231}, {"wallTime": 1733071224.6614625, "step": 3760, "value": 0.16987188160419464}, {"wallTime": 1733071232.8602753, "step": 3770, "value": 0.16360405087471008}, {"wallTime": 1733071248.5330224, "step": 3780, "value": 0.3569655120372772}, {"wallTime": 1733071257.3913517, "step": 3790, "value": 0.42437806725502014}, {"wallTime": 1733071265.5668983, "step": 3800, "value": 0.19344843924045563}, {"wallTime": 1733071274.1976697, "step": 3810, "value": 0.3093855381011963}, {"wallTime": 1733071283.0175385, "step": 3820, "value": 0.2290673553943634}, {"wallTime": 1733071291.7293837, "step": 3830, "value": 0.17688751220703125}, {"wallTime": 1733071299.8930523, "step": 3840, "value": 0.20783290266990662}, {"wallTime": 1733071308.479102, "step": 3850, "value": 0.28447282314300537}, {"wallTime": 1733071316.9511807, "step": 3860, "value": 0.30478984117507935}, {"wallTime": 1733071330.2148178, "step": 3870, "value": 0.22335460782051086}, {"wallTime": 1733071338.9886353, "step": 3880, "value": 0.2405148595571518}, {"wallTime": 1733071347.7365646, "step": 3890, "value": 0.21514028310775757}, {"wallTime": 1733071357.0343835, "step": 3900, "value": 0.21622663736343384}, {"wallTime": 1733071365.225237, "step": 3910, "value": 0.2951582074165344}, {"wallTime": 1733071374.13453, "step": 3920, "value": 0.4590761959552765}, {"wallTime": 1733071382.8137362, "step": 3930, "value": 0.29802167415618896}, {"wallTime": 1733071391.5683131, "step": 3940, "value": 0.2558916509151459}, {"wallTime": 1733071404.467189, "step": 3950, "value": 0.23278990387916565}, {"wallTime": 1733071412.3388054, "step": 3960, "value": 0.25520411133766174}, {"wallTime": 1733071421.1574829, "step": 3970, "value": 0.27310070395469666}, {"wallTime": 1733071430.120472, "step": 3980, "value": 0.19458967447280884}, {"wallTime": 1733071438.413986, "step": 3990, "value": 0.37311407923698425}, {"wallTime": 1733071447.7288108, "step": 4000, "value": 0.3531872034072876}, {"wallTime": 1733071456.196571, "step": 4010, "value": 0.29175978899002075}, {"wallTime": 1733071464.7494333, "step": 4020, "value": 0.24911558628082275}, {"wallTime": 1733071473.3972871, "step": 4030, "value": 0.3256644308567047}, {"wallTime": 1733071490.286392, "step": 4040, "value": 0.24738414585590363}, {"wallTime": 1733071498.7117095, "step": 4050, "value": 0.2360990047454834}, {"wallTime": 1733071507.097575, "step": 4060, "value": 0.1915367841720581}, {"wallTime": 1733071515.0678587, "step": 4070, "value": 0.28566816449165344}, {"wallTime": 1733071523.8812518, "step": 4080, "value": 0.2718665599822998}, {"wallTime": 1733071532.2855492, "step": 4090, "value": 0.1966448724269867}, {"wallTime": 1733071540.917817, "step": 4100, "value": 0.21662276983261108}, {"wallTime": 1733071549.1763716, "step": 4110, "value": 0.18344873189926147}, {"wallTime": 1733071565.8362634, "step": 4120, "value": 0.22603584825992584}, {"wallTime": 1733071573.631969, "step": 4130, "value": 0.1608932912349701}, {"wallTime": 1733071582.0965505, "step": 4140, "value": 0.41995131969451904}, {"wallTime": 1733071590.0231025, "step": 4150, "value": 0.16087117791175842}, {"wallTime": 1733071599.2414298, "step": 4160, "value": 0.7094476222991943}, {"wallTime": 1733071608.0722275, "step": 4170, "value": 0.2539356052875519}, {"wallTime": 1733071616.1843452, "step": 4180, "value": 0.3132743239402771}, {"wallTime": 1733071626.0834033, "step": 4190, "value": 0.15960904955863953}, {"wallTime": 1733071641.0086193, "step": 4200, "value": 0.24506592750549316}, {"wallTime": 1733071649.0413415, "step": 4210, "value": 0.20186585187911987}, {"wallTime": 1733071658.5321064, "step": 4220, "value": 0.2799873352050781}, {"wallTime": 1733071667.9667802, "step": 4230, "value": 0.32402274012565613}, {"wallTime": 1733071676.109504, "step": 4240, "value": 0.20844943821430206}, {"wallTime": 1733071684.3793027, "step": 4250, "value": 0.31421345472335815}, {"wallTime": 1733071693.1103811, "step": 4260, "value": 0.2888542711734772}, {"wallTime": 1733071702.1846578, "step": 4270, "value": 0.21155394613742828}, {"wallTime": 1733071710.6312153, "step": 4280, "value": 0.32212331891059875}, {"wallTime": 1733071726.6775012, "step": 4290, "value": 0.2637500762939453}, {"wallTime": 1733071735.2163475, "step": 4300, "value": 0.268235445022583}, {"wallTime": 1733071742.957864, "step": 4310, "value": 0.26260560750961304}, {"wallTime": 1733071751.5864906, "step": 4320, "value": 0.42464110255241394}, {"wallTime": 1733071760.035591, "step": 4330, "value": 0.2764802575111389}, {"wallTime": 1733071768.4321136, "step": 4340, "value": 0.18074141442775726}, {"wallTime": 1733071777.4029596, "step": 4350, "value": 0.29684770107269287}, {"wallTime": 1733071785.5481265, "step": 4360, "value": 0.2733258008956909}, {"wallTime": 1733071800.88559, "step": 4370, "value": 0.3575611114501953}, {"wallTime": 1733071809.2666295, "step": 4380, "value": 0.24138164520263672}, {"wallTime": 1733071817.3472106, "step": 4390, "value": 0.20545022189617157}, {"wallTime": 1733071826.4312198, "step": 4400, "value": 0.3054538071155548}, {"wallTime": 1733071834.888406, "step": 4410, "value": 0.293451726436615}, {"wallTime": 1733071843.447675, "step": 4420, "value": 0.2575245201587677}, {"wallTime": 1733071851.5968254, "step": 4430, "value": 0.2465515434741974}, {"wallTime": 1733071859.9249396, "step": 4440, "value": 0.2582724392414093}, {"wallTime": 1733071868.6740294, "step": 4450, "value": 0.245243102312088}, {"wallTime": 1733071881.3369503, "step": 4460, "value": 0.22681522369384766}, {"wallTime": 1733071889.6375992, "step": 4470, "value": 0.23946942389011383}, {"wallTime": 1733071898.4216187, "step": 4480, "value": 0.26862767338752747}, {"wallTime": 1733071907.336814, "step": 4490, "value": 0.2292189747095108}, {"wallTime": 1733071916.2790036, "step": 4500, "value": 0.32890087366104126}, {"wallTime": 1733071925.3494701, "step": 4510, "value": 0.36370888352394104}, {"wallTime": 1733071933.3301265, "step": 4520, "value": 0.15223829448223114}, {"wallTime": 1733071941.4834595, "step": 4530, "value": 0.16459131240844727}, {"wallTime": 1733071954.1696997, "step": 4540, "value": 0.23398739099502563}, {"wallTime": 1733071962.3965216, "step": 4550, "value": 0.18836535513401031}, {"wallTime": 1733071970.5140786, "step": 4560, "value": 0.2648364305496216}, {"wallTime": 1733071978.8706412, "step": 4570, "value": 0.3712177574634552}, {"wallTime": 1733071987.7111945, "step": 4580, "value": 0.29681485891342163}, {"wallTime": 1733071996.445433, "step": 4590, "value": 0.3875601589679718}, {"wallTime": 1733072004.476617, "step": 4600, "value": 0.19254198670387268}, {"wallTime": 1733072012.7453816, "step": 4610, "value": 0.18173101544380188}, {"wallTime": 1733072025.4008434, "step": 4620, "value": 0.19880451261997223}, {"wallTime": 1733072034.1188474, "step": 4630, "value": 0.18918830156326294}, {"wallTime": 1733072043.0383217, "step": 4640, "value": 0.31226274371147156}, {"wallTime": 1733072051.786117, "step": 4650, "value": 0.25161051750183105}, {"wallTime": 1733072060.1086113, "step": 4660, "value": 0.2439451813697815}, {"wallTime": 1733072068.6033876, "step": 4670, "value": 0.272918164730072}, {"wallTime": 1733072076.8367898, "step": 4680, "value": 0.2686169445514679}, {"wallTime": 1733072085.3762174, "step": 4690, "value": 0.28672459721565247}, {"wallTime": 1733072093.7486637, "step": 4700, "value": 0.21434921026229858}, {"wallTime": 1733072106.989783, "step": 4710, "value": 0.2590298056602478}, {"wallTime": 1733072115.665286, "step": 4720, "value": 0.4168251156806946}, {"wallTime": 1733072123.950685, "step": 4730, "value": 0.32424795627593994}, {"wallTime": 1733072132.2807448, "step": 4740, "value": 0.22813460230827332}, {"wallTime": 1733072140.4206421, "step": 4750, "value": 0.19406378269195557}, {"wallTime": 1733072149.0872095, "step": 4760, "value": 0.21349288523197174}, {"wallTime": 1733072157.4118896, "step": 4770, "value": 0.23984459042549133}, {"wallTime": 1733072165.4893785, "step": 4780, "value": 0.27163827419281006}, {"wallTime": 1733072179.6492045, "step": 4790, "value": 0.2589848041534424}, {"wallTime": 1733072188.3297362, "step": 4800, "value": 0.19370727241039276}, {"wallTime": 1733072196.8470635, "step": 4810, "value": 0.2588323950767517}, {"wallTime": 1733072204.5623212, "step": 4820, "value": 0.20298384130001068}, {"wallTime": 1733072213.0996943, "step": 4830, "value": 0.3616011142730713}, {"wallTime": 1733072221.6671307, "step": 4840, "value": 0.2649257183074951}, {"wallTime": 1733072229.8940399, "step": 4850, "value": 0.20381826162338257}, {"wallTime": 1733072238.0562701, "step": 4860, "value": 0.24295397102832794}, {"wallTime": 1733072246.3436363, "step": 4870, "value": 0.20096226036548615}, {"wallTime": 1733072261.2674284, "step": 4880, "value": 0.22975698113441467}, {"wallTime": 1733072269.8526874, "step": 4890, "value": 0.2208186835050583}, {"wallTime": 1733072278.8804266, "step": 4900, "value": 0.28529778122901917}, {"wallTime": 1733072287.534604, "step": 4910, "value": 0.20159024000167847}, {"wallTime": 1733072295.9473782, "step": 4920, "value": 0.17802631855010986}, {"wallTime": 1733072304.355532, "step": 4930, "value": 0.2651712894439697}, {"wallTime": 1733072313.5100586, "step": 4940, "value": 0.26413384079933167}, {"wallTime": 1733072321.325542, "step": 4950, "value": 0.1874440312385559}, {"wallTime": 1733072337.025174, "step": 4960, "value": 0.16453683376312256}, {"wallTime": 1733072345.5322754, "step": 4970, "value": 0.17695188522338867}, {"wallTime": 1733072353.430023, "step": 4980, "value": 0.22536775469779968}, {"wallTime": 1733072362.413527, "step": 4990, "value": 0.2406969964504242}, {"wallTime": 1733072371.7462225, "step": 5000, "value": 0.22942006587982178}, {"wallTime": 1733072380.5299711, "step": 5010, "value": 0.28999119997024536}, {"wallTime": 1733072389.02676, "step": 5020, "value": 0.3047886788845062}, {"wallTime": 1733072397.7858627, "step": 5030, "value": 0.19619637727737427}, {"wallTime": 1733072411.2986548, "step": 5040, "value": 0.22018836438655853}, {"wallTime": 1733072419.47452, "step": 5050, "value": 0.20699602365493774}, {"wallTime": 1733072428.3725576, "step": 5060, "value": 0.2878718674182892}, {"wallTime": 1733072437.1170468, "step": 5070, "value": 0.2662941515445709}, {"wallTime": 1733072446.1755602, "step": 5080, "value": 0.2905229330062866}, {"wallTime": 1733072454.428946, "step": 5090, "value": 0.19895119965076447}, {"wallTime": 1733072462.410868, "step": 5100, "value": 0.24819520115852356}, {"wallTime": 1733072471.150625, "step": 5110, "value": 0.21856343746185303}, {"wallTime": 1733072478.94693, "step": 5120, "value": 0.30160027742385864}, {"wallTime": 1733072491.3219874, "step": 5130, "value": 0.32516175508499146}, {"wallTime": 1733072499.2590837, "step": 5140, "value": 0.16805675625801086}, {"wallTime": 1733072507.1124096, "step": 5150, "value": 0.21901936829090118}, {"wallTime": 1733072515.3175714, "step": 5160, "value": 0.6163445115089417}, {"wallTime": 1733072523.5010607, "step": 5170, "value": 0.27432259917259216}, {"wallTime": 1733072531.0875933, "step": 5180, "value": 0.17431756854057312}, {"wallTime": 1733072540.022884, "step": 5190, "value": 0.23822622001171112}, {"wallTime": 1733072548.6530793, "step": 5200, "value": 0.26445862650871277}, {"wallTime": 1733072561.416206, "step": 5210, "value": 0.20931300520896912}, {"wallTime": 1733072569.8972719, "step": 5220, "value": 0.28945082426071167}, {"wallTime": 1733072578.6799111, "step": 5230, "value": 0.267118364572525}, {"wallTime": 1733072586.9431856, "step": 5240, "value": 0.2726724147796631}, {"wallTime": 1733072595.034689, "step": 5250, "value": 0.3356335163116455}, {"wallTime": 1733072603.1738038, "step": 5260, "value": 0.24638234078884125}, {"wallTime": 1733072611.0806413, "step": 5270, "value": 0.27595263719558716}, {"wallTime": 1733072619.9558856, "step": 5280, "value": 0.2439696341753006}, {"wallTime": 1733072628.6349154, "step": 5290, "value": 0.23925748467445374}, {"wallTime": 1733072641.3759186, "step": 5300, "value": 0.22553536295890808}, {"wallTime": 1733072649.8586557, "step": 5310, "value": 0.16630426049232483}, {"wallTime": 1733072657.9716272, "step": 5320, "value": 0.18240927159786224}, {"wallTime": 1733072667.0298548, "step": 5330, "value": 0.29442185163497925}, {"wallTime": 1733072675.943391, "step": 5340, "value": 0.24003110826015472}, {"wallTime": 1733072684.238776, "step": 5350, "value": 0.37171125411987305}, {"wallTime": 1733072691.8584738, "step": 5360, "value": 0.24844862520694733}, {"wallTime": 1733072700.148339, "step": 5370, "value": 0.18591442704200745}, {"wallTime": 1733072713.1833954, "step": 5380, "value": 0.18878701329231262}, {"wallTime": 1733072721.025053, "step": 5390, "value": 0.16496440768241882}, {"wallTime": 1733072729.8772826, "step": 5400, "value": 0.22550112009048462}, {"wallTime": 1733072738.3704748, "step": 5410, "value": 0.1790572702884674}, {"wallTime": 1733072746.3830466, "step": 5420, "value": 0.24976134300231934}, {"wallTime": 1733072754.6180017, "step": 5430, "value": 0.3131495714187622}, {"wallTime": 1733072762.5478878, "step": 5440, "value": 0.1870986819267273}, {"wallTime": 1733072771.3609672, "step": 5450, "value": 0.24347437918186188}, {"wallTime": 1733072787.1520638, "step": 5460, "value": 0.17868943512439728}, {"wallTime": 1733072795.803147, "step": 5470, "value": 0.250661700963974}, {"wallTime": 1733072804.2423599, "step": 5480, "value": 0.1676611304283142}, {"wallTime": 1733072812.3734276, "step": 5490, "value": 0.2650394141674042}, {"wallTime": 1733072821.1595495, "step": 5500, "value": 0.27428123354911804}, {"wallTime": 1733072830.022974, "step": 5510, "value": 0.2948320508003235}, {"wallTime": 1733072838.6954257, "step": 5520, "value": 0.207432821393013}, {"wallTime": 1733072846.905286, "step": 5530, "value": 0.16963830590248108}, {"wallTime": 1733072855.2471626, "step": 5540, "value": 0.19776956737041473}, {"wallTime": 1733072870.6451945, "step": 5550, "value": 0.28324398398399353}, {"wallTime": 1733072878.7301679, "step": 5560, "value": 0.27518802881240845}, {"wallTime": 1733072886.6114802, "step": 5570, "value": 0.2332153171300888}, {"wallTime": 1733072895.0212274, "step": 5580, "value": 0.8562355637550354}, {"wallTime": 1733072903.4030585, "step": 5590, "value": 0.2086397409439087}, {"wallTime": 1733072911.2100964, "step": 5600, "value": 0.30895575881004333}, {"wallTime": 1733072919.840051, "step": 5610, "value": 0.26019591093063354}, {"wallTime": 1733072928.7331991, "step": 5620, "value": 0.3685268461704254}, {"wallTime": 1733072941.7038188, "step": 5630, "value": 0.20339709520339966}, {"wallTime": 1733072949.9802084, "step": 5640, "value": 0.23384374380111694}, {"wallTime": 1733072958.7202816, "step": 5650, "value": 0.3245423436164856}, {"wallTime": 1733072966.8150756, "step": 5660, "value": 0.20304012298583984}, {"wallTime": 1733072974.9624891, "step": 5670, "value": 0.18517673015594482}, {"wallTime": 1733072983.5620787, "step": 5680, "value": 0.23023875057697296}, {"wallTime": 1733072992.228947, "step": 5690, "value": 0.25090503692626953}, {"wallTime": 1733073000.8172796, "step": 5700, "value": 0.19796821475028992}, {"wallTime": 1733073009.7833674, "step": 5710, "value": 0.2407953441143036}, {"wallTime": 1733073022.8683584, "step": 5720, "value": 0.365953266620636}, {"wallTime": 1733073031.5348873, "step": 5730, "value": 0.28818249702453613}, {"wallTime": 1733073039.5712876, "step": 5740, "value": 0.24313756823539734}, {"wallTime": 1733073047.8430526, "step": 5750, "value": 0.2377249002456665}, {"wallTime": 1733073056.1566696, "step": 5760, "value": 0.1836763620376587}, {"wallTime": 1733073064.9552312, "step": 5770, "value": 0.3403233289718628}, {"wallTime": 1733073073.8378325, "step": 5780, "value": 0.22208648920059204}, {"wallTime": 1733073082.725218, "step": 5790, "value": 0.3165636658668518}, {"wallTime": 1733073095.1031392, "step": 5800, "value": 0.21871310472488403}, {"wallTime": 1733073103.3159566, "step": 5810, "value": 0.2459620088338852}, {"wallTime": 1733073111.9708376, "step": 5820, "value": 0.16240310668945312}, {"wallTime": 1733073120.3565116, "step": 5830, "value": 0.30496084690093994}, {"wallTime": 1733073128.2094054, "step": 5840, "value": 0.20111489295959473}, {"wallTime": 1733073136.7158997, "step": 5850, "value": 0.16776299476623535}, {"wallTime": 1733073144.9280312, "step": 5860, "value": 0.2509552836418152}, {"wallTime": 1733073153.041667, "step": 5870, "value": 0.1564769595861435}, {"wallTime": 1733073166.0032861, "step": 5880, "value": 0.19065704941749573}, {"wallTime": 1733073174.6592424, "step": 5890, "value": 0.15489786863327026}, {"wallTime": 1733073182.5085266, "step": 5900, "value": 0.22694295644760132}, {"wallTime": 1733073191.5597668, "step": 5910, "value": 0.18625926971435547}, {"wallTime": 1733073199.4118965, "step": 5920, "value": 0.10388399660587311}, {"wallTime": 1733073207.4657855, "step": 5930, "value": 0.233026921749115}, {"wallTime": 1733073215.6031551, "step": 5940, "value": 0.2079206109046936}, {"wallTime": 1733073224.3584383, "step": 5950, "value": 0.2012939602136612}, {"wallTime": 1733073232.87747, "step": 5960, "value": 0.28135526180267334}, {"wallTime": 1733073245.3741167, "step": 5970, "value": 0.198486328125}, {"wallTime": 1733073253.1798556, "step": 5980, "value": 0.24550187587738037}, {"wallTime": 1733073261.8003886, "step": 5990, "value": 0.22085824608802795}, {"wallTime": 1733073270.0601783, "step": 6000, "value": 0.21625593304634094}, {"wallTime": 1733073278.8963077, "step": 6010, "value": 0.3622754216194153}, {"wallTime": 1733073287.682579, "step": 6020, "value": 0.2496136724948883}, {"wallTime": 1733073297.274954, "step": 6030, "value": 0.38877877593040466}, {"wallTime": 1733073305.9187422, "step": 6040, "value": 0.29727882146835327}, {"wallTime": 1733073322.3551345, "step": 6050, "value": 0.21498975157737732}, {"wallTime": 1733073331.9777722, "step": 6060, "value": 0.15916109085083008}, {"wallTime": 1733073340.5226593, "step": 6070, "value": 0.18742530047893524}, {"wallTime": 1733073349.6024725, "step": 6080, "value": 0.30012625455856323}, {"wallTime": 1733073359.0717082, "step": 6090, "value": 0.18626736104488373}, {"wallTime": 1733073368.4034355, "step": 6100, "value": 0.2303718626499176}, {"wallTime": 1733073377.6754854, "step": 6110, "value": 0.24308890104293823}, {"wallTime": 1733073386.4008834, "step": 6120, "value": 0.16346526145935059}, {"wallTime": 1733073395.4519963, "step": 6130, "value": 0.22838392853736877}, {"wallTime": 1733073408.1517353, "step": 6140, "value": 0.1527031660079956}, {"wallTime": 1733073417.324231, "step": 6150, "value": 0.1895807981491089}, {"wallTime": 1733073426.25737, "step": 6160, "value": 0.19301669299602509}, {"wallTime": 1733073434.809795, "step": 6170, "value": 0.1683557629585266}, {"wallTime": 1733073444.5131612, "step": 6180, "value": 0.2073138952255249}, {"wallTime": 1733073453.117098, "step": 6190, "value": 0.24198026955127716}, {"wallTime": 1733073462.5660522, "step": 6200, "value": 0.16172972321510315}, {"wallTime": 1733073472.024978, "step": 6210, "value": 0.23355615139007568}, {"wallTime": 1733073484.4487884, "step": 6220, "value": 0.19843977689743042}, {"wallTime": 1733073493.6603591, "step": 6230, "value": 0.19295893609523773}, {"wallTime": 1733073502.441614, "step": 6240, "value": 0.21378645300865173}, {"wallTime": 1733073511.256623, "step": 6250, "value": 0.23668551445007324}, {"wallTime": 1733073520.4853566, "step": 6260, "value": 0.18609283864498138}, {"wallTime": 1733073529.781798, "step": 6270, "value": 0.2801409661769867}, {"wallTime": 1733073539.6395204, "step": 6280, "value": 0.23269890248775482}, {"wallTime": 1733073548.91135, "step": 6290, "value": 0.20241066813468933}, {"wallTime": 1733073560.6201308, "step": 6300, "value": 0.2655734419822693}, {"wallTime": 1733073570.069362, "step": 6310, "value": 0.18877126276493073}, {"wallTime": 1733073579.4814942, "step": 6320, "value": 0.24617089331150055}, {"wallTime": 1733073587.6676764, "step": 6330, "value": 0.1923314929008484}, {"wallTime": 1733073597.2182956, "step": 6340, "value": 0.20351575314998627}, {"wallTime": 1733073606.2384953, "step": 6350, "value": 0.19662542641162872}, {"wallTime": 1733073615.0779786, "step": 6360, "value": 0.2946217656135559}, {"wallTime": 1733073624.8348715, "step": 6370, "value": 0.2514888644218445}, {"wallTime": 1733073634.67293, "step": 6380, "value": 0.23545719683170319}, {"wallTime": 1733073646.5285666, "step": 6390, "value": 0.200948566198349}, {"wallTime": 1733073655.7458506, "step": 6400, "value": 0.23546525835990906}, {"wallTime": 1733073665.6074958, "step": 6410, "value": 0.22525423765182495}, {"wallTime": 1733073674.6431606, "step": 6420, "value": 0.28314706683158875}, {"wallTime": 1733073683.6707084, "step": 6430, "value": 0.168727844953537}, {"wallTime": 1733073692.8771558, "step": 6440, "value": 0.2556025981903076}, {"wallTime": 1733073702.5195105, "step": 6450, "value": 0.1738390177488327}, {"wallTime": 1733073712.627698, "step": 6460, "value": 0.25300168991088867}, {"wallTime": 1733073724.0478814, "step": 6470, "value": 0.3185388147830963}, {"wallTime": 1733073732.8287966, "step": 6480, "value": 0.23397527635097504}, {"wallTime": 1733073741.9577713, "step": 6490, "value": 0.21056139469146729}, {"wallTime": 1733073750.7180507, "step": 6500, "value": 0.23795567452907562}, {"wallTime": 1733073760.4884834, "step": 6510, "value": 0.15325772762298584}, {"wallTime": 1733073769.8637455, "step": 6520, "value": 0.17367668449878693}, {"wallTime": 1733073779.1274238, "step": 6530, "value": 0.1983334720134735}, {"wallTime": 1733073789.4780786, "step": 6540, "value": 0.30992183089256287}, {"wallTime": 1733073798.103742, "step": 6550, "value": 0.33399227261543274}, {"wallTime": 1733073810.5532644, "step": 6560, "value": 0.22670823335647583}, {"wallTime": 1733073820.0368063, "step": 6570, "value": 0.20270423591136932}, {"wallTime": 1733073828.2390113, "step": 6580, "value": 0.26423877477645874}, {"wallTime": 1733073836.798618, "step": 6590, "value": 0.17440694570541382}, {"wallTime": 1733073845.9879231, "step": 6600, "value": 0.21734772622585297}, {"wallTime": 1733073855.2525406, "step": 6610, "value": 0.20507989823818207}, {"wallTime": 1733073864.6941307, "step": 6620, "value": 0.19044198095798492}, {"wallTime": 1733073873.8350546, "step": 6630, "value": 0.21221233904361725}, {"wallTime": 1733073887.5250835, "step": 6640, "value": 0.2550089359283447}, {"wallTime": 1733073897.334654, "step": 6650, "value": 0.2258598804473877}, {"wallTime": 1733073906.8772697, "step": 6660, "value": 0.2230001837015152}, {"wallTime": 1733073916.3507445, "step": 6670, "value": 0.25486722588539124}, {"wallTime": 1733073925.6193492, "step": 6680, "value": 0.18779517710208893}, {"wallTime": 1733073934.9173465, "step": 6690, "value": 0.1760474443435669}, {"wallTime": 1733073943.7429307, "step": 6700, "value": 0.16606196761131287}, {"wallTime": 1733073952.4776742, "step": 6710, "value": 0.23084788024425507}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15035" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_aux_3%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_aux_3", "runToSeries": {".": [{"wallTime": 1733067631.5386136, "step": 0, "value": 1.8448777198791504}, {"wallTime": 1733067646.6520026, "step": 10, "value": 2.0803728103637695}, {"wallTime": 1733067660.7839928, "step": 20, "value": 1.89419686794281}, {"wallTime": 1733067674.1372356, "step": 30, "value": 1.8063888549804688}, {"wallTime": 1733067687.0569215, "step": 40, "value": 2.0383853912353516}, {"wallTime": 1733067699.4928002, "step": 50, "value": 1.307590126991272}, {"wallTime": 1733067710.6290965, "step": 60, "value": 1.6364301443099976}, {"wallTime": 1733067722.7553008, "step": 70, "value": 1.407225251197815}, {"wallTime": 1733067733.7251415, "step": 80, "value": 0.9416264295578003}, {"wallTime": 1733067750.9460392, "step": 90, "value": 1.2382574081420898}, {"wallTime": 1733067761.9806173, "step": 100, "value": 1.0942225456237793}, {"wallTime": 1733067771.6061962, "step": 110, "value": 0.724606990814209}, {"wallTime": 1733067780.547157, "step": 120, "value": 0.6186941862106323}, {"wallTime": 1733067790.4851213, "step": 130, "value": 0.8109501004219055}, {"wallTime": 1733067799.1054046, "step": 140, "value": 0.4363618791103363}, {"wallTime": 1733067809.444405, "step": 150, "value": 0.6419657468795776}, {"wallTime": 1733067818.9205155, "step": 160, "value": 0.5946321487426758}, {"wallTime": 1733067836.6493032, "step": 170, "value": 0.43892228603363037}, {"wallTime": 1733067846.3904126, "step": 180, "value": 0.664887547492981}, {"wallTime": 1733067855.6665542, "step": 190, "value": 0.43409138917922974}, {"wallTime": 1733067864.8894117, "step": 200, "value": 0.7821613550186157}, {"wallTime": 1733067874.001525, "step": 210, "value": 0.6015061140060425}, {"wallTime": 1733067883.7857106, "step": 220, "value": 0.4075982868671417}, {"wallTime": 1733067892.1229038, "step": 230, "value": 0.5092415809631348}, {"wallTime": 1733067901.069165, "step": 240, "value": 0.5013769268989563}, {"wallTime": 1733067910.0746667, "step": 250, "value": 0.46910303831100464}, {"wallTime": 1733067925.9497938, "step": 260, "value": 0.7742117643356323}, {"wallTime": 1733067935.4753036, "step": 270, "value": 0.4324985146522522}, {"wallTime": 1733067944.0151272, "step": 280, "value": 0.4751352071762085}, {"wallTime": 1733067952.5461907, "step": 290, "value": 0.4717550277709961}, {"wallTime": 1733067961.0264907, "step": 300, "value": 0.3267776370048523}, {"wallTime": 1733067970.1343722, "step": 310, "value": 0.5355179905891418}, {"wallTime": 1733067980.2255034, "step": 320, "value": 0.4478195607662201}, {"wallTime": 1733067988.8158362, "step": 330, "value": 0.5380954742431641}, {"wallTime": 1733068005.0903895, "step": 340, "value": 0.41371095180511475}, {"wallTime": 1733068014.0649467, "step": 350, "value": 0.40087610483169556}, {"wallTime": 1733068022.5527956, "step": 360, "value": 0.46064817905426025}, {"wallTime": 1733068031.8244925, "step": 370, "value": 0.49772870540618896}, {"wallTime": 1733068040.7876184, "step": 380, "value": 0.36892879009246826}, {"wallTime": 1733068050.1600337, "step": 390, "value": 0.3925211429595947}, {"wallTime": 1733068059.1259093, "step": 400, "value": 0.29772624373435974}, {"wallTime": 1733068068.089934, "step": 410, "value": 0.6687220931053162}, {"wallTime": 1733068084.8438337, "step": 420, "value": 0.3847324252128601}, {"wallTime": 1733068094.6664479, "step": 430, "value": 0.5026352405548096}, {"wallTime": 1733068103.7079532, "step": 440, "value": 0.3435211777687073}, {"wallTime": 1733068112.6995747, "step": 450, "value": 0.4298660159111023}, {"wallTime": 1733068121.5009894, "step": 460, "value": 0.5339593291282654}, {"wallTime": 1733068130.7277598, "step": 470, "value": 0.39578673243522644}, {"wallTime": 1733068139.8557444, "step": 480, "value": 0.40460440516471863}, {"wallTime": 1733068149.3701322, "step": 490, "value": 0.5335665345191956}, {"wallTime": 1733068158.0701396, "step": 500, "value": 0.5216072797775269}, {"wallTime": 1733068174.115226, "step": 510, "value": 0.48046332597732544}, {"wallTime": 1733068182.719723, "step": 520, "value": 0.3793274164199829}, {"wallTime": 1733068192.4137268, "step": 530, "value": 0.40164506435394287}, {"wallTime": 1733068201.8082747, "step": 540, "value": 0.39107829332351685}, {"wallTime": 1733068210.6546686, "step": 550, "value": 0.5914725661277771}, {"wallTime": 1733068220.1952758, "step": 560, "value": 0.7245988845825195}, {"wallTime": 1733068229.1595163, "step": 570, "value": 0.3160843849182129}, {"wallTime": 1733068238.5917327, "step": 580, "value": 0.29227975010871887}, {"wallTime": 1733068256.0737114, "step": 590, "value": 0.4234974980354309}, {"wallTime": 1733068265.4320452, "step": 600, "value": 0.4998519718647003}, {"wallTime": 1733068274.6567032, "step": 610, "value": 0.663028359413147}, {"wallTime": 1733068283.7702296, "step": 620, "value": 0.5912083387374878}, {"wallTime": 1733068293.334347, "step": 630, "value": 0.4561246633529663}, {"wallTime": 1733068302.6473653, "step": 640, "value": 0.38306924700737}, {"wallTime": 1733068311.3883464, "step": 650, "value": 0.34279942512512207}, {"wallTime": 1733068320.3903368, "step": 660, "value": 0.4527305066585541}, {"wallTime": 1733068328.7314696, "step": 670, "value": 0.3687518835067749}, {"wallTime": 1733068344.4613838, "step": 680, "value": 0.39783787727355957}, {"wallTime": 1733068353.7171865, "step": 690, "value": 0.35578447580337524}, {"wallTime": 1733068362.0581522, "step": 700, "value": 0.33099377155303955}, {"wallTime": 1733068371.104276, "step": 710, "value": 0.5224176049232483}, {"wallTime": 1733068380.5334182, "step": 720, "value": 0.40702101588249207}, {"wallTime": 1733068390.0869637, "step": 730, "value": 0.3151842951774597}, {"wallTime": 1733068398.7212794, "step": 740, "value": 0.46458327770233154}, {"wallTime": 1733068407.1242583, "step": 750, "value": 0.409241646528244}, {"wallTime": 1733068423.0710828, "step": 760, "value": 0.4108909070491791}, {"wallTime": 1733068431.4056597, "step": 770, "value": 0.3302742540836334}, {"wallTime": 1733068440.4252455, "step": 780, "value": 0.3541812598705292}, {"wallTime": 1733068449.0068924, "step": 790, "value": 0.37511464953422546}, {"wallTime": 1733068457.6379051, "step": 800, "value": 0.399139404296875}, {"wallTime": 1733068467.0475526, "step": 810, "value": 0.380034863948822}, {"wallTime": 1733068475.6207964, "step": 820, "value": 0.37370410561561584}, {"wallTime": 1733068484.9793591, "step": 830, "value": 0.3770962357521057}, {"wallTime": 1733068500.7319787, "step": 840, "value": 0.40632152557373047}, {"wallTime": 1733068509.3082469, "step": 850, "value": 0.41733425855636597}, {"wallTime": 1733068519.0226724, "step": 860, "value": 0.41392382979393005}, {"wallTime": 1733068527.4990373, "step": 870, "value": 0.33132678270339966}, {"wallTime": 1733068536.9207842, "step": 880, "value": 0.484712153673172}, {"wallTime": 1733068544.909315, "step": 890, "value": 0.35365283489227295}, {"wallTime": 1733068553.5796003, "step": 900, "value": 0.37566298246383667}, {"wallTime": 1733068562.6865563, "step": 910, "value": 0.4159557521343231}, {"wallTime": 1733068571.2469401, "step": 920, "value": 0.3412766754627228}, {"wallTime": 1733068584.7769918, "step": 930, "value": 0.38662558794021606}, {"wallTime": 1733068593.773397, "step": 940, "value": 0.3717288374900818}, {"wallTime": 1733068602.7674456, "step": 950, "value": 0.4526767432689667}, {"wallTime": 1733068611.0414631, "step": 960, "value": 0.2866344749927521}, {"wallTime": 1733068620.228311, "step": 970, "value": 0.3350764214992523}, {"wallTime": 1733068628.843429, "step": 980, "value": 0.4063543379306793}, {"wallTime": 1733068637.6322014, "step": 990, "value": 0.33572614192962646}, {"wallTime": 1733068646.6748154, "step": 1000, "value": 0.3925004005432129}, {"wallTime": 1733068662.7585726, "step": 1010, "value": 0.25172698497772217}, {"wallTime": 1733068672.0563035, "step": 1020, "value": 0.3018604815006256}, {"wallTime": 1733068680.5649388, "step": 1030, "value": 0.32916533946990967}, {"wallTime": 1733068690.1878586, "step": 1040, "value": 0.3571162223815918}, {"wallTime": 1733068698.8502667, "step": 1050, "value": 0.34047240018844604}, {"wallTime": 1733068707.74538, "step": 1060, "value": 0.7617201805114746}, {"wallTime": 1733068717.3465927, "step": 1070, "value": 0.3398570716381073}, {"wallTime": 1733068726.3633616, "step": 1080, "value": 0.41800203919410706}, {"wallTime": 1733068735.2537844, "step": 1090, "value": 0.44892799854278564}, {"wallTime": 1733068749.549918, "step": 1100, "value": 0.3581875264644623}, {"wallTime": 1733068758.3773715, "step": 1110, "value": 0.447238951921463}, {"wallTime": 1733068767.0058486, "step": 1120, "value": 0.525993824005127}, {"wallTime": 1733068776.6208227, "step": 1130, "value": 0.46085041761398315}, {"wallTime": 1733068785.403246, "step": 1140, "value": 0.24226102232933044}, {"wallTime": 1733068794.2809842, "step": 1150, "value": 0.4077049493789673}, {"wallTime": 1733068802.699331, "step": 1160, "value": 0.2750876247882843}, {"wallTime": 1733068811.5536418, "step": 1170, "value": 0.39223653078079224}, {"wallTime": 1733068824.967687, "step": 1180, "value": 0.2277223914861679}, {"wallTime": 1733068834.3791926, "step": 1190, "value": 0.3708103597164154}, {"wallTime": 1733068843.5181482, "step": 1200, "value": 0.45223701000213623}, {"wallTime": 1733068852.230481, "step": 1210, "value": 0.3492865264415741}, {"wallTime": 1733068861.1189332, "step": 1220, "value": 0.3620923161506653}, {"wallTime": 1733068870.0578697, "step": 1230, "value": 0.6337267756462097}, {"wallTime": 1733068878.7223659, "step": 1240, "value": 0.4251590073108673}, {"wallTime": 1733068887.7401175, "step": 1250, "value": 0.3327803611755371}, {"wallTime": 1733068903.1687734, "step": 1260, "value": 0.4801090359687805}, {"wallTime": 1733068912.4170074, "step": 1270, "value": 0.273013174533844}, {"wallTime": 1733068921.475374, "step": 1280, "value": 0.3471888601779938}, {"wallTime": 1733068929.7486346, "step": 1290, "value": 0.3828348219394684}, {"wallTime": 1733068939.503351, "step": 1300, "value": 0.3380557894706726}, {"wallTime": 1733068948.929717, "step": 1310, "value": 0.39446377754211426}, {"wallTime": 1733068957.2364218, "step": 1320, "value": 0.48959869146347046}, {"wallTime": 1733068966.0790243, "step": 1330, "value": 0.282460480928421}, {"wallTime": 1733068975.5671728, "step": 1340, "value": 0.5302631855010986}, {"wallTime": 1733068989.8003623, "step": 1350, "value": 0.38618969917297363}, {"wallTime": 1733068998.2839959, "step": 1360, "value": 0.2911321818828583}, {"wallTime": 1733069007.1508534, "step": 1370, "value": 0.35319995880126953}, {"wallTime": 1733069015.9234881, "step": 1380, "value": 0.20313259959220886}, {"wallTime": 1733069025.3052242, "step": 1390, "value": 0.3661660850048065}, {"wallTime": 1733069034.4833896, "step": 1400, "value": 0.27203065156936646}, {"wallTime": 1733069042.7949333, "step": 1410, "value": 0.4278985857963562}, {"wallTime": 1733069052.139462, "step": 1420, "value": 0.2586922347545624}, {"wallTime": 1733069065.0035162, "step": 1430, "value": 0.29939475655555725}, {"wallTime": 1733069074.5258708, "step": 1440, "value": 0.32103466987609863}, {"wallTime": 1733069083.784447, "step": 1450, "value": 0.3845358192920685}, {"wallTime": 1733069092.2601562, "step": 1460, "value": 0.2927987575531006}, {"wallTime": 1733069101.0315228, "step": 1470, "value": 0.34351229667663574}, {"wallTime": 1733069109.9073648, "step": 1480, "value": 0.3017939329147339}, {"wallTime": 1733069119.1196616, "step": 1490, "value": 0.2320830523967743}, {"wallTime": 1733069128.4169831, "step": 1500, "value": 0.32331132888793945}, {"wallTime": 1733069137.6075673, "step": 1510, "value": 0.4584472179412842}, {"wallTime": 1733069150.5443285, "step": 1520, "value": 0.39671915769577026}, {"wallTime": 1733069159.7578623, "step": 1530, "value": 0.43983787298202515}, {"wallTime": 1733069168.1711419, "step": 1540, "value": 0.2007925808429718}, {"wallTime": 1733069176.841737, "step": 1550, "value": 0.43275052309036255}, {"wallTime": 1733069185.8930626, "step": 1560, "value": 0.23377463221549988}, {"wallTime": 1733069194.924821, "step": 1570, "value": 0.38019612431526184}, {"wallTime": 1733069203.913736, "step": 1580, "value": 0.3143974542617798}, {"wallTime": 1733069212.7165453, "step": 1590, "value": 0.2629874050617218}, {"wallTime": 1733069225.5346568, "step": 1600, "value": 0.28921037912368774}, {"wallTime": 1733069235.4646037, "step": 1610, "value": 0.4445868730545044}, {"wallTime": 1733069244.630603, "step": 1620, "value": 0.4981991946697235}, {"wallTime": 1733069254.2723968, "step": 1630, "value": 0.3387187123298645}, {"wallTime": 1733069263.0060751, "step": 1640, "value": 0.25790727138519287}, {"wallTime": 1733069271.8674395, "step": 1650, "value": 0.4420566260814667}, {"wallTime": 1733069280.510657, "step": 1660, "value": 0.27493125200271606}, {"wallTime": 1733069289.6804953, "step": 1670, "value": 0.3771825432777405}, {"wallTime": 1733069303.6105363, "step": 1680, "value": 0.48882025480270386}, {"wallTime": 1733069312.4803724, "step": 1690, "value": 0.3857996463775635}, {"wallTime": 1733069321.8393753, "step": 1700, "value": 0.4644598364830017}, {"wallTime": 1733069330.3487604, "step": 1710, "value": 0.29657772183418274}, {"wallTime": 1733069339.246013, "step": 1720, "value": 0.23385071754455566}, {"wallTime": 1733069346.8583486, "step": 1730, "value": 0.24575480818748474}, {"wallTime": 1733069355.6541286, "step": 1740, "value": 0.45576733350753784}, {"wallTime": 1733069364.5128117, "step": 1750, "value": 0.3587580919265747}, {"wallTime": 1733069373.7393966, "step": 1760, "value": 0.3198278546333313}, {"wallTime": 1733069387.5418055, "step": 1770, "value": 0.308614581823349}, {"wallTime": 1733069396.4682806, "step": 1780, "value": 0.26230481266975403}, {"wallTime": 1733069405.997029, "step": 1790, "value": 0.2030448019504547}, {"wallTime": 1733069415.05454, "step": 1800, "value": 0.2520764172077179}, {"wallTime": 1733069423.9082382, "step": 1810, "value": 0.2121165543794632}, {"wallTime": 1733069432.5318844, "step": 1820, "value": 0.415901243686676}, {"wallTime": 1733069441.2186122, "step": 1830, "value": 0.33531731367111206}, {"wallTime": 1733069450.0888987, "step": 1840, "value": 0.24106493592262268}, {"wallTime": 1733069463.1073968, "step": 1850, "value": 0.2333773672580719}, {"wallTime": 1733069471.5733633, "step": 1860, "value": 0.26089972257614136}, {"wallTime": 1733069480.4985754, "step": 1870, "value": 0.5195370316505432}, {"wallTime": 1733069489.3852582, "step": 1880, "value": 0.420540452003479}, {"wallTime": 1733069497.9770548, "step": 1890, "value": 0.4226766526699066}, {"wallTime": 1733069506.794616, "step": 1900, "value": 0.31984028220176697}, {"wallTime": 1733069515.8249886, "step": 1910, "value": 0.24336963891983032}, {"wallTime": 1733069524.636841, "step": 1920, "value": 0.2874487340450287}, {"wallTime": 1733069533.5424373, "step": 1930, "value": 0.21752966940402985}, {"wallTime": 1733069550.4782617, "step": 1940, "value": 0.37144720554351807}, {"wallTime": 1733069558.8282995, "step": 1950, "value": 0.2618645131587982}, {"wallTime": 1733069567.758196, "step": 1960, "value": 0.260277658700943}, {"wallTime": 1733069576.3454754, "step": 1970, "value": 0.2630215585231781}, {"wallTime": 1733069585.52947, "step": 1980, "value": 0.4078219532966614}, {"wallTime": 1733069594.3505175, "step": 1990, "value": 0.38775041699409485}, {"wallTime": 1733069602.4019518, "step": 2000, "value": 0.5760974287986755}, {"wallTime": 1733069610.2502596, "step": 2010, "value": 0.47109755873680115}, {"wallTime": 1733069626.6871026, "step": 2020, "value": 0.4072880744934082}, {"wallTime": 1733069635.0311933, "step": 2030, "value": 0.27182692289352417}, {"wallTime": 1733069643.822835, "step": 2040, "value": 0.2541438639163971}, {"wallTime": 1733069652.1947143, "step": 2050, "value": 0.2988937795162201}, {"wallTime": 1733069660.453726, "step": 2060, "value": 0.42544540762901306}, {"wallTime": 1733069669.59234, "step": 2070, "value": 0.33586445450782776}, {"wallTime": 1733069678.7786255, "step": 2080, "value": 0.5299047827720642}, {"wallTime": 1733069686.9450994, "step": 2090, "value": 0.40094539523124695}, {"wallTime": 1733069700.60231, "step": 2100, "value": 0.32616111636161804}, {"wallTime": 1733069708.7265959, "step": 2110, "value": 0.2421240210533142}, {"wallTime": 1733069717.4485247, "step": 2120, "value": 0.29832321405410767}, {"wallTime": 1733069726.1414905, "step": 2130, "value": 0.3074462413787842}, {"wallTime": 1733069735.0383506, "step": 2140, "value": 0.33784061670303345}, {"wallTime": 1733069743.3063602, "step": 2150, "value": 0.27943265438079834}, {"wallTime": 1733069752.5010564, "step": 2160, "value": 0.3244900107383728}, {"wallTime": 1733069761.451205, "step": 2170, "value": 0.3202696442604065}, {"wallTime": 1733069770.4333875, "step": 2180, "value": 0.3931383490562439}, {"wallTime": 1733069784.3638144, "step": 2190, "value": 0.365197092294693}, {"wallTime": 1733069793.122723, "step": 2200, "value": 0.17417803406715393}, {"wallTime": 1733069801.6363263, "step": 2210, "value": 0.29088157415390015}, {"wallTime": 1733069810.6080985, "step": 2220, "value": 0.4193737506866455}, {"wallTime": 1733069819.3423016, "step": 2230, "value": 0.2577347159385681}, {"wallTime": 1733069827.3262758, "step": 2240, "value": 0.39118486642837524}, {"wallTime": 1733069835.8681228, "step": 2250, "value": 0.28140023350715637}, {"wallTime": 1733069844.2360575, "step": 2260, "value": 0.3201749324798584}, {"wallTime": 1733069856.7493134, "step": 2270, "value": 0.26086336374282837}, {"wallTime": 1733069865.257748, "step": 2280, "value": 0.2134561538696289}, {"wallTime": 1733069874.005907, "step": 2290, "value": 0.19328421354293823}, {"wallTime": 1733069881.7817698, "step": 2300, "value": 0.37340047955513}, {"wallTime": 1733069890.4139092, "step": 2310, "value": 0.2555195093154907}, {"wallTime": 1733069898.8766823, "step": 2320, "value": 0.2748355567455292}, {"wallTime": 1733069908.3177805, "step": 2330, "value": 0.26844045519828796}, {"wallTime": 1733069917.415215, "step": 2340, "value": 0.36751848459243774}, {"wallTime": 1733069925.8506372, "step": 2350, "value": 0.2307632565498352}, {"wallTime": 1733069938.7028487, "step": 2360, "value": 0.34486109018325806}, {"wallTime": 1733069947.426173, "step": 2370, "value": 0.3730739951133728}, {"wallTime": 1733069956.2067482, "step": 2380, "value": 0.407029926776886}, {"wallTime": 1733069964.2747545, "step": 2390, "value": 0.2963036894798279}, {"wallTime": 1733069973.326096, "step": 2400, "value": 0.2276274710893631}, {"wallTime": 1733069981.432137, "step": 2410, "value": 0.25690796971321106}, {"wallTime": 1733069990.139681, "step": 2420, "value": 0.2826524078845978}, {"wallTime": 1733069998.7981, "step": 2430, "value": 0.30805453658103943}, {"wallTime": 1733070012.4557319, "step": 2440, "value": 0.27501198649406433}, {"wallTime": 1733070021.5989146, "step": 2450, "value": 0.2474023997783661}, {"wallTime": 1733070030.1909409, "step": 2460, "value": 0.2591733932495117}, {"wallTime": 1733070039.2192934, "step": 2470, "value": 0.2853323221206665}, {"wallTime": 1733070048.2688832, "step": 2480, "value": 0.36002084612846375}, {"wallTime": 1733070056.1556718, "step": 2490, "value": 0.3876466751098633}, {"wallTime": 1733070064.4505668, "step": 2500, "value": 0.3548946678638458}, {"wallTime": 1733070072.5505457, "step": 2510, "value": 0.24551603198051453}, {"wallTime": 1733070087.656791, "step": 2520, "value": 0.29099413752555847}, {"wallTime": 1733070095.4416215, "step": 2530, "value": 0.2669614851474762}, {"wallTime": 1733070103.7687929, "step": 2540, "value": 0.24362564086914062}, {"wallTime": 1733070113.0491576, "step": 2550, "value": 0.23978398740291595}, {"wallTime": 1733070121.0377495, "step": 2560, "value": 0.24489648640155792}, {"wallTime": 1733070129.5843341, "step": 2570, "value": 0.2991619408130646}, {"wallTime": 1733070138.3607123, "step": 2580, "value": 0.2651086747646332}, {"wallTime": 1733070147.0872033, "step": 2590, "value": 0.3470684885978699}, {"wallTime": 1733070155.4868908, "step": 2600, "value": 0.442903608083725}, {"wallTime": 1733070172.5772007, "step": 2610, "value": 0.3072294294834137}, {"wallTime": 1733070181.2111366, "step": 2620, "value": 0.33080044388771057}, {"wallTime": 1733070189.692307, "step": 2630, "value": 0.27695563435554504}, {"wallTime": 1733070198.3990648, "step": 2640, "value": 0.2674602270126343}, {"wallTime": 1733070206.7073143, "step": 2650, "value": 0.21362841129302979}, {"wallTime": 1733070215.5996091, "step": 2660, "value": 0.3345049023628235}, {"wallTime": 1733070224.3158689, "step": 2670, "value": 0.3274328112602234}, {"wallTime": 1733070233.5393097, "step": 2680, "value": 0.2811466455459595}, {"wallTime": 1733070246.7580807, "step": 2690, "value": 0.2589438259601593}, {"wallTime": 1733070256.0289714, "step": 2700, "value": 0.39532262086868286}, {"wallTime": 1733070264.9507136, "step": 2710, "value": 0.25956910848617554}, {"wallTime": 1733070273.80463, "step": 2720, "value": 0.34025028347969055}, {"wallTime": 1733070282.9589977, "step": 2730, "value": 0.30136024951934814}, {"wallTime": 1733070292.2778382, "step": 2740, "value": 0.2884413003921509}, {"wallTime": 1733070300.3366933, "step": 2750, "value": 0.27601706981658936}, {"wallTime": 1733070309.4121048, "step": 2760, "value": 0.42888057231903076}, {"wallTime": 1733070317.5314224, "step": 2770, "value": 0.40364858508110046}, {"wallTime": 1733070330.4360816, "step": 2780, "value": 0.32759010791778564}, {"wallTime": 1733070339.8229222, "step": 2790, "value": 0.26162612438201904}, {"wallTime": 1733070347.9934368, "step": 2800, "value": 0.20331519842147827}, {"wallTime": 1733070356.892495, "step": 2810, "value": 0.29380398988723755}, {"wallTime": 1733070365.5769513, "step": 2820, "value": 0.26797524094581604}, {"wallTime": 1733070374.3932943, "step": 2830, "value": 0.27011916041374207}, {"wallTime": 1733070382.4269307, "step": 2840, "value": 0.3426685333251953}, {"wallTime": 1733070390.9412858, "step": 2850, "value": 0.23695188760757446}, {"wallTime": 1733070406.6786747, "step": 2860, "value": 0.2519775927066803}, {"wallTime": 1733070415.0899463, "step": 2870, "value": 0.2443784773349762}, {"wallTime": 1733070422.9199624, "step": 2880, "value": 0.23006463050842285}, {"wallTime": 1733070431.5373726, "step": 2890, "value": 0.25643935799598694}, {"wallTime": 1733070439.9808912, "step": 2900, "value": 0.3275698125362396}, {"wallTime": 1733070448.0854902, "step": 2910, "value": 0.41266846656799316}, {"wallTime": 1733070457.4237022, "step": 2920, "value": 0.4407784342765808}, {"wallTime": 1733070466.7228756, "step": 2930, "value": 0.3773528039455414}, {"wallTime": 1733070479.332489, "step": 2940, "value": 0.30678504705429077}, {"wallTime": 1733070488.7822964, "step": 2950, "value": 0.28908228874206543}, {"wallTime": 1733070497.224836, "step": 2960, "value": 0.3667529821395874}, {"wallTime": 1733070505.633795, "step": 2970, "value": 0.24200212955474854}, {"wallTime": 1733070513.3538501, "step": 2980, "value": 0.20403790473937988}, {"wallTime": 1733070522.3011148, "step": 2990, "value": 0.35656338930130005}, {"wallTime": 1733070530.2126243, "step": 3000, "value": 0.19583627581596375}, {"wallTime": 1733070538.2999504, "step": 3010, "value": 0.30392906069755554}, {"wallTime": 1733070547.4002168, "step": 3020, "value": 0.2508965730667114}, {"wallTime": 1733070564.0506988, "step": 3030, "value": 0.23632165789604187}, {"wallTime": 1733070572.369659, "step": 3040, "value": 0.23653218150138855}, {"wallTime": 1733070580.670849, "step": 3050, "value": 0.2721317410469055}, {"wallTime": 1733070588.6531384, "step": 3060, "value": 0.27372145652770996}, {"wallTime": 1733070597.4205735, "step": 3070, "value": 0.23957835137844086}, {"wallTime": 1733070606.137074, "step": 3080, "value": 0.37294310331344604}, {"wallTime": 1733070614.4394622, "step": 3090, "value": 0.3370058238506317}, {"wallTime": 1733070623.999888, "step": 3100, "value": 0.2801072895526886}, {"wallTime": 1733070637.2519445, "step": 3110, "value": 0.3444654047489166}, {"wallTime": 1733070645.6819034, "step": 3120, "value": 0.2973582148551941}, {"wallTime": 1733070654.2694952, "step": 3130, "value": 0.24151013791561127}, {"wallTime": 1733070663.3202586, "step": 3140, "value": 0.2483803927898407}, {"wallTime": 1733070671.117045, "step": 3150, "value": 0.33968013525009155}, {"wallTime": 1733070679.764527, "step": 3160, "value": 0.36930668354034424}, {"wallTime": 1733070687.844247, "step": 3170, "value": 0.25370779633522034}, {"wallTime": 1733070695.8547966, "step": 3180, "value": 0.32281607389450073}, {"wallTime": 1733070704.621419, "step": 3190, "value": 0.25294241309165955}, {"wallTime": 1733070717.1078131, "step": 3200, "value": 0.19869846105575562}, {"wallTime": 1733070726.097628, "step": 3210, "value": 0.29419928789138794}, {"wallTime": 1733070734.776157, "step": 3220, "value": 0.18465743958950043}, {"wallTime": 1733070744.4113467, "step": 3230, "value": 0.2798713445663452}, {"wallTime": 1733070752.500614, "step": 3240, "value": 0.4386003017425537}, {"wallTime": 1733070761.720109, "step": 3250, "value": 0.39145514369010925}, {"wallTime": 1733070770.3755615, "step": 3260, "value": 0.27150997519493103}, {"wallTime": 1733070779.729033, "step": 3270, "value": 0.25841018557548523}, {"wallTime": 1733070793.677434, "step": 3280, "value": 0.23803508281707764}, {"wallTime": 1733070801.8989992, "step": 3290, "value": 0.38623079657554626}, {"wallTime": 1733070810.160028, "step": 3300, "value": 0.34352555871009827}, {"wallTime": 1733070818.7254987, "step": 3310, "value": 0.17854878306388855}, {"wallTime": 1733070827.0062869, "step": 3320, "value": 0.2279435694217682}, {"wallTime": 1733070835.5737798, "step": 3330, "value": 0.2712876498699188}, {"wallTime": 1733070843.973891, "step": 3340, "value": 0.4056650996208191}, {"wallTime": 1733070853.0906887, "step": 3350, "value": 0.3220245838165283}, {"wallTime": 1733070865.4185152, "step": 3360, "value": 0.20795780420303345}, {"wallTime": 1733070873.6606672, "step": 3370, "value": 0.25820714235305786}, {"wallTime": 1733070883.3350232, "step": 3380, "value": 0.23878586292266846}, {"wallTime": 1733070892.3760417, "step": 3390, "value": 0.27161097526550293}, {"wallTime": 1733070900.7213862, "step": 3400, "value": 0.3130490183830261}, {"wallTime": 1733070908.5032125, "step": 3410, "value": 0.27857884764671326}, {"wallTime": 1733070916.6547983, "step": 3420, "value": 0.37216392159461975}, {"wallTime": 1733070925.2083914, "step": 3430, "value": 0.2567862272262573}, {"wallTime": 1733070933.8092928, "step": 3440, "value": 0.21328672766685486}, {"wallTime": 1733070947.4787953, "step": 3450, "value": 0.2402401566505432}, {"wallTime": 1733070956.1863527, "step": 3460, "value": 0.24744004011154175}, {"wallTime": 1733070964.2653303, "step": 3470, "value": 0.2630038857460022}, {"wallTime": 1733070972.3851542, "step": 3480, "value": 0.26861196756362915}, {"wallTime": 1733070980.6461468, "step": 3490, "value": 0.4607537090778351}, {"wallTime": 1733070989.6867867, "step": 3500, "value": 0.24355977773666382}, {"wallTime": 1733070997.7875717, "step": 3510, "value": 0.23303568363189697}, {"wallTime": 1733071006.270449, "step": 3520, "value": 0.3245103359222412}, {"wallTime": 1733071018.89513, "step": 3530, "value": 0.24009570479393005}, {"wallTime": 1733071027.1962256, "step": 3540, "value": 0.17778991162776947}, {"wallTime": 1733071035.319614, "step": 3550, "value": 0.2632920742034912}, {"wallTime": 1733071043.744853, "step": 3560, "value": 0.21969416737556458}, {"wallTime": 1733071051.8712542, "step": 3570, "value": 0.28599095344543457}, {"wallTime": 1733071060.495232, "step": 3580, "value": 0.24736493825912476}, {"wallTime": 1733071068.8785584, "step": 3590, "value": 0.25663068890571594}, {"wallTime": 1733071077.7120738, "step": 3600, "value": 0.2780255079269409}, {"wallTime": 1733071086.211534, "step": 3610, "value": 0.21650023758411407}, {"wallTime": 1733071101.657849, "step": 3620, "value": 0.2385314404964447}, {"wallTime": 1733071109.619999, "step": 3630, "value": 0.282715767621994}, {"wallTime": 1733071118.128432, "step": 3640, "value": 0.25499850511550903}, {"wallTime": 1733071126.9923193, "step": 3650, "value": 0.2119876742362976}, {"wallTime": 1733071135.8266158, "step": 3660, "value": 0.3130750358104706}, {"wallTime": 1733071144.2475169, "step": 3670, "value": 0.22167401015758514}, {"wallTime": 1733071152.9636421, "step": 3680, "value": 0.24148181080818176}, {"wallTime": 1733071160.6026356, "step": 3690, "value": 0.2573021352291107}, {"wallTime": 1733071173.7494972, "step": 3700, "value": 0.26106902956962585}, {"wallTime": 1733071182.8824584, "step": 3710, "value": 0.2661355435848236}, {"wallTime": 1733071191.2092874, "step": 3720, "value": 0.313183069229126}, {"wallTime": 1733071200.3326638, "step": 3730, "value": 0.5735841393470764}, {"wallTime": 1733071208.364931, "step": 3740, "value": 0.280414879322052}, {"wallTime": 1733071216.571128, "step": 3750, "value": 0.201498880982399}, {"wallTime": 1733071224.661133, "step": 3760, "value": 0.16983139514923096}, {"wallTime": 1733071232.859927, "step": 3770, "value": 0.1635921746492386}, {"wallTime": 1733071248.532633, "step": 3780, "value": 0.3570113182067871}, {"wallTime": 1733071257.3910174, "step": 3790, "value": 0.4243650436401367}, {"wallTime": 1733071265.5665648, "step": 3800, "value": 0.19337059557437897}, {"wallTime": 1733071274.1973197, "step": 3810, "value": 0.30935126543045044}, {"wallTime": 1733071283.0172012, "step": 3820, "value": 0.22907449305057526}, {"wallTime": 1733071291.729055, "step": 3830, "value": 0.1770164966583252}, {"wallTime": 1733071299.8923883, "step": 3840, "value": 0.20797660946846008}, {"wallTime": 1733071308.4787493, "step": 3850, "value": 0.28448110818862915}, {"wallTime": 1733071316.9508307, "step": 3860, "value": 0.3049167990684509}, {"wallTime": 1733071330.2143357, "step": 3870, "value": 0.2233383059501648}, {"wallTime": 1733071338.9883103, "step": 3880, "value": 0.24045781791210175}, {"wallTime": 1733071347.736246, "step": 3890, "value": 0.21511715650558472}, {"wallTime": 1733071357.033997, "step": 3900, "value": 0.21619707345962524}, {"wallTime": 1733071365.2249045, "step": 3910, "value": 0.29530712962150574}, {"wallTime": 1733071374.134203, "step": 3920, "value": 0.4590294063091278}, {"wallTime": 1733071382.8133965, "step": 3930, "value": 0.2979811429977417}, {"wallTime": 1733071391.5679896, "step": 3940, "value": 0.25590425729751587}, {"wallTime": 1733071404.4668283, "step": 3950, "value": 0.23275533318519592}, {"wallTime": 1733071412.338462, "step": 3960, "value": 0.2552318274974823}, {"wallTime": 1733071421.1571577, "step": 3970, "value": 0.2731834053993225}, {"wallTime": 1733071430.1201506, "step": 3980, "value": 0.19478803873062134}, {"wallTime": 1733071438.413612, "step": 3990, "value": 0.3724633455276489}, {"wallTime": 1733071447.7284553, "step": 4000, "value": 0.35324668884277344}, {"wallTime": 1733071456.196233, "step": 4010, "value": 0.2917415499687195}, {"wallTime": 1733071464.7490907, "step": 4020, "value": 0.2491370141506195}, {"wallTime": 1733071473.3968303, "step": 4030, "value": 0.3256910741329193}, {"wallTime": 1733071490.286052, "step": 4040, "value": 0.247211292386055}, {"wallTime": 1733071498.7113814, "step": 4050, "value": 0.23630473017692566}, {"wallTime": 1733071507.0972, "step": 4060, "value": 0.19165469706058502}, {"wallTime": 1733071515.0675051, "step": 4070, "value": 0.28571268916130066}, {"wallTime": 1733071523.8809326, "step": 4080, "value": 0.2718605399131775}, {"wallTime": 1733071532.2851179, "step": 4090, "value": 0.1965322494506836}, {"wallTime": 1733071540.9174786, "step": 4100, "value": 0.2165621668100357}, {"wallTime": 1733071549.1760411, "step": 4110, "value": 0.18347957730293274}, {"wallTime": 1733071565.835902, "step": 4120, "value": 0.226017564535141}, {"wallTime": 1733071573.6316166, "step": 4130, "value": 0.1607952117919922}, {"wallTime": 1733071582.0962245, "step": 4140, "value": 0.41961026191711426}, {"wallTime": 1733071590.0227666, "step": 4150, "value": 0.16087204217910767}, {"wallTime": 1733071599.2410915, "step": 4160, "value": 0.7093356847763062}, {"wallTime": 1733071608.071837, "step": 4170, "value": 0.25379160046577454}, {"wallTime": 1733071616.1840038, "step": 4180, "value": 0.31306561827659607}, {"wallTime": 1733071626.0830739, "step": 4190, "value": 0.15955501794815063}, {"wallTime": 1733071641.0082448, "step": 4200, "value": 0.24502456188201904}, {"wallTime": 1733071649.0410104, "step": 4210, "value": 0.20163100957870483}, {"wallTime": 1733071658.531767, "step": 4220, "value": 0.2799375057220459}, {"wallTime": 1733071667.9664464, "step": 4230, "value": 0.3238725960254669}, {"wallTime": 1733071676.1091597, "step": 4240, "value": 0.20839788019657135}, {"wallTime": 1733071684.3789687, "step": 4250, "value": 0.31406596302986145}, {"wallTime": 1733071693.1100523, "step": 4260, "value": 0.28895363211631775}, {"wallTime": 1733071702.1843162, "step": 4270, "value": 0.2115534096956253}, {"wallTime": 1733071710.6307938, "step": 4280, "value": 0.3221556842327118}, {"wallTime": 1733071726.677157, "step": 4290, "value": 0.2639176547527313}, {"wallTime": 1733071735.2160103, "step": 4300, "value": 0.2667478322982788}, {"wallTime": 1733071742.9575222, "step": 4310, "value": 0.26250186562538147}, {"wallTime": 1733071751.5861707, "step": 4320, "value": 0.4245612323284149}, {"wallTime": 1733071760.0352128, "step": 4330, "value": 0.2764208912849426}, {"wallTime": 1733071768.4317768, "step": 4340, "value": 0.18080942332744598}, {"wallTime": 1733071777.4026017, "step": 4350, "value": 0.2969862222671509}, {"wallTime": 1733071785.5477972, "step": 4360, "value": 0.27324867248535156}, {"wallTime": 1733071800.885204, "step": 4370, "value": 0.35793158411979675}, {"wallTime": 1733071809.2663188, "step": 4380, "value": 0.2421693354845047}, {"wallTime": 1733071817.3468692, "step": 4390, "value": 0.2054120898246765}, {"wallTime": 1733071826.4308796, "step": 4400, "value": 0.3055386245250702}, {"wallTime": 1733071834.8880591, "step": 4410, "value": 0.2934902310371399}, {"wallTime": 1733071843.4473386, "step": 4420, "value": 0.2575441896915436}, {"wallTime": 1733071851.59649, "step": 4430, "value": 0.2463504672050476}, {"wallTime": 1733071859.9245892, "step": 4440, "value": 0.25798338651657104}, {"wallTime": 1733071868.6736958, "step": 4450, "value": 0.24519018828868866}, {"wallTime": 1733071881.3366127, "step": 4460, "value": 0.22660233080387115}, {"wallTime": 1733071889.6371474, "step": 4470, "value": 0.23912347853183746}, {"wallTime": 1733071898.4212868, "step": 4480, "value": 0.26833176612854004}, {"wallTime": 1733071907.3364706, "step": 4490, "value": 0.2289033830165863}, {"wallTime": 1733071916.2786586, "step": 4500, "value": 0.32897281646728516}, {"wallTime": 1733071925.3491452, "step": 4510, "value": 0.3632352948188782}, {"wallTime": 1733071933.3297894, "step": 4520, "value": 0.15204861760139465}, {"wallTime": 1733071941.483121, "step": 4530, "value": 0.16443383693695068}, {"wallTime": 1733071954.1693635, "step": 4540, "value": 0.2338559776544571}, {"wallTime": 1733071962.3961804, "step": 4550, "value": 0.18832863867282867}, {"wallTime": 1733071970.5137484, "step": 4560, "value": 0.26481661200523376}, {"wallTime": 1733071978.8703167, "step": 4570, "value": 0.37099456787109375}, {"wallTime": 1733071987.7108638, "step": 4580, "value": 0.2966652810573578}, {"wallTime": 1733071996.4450064, "step": 4590, "value": 0.387528657913208}, {"wallTime": 1733072004.4762907, "step": 4600, "value": 0.19274663925170898}, {"wallTime": 1733072012.7450337, "step": 4610, "value": 0.18156656622886658}, {"wallTime": 1733072025.4004254, "step": 4620, "value": 0.19899992644786835}, {"wallTime": 1733072034.1184988, "step": 4630, "value": 0.18961438536643982}, {"wallTime": 1733072043.0377572, "step": 4640, "value": 0.31264814734458923}, {"wallTime": 1733072051.7855332, "step": 4650, "value": 0.2519025206565857}, {"wallTime": 1733072060.1082845, "step": 4660, "value": 0.24454699456691742}, {"wallTime": 1733072068.6030557, "step": 4670, "value": 0.2729768753051758}, {"wallTime": 1733072076.8364382, "step": 4680, "value": 0.26893702149391174}, {"wallTime": 1733072085.3758812, "step": 4690, "value": 0.28680408000946045}, {"wallTime": 1733072093.7483275, "step": 4700, "value": 0.21419821679592133}, {"wallTime": 1733072106.989439, "step": 4710, "value": 0.25876539945602417}, {"wallTime": 1733072115.6649394, "step": 4720, "value": 0.41598600149154663}, {"wallTime": 1733072123.9503474, "step": 4730, "value": 0.3241477906703949}, {"wallTime": 1733072132.2804012, "step": 4740, "value": 0.22825582325458527}, {"wallTime": 1733072140.420302, "step": 4750, "value": 0.19417187571525574}, {"wallTime": 1733072149.086883, "step": 4760, "value": 0.21381555497646332}, {"wallTime": 1733072157.4115367, "step": 4770, "value": 0.23978827893733978}, {"wallTime": 1733072165.4890485, "step": 4780, "value": 0.2715410590171814}, {"wallTime": 1733072179.6485937, "step": 4790, "value": 0.25898632407188416}, {"wallTime": 1733072188.3293884, "step": 4800, "value": 0.19411972165107727}, {"wallTime": 1733072196.8467112, "step": 4810, "value": 0.25920620560646057}, {"wallTime": 1733072204.5619767, "step": 4820, "value": 0.2031019628047943}, {"wallTime": 1733072213.0993488, "step": 4830, "value": 0.36093443632125854}, {"wallTime": 1733072221.666796, "step": 4840, "value": 0.26457318663597107}, {"wallTime": 1733072229.8936923, "step": 4850, "value": 0.20372635126113892}, {"wallTime": 1733072238.0559344, "step": 4860, "value": 0.2429065704345703}, {"wallTime": 1733072246.3433046, "step": 4870, "value": 0.20071259140968323}, {"wallTime": 1733072261.267097, "step": 4880, "value": 0.22945049405097961}, {"wallTime": 1733072269.8523111, "step": 4890, "value": 0.22102725505828857}, {"wallTime": 1733072278.8801053, "step": 4900, "value": 0.285357266664505}, {"wallTime": 1733072287.5342844, "step": 4910, "value": 0.2013714760541916}, {"wallTime": 1733072295.9470375, "step": 4920, "value": 0.17786996066570282}, {"wallTime": 1733072304.3552089, "step": 4930, "value": 0.2651706337928772}, {"wallTime": 1733072313.5097094, "step": 4940, "value": 0.2638702392578125}, {"wallTime": 1733072321.3252006, "step": 4950, "value": 0.18796660006046295}, {"wallTime": 1733072337.0248241, "step": 4960, "value": 0.1648993194103241}, {"wallTime": 1733072345.5317178, "step": 4970, "value": 0.1773093342781067}, {"wallTime": 1733072353.42969, "step": 4980, "value": 0.2253793329000473}, {"wallTime": 1733072362.4131908, "step": 4990, "value": 0.24089694023132324}, {"wallTime": 1733072371.745889, "step": 5000, "value": 0.22921887040138245}, {"wallTime": 1733072380.5296311, "step": 5010, "value": 0.28996890783309937}, {"wallTime": 1733072389.0264144, "step": 5020, "value": 0.30459171533584595}, {"wallTime": 1733072397.7855287, "step": 5030, "value": 0.19627881050109863}, {"wallTime": 1733072411.2982657, "step": 5040, "value": 0.2199522852897644}, {"wallTime": 1733072419.474081, "step": 5050, "value": 0.2067287415266037}, {"wallTime": 1733072428.372228, "step": 5060, "value": 0.28755518794059753}, {"wallTime": 1733072437.1167238, "step": 5070, "value": 0.2662574350833893}, {"wallTime": 1733072446.1752405, "step": 5080, "value": 0.29038968682289124}, {"wallTime": 1733072454.428592, "step": 5090, "value": 0.19873066246509552}, {"wallTime": 1733072462.4105263, "step": 5100, "value": 0.24890679121017456}, {"wallTime": 1733072471.1501207, "step": 5110, "value": 0.2197532206773758}, {"wallTime": 1733072478.946581, "step": 5120, "value": 0.3015393316745758}, {"wallTime": 1733072491.3216348, "step": 5130, "value": 0.32556119561195374}, {"wallTime": 1733072499.258747, "step": 5140, "value": 0.16830267012119293}, {"wallTime": 1733072507.112094, "step": 5150, "value": 0.21884146332740784}, {"wallTime": 1733072515.3172274, "step": 5160, "value": 0.6168838739395142}, {"wallTime": 1733072523.5004869, "step": 5170, "value": 0.2741369307041168}, {"wallTime": 1733072531.0872586, "step": 5180, "value": 0.17419731616973877}, {"wallTime": 1733072540.022276, "step": 5190, "value": 0.23810379207134247}, {"wallTime": 1733072548.652509, "step": 5200, "value": 0.26460716128349304}, {"wallTime": 1733072561.415619, "step": 5210, "value": 0.20952799916267395}, {"wallTime": 1733072569.8967013, "step": 5220, "value": 0.2896248698234558}, {"wallTime": 1733072578.679338, "step": 5230, "value": 0.2670966386795044}, {"wallTime": 1733072586.9426086, "step": 5240, "value": 0.27292248606681824}, {"wallTime": 1733072595.0343332, "step": 5250, "value": 0.33573654294013977}, {"wallTime": 1733072603.1734223, "step": 5260, "value": 0.24657994508743286}, {"wallTime": 1733072611.0801837, "step": 5270, "value": 0.2752572000026703}, {"wallTime": 1733072619.955347, "step": 5280, "value": 0.2439536452293396}, {"wallTime": 1733072628.6345778, "step": 5290, "value": 0.23960310220718384}, {"wallTime": 1733072641.3755121, "step": 5300, "value": 0.2256244719028473}, {"wallTime": 1733072649.8582547, "step": 5310, "value": 0.16636909544467926}, {"wallTime": 1733072657.9712949, "step": 5320, "value": 0.1826833039522171}, {"wallTime": 1733072667.0295112, "step": 5330, "value": 0.29537317156791687}, {"wallTime": 1733072675.9430501, "step": 5340, "value": 0.2404165267944336}, {"wallTime": 1733072684.2384286, "step": 5350, "value": 0.3716413974761963}, {"wallTime": 1733072691.8581555, "step": 5360, "value": 0.24885627627372742}, {"wallTime": 1733072700.148012, "step": 5370, "value": 0.18614672124385834}, {"wallTime": 1733072713.1830616, "step": 5380, "value": 0.1887439340353012}, {"wallTime": 1733072721.0247219, "step": 5390, "value": 0.16515305638313293}, {"wallTime": 1733072729.8769555, "step": 5400, "value": 0.2256925255060196}, {"wallTime": 1733072738.3699157, "step": 5410, "value": 0.17913325130939484}, {"wallTime": 1733072746.3826983, "step": 5420, "value": 0.2498774528503418}, {"wallTime": 1733072754.6176736, "step": 5430, "value": 0.3136952221393585}, {"wallTime": 1733072762.547305, "step": 5440, "value": 0.18748046457767487}, {"wallTime": 1733072771.3606195, "step": 5450, "value": 0.24398057162761688}, {"wallTime": 1733072787.151721, "step": 5460, "value": 0.17901480197906494}, {"wallTime": 1733072795.80271, "step": 5470, "value": 0.25060319900512695}, {"wallTime": 1733072804.2420115, "step": 5480, "value": 0.16756784915924072}, {"wallTime": 1733072812.3730981, "step": 5490, "value": 0.2646525502204895}, {"wallTime": 1733072821.159212, "step": 5500, "value": 0.27472439408302307}, {"wallTime": 1733072830.0226228, "step": 5510, "value": 0.2945416569709778}, {"wallTime": 1733072838.6951046, "step": 5520, "value": 0.20730355381965637}, {"wallTime": 1733072846.9049537, "step": 5530, "value": 0.16966594755649567}, {"wallTime": 1733072855.2465856, "step": 5540, "value": 0.1975415050983429}, {"wallTime": 1733072870.6446233, "step": 5550, "value": 0.2833622694015503}, {"wallTime": 1733072878.7295756, "step": 5560, "value": 0.2753436267375946}, {"wallTime": 1733072886.6109214, "step": 5570, "value": 0.2332628071308136}, {"wallTime": 1733072895.0208497, "step": 5580, "value": 0.8560565114021301}, {"wallTime": 1733072903.4027321, "step": 5590, "value": 0.20857535302639008}, {"wallTime": 1733072911.2097676, "step": 5600, "value": 0.30877944827079773}, {"wallTime": 1733072919.8397045, "step": 5610, "value": 0.2599077522754669}, {"wallTime": 1733072928.7328014, "step": 5620, "value": 0.36863091588020325}, {"wallTime": 1733072941.7034495, "step": 5630, "value": 0.2032681107521057}, {"wallTime": 1733072949.9798667, "step": 5640, "value": 0.23382045328617096}, {"wallTime": 1733072958.7197163, "step": 5650, "value": 0.324810266494751}, {"wallTime": 1733072966.8145027, "step": 5660, "value": 0.20294813811779022}, {"wallTime": 1733072974.9619286, "step": 5670, "value": 0.18512535095214844}, {"wallTime": 1733072983.5617394, "step": 5680, "value": 0.2301594763994217}, {"wallTime": 1733072992.2283628, "step": 5690, "value": 0.25097423791885376}, {"wallTime": 1733073000.8169358, "step": 5700, "value": 0.19806206226348877}, {"wallTime": 1733073009.7830467, "step": 5710, "value": 0.24051876366138458}, {"wallTime": 1733073022.8679724, "step": 5720, "value": 0.3658287525177002}, {"wallTime": 1733073031.534311, "step": 5730, "value": 0.2889172434806824}, {"wallTime": 1733073039.5707395, "step": 5740, "value": 0.24404501914978027}, {"wallTime": 1733073047.8427224, "step": 5750, "value": 0.23777253925800323}, {"wallTime": 1733073056.156336, "step": 5760, "value": 0.184198796749115}, {"wallTime": 1733073064.9548936, "step": 5770, "value": 0.33998730778694153}, {"wallTime": 1733073073.8374813, "step": 5780, "value": 0.22197243571281433}, {"wallTime": 1733073082.7248876, "step": 5790, "value": 0.3175445795059204}, {"wallTime": 1733073095.1028101, "step": 5800, "value": 0.2184804528951645}, {"wallTime": 1733073103.3155756, "step": 5810, "value": 0.24583059549331665}, {"wallTime": 1733073111.9704607, "step": 5820, "value": 0.16234003007411957}, {"wallTime": 1733073120.3559556, "step": 5830, "value": 0.30513736605644226}, {"wallTime": 1733073128.2090764, "step": 5840, "value": 0.2012450098991394}, {"wallTime": 1733073136.7155535, "step": 5850, "value": 0.16796785593032837}, {"wallTime": 1733073144.9276893, "step": 5860, "value": 0.25108298659324646}, {"wallTime": 1733073153.0411508, "step": 5870, "value": 0.15665285289287567}, {"wallTime": 1733073166.0029395, "step": 5880, "value": 0.19065187871456146}, {"wallTime": 1733073174.6588883, "step": 5890, "value": 0.15496714413166046}, {"wallTime": 1733073182.508195, "step": 5900, "value": 0.22676847875118256}, {"wallTime": 1733073191.5594234, "step": 5910, "value": 0.18613433837890625}, {"wallTime": 1733073199.4113185, "step": 5920, "value": 0.10385572910308838}, {"wallTime": 1733073207.465445, "step": 5930, "value": 0.23308752477169037}, {"wallTime": 1733073215.6028106, "step": 5940, "value": 0.2079969346523285}, {"wallTime": 1733073224.3581016, "step": 5950, "value": 0.20172657072544098}, {"wallTime": 1733073232.8770266, "step": 5960, "value": 0.2816852331161499}, {"wallTime": 1733073245.3737247, "step": 5970, "value": 0.19902794063091278}, {"wallTime": 1733073253.1795242, "step": 5980, "value": 0.2458905577659607}, {"wallTime": 1733073261.7998133, "step": 5990, "value": 0.22079193592071533}, {"wallTime": 1733073270.0598571, "step": 6000, "value": 0.21641021966934204}, {"wallTime": 1733073278.8958535, "step": 6010, "value": 0.362303227186203}, {"wallTime": 1733073287.682233, "step": 6020, "value": 0.2496892809867859}, {"wallTime": 1733073297.2745616, "step": 6030, "value": 0.3888257145881653}, {"wallTime": 1733073305.9184082, "step": 6040, "value": 0.2972540259361267}, {"wallTime": 1733073322.3548107, "step": 6050, "value": 0.21531865000724792}, {"wallTime": 1733073331.9774163, "step": 6060, "value": 0.15959078073501587}, {"wallTime": 1733073340.5223026, "step": 6070, "value": 0.18729841709136963}, {"wallTime": 1733073349.6021404, "step": 6080, "value": 0.2995789349079132}, {"wallTime": 1733073359.0713708, "step": 6090, "value": 0.18628789484500885}, {"wallTime": 1733073368.4030924, "step": 6100, "value": 0.2302139401435852}, {"wallTime": 1733073377.675152, "step": 6110, "value": 0.24311482906341553}, {"wallTime": 1733073386.4005141, "step": 6120, "value": 0.1634456217288971}, {"wallTime": 1733073395.4516542, "step": 6130, "value": 0.22827176749706268}, {"wallTime": 1733073408.151402, "step": 6140, "value": 0.15311965346336365}, {"wallTime": 1733073417.323885, "step": 6150, "value": 0.18976876139640808}, {"wallTime": 1733073426.256806, "step": 6160, "value": 0.19313228130340576}, {"wallTime": 1733073434.8094351, "step": 6170, "value": 0.1683611422777176}, {"wallTime": 1733073444.5128298, "step": 6180, "value": 0.20732781291007996}, {"wallTime": 1733073453.1165154, "step": 6190, "value": 0.2420022189617157}, {"wallTime": 1733073462.5657153, "step": 6200, "value": 0.1617584377527237}, {"wallTime": 1733073472.0245545, "step": 6210, "value": 0.23354513943195343}, {"wallTime": 1733073484.4483874, "step": 6220, "value": 0.199024498462677}, {"wallTime": 1733073493.6600416, "step": 6230, "value": 0.1931198239326477}, {"wallTime": 1733073502.4412832, "step": 6240, "value": 0.21352854371070862}, {"wallTime": 1733073511.2562308, "step": 6250, "value": 0.23644471168518066}, {"wallTime": 1733073520.485027, "step": 6260, "value": 0.18670187890529633}, {"wallTime": 1733073529.7814746, "step": 6270, "value": 0.2799288332462311}, {"wallTime": 1733073539.6391926, "step": 6280, "value": 0.2325994074344635}, {"wallTime": 1733073548.91103, "step": 6290, "value": 0.2023933082818985}, {"wallTime": 1733073560.6197853, "step": 6300, "value": 0.2654888331890106}, {"wallTime": 1733073570.0690427, "step": 6310, "value": 0.18892166018486023}, {"wallTime": 1733073579.481168, "step": 6320, "value": 0.2464827001094818}, {"wallTime": 1733073587.6672938, "step": 6330, "value": 0.19225390255451202}, {"wallTime": 1733073597.2179723, "step": 6340, "value": 0.203928142786026}, {"wallTime": 1733073606.2381616, "step": 6350, "value": 0.19659988582134247}, {"wallTime": 1733073615.0776172, "step": 6360, "value": 0.29457610845565796}, {"wallTime": 1733073624.8345237, "step": 6370, "value": 0.25155285000801086}, {"wallTime": 1733073634.6725705, "step": 6380, "value": 0.2353798747062683}, {"wallTime": 1733073646.528245, "step": 6390, "value": 0.2012200802564621}, {"wallTime": 1733073655.7454798, "step": 6400, "value": 0.23590630292892456}, {"wallTime": 1733073665.6071746, "step": 6410, "value": 0.2252807915210724}, {"wallTime": 1733073674.642827, "step": 6420, "value": 0.28312060236930847}, {"wallTime": 1733073683.670363, "step": 6430, "value": 0.16865286231040955}, {"wallTime": 1733073692.8768167, "step": 6440, "value": 0.25564682483673096}, {"wallTime": 1733073702.5191634, "step": 6450, "value": 0.17389261722564697}, {"wallTime": 1733073712.6273577, "step": 6460, "value": 0.25300630927085876}, {"wallTime": 1733073724.0473883, "step": 6470, "value": 0.31882375478744507}, {"wallTime": 1733073732.8284483, "step": 6480, "value": 0.23377221822738647}, {"wallTime": 1733073741.9573815, "step": 6490, "value": 0.21022897958755493}, {"wallTime": 1733073750.7177176, "step": 6500, "value": 0.23772475123405457}, {"wallTime": 1733073760.4881625, "step": 6510, "value": 0.15336909890174866}, {"wallTime": 1733073769.8633673, "step": 6520, "value": 0.1736111044883728}, {"wallTime": 1733073779.1271012, "step": 6530, "value": 0.19823454320430756}, {"wallTime": 1733073789.4777434, "step": 6540, "value": 0.30939316749572754}, {"wallTime": 1733073798.1033888, "step": 6550, "value": 0.3339477777481079}, {"wallTime": 1733073810.552938, "step": 6560, "value": 0.2267632633447647}, {"wallTime": 1733073820.0364447, "step": 6570, "value": 0.20266489684581757}, {"wallTime": 1733073828.2386699, "step": 6580, "value": 0.26344168186187744}, {"wallTime": 1733073836.7982519, "step": 6590, "value": 0.1743515133857727}, {"wallTime": 1733073845.987569, "step": 6600, "value": 0.21708472073078156}, {"wallTime": 1733073855.2522187, "step": 6610, "value": 0.20475827157497406}, {"wallTime": 1733073864.6938055, "step": 6620, "value": 0.19038158655166626}, {"wallTime": 1733073873.8347313, "step": 6630, "value": 0.212288036942482}, {"wallTime": 1733073887.5247376, "step": 6640, "value": 0.25557461380958557}, {"wallTime": 1733073897.3343074, "step": 6650, "value": 0.2257823646068573}, {"wallTime": 1733073906.8769333, "step": 6660, "value": 0.22274154424667358}, {"wallTime": 1733073916.3503993, "step": 6670, "value": 0.25492483377456665}, {"wallTime": 1733073925.6190186, "step": 6680, "value": 0.18791331350803375}, {"wallTime": 1733073934.9170108, "step": 6690, "value": 0.17618505656719208}, {"wallTime": 1733073943.7425728, "step": 6700, "value": 0.1663171350955963}, {"wallTime": 1733073952.4773364, "step": 6710, "value": 0.23088620603084564}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15059" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_2%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_2", "runToSeries": {".": [{"wallTime": 1733067631.5403905, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.6537132, "step": 10, "value": 0.053525447845458984}, {"wallTime": 1733067660.7857726, "step": 20, "value": 0.045552171766757965}, {"wallTime": 1733067674.1390288, "step": 30, "value": 0.051400937139987946}, {"wallTime": 1733067687.0586882, "step": 40, "value": 0.06601013988256454}, {"wallTime": 1733067699.494742, "step": 50, "value": 0.10139337182044983}, {"wallTime": 1733067710.6309118, "step": 60, "value": 0.08827753365039825}, {"wallTime": 1733067722.757103, "step": 70, "value": 0.034762922674417496}, {"wallTime": 1733067733.7269409, "step": 80, "value": 0.12407564371824265}, {"wallTime": 1733067750.9477856, "step": 90, "value": 0.04291493073105812}, {"wallTime": 1733067761.9824755, "step": 100, "value": 0.06371819227933884}, {"wallTime": 1733067771.6079247, "step": 110, "value": 0.07024676352739334}, {"wallTime": 1733067780.5489244, "step": 120, "value": 0.12578216195106506}, {"wallTime": 1733067790.48692, "step": 130, "value": 0.051611654460430145}, {"wallTime": 1733067799.1071455, "step": 140, "value": 0.08780284225940704}, {"wallTime": 1733067809.4463167, "step": 150, "value": 0.13929684460163116}, {"wallTime": 1733067818.9222324, "step": 160, "value": 0.06246814876794815}, {"wallTime": 1733067836.6511493, "step": 170, "value": 0.06573890149593353}, {"wallTime": 1733067846.392068, "step": 180, "value": 0.0786968246102333}, {"wallTime": 1733067855.6685288, "step": 190, "value": 0.07630716264247894}, {"wallTime": 1733067864.8923743, "step": 200, "value": 0.07954872399568558}, {"wallTime": 1733067874.00345, "step": 210, "value": 0.06413554400205612}, {"wallTime": 1733067883.788615, "step": 220, "value": 0.06300149112939835}, {"wallTime": 1733067892.124679, "step": 230, "value": 0.05678272247314453}, {"wallTime": 1733067901.0708783, "step": 240, "value": 0.10116122663021088}, {"wallTime": 1733067910.076421, "step": 250, "value": 0.08365000784397125}, {"wallTime": 1733067925.9515424, "step": 260, "value": 0.0630955621600151}, {"wallTime": 1733067935.477102, "step": 270, "value": 0.05137607827782631}, {"wallTime": 1733067944.0180666, "step": 280, "value": 0.05374888330698013}, {"wallTime": 1733067952.5491767, "step": 290, "value": 0.12265592068433762}, {"wallTime": 1733067961.0282478, "step": 300, "value": 0.10938026010990143}, {"wallTime": 1733067970.136081, "step": 310, "value": 0.0886605829000473}, {"wallTime": 1733067980.2273204, "step": 320, "value": 0.06040669605135918}, {"wallTime": 1733067988.8175616, "step": 330, "value": 0.0685175433754921}, {"wallTime": 1733068005.0921695, "step": 340, "value": 0.06378769874572754}, {"wallTime": 1733068014.0667205, "step": 350, "value": 0.029362410306930542}, {"wallTime": 1733068022.5545459, "step": 360, "value": 0.06038910895586014}, {"wallTime": 1733068031.8262324, "step": 370, "value": 0.06490397453308105}, {"wallTime": 1733068040.789339, "step": 380, "value": 0.05466654524207115}, {"wallTime": 1733068050.1618216, "step": 390, "value": 0.10095565766096115}, {"wallTime": 1733068059.1276417, "step": 400, "value": 0.10905928909778595}, {"wallTime": 1733068068.0916579, "step": 410, "value": 0.11149190366268158}, {"wallTime": 1733068084.846008, "step": 420, "value": 0.08116191625595093}, {"wallTime": 1733068094.668329, "step": 430, "value": 0.04486126825213432}, {"wallTime": 1733068103.7098055, "step": 440, "value": 0.05495944991707802}, {"wallTime": 1733068112.7012658, "step": 450, "value": 0.057337164878845215}, {"wallTime": 1733068121.502848, "step": 460, "value": 0.04727385565638542}, {"wallTime": 1733068130.7295103, "step": 470, "value": 0.0698925256729126}, {"wallTime": 1733068139.8574777, "step": 480, "value": 0.0612838938832283}, {"wallTime": 1733068149.371805, "step": 490, "value": 0.07276138663291931}, {"wallTime": 1733068158.0718145, "step": 500, "value": 0.07092051953077316}, {"wallTime": 1733068174.1169941, "step": 510, "value": 0.08689253777265549}, {"wallTime": 1733068182.7214327, "step": 520, "value": 0.04787614196538925}, {"wallTime": 1733068192.4155118, "step": 530, "value": 0.0806056410074234}, {"wallTime": 1733068201.8322985, "step": 540, "value": 0.07336892932653427}, {"wallTime": 1733068210.656387, "step": 550, "value": 0.0728960856795311}, {"wallTime": 1733068220.196988, "step": 560, "value": 0.07325216382741928}, {"wallTime": 1733068229.1613617, "step": 570, "value": 0.08057866245508194}, {"wallTime": 1733068238.5934975, "step": 580, "value": 0.06974548101425171}, {"wallTime": 1733068256.076683, "step": 590, "value": 0.052568599581718445}, {"wallTime": 1733068265.4338346, "step": 600, "value": 0.12235190719366074}, {"wallTime": 1733068274.6584082, "step": 610, "value": 0.05337781459093094}, {"wallTime": 1733068283.772006, "step": 620, "value": 0.05834927409887314}, {"wallTime": 1733068293.3360953, "step": 630, "value": 0.05932719260454178}, {"wallTime": 1733068302.6491063, "step": 640, "value": 0.0738263726234436}, {"wallTime": 1733068311.3901396, "step": 650, "value": 0.05715108662843704}, {"wallTime": 1733068320.3921409, "step": 660, "value": 0.07106301933526993}, {"wallTime": 1733068328.7334187, "step": 670, "value": 0.07045476138591766}, {"wallTime": 1733068344.463153, "step": 680, "value": 0.08075757324695587}, {"wallTime": 1733068353.7189343, "step": 690, "value": 0.05024503171443939}, {"wallTime": 1733068362.0598717, "step": 700, "value": 0.0816897451877594}, {"wallTime": 1733068371.1060767, "step": 710, "value": 0.044160857796669006}, {"wallTime": 1733068380.535197, "step": 720, "value": 0.07741118967533112}, {"wallTime": 1733068390.0886583, "step": 730, "value": 0.043275412172079086}, {"wallTime": 1733068398.7230206, "step": 740, "value": 0.08739054203033447}, {"wallTime": 1733068407.126007, "step": 750, "value": 0.059417180716991425}, {"wallTime": 1733068423.0744526, "step": 760, "value": 0.06330785900354385}, {"wallTime": 1733068431.4073796, "step": 770, "value": 0.07543396204710007}, {"wallTime": 1733068440.4270394, "step": 780, "value": 0.04484282806515694}, {"wallTime": 1733068449.00869, "step": 790, "value": 0.05976077541708946}, {"wallTime": 1733068457.6409104, "step": 800, "value": 0.04076611250638962}, {"wallTime": 1733068467.0494416, "step": 810, "value": 0.05826998129487038}, {"wallTime": 1733068475.62257, "step": 820, "value": 0.05923666059970856}, {"wallTime": 1733068484.9811134, "step": 830, "value": 0.047202713787555695}, {"wallTime": 1733068500.7337837, "step": 840, "value": 0.042635396122932434}, {"wallTime": 1733068509.31, "step": 850, "value": 0.04493001103401184}, {"wallTime": 1733068519.0244484, "step": 860, "value": 0.03579162806272507}, {"wallTime": 1733068527.5007877, "step": 870, "value": 0.06274557113647461}, {"wallTime": 1733068536.9225688, "step": 880, "value": 0.05634765699505806}, {"wallTime": 1733068544.9110796, "step": 890, "value": 0.05026191473007202}, {"wallTime": 1733068553.5814266, "step": 900, "value": 0.06029101461172104}, {"wallTime": 1733068562.68829, "step": 910, "value": 0.06997910141944885}, {"wallTime": 1733068571.2486918, "step": 920, "value": 0.05262155830860138}, {"wallTime": 1733068584.7788136, "step": 930, "value": 0.04015188664197922}, {"wallTime": 1733068593.7756593, "step": 940, "value": 0.061853259801864624}, {"wallTime": 1733068602.769329, "step": 950, "value": 0.027678798884153366}, {"wallTime": 1733068611.0433311, "step": 960, "value": 0.06856432557106018}, {"wallTime": 1733068620.2300503, "step": 970, "value": 0.05226662755012512}, {"wallTime": 1733068628.8452022, "step": 980, "value": 0.04782045632600784}, {"wallTime": 1733068637.6339178, "step": 990, "value": 0.037848249077796936}, {"wallTime": 1733068646.6765583, "step": 1000, "value": 0.06595268100500107}, {"wallTime": 1733068662.760522, "step": 1010, "value": 0.055006518959999084}, {"wallTime": 1733068672.05804, "step": 1020, "value": 0.050755009055137634}, {"wallTime": 1733068680.5666382, "step": 1030, "value": 0.06752660870552063}, {"wallTime": 1733068690.1896024, "step": 1040, "value": 0.039316534996032715}, {"wallTime": 1733068698.852012, "step": 1050, "value": 0.06300243735313416}, {"wallTime": 1733068707.7471576, "step": 1060, "value": 0.04365037381649017}, {"wallTime": 1733068717.3483396, "step": 1070, "value": 0.04383513703942299}, {"wallTime": 1733068726.36508, "step": 1080, "value": 0.033059000968933105}, {"wallTime": 1733068735.2554674, "step": 1090, "value": 0.04429876059293747}, {"wallTime": 1733068749.5517173, "step": 1100, "value": 0.033108189702034}, {"wallTime": 1733068758.379062, "step": 1110, "value": 0.05488777160644531}, {"wallTime": 1733068767.007562, "step": 1120, "value": 0.061617590487003326}, {"wallTime": 1733068776.622575, "step": 1130, "value": 0.05079926922917366}, {"wallTime": 1733068785.4050627, "step": 1140, "value": 0.06464599817991257}, {"wallTime": 1733068794.2828352, "step": 1150, "value": 0.06911181658506393}, {"wallTime": 1733068802.7010484, "step": 1160, "value": 0.07094746828079224}, {"wallTime": 1733068811.555635, "step": 1170, "value": 0.05533032491803169}, {"wallTime": 1733068824.969482, "step": 1180, "value": 0.049910884350538254}, {"wallTime": 1733068834.380974, "step": 1190, "value": 0.04477469250559807}, {"wallTime": 1733068843.5199058, "step": 1200, "value": 0.05121568217873573}, {"wallTime": 1733068852.2322965, "step": 1210, "value": 0.040897954255342484}, {"wallTime": 1733068861.1206667, "step": 1220, "value": 0.040841396898031235}, {"wallTime": 1733068870.0595949, "step": 1230, "value": 0.06508615612983704}, {"wallTime": 1733068878.7240863, "step": 1240, "value": 0.06828982383012772}, {"wallTime": 1733068887.7418647, "step": 1250, "value": 0.03868212550878525}, {"wallTime": 1733068903.1705363, "step": 1260, "value": 0.036991529166698456}, {"wallTime": 1733068912.420565, "step": 1270, "value": 0.05399186164140701}, {"wallTime": 1733068921.4783592, "step": 1280, "value": 0.06668603420257568}, {"wallTime": 1733068929.7503347, "step": 1290, "value": 0.045623451471328735}, {"wallTime": 1733068939.5051, "step": 1300, "value": 0.04221833869814873}, {"wallTime": 1733068948.9317024, "step": 1310, "value": 0.032532911747694016}, {"wallTime": 1733068957.2381656, "step": 1320, "value": 0.061041563749313354}, {"wallTime": 1733068966.0807376, "step": 1330, "value": 0.05754325911402702}, {"wallTime": 1733068975.5689857, "step": 1340, "value": 0.05823278799653053}, {"wallTime": 1733068989.8033433, "step": 1350, "value": 0.030609527602791786}, {"wallTime": 1733068998.286909, "step": 1360, "value": 0.028886858373880386}, {"wallTime": 1733069007.1541913, "step": 1370, "value": 0.039654966443777084}, {"wallTime": 1733069015.9263868, "step": 1380, "value": 0.03714429959654808}, {"wallTime": 1733069025.3069494, "step": 1390, "value": 0.0469125397503376}, {"wallTime": 1733069034.485169, "step": 1400, "value": 0.055715449154376984}, {"wallTime": 1733069042.7966638, "step": 1410, "value": 0.06057906150817871}, {"wallTime": 1733069052.141229, "step": 1420, "value": 0.04310787469148636}, {"wallTime": 1733069065.005377, "step": 1430, "value": 0.04386281594634056}, {"wallTime": 1733069074.527635, "step": 1440, "value": 0.04745270311832428}, {"wallTime": 1733069083.7862456, "step": 1450, "value": 0.0492950975894928}, {"wallTime": 1733069092.2625222, "step": 1460, "value": 0.057050853967666626}, {"wallTime": 1733069101.0335188, "step": 1470, "value": 0.0553673692047596}, {"wallTime": 1733069109.909441, "step": 1480, "value": 0.06419824063777924}, {"wallTime": 1733069119.1214519, "step": 1490, "value": 0.04439878463745117}, {"wallTime": 1733069128.41873, "step": 1500, "value": 0.052778009325265884}, {"wallTime": 1733069137.6092894, "step": 1510, "value": 0.05944186821579933}, {"wallTime": 1733069150.5461156, "step": 1520, "value": 0.034368954598903656}, {"wallTime": 1733069159.7595685, "step": 1530, "value": 0.04511915519833565}, {"wallTime": 1733069168.1731548, "step": 1540, "value": 0.05415721982717514}, {"wallTime": 1733069176.8434947, "step": 1550, "value": 0.05319666862487793}, {"wallTime": 1733069185.8947718, "step": 1560, "value": 0.03487519547343254}, {"wallTime": 1733069194.9267745, "step": 1570, "value": 0.06146283447742462}, {"wallTime": 1733069203.9167435, "step": 1580, "value": 0.03240314871072769}, {"wallTime": 1733069212.7188387, "step": 1590, "value": 0.03867499530315399}, {"wallTime": 1733069225.5366578, "step": 1600, "value": 0.038503143936395645}, {"wallTime": 1733069235.466364, "step": 1610, "value": 0.04692230373620987}, {"wallTime": 1733069244.6329334, "step": 1620, "value": 0.04172954335808754}, {"wallTime": 1733069254.2961464, "step": 1630, "value": 0.050687097012996674}, {"wallTime": 1733069263.0078826, "step": 1640, "value": 0.0477246530354023}, {"wallTime": 1733069271.8691716, "step": 1650, "value": 0.05391895771026611}, {"wallTime": 1733069280.5123713, "step": 1660, "value": 0.09787490963935852}, {"wallTime": 1733069289.682259, "step": 1670, "value": 0.0461854487657547}, {"wallTime": 1733069303.6133313, "step": 1680, "value": 0.060065969824790955}, {"wallTime": 1733069312.4821875, "step": 1690, "value": 0.041154008358716965}, {"wallTime": 1733069321.841394, "step": 1700, "value": 0.043834030628204346}, {"wallTime": 1733069330.3504765, "step": 1710, "value": 0.0464082732796669}, {"wallTime": 1733069339.2479897, "step": 1720, "value": 0.03667537122964859}, {"wallTime": 1733069346.8613088, "step": 1730, "value": 0.07663856446743011}, {"wallTime": 1733069355.6570437, "step": 1740, "value": 0.03450561687350273}, {"wallTime": 1733069364.5145648, "step": 1750, "value": 0.06673740595579147}, {"wallTime": 1733069373.7411792, "step": 1760, "value": 0.08812613040208817}, {"wallTime": 1733069387.543618, "step": 1770, "value": 0.04883343726396561}, {"wallTime": 1733069396.4712522, "step": 1780, "value": 0.06693192571401596}, {"wallTime": 1733069405.998743, "step": 1790, "value": 0.0524383969604969}, {"wallTime": 1733069415.056326, "step": 1800, "value": 0.04333048313856125}, {"wallTime": 1733069423.909954, "step": 1810, "value": 0.04236482083797455}, {"wallTime": 1733069432.5336893, "step": 1820, "value": 0.05149137228727341}, {"wallTime": 1733069441.221616, "step": 1830, "value": 0.04069828242063522}, {"wallTime": 1733069450.092293, "step": 1840, "value": 0.034351564943790436}, {"wallTime": 1733069463.1095023, "step": 1850, "value": 0.03671931102871895}, {"wallTime": 1733069471.5751214, "step": 1860, "value": 0.03162655234336853}, {"wallTime": 1733069480.500316, "step": 1870, "value": 0.07465454936027527}, {"wallTime": 1733069489.3870258, "step": 1880, "value": 0.04663810506463051}, {"wallTime": 1733069497.9788394, "step": 1890, "value": 0.056322310119867325}, {"wallTime": 1733069506.8169346, "step": 1900, "value": 0.0328088104724884}, {"wallTime": 1733069515.8267145, "step": 1910, "value": 0.05015793442726135}, {"wallTime": 1733069524.6385684, "step": 1920, "value": 0.03598695993423462}, {"wallTime": 1733069533.544269, "step": 1930, "value": 0.05829695984721184}, {"wallTime": 1733069550.480008, "step": 1940, "value": 0.024213949218392372}, {"wallTime": 1733069558.830122, "step": 1950, "value": 0.06005918234586716}, {"wallTime": 1733069567.7599652, "step": 1960, "value": 0.0403265580534935}, {"wallTime": 1733069576.3472674, "step": 1970, "value": 0.05170416831970215}, {"wallTime": 1733069585.531175, "step": 1980, "value": 0.04984380677342415}, {"wallTime": 1733069594.35231, "step": 1990, "value": 0.051635246723890305}, {"wallTime": 1733069602.4037337, "step": 2000, "value": 0.06035264953970909}, {"wallTime": 1733069610.2519884, "step": 2010, "value": 0.0524238683283329}, {"wallTime": 1733069626.6888354, "step": 2020, "value": 0.048596955835819244}, {"wallTime": 1733069635.0329266, "step": 2030, "value": 0.03669799119234085}, {"wallTime": 1733069643.8246315, "step": 2040, "value": 0.053231120109558105}, {"wallTime": 1733069652.1963906, "step": 2050, "value": 0.056681908667087555}, {"wallTime": 1733069660.4554877, "step": 2060, "value": 0.07731464505195618}, {"wallTime": 1733069669.5940719, "step": 2070, "value": 0.03450379520654678}, {"wallTime": 1733069678.7804482, "step": 2080, "value": 0.05223206430673599}, {"wallTime": 1733069686.946906, "step": 2090, "value": 0.04964042082428932}, {"wallTime": 1733069700.604131, "step": 2100, "value": 0.035947054624557495}, {"wallTime": 1733069708.7283638, "step": 2110, "value": 0.03944086283445358}, {"wallTime": 1733069717.4502504, "step": 2120, "value": 0.045134373009204865}, {"wallTime": 1733069726.143261, "step": 2130, "value": 0.031777095049619675}, {"wallTime": 1733069735.0400558, "step": 2140, "value": 0.03236328065395355}, {"wallTime": 1733069743.3080754, "step": 2150, "value": 0.04104812443256378}, {"wallTime": 1733069752.5028186, "step": 2160, "value": 0.042887087911367416}, {"wallTime": 1733069761.4529524, "step": 2170, "value": 0.03676943853497505}, {"wallTime": 1733069770.4351456, "step": 2180, "value": 0.052407748997211456}, {"wallTime": 1733069784.3658361, "step": 2190, "value": 0.04331987351179123}, {"wallTime": 1733069793.1244488, "step": 2200, "value": 0.034056391566991806}, {"wallTime": 1733069801.6381466, "step": 2210, "value": 0.05419956147670746}, {"wallTime": 1733069810.6098297, "step": 2220, "value": 0.03976840525865555}, {"wallTime": 1733069819.344559, "step": 2230, "value": 0.05970412492752075}, {"wallTime": 1733069827.328026, "step": 2240, "value": 0.047520436346530914}, {"wallTime": 1733069835.8701222, "step": 2250, "value": 0.0349716991186142}, {"wallTime": 1733069844.2378547, "step": 2260, "value": 0.047545675188302994}, {"wallTime": 1733069856.7513041, "step": 2270, "value": 0.06613777577877045}, {"wallTime": 1733069865.2594612, "step": 2280, "value": 0.05949699878692627}, {"wallTime": 1733069874.0077715, "step": 2290, "value": 0.04096926748752594}, {"wallTime": 1733069881.7834926, "step": 2300, "value": 0.0467740073800087}, {"wallTime": 1733069890.415642, "step": 2310, "value": 0.031477123498916626}, {"wallTime": 1733069898.8784554, "step": 2320, "value": 0.05083141848444939}, {"wallTime": 1733069908.319518, "step": 2330, "value": 0.037579964846372604}, {"wallTime": 1733069917.4170413, "step": 2340, "value": 0.03802356496453285}, {"wallTime": 1733069925.8526573, "step": 2350, "value": 0.03932954743504524}, {"wallTime": 1733069938.7057893, "step": 2360, "value": 0.07409985363483429}, {"wallTime": 1733069947.427971, "step": 2370, "value": 0.029881741851568222}, {"wallTime": 1733069956.2096908, "step": 2380, "value": 0.045189566910266876}, {"wallTime": 1733069964.2765718, "step": 2390, "value": 0.07559613138437271}, {"wallTime": 1733069973.3278449, "step": 2400, "value": 0.032879170030355453}, {"wallTime": 1733069981.4338722, "step": 2410, "value": 0.02438330091536045}, {"wallTime": 1733069990.141452, "step": 2420, "value": 0.04769611731171608}, {"wallTime": 1733069998.8004794, "step": 2430, "value": 0.04190646857023239}, {"wallTime": 1733070012.4575949, "step": 2440, "value": 0.040955401957035065}, {"wallTime": 1733070021.6008224, "step": 2450, "value": 0.037553850561380386}, {"wallTime": 1733070030.1926894, "step": 2460, "value": 0.037109147757291794}, {"wallTime": 1733070039.2210112, "step": 2470, "value": 0.04917289689183235}, {"wallTime": 1733070048.2706287, "step": 2480, "value": 0.043569885194301605}, {"wallTime": 1733070056.157457, "step": 2490, "value": 0.035379406064748764}, {"wallTime": 1733070064.4523373, "step": 2500, "value": 0.027329273521900177}, {"wallTime": 1733070072.5535946, "step": 2510, "value": 0.0575556606054306}, {"wallTime": 1733070087.6586711, "step": 2520, "value": 0.031272463500499725}, {"wallTime": 1733070095.4433799, "step": 2530, "value": 0.026255983859300613}, {"wallTime": 1733070103.770571, "step": 2540, "value": 0.05333021283149719}, {"wallTime": 1733070113.0511246, "step": 2550, "value": 0.04333183169364929}, {"wallTime": 1733070121.0394537, "step": 2560, "value": 0.05398411303758621}, {"wallTime": 1733070129.586812, "step": 2570, "value": 0.03956069052219391}, {"wallTime": 1733070138.3625045, "step": 2580, "value": 0.04166729375720024}, {"wallTime": 1733070147.0890007, "step": 2590, "value": 0.04397299140691757}, {"wallTime": 1733070155.4885638, "step": 2600, "value": 0.03678223863244057}, {"wallTime": 1733070172.578993, "step": 2610, "value": 0.04672512039542198}, {"wallTime": 1733070181.2128267, "step": 2620, "value": 0.035920944064855576}, {"wallTime": 1733070189.694097, "step": 2630, "value": 0.04664408415555954}, {"wallTime": 1733070198.400797, "step": 2640, "value": 0.05122027546167374}, {"wallTime": 1733070206.7091312, "step": 2650, "value": 0.041085682809352875}, {"wallTime": 1733070215.6013803, "step": 2660, "value": 0.03615188971161842}, {"wallTime": 1733070224.3179781, "step": 2670, "value": 0.04385958984494209}, {"wallTime": 1733070233.54107, "step": 2680, "value": 0.048842333257198334}, {"wallTime": 1733070246.7599454, "step": 2690, "value": 0.032491859048604965}, {"wallTime": 1733070256.0308788, "step": 2700, "value": 0.05735010281205177}, {"wallTime": 1733070264.9524317, "step": 2710, "value": 0.03199555352330208}, {"wallTime": 1733070273.8287094, "step": 2720, "value": 0.045889340341091156}, {"wallTime": 1733070282.960781, "step": 2730, "value": 0.04085943475365639}, {"wallTime": 1733070292.2795756, "step": 2740, "value": 0.03577316924929619}, {"wallTime": 1733070300.338458, "step": 2750, "value": 0.05448898300528526}, {"wallTime": 1733070309.4138753, "step": 2760, "value": 0.048248156905174255}, {"wallTime": 1733070317.533253, "step": 2770, "value": 0.0448695532977581}, {"wallTime": 1733070330.4378927, "step": 2780, "value": 0.04261700063943863}, {"wallTime": 1733070339.8251507, "step": 2790, "value": 0.041085708886384964}, {"wallTime": 1733070347.9965465, "step": 2800, "value": 0.034473247826099396}, {"wallTime": 1733070356.8958845, "step": 2810, "value": 0.04112625494599342}, {"wallTime": 1733070365.5787299, "step": 2820, "value": 0.034261107444763184}, {"wallTime": 1733070374.3953803, "step": 2830, "value": 0.03207041323184967}, {"wallTime": 1733070382.4287107, "step": 2840, "value": 0.052282143384218216}, {"wallTime": 1733070390.9430404, "step": 2850, "value": 0.029714465141296387}, {"wallTime": 1733070406.680417, "step": 2860, "value": 0.06330850720405579}, {"wallTime": 1733070415.0920718, "step": 2870, "value": 0.05806495249271393}, {"wallTime": 1733070422.9218228, "step": 2880, "value": 0.030051428824663162}, {"wallTime": 1733070431.539096, "step": 2890, "value": 0.033619027584791183}, {"wallTime": 1733070439.982736, "step": 2900, "value": 0.03618143871426582}, {"wallTime": 1733070448.0872698, "step": 2910, "value": 0.04755379632115364}, {"wallTime": 1733070457.4253938, "step": 2920, "value": 0.033356279134750366}, {"wallTime": 1733070466.7246408, "step": 2930, "value": 0.05117865279316902}, {"wallTime": 1733070479.3344076, "step": 2940, "value": 0.04277372732758522}, {"wallTime": 1733070488.784131, "step": 2950, "value": 0.02965388633310795}, {"wallTime": 1733070497.22666, "step": 2960, "value": 0.03269017115235329}, {"wallTime": 1733070505.6355143, "step": 2970, "value": 0.03201711177825928}, {"wallTime": 1733070513.3556406, "step": 2980, "value": 0.058423954993486404}, {"wallTime": 1733070522.3191383, "step": 2990, "value": 0.037849362939596176}, {"wallTime": 1733070530.214342, "step": 3000, "value": 0.054155196994543076}, {"wallTime": 1733070538.3016887, "step": 3010, "value": 0.03047792613506317}, {"wallTime": 1733070547.4022028, "step": 3020, "value": 0.044414568692445755}, {"wallTime": 1733070564.052693, "step": 3030, "value": 0.03860580176115036}, {"wallTime": 1733070572.3714054, "step": 3040, "value": 0.029710523784160614}, {"wallTime": 1733070580.672839, "step": 3050, "value": 0.05330023169517517}, {"wallTime": 1733070588.6548867, "step": 3060, "value": 0.02920370362699032}, {"wallTime": 1733070597.4225411, "step": 3070, "value": 0.03374648466706276}, {"wallTime": 1733070606.1390984, "step": 3080, "value": 0.06397370994091034}, {"wallTime": 1733070614.4415245, "step": 3090, "value": 0.060219451785087585}, {"wallTime": 1733070624.001942, "step": 3100, "value": 0.028197258710861206}, {"wallTime": 1733070637.2537186, "step": 3110, "value": 0.047751534730196}, {"wallTime": 1733070645.6837044, "step": 3120, "value": 0.03238014876842499}, {"wallTime": 1733070654.2712686, "step": 3130, "value": 0.04541366547346115}, {"wallTime": 1733070663.3220813, "step": 3140, "value": 0.037906888872385025}, {"wallTime": 1733070671.118737, "step": 3150, "value": 0.0575370267033577}, {"wallTime": 1733070679.766277, "step": 3160, "value": 0.02677464671432972}, {"wallTime": 1733070687.8462906, "step": 3170, "value": 0.05605820193886757}, {"wallTime": 1733070695.856469, "step": 3180, "value": 0.030641082674264908}, {"wallTime": 1733070704.623212, "step": 3190, "value": 0.03432850167155266}, {"wallTime": 1733070717.1096265, "step": 3200, "value": 0.04660098999738693}, {"wallTime": 1733070726.0994575, "step": 3210, "value": 0.04615282639861107}, {"wallTime": 1733070734.779186, "step": 3220, "value": 0.04357442259788513}, {"wallTime": 1733070744.4132817, "step": 3230, "value": 0.028033340349793434}, {"wallTime": 1733070752.5023813, "step": 3240, "value": 0.03991979733109474}, {"wallTime": 1733070761.722105, "step": 3250, "value": 0.02645106241106987}, {"wallTime": 1733070770.3773944, "step": 3260, "value": 0.02664734050631523}, {"wallTime": 1733070779.7307067, "step": 3270, "value": 0.03502093628048897}, {"wallTime": 1733070793.6793492, "step": 3280, "value": 0.03420492634177208}, {"wallTime": 1733070801.900704, "step": 3290, "value": 0.027472365647554398}, {"wallTime": 1733070810.1617756, "step": 3300, "value": 0.02666402980685234}, {"wallTime": 1733070818.727315, "step": 3310, "value": 0.03812873363494873}, {"wallTime": 1733070827.0091329, "step": 3320, "value": 0.04386911168694496}, {"wallTime": 1733070835.5766988, "step": 3330, "value": 0.06360763311386108}, {"wallTime": 1733070843.9768748, "step": 3340, "value": 0.03941907733678818}, {"wallTime": 1733070853.092668, "step": 3350, "value": 0.05774453282356262}, {"wallTime": 1733070865.4203196, "step": 3360, "value": 0.03090156614780426}, {"wallTime": 1733070873.6623733, "step": 3370, "value": 0.03395744413137436}, {"wallTime": 1733070883.3367488, "step": 3380, "value": 0.03474702686071396}, {"wallTime": 1733070892.3777318, "step": 3390, "value": 0.03577524051070213}, {"wallTime": 1733070900.7231083, "step": 3400, "value": 0.04720264673233032}, {"wallTime": 1733070908.504925, "step": 3410, "value": 0.029408492147922516}, {"wallTime": 1733070916.6565008, "step": 3420, "value": 0.04445045441389084}, {"wallTime": 1733070925.2118669, "step": 3430, "value": 0.0346316359937191}, {"wallTime": 1733070933.8110392, "step": 3440, "value": 0.0371246300637722}, {"wallTime": 1733070947.4805589, "step": 3450, "value": 0.032304856926202774}, {"wallTime": 1733070956.188341, "step": 3460, "value": 0.030611036345362663}, {"wallTime": 1733070964.2671204, "step": 3470, "value": 0.09346704930067062}, {"wallTime": 1733070972.386919, "step": 3480, "value": 0.041065461933612823}, {"wallTime": 1733070980.6478746, "step": 3490, "value": 0.04132143780589104}, {"wallTime": 1733070989.6885211, "step": 3500, "value": 0.0348665714263916}, {"wallTime": 1733070997.789476, "step": 3510, "value": 0.052294060587882996}, {"wallTime": 1733071006.272243, "step": 3520, "value": 0.06360997259616852}, {"wallTime": 1733071018.8969436, "step": 3530, "value": 0.04149075597524643}, {"wallTime": 1733071027.198136, "step": 3540, "value": 0.023621302098035812}, {"wallTime": 1733071035.3214502, "step": 3550, "value": 0.05057886615395546}, {"wallTime": 1733071043.7465987, "step": 3560, "value": 0.032829649746418}, {"wallTime": 1733071051.8730507, "step": 3570, "value": 0.04684984311461449}, {"wallTime": 1733071060.4970233, "step": 3580, "value": 0.040261298418045044}, {"wallTime": 1733071068.880381, "step": 3590, "value": 0.046708859503269196}, {"wallTime": 1733071077.7139125, "step": 3600, "value": 0.04013574868440628}, {"wallTime": 1733071086.2133183, "step": 3610, "value": 0.03843129053711891}, {"wallTime": 1733071101.6597419, "step": 3620, "value": 0.039602749049663544}, {"wallTime": 1733071109.6229537, "step": 3630, "value": 0.04830460622906685}, {"wallTime": 1733071118.130211, "step": 3640, "value": 0.0351882204413414}, {"wallTime": 1733071126.9941185, "step": 3650, "value": 0.03260388597846031}, {"wallTime": 1733071135.8283691, "step": 3660, "value": 0.04387344419956207}, {"wallTime": 1733071144.249433, "step": 3670, "value": 0.038097504526376724}, {"wallTime": 1733071152.9654613, "step": 3680, "value": 0.033877499401569366}, {"wallTime": 1733071160.6044078, "step": 3690, "value": 0.03377774357795715}, {"wallTime": 1733071173.7512822, "step": 3700, "value": 0.03745580092072487}, {"wallTime": 1733071182.8842063, "step": 3710, "value": 0.030113626271486282}, {"wallTime": 1733071191.2111511, "step": 3720, "value": 0.058671630918979645}, {"wallTime": 1733071200.334374, "step": 3730, "value": 0.024453286081552505}, {"wallTime": 1733071208.36668, "step": 3740, "value": 0.026889219880104065}, {"wallTime": 1733071216.572899, "step": 3750, "value": 0.05443571135401726}, {"wallTime": 1733071224.6628528, "step": 3760, "value": 0.026136137545108795}, {"wallTime": 1733071232.8617294, "step": 3770, "value": 0.055117666721343994}, {"wallTime": 1733071248.5345442, "step": 3780, "value": 0.027701761573553085}, {"wallTime": 1733071257.392733, "step": 3790, "value": 0.033061396330595016}, {"wallTime": 1733071265.5683112, "step": 3800, "value": 0.0329287126660347}, {"wallTime": 1733071274.1991086, "step": 3810, "value": 0.033579252660274506}, {"wallTime": 1733071283.0189364, "step": 3820, "value": 0.03338903561234474}, {"wallTime": 1733071291.7307868, "step": 3830, "value": 0.031710755079984665}, {"wallTime": 1733071299.8950949, "step": 3840, "value": 0.030526136979460716}, {"wallTime": 1733071308.4805393, "step": 3850, "value": 0.04466991499066353}, {"wallTime": 1733071316.9526238, "step": 3860, "value": 0.03842326998710632}, {"wallTime": 1733071330.216432, "step": 3870, "value": 0.04074997827410698}, {"wallTime": 1733071338.9901035, "step": 3880, "value": 0.04314751178026199}, {"wallTime": 1733071347.7379863, "step": 3890, "value": 0.02575581520795822}, {"wallTime": 1733071357.0359807, "step": 3900, "value": 0.03187958523631096}, {"wallTime": 1733071365.2266605, "step": 3910, "value": 0.06131291389465332}, {"wallTime": 1733071374.1359165, "step": 3920, "value": 0.047335200011730194}, {"wallTime": 1733071382.8151503, "step": 3930, "value": 0.04974881559610367}, {"wallTime": 1733071391.5696878, "step": 3940, "value": 0.02992580644786358}, {"wallTime": 1733071404.4686923, "step": 3950, "value": 0.028311440721154213}, {"wallTime": 1733071412.3402407, "step": 3960, "value": 0.028985943645238876}, {"wallTime": 1733071421.1588688, "step": 3970, "value": 0.04290161281824112}, {"wallTime": 1733071430.1219153, "step": 3980, "value": 0.03398426994681358}, {"wallTime": 1733071438.4153929, "step": 3990, "value": 0.04754428192973137}, {"wallTime": 1733071447.7302463, "step": 4000, "value": 0.024117494001984596}, {"wallTime": 1733071456.1979742, "step": 4010, "value": 0.07435239851474762}, {"wallTime": 1733071464.7508683, "step": 4020, "value": 0.03774429112672806}, {"wallTime": 1733071473.3991554, "step": 4030, "value": 0.03567042946815491}, {"wallTime": 1733071490.2878733, "step": 4040, "value": 0.03966102376580238}, {"wallTime": 1733071498.713129, "step": 4050, "value": 0.042694658041000366}, {"wallTime": 1733071507.098978, "step": 4060, "value": 0.029628902673721313}, {"wallTime": 1733071515.0692565, "step": 4070, "value": 0.0671209916472435}, {"wallTime": 1733071523.9082532, "step": 4080, "value": 0.029151665046811104}, {"wallTime": 1733071532.2870877, "step": 4090, "value": 0.035515788942575455}, {"wallTime": 1733071540.919151, "step": 4100, "value": 0.025834359228610992}, {"wallTime": 1733071549.177793, "step": 4110, "value": 0.027642764151096344}, {"wallTime": 1733071565.8377345, "step": 4120, "value": 0.027588725090026855}, {"wallTime": 1733071573.633458, "step": 4130, "value": 0.032617442309856415}, {"wallTime": 1733071582.0980206, "step": 4140, "value": 0.04326721280813217}, {"wallTime": 1733071590.0245118, "step": 4150, "value": 0.03963945806026459}, {"wallTime": 1733071599.2428987, "step": 4160, "value": 0.03285622596740723}, {"wallTime": 1733071608.0736659, "step": 4170, "value": 0.035879652947187424}, {"wallTime": 1733071616.185928, "step": 4180, "value": 0.06291531771421432}, {"wallTime": 1733071626.0848393, "step": 4190, "value": 0.027409391477704048}, {"wallTime": 1733071641.0103378, "step": 4200, "value": 0.03512671962380409}, {"wallTime": 1733071649.0427957, "step": 4210, "value": 0.042336247861385345}, {"wallTime": 1733071658.5335147, "step": 4220, "value": 0.0409184992313385}, {"wallTime": 1733071667.968182, "step": 4230, "value": 0.02747994288802147}, {"wallTime": 1733071676.1109092, "step": 4240, "value": 0.026226939633488655}, {"wallTime": 1733071684.380711, "step": 4250, "value": 0.04854089766740799}, {"wallTime": 1733071693.111805, "step": 4260, "value": 0.02363455295562744}, {"wallTime": 1733071702.1860569, "step": 4270, "value": 0.043775107711553574}, {"wallTime": 1733071710.633022, "step": 4280, "value": 0.023527851328253746}, {"wallTime": 1733071726.6789594, "step": 4290, "value": 0.03538907691836357}, {"wallTime": 1733071735.21778, "step": 4300, "value": 0.039246708154678345}, {"wallTime": 1733071742.959281, "step": 4310, "value": 0.03558565303683281}, {"wallTime": 1733071751.5878892, "step": 4320, "value": 0.03072364255785942}, {"wallTime": 1733071760.0371852, "step": 4330, "value": 0.0312548503279686}, {"wallTime": 1733071768.4335165, "step": 4340, "value": 0.032678842544555664}, {"wallTime": 1733071777.4044127, "step": 4350, "value": 0.043725237250328064}, {"wallTime": 1733071785.549511, "step": 4360, "value": 0.041785482317209244}, {"wallTime": 1733071800.8871472, "step": 4370, "value": 0.039367616176605225}, {"wallTime": 1733071809.2681031, "step": 4380, "value": 0.031404897570610046}, {"wallTime": 1733071817.348665, "step": 4390, "value": 0.06865843385457993}, {"wallTime": 1733071826.4326415, "step": 4400, "value": 0.044797081500291824}, {"wallTime": 1733071834.889809, "step": 4410, "value": 0.04630494862794876}, {"wallTime": 1733071843.449088, "step": 4420, "value": 0.0528574176132679}, {"wallTime": 1733071851.5982687, "step": 4430, "value": 0.033110860735177994}, {"wallTime": 1733071859.9264116, "step": 4440, "value": 0.02844131551682949}, {"wallTime": 1733071868.6754656, "step": 4450, "value": 0.04045095667243004}, {"wallTime": 1733071881.33839, "step": 4460, "value": 0.033396825194358826}, {"wallTime": 1733071889.6399245, "step": 4470, "value": 0.03526892885565758}, {"wallTime": 1733071898.4230425, "step": 4480, "value": 0.03297553211450577}, {"wallTime": 1733071907.3382237, "step": 4490, "value": 0.04058096557855606}, {"wallTime": 1733071916.2804208, "step": 4500, "value": 0.044367678463459015}, {"wallTime": 1733071925.3508685, "step": 4510, "value": 0.04679230973124504}, {"wallTime": 1733071933.331573, "step": 4520, "value": 0.04970085248351097}, {"wallTime": 1733071941.4848683, "step": 4530, "value": 0.03583645075559616}, {"wallTime": 1733071954.1711757, "step": 4540, "value": 0.026871683076024055}, {"wallTime": 1733071962.3979952, "step": 4550, "value": 0.030399803072214127}, {"wallTime": 1733071970.5154583, "step": 4560, "value": 0.04214546084403992}, {"wallTime": 1733071978.8720596, "step": 4570, "value": 0.030522385612130165}, {"wallTime": 1733071987.712593, "step": 4580, "value": 0.05331997200846672}, {"wallTime": 1733071996.447218, "step": 4590, "value": 0.05209556967020035}, {"wallTime": 1733072004.4780438, "step": 4600, "value": 0.019767729565501213}, {"wallTime": 1733072012.7468088, "step": 4610, "value": 0.0323907844722271}, {"wallTime": 1733072025.4023497, "step": 4620, "value": 0.042686037719249725}, {"wallTime": 1733072034.1203697, "step": 4630, "value": 0.025309540331363678}, {"wallTime": 1733072043.0398743, "step": 4640, "value": 0.0383581779897213}, {"wallTime": 1733072051.7885716, "step": 4650, "value": 0.031132709234952927}, {"wallTime": 1733072060.1101112, "step": 4660, "value": 0.04667491093277931}, {"wallTime": 1733072068.6048448, "step": 4670, "value": 0.05097963660955429}, {"wallTime": 1733072076.838224, "step": 4680, "value": 0.040542103350162506}, {"wallTime": 1733072085.3775818, "step": 4690, "value": 0.027414437383413315}, {"wallTime": 1733072093.7500648, "step": 4700, "value": 0.03939136117696762}, {"wallTime": 1733072106.9912477, "step": 4710, "value": 0.04240472614765167}, {"wallTime": 1733072115.6667006, "step": 4720, "value": 0.05372851714491844}, {"wallTime": 1733072123.9521098, "step": 4730, "value": 0.04778993874788284}, {"wallTime": 1733072132.282187, "step": 4740, "value": 0.031271982938051224}, {"wallTime": 1733072140.4221811, "step": 4750, "value": 0.06173386797308922}, {"wallTime": 1733072149.0885973, "step": 4760, "value": 0.02714628539979458}, {"wallTime": 1733072157.4133184, "step": 4770, "value": 0.03093421645462513}, {"wallTime": 1733072165.4907758, "step": 4780, "value": 0.05562895908951759}, {"wallTime": 1733072179.6517358, "step": 4790, "value": 0.035642050206661224}, {"wallTime": 1733072188.3310835, "step": 4800, "value": 0.02881878986954689}, {"wallTime": 1733072196.848468, "step": 4810, "value": 0.04090888425707817}, {"wallTime": 1733072204.563731, "step": 4820, "value": 0.03587910532951355}, {"wallTime": 1733072213.1011026, "step": 4830, "value": 0.02384794130921364}, {"wallTime": 1733072221.6685982, "step": 4840, "value": 0.026488902047276497}, {"wallTime": 1733072229.8955307, "step": 4850, "value": 0.026567690074443817}, {"wallTime": 1733072238.0576985, "step": 4860, "value": 0.038680046796798706}, {"wallTime": 1733072246.3450916, "step": 4870, "value": 0.025556325912475586}, {"wallTime": 1733072261.268885, "step": 4880, "value": 0.0356125608086586}, {"wallTime": 1733072269.8542593, "step": 4890, "value": 0.03835510089993477}, {"wallTime": 1733072278.8818624, "step": 4900, "value": 0.03746113181114197}, {"wallTime": 1733072287.5360117, "step": 4910, "value": 0.030206747353076935}, {"wallTime": 1733072295.948833, "step": 4920, "value": 0.034967247396707535}, {"wallTime": 1733072304.356924, "step": 4930, "value": 0.04652385413646698}, {"wallTime": 1733072313.5114238, "step": 4940, "value": 0.030487829819321632}, {"wallTime": 1733072321.3270051, "step": 4950, "value": 0.03423861414194107}, {"wallTime": 1733072337.0266335, "step": 4960, "value": 0.03072018176317215}, {"wallTime": 1733072345.5346117, "step": 4970, "value": 0.026911042630672455}, {"wallTime": 1733072353.4314187, "step": 4980, "value": 0.025509536266326904}, {"wallTime": 1733072362.4149013, "step": 4990, "value": 0.044142767786979675}, {"wallTime": 1733072371.7476404, "step": 5000, "value": 0.04429825022816658}, {"wallTime": 1733072380.5313444, "step": 5010, "value": 0.029130438342690468}, {"wallTime": 1733072389.02821, "step": 5020, "value": 0.041202984750270844}, {"wallTime": 1733072397.787286, "step": 5030, "value": 0.03051222860813141}, {"wallTime": 1733072411.3001835, "step": 5040, "value": 0.04057842493057251}, {"wallTime": 1733072419.4760683, "step": 5050, "value": 0.039445776492357254}, {"wallTime": 1733072428.3739522, "step": 5060, "value": 0.04697089642286301}, {"wallTime": 1733072437.1188073, "step": 5070, "value": 0.04075480252504349}, {"wallTime": 1733072446.1771193, "step": 5080, "value": 0.049472957849502563}, {"wallTime": 1733072454.430326, "step": 5090, "value": 0.03725884109735489}, {"wallTime": 1733072462.412305, "step": 5100, "value": 0.044511739164590836}, {"wallTime": 1733072471.152476, "step": 5110, "value": 0.02903798595070839}, {"wallTime": 1733072478.9484642, "step": 5120, "value": 0.030111659318208694}, {"wallTime": 1733072491.3234465, "step": 5130, "value": 0.04475175961852074}, {"wallTime": 1733072499.2605033, "step": 5140, "value": 0.023613741621375084}, {"wallTime": 1733072507.1138084, "step": 5150, "value": 0.040448836982250214}, {"wallTime": 1733072515.3190312, "step": 5160, "value": 0.025115784257650375}, {"wallTime": 1733072523.5189326, "step": 5170, "value": 0.029943525791168213}, {"wallTime": 1733072531.0890427, "step": 5180, "value": 0.024787843227386475}, {"wallTime": 1733072540.025259, "step": 5190, "value": 0.029645752161741257}, {"wallTime": 1733072548.655437, "step": 5200, "value": 0.02915477752685547}, {"wallTime": 1733072561.4186053, "step": 5210, "value": 0.04680432006716728}, {"wallTime": 1733072569.8996863, "step": 5220, "value": 0.03551315888762474}, {"wallTime": 1733072578.6822524, "step": 5230, "value": 0.045903466641902924}, {"wallTime": 1733072586.94558, "step": 5240, "value": 0.032974179834127426}, {"wallTime": 1733072595.0361118, "step": 5250, "value": 0.046127382665872574}, {"wallTime": 1733072603.1752264, "step": 5260, "value": 0.04484664276242256}, {"wallTime": 1733072611.0826173, "step": 5270, "value": 0.06782222539186478}, {"wallTime": 1733072619.958122, "step": 5280, "value": 0.029099170118570328}, {"wallTime": 1733072628.6363106, "step": 5290, "value": 0.02676944062113762}, {"wallTime": 1733072641.377389, "step": 5300, "value": 0.026818104088306427}, {"wallTime": 1733072649.860347, "step": 5310, "value": 0.03577987849712372}, {"wallTime": 1733072657.9731364, "step": 5320, "value": 0.0343041829764843}, {"wallTime": 1733072667.0312185, "step": 5330, "value": 0.036993563175201416}, {"wallTime": 1733072675.9448159, "step": 5340, "value": 0.02570338547229767}, {"wallTime": 1733072684.2401783, "step": 5350, "value": 0.04021019488573074}, {"wallTime": 1733072691.859878, "step": 5360, "value": 0.028998244553804398}, {"wallTime": 1733072700.1497586, "step": 5370, "value": 0.03690725564956665}, {"wallTime": 1733072713.1848683, "step": 5380, "value": 0.035109881311655045}, {"wallTime": 1733072721.026474, "step": 5390, "value": 0.031820524483919144}, {"wallTime": 1733072729.8786817, "step": 5400, "value": 0.04058576375246048}, {"wallTime": 1733072738.3728383, "step": 5410, "value": 0.03603886440396309}, {"wallTime": 1733072746.384432, "step": 5420, "value": 0.02703668363392353}, {"wallTime": 1733072754.6193998, "step": 5430, "value": 0.033738765865564346}, {"wallTime": 1733072762.5502892, "step": 5440, "value": 0.036764174699783325}, {"wallTime": 1733072771.3623683, "step": 5450, "value": 0.03282926604151726}, {"wallTime": 1733072787.1534758, "step": 5460, "value": 0.03875229135155678}, {"wallTime": 1733072795.8045967, "step": 5470, "value": 0.04535429924726486}, {"wallTime": 1733072804.2438197, "step": 5480, "value": 0.027605660259723663}, {"wallTime": 1733072812.3748183, "step": 5490, "value": 0.03082422912120819}, {"wallTime": 1733072821.1609762, "step": 5500, "value": 0.03167256712913513}, {"wallTime": 1733072830.0243669, "step": 5510, "value": 0.03558377921581268}, {"wallTime": 1733072838.6968427, "step": 5520, "value": 0.035259440541267395}, {"wallTime": 1733072846.9066284, "step": 5530, "value": 0.02864956483244896}, {"wallTime": 1733072855.2495136, "step": 5540, "value": 0.04601801186800003}, {"wallTime": 1733072870.6475425, "step": 5550, "value": 0.034928128123283386}, {"wallTime": 1733072878.7324965, "step": 5560, "value": 0.033000342547893524}, {"wallTime": 1733072886.6138678, "step": 5570, "value": 0.038846779614686966}, {"wallTime": 1733072895.022939, "step": 5580, "value": 0.03448797017335892}, {"wallTime": 1733072903.404448, "step": 5590, "value": 0.028925389051437378}, {"wallTime": 1733072911.2115076, "step": 5600, "value": 0.030454490333795547}, {"wallTime": 1733072919.8414383, "step": 5610, "value": 0.027026034891605377}, {"wallTime": 1733072928.7346132, "step": 5620, "value": 0.03510960191488266}, {"wallTime": 1733072941.7052677, "step": 5630, "value": 0.03930871933698654}, {"wallTime": 1733072949.981759, "step": 5640, "value": 0.03127605468034744}, {"wallTime": 1733072958.7226615, "step": 5650, "value": 0.06944642961025238}, {"wallTime": 1733072966.8174746, "step": 5660, "value": 0.032589517533779144}, {"wallTime": 1733072974.9649222, "step": 5670, "value": 0.02806035988032818}, {"wallTime": 1733072983.563568, "step": 5680, "value": 0.04976672679185867}, {"wallTime": 1733072992.231304, "step": 5690, "value": 0.02849605306982994}, {"wallTime": 1733073000.818754, "step": 5700, "value": 0.019970104098320007}, {"wallTime": 1733073009.7847774, "step": 5710, "value": 0.04851560667157173}, {"wallTime": 1733073022.8698437, "step": 5720, "value": 0.04549607262015343}, {"wallTime": 1733073031.5372193, "step": 5730, "value": 0.026456285268068314}, {"wallTime": 1733073039.5736256, "step": 5740, "value": 0.04290233924984932}, {"wallTime": 1733073047.844417, "step": 5750, "value": 0.030725833028554916}, {"wallTime": 1733073056.1580722, "step": 5760, "value": 0.028425166383385658}, {"wallTime": 1733073064.956641, "step": 5770, "value": 0.0434807650744915}, {"wallTime": 1733073073.839272, "step": 5780, "value": 0.03852110728621483}, {"wallTime": 1733073082.7265687, "step": 5790, "value": 0.02861003205180168}, {"wallTime": 1733073095.1046119, "step": 5800, "value": 0.04653701186180115}, {"wallTime": 1733073103.3173702, "step": 5810, "value": 0.027531152591109276}, {"wallTime": 1733073111.972217, "step": 5820, "value": 0.02670442685484886}, {"wallTime": 1733073120.3588688, "step": 5830, "value": 0.037237748503685}, {"wallTime": 1733073128.2108405, "step": 5840, "value": 0.036513857543468475}, {"wallTime": 1733073136.7172887, "step": 5850, "value": 0.027503792196512222}, {"wallTime": 1733073144.929423, "step": 5860, "value": 0.0548083633184433}, {"wallTime": 1733073153.0438883, "step": 5870, "value": 0.03346565365791321}, {"wallTime": 1733073166.004751, "step": 5880, "value": 0.03428826481103897}, {"wallTime": 1733073174.6606994, "step": 5890, "value": 0.03381869196891785}, {"wallTime": 1733073182.5099726, "step": 5900, "value": 0.0497034527361393}, {"wallTime": 1733073191.5611515, "step": 5910, "value": 0.02342105284333229}, {"wallTime": 1733073199.4142623, "step": 5920, "value": 0.04469790309667587}, {"wallTime": 1733073207.4671476, "step": 5930, "value": 0.027055811136960983}, {"wallTime": 1733073215.6045394, "step": 5940, "value": 0.031632982194423676}, {"wallTime": 1733073224.3598585, "step": 5950, "value": 0.027099862694740295}, {"wallTime": 1733073232.8793232, "step": 5960, "value": 0.03991468995809555}, {"wallTime": 1733073245.3757167, "step": 5970, "value": 0.04216095060110092}, {"wallTime": 1733073253.1813023, "step": 5980, "value": 0.0374145433306694}, {"wallTime": 1733073261.8029718, "step": 5990, "value": 0.03406278043985367}, {"wallTime": 1733073270.0615344, "step": 6000, "value": 0.03783039376139641}, {"wallTime": 1733073278.8982065, "step": 6010, "value": 0.03850223496556282}, {"wallTime": 1733073287.683996, "step": 6020, "value": 0.04028813913464546}, {"wallTime": 1733073297.2763543, "step": 6030, "value": 0.039324093610048294}, {"wallTime": 1733073305.9201484, "step": 6040, "value": 0.03834206238389015}, {"wallTime": 1733073322.3565686, "step": 6050, "value": 0.0335618294775486}, {"wallTime": 1733073331.979166, "step": 6060, "value": 0.040587928146123886}, {"wallTime": 1733073340.5241425, "step": 6070, "value": 0.033007439225912094}, {"wallTime": 1733073349.6038766, "step": 6080, "value": 0.028686923906207085}, {"wallTime": 1733073359.0731413, "step": 6090, "value": 0.044547416269779205}, {"wallTime": 1733073368.4048991, "step": 6100, "value": 0.026946790516376495}, {"wallTime": 1733073377.6769028, "step": 6110, "value": 0.034513190388679504}, {"wallTime": 1733073386.40239, "step": 6120, "value": 0.03030461259186268}, {"wallTime": 1733073395.453406, "step": 6130, "value": 0.03694947436451912}, {"wallTime": 1733073408.1531844, "step": 6140, "value": 0.026565294712781906}, {"wallTime": 1733073417.3258162, "step": 6150, "value": 0.028696265071630478}, {"wallTime": 1733073426.2597635, "step": 6160, "value": 0.03857860714197159}, {"wallTime": 1733073434.8112438, "step": 6170, "value": 0.03549748286604881}, {"wallTime": 1733073444.5145485, "step": 6180, "value": 0.06387238204479218}, {"wallTime": 1733073453.1194577, "step": 6190, "value": 0.03191379830241203}, {"wallTime": 1733073462.567489, "step": 6200, "value": 0.03055073507130146}, {"wallTime": 1733073472.0265715, "step": 6210, "value": 0.03759665787220001}, {"wallTime": 1733073484.4502997, "step": 6220, "value": 0.0326128825545311}, {"wallTime": 1733073493.6617875, "step": 6230, "value": 0.025697313249111176}, {"wallTime": 1733073502.4431133, "step": 6240, "value": 0.04136517271399498}, {"wallTime": 1733073511.2582617, "step": 6250, "value": 0.036643702536821365}, {"wallTime": 1733073520.5115771, "step": 6260, "value": 0.027626056224107742}, {"wallTime": 1733073529.7832148, "step": 6270, "value": 0.0379069559276104}, {"wallTime": 1733073539.6409001, "step": 6280, "value": 0.03220317140221596}, {"wallTime": 1733073548.9127448, "step": 6290, "value": 0.029201239347457886}, {"wallTime": 1733073560.621551, "step": 6300, "value": 0.03129813075065613}, {"wallTime": 1733073570.0707586, "step": 6310, "value": 0.03527315333485603}, {"wallTime": 1733073579.4830205, "step": 6320, "value": 0.03554564341902733}, {"wallTime": 1733073587.6691113, "step": 6330, "value": 0.03313712403178215}, {"wallTime": 1733073597.2196743, "step": 6340, "value": 0.03581457585096359}, {"wallTime": 1733073606.2399058, "step": 6350, "value": 0.03169303387403488}, {"wallTime": 1733073615.079465, "step": 6360, "value": 0.034196995198726654}, {"wallTime": 1733073624.8362463, "step": 6370, "value": 0.031248537823557854}, {"wallTime": 1733073634.6743674, "step": 6380, "value": 0.04100438952445984}, {"wallTime": 1733073646.5300286, "step": 6390, "value": 0.03167964890599251}, {"wallTime": 1733073655.7472665, "step": 6400, "value": 0.03278469666838646}, {"wallTime": 1733073665.6089766, "step": 6410, "value": 0.03125568479299545}, {"wallTime": 1733073674.6445312, "step": 6420, "value": 0.029794897884130478}, {"wallTime": 1733073683.672122, "step": 6430, "value": 0.03552132099866867}, {"wallTime": 1733073692.8785517, "step": 6440, "value": 0.03262835368514061}, {"wallTime": 1733073702.5209508, "step": 6450, "value": 0.032179586589336395}, {"wallTime": 1733073712.6291144, "step": 6460, "value": 0.031479883939027786}, {"wallTime": 1733073724.0494206, "step": 6470, "value": 0.025929834693670273}, {"wallTime": 1733073732.8302648, "step": 6480, "value": 0.04220815375447273}, {"wallTime": 1733073741.9596171, "step": 6490, "value": 0.03812463581562042}, {"wallTime": 1733073750.7194219, "step": 6500, "value": 0.06008114293217659}, {"wallTime": 1733073760.4898763, "step": 6510, "value": 0.03603123500943184}, {"wallTime": 1733073769.8651776, "step": 6520, "value": 0.030812116339802742}, {"wallTime": 1733073779.1288464, "step": 6530, "value": 0.033198148012161255}, {"wallTime": 1733073789.4794588, "step": 6540, "value": 0.0360565148293972}, {"wallTime": 1733073798.1051702, "step": 6550, "value": 0.0332152396440506}, {"wallTime": 1733073810.554726, "step": 6560, "value": 0.049230776727199554}, {"wallTime": 1733073820.0382617, "step": 6570, "value": 0.044194795191287994}, {"wallTime": 1733073828.2404451, "step": 6580, "value": 0.032239481806755066}, {"wallTime": 1733073836.8000526, "step": 6590, "value": 0.02833908423781395}, {"wallTime": 1733073845.9893541, "step": 6600, "value": 0.035444676876068115}, {"wallTime": 1733073855.2539816, "step": 6610, "value": 0.033655308187007904}, {"wallTime": 1733073864.6955163, "step": 6620, "value": 0.030755529180169106}, {"wallTime": 1733073873.836449, "step": 6630, "value": 0.027407117187976837}, {"wallTime": 1733073887.5265403, "step": 6640, "value": 0.03436770662665367}, {"wallTime": 1733073897.3361151, "step": 6650, "value": 0.035644203424453735}, {"wallTime": 1733073906.8786833, "step": 6660, "value": 0.04593483358621597}, {"wallTime": 1733073916.35214, "step": 6670, "value": 0.03623918071389198}, {"wallTime": 1733073925.620733, "step": 6680, "value": 0.029489852488040924}, {"wallTime": 1733073934.9187934, "step": 6690, "value": 0.03410003334283829}, {"wallTime": 1733073943.7444031, "step": 6700, "value": 0.045787300914525986}, {"wallTime": 1733073952.47905, "step": 6710, "value": 0.04471961781382561}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15051" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_3%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_3", "runToSeries": {".": [{"wallTime": 1733067631.5407298, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.6540554, "step": 10, "value": 0.053507328033447266}, {"wallTime": 1733067660.7861185, "step": 20, "value": 0.04550386592745781}, {"wallTime": 1733067674.1393743, "step": 30, "value": 0.051278308033943176}, {"wallTime": 1733067687.0590205, "step": 40, "value": 0.06572197377681732}, {"wallTime": 1733067699.4950871, "step": 50, "value": 0.10094626247882843}, {"wallTime": 1733067710.6312633, "step": 60, "value": 0.08789129555225372}, {"wallTime": 1733067722.7574346, "step": 70, "value": 0.03460902348160744}, {"wallTime": 1733067733.7272584, "step": 80, "value": 0.12409073114395142}, {"wallTime": 1733067750.9481514, "step": 90, "value": 0.043200816959142685}, {"wallTime": 1733067761.982837, "step": 100, "value": 0.06447503715753555}, {"wallTime": 1733067771.6082547, "step": 110, "value": 0.07050009071826935}, {"wallTime": 1733067780.5492547, "step": 120, "value": 0.12617017328739166}, {"wallTime": 1733067790.487278, "step": 130, "value": 0.05163029208779335}, {"wallTime": 1733067799.1074722, "step": 140, "value": 0.08753617107868195}, {"wallTime": 1733067809.4468222, "step": 150, "value": 0.13922764360904694}, {"wallTime": 1733067818.9225461, "step": 160, "value": 0.062174491584300995}, {"wallTime": 1733067836.6514683, "step": 170, "value": 0.06604387611150742}, {"wallTime": 1733067846.3923826, "step": 180, "value": 0.07855083048343658}, {"wallTime": 1733067855.668877, "step": 190, "value": 0.07649277150630951}, {"wallTime": 1733067864.8929398, "step": 200, "value": 0.07953514158725739}, {"wallTime": 1733067874.0038044, "step": 210, "value": 0.06439723819494247}, {"wallTime": 1733067883.7891855, "step": 220, "value": 0.06286285072565079}, {"wallTime": 1733067892.1250134, "step": 230, "value": 0.05703217536211014}, {"wallTime": 1733067901.0712156, "step": 240, "value": 0.10151747614145279}, {"wallTime": 1733067910.0767694, "step": 250, "value": 0.08362679928541183}, {"wallTime": 1733067925.951879, "step": 260, "value": 0.06292876601219177}, {"wallTime": 1733067935.4774408, "step": 270, "value": 0.051396679133176804}, {"wallTime": 1733067944.0186157, "step": 280, "value": 0.053628090769052505}, {"wallTime": 1733067952.5497391, "step": 290, "value": 0.12203425168991089}, {"wallTime": 1733067961.0285704, "step": 300, "value": 0.1087523102760315}, {"wallTime": 1733067970.1364057, "step": 310, "value": 0.08811083436012268}, {"wallTime": 1733067980.2276313, "step": 320, "value": 0.060268584638834}, {"wallTime": 1733067988.8179057, "step": 330, "value": 0.0680682510137558}, {"wallTime": 1733068005.0924911, "step": 340, "value": 0.06342402845621109}, {"wallTime": 1733068014.0670595, "step": 350, "value": 0.029318444430828094}, {"wallTime": 1733068022.554888, "step": 360, "value": 0.05973391979932785}, {"wallTime": 1733068031.8265543, "step": 370, "value": 0.06371147185564041}, {"wallTime": 1733068040.7896948, "step": 380, "value": 0.054487619549036026}, {"wallTime": 1733068050.1621547, "step": 390, "value": 0.09972333163022995}, {"wallTime": 1733068059.1280081, "step": 400, "value": 0.10610833764076233}, {"wallTime": 1733068068.0919876, "step": 410, "value": 0.10990133881568909}, {"wallTime": 1733068084.8463297, "step": 420, "value": 0.08020751178264618}, {"wallTime": 1733068094.6686416, "step": 430, "value": 0.04444592073559761}, {"wallTime": 1733068103.710155, "step": 440, "value": 0.05417998880147934}, {"wallTime": 1733068112.7015831, "step": 450, "value": 0.056358058005571365}, {"wallTime": 1733068121.503166, "step": 460, "value": 0.0466068834066391}, {"wallTime": 1733068130.7298539, "step": 470, "value": 0.0690360963344574}, {"wallTime": 1733068139.8578172, "step": 480, "value": 0.06115611642599106}, {"wallTime": 1733068149.3721209, "step": 490, "value": 0.07238956540822983}, {"wallTime": 1733068158.072133, "step": 500, "value": 0.07141300290822983}, {"wallTime": 1733068174.1173146, "step": 510, "value": 0.086440309882164}, {"wallTime": 1733068182.7217646, "step": 520, "value": 0.04782970994710922}, {"wallTime": 1733068192.4158602, "step": 530, "value": 0.08054378628730774}, {"wallTime": 1733068201.832761, "step": 540, "value": 0.07322416454553604}, {"wallTime": 1733068210.656761, "step": 550, "value": 0.07277262210845947}, {"wallTime": 1733068220.197312, "step": 560, "value": 0.07345431298017502}, {"wallTime": 1733068229.161697, "step": 570, "value": 0.07945176213979721}, {"wallTime": 1733068238.5938475, "step": 580, "value": 0.06972657144069672}, {"wallTime": 1733068256.0772595, "step": 590, "value": 0.05234922468662262}, {"wallTime": 1733068265.4341683, "step": 600, "value": 0.12212789803743362}, {"wallTime": 1733068274.6587343, "step": 610, "value": 0.05309018865227699}, {"wallTime": 1733068283.7723348, "step": 620, "value": 0.057977333664894104}, {"wallTime": 1733068293.3364284, "step": 630, "value": 0.05888998508453369}, {"wallTime": 1733068302.649442, "step": 640, "value": 0.07406593859195709}, {"wallTime": 1733068311.3904707, "step": 650, "value": 0.057110968977212906}, {"wallTime": 1733068320.3924685, "step": 660, "value": 0.07198172807693481}, {"wallTime": 1733068328.7337887, "step": 670, "value": 0.07117027789354324}, {"wallTime": 1733068344.4635859, "step": 680, "value": 0.08040732145309448}, {"wallTime": 1733068353.7192764, "step": 690, "value": 0.05026893690228462}, {"wallTime": 1733068362.060193, "step": 700, "value": 0.08109249919652939}, {"wallTime": 1733068371.1064045, "step": 710, "value": 0.04291699826717377}, {"wallTime": 1733068380.5355222, "step": 720, "value": 0.07679936289787292}, {"wallTime": 1733068390.0889826, "step": 730, "value": 0.043340664356946945}, {"wallTime": 1733068398.7233362, "step": 740, "value": 0.08696340024471283}, {"wallTime": 1733068407.1263316, "step": 750, "value": 0.05903948098421097}, {"wallTime": 1733068423.0750282, "step": 760, "value": 0.06386076658964157}, {"wallTime": 1733068431.4077127, "step": 770, "value": 0.07484704256057739}, {"wallTime": 1733068440.4273725, "step": 780, "value": 0.04518924281001091}, {"wallTime": 1733068449.009026, "step": 790, "value": 0.059458762407302856}, {"wallTime": 1733068457.6414986, "step": 800, "value": 0.04093022644519806}, {"wallTime": 1733068467.0659978, "step": 810, "value": 0.058299507945775986}, {"wallTime": 1733068475.622922, "step": 820, "value": 0.05942535027861595}, {"wallTime": 1733068484.9814317, "step": 830, "value": 0.04698920622467995}, {"wallTime": 1733068500.7341092, "step": 840, "value": 0.042005911469459534}, {"wallTime": 1733068509.3103242, "step": 850, "value": 0.04424609988927841}, {"wallTime": 1733068519.024747, "step": 860, "value": 0.035681094974279404}, {"wallTime": 1733068527.501119, "step": 870, "value": 0.060764458030462265}, {"wallTime": 1733068536.9229012, "step": 880, "value": 0.05594490468502045}, {"wallTime": 1733068544.9114091, "step": 890, "value": 0.05004456639289856}, {"wallTime": 1733068553.5817668, "step": 900, "value": 0.059840936213731766}, {"wallTime": 1733068562.6886241, "step": 910, "value": 0.06956728547811508}, {"wallTime": 1733068571.2490292, "step": 920, "value": 0.05255020409822464}, {"wallTime": 1733068584.779183, "step": 930, "value": 0.03988876938819885}, {"wallTime": 1733068593.7760272, "step": 940, "value": 0.06180284544825554}, {"wallTime": 1733068602.7696662, "step": 950, "value": 0.026693006977438927}, {"wallTime": 1733068611.0436625, "step": 960, "value": 0.06856783479452133}, {"wallTime": 1733068620.2303603, "step": 970, "value": 0.05202077701687813}, {"wallTime": 1733068628.845526, "step": 980, "value": 0.047411613166332245}, {"wallTime": 1733068637.6342375, "step": 990, "value": 0.037801649421453476}, {"wallTime": 1733068646.6769078, "step": 1000, "value": 0.06494014710187912}, {"wallTime": 1733068662.7609332, "step": 1010, "value": 0.053963445127010345}, {"wallTime": 1733068672.058365, "step": 1020, "value": 0.05067851394414902}, {"wallTime": 1733068680.5670812, "step": 1030, "value": 0.06654766947031021}, {"wallTime": 1733068690.1899717, "step": 1040, "value": 0.03914206847548485}, {"wallTime": 1733068698.8523326, "step": 1050, "value": 0.06311799585819244}, {"wallTime": 1733068707.7474864, "step": 1060, "value": 0.04302287846803665}, {"wallTime": 1733068717.3486795, "step": 1070, "value": 0.04361175000667572}, {"wallTime": 1733068726.365393, "step": 1080, "value": 0.03291073814034462}, {"wallTime": 1733068735.2557878, "step": 1090, "value": 0.04396898299455643}, {"wallTime": 1733068749.5520594, "step": 1100, "value": 0.03302513808012009}, {"wallTime": 1733068758.3793817, "step": 1110, "value": 0.054666917771101}, {"wallTime": 1733068767.0079107, "step": 1120, "value": 0.06030741706490517}, {"wallTime": 1733068776.6229234, "step": 1130, "value": 0.050560250878334045}, {"wallTime": 1733068785.4053903, "step": 1140, "value": 0.06405006349086761}, {"wallTime": 1733068794.283179, "step": 1150, "value": 0.06771056354045868}, {"wallTime": 1733068802.701364, "step": 1160, "value": 0.0695495456457138}, {"wallTime": 1733068811.5560296, "step": 1170, "value": 0.055219247937202454}, {"wallTime": 1733068824.9698534, "step": 1180, "value": 0.049461815506219864}, {"wallTime": 1733068834.381318, "step": 1190, "value": 0.04462511092424393}, {"wallTime": 1733068843.5202353, "step": 1200, "value": 0.05155947431921959}, {"wallTime": 1733068852.2326381, "step": 1210, "value": 0.04081188887357712}, {"wallTime": 1733068861.1210082, "step": 1220, "value": 0.04082970321178436}, {"wallTime": 1733068870.0599425, "step": 1230, "value": 0.06466018408536911}, {"wallTime": 1733068878.72441, "step": 1240, "value": 0.06891519576311111}, {"wallTime": 1733068887.7421963, "step": 1250, "value": 0.03844932094216347}, {"wallTime": 1733068903.1708696, "step": 1260, "value": 0.03682129085063934}, {"wallTime": 1733068912.421168, "step": 1270, "value": 0.05257910490036011}, {"wallTime": 1733068921.4789338, "step": 1280, "value": 0.06599464267492294}, {"wallTime": 1733068929.75066, "step": 1290, "value": 0.04602959752082825}, {"wallTime": 1733068939.5054271, "step": 1300, "value": 0.04177585989236832}, {"wallTime": 1733068948.9320817, "step": 1310, "value": 0.03225114196538925}, {"wallTime": 1733068957.2384815, "step": 1320, "value": 0.061066508293151855}, {"wallTime": 1733068966.0810735, "step": 1330, "value": 0.0578063540160656}, {"wallTime": 1733068975.5693264, "step": 1340, "value": 0.057869140058755875}, {"wallTime": 1733068989.8039167, "step": 1350, "value": 0.030452553182840347}, {"wallTime": 1733068998.2874594, "step": 1360, "value": 0.02888965979218483}, {"wallTime": 1733069007.154823, "step": 1370, "value": 0.039208587259054184}, {"wallTime": 1733069015.9269512, "step": 1380, "value": 0.036726899445056915}, {"wallTime": 1733069025.3072724, "step": 1390, "value": 0.04702669009566307}, {"wallTime": 1733069034.4854968, "step": 1400, "value": 0.055920254439115524}, {"wallTime": 1733069042.7970304, "step": 1410, "value": 0.05988254398107529}, {"wallTime": 1733069052.1415563, "step": 1420, "value": 0.042816080152988434}, {"wallTime": 1733069065.0057492, "step": 1430, "value": 0.04415048286318779}, {"wallTime": 1733069074.527984, "step": 1440, "value": 0.04738980904221535}, {"wallTime": 1733069083.7865825, "step": 1450, "value": 0.04940468817949295}, {"wallTime": 1733069092.2630343, "step": 1460, "value": 0.056156985461711884}, {"wallTime": 1733069101.0339062, "step": 1470, "value": 0.05414516106247902}, {"wallTime": 1733069109.9097822, "step": 1480, "value": 0.06355348974466324}, {"wallTime": 1733069119.1217895, "step": 1490, "value": 0.044162094593048096}, {"wallTime": 1733069128.4190652, "step": 1500, "value": 0.05208868160843849}, {"wallTime": 1733069137.6096072, "step": 1510, "value": 0.05945909395813942}, {"wallTime": 1733069150.5464423, "step": 1520, "value": 0.034356821328401566}, {"wallTime": 1733069159.7598977, "step": 1530, "value": 0.04489804804325104}, {"wallTime": 1733069168.173522, "step": 1540, "value": 0.0536901094019413}, {"wallTime": 1733069176.843821, "step": 1550, "value": 0.05311911925673485}, {"wallTime": 1733069185.8950956, "step": 1560, "value": 0.03479092940688133}, {"wallTime": 1733069194.927142, "step": 1570, "value": 0.06131872534751892}, {"wallTime": 1733069203.9173245, "step": 1580, "value": 0.03237522765994072}, {"wallTime": 1733069212.719269, "step": 1590, "value": 0.038360148668289185}, {"wallTime": 1733069225.5369966, "step": 1600, "value": 0.03823645040392876}, {"wallTime": 1733069235.4666884, "step": 1610, "value": 0.04683331027626991}, {"wallTime": 1733069244.6333694, "step": 1620, "value": 0.041158903390169144}, {"wallTime": 1733069254.2964883, "step": 1630, "value": 0.050367824733257294}, {"wallTime": 1733069263.0082526, "step": 1640, "value": 0.04737645387649536}, {"wallTime": 1733069271.8694887, "step": 1650, "value": 0.054306838661432266}, {"wallTime": 1733069280.5127053, "step": 1660, "value": 0.09569814801216125}, {"wallTime": 1733069289.682608, "step": 1670, "value": 0.04705052450299263}, {"wallTime": 1733069303.6138778, "step": 1680, "value": 0.05978606641292572}, {"wallTime": 1733069312.4825184, "step": 1690, "value": 0.04095511883497238}, {"wallTime": 1733069321.841768, "step": 1700, "value": 0.04366971179842949}, {"wallTime": 1733069330.3508043, "step": 1710, "value": 0.044959019869565964}, {"wallTime": 1733069339.2483628, "step": 1720, "value": 0.036390308290719986}, {"wallTime": 1733069346.861876, "step": 1730, "value": 0.07575967162847519}, {"wallTime": 1733069355.6573868, "step": 1740, "value": 0.034448474645614624}, {"wallTime": 1733069364.514902, "step": 1750, "value": 0.06570813804864883}, {"wallTime": 1733069373.741518, "step": 1760, "value": 0.0880078673362732}, {"wallTime": 1733069387.543958, "step": 1770, "value": 0.04842793568968773}, {"wallTime": 1733069396.471825, "step": 1780, "value": 0.06637831032276154}, {"wallTime": 1733069405.9990747, "step": 1790, "value": 0.050253137946128845}, {"wallTime": 1733069415.0566554, "step": 1800, "value": 0.04288485646247864}, {"wallTime": 1733069423.9102702, "step": 1810, "value": 0.042331818491220474}, {"wallTime": 1733069432.534028, "step": 1820, "value": 0.050629764795303345}, {"wallTime": 1733069441.2221992, "step": 1830, "value": 0.04067940637469292}, {"wallTime": 1733069450.0928626, "step": 1840, "value": 0.03434735909104347}, {"wallTime": 1733069463.1098552, "step": 1850, "value": 0.03646085783839226}, {"wallTime": 1733069471.5754533, "step": 1860, "value": 0.031328752636909485}, {"wallTime": 1733069480.5006323, "step": 1870, "value": 0.0733746886253357}, {"wallTime": 1733069489.387346, "step": 1880, "value": 0.046297550201416016}, {"wallTime": 1733069497.9791672, "step": 1890, "value": 0.055958595126867294}, {"wallTime": 1733069506.8172884, "step": 1900, "value": 0.032495271414518356}, {"wallTime": 1733069515.8270447, "step": 1910, "value": 0.05013369768857956}, {"wallTime": 1733069524.6389248, "step": 1920, "value": 0.03557440638542175}, {"wallTime": 1733069533.5446708, "step": 1930, "value": 0.05780553072690964}, {"wallTime": 1733069550.480401, "step": 1940, "value": 0.02413901500403881}, {"wallTime": 1733069558.8304424, "step": 1950, "value": 0.0591551810503006}, {"wallTime": 1733069567.7602885, "step": 1960, "value": 0.039749205112457275}, {"wallTime": 1733069576.347594, "step": 1970, "value": 0.05118483304977417}, {"wallTime": 1733069585.5314956, "step": 1980, "value": 0.04901965707540512}, {"wallTime": 1733069594.3526602, "step": 1990, "value": 0.05147971957921982}, {"wallTime": 1733069602.404078, "step": 2000, "value": 0.0603434294462204}, {"wallTime": 1733069610.2523093, "step": 2010, "value": 0.05234319716691971}, {"wallTime": 1733069626.6891654, "step": 2020, "value": 0.048229604959487915}, {"wallTime": 1733069635.033251, "step": 2030, "value": 0.03670591861009598}, {"wallTime": 1733069643.8249762, "step": 2040, "value": 0.05308298394083977}, {"wallTime": 1733069652.1967275, "step": 2050, "value": 0.05626905709505081}, {"wallTime": 1733069660.4558322, "step": 2060, "value": 0.07697419822216034}, {"wallTime": 1733069669.5944078, "step": 2070, "value": 0.034624043852090836}, {"wallTime": 1733069678.7808268, "step": 2080, "value": 0.05177617818117142}, {"wallTime": 1733069686.9472413, "step": 2090, "value": 0.04910267889499664}, {"wallTime": 1733069700.6044526, "step": 2100, "value": 0.035928793251514435}, {"wallTime": 1733069708.7287045, "step": 2110, "value": 0.03906441852450371}, {"wallTime": 1733069717.4505718, "step": 2120, "value": 0.044547490775585175}, {"wallTime": 1733069726.1435828, "step": 2130, "value": 0.031562432646751404}, {"wallTime": 1733069735.0403702, "step": 2140, "value": 0.03251820430159569}, {"wallTime": 1733069743.3083973, "step": 2150, "value": 0.04051957279443741}, {"wallTime": 1733069752.5031545, "step": 2160, "value": 0.04288281872868538}, {"wallTime": 1733069761.4532971, "step": 2170, "value": 0.03660900890827179}, {"wallTime": 1733069770.4354658, "step": 2180, "value": 0.052186645567417145}, {"wallTime": 1733069784.3662121, "step": 2190, "value": 0.04321839660406113}, {"wallTime": 1733069793.1248076, "step": 2200, "value": 0.03412090986967087}, {"wallTime": 1733069801.6384866, "step": 2210, "value": 0.05395609885454178}, {"wallTime": 1733069810.6101646, "step": 2220, "value": 0.03980684652924538}, {"wallTime": 1733069819.3451817, "step": 2230, "value": 0.05865909531712532}, {"wallTime": 1733069827.3283446, "step": 2240, "value": 0.047420576214790344}, {"wallTime": 1733069835.8704967, "step": 2250, "value": 0.03469771146774292}, {"wallTime": 1733069844.2381816, "step": 2260, "value": 0.04724849760532379}, {"wallTime": 1733069856.7517052, "step": 2270, "value": 0.06594114005565643}, {"wallTime": 1733069865.2597966, "step": 2280, "value": 0.05894053727388382}, {"wallTime": 1733069874.0081036, "step": 2290, "value": 0.04051991552114487}, {"wallTime": 1733069881.7838237, "step": 2300, "value": 0.04664796590805054}, {"wallTime": 1733069890.4159865, "step": 2310, "value": 0.03144413232803345}, {"wallTime": 1733069898.8787968, "step": 2320, "value": 0.0504746250808239}, {"wallTime": 1733069908.319856, "step": 2330, "value": 0.03762862831354141}, {"wallTime": 1733069917.417376, "step": 2340, "value": 0.03739373758435249}, {"wallTime": 1733069925.8529956, "step": 2350, "value": 0.038633666932582855}, {"wallTime": 1733069938.70634, "step": 2360, "value": 0.07444238662719727}, {"wallTime": 1733069947.428294, "step": 2370, "value": 0.029797639697790146}, {"wallTime": 1733069956.2102463, "step": 2380, "value": 0.044878046959638596}, {"wallTime": 1733069964.2769258, "step": 2390, "value": 0.07498402148485184}, {"wallTime": 1733069973.3281803, "step": 2400, "value": 0.032539792358875275}, {"wallTime": 1733069981.4341955, "step": 2410, "value": 0.02426103875041008}, {"wallTime": 1733069990.1418147, "step": 2420, "value": 0.04747477173805237}, {"wallTime": 1733069998.80093, "step": 2430, "value": 0.04178646206855774}, {"wallTime": 1733070012.4579284, "step": 2440, "value": 0.040753163397312164}, {"wallTime": 1733070021.6011543, "step": 2450, "value": 0.037447378039360046}, {"wallTime": 1733070030.1930354, "step": 2460, "value": 0.03699769079685211}, {"wallTime": 1733070039.221337, "step": 2470, "value": 0.04875478893518448}, {"wallTime": 1733070048.2709723, "step": 2480, "value": 0.043354637920856476}, {"wallTime": 1733070056.1578104, "step": 2490, "value": 0.03543267399072647}, {"wallTime": 1733070064.4526742, "step": 2500, "value": 0.02729920670390129}, {"wallTime": 1733070072.5541768, "step": 2510, "value": 0.05674789100885391}, {"wallTime": 1733070087.6590078, "step": 2520, "value": 0.03122929483652115}, {"wallTime": 1733070095.4437087, "step": 2530, "value": 0.02617029659450054}, {"wallTime": 1733070103.770926, "step": 2540, "value": 0.05321839824318886}, {"wallTime": 1733070113.0514934, "step": 2550, "value": 0.04280475899577141}, {"wallTime": 1733070121.039783, "step": 2560, "value": 0.054428599774837494}, {"wallTime": 1733070129.587267, "step": 2570, "value": 0.03901613503694534}, {"wallTime": 1733070138.3628576, "step": 2580, "value": 0.04104826971888542}, {"wallTime": 1733070147.0893302, "step": 2590, "value": 0.04399068281054497}, {"wallTime": 1733070155.4889815, "step": 2600, "value": 0.036647628992795944}, {"wallTime": 1733070172.5793245, "step": 2610, "value": 0.04650608450174332}, {"wallTime": 1733070181.2131608, "step": 2620, "value": 0.03608192875981331}, {"wallTime": 1733070189.6944463, "step": 2630, "value": 0.04652326926589012}, {"wallTime": 1733070198.4011316, "step": 2640, "value": 0.05073670670390129}, {"wallTime": 1733070206.7094533, "step": 2650, "value": 0.040423352271318436}, {"wallTime": 1733070215.601831, "step": 2660, "value": 0.03588347136974335}, {"wallTime": 1733070224.3183126, "step": 2670, "value": 0.042925458401441574}, {"wallTime": 1733070233.541401, "step": 2680, "value": 0.04871821030974388}, {"wallTime": 1733070246.7602832, "step": 2690, "value": 0.03241077437996864}, {"wallTime": 1733070256.0312204, "step": 2700, "value": 0.057026613503694534}, {"wallTime": 1733070264.9527714, "step": 2710, "value": 0.03191928192973137}, {"wallTime": 1733070273.8290434, "step": 2720, "value": 0.0455404669046402}, {"wallTime": 1733070282.961109, "step": 2730, "value": 0.04083199054002762}, {"wallTime": 1733070292.2799294, "step": 2740, "value": 0.03555545210838318}, {"wallTime": 1733070300.3388038, "step": 2750, "value": 0.05417168140411377}, {"wallTime": 1733070309.4142246, "step": 2760, "value": 0.04828302562236786}, {"wallTime": 1733070317.5335863, "step": 2770, "value": 0.04419982433319092}, {"wallTime": 1733070330.4382381, "step": 2780, "value": 0.04228193312883377}, {"wallTime": 1733070339.8255668, "step": 2790, "value": 0.04091606289148331}, {"wallTime": 1733070347.9970276, "step": 2800, "value": 0.03434723615646362}, {"wallTime": 1733070356.896514, "step": 2810, "value": 0.04038441926240921}, {"wallTime": 1733070365.579062, "step": 2820, "value": 0.034279342740774155}, {"wallTime": 1733070374.3957202, "step": 2830, "value": 0.03191068023443222}, {"wallTime": 1733070382.429046, "step": 2840, "value": 0.052267126739025116}, {"wallTime": 1733070390.9433575, "step": 2850, "value": 0.02973930537700653}, {"wallTime": 1733070406.6807714, "step": 2860, "value": 0.06257834285497665}, {"wallTime": 1733070415.0925186, "step": 2870, "value": 0.05781211331486702}, {"wallTime": 1733070422.9221604, "step": 2880, "value": 0.029819898307323456}, {"wallTime": 1733070431.5394197, "step": 2890, "value": 0.03359018266201019}, {"wallTime": 1733070439.983069, "step": 2900, "value": 0.03613737225532532}, {"wallTime": 1733070448.0875916, "step": 2910, "value": 0.04770863056182861}, {"wallTime": 1733070457.4257236, "step": 2920, "value": 0.032998643815517426}, {"wallTime": 1733070466.725, "step": 2930, "value": 0.05096288397908211}, {"wallTime": 1733070479.334779, "step": 2940, "value": 0.042217135429382324}, {"wallTime": 1733070488.7844646, "step": 2950, "value": 0.029712041839957237}, {"wallTime": 1733070497.22701, "step": 2960, "value": 0.03250521421432495}, {"wallTime": 1733070505.6358564, "step": 2970, "value": 0.03208687901496887}, {"wallTime": 1733070513.3559952, "step": 2980, "value": 0.057628385722637177}, {"wallTime": 1733070522.3194752, "step": 2990, "value": 0.03772331774234772}, {"wallTime": 1733070530.214672, "step": 3000, "value": 0.052835751324892044}, {"wallTime": 1733070538.302026, "step": 3010, "value": 0.030461151152849197}, {"wallTime": 1733070547.4025252, "step": 3020, "value": 0.04430413991212845}, {"wallTime": 1733070564.053076, "step": 3030, "value": 0.03829232603311539}, {"wallTime": 1733070572.3717754, "step": 3040, "value": 0.02978135086596012}, {"wallTime": 1733070580.673278, "step": 3050, "value": 0.052149686962366104}, {"wallTime": 1733070588.6552129, "step": 3060, "value": 0.02906401827931404}, {"wallTime": 1733070597.4228961, "step": 3070, "value": 0.03371185064315796}, {"wallTime": 1733070606.1394203, "step": 3080, "value": 0.06394337117671967}, {"wallTime": 1733070614.4419162, "step": 3090, "value": 0.060166969895362854}, {"wallTime": 1733070624.0023537, "step": 3100, "value": 0.02821425348520279}, {"wallTime": 1733070637.2540405, "step": 3110, "value": 0.047898344695568085}, {"wallTime": 1733070645.6840417, "step": 3120, "value": 0.03233518451452255}, {"wallTime": 1733070654.2715847, "step": 3130, "value": 0.04529762640595436}, {"wallTime": 1733070663.3224273, "step": 3140, "value": 0.03714382275938988}, {"wallTime": 1733070671.1190705, "step": 3150, "value": 0.05718138813972473}, {"wallTime": 1733070679.7666001, "step": 3160, "value": 0.02699618972837925}, {"wallTime": 1733070687.846686, "step": 3170, "value": 0.05619226396083832}, {"wallTime": 1733070695.8568032, "step": 3180, "value": 0.03063037618994713}, {"wallTime": 1733070704.6235323, "step": 3190, "value": 0.034383099526166916}, {"wallTime": 1733070717.1099744, "step": 3200, "value": 0.046363428235054016}, {"wallTime": 1733070726.0997965, "step": 3210, "value": 0.04627440497279167}, {"wallTime": 1733070734.7797496, "step": 3220, "value": 0.04346424341201782}, {"wallTime": 1733070744.4136338, "step": 3230, "value": 0.02795945107936859}, {"wallTime": 1733070752.502739, "step": 3240, "value": 0.03958528861403465}, {"wallTime": 1733070761.7224388, "step": 3250, "value": 0.026332218199968338}, {"wallTime": 1733070770.3777425, "step": 3260, "value": 0.026561476290225983}, {"wallTime": 1733070779.7310264, "step": 3270, "value": 0.03491732105612755}, {"wallTime": 1733070793.6796918, "step": 3280, "value": 0.034140296280384064}, {"wallTime": 1733070801.9010437, "step": 3290, "value": 0.0274340957403183}, {"wallTime": 1733070810.1621044, "step": 3300, "value": 0.026669593527913094}, {"wallTime": 1733070818.7276597, "step": 3310, "value": 0.037725869566202164}, {"wallTime": 1733070827.0096717, "step": 3320, "value": 0.04376593232154846}, {"wallTime": 1733070835.5772576, "step": 3330, "value": 0.06379102170467377}, {"wallTime": 1733070843.9774542, "step": 3340, "value": 0.03926880657672882}, {"wallTime": 1733070853.0930443, "step": 3350, "value": 0.057769253849983215}, {"wallTime": 1733070865.4207213, "step": 3360, "value": 0.030553307384252548}, {"wallTime": 1733070873.6627176, "step": 3370, "value": 0.03345043957233429}, {"wallTime": 1733070883.337071, "step": 3380, "value": 0.03469960391521454}, {"wallTime": 1733070892.378061, "step": 3390, "value": 0.035716213285923004}, {"wallTime": 1733070900.7234209, "step": 3400, "value": 0.04650314152240753}, {"wallTime": 1733070908.5052452, "step": 3410, "value": 0.029387015849351883}, {"wallTime": 1733070916.656842, "step": 3420, "value": 0.04440406337380409}, {"wallTime": 1733070925.212639, "step": 3430, "value": 0.034317538142204285}, {"wallTime": 1733070933.8113706, "step": 3440, "value": 0.037099119275808334}, {"wallTime": 1733070947.4808884, "step": 3450, "value": 0.032239437103271484}, {"wallTime": 1733070956.188724, "step": 3460, "value": 0.030427824705839157}, {"wallTime": 1733070964.2674468, "step": 3470, "value": 0.09334562718868256}, {"wallTime": 1733070972.3872495, "step": 3480, "value": 0.04095088317990303}, {"wallTime": 1733070980.6481988, "step": 3490, "value": 0.04148685187101364}, {"wallTime": 1733070989.6888576, "step": 3500, "value": 0.034963227808475494}, {"wallTime": 1733070997.7898254, "step": 3510, "value": 0.05161979794502258}, {"wallTime": 1733071006.272567, "step": 3520, "value": 0.06358124315738678}, {"wallTime": 1733071018.8972847, "step": 3530, "value": 0.04143340885639191}, {"wallTime": 1733071027.1984816, "step": 3540, "value": 0.02347012609243393}, {"wallTime": 1733071035.3218133, "step": 3550, "value": 0.050210900604724884}, {"wallTime": 1733071043.7469463, "step": 3560, "value": 0.03254745528101921}, {"wallTime": 1733071051.8733878, "step": 3570, "value": 0.046790897846221924}, {"wallTime": 1733071060.497341, "step": 3580, "value": 0.03990927338600159}, {"wallTime": 1733071068.88073, "step": 3590, "value": 0.04648781567811966}, {"wallTime": 1733071077.714253, "step": 3600, "value": 0.03998471796512604}, {"wallTime": 1733071086.2136545, "step": 3610, "value": 0.03823745995759964}, {"wallTime": 1733071101.6600757, "step": 3620, "value": 0.03930599242448807}, {"wallTime": 1733071109.6235106, "step": 3630, "value": 0.04796837270259857}, {"wallTime": 1733071118.1305628, "step": 3640, "value": 0.03523881733417511}, {"wallTime": 1733071126.9944477, "step": 3650, "value": 0.03234684839844704}, {"wallTime": 1733071135.8286967, "step": 3660, "value": 0.04384274035692215}, {"wallTime": 1733071144.2497852, "step": 3670, "value": 0.03769100457429886}, {"wallTime": 1733071152.9658105, "step": 3680, "value": 0.03363597020506859}, {"wallTime": 1733071160.6047537, "step": 3690, "value": 0.03365873545408249}, {"wallTime": 1733071173.7516205, "step": 3700, "value": 0.03722438961267471}, {"wallTime": 1733071182.8845298, "step": 3710, "value": 0.03009176068007946}, {"wallTime": 1733071191.211489, "step": 3720, "value": 0.058601949363946915}, {"wallTime": 1733071200.3347087, "step": 3730, "value": 0.024368854239583015}, {"wallTime": 1733071208.367014, "step": 3740, "value": 0.026725053787231445}, {"wallTime": 1733071216.5732372, "step": 3750, "value": 0.05406110733747482}, {"wallTime": 1733071224.663185, "step": 3760, "value": 0.026165343821048737}, {"wallTime": 1733071232.862071, "step": 3770, "value": 0.05488010495901108}, {"wallTime": 1733071248.5349007, "step": 3780, "value": 0.027598708868026733}, {"wallTime": 1733071257.3930595, "step": 3790, "value": 0.03264964371919632}, {"wallTime": 1733071265.5686393, "step": 3800, "value": 0.03270100802183151}, {"wallTime": 1733071274.1994555, "step": 3810, "value": 0.03355097398161888}, {"wallTime": 1733071283.0192623, "step": 3820, "value": 0.03319500386714935}, {"wallTime": 1733071291.7311254, "step": 3830, "value": 0.03166578337550163}, {"wallTime": 1733071299.8955142, "step": 3840, "value": 0.029810763895511627}, {"wallTime": 1733071308.4809027, "step": 3850, "value": 0.044490016996860504}, {"wallTime": 1733071316.952963, "step": 3860, "value": 0.038037728518247604}, {"wallTime": 1733071330.2167926, "step": 3870, "value": 0.04048683121800423}, {"wallTime": 1733071338.990421, "step": 3880, "value": 0.04326339066028595}, {"wallTime": 1733071347.7383173, "step": 3890, "value": 0.0257105752825737}, {"wallTime": 1733071357.0363555, "step": 3900, "value": 0.03172866255044937}, {"wallTime": 1733071365.2269936, "step": 3910, "value": 0.06060367450118065}, {"wallTime": 1733071374.136249, "step": 3920, "value": 0.04749887064099312}, {"wallTime": 1733071382.8154783, "step": 3930, "value": 0.05017872527241707}, {"wallTime": 1733071391.5700238, "step": 3940, "value": 0.02980385720729828}, {"wallTime": 1733071404.4690464, "step": 3950, "value": 0.02826310507953167}, {"wallTime": 1733071412.340562, "step": 3960, "value": 0.02885197103023529}, {"wallTime": 1733071421.1592073, "step": 3970, "value": 0.04272579401731491}, {"wallTime": 1733071430.1222517, "step": 3980, "value": 0.033914946019649506}, {"wallTime": 1733071438.4157403, "step": 3990, "value": 0.04759623855352402}, {"wallTime": 1733071447.7305818, "step": 4000, "value": 0.023938780650496483}, {"wallTime": 1733071456.1982982, "step": 4010, "value": 0.07394901663064957}, {"wallTime": 1733071464.7512028, "step": 4020, "value": 0.03747381642460823}, {"wallTime": 1733071473.3996017, "step": 4030, "value": 0.03542131558060646}, {"wallTime": 1733071490.2882094, "step": 4040, "value": 0.03927804157137871}, {"wallTime": 1733071498.7134507, "step": 4050, "value": 0.042995065450668335}, {"wallTime": 1733071507.0993156, "step": 4060, "value": 0.029325203970074654}, {"wallTime": 1733071515.0695856, "step": 4070, "value": 0.06704672425985336}, {"wallTime": 1733071523.908587, "step": 4080, "value": 0.029068026691675186}, {"wallTime": 1733071532.2874281, "step": 4090, "value": 0.035438694059848785}, {"wallTime": 1733071540.9194584, "step": 4100, "value": 0.025784848257899284}, {"wallTime": 1733071549.1784124, "step": 4110, "value": 0.02755332551896572}, {"wallTime": 1733071565.8380713, "step": 4120, "value": 0.027556177228689194}, {"wallTime": 1733071573.6337957, "step": 4130, "value": 0.032623376697301865}, {"wallTime": 1733071582.09834, "step": 4140, "value": 0.04317522794008255}, {"wallTime": 1733071590.0249007, "step": 4150, "value": 0.038129933178424835}, {"wallTime": 1733071599.2432394, "step": 4160, "value": 0.03270921856164932}, {"wallTime": 1733071608.0740333, "step": 4170, "value": 0.0358273908495903}, {"wallTime": 1733071616.186267, "step": 4180, "value": 0.06256713718175888}, {"wallTime": 1733071626.0851848, "step": 4190, "value": 0.026576735079288483}, {"wallTime": 1733071641.0107455, "step": 4200, "value": 0.03515712544322014}, {"wallTime": 1733071649.0431366, "step": 4210, "value": 0.042109496891498566}, {"wallTime": 1733071658.533856, "step": 4220, "value": 0.04069233685731888}, {"wallTime": 1733071667.9685047, "step": 4230, "value": 0.02755906619131565}, {"wallTime": 1733071676.1112502, "step": 4240, "value": 0.02616794966161251}, {"wallTime": 1733071684.3810582, "step": 4250, "value": 0.048917412757873535}, {"wallTime": 1733071693.1121614, "step": 4260, "value": 0.023668784648180008}, {"wallTime": 1733071702.186376, "step": 4270, "value": 0.043297648429870605}, {"wallTime": 1733071710.6334474, "step": 4280, "value": 0.023470165207982063}, {"wallTime": 1733071726.6792824, "step": 4290, "value": 0.035052891820669174}, {"wallTime": 1733071735.2181144, "step": 4300, "value": 0.03918444365262985}, {"wallTime": 1733071742.959606, "step": 4310, "value": 0.035478100180625916}, {"wallTime": 1733071751.5882218, "step": 4320, "value": 0.030589744448661804}, {"wallTime": 1733071760.0375557, "step": 4330, "value": 0.031353823840618134}, {"wallTime": 1733071768.433859, "step": 4340, "value": 0.03260679170489311}, {"wallTime": 1733071777.4047456, "step": 4350, "value": 0.0436864048242569}, {"wallTime": 1733071785.5498598, "step": 4360, "value": 0.04146316647529602}, {"wallTime": 1733071800.8875008, "step": 4370, "value": 0.039129383862018585}, {"wallTime": 1733071809.2684398, "step": 4380, "value": 0.031365588307380676}, {"wallTime": 1733071817.3491235, "step": 4390, "value": 0.06780438870191574}, {"wallTime": 1733071826.4329848, "step": 4400, "value": 0.045003388077020645}, {"wallTime": 1733071834.8901377, "step": 4410, "value": 0.046023037284612656}, {"wallTime": 1733071843.4494145, "step": 4420, "value": 0.052649158984422684}, {"wallTime": 1733071851.5985878, "step": 4430, "value": 0.03295799344778061}, {"wallTime": 1733071859.926739, "step": 4440, "value": 0.028310062363743782}, {"wallTime": 1733071868.6757908, "step": 4450, "value": 0.04003261774778366}, {"wallTime": 1733071881.338725, "step": 4460, "value": 0.03334631770849228}, {"wallTime": 1733071889.6403854, "step": 4470, "value": 0.03511389344930649}, {"wallTime": 1733071898.4233646, "step": 4480, "value": 0.032825570553541183}, {"wallTime": 1733071907.338556, "step": 4490, "value": 0.04029935225844383}, {"wallTime": 1733071916.2807536, "step": 4500, "value": 0.04426560923457146}, {"wallTime": 1733071925.3511958, "step": 4510, "value": 0.04677695035934448}, {"wallTime": 1733071933.3319137, "step": 4520, "value": 0.04948092997074127}, {"wallTime": 1733071941.4851983, "step": 4530, "value": 0.03584987297654152}, {"wallTime": 1733071954.171499, "step": 4540, "value": 0.02686155214905739}, {"wallTime": 1733071962.3983328, "step": 4550, "value": 0.030281219631433487}, {"wallTime": 1733071970.515791, "step": 4560, "value": 0.04138009622693062}, {"wallTime": 1733071978.872382, "step": 4570, "value": 0.030462907627224922}, {"wallTime": 1733071987.7129374, "step": 4580, "value": 0.05289582163095474}, {"wallTime": 1733071996.4476335, "step": 4590, "value": 0.05192752182483673}, {"wallTime": 1733072004.4783733, "step": 4600, "value": 0.01975877210497856}, {"wallTime": 1733072012.7471387, "step": 4610, "value": 0.03218748793005943}, {"wallTime": 1733072025.4027417, "step": 4620, "value": 0.04221199080348015}, {"wallTime": 1733072034.1207182, "step": 4630, "value": 0.02527184598147869}, {"wallTime": 1733072043.0402148, "step": 4640, "value": 0.037774600088596344}, {"wallTime": 1733072051.7891445, "step": 4650, "value": 0.031087230890989304}, {"wallTime": 1733072060.110442, "step": 4660, "value": 0.04618477076292038}, {"wallTime": 1733072068.6051848, "step": 4670, "value": 0.050803326070308685}, {"wallTime": 1733072076.838555, "step": 4680, "value": 0.04032913222908974}, {"wallTime": 1733072085.377922, "step": 4690, "value": 0.027372490614652634}, {"wallTime": 1733072093.7503915, "step": 4700, "value": 0.0391547791659832}, {"wallTime": 1733072106.991571, "step": 4710, "value": 0.04268942400813103}, {"wallTime": 1733072115.6670496, "step": 4720, "value": 0.05365237593650818}, {"wallTime": 1733072123.9524512, "step": 4730, "value": 0.04741876572370529}, {"wallTime": 1733072132.2825193, "step": 4740, "value": 0.031136928126215935}, {"wallTime": 1733072140.4225101, "step": 4750, "value": 0.06117522343993187}, {"wallTime": 1733072149.0889707, "step": 4760, "value": 0.027116870507597923}, {"wallTime": 1733072157.4136415, "step": 4770, "value": 0.03099965676665306}, {"wallTime": 1733072165.4911096, "step": 4780, "value": 0.05532275140285492}, {"wallTime": 1733072179.652299, "step": 4790, "value": 0.03569895774126053}, {"wallTime": 1733072188.3313951, "step": 4800, "value": 0.028636258095502853}, {"wallTime": 1733072196.8488054, "step": 4810, "value": 0.040747467428445816}, {"wallTime": 1733072204.5640552, "step": 4820, "value": 0.035885926336050034}, {"wallTime": 1733072213.1014228, "step": 4830, "value": 0.023850610479712486}, {"wallTime": 1733072221.6689644, "step": 4840, "value": 0.026434648782014847}, {"wallTime": 1733072229.8958876, "step": 4850, "value": 0.026480410248041153}, {"wallTime": 1733072238.0580459, "step": 4860, "value": 0.03836866095662117}, {"wallTime": 1733072246.3454275, "step": 4870, "value": 0.025548763573169708}, {"wallTime": 1733072261.2692192, "step": 4880, "value": 0.03560555726289749}, {"wallTime": 1733072269.8546274, "step": 4890, "value": 0.03789661079645157}, {"wallTime": 1733072278.8821888, "step": 4900, "value": 0.037364840507507324}, {"wallTime": 1733072287.5363462, "step": 4910, "value": 0.030092988163232803}, {"wallTime": 1733072295.9491653, "step": 4920, "value": 0.03477755934000015}, {"wallTime": 1733072304.357247, "step": 4930, "value": 0.04663999378681183}, {"wallTime": 1733072313.511757, "step": 4940, "value": 0.03039579465985298}, {"wallTime": 1733072321.327348, "step": 4950, "value": 0.03383847698569298}, {"wallTime": 1733072337.0270026, "step": 4960, "value": 0.030600259080529213}, {"wallTime": 1733072345.5351913, "step": 4970, "value": 0.02681037411093712}, {"wallTime": 1733072353.4317575, "step": 4980, "value": 0.02534189261496067}, {"wallTime": 1733072362.4152327, "step": 4990, "value": 0.04361588507890701}, {"wallTime": 1733072371.747994, "step": 5000, "value": 0.04411740228533745}, {"wallTime": 1733072380.5316887, "step": 5010, "value": 0.029038820415735245}, {"wallTime": 1733072389.028534, "step": 5020, "value": 0.0410228930413723}, {"wallTime": 1733072397.7876024, "step": 5030, "value": 0.030526408925652504}, {"wallTime": 1733072411.3008058, "step": 5040, "value": 0.040212392807006836}, {"wallTime": 1733072419.4763827, "step": 5050, "value": 0.03946617618203163}, {"wallTime": 1733072428.3742902, "step": 5060, "value": 0.04702458158135414}, {"wallTime": 1733072437.119258, "step": 5070, "value": 0.04067813977599144}, {"wallTime": 1733072446.1774888, "step": 5080, "value": 0.04912380874156952}, {"wallTime": 1733072454.4307034, "step": 5090, "value": 0.03700099140405655}, {"wallTime": 1733072462.4126344, "step": 5100, "value": 0.044459111988544464}, {"wallTime": 1733072471.152934, "step": 5110, "value": 0.028917711228132248}, {"wallTime": 1733072478.948809, "step": 5120, "value": 0.030068140476942062}, {"wallTime": 1733072491.3237896, "step": 5130, "value": 0.04441642761230469}, {"wallTime": 1733072499.2608376, "step": 5140, "value": 0.023449450731277466}, {"wallTime": 1733072507.1141493, "step": 5150, "value": 0.040126733481884}, {"wallTime": 1733072515.3193674, "step": 5160, "value": 0.025014841929078102}, {"wallTime": 1733072523.5194848, "step": 5170, "value": 0.029968470335006714}, {"wallTime": 1733072531.0893629, "step": 5180, "value": 0.0247297715395689}, {"wallTime": 1733072540.0258186, "step": 5190, "value": 0.02955777756869793}, {"wallTime": 1733072548.6560102, "step": 5200, "value": 0.029231347143650055}, {"wallTime": 1733072561.4191823, "step": 5210, "value": 0.046311937272548676}, {"wallTime": 1733072569.9002473, "step": 5220, "value": 0.03537308797240257}, {"wallTime": 1733072578.6828277, "step": 5230, "value": 0.04577907919883728}, {"wallTime": 1733072586.9461668, "step": 5240, "value": 0.03288421034812927}, {"wallTime": 1733072595.036428, "step": 5250, "value": 0.04564999043941498}, {"wallTime": 1733072603.1755526, "step": 5260, "value": 0.04501326009631157}, {"wallTime": 1733072611.08308, "step": 5270, "value": 0.06725187599658966}, {"wallTime": 1733072619.9586425, "step": 5280, "value": 0.0291819516569376}, {"wallTime": 1733072628.6366546, "step": 5290, "value": 0.0267668254673481}, {"wallTime": 1733072641.3777385, "step": 5300, "value": 0.026759445667266846}, {"wallTime": 1733072649.8607073, "step": 5310, "value": 0.035715050995349884}, {"wallTime": 1733072657.9734545, "step": 5320, "value": 0.033870529383420944}, {"wallTime": 1733072667.031535, "step": 5330, "value": 0.036931365728378296}, {"wallTime": 1733072675.9451432, "step": 5340, "value": 0.02551122009754181}, {"wallTime": 1733072684.2404985, "step": 5350, "value": 0.040647394955158234}, {"wallTime": 1733072691.8601985, "step": 5360, "value": 0.0290234312415123}, {"wallTime": 1733072700.1501033, "step": 5370, "value": 0.03674749657511711}, {"wallTime": 1733072713.1851966, "step": 5380, "value": 0.0344659723341465}, {"wallTime": 1733072721.026815, "step": 5390, "value": 0.031928740441799164}, {"wallTime": 1733072729.8790023, "step": 5400, "value": 0.040387991815805435}, {"wallTime": 1733072738.373388, "step": 5410, "value": 0.035878077149391174}, {"wallTime": 1733072746.3847666, "step": 5420, "value": 0.02694622427225113}, {"wallTime": 1733072754.6197374, "step": 5430, "value": 0.03363431990146637}, {"wallTime": 1733072762.5508606, "step": 5440, "value": 0.03664647787809372}, {"wallTime": 1733072771.362723, "step": 5450, "value": 0.03216785192489624}, {"wallTime": 1733072787.1538703, "step": 5460, "value": 0.03859284520149231}, {"wallTime": 1733072795.8049552, "step": 5470, "value": 0.04519163817167282}, {"wallTime": 1733072804.2441561, "step": 5480, "value": 0.02764165587723255}, {"wallTime": 1733072812.375134, "step": 5490, "value": 0.03068043850362301}, {"wallTime": 1733072821.161365, "step": 5500, "value": 0.03141864761710167}, {"wallTime": 1733072830.0247025, "step": 5510, "value": 0.03553652763366699}, {"wallTime": 1733072838.6971676, "step": 5520, "value": 0.035264160484075546}, {"wallTime": 1733072846.9069643, "step": 5530, "value": 0.028363127261400223}, {"wallTime": 1733072855.250084, "step": 5540, "value": 0.04605846107006073}, {"wallTime": 1733072870.6481204, "step": 5550, "value": 0.0343550406396389}, {"wallTime": 1733072878.7330687, "step": 5560, "value": 0.03291095793247223}, {"wallTime": 1733072886.6144235, "step": 5570, "value": 0.03882864862680435}, {"wallTime": 1733072895.0232625, "step": 5580, "value": 0.034283969551324844}, {"wallTime": 1733072903.4047854, "step": 5590, "value": 0.028777306899428368}, {"wallTime": 1733072911.2118754, "step": 5600, "value": 0.03028547391295433}, {"wallTime": 1733072919.8418267, "step": 5610, "value": 0.027102265506982803}, {"wallTime": 1733072928.7349765, "step": 5620, "value": 0.03494604676961899}, {"wallTime": 1733072941.7055926, "step": 5630, "value": 0.03915400803089142}, {"wallTime": 1733072949.9820948, "step": 5640, "value": 0.03122055158019066}, {"wallTime": 1733072958.7232394, "step": 5650, "value": 0.06882874667644501}, {"wallTime": 1733072966.8180578, "step": 5660, "value": 0.03266417980194092}, {"wallTime": 1733072974.9654658, "step": 5670, "value": 0.027959298342466354}, {"wallTime": 1733072983.563933, "step": 5680, "value": 0.04921289160847664}, {"wallTime": 1733072992.2318642, "step": 5690, "value": 0.028208807110786438}, {"wallTime": 1733073000.8190958, "step": 5700, "value": 0.01991511508822441}, {"wallTime": 1733073009.7851136, "step": 5710, "value": 0.04822681099176407}, {"wallTime": 1733073022.8701825, "step": 5720, "value": 0.04516264423727989}, {"wallTime": 1733073031.537781, "step": 5730, "value": 0.026002394035458565}, {"wallTime": 1733073039.5741944, "step": 5740, "value": 0.04263325035572052}, {"wallTime": 1733073047.8447506, "step": 5750, "value": 0.03063645027577877}, {"wallTime": 1733073056.1584022, "step": 5760, "value": 0.028293583542108536}, {"wallTime": 1733073064.9569824, "step": 5770, "value": 0.04330313950777054}, {"wallTime": 1733073073.8396015, "step": 5780, "value": 0.03744668513536453}, {"wallTime": 1733073082.726915, "step": 5790, "value": 0.028507066890597343}, {"wallTime": 1733073095.104937, "step": 5800, "value": 0.04676925390958786}, {"wallTime": 1733073103.317698, "step": 5810, "value": 0.027523672208189964}, {"wallTime": 1733073111.972537, "step": 5820, "value": 0.026543354615569115}, {"wallTime": 1733073120.3594372, "step": 5830, "value": 0.036868348717689514}, {"wallTime": 1733073128.2111778, "step": 5840, "value": 0.036242544651031494}, {"wallTime": 1733073136.7176025, "step": 5850, "value": 0.027356360107660294}, {"wallTime": 1733073144.9297645, "step": 5860, "value": 0.05455843731760979}, {"wallTime": 1733073153.0446398, "step": 5870, "value": 0.03312249481678009}, {"wallTime": 1733073166.0050874, "step": 5880, "value": 0.03461263328790665}, {"wallTime": 1733073174.66103, "step": 5890, "value": 0.03374144434928894}, {"wallTime": 1733073182.5102975, "step": 5900, "value": 0.04960460215806961}, {"wallTime": 1733073191.5614662, "step": 5910, "value": 0.023358482867479324}, {"wallTime": 1733073199.4148297, "step": 5920, "value": 0.043777160346508026}, {"wallTime": 1733073207.4674678, "step": 5930, "value": 0.02695373259484768}, {"wallTime": 1733073215.6048841, "step": 5940, "value": 0.031197454780340195}, {"wallTime": 1733073224.3601866, "step": 5950, "value": 0.02695963904261589}, {"wallTime": 1733073232.8797698, "step": 5960, "value": 0.03908562660217285}, {"wallTime": 1733073245.3760505, "step": 5970, "value": 0.041717931628227234}, {"wallTime": 1733073253.181618, "step": 5980, "value": 0.03720615431666374}, {"wallTime": 1733073261.8035257, "step": 5990, "value": 0.034020036458969116}, {"wallTime": 1733073270.06186, "step": 6000, "value": 0.03787482529878616}, {"wallTime": 1733073278.8986614, "step": 6010, "value": 0.038209784775972366}, {"wallTime": 1733073287.6843202, "step": 6020, "value": 0.03978576883673668}, {"wallTime": 1733073297.2766843, "step": 6030, "value": 0.03973351791501045}, {"wallTime": 1733073305.9204683, "step": 6040, "value": 0.038338545709848404}, {"wallTime": 1733073322.3569114, "step": 6050, "value": 0.03328608348965645}, {"wallTime": 1733073331.9794955, "step": 6060, "value": 0.040521569550037384}, {"wallTime": 1733073340.524478, "step": 6070, "value": 0.032120876014232635}, {"wallTime": 1733073349.6042032, "step": 6080, "value": 0.02862635813653469}, {"wallTime": 1733073359.0734746, "step": 6090, "value": 0.04392281919717789}, {"wallTime": 1733073368.4052236, "step": 6100, "value": 0.026866642758250237}, {"wallTime": 1733073377.6772306, "step": 6110, "value": 0.034096937626600266}, {"wallTime": 1733073386.402771, "step": 6120, "value": 0.03003823012113571}, {"wallTime": 1733073395.4537342, "step": 6130, "value": 0.0367804579436779}, {"wallTime": 1733073408.1535115, "step": 6140, "value": 0.026488468050956726}, {"wallTime": 1733073417.3261652, "step": 6150, "value": 0.02850285731256008}, {"wallTime": 1733073426.26032, "step": 6160, "value": 0.03827882558107376}, {"wallTime": 1733073434.8115776, "step": 6170, "value": 0.035359080880880356}, {"wallTime": 1733073444.514892, "step": 6180, "value": 0.06330537796020508}, {"wallTime": 1733073453.1200228, "step": 6190, "value": 0.031757235527038574}, {"wallTime": 1733073462.5678308, "step": 6200, "value": 0.03051156923174858}, {"wallTime": 1733073472.0269911, "step": 6210, "value": 0.037241507321596146}, {"wallTime": 1733073484.450616, "step": 6220, "value": 0.03225331753492355}, {"wallTime": 1733073493.6621227, "step": 6230, "value": 0.025715600699186325}, {"wallTime": 1733073502.4434435, "step": 6240, "value": 0.040730688720941544}, {"wallTime": 1733073511.2586355, "step": 6250, "value": 0.036528896540403366}, {"wallTime": 1733073520.5119143, "step": 6260, "value": 0.027643389999866486}, {"wallTime": 1733073529.783544, "step": 6270, "value": 0.03792013227939606}, {"wallTime": 1733073539.6412308, "step": 6280, "value": 0.03193017467856407}, {"wallTime": 1733073548.913078, "step": 6290, "value": 0.0291083212941885}, {"wallTime": 1733073560.6218863, "step": 6300, "value": 0.03116380050778389}, {"wallTime": 1733073570.0710874, "step": 6310, "value": 0.035045042634010315}, {"wallTime": 1733073579.4833596, "step": 6320, "value": 0.035520024597644806}, {"wallTime": 1733073587.6694384, "step": 6330, "value": 0.03279366344213486}, {"wallTime": 1733073597.2200153, "step": 6340, "value": 0.03567924723029137}, {"wallTime": 1733073606.2402346, "step": 6350, "value": 0.031752295792102814}, {"wallTime": 1733073615.07982, "step": 6360, "value": 0.03415754809975624}, {"wallTime": 1733073624.8365731, "step": 6370, "value": 0.031109388917684555}, {"wallTime": 1733073634.6747243, "step": 6380, "value": 0.04108193516731262}, {"wallTime": 1733073646.5303495, "step": 6390, "value": 0.03157462552189827}, {"wallTime": 1733073655.7475836, "step": 6400, "value": 0.0326804593205452}, {"wallTime": 1733073665.6093104, "step": 6410, "value": 0.030933398753404617}, {"wallTime": 1733073674.6448603, "step": 6420, "value": 0.029461439698934555}, {"wallTime": 1733073683.6724389, "step": 6430, "value": 0.03545337915420532}, {"wallTime": 1733073692.8788898, "step": 6440, "value": 0.03254889324307442}, {"wallTime": 1733073702.5212848, "step": 6450, "value": 0.03196803480386734}, {"wallTime": 1733073712.6294355, "step": 6460, "value": 0.03130112215876579}, {"wallTime": 1733073724.0497603, "step": 6470, "value": 0.025919348001480103}, {"wallTime": 1733073732.830587, "step": 6480, "value": 0.041988909244537354}, {"wallTime": 1733073741.960029, "step": 6490, "value": 0.038291964679956436}, {"wallTime": 1733073750.719743, "step": 6500, "value": 0.05942169576883316}, {"wallTime": 1733073760.4902022, "step": 6510, "value": 0.035682350397109985}, {"wallTime": 1733073769.865504, "step": 6520, "value": 0.030656758695840836}, {"wallTime": 1733073779.1524682, "step": 6530, "value": 0.03276468440890312}, {"wallTime": 1733073789.4797997, "step": 6540, "value": 0.03594210743904114}, {"wallTime": 1733073798.1054976, "step": 6550, "value": 0.032868336886167526}, {"wallTime": 1733073810.5550666, "step": 6560, "value": 0.04882458597421646}, {"wallTime": 1733073820.0385933, "step": 6570, "value": 0.043246280401945114}, {"wallTime": 1733073828.2407973, "step": 6580, "value": 0.03220906853675842}, {"wallTime": 1733073836.8003874, "step": 6590, "value": 0.02830907329916954}, {"wallTime": 1733073845.9897082, "step": 6600, "value": 0.03470305725932121}, {"wallTime": 1733073855.2543085, "step": 6610, "value": 0.033607058227062225}, {"wallTime": 1733073864.6958616, "step": 6620, "value": 0.030769187957048416}, {"wallTime": 1733073873.8367724, "step": 6630, "value": 0.027350343763828278}, {"wallTime": 1733073887.5268748, "step": 6640, "value": 0.03433417156338692}, {"wallTime": 1733073897.3364463, "step": 6650, "value": 0.035322174429893494}, {"wallTime": 1733073906.8790236, "step": 6660, "value": 0.045561932027339935}, {"wallTime": 1733073916.3524673, "step": 6670, "value": 0.03598852455615997}, {"wallTime": 1733073925.6210668, "step": 6680, "value": 0.029235629364848137}, {"wallTime": 1733073934.9191263, "step": 6690, "value": 0.03401242196559906}, {"wallTime": 1733073943.7447536, "step": 6700, "value": 0.04506608098745346}, {"wallTime": 1733073952.479364, "step": 6710, "value": 0.04415060579776764}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15072" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_0%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_0", "runToSeries": {".": [{"wallTime": 1733067631.539691, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.653057, "step": 10, "value": 0.053557101637125015}, {"wallTime": 1733067660.7850964, "step": 20, "value": 0.04564112424850464}, {"wallTime": 1733067674.1383326, "step": 30, "value": 0.05163343995809555}, {"wallTime": 1733067687.0580165, "step": 40, "value": 0.0666482076048851}, {"wallTime": 1733067699.494046, "step": 50, "value": 0.10247862339019775}, {"wallTime": 1733067710.630212, "step": 60, "value": 0.08943208307027817}, {"wallTime": 1733067722.756406, "step": 70, "value": 0.0353589691221714}, {"wallTime": 1733067733.7262468, "step": 80, "value": 0.12449387460947037}, {"wallTime": 1733067750.9471161, "step": 90, "value": 0.042743850499391556}, {"wallTime": 1733067761.981799, "step": 100, "value": 0.062372010201215744}, {"wallTime": 1733067771.6072648, "step": 110, "value": 0.0690472200512886}, {"wallTime": 1733067780.5482554, "step": 120, "value": 0.12220095843076706}, {"wallTime": 1733067790.4862497, "step": 130, "value": 0.05040760338306427}, {"wallTime": 1733067799.1064658, "step": 140, "value": 0.08697301894426346}, {"wallTime": 1733067809.445594, "step": 150, "value": 0.1364833563566208}, {"wallTime": 1733067818.9215703, "step": 160, "value": 0.062424883246421814}, {"wallTime": 1733067836.6504195, "step": 170, "value": 0.0643153190612793}, {"wallTime": 1733067846.3914316, "step": 180, "value": 0.07910511642694473}, {"wallTime": 1733067855.6677728, "step": 190, "value": 0.0751267597079277}, {"wallTime": 1733067864.8912604, "step": 200, "value": 0.07915517687797546}, {"wallTime": 1733067874.002771, "step": 210, "value": 0.06289118528366089}, {"wallTime": 1733067883.7874906, "step": 220, "value": 0.06298967450857162}, {"wallTime": 1733067892.1240141, "step": 230, "value": 0.055509302765131}, {"wallTime": 1733067901.070218, "step": 240, "value": 0.09828858822584152}, {"wallTime": 1733067910.0757551, "step": 250, "value": 0.0817263275384903}, {"wallTime": 1733067925.9508343, "step": 260, "value": 0.06273933500051498}, {"wallTime": 1733067935.476372, "step": 270, "value": 0.0506930872797966}, {"wallTime": 1733067944.0169506, "step": 280, "value": 0.05327741801738739}, {"wallTime": 1733067952.5480514, "step": 290, "value": 0.12257331609725952}, {"wallTime": 1733067961.027577, "step": 300, "value": 0.10965237021446228}, {"wallTime": 1733067970.1354175, "step": 310, "value": 0.08800286799669266}, {"wallTime": 1733067980.2266686, "step": 320, "value": 0.05983194336295128}, {"wallTime": 1733067988.8169177, "step": 330, "value": 0.06881796568632126}, {"wallTime": 1733068005.091453, "step": 340, "value": 0.06378601491451263}, {"wallTime": 1733068014.0660393, "step": 350, "value": 0.029326677322387695}, {"wallTime": 1733068022.553887, "step": 360, "value": 0.0609176941215992}, {"wallTime": 1733068031.8255572, "step": 370, "value": 0.06653052568435669}, {"wallTime": 1733068040.7887003, "step": 380, "value": 0.05427263677120209}, {"wallTime": 1733068050.161157, "step": 390, "value": 0.10226338356733322}, {"wallTime": 1733068059.1269772, "step": 400, "value": 0.11408571153879166}, {"wallTime": 1733068068.0909977, "step": 410, "value": 0.11502302438020706}, {"wallTime": 1733068084.8452256, "step": 420, "value": 0.083526611328125}, {"wallTime": 1733068094.6675751, "step": 430, "value": 0.04606904834508896}, {"wallTime": 1733068103.7090468, "step": 440, "value": 0.05570158362388611}, {"wallTime": 1733068112.7006185, "step": 450, "value": 0.06103096157312393}, {"wallTime": 1733068121.502158, "step": 460, "value": 0.04895620420575142}, {"wallTime": 1733068130.7288637, "step": 470, "value": 0.07680903375148773}, {"wallTime": 1733068139.8568091, "step": 480, "value": 0.063334621489048}, {"wallTime": 1733068149.3711698, "step": 490, "value": 0.07729555666446686}, {"wallTime": 1733068158.0711744, "step": 500, "value": 0.06999778002500534}, {"wallTime": 1733068174.1163204, "step": 510, "value": 0.09084385633468628}, {"wallTime": 1733068182.720779, "step": 520, "value": 0.05022849515080452}, {"wallTime": 1733068192.4148355, "step": 530, "value": 0.08715658634901047}, {"wallTime": 1733068201.831599, "step": 540, "value": 0.07709255814552307}, {"wallTime": 1733068210.6557424, "step": 550, "value": 0.07795404642820358}, {"wallTime": 1733068220.1963148, "step": 560, "value": 0.07813319563865662}, {"wallTime": 1733068229.1606004, "step": 570, "value": 0.08738572895526886}, {"wallTime": 1733068238.5928407, "step": 580, "value": 0.07367630302906036}, {"wallTime": 1733068256.0755122, "step": 590, "value": 0.05317946895956993}, {"wallTime": 1733068265.433152, "step": 600, "value": 0.13174323737621307}, {"wallTime": 1733068274.657749, "step": 610, "value": 0.05670568346977234}, {"wallTime": 1733068283.7713275, "step": 620, "value": 0.06293216347694397}, {"wallTime": 1733068293.3354228, "step": 630, "value": 0.06448878347873688}, {"wallTime": 1733068302.6484418, "step": 640, "value": 0.08025086671113968}, {"wallTime": 1733068311.389469, "step": 650, "value": 0.0609397292137146}, {"wallTime": 1733068320.3914642, "step": 660, "value": 0.07683975249528885}, {"wallTime": 1733068328.7326972, "step": 670, "value": 0.07263186573982239}, {"wallTime": 1733068344.4624696, "step": 680, "value": 0.08622017502784729}, {"wallTime": 1733068353.718278, "step": 690, "value": 0.05425434559583664}, {"wallTime": 1733068362.0592108, "step": 700, "value": 0.09062992036342621}, {"wallTime": 1733068371.1053975, "step": 710, "value": 0.051145538687705994}, {"wallTime": 1733068380.5345054, "step": 720, "value": 0.09001675248146057}, {"wallTime": 1733068390.0880127, "step": 730, "value": 0.04606251046061516}, {"wallTime": 1733068398.7223442, "step": 740, "value": 0.09739097952842712}, {"wallTime": 1733068407.125335, "step": 750, "value": 0.066811703145504}, {"wallTime": 1733068423.0732794, "step": 760, "value": 0.0692686215043068}, {"wallTime": 1733068431.4067447, "step": 770, "value": 0.0864957943558693}, {"wallTime": 1733068440.4263482, "step": 780, "value": 0.04735846444964409}, {"wallTime": 1733068449.007999, "step": 790, "value": 0.06637885421514511}, {"wallTime": 1733068457.63976, "step": 800, "value": 0.047057993710041046}, {"wallTime": 1733068467.0486264, "step": 810, "value": 0.06542829424142838}, {"wallTime": 1733068475.6218994, "step": 820, "value": 0.06896532326936722}, {"wallTime": 1733068484.980453, "step": 830, "value": 0.055039383471012115}, {"wallTime": 1733068500.7330816, "step": 840, "value": 0.0528234988451004}, {"wallTime": 1733068509.3093245, "step": 850, "value": 0.049644045531749725}, {"wallTime": 1733068519.023767, "step": 860, "value": 0.04139820486307144}, {"wallTime": 1733068527.500117, "step": 870, "value": 0.07304820418357849}, {"wallTime": 1733068536.9218857, "step": 880, "value": 0.0684124305844307}, {"wallTime": 1733068544.9104068, "step": 890, "value": 0.06290839612483978}, {"wallTime": 1733068553.5807273, "step": 900, "value": 0.07192645967006683}, {"wallTime": 1733068562.687616, "step": 910, "value": 0.08201858401298523}, {"wallTime": 1733068571.2480133, "step": 920, "value": 0.05701307952404022}, {"wallTime": 1733068584.7781286, "step": 930, "value": 0.04817981645464897}, {"wallTime": 1733068593.774929, "step": 940, "value": 0.06753735989332199}, {"wallTime": 1733068602.76866, "step": 950, "value": 0.03341790661215782}, {"wallTime": 1733068611.0426826, "step": 960, "value": 0.07373197376728058}, {"wallTime": 1733068620.2293832, "step": 970, "value": 0.0641859918832779}, {"wallTime": 1733068628.8445354, "step": 980, "value": 0.05564143508672714}, {"wallTime": 1733068637.6332572, "step": 990, "value": 0.04361559450626373}, {"wallTime": 1733068646.675877, "step": 1000, "value": 0.07653982937335968}, {"wallTime": 1733068662.7596796, "step": 1010, "value": 0.06967762857675552}, {"wallTime": 1733068672.0573778, "step": 1020, "value": 0.05621008574962616}, {"wallTime": 1733068680.5659938, "step": 1030, "value": 0.07262376695871353}, {"wallTime": 1733068690.1889412, "step": 1040, "value": 0.048174820840358734}, {"wallTime": 1733068698.851346, "step": 1050, "value": 0.07368931919336319}, {"wallTime": 1733068707.746486, "step": 1060, "value": 0.05388946831226349}, {"wallTime": 1733068717.347675, "step": 1070, "value": 0.05024636536836624}, {"wallTime": 1733068726.3644168, "step": 1080, "value": 0.03837880119681358}, {"wallTime": 1733068735.2548351, "step": 1090, "value": 0.05219722539186478}, {"wallTime": 1733068749.5509832, "step": 1100, "value": 0.03556668758392334}, {"wallTime": 1733068758.3784108, "step": 1110, "value": 0.06340482831001282}, {"wallTime": 1733068767.0069115, "step": 1120, "value": 0.0671069473028183}, {"wallTime": 1733068776.6219132, "step": 1130, "value": 0.05598950386047363}, {"wallTime": 1733068785.404386, "step": 1140, "value": 0.07673802971839905}, {"wallTime": 1733068794.282133, "step": 1150, "value": 0.07963481545448303}, {"wallTime": 1733068802.7003968, "step": 1160, "value": 0.09367495030164719}, {"wallTime": 1733068811.5548744, "step": 1170, "value": 0.059785280376672745}, {"wallTime": 1733068824.968804, "step": 1180, "value": 0.06187530606985092}, {"wallTime": 1733068834.3802903, "step": 1190, "value": 0.04723384603857994}, {"wallTime": 1733068843.5192451, "step": 1200, "value": 0.05978766456246376}, {"wallTime": 1733068852.2315896, "step": 1210, "value": 0.045565731823444366}, {"wallTime": 1733068861.1200066, "step": 1220, "value": 0.0493280366063118}, {"wallTime": 1733068870.0589504, "step": 1230, "value": 0.07508395612239838}, {"wallTime": 1733068878.7234282, "step": 1240, "value": 0.0721740648150444}, {"wallTime": 1733068887.7411988, "step": 1250, "value": 0.04390652850270271}, {"wallTime": 1733068903.1698334, "step": 1260, "value": 0.03997904807329178}, {"wallTime": 1733068912.419043, "step": 1270, "value": 0.06808781623840332}, {"wallTime": 1733068921.47721, "step": 1280, "value": 0.07554623484611511}, {"wallTime": 1733068929.7496893, "step": 1290, "value": 0.05026862025260925}, {"wallTime": 1733068939.5044339, "step": 1300, "value": 0.0461321659386158}, {"wallTime": 1733068948.9309454, "step": 1310, "value": 0.037075284868478775}, {"wallTime": 1733068957.2375026, "step": 1320, "value": 0.07201109826564789}, {"wallTime": 1733068966.080079, "step": 1330, "value": 0.06676067411899567}, {"wallTime": 1733068975.5682933, "step": 1340, "value": 0.06965592503547668}, {"wallTime": 1733068989.8021803, "step": 1350, "value": 0.03932568430900574}, {"wallTime": 1733068998.2858002, "step": 1360, "value": 0.03850581869482994}, {"wallTime": 1733069007.15288, "step": 1370, "value": 0.04680011421442032}, {"wallTime": 1733069015.925275, "step": 1380, "value": 0.047177739441394806}, {"wallTime": 1733069025.3062932, "step": 1390, "value": 0.05352356284856796}, {"wallTime": 1733069034.4844518, "step": 1400, "value": 0.062159616500139236}, {"wallTime": 1733069042.7960038, "step": 1410, "value": 0.0727265477180481}, {"wallTime": 1733069052.140536, "step": 1420, "value": 0.04844790697097778}, {"wallTime": 1733069065.004724, "step": 1430, "value": 0.054176293313503265}, {"wallTime": 1733069074.5269804, "step": 1440, "value": 0.0545058473944664}, {"wallTime": 1733069083.7855701, "step": 1450, "value": 0.05766378343105316}, {"wallTime": 1733069092.2616067, "step": 1460, "value": 0.07129362225532532}, {"wallTime": 1733069101.0327587, "step": 1470, "value": 0.060483645647764206}, {"wallTime": 1733069109.9085903, "step": 1480, "value": 0.07595261931419373}, {"wallTime": 1733069119.120763, "step": 1490, "value": 0.055753372609615326}, {"wallTime": 1733069128.418057, "step": 1500, "value": 0.06599342823028564}, {"wallTime": 1733069137.608623, "step": 1510, "value": 0.06542028486728668}, {"wallTime": 1733069150.5454247, "step": 1520, "value": 0.04246525466442108}, {"wallTime": 1733069159.7589173, "step": 1530, "value": 0.05364476889371872}, {"wallTime": 1733069168.1723602, "step": 1540, "value": 0.06822780519723892}, {"wallTime": 1733069176.8428326, "step": 1550, "value": 0.07141496241092682}, {"wallTime": 1733069185.8941233, "step": 1560, "value": 0.04004199430346489}, {"wallTime": 1733069194.9260273, "step": 1570, "value": 0.07738455384969711}, {"wallTime": 1733069203.9155798, "step": 1580, "value": 0.0405004546046257}, {"wallTime": 1733069212.7179577, "step": 1590, "value": 0.04128335043787956}, {"wallTime": 1733069225.5359366, "step": 1600, "value": 0.04777219146490097}, {"wallTime": 1733069235.4657211, "step": 1610, "value": 0.05412273481488228}, {"wallTime": 1733069244.632051, "step": 1620, "value": 0.051184460520744324}, {"wallTime": 1733069254.2954495, "step": 1630, "value": 0.06043010950088501}, {"wallTime": 1733069263.0071936, "step": 1640, "value": 0.05845385789871216}, {"wallTime": 1733069271.8685024, "step": 1650, "value": 0.06783679127693176}, {"wallTime": 1733069280.5117135, "step": 1660, "value": 0.11742152273654938}, {"wallTime": 1733069289.6815844, "step": 1670, "value": 0.046123918145895004}, {"wallTime": 1733069303.612216, "step": 1680, "value": 0.0801151841878891}, {"wallTime": 1733069312.4815078, "step": 1690, "value": 0.048889338970184326}, {"wallTime": 1733069321.8404965, "step": 1700, "value": 0.05049136281013489}, {"wallTime": 1733069330.349828, "step": 1710, "value": 0.05589732527732849}, {"wallTime": 1733069339.247231, "step": 1720, "value": 0.04469852149486542}, {"wallTime": 1733069346.860171, "step": 1730, "value": 0.09709443151950836}, {"wallTime": 1733069355.6559224, "step": 1740, "value": 0.04179968684911728}, {"wallTime": 1733069364.5138912, "step": 1750, "value": 0.07809468358755112}, {"wallTime": 1733069373.7404902, "step": 1760, "value": 0.10506385564804077}, {"wallTime": 1733069387.5428996, "step": 1770, "value": 0.0614023357629776}, {"wallTime": 1733069396.4700954, "step": 1780, "value": 0.07977920770645142}, {"wallTime": 1733069405.9980843, "step": 1790, "value": 0.06727935373783112}, {"wallTime": 1733069415.0556734, "step": 1800, "value": 0.05210327357053757}, {"wallTime": 1733069423.9093006, "step": 1810, "value": 0.048395782709121704}, {"wallTime": 1733069432.5330029, "step": 1820, "value": 0.06016067788004875}, {"wallTime": 1733069441.2204769, "step": 1830, "value": 0.052818652242422104}, {"wallTime": 1733069450.0911434, "step": 1840, "value": 0.04221720993518829}, {"wallTime": 1733069463.108698, "step": 1850, "value": 0.05105556547641754}, {"wallTime": 1733069471.5744407, "step": 1860, "value": 0.03552324324846268}, {"wallTime": 1733069480.4996572, "step": 1870, "value": 0.08268404006958008}, {"wallTime": 1733069489.3863647, "step": 1880, "value": 0.061947889626026154}, {"wallTime": 1733069497.9781594, "step": 1890, "value": 0.0646619200706482}, {"wallTime": 1733069506.7956917, "step": 1900, "value": 0.043694913387298584}, {"wallTime": 1733069515.82606, "step": 1910, "value": 0.06507521867752075}, {"wallTime": 1733069524.6379075, "step": 1920, "value": 0.045870110392570496}, {"wallTime": 1733069533.543583, "step": 1930, "value": 0.07469935715198517}, {"wallTime": 1733069550.4793346, "step": 1940, "value": 0.02886063978075981}, {"wallTime": 1733069558.8294485, "step": 1950, "value": 0.07376385480165482}, {"wallTime": 1733069567.7592797, "step": 1960, "value": 0.04795991629362106}, {"wallTime": 1733069576.3465672, "step": 1970, "value": 0.06384983658790588}, {"wallTime": 1733069585.5305095, "step": 1980, "value": 0.061179645359516144}, {"wallTime": 1733069594.3516111, "step": 1990, "value": 0.05843663588166237}, {"wallTime": 1733069602.4030614, "step": 2000, "value": 0.07817510515451431}, {"wallTime": 1733069610.2513301, "step": 2010, "value": 0.06330381333827972}, {"wallTime": 1733069626.6881564, "step": 2020, "value": 0.05679662898182869}, {"wallTime": 1733069635.0322614, "step": 2030, "value": 0.04694278538227081}, {"wallTime": 1733069643.8239422, "step": 2040, "value": 0.06261936575174332}, {"wallTime": 1733069652.1957471, "step": 2050, "value": 0.07073447853326797}, {"wallTime": 1733069660.4548128, "step": 2060, "value": 0.09071135520935059}, {"wallTime": 1733069669.5934105, "step": 2070, "value": 0.04354284703731537}, {"wallTime": 1733069678.7797623, "step": 2080, "value": 0.06112378090620041}, {"wallTime": 1733069686.9462078, "step": 2090, "value": 0.060417838394641876}, {"wallTime": 1733069700.6034184, "step": 2100, "value": 0.04542094096541405}, {"wallTime": 1733069708.7276697, "step": 2110, "value": 0.04706244543194771}, {"wallTime": 1733069717.4495928, "step": 2120, "value": 0.060737960040569305}, {"wallTime": 1733069726.142573, "step": 2130, "value": 0.0383143350481987}, {"wallTime": 1733069735.0394053, "step": 2140, "value": 0.038255464285612106}, {"wallTime": 1733069743.3074174, "step": 2150, "value": 0.04952140524983406}, {"wallTime": 1733069752.5021324, "step": 2160, "value": 0.0471341609954834}, {"wallTime": 1733069761.452294, "step": 2170, "value": 0.041300784796476364}, {"wallTime": 1733069770.4344814, "step": 2180, "value": 0.06613785028457642}, {"wallTime": 1733069784.365054, "step": 2190, "value": 0.05018866807222366}, {"wallTime": 1733069793.123796, "step": 2200, "value": 0.041011013090610504}, {"wallTime": 1733069801.6374269, "step": 2210, "value": 0.06797576695680618}, {"wallTime": 1733069810.6091673, "step": 2220, "value": 0.04583307355642319}, {"wallTime": 1733069819.3437088, "step": 2230, "value": 0.08106878399848938}, {"wallTime": 1733069827.3273203, "step": 2240, "value": 0.06159520894289017}, {"wallTime": 1733069835.8693557, "step": 2250, "value": 0.04117858037352562}, {"wallTime": 1733069844.237148, "step": 2260, "value": 0.05248459428548813}, {"wallTime": 1733069856.7504709, "step": 2270, "value": 0.0902668684720993}, {"wallTime": 1733069865.2588162, "step": 2280, "value": 0.07600992172956467}, {"wallTime": 1733069874.007025, "step": 2290, "value": 0.05155190825462341}, {"wallTime": 1733069881.782826, "step": 2300, "value": 0.06023828312754631}, {"wallTime": 1733069890.4149957, "step": 2310, "value": 0.0368734672665596}, {"wallTime": 1733069898.8777788, "step": 2320, "value": 0.057730596512556076}, {"wallTime": 1733069908.3188465, "step": 2330, "value": 0.04649643227458}, {"wallTime": 1733069917.4163618, "step": 2340, "value": 0.04309646412730217}, {"wallTime": 1733069925.8519943, "step": 2350, "value": 0.04975704103708267}, {"wallTime": 1733069938.70462, "step": 2360, "value": 0.09409483522176743}, {"wallTime": 1733069947.4272664, "step": 2370, "value": 0.038096003234386444}, {"wallTime": 1733069956.2085643, "step": 2380, "value": 0.05132216960191727}, {"wallTime": 1733069964.2758963, "step": 2390, "value": 0.0970456451177597}, {"wallTime": 1733069973.3271508, "step": 2400, "value": 0.039943628013134}, {"wallTime": 1733069981.4332144, "step": 2410, "value": 0.029550837352871895}, {"wallTime": 1733069990.1408002, "step": 2420, "value": 0.058208588510751724}, {"wallTime": 1733069998.7995644, "step": 2430, "value": 0.050336550921201706}, {"wallTime": 1733070012.456884, "step": 2440, "value": 0.04813482612371445}, {"wallTime": 1733070021.6000938, "step": 2450, "value": 0.04395001381635666}, {"wallTime": 1733070030.1920297, "step": 2460, "value": 0.044059935957193375}, {"wallTime": 1733070039.2203531, "step": 2470, "value": 0.060970716178417206}, {"wallTime": 1733070048.2699633, "step": 2480, "value": 0.057347774505615234}, {"wallTime": 1733070056.1568024, "step": 2490, "value": 0.03990393877029419}, {"wallTime": 1733070064.4516613, "step": 2500, "value": 0.03227367624640465}, {"wallTime": 1733070072.55247, "step": 2510, "value": 0.07278493791818619}, {"wallTime": 1733070087.6579328, "step": 2520, "value": 0.037284620106220245}, {"wallTime": 1733070095.4427478, "step": 2530, "value": 0.033219777047634125}, {"wallTime": 1733070103.7699018, "step": 2540, "value": 0.06181365251541138}, {"wallTime": 1733070113.0503664, "step": 2550, "value": 0.05336117744445801}, {"wallTime": 1733070121.0388048, "step": 2560, "value": 0.06901393085718155}, {"wallTime": 1733070129.5859008, "step": 2570, "value": 0.05262686312198639}, {"wallTime": 1733070138.3618302, "step": 2580, "value": 0.05095105990767479}, {"wallTime": 1733070147.0883105, "step": 2590, "value": 0.05510200560092926}, {"wallTime": 1733070155.4879422, "step": 2600, "value": 0.0430854968726635}, {"wallTime": 1733070172.5782645, "step": 2610, "value": 0.0613463893532753}, {"wallTime": 1733070181.2121766, "step": 2620, "value": 0.04188433289527893}, {"wallTime": 1733070189.693406, "step": 2630, "value": 0.053842686116695404}, {"wallTime": 1733070198.4001398, "step": 2640, "value": 0.0650683119893074}, {"wallTime": 1733070206.7084403, "step": 2650, "value": 0.05402155965566635}, {"wallTime": 1733070215.6006398, "step": 2660, "value": 0.040952809154987335}, {"wallTime": 1733070224.3172822, "step": 2670, "value": 0.05583905428647995}, {"wallTime": 1733070233.5403826, "step": 2680, "value": 0.06381035596132278}, {"wallTime": 1733070246.7591968, "step": 2690, "value": 0.04310888797044754}, {"wallTime": 1733070256.0301754, "step": 2700, "value": 0.06622663885354996}, {"wallTime": 1733070264.951774, "step": 2710, "value": 0.037054941058158875}, {"wallTime": 1733070273.8280163, "step": 2720, "value": 0.058659687638282776}, {"wallTime": 1733070282.960114, "step": 2730, "value": 0.04846462607383728}, {"wallTime": 1733070292.2789083, "step": 2740, "value": 0.045243434607982635}, {"wallTime": 1733070300.3377936, "step": 2750, "value": 0.06533133238554001}, {"wallTime": 1733070309.4132142, "step": 2760, "value": 0.06533389538526535}, {"wallTime": 1733070317.5325747, "step": 2770, "value": 0.05640026926994324}, {"wallTime": 1733070330.4371755, "step": 2780, "value": 0.05452040210366249}, {"wallTime": 1733070339.8243048, "step": 2790, "value": 0.056662898510694504}, {"wallTime": 1733070347.995196, "step": 2800, "value": 0.04289001598954201}, {"wallTime": 1733070356.8946142, "step": 2810, "value": 0.05206596106290817}, {"wallTime": 1733070365.5780501, "step": 2820, "value": 0.039805490523576736}, {"wallTime": 1733070374.3947036, "step": 2830, "value": 0.04011934995651245}, {"wallTime": 1733070382.4280114, "step": 2840, "value": 0.06509296596050262}, {"wallTime": 1733070390.942364, "step": 2850, "value": 0.0345999114215374}, {"wallTime": 1733070406.679697, "step": 2860, "value": 0.07304347306489944}, {"wallTime": 1733070415.0912225, "step": 2870, "value": 0.06481502205133438}, {"wallTime": 1733070422.9211671, "step": 2880, "value": 0.04993168264627457}, {"wallTime": 1733070431.5384262, "step": 2890, "value": 0.03725476190447807}, {"wallTime": 1733070439.9820325, "step": 2900, "value": 0.04219741001725197}, {"wallTime": 1733070448.086552, "step": 2910, "value": 0.05696955695748329}, {"wallTime": 1733070457.4247406, "step": 2920, "value": 0.03693634271621704}, {"wallTime": 1733070466.723962, "step": 2930, "value": 0.060229331254959106}, {"wallTime": 1733070479.3336236, "step": 2940, "value": 0.05298691242933273}, {"wallTime": 1733070488.7834084, "step": 2950, "value": 0.03482991084456444}, {"wallTime": 1733070497.2258956, "step": 2960, "value": 0.04279368370771408}, {"wallTime": 1733070505.6348557, "step": 2970, "value": 0.037269409745931625}, {"wallTime": 1733070513.3549764, "step": 2980, "value": 0.07036525011062622}, {"wallTime": 1733070522.3021996, "step": 2990, "value": 0.05536941811442375}, {"wallTime": 1733070530.2136855, "step": 3000, "value": 0.07453589886426926}, {"wallTime": 1733070538.3010254, "step": 3010, "value": 0.035953931510448456}, {"wallTime": 1733070547.4015038, "step": 3020, "value": 0.0519309937953949}, {"wallTime": 1733070564.051747, "step": 3030, "value": 0.053105685859918594}, {"wallTime": 1733070572.3707325, "step": 3040, "value": 0.03675068914890289}, {"wallTime": 1733070580.6721053, "step": 3050, "value": 0.0723399668931961}, {"wallTime": 1733070588.6542203, "step": 3060, "value": 0.038223136216402054}, {"wallTime": 1733070597.421852, "step": 3070, "value": 0.040987130254507065}, {"wallTime": 1733070606.138415, "step": 3080, "value": 0.07571358233690262}, {"wallTime": 1733070614.4407434, "step": 3090, "value": 0.0764487087726593}, {"wallTime": 1733070624.0012505, "step": 3100, "value": 0.035383470356464386}, {"wallTime": 1733070637.253018, "step": 3110, "value": 0.05668681114912033}, {"wallTime": 1733070645.6830158, "step": 3120, "value": 0.038727305829524994}, {"wallTime": 1733070654.2705846, "step": 3130, "value": 0.05120044946670532}, {"wallTime": 1733070663.321378, "step": 3140, "value": 0.049721818417310715}, {"wallTime": 1733070671.1180801, "step": 3150, "value": 0.06688275933265686}, {"wallTime": 1733070679.765602, "step": 3160, "value": 0.036242567002773285}, {"wallTime": 1733070687.8454895, "step": 3170, "value": 0.06849931180477142}, {"wallTime": 1733070695.8558302, "step": 3180, "value": 0.03898688405752182}, {"wallTime": 1733070704.622505, "step": 3190, "value": 0.04254693537950516}, {"wallTime": 1733070717.108911, "step": 3200, "value": 0.06380023062229156}, {"wallTime": 1733070726.0987086, "step": 3210, "value": 0.06016834080219269}, {"wallTime": 1733070734.7779603, "step": 3220, "value": 0.06624802201986313}, {"wallTime": 1733070744.41253, "step": 3230, "value": 0.0353652685880661}, {"wallTime": 1733070752.5017085, "step": 3240, "value": 0.052830297499895096}, {"wallTime": 1733070761.7212963, "step": 3250, "value": 0.03131602331995964}, {"wallTime": 1733070770.376713, "step": 3260, "value": 0.03405839577317238}, {"wallTime": 1733070779.7300599, "step": 3270, "value": 0.043233565986156464}, {"wallTime": 1733070793.6785908, "step": 3280, "value": 0.039324045181274414}, {"wallTime": 1733070801.900055, "step": 3290, "value": 0.030872410163283348}, {"wallTime": 1733070810.1611187, "step": 3300, "value": 0.036760516464710236}, {"wallTime": 1733070818.7266018, "step": 3310, "value": 0.047913771122694016}, {"wallTime": 1733070827.0080366, "step": 3320, "value": 0.054269615560770035}, {"wallTime": 1733070835.57557, "step": 3330, "value": 0.07780285179615021}, {"wallTime": 1733070843.975728, "step": 3340, "value": 0.04755527153611183}, {"wallTime": 1733070853.0919037, "step": 3350, "value": 0.06780138611793518}, {"wallTime": 1733070865.419617, "step": 3360, "value": 0.03796354681253433}, {"wallTime": 1733070873.6617348, "step": 3370, "value": 0.04463743790984154}, {"wallTime": 1733070883.336087, "step": 3380, "value": 0.03976299613714218}, {"wallTime": 1733070892.3770702, "step": 3390, "value": 0.042925309389829636}, {"wallTime": 1733070900.7224414, "step": 3400, "value": 0.06018586829304695}, {"wallTime": 1733070908.504288, "step": 3410, "value": 0.0350508876144886}, {"wallTime": 1733070916.6558585, "step": 3420, "value": 0.052252430468797684}, {"wallTime": 1733070925.2104928, "step": 3430, "value": 0.04300879314541817}, {"wallTime": 1733070933.8103685, "step": 3440, "value": 0.04485481232404709}, {"wallTime": 1733070947.4799035, "step": 3450, "value": 0.04180837795138359}, {"wallTime": 1733070956.1875684, "step": 3460, "value": 0.037592314183712006}, {"wallTime": 1733070964.2664232, "step": 3470, "value": 0.1287485510110855}, {"wallTime": 1733070972.3862414, "step": 3480, "value": 0.04686139523983002}, {"wallTime": 1733070980.647218, "step": 3490, "value": 0.053359344601631165}, {"wallTime": 1733070989.6878598, "step": 3500, "value": 0.04252663254737854}, {"wallTime": 1733070997.788814, "step": 3510, "value": 0.06594432145357132}, {"wallTime": 1733071006.2715547, "step": 3520, "value": 0.07789355516433716}, {"wallTime": 1733071018.896235, "step": 3530, "value": 0.052314046770334244}, {"wallTime": 1733071027.1973789, "step": 3540, "value": 0.027483288198709488}, {"wallTime": 1733071035.3207808, "step": 3550, "value": 0.057008370757102966}, {"wallTime": 1733071043.7459395, "step": 3560, "value": 0.04287131875753403}, {"wallTime": 1733071051.8723435, "step": 3570, "value": 0.05888967961072922}, {"wallTime": 1733071060.4963424, "step": 3580, "value": 0.051420215517282486}, {"wallTime": 1733071068.879671, "step": 3590, "value": 0.059036776423454285}, {"wallTime": 1733071077.713145, "step": 3600, "value": 0.048753924667835236}, {"wallTime": 1733071086.212639, "step": 3610, "value": 0.04573461413383484}, {"wallTime": 1733071101.6589954, "step": 3620, "value": 0.05257025733590126}, {"wallTime": 1733071109.6218178, "step": 3630, "value": 0.05796271562576294}, {"wallTime": 1733071118.129539, "step": 3640, "value": 0.04888874292373657}, {"wallTime": 1733071126.9934342, "step": 3650, "value": 0.042007215321063995}, {"wallTime": 1733071135.8277225, "step": 3660, "value": 0.0552411787211895}, {"wallTime": 1733071144.2486372, "step": 3670, "value": 0.04997531324625015}, {"wallTime": 1733071152.9647217, "step": 3680, "value": 0.0401388518512249}, {"wallTime": 1733071160.6037316, "step": 3690, "value": 0.046153128147125244}, {"wallTime": 1733071173.7505765, "step": 3700, "value": 0.04503431171178818}, {"wallTime": 1733071182.883545, "step": 3710, "value": 0.03653104603290558}, {"wallTime": 1733071191.2104106, "step": 3720, "value": 0.07492037117481232}, {"wallTime": 1733071200.3337226, "step": 3730, "value": 0.031119734048843384}, {"wallTime": 1733071208.3660135, "step": 3740, "value": 0.03141117841005325}, {"wallTime": 1733071216.5722113, "step": 3750, "value": 0.06506875902414322}, {"wallTime": 1733071224.6621878, "step": 3760, "value": 0.030246518552303314}, {"wallTime": 1733071232.8610642, "step": 3770, "value": 0.07662536203861237}, {"wallTime": 1733071248.533825, "step": 3780, "value": 0.03599076718091965}, {"wallTime": 1733071257.3920772, "step": 3790, "value": 0.043619927018880844}, {"wallTime": 1733071265.5676298, "step": 3800, "value": 0.040881577879190445}, {"wallTime": 1733071274.1984222, "step": 3810, "value": 0.043630316853523254}, {"wallTime": 1733071283.0182738, "step": 3820, "value": 0.04186239838600159}, {"wallTime": 1733071291.730125, "step": 3830, "value": 0.03734001889824867}, {"wallTime": 1733071299.8942869, "step": 3840, "value": 0.044511351734399796}, {"wallTime": 1733071308.479859, "step": 3850, "value": 0.05715324729681015}, {"wallTime": 1733071316.9519682, "step": 3860, "value": 0.053325310349464417}, {"wallTime": 1733071330.2156804, "step": 3870, "value": 0.054693400859832764}, {"wallTime": 1733071338.989374, "step": 3880, "value": 0.05384436249732971}, {"wallTime": 1733071347.7373073, "step": 3890, "value": 0.034316688776016235}, {"wallTime": 1733071357.0352254, "step": 3900, "value": 0.03874347731471062}, {"wallTime": 1733071365.2259896, "step": 3910, "value": 0.08053050935268402}, {"wallTime": 1733071374.1352482, "step": 3920, "value": 0.05921903997659683}, {"wallTime": 1733071382.8144639, "step": 3930, "value": 0.06225550174713135}, {"wallTime": 1733071391.569032, "step": 3940, "value": 0.03959310054779053}, {"wallTime": 1733071404.4679823, "step": 3950, "value": 0.034051068127155304}, {"wallTime": 1733071412.3395622, "step": 3960, "value": 0.03716205433011055}, {"wallTime": 1733071421.1582167, "step": 3970, "value": 0.05169527605175972}, {"wallTime": 1733071430.121244, "step": 3980, "value": 0.04062633588910103}, {"wallTime": 1733071438.4147348, "step": 3990, "value": 0.055367644876241684}, {"wallTime": 1733071447.7295704, "step": 4000, "value": 0.029546353965997696}, {"wallTime": 1733071456.1973083, "step": 4010, "value": 0.09413483738899231}, {"wallTime": 1733071464.7501996, "step": 4020, "value": 0.049980320036411285}, {"wallTime": 1733071473.3982732, "step": 4030, "value": 0.044584888964891434}, {"wallTime": 1733071490.2871299, "step": 4040, "value": 0.05345765873789787}, {"wallTime": 1733071498.7124631, "step": 4050, "value": 0.05205820873379707}, {"wallTime": 1733071507.098336, "step": 4060, "value": 0.036556173115968704}, {"wallTime": 1733071515.068589, "step": 4070, "value": 0.07559278607368469}, {"wallTime": 1733071523.8819716, "step": 4080, "value": 0.03594367951154709}, {"wallTime": 1733071532.2863941, "step": 4090, "value": 0.045067351311445236}, {"wallTime": 1733071540.918511, "step": 4100, "value": 0.03276074305176735}, {"wallTime": 1733071549.1771157, "step": 4110, "value": 0.034353453665971756}, {"wallTime": 1733071565.8370042, "step": 4120, "value": 0.032738927751779556}, {"wallTime": 1733071573.6327186, "step": 4130, "value": 0.037081778049468994}, {"wallTime": 1733071582.0972884, "step": 4140, "value": 0.058624446392059326}, {"wallTime": 1733071590.0238557, "step": 4150, "value": 0.05386669933795929}, {"wallTime": 1733071599.242187, "step": 4160, "value": 0.035778872668743134}, {"wallTime": 1733071608.0729837, "step": 4170, "value": 0.0451020821928978}, {"wallTime": 1733071616.1851296, "step": 4180, "value": 0.0853847861289978}, {"wallTime": 1733071626.084168, "step": 4190, "value": 0.033209629356861115}, {"wallTime": 1733071641.0095148, "step": 4200, "value": 0.04504713416099548}, {"wallTime": 1733071649.0421042, "step": 4210, "value": 0.05775716155767441}, {"wallTime": 1733071658.5328398, "step": 4220, "value": 0.05801798403263092}, {"wallTime": 1733071667.9674983, "step": 4230, "value": 0.03180678188800812}, {"wallTime": 1733071676.1102433, "step": 4240, "value": 0.03376055881381035}, {"wallTime": 1733071684.380049, "step": 4250, "value": 0.055620040744543076}, {"wallTime": 1733071693.1111352, "step": 4260, "value": 0.026865612715482712}, {"wallTime": 1733071702.1853912, "step": 4270, "value": 0.05828302353620529}, {"wallTime": 1733071710.6321666, "step": 4280, "value": 0.030129987746477127}, {"wallTime": 1733071726.67825, "step": 4290, "value": 0.04417121410369873}, {"wallTime": 1733071735.2170908, "step": 4300, "value": 0.05007529631257057}, {"wallTime": 1733071742.958588, "step": 4310, "value": 0.048373013734817505}, {"wallTime": 1733071751.587222, "step": 4320, "value": 0.03938344120979309}, {"wallTime": 1733071760.0364227, "step": 4330, "value": 0.034979771822690964}, {"wallTime": 1733071768.43285, "step": 4340, "value": 0.044273022562265396}, {"wallTime": 1733071777.4037375, "step": 4350, "value": 0.0582701712846756}, {"wallTime": 1733071785.5488565, "step": 4360, "value": 0.05802764743566513}, {"wallTime": 1733071800.8863463, "step": 4370, "value": 0.04917103052139282}, {"wallTime": 1733071809.2673728, "step": 4380, "value": 0.043395109474658966}, {"wallTime": 1733071817.347959, "step": 4390, "value": 0.08643131703138351}, {"wallTime": 1733071826.4319837, "step": 4400, "value": 0.05417945235967636}, {"wallTime": 1733071834.8891416, "step": 4410, "value": 0.05484456196427345}, {"wallTime": 1733071843.4484165, "step": 4420, "value": 0.0658448114991188}, {"wallTime": 1733071851.5975635, "step": 4430, "value": 0.039834342896938324}, {"wallTime": 1733071859.9257529, "step": 4440, "value": 0.03362269699573517}, {"wallTime": 1733071868.6747828, "step": 4450, "value": 0.05015140399336815}, {"wallTime": 1733071881.337693, "step": 4460, "value": 0.0374569445848465}, {"wallTime": 1733071889.638621, "step": 4470, "value": 0.049786586314439774}, {"wallTime": 1733071898.4223657, "step": 4480, "value": 0.03972277045249939}, {"wallTime": 1733071907.337557, "step": 4490, "value": 0.05429813265800476}, {"wallTime": 1733071916.2797399, "step": 4500, "value": 0.05334935337305069}, {"wallTime": 1733071925.350208, "step": 4510, "value": 0.052455008029937744}, {"wallTime": 1733071933.3309038, "step": 4520, "value": 0.07775411754846573}, {"wallTime": 1733071941.4841895, "step": 4530, "value": 0.04247744008898735}, {"wallTime": 1733071954.1704326, "step": 4540, "value": 0.03295600041747093}, {"wallTime": 1733071962.3972702, "step": 4550, "value": 0.0375448539853096}, {"wallTime": 1733071970.5148034, "step": 4560, "value": 0.05359538644552231}, {"wallTime": 1733071978.8713906, "step": 4570, "value": 0.03909936174750328}, {"wallTime": 1733071987.7119257, "step": 4580, "value": 0.07022043317556381}, {"wallTime": 1733071996.4463696, "step": 4590, "value": 0.06585456430912018}, {"wallTime": 1733072004.4773664, "step": 4600, "value": 0.02414361760020256}, {"wallTime": 1733072012.746158, "step": 4610, "value": 0.04329942166805267}, {"wallTime": 1733072025.401558, "step": 4620, "value": 0.05794433504343033}, {"wallTime": 1733072034.119594, "step": 4630, "value": 0.03105747513473034}, {"wallTime": 1733072043.0391147, "step": 4640, "value": 0.05032806098461151}, {"wallTime": 1733072051.7873495, "step": 4650, "value": 0.03880363702774048}, {"wallTime": 1733072060.1093628, "step": 4660, "value": 0.060025572776794434}, {"wallTime": 1733072068.604154, "step": 4670, "value": 0.060556262731552124}, {"wallTime": 1733072076.8375459, "step": 4680, "value": 0.051733385771512985}, {"wallTime": 1733072085.3769453, "step": 4690, "value": 0.03300132229924202}, {"wallTime": 1733072093.7494066, "step": 4700, "value": 0.04699302464723587}, {"wallTime": 1733072106.9905179, "step": 4710, "value": 0.05567583441734314}, {"wallTime": 1733072115.6660318, "step": 4720, "value": 0.06160765513777733}, {"wallTime": 1733072123.9514337, "step": 4730, "value": 0.06188620254397392}, {"wallTime": 1733072132.2814775, "step": 4740, "value": 0.042370375245809555}, {"wallTime": 1733072140.4214592, "step": 4750, "value": 0.0842360258102417}, {"wallTime": 1733072149.0879545, "step": 4760, "value": 0.03267592936754227}, {"wallTime": 1733072157.4126623, "step": 4770, "value": 0.04198705404996872}, {"wallTime": 1733072165.4901123, "step": 4780, "value": 0.06982690840959549}, {"wallTime": 1733072179.650476, "step": 4790, "value": 0.04334086552262306}, {"wallTime": 1733072188.330446, "step": 4800, "value": 0.03862236812710762}, {"wallTime": 1733072196.847808, "step": 4810, "value": 0.050253380089998245}, {"wallTime": 1733072204.5630724, "step": 4820, "value": 0.04667537286877632}, {"wallTime": 1733072213.1004176, "step": 4830, "value": 0.027130741626024246}, {"wallTime": 1733072221.6678774, "step": 4840, "value": 0.031266868114471436}, {"wallTime": 1733072229.894832, "step": 4850, "value": 0.03435835614800453}, {"wallTime": 1733072238.0570273, "step": 4860, "value": 0.047814302146434784}, {"wallTime": 1733072246.3443854, "step": 4870, "value": 0.033876243978738785}, {"wallTime": 1733072261.2681816, "step": 4880, "value": 0.04317868873476982}, {"wallTime": 1733072269.8535132, "step": 4890, "value": 0.047575123608112335}, {"wallTime": 1733072278.8811884, "step": 4900, "value": 0.044291622936725616}, {"wallTime": 1733072287.5353484, "step": 4910, "value": 0.037755031138658524}, {"wallTime": 1733072295.948159, "step": 4920, "value": 0.04369499161839485}, {"wallTime": 1733072304.3562577, "step": 4930, "value": 0.06433439254760742}, {"wallTime": 1733072313.5107863, "step": 4940, "value": 0.0382361002266407}, {"wallTime": 1733072321.326299, "step": 4950, "value": 0.042838290333747864}, {"wallTime": 1733072337.0259259, "step": 4960, "value": 0.03873289003968239}, {"wallTime": 1733072345.5335002, "step": 4970, "value": 0.03147200122475624}, {"wallTime": 1733072353.4307408, "step": 4980, "value": 0.030939418822526932}, {"wallTime": 1733072362.4142554, "step": 4990, "value": 0.05440615490078926}, {"wallTime": 1733072371.7469738, "step": 5000, "value": 0.06408660858869553}, {"wallTime": 1733072380.5306916, "step": 5010, "value": 0.0359092578291893}, {"wallTime": 1733072389.0274916, "step": 5020, "value": 0.0530218705534935}, {"wallTime": 1733072397.786589, "step": 5030, "value": 0.03745671361684799}, {"wallTime": 1733072411.2993817, "step": 5040, "value": 0.054669663310050964}, {"wallTime": 1733072419.4753642, "step": 5050, "value": 0.04505962133407593}, {"wallTime": 1733072428.373297, "step": 5060, "value": 0.05450321361422539}, {"wallTime": 1733072437.1178641, "step": 5070, "value": 0.06122177839279175}, {"wallTime": 1733072446.1762967, "step": 5080, "value": 0.06272446364164352}, {"wallTime": 1733072454.429678, "step": 5090, "value": 0.04863674193620682}, {"wallTime": 1733072462.411614, "step": 5100, "value": 0.054508764296770096}, {"wallTime": 1733072471.1515837, "step": 5110, "value": 0.035024113953113556}, {"wallTime": 1733072478.9477673, "step": 5120, "value": 0.03573727235198021}, {"wallTime": 1733072491.3227148, "step": 5130, "value": 0.05837124213576317}, {"wallTime": 1733072499.2598248, "step": 5140, "value": 0.030154533684253693}, {"wallTime": 1733072507.11314, "step": 5150, "value": 0.050565555691719055}, {"wallTime": 1733072515.3183455, "step": 5160, "value": 0.032366372644901276}, {"wallTime": 1733072523.517771, "step": 5170, "value": 0.036830879747867584}, {"wallTime": 1733072531.0883338, "step": 5180, "value": 0.03027668222784996}, {"wallTime": 1733072540.0241401, "step": 5190, "value": 0.03633786737918854}, {"wallTime": 1733072548.6543105, "step": 5200, "value": 0.03345851972699165}, {"wallTime": 1733072561.4174862, "step": 5210, "value": 0.0600714236497879}, {"wallTime": 1733072569.898524, "step": 5220, "value": 0.046901993453502655}, {"wallTime": 1733072578.6811464, "step": 5230, "value": 0.055194441229104996}, {"wallTime": 1733072586.9444275, "step": 5240, "value": 0.03833125904202461}, {"wallTime": 1733072595.0354364, "step": 5250, "value": 0.06228029727935791}, {"wallTime": 1733072603.1745574, "step": 5260, "value": 0.06055975332856178}, {"wallTime": 1733072611.0816967, "step": 5270, "value": 0.09245477616786957}, {"wallTime": 1733072619.9570649, "step": 5280, "value": 0.03537852689623833}, {"wallTime": 1733072628.6356356, "step": 5290, "value": 0.03280219808220863}, {"wallTime": 1733072641.376655, "step": 5300, "value": 0.032197143882513046}, {"wallTime": 1733072649.8595243, "step": 5310, "value": 0.04308951646089554}, {"wallTime": 1733072657.972379, "step": 5320, "value": 0.04773702472448349}, {"wallTime": 1733072667.0305657, "step": 5330, "value": 0.04697175323963165}, {"wallTime": 1733072675.9441366, "step": 5340, "value": 0.03217725828289986}, {"wallTime": 1733072684.2395017, "step": 5350, "value": 0.05061383545398712}, {"wallTime": 1733072691.8592231, "step": 5360, "value": 0.03590194135904312}, {"wallTime": 1733072700.149079, "step": 5370, "value": 0.04871849715709686}, {"wallTime": 1733072713.1841378, "step": 5380, "value": 0.0457635372877121}, {"wallTime": 1733072721.0257974, "step": 5390, "value": 0.03966302424669266}, {"wallTime": 1733072729.8780272, "step": 5400, "value": 0.05031570419669151}, {"wallTime": 1733072738.3717296, "step": 5410, "value": 0.046494171023368835}, {"wallTime": 1733072746.383773, "step": 5420, "value": 0.036668866872787476}, {"wallTime": 1733072754.6187167, "step": 5430, "value": 0.040728192776441574}, {"wallTime": 1733072762.549136, "step": 5440, "value": 0.04671891778707504}, {"wallTime": 1733072771.36171, "step": 5450, "value": 0.04196387156844139}, {"wallTime": 1733072787.1528137, "step": 5460, "value": 0.05090261250734329}, {"wallTime": 1733072795.8039243, "step": 5470, "value": 0.06019115075469017}, {"wallTime": 1733072804.243136, "step": 5480, "value": 0.031200934201478958}, {"wallTime": 1733072812.3741705, "step": 5490, "value": 0.0399412140250206}, {"wallTime": 1733072821.1602917, "step": 5500, "value": 0.03725290298461914}, {"wallTime": 1733072830.0237217, "step": 5510, "value": 0.04374457523226738}, {"wallTime": 1733072838.6961746, "step": 5520, "value": 0.04130963236093521}, {"wallTime": 1733072846.90599, "step": 5530, "value": 0.03754749894142151}, {"wallTime": 1733072855.2484019, "step": 5540, "value": 0.050581153482198715}, {"wallTime": 1733072870.6464272, "step": 5550, "value": 0.05255034193396568}, {"wallTime": 1733072878.731384, "step": 5560, "value": 0.03962608426809311}, {"wallTime": 1733072886.6127489, "step": 5570, "value": 0.04991493746638298}, {"wallTime": 1733072895.0222466, "step": 5580, "value": 0.042505182325839996}, {"wallTime": 1733072903.403791, "step": 5590, "value": 0.03841392695903778}, {"wallTime": 1733072911.2108464, "step": 5600, "value": 0.03863111510872841}, {"wallTime": 1733072919.8407896, "step": 5610, "value": 0.03534684330224991}, {"wallTime": 1733072928.733956, "step": 5620, "value": 0.0456099733710289}, {"wallTime": 1733072941.704549, "step": 5630, "value": 0.05087759345769882}, {"wallTime": 1733072949.980976, "step": 5640, "value": 0.03823203593492508}, {"wallTime": 1733072958.7215035, "step": 5650, "value": 0.09081485867500305}, {"wallTime": 1733072966.8163457, "step": 5660, "value": 0.041724737733602524}, {"wallTime": 1733072974.963795, "step": 5670, "value": 0.03720315545797348}, {"wallTime": 1733072983.5628579, "step": 5680, "value": 0.05965914577245712}, {"wallTime": 1733072992.230185, "step": 5690, "value": 0.03418632969260216}, {"wallTime": 1733073000.8180425, "step": 5700, "value": 0.02580936625599861}, {"wallTime": 1733073009.784116, "step": 5710, "value": 0.0623907707631588}, {"wallTime": 1733073022.869112, "step": 5720, "value": 0.051658567041158676}, {"wallTime": 1733073031.5361116, "step": 5730, "value": 0.03497990220785141}, {"wallTime": 1733073039.57251, "step": 5740, "value": 0.056417316198349}, {"wallTime": 1733073047.843786, "step": 5750, "value": 0.03944885730743408}, {"wallTime": 1733073056.1574047, "step": 5760, "value": 0.033584460616111755}, {"wallTime": 1733073064.9559693, "step": 5770, "value": 0.05578797683119774}, {"wallTime": 1733073073.838574, "step": 5780, "value": 0.05477290228009224}, {"wallTime": 1733073082.7259395, "step": 5790, "value": 0.037425071001052856}, {"wallTime": 1733073095.103915, "step": 5800, "value": 0.05501928925514221}, {"wallTime": 1733073103.3167107, "step": 5810, "value": 0.035686228424310684}, {"wallTime": 1733073111.9715607, "step": 5820, "value": 0.03146221488714218}, {"wallTime": 1733073120.3577454, "step": 5830, "value": 0.04675427824258804}, {"wallTime": 1733073128.2101612, "step": 5840, "value": 0.046065159142017365}, {"wallTime": 1733073136.7166338, "step": 5850, "value": 0.03773016482591629}, {"wallTime": 1733073144.928767, "step": 5860, "value": 0.06810638308525085}, {"wallTime": 1733073153.0428574, "step": 5870, "value": 0.04418807476758957}, {"wallTime": 1733073166.0040402, "step": 5880, "value": 0.0472957119345665}, {"wallTime": 1733073174.6600084, "step": 5890, "value": 0.04022824019193649}, {"wallTime": 1733073182.509259, "step": 5900, "value": 0.06385376304388046}, {"wallTime": 1733073191.560492, "step": 5910, "value": 0.027911100536584854}, {"wallTime": 1733073199.4131575, "step": 5920, "value": 0.05634745955467224}, {"wallTime": 1733073207.4664922, "step": 5930, "value": 0.03367091715335846}, {"wallTime": 1733073215.6038818, "step": 5940, "value": 0.03818390518426895}, {"wallTime": 1733073224.3591802, "step": 5950, "value": 0.033447153866291046}, {"wallTime": 1733073232.878435, "step": 5960, "value": 0.04865220934152603}, {"wallTime": 1733073245.3748686, "step": 5970, "value": 0.05369013175368309}, {"wallTime": 1733073253.1805713, "step": 5980, "value": 0.04740988463163376}, {"wallTime": 1733073261.8016388, "step": 5990, "value": 0.04169405996799469}, {"wallTime": 1733073270.06089, "step": 6000, "value": 0.046958401799201965}, {"wallTime": 1733073278.8973107, "step": 6010, "value": 0.048297055065631866}, {"wallTime": 1733073287.683321, "step": 6020, "value": 0.0563005767762661}, {"wallTime": 1733073297.2756824, "step": 6030, "value": 0.0458311066031456}, {"wallTime": 1733073305.9194694, "step": 6040, "value": 0.050135497003793716}, {"wallTime": 1733073322.355864, "step": 6050, "value": 0.04605952650308609}, {"wallTime": 1733073331.9785075, "step": 6060, "value": 0.04783770442008972}, {"wallTime": 1733073340.523418, "step": 6070, "value": 0.04198683053255081}, {"wallTime": 1733073349.6032202, "step": 6080, "value": 0.03772623836994171}, {"wallTime": 1733073359.072439, "step": 6090, "value": 0.05599146708846092}, {"wallTime": 1733073368.404201, "step": 6100, "value": 0.033705439418554306}, {"wallTime": 1733073377.6762354, "step": 6110, "value": 0.042922377586364746}, {"wallTime": 1733073386.4016395, "step": 6120, "value": 0.03999009355902672}, {"wallTime": 1733073395.4527311, "step": 6130, "value": 0.049433689564466476}, {"wallTime": 1733073408.1524553, "step": 6140, "value": 0.03128298744559288}, {"wallTime": 1733073417.3251412, "step": 6150, "value": 0.035998471081256866}, {"wallTime": 1733073426.258612, "step": 6160, "value": 0.04691120609641075}, {"wallTime": 1733073434.8105345, "step": 6170, "value": 0.05034269392490387}, {"wallTime": 1733073444.513898, "step": 6180, "value": 0.09016776084899902}, {"wallTime": 1733073453.1183453, "step": 6190, "value": 0.04235333204269409}, {"wallTime": 1733073462.566807, "step": 6200, "value": 0.0369691401720047}, {"wallTime": 1733073472.02575, "step": 6210, "value": 0.04942391440272331}, {"wallTime": 1733073484.4495428, "step": 6220, "value": 0.04480353742837906}, {"wallTime": 1733073493.6610768, "step": 6230, "value": 0.03348372504115105}, {"wallTime": 1733073502.4423428, "step": 6240, "value": 0.053662728518247604}, {"wallTime": 1733073511.2574892, "step": 6250, "value": 0.047843702137470245}, {"wallTime": 1733073520.510927, "step": 6260, "value": 0.03271402418613434}, {"wallTime": 1733073529.7825255, "step": 6270, "value": 0.04998847097158432}, {"wallTime": 1733073539.6402466, "step": 6280, "value": 0.04534345865249634}, {"wallTime": 1733073548.912086, "step": 6290, "value": 0.034999825060367584}, {"wallTime": 1733073560.6208324, "step": 6300, "value": 0.042603444308042526}, {"wallTime": 1733073570.0700998, "step": 6310, "value": 0.04604298993945122}, {"wallTime": 1733073579.4823024, "step": 6320, "value": 0.04901054874062538}, {"wallTime": 1733073587.6684217, "step": 6330, "value": 0.04412563890218735}, {"wallTime": 1733073597.2190285, "step": 6340, "value": 0.046829525381326675}, {"wallTime": 1733073606.2392373, "step": 6350, "value": 0.039543308317661285}, {"wallTime": 1733073615.0787966, "step": 6360, "value": 0.0409109927713871}, {"wallTime": 1733073624.835579, "step": 6370, "value": 0.0419473834335804}, {"wallTime": 1733073634.6736937, "step": 6380, "value": 0.053460195660591125}, {"wallTime": 1733073646.5293055, "step": 6390, "value": 0.04601272940635681}, {"wallTime": 1733073655.746592, "step": 6400, "value": 0.03902120515704155}, {"wallTime": 1733073665.60825, "step": 6410, "value": 0.03977802023291588}, {"wallTime": 1733073674.6438806, "step": 6420, "value": 0.03936979919672012}, {"wallTime": 1733073683.6714582, "step": 6430, "value": 0.04410361498594284}, {"wallTime": 1733073692.8778794, "step": 6440, "value": 0.04433169215917587}, {"wallTime": 1733073702.5202782, "step": 6450, "value": 0.043094683438539505}, {"wallTime": 1733073712.6284454, "step": 6460, "value": 0.041439179331064224}, {"wallTime": 1733073724.0486603, "step": 6470, "value": 0.03312480077147484}, {"wallTime": 1733073732.8295276, "step": 6480, "value": 0.05429983511567116}, {"wallTime": 1733073741.95868, "step": 6490, "value": 0.04942116141319275}, {"wallTime": 1733073750.718771, "step": 6500, "value": 0.07970011234283447}, {"wallTime": 1733073760.4892232, "step": 6510, "value": 0.04576554894447327}, {"wallTime": 1733073769.8644845, "step": 6520, "value": 0.036488182842731476}, {"wallTime": 1733073779.128169, "step": 6530, "value": 0.04365145415067673}, {"wallTime": 1733073789.4788184, "step": 6540, "value": 0.048936303704977036}, {"wallTime": 1733073798.1044705, "step": 6550, "value": 0.04271876439452171}, {"wallTime": 1733073810.5540323, "step": 6560, "value": 0.06576888263225555}, {"wallTime": 1733073820.0375679, "step": 6570, "value": 0.06607891619205475}, {"wallTime": 1733073828.2397542, "step": 6580, "value": 0.04180338233709335}, {"wallTime": 1733073836.7993753, "step": 6590, "value": 0.033733759075403214}, {"wallTime": 1733073845.9886765, "step": 6600, "value": 0.04345068708062172}, {"wallTime": 1733073855.2532773, "step": 6610, "value": 0.04051320254802704}, {"wallTime": 1733073864.6948612, "step": 6620, "value": 0.03710845112800598}, {"wallTime": 1733073873.835797, "step": 6630, "value": 0.03395942598581314}, {"wallTime": 1733073887.5258029, "step": 6640, "value": 0.04802902787923813}, {"wallTime": 1733073897.3354433, "step": 6650, "value": 0.0495663657784462}, {"wallTime": 1733073906.878012, "step": 6660, "value": 0.0653822049498558}, {"wallTime": 1733073916.3514707, "step": 6670, "value": 0.04891890659928322}, {"wallTime": 1733073925.620068, "step": 6680, "value": 0.03647758439183235}, {"wallTime": 1733073934.918102, "step": 6690, "value": 0.04548206925392151}, {"wallTime": 1733073943.7436996, "step": 6700, "value": 0.07150730490684509}, {"wallTime": 1733073952.478389, "step": 6710, "value": 0.061967357993125916}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15010" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_1%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_1", "runToSeries": {".": [{"wallTime": 1733067631.540014, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.653378, "step": 10, "value": 0.053541168570518494}, {"wallTime": 1733067660.78543, "step": 20, "value": 0.04559643566608429}, {"wallTime": 1733067674.1386852, "step": 30, "value": 0.051519326865673065}, {"wallTime": 1733067687.0583477, "step": 40, "value": 0.06632667779922485}, {"wallTime": 1733067699.4943852, "step": 50, "value": 0.10192472487688065}, {"wallTime": 1733067710.6305556, "step": 60, "value": 0.08878007531166077}, {"wallTime": 1733067722.756751, "step": 70, "value": 0.03498575836420059}, {"wallTime": 1733067733.7265832, "step": 80, "value": 0.12414583563804626}, {"wallTime": 1733067750.9474463, "step": 90, "value": 0.04256339743733406}, {"wallTime": 1733067761.9821348, "step": 100, "value": 0.06260912120342255}, {"wallTime": 1733067771.607588, "step": 110, "value": 0.06941517442464828}, {"wallTime": 1733067780.5485752, "step": 120, "value": 0.12404966354370117}, {"wallTime": 1733067790.4865744, "step": 130, "value": 0.051098890602588654}, {"wallTime": 1733067799.106811, "step": 140, "value": 0.0875052884221077}, {"wallTime": 1733067809.4459944, "step": 150, "value": 0.13814213871955872}, {"wallTime": 1733067818.921904, "step": 160, "value": 0.0624811127781868}, {"wallTime": 1733067836.6507525, "step": 170, "value": 0.06497866660356522}, {"wallTime": 1733067846.3917537, "step": 180, "value": 0.07875003665685654}, {"wallTime": 1733067855.6681795, "step": 190, "value": 0.07566949725151062}, {"wallTime": 1733067864.8918295, "step": 200, "value": 0.07926908135414124}, {"wallTime": 1733067874.0031064, "step": 210, "value": 0.0635388195514679}, {"wallTime": 1733067883.788058, "step": 220, "value": 0.06297994405031204}, {"wallTime": 1733067892.1243484, "step": 230, "value": 0.056320350617170334}, {"wallTime": 1733067901.07054, "step": 240, "value": 0.10050998628139496}, {"wallTime": 1733067910.0761003, "step": 250, "value": 0.08336968719959259}, {"wallTime": 1733067925.9512107, "step": 260, "value": 0.06316147744655609}, {"wallTime": 1733067935.4767375, "step": 270, "value": 0.051284998655319214}, {"wallTime": 1733067944.0175033, "step": 280, "value": 0.05375763401389122}, {"wallTime": 1733067952.5486016, "step": 290, "value": 0.12300579249858856}, {"wallTime": 1733067961.027922, "step": 300, "value": 0.10968101024627686}, {"wallTime": 1733067970.135749, "step": 310, "value": 0.08877184987068176}, {"wallTime": 1733067980.2270021, "step": 320, "value": 0.06054379791021347}, {"wallTime": 1733067988.8172386, "step": 330, "value": 0.0690186470746994}, {"wallTime": 1733068005.0918403, "step": 340, "value": 0.0641002207994461}, {"wallTime": 1733068014.066374, "step": 350, "value": 0.029526323080062866}, {"wallTime": 1733068022.5542192, "step": 360, "value": 0.061068128794431686}, {"wallTime": 1733068031.8259022, "step": 370, "value": 0.06614029407501221}, {"wallTime": 1733068040.7890227, "step": 380, "value": 0.054667290300130844}, {"wallTime": 1733068050.1614878, "step": 390, "value": 0.10228799283504486}, {"wallTime": 1733068059.1273136, "step": 400, "value": 0.11305592209100723}, {"wallTime": 1733068068.0913212, "step": 410, "value": 0.11408188939094543}, {"wallTime": 1733068084.8455572, "step": 420, "value": 0.08298514783382416}, {"wallTime": 1733068094.66792, "step": 430, "value": 0.045578666031360626}, {"wallTime": 1733068103.7093835, "step": 440, "value": 0.055246949195861816}, {"wallTime": 1733068112.7009509, "step": 450, "value": 0.05942348390817642}, {"wallTime": 1733068121.502496, "step": 460, "value": 0.048178765922784805}, {"wallTime": 1733068130.7291954, "step": 470, "value": 0.07366792857646942}, {"wallTime": 1733068139.8571491, "step": 480, "value": 0.06255096942186356}, {"wallTime": 1733068149.371481, "step": 490, "value": 0.07493708282709122}, {"wallTime": 1733068158.0714886, "step": 500, "value": 0.06973613798618317}, {"wallTime": 1733068174.116685, "step": 510, "value": 0.08884578943252563}, {"wallTime": 1733068182.7211075, "step": 520, "value": 0.04843512177467346}, {"wallTime": 1733068192.41518, "step": 530, "value": 0.08327015489339828}, {"wallTime": 1733068201.8319697, "step": 540, "value": 0.07474878430366516}, {"wallTime": 1733068210.6560671, "step": 550, "value": 0.07501699775457382}, {"wallTime": 1733068220.1966317, "step": 560, "value": 0.07493440806865692}, {"wallTime": 1733068229.161028, "step": 570, "value": 0.08355051279067993}, {"wallTime": 1733068238.5931785, "step": 580, "value": 0.07100454717874527}, {"wallTime": 1733068256.0760999, "step": 590, "value": 0.05371371656656265}, {"wallTime": 1733068265.4334774, "step": 600, "value": 0.12537822127342224}, {"wallTime": 1733068274.658085, "step": 610, "value": 0.05493384599685669}, {"wallTime": 1733068283.7716713, "step": 620, "value": 0.05983206629753113}, {"wallTime": 1733068293.3357575, "step": 630, "value": 0.06130652502179146}, {"wallTime": 1733068302.648777, "step": 640, "value": 0.07500769942998886}, {"wallTime": 1733068311.3898096, "step": 650, "value": 0.05810488760471344}, {"wallTime": 1733068320.391806, "step": 660, "value": 0.07257251441478729}, {"wallTime": 1733068328.7330723, "step": 670, "value": 0.07212720066308975}, {"wallTime": 1733068344.4628148, "step": 680, "value": 0.08227819204330444}, {"wallTime": 1733068353.718595, "step": 690, "value": 0.05121566355228424}, {"wallTime": 1733068362.059529, "step": 700, "value": 0.08322256803512573}, {"wallTime": 1733068371.105759, "step": 710, "value": 0.04627663269639015}, {"wallTime": 1733068380.5348473, "step": 720, "value": 0.08173968642950058}, {"wallTime": 1733068390.0883355, "step": 730, "value": 0.043715257197618484}, {"wallTime": 1733068398.7226977, "step": 740, "value": 0.08834642171859741}, {"wallTime": 1733068407.1256776, "step": 750, "value": 0.060701701790094376}, {"wallTime": 1733068423.0738928, "step": 760, "value": 0.0636763945221901}, {"wallTime": 1733068431.407066, "step": 770, "value": 0.07788314670324326}, {"wallTime": 1733068440.426707, "step": 780, "value": 0.044716477394104004}, {"wallTime": 1733068449.0083516, "step": 790, "value": 0.060530152171850204}, {"wallTime": 1733068457.6403391, "step": 800, "value": 0.04168550670146942}, {"wallTime": 1733068467.048968, "step": 810, "value": 0.059458136558532715}, {"wallTime": 1733068475.6222317, "step": 820, "value": 0.06062505766749382}, {"wallTime": 1733068484.980789, "step": 830, "value": 0.04829865321516991}, {"wallTime": 1733068500.7334416, "step": 840, "value": 0.044533874839544296}, {"wallTime": 1733068509.3096669, "step": 850, "value": 0.04623439908027649}, {"wallTime": 1733068519.0241098, "step": 860, "value": 0.0363510325551033}, {"wallTime": 1733068527.500448, "step": 870, "value": 0.065402090549469}, {"wallTime": 1733068536.9222183, "step": 880, "value": 0.057506635785102844}, {"wallTime": 1733068544.910741, "step": 890, "value": 0.05361690744757652}, {"wallTime": 1733068553.5811064, "step": 900, "value": 0.061976127326488495}, {"wallTime": 1733068562.6879597, "step": 910, "value": 0.072276771068573}, {"wallTime": 1733068571.2483356, "step": 920, "value": 0.05365122854709625}, {"wallTime": 1733068584.7784686, "step": 930, "value": 0.0413641631603241}, {"wallTime": 1733068593.7753158, "step": 940, "value": 0.062349043786525726}, {"wallTime": 1733068602.768998, "step": 950, "value": 0.030516797676682472}, {"wallTime": 1733068611.0430095, "step": 960, "value": 0.06738179922103882}, {"wallTime": 1733068620.2297125, "step": 970, "value": 0.054416149854660034}, {"wallTime": 1733068628.8448648, "step": 980, "value": 0.050072722136974335}, {"wallTime": 1733068637.633575, "step": 990, "value": 0.03873887658119202}, {"wallTime": 1733068646.6762185, "step": 1000, "value": 0.06893037259578705}, {"wallTime": 1733068662.7601147, "step": 1010, "value": 0.05922389775514603}, {"wallTime": 1733068672.0577106, "step": 1020, "value": 0.05125865712761879}, {"wallTime": 1733068680.5663252, "step": 1030, "value": 0.06886455416679382}, {"wallTime": 1733068690.1892734, "step": 1040, "value": 0.04059707373380661}, {"wallTime": 1733068698.8516748, "step": 1050, "value": 0.06368553638458252}, {"wallTime": 1733068707.7468271, "step": 1060, "value": 0.046524256467819214}, {"wallTime": 1733068717.3480208, "step": 1070, "value": 0.04574154317378998}, {"wallTime": 1733068726.3647583, "step": 1080, "value": 0.03430016711354256}, {"wallTime": 1733068735.2551558, "step": 1090, "value": 0.04582289978861809}, {"wallTime": 1733068749.551375, "step": 1100, "value": 0.0337645523250103}, {"wallTime": 1733068758.3787427, "step": 1110, "value": 0.05678042769432068}, {"wallTime": 1733068767.0072327, "step": 1120, "value": 0.0649658665060997}, {"wallTime": 1733068776.6222365, "step": 1130, "value": 0.051735904067754745}, {"wallTime": 1733068785.4047313, "step": 1140, "value": 0.06866706907749176}, {"wallTime": 1733068794.282475, "step": 1150, "value": 0.07153554260730743}, {"wallTime": 1733068802.7007296, "step": 1160, "value": 0.0759134292602539}, {"wallTime": 1733068811.5552614, "step": 1170, "value": 0.05468544363975525}, {"wallTime": 1733068824.9691553, "step": 1180, "value": 0.052350662648677826}, {"wallTime": 1733068834.3806326, "step": 1190, "value": 0.04594491794705391}, {"wallTime": 1733068843.5195644, "step": 1200, "value": 0.053641628473997116}, {"wallTime": 1733068852.2319515, "step": 1210, "value": 0.041145600378513336}, {"wallTime": 1733068861.1203272, "step": 1220, "value": 0.044137682765722275}, {"wallTime": 1733068870.0592687, "step": 1230, "value": 0.06723280251026154}, {"wallTime": 1733068878.7237668, "step": 1240, "value": 0.0659029483795166}, {"wallTime": 1733068887.741514, "step": 1250, "value": 0.04070298373699188}, {"wallTime": 1733068903.1702213, "step": 1260, "value": 0.03726322203874588}, {"wallTime": 1733068912.4196823, "step": 1270, "value": 0.05746088922023773}, {"wallTime": 1733068921.4777825, "step": 1280, "value": 0.0688309296965599}, {"wallTime": 1733068929.7500143, "step": 1290, "value": 0.046684592962265015}, {"wallTime": 1733068939.504771, "step": 1300, "value": 0.04092445597052574}, {"wallTime": 1733068948.9313228, "step": 1310, "value": 0.03313031792640686}, {"wallTime": 1733068957.237837, "step": 1320, "value": 0.06092950329184532}, {"wallTime": 1733068966.0803962, "step": 1330, "value": 0.05773887038230896}, {"wallTime": 1733068975.5686316, "step": 1340, "value": 0.06148428097367287}, {"wallTime": 1733068989.8027868, "step": 1350, "value": 0.03139578178524971}, {"wallTime": 1733068998.286351, "step": 1360, "value": 0.03174007311463356}, {"wallTime": 1733069007.1535454, "step": 1370, "value": 0.04123750701546669}, {"wallTime": 1733069015.9258387, "step": 1380, "value": 0.03889564052224159}, {"wallTime": 1733069025.3066163, "step": 1390, "value": 0.04721073433756828}, {"wallTime": 1733069034.4847968, "step": 1400, "value": 0.05640921741724014}, {"wallTime": 1733069042.7963336, "step": 1410, "value": 0.06392750889062881}, {"wallTime": 1733069052.140894, "step": 1420, "value": 0.046274106949567795}, {"wallTime": 1733069065.0050576, "step": 1430, "value": 0.04482070356607437}, {"wallTime": 1733069074.5273159, "step": 1440, "value": 0.048747140914201736}, {"wallTime": 1733069083.7859147, "step": 1450, "value": 0.050687938928604126}, {"wallTime": 1733069092.262078, "step": 1460, "value": 0.060432031750679016}, {"wallTime": 1733069101.033144, "step": 1470, "value": 0.05791248753666878}, {"wallTime": 1733069109.9091115, "step": 1480, "value": 0.06715649366378784}, {"wallTime": 1733069119.121107, "step": 1490, "value": 0.0468413345515728}, {"wallTime": 1733069128.4183984, "step": 1500, "value": 0.05455508455634117}, {"wallTime": 1733069137.6089492, "step": 1510, "value": 0.05973929166793823}, {"wallTime": 1733069150.5457842, "step": 1520, "value": 0.035208337008953094}, {"wallTime": 1733069159.759244, "step": 1530, "value": 0.04565948620438576}, {"wallTime": 1733069168.172776, "step": 1540, "value": 0.05670592188835144}, {"wallTime": 1733069176.8431623, "step": 1550, "value": 0.05644567683339119}, {"wallTime": 1733069185.894437, "step": 1560, "value": 0.034267742186784744}, {"wallTime": 1733069194.9263957, "step": 1570, "value": 0.06424276530742645}, {"wallTime": 1733069203.9161713, "step": 1580, "value": 0.033091701567173004}, {"wallTime": 1733069212.7183936, "step": 1590, "value": 0.03960218280553818}, {"wallTime": 1733069225.536314, "step": 1600, "value": 0.03908763825893402}, {"wallTime": 1733069235.466042, "step": 1610, "value": 0.04790588468313217}, {"wallTime": 1733069244.6324868, "step": 1620, "value": 0.04429955407977104}, {"wallTime": 1733069254.2958102, "step": 1630, "value": 0.05234125629067421}, {"wallTime": 1733069263.0075285, "step": 1640, "value": 0.049436770379543304}, {"wallTime": 1733069271.868835, "step": 1650, "value": 0.05379120260477066}, {"wallTime": 1733069280.5120473, "step": 1660, "value": 0.10408404469490051}, {"wallTime": 1733069289.681922, "step": 1670, "value": 0.04360365867614746}, {"wallTime": 1733069303.612726, "step": 1680, "value": 0.06324564665555954}, {"wallTime": 1733069312.4818537, "step": 1690, "value": 0.042827166616916656}, {"wallTime": 1733069321.8409812, "step": 1700, "value": 0.04550737887620926}, {"wallTime": 1733069330.3501525, "step": 1710, "value": 0.04840901494026184}, {"wallTime": 1733069339.2476075, "step": 1720, "value": 0.038580913096666336}, {"wallTime": 1733069346.8607464, "step": 1730, "value": 0.08059852570295334}, {"wallTime": 1733069355.6564677, "step": 1740, "value": 0.03601042926311493}, {"wallTime": 1733069364.5142376, "step": 1750, "value": 0.06911173462867737}, {"wallTime": 1733069373.74085, "step": 1760, "value": 0.08990289270877838}, {"wallTime": 1733069387.5432897, "step": 1770, "value": 0.051007214933633804}, {"wallTime": 1733069396.4706647, "step": 1780, "value": 0.06785250455141068}, {"wallTime": 1733069405.9984143, "step": 1790, "value": 0.05272463336586952}, {"wallTime": 1733069415.0559976, "step": 1800, "value": 0.045866064727306366}, {"wallTime": 1733069423.9096162, "step": 1810, "value": 0.04312898963689804}, {"wallTime": 1733069432.533347, "step": 1820, "value": 0.054034288972616196}, {"wallTime": 1733069441.2210517, "step": 1830, "value": 0.04158099740743637}, {"wallTime": 1733069450.0917182, "step": 1840, "value": 0.03568604215979576}, {"wallTime": 1733069463.1090949, "step": 1850, "value": 0.038030438125133514}, {"wallTime": 1733069471.5747962, "step": 1860, "value": 0.033967915922403336}, {"wallTime": 1733069480.499993, "step": 1870, "value": 0.07467249035835266}, {"wallTime": 1733069489.386702, "step": 1880, "value": 0.048685625195503235}, {"wallTime": 1733069497.9784923, "step": 1890, "value": 0.057690948247909546}, {"wallTime": 1733069506.7960298, "step": 1900, "value": 0.03484579920768738}, {"wallTime": 1733069515.8263772, "step": 1910, "value": 0.052949097007513046}, {"wallTime": 1733069524.638243, "step": 1920, "value": 0.03955704718828201}, {"wallTime": 1733069533.5439394, "step": 1930, "value": 0.061022959649562836}, {"wallTime": 1733069550.47967, "step": 1940, "value": 0.024661876261234283}, {"wallTime": 1733069558.8297887, "step": 1950, "value": 0.061709776520729065}, {"wallTime": 1733069567.7596188, "step": 1960, "value": 0.04216614365577698}, {"wallTime": 1733069576.3469236, "step": 1970, "value": 0.05336519703269005}, {"wallTime": 1733069585.530846, "step": 1980, "value": 0.052627142518758774}, {"wallTime": 1733069594.3519688, "step": 1990, "value": 0.05141119658946991}, {"wallTime": 1733069602.4034004, "step": 2000, "value": 0.06144475191831589}, {"wallTime": 1733069610.251659, "step": 2010, "value": 0.05312858521938324}, {"wallTime": 1733069626.6885111, "step": 2020, "value": 0.050818342715501785}, {"wallTime": 1733069635.0325835, "step": 2030, "value": 0.03739243000745773}, {"wallTime": 1733069643.824289, "step": 2040, "value": 0.05524587631225586}, {"wallTime": 1733069652.1960714, "step": 2050, "value": 0.05990986153483391}, {"wallTime": 1733069660.4551437, "step": 2060, "value": 0.07902852445840836}, {"wallTime": 1733069669.5937357, "step": 2070, "value": 0.035178955644369125}, {"wallTime": 1733069678.7801092, "step": 2080, "value": 0.05437768995761871}, {"wallTime": 1733069686.946555, "step": 2090, "value": 0.052563492208719254}, {"wallTime": 1733069700.603799, "step": 2100, "value": 0.03854737803339958}, {"wallTime": 1733069708.7280023, "step": 2110, "value": 0.04065008834004402}, {"wallTime": 1733069717.4499338, "step": 2120, "value": 0.0488034226000309}, {"wallTime": 1733069726.1429224, "step": 2130, "value": 0.032637130469083786}, {"wallTime": 1733069735.0397325, "step": 2140, "value": 0.03243960440158844}, {"wallTime": 1733069743.3077455, "step": 2150, "value": 0.04339004307985306}, {"wallTime": 1733069752.5024617, "step": 2160, "value": 0.04295725375413895}, {"wallTime": 1733069761.452614, "step": 2170, "value": 0.0367109589278698}, {"wallTime": 1733069770.434819, "step": 2180, "value": 0.05371711775660515}, {"wallTime": 1733069784.3654678, "step": 2190, "value": 0.044095929712057114}, {"wallTime": 1733069793.1241302, "step": 2200, "value": 0.035306524485349655}, {"wallTime": 1733069801.637802, "step": 2210, "value": 0.05630180984735489}, {"wallTime": 1733069810.6094878, "step": 2220, "value": 0.041123710572719574}, {"wallTime": 1733069819.3441327, "step": 2230, "value": 0.06497024744749069}, {"wallTime": 1733069827.3276358, "step": 2240, "value": 0.04870767891407013}, {"wallTime": 1733069835.8697412, "step": 2250, "value": 0.03677772358059883}, {"wallTime": 1733069844.2374928, "step": 2260, "value": 0.04786531627178192}, {"wallTime": 1733069856.7508562, "step": 2270, "value": 0.07125817984342575}, {"wallTime": 1733069865.259138, "step": 2280, "value": 0.06117131561040878}, {"wallTime": 1733069874.0074, "step": 2290, "value": 0.04323114454746246}, {"wallTime": 1733069881.7831795, "step": 2300, "value": 0.04874628409743309}, {"wallTime": 1733069890.4153154, "step": 2310, "value": 0.032474614679813385}, {"wallTime": 1733069898.8781266, "step": 2320, "value": 0.052032820880413055}, {"wallTime": 1733069908.3191795, "step": 2330, "value": 0.03888138011097908}, {"wallTime": 1733069917.4167063, "step": 2340, "value": 0.037985946983098984}, {"wallTime": 1733069925.8523254, "step": 2350, "value": 0.041882000863552094}, {"wallTime": 1733069938.705224, "step": 2360, "value": 0.07625968009233475}, {"wallTime": 1733069947.4276073, "step": 2370, "value": 0.03084903210401535}, {"wallTime": 1733069956.2091365, "step": 2380, "value": 0.045974865555763245}, {"wallTime": 1733069964.276251, "step": 2390, "value": 0.07768319547176361}, {"wallTime": 1733069973.327479, "step": 2400, "value": 0.03425604850053787}, {"wallTime": 1733069981.4335423, "step": 2410, "value": 0.02442326210439205}, {"wallTime": 1733069990.1411335, "step": 2420, "value": 0.0494275838136673}, {"wallTime": 1733069998.800044, "step": 2430, "value": 0.043049201369285583}, {"wallTime": 1733070012.4572167, "step": 2440, "value": 0.04231210798025131}, {"wallTime": 1733070021.6004164, "step": 2450, "value": 0.040034111589193344}, {"wallTime": 1733070030.19235, "step": 2460, "value": 0.03942875564098358}, {"wallTime": 1733070039.220681, "step": 2470, "value": 0.05339596047997475}, {"wallTime": 1733070048.2703044, "step": 2480, "value": 0.04489442706108093}, {"wallTime": 1733070056.1571298, "step": 2490, "value": 0.03658581152558327}, {"wallTime": 1733070064.4519987, "step": 2500, "value": 0.027341056615114212}, {"wallTime": 1733070072.553046, "step": 2510, "value": 0.06137356907129288}, {"wallTime": 1733070087.6583073, "step": 2520, "value": 0.0306262094527483}, {"wallTime": 1733070095.4430642, "step": 2530, "value": 0.027209028601646423}, {"wallTime": 1733070103.7702456, "step": 2540, "value": 0.05423513054847717}, {"wallTime": 1733070113.0507438, "step": 2550, "value": 0.04513236880302429}, {"wallTime": 1733070121.0391316, "step": 2560, "value": 0.05411464348435402}, {"wallTime": 1733070129.5863504, "step": 2570, "value": 0.04200588911771774}, {"wallTime": 1733070138.3621738, "step": 2580, "value": 0.04333008825778961}, {"wallTime": 1733070147.0886636, "step": 2590, "value": 0.04563980549573898}, {"wallTime": 1733070155.488253, "step": 2600, "value": 0.036708954721689224}, {"wallTime": 1733070172.5786655, "step": 2610, "value": 0.04788696765899658}, {"wallTime": 1733070181.2124956, "step": 2620, "value": 0.037207141518592834}, {"wallTime": 1733070189.6937628, "step": 2630, "value": 0.04796332120895386}, {"wallTime": 1733070198.4004638, "step": 2640, "value": 0.0534975528717041}, {"wallTime": 1733070206.7087965, "step": 2650, "value": 0.042319029569625854}, {"wallTime": 1733070215.6009748, "step": 2660, "value": 0.03586823493242264}, {"wallTime": 1733070224.3176086, "step": 2670, "value": 0.04680989310145378}, {"wallTime": 1733070233.5407367, "step": 2680, "value": 0.05111885070800781}, {"wallTime": 1733070246.7595406, "step": 2690, "value": 0.03377513587474823}, {"wallTime": 1733070256.0304983, "step": 2700, "value": 0.05907393619418144}, {"wallTime": 1733070264.9521103, "step": 2710, "value": 0.032098300755023956}, {"wallTime": 1733070273.828351, "step": 2720, "value": 0.047798678278923035}, {"wallTime": 1733070282.9604368, "step": 2730, "value": 0.041773226112127304}, {"wallTime": 1733070292.2792423, "step": 2740, "value": 0.0364018976688385}, {"wallTime": 1733070300.3381305, "step": 2750, "value": 0.05538292974233627}, {"wallTime": 1733070309.413536, "step": 2760, "value": 0.050514113157987595}, {"wallTime": 1733070317.532918, "step": 2770, "value": 0.047854915261268616}, {"wallTime": 1733070330.4375494, "step": 2780, "value": 0.04352029785513878}, {"wallTime": 1733070339.8247344, "step": 2790, "value": 0.04202362149953842}, {"wallTime": 1733070347.9959495, "step": 2800, "value": 0.035695791244506836}, {"wallTime": 1733070356.8952665, "step": 2810, "value": 0.04270254820585251}, {"wallTime": 1733070365.5783908, "step": 2820, "value": 0.034532152116298676}, {"wallTime": 1733070374.3950474, "step": 2830, "value": 0.0331198126077652}, {"wallTime": 1733070382.4283683, "step": 2840, "value": 0.053495969623327255}, {"wallTime": 1733070390.9427023, "step": 2850, "value": 0.030705733224749565}, {"wallTime": 1733070406.6800904, "step": 2860, "value": 0.06332828849554062}, {"wallTime": 1733070415.0916326, "step": 2870, "value": 0.05943676456809044}, {"wallTime": 1733070422.9214857, "step": 2880, "value": 0.03078535385429859}, {"wallTime": 1733070431.538759, "step": 2890, "value": 0.033827997744083405}, {"wallTime": 1733070439.9823718, "step": 2900, "value": 0.03694010153412819}, {"wallTime": 1733070448.0869365, "step": 2910, "value": 0.047889020293951035}, {"wallTime": 1733070457.4250686, "step": 2920, "value": 0.03403931483626366}, {"wallTime": 1733070466.7243059, "step": 2930, "value": 0.051806047558784485}, {"wallTime": 1733070479.3339896, "step": 2940, "value": 0.0446503609418869}, {"wallTime": 1733070488.7837636, "step": 2950, "value": 0.030282139778137207}, {"wallTime": 1733070497.2262225, "step": 2960, "value": 0.03310419246554375}, {"wallTime": 1733070505.6351826, "step": 2970, "value": 0.03261563554406166}, {"wallTime": 1733070513.355311, "step": 2980, "value": 0.060349445790052414}, {"wallTime": 1733070522.3186686, "step": 2990, "value": 0.038618575781583786}, {"wallTime": 1733070530.2140095, "step": 3000, "value": 0.05850205570459366}, {"wallTime": 1733070538.3013558, "step": 3010, "value": 0.031163979321718216}, {"wallTime": 1733070547.4018614, "step": 3020, "value": 0.045287493616342545}, {"wallTime": 1733070564.0522993, "step": 3030, "value": 0.03997516259551048}, {"wallTime": 1733070572.3710637, "step": 3040, "value": 0.03068787045776844}, {"wallTime": 1733070580.6724494, "step": 3050, "value": 0.05580030009150505}, {"wallTime": 1733070588.654547, "step": 3060, "value": 0.029468730092048645}, {"wallTime": 1733070597.422215, "step": 3070, "value": 0.03436223417520523}, {"wallTime": 1733070606.1387584, "step": 3080, "value": 0.06483890116214752}, {"wallTime": 1733070614.4411397, "step": 3090, "value": 0.061702486127614975}, {"wallTime": 1733070624.0015767, "step": 3100, "value": 0.029565677046775818}, {"wallTime": 1733070637.253384, "step": 3110, "value": 0.04846365004777908}, {"wallTime": 1733070645.6833577, "step": 3120, "value": 0.03213389217853546}, {"wallTime": 1733070654.2709346, "step": 3130, "value": 0.04667922109365463}, {"wallTime": 1733070663.3217423, "step": 3140, "value": 0.03949327766895294}, {"wallTime": 1733070671.1184015, "step": 3150, "value": 0.05891506001353264}, {"wallTime": 1733070679.7659428, "step": 3160, "value": 0.02771087735891342}, {"wallTime": 1733070687.8459165, "step": 3170, "value": 0.05639397352933884}, {"wallTime": 1733070695.8561556, "step": 3180, "value": 0.031171655282378197}, {"wallTime": 1733070704.6228747, "step": 3190, "value": 0.03523556888103485}, {"wallTime": 1733070717.109238, "step": 3200, "value": 0.04809640347957611}, {"wallTime": 1733070726.0990577, "step": 3210, "value": 0.047928448766469955}, {"wallTime": 1733070734.778514, "step": 3220, "value": 0.04823373258113861}, {"wallTime": 1733070744.4128978, "step": 3230, "value": 0.02868514508008957}, {"wallTime": 1733070752.5020456, "step": 3240, "value": 0.041949767619371414}, {"wallTime": 1733070761.7217495, "step": 3250, "value": 0.02760734036564827}, {"wallTime": 1733070770.3770652, "step": 3260, "value": 0.02705523371696472}, {"wallTime": 1733070779.7303767, "step": 3270, "value": 0.03569670766592026}, {"wallTime": 1733070793.6790068, "step": 3280, "value": 0.03478878736495972}, {"wallTime": 1733070801.900379, "step": 3290, "value": 0.028018968179821968}, {"wallTime": 1733070810.1614454, "step": 3300, "value": 0.02730725333094597}, {"wallTime": 1733070818.7269714, "step": 3310, "value": 0.039639152586460114}, {"wallTime": 1733070827.0085728, "step": 3320, "value": 0.044638585299253464}, {"wallTime": 1733070835.576134, "step": 3330, "value": 0.06508564949035645}, {"wallTime": 1733070843.9762957, "step": 3340, "value": 0.04058977961540222}, {"wallTime": 1733070853.0922837, "step": 3350, "value": 0.05755046010017395}, {"wallTime": 1733070865.4199839, "step": 3360, "value": 0.03337809070944786}, {"wallTime": 1733070873.6620564, "step": 3370, "value": 0.03611001744866371}, {"wallTime": 1733070883.3364162, "step": 3380, "value": 0.03483596444129944}, {"wallTime": 1733070892.3773873, "step": 3390, "value": 0.03596275672316551}, {"wallTime": 1733070900.7227812, "step": 3400, "value": 0.049387767910957336}, {"wallTime": 1733070908.5045962, "step": 3410, "value": 0.029815636575222015}, {"wallTime": 1733070916.656183, "step": 3420, "value": 0.044327810406684875}, {"wallTime": 1733070925.2111297, "step": 3430, "value": 0.03561246767640114}, {"wallTime": 1733070933.8107097, "step": 3440, "value": 0.038318295031785965}, {"wallTime": 1733070947.4802387, "step": 3450, "value": 0.03371346741914749}, {"wallTime": 1733070956.1879642, "step": 3460, "value": 0.03175675868988037}, {"wallTime": 1733070964.2667835, "step": 3470, "value": 0.09759926795959473}, {"wallTime": 1733070972.386563, "step": 3480, "value": 0.043130435049533844}, {"wallTime": 1733070980.6475444, "step": 3490, "value": 0.042597632855176926}, {"wallTime": 1733070989.6881917, "step": 3500, "value": 0.03513266146183014}, {"wallTime": 1733070997.7891486, "step": 3510, "value": 0.05467456206679344}, {"wallTime": 1733071006.2718885, "step": 3520, "value": 0.06346749514341354}, {"wallTime": 1733071018.8965986, "step": 3530, "value": 0.04251421242952347}, {"wallTime": 1733071027.197787, "step": 3540, "value": 0.023874588310718536}, {"wallTime": 1733071035.3211246, "step": 3550, "value": 0.05210607871413231}, {"wallTime": 1733071043.746269, "step": 3560, "value": 0.035155970603227615}, {"wallTime": 1733071051.872699, "step": 3570, "value": 0.04781283810734749}, {"wallTime": 1733071060.4966788, "step": 3580, "value": 0.04291246831417084}, {"wallTime": 1733071068.8800359, "step": 3590, "value": 0.04818626120686531}, {"wallTime": 1733071077.713464, "step": 3600, "value": 0.0413145087659359}, {"wallTime": 1733071086.2129874, "step": 3610, "value": 0.03813403099775314}, {"wallTime": 1733071101.659334, "step": 3620, "value": 0.04122326150536537}, {"wallTime": 1733071109.622375, "step": 3630, "value": 0.04773469641804695}, {"wallTime": 1733071118.1298807, "step": 3640, "value": 0.036210961639881134}, {"wallTime": 1733071126.993789, "step": 3650, "value": 0.03356906399130821}, {"wallTime": 1733071135.8280413, "step": 3660, "value": 0.04577714577317238}, {"wallTime": 1733071144.2490816, "step": 3670, "value": 0.038814976811409}, {"wallTime": 1733071152.9650593, "step": 3680, "value": 0.03506043180823326}, {"wallTime": 1733071160.6040697, "step": 3690, "value": 0.03525541350245476}, {"wallTime": 1733071173.7509525, "step": 3700, "value": 0.0379004031419754}, {"wallTime": 1733071182.8838723, "step": 3710, "value": 0.030649641528725624}, {"wallTime": 1733071191.2108107, "step": 3720, "value": 0.06138172000646591}, {"wallTime": 1733071200.3340497, "step": 3730, "value": 0.025238342583179474}, {"wallTime": 1733071208.3663538, "step": 3740, "value": 0.027442647144198418}, {"wallTime": 1733071216.5725548, "step": 3750, "value": 0.05533222854137421}, {"wallTime": 1733071224.66251, "step": 3760, "value": 0.026058537885546684}, {"wallTime": 1733071232.8613944, "step": 3770, "value": 0.05979260429739952}, {"wallTime": 1733071248.5341797, "step": 3780, "value": 0.028025051578879356}, {"wallTime": 1733071257.3923903, "step": 3790, "value": 0.03368978947401047}, {"wallTime": 1733071265.5679836, "step": 3800, "value": 0.03350166231393814}, {"wallTime": 1733071274.1987624, "step": 3810, "value": 0.035036493092775345}, {"wallTime": 1733071283.0185976, "step": 3820, "value": 0.03519510105252266}, {"wallTime": 1733071291.730446, "step": 3830, "value": 0.032171983271837234}, {"wallTime": 1733071299.894735, "step": 3840, "value": 0.03203268349170685}, {"wallTime": 1733071308.4802008, "step": 3850, "value": 0.04644492268562317}, {"wallTime": 1733071316.9523041, "step": 3860, "value": 0.039475444704294205}, {"wallTime": 1733071330.216035, "step": 3870, "value": 0.042906276881694794}, {"wallTime": 1733071338.9896963, "step": 3880, "value": 0.044091373682022095}, {"wallTime": 1733071347.7376363, "step": 3890, "value": 0.025909364223480225}, {"wallTime": 1733071357.035598, "step": 3900, "value": 0.033437538892030716}, {"wallTime": 1733071365.2263186, "step": 3910, "value": 0.06400129944086075}, {"wallTime": 1733071374.1355796, "step": 3920, "value": 0.04886908829212189}, {"wallTime": 1733071382.8148189, "step": 3930, "value": 0.051458071917295456}, {"wallTime": 1733071391.569355, "step": 3940, "value": 0.030602330341935158}, {"wallTime": 1733071404.4683504, "step": 3950, "value": 0.029050376266241074}, {"wallTime": 1733071412.3399084, "step": 3960, "value": 0.029620489105582237}, {"wallTime": 1733071421.158534, "step": 3970, "value": 0.04390336573123932}, {"wallTime": 1733071430.1215725, "step": 3980, "value": 0.034250762313604355}, {"wallTime": 1733071438.415068, "step": 3990, "value": 0.04994962364435196}, {"wallTime": 1733071447.7299173, "step": 4000, "value": 0.0250531192868948}, {"wallTime": 1733071456.197631, "step": 4010, "value": 0.075413279235363}, {"wallTime": 1733071464.750522, "step": 4020, "value": 0.03922828286886215}, {"wallTime": 1733071473.398717, "step": 4030, "value": 0.03636081516742706}, {"wallTime": 1733071490.2875295, "step": 4040, "value": 0.04083054140210152}, {"wallTime": 1733071498.712801, "step": 4050, "value": 0.0437861904501915}, {"wallTime": 1733071507.0986588, "step": 4060, "value": 0.030490046367049217}, {"wallTime": 1733071515.0689337, "step": 4070, "value": 0.06606892496347427}, {"wallTime": 1733071523.9079142, "step": 4080, "value": 0.029876351356506348}, {"wallTime": 1733071532.286754, "step": 4090, "value": 0.03664165362715721}, {"wallTime": 1733071540.918832, "step": 4100, "value": 0.026519259437918663}, {"wallTime": 1733071549.1774478, "step": 4110, "value": 0.02824680507183075}, {"wallTime": 1733071565.8373256, "step": 4120, "value": 0.02808545157313347}, {"wallTime": 1733071573.6330492, "step": 4130, "value": 0.032260023057460785}, {"wallTime": 1733071582.0976043, "step": 4140, "value": 0.04501288756728172}, {"wallTime": 1733071590.024182, "step": 4150, "value": 0.04253917932510376}, {"wallTime": 1733071599.2425196, "step": 4160, "value": 0.03274328634142876}, {"wallTime": 1733071608.0733168, "step": 4170, "value": 0.03635575994849205}, {"wallTime": 1733071616.1855779, "step": 4180, "value": 0.06645052134990692}, {"wallTime": 1733071626.0844953, "step": 4190, "value": 0.030534867197275162}, {"wallTime": 1733071641.0099494, "step": 4200, "value": 0.035435598343610764}, {"wallTime": 1733071649.0424342, "step": 4210, "value": 0.045109450817108154}, {"wallTime": 1733071658.5331848, "step": 4220, "value": 0.04250378906726837}, {"wallTime": 1733071667.9678483, "step": 4230, "value": 0.028081148862838745}, {"wallTime": 1733071676.1105635, "step": 4240, "value": 0.02684292383491993}, {"wallTime": 1733071684.3803797, "step": 4250, "value": 0.04768272489309311}, {"wallTime": 1733071693.1114547, "step": 4260, "value": 0.024275844916701317}, {"wallTime": 1733071702.185729, "step": 4270, "value": 0.04593631625175476}, {"wallTime": 1733071710.6325872, "step": 4280, "value": 0.02394629642367363}, {"wallTime": 1733071726.678618, "step": 4290, "value": 0.036815524101257324}, {"wallTime": 1733071735.21743, "step": 4300, "value": 0.039950743317604065}, {"wallTime": 1733071742.9589446, "step": 4310, "value": 0.03657236695289612}, {"wallTime": 1733071751.5875494, "step": 4320, "value": 0.03152866289019585}, {"wallTime": 1733071760.036814, "step": 4330, "value": 0.030868086963891983}, {"wallTime": 1733071768.4331858, "step": 4340, "value": 0.03304728865623474}, {"wallTime": 1733071777.4040732, "step": 4350, "value": 0.04448957368731499}, {"wallTime": 1733071785.5491843, "step": 4360, "value": 0.04278776794672012}, {"wallTime": 1733071800.8866677, "step": 4370, "value": 0.0404524952173233}, {"wallTime": 1733071809.267702, "step": 4380, "value": 0.032785553485155106}, {"wallTime": 1733071817.348275, "step": 4390, "value": 0.07086293399333954}, {"wallTime": 1733071826.4323113, "step": 4400, "value": 0.04574327915906906}, {"wallTime": 1733071834.889473, "step": 4410, "value": 0.04666189104318619}, {"wallTime": 1733071843.4487553, "step": 4420, "value": 0.05354524031281471}, {"wallTime": 1733071851.597919, "step": 4430, "value": 0.033728983253240585}, {"wallTime": 1733071859.9260864, "step": 4440, "value": 0.028538668528199196}, {"wallTime": 1733071868.675122, "step": 4450, "value": 0.042122676968574524}, {"wallTime": 1733071881.3380718, "step": 4460, "value": 0.03407423943281174}, {"wallTime": 1733071889.6392808, "step": 4470, "value": 0.03575868532061577}, {"wallTime": 1733071898.4227173, "step": 4480, "value": 0.03376581147313118}, {"wallTime": 1733071907.3378959, "step": 4490, "value": 0.041676830500364304}, {"wallTime": 1733071916.2800925, "step": 4500, "value": 0.04524631053209305}, {"wallTime": 1733071925.3505414, "step": 4510, "value": 0.047065652906894684}, {"wallTime": 1733071933.3312402, "step": 4520, "value": 0.05445408821105957}, {"wallTime": 1733071941.484521, "step": 4530, "value": 0.03579552471637726}, {"wallTime": 1733071954.170833, "step": 4540, "value": 0.02725696563720703}, {"wallTime": 1733071962.3976374, "step": 4550, "value": 0.031845081597566605}, {"wallTime": 1733071970.5151362, "step": 4560, "value": 0.04351527988910675}, {"wallTime": 1733071978.8717382, "step": 4570, "value": 0.03155706822872162}, {"wallTime": 1733071987.712267, "step": 4580, "value": 0.05624553561210632}, {"wallTime": 1733071996.4467978, "step": 4590, "value": 0.052947960793972015}, {"wallTime": 1733072004.4776976, "step": 4600, "value": 0.020323246717453003}, {"wallTime": 1733072012.7464807, "step": 4610, "value": 0.033872999250888824}, {"wallTime": 1733072025.4019272, "step": 4620, "value": 0.043686315417289734}, {"wallTime": 1733072034.1199403, "step": 4630, "value": 0.02559458650648594}, {"wallTime": 1733072043.0394535, "step": 4640, "value": 0.040590014308691025}, {"wallTime": 1733072051.787918, "step": 4650, "value": 0.03150414675474167}, {"wallTime": 1733072060.1097043, "step": 4660, "value": 0.04837183281779289}, {"wallTime": 1733072068.604487, "step": 4670, "value": 0.05106823891401291}, {"wallTime": 1733072076.8378942, "step": 4680, "value": 0.041510652750730515}, {"wallTime": 1733072085.3772686, "step": 4690, "value": 0.028255492448806763}, {"wallTime": 1733072093.7497444, "step": 4700, "value": 0.040023479610681534}, {"wallTime": 1733072106.9909153, "step": 4710, "value": 0.04311538487672806}, {"wallTime": 1733072115.6663635, "step": 4720, "value": 0.054748114198446274}, {"wallTime": 1733072123.951767, "step": 4730, "value": 0.04941197484731674}, {"wallTime": 1733072132.281841, "step": 4740, "value": 0.032403964549303055}, {"wallTime": 1733072140.421831, "step": 4750, "value": 0.0651601254940033}, {"wallTime": 1733072149.0882812, "step": 4760, "value": 0.027802806347608566}, {"wallTime": 1733072157.4130008, "step": 4770, "value": 0.031408924609422684}, {"wallTime": 1733072165.4904323, "step": 4780, "value": 0.05732181668281555}, {"wallTime": 1733072179.651054, "step": 4790, "value": 0.03620890900492668}, {"wallTime": 1733072188.33077, "step": 4800, "value": 0.029011230915784836}, {"wallTime": 1733072196.8481393, "step": 4810, "value": 0.04214288294315338}, {"wallTime": 1733072204.5634038, "step": 4820, "value": 0.03721768409013748}, {"wallTime": 1733072213.1007633, "step": 4830, "value": 0.024250594899058342}, {"wallTime": 1733072221.6682284, "step": 4840, "value": 0.02657082863152027}, {"wallTime": 1733072229.8951883, "step": 4850, "value": 0.02690979279577732}, {"wallTime": 1733072238.0573533, "step": 4860, "value": 0.03941747546195984}, {"wallTime": 1733072246.3447464, "step": 4870, "value": 0.026274191215634346}, {"wallTime": 1733072261.2685432, "step": 4880, "value": 0.03582077473402023}, {"wallTime": 1733072269.8538866, "step": 4890, "value": 0.03937818855047226}, {"wallTime": 1733072278.8815234, "step": 4900, "value": 0.037483856081962585}, {"wallTime": 1733072287.5356758, "step": 4910, "value": 0.031438928097486496}, {"wallTime": 1733072295.948476, "step": 4920, "value": 0.03523731976747513}, {"wallTime": 1733072304.3565826, "step": 4930, "value": 0.04732199013233185}, {"wallTime": 1733072313.5111067, "step": 4940, "value": 0.031378746032714844}, {"wallTime": 1733072321.3266366, "step": 4950, "value": 0.03611625358462334}, {"wallTime": 1733072337.0263007, "step": 4960, "value": 0.03133043274283409}, {"wallTime": 1733072345.534062, "step": 4970, "value": 0.027136720716953278}, {"wallTime": 1733072353.4310865, "step": 4980, "value": 0.02607012540102005}, {"wallTime": 1733072362.4145684, "step": 4990, "value": 0.045502305030822754}, {"wallTime": 1733072371.7473056, "step": 5000, "value": 0.047115251421928406}, {"wallTime": 1733072380.5310156, "step": 5010, "value": 0.029633866623044014}, {"wallTime": 1733072389.0278754, "step": 5020, "value": 0.0421239398419857}, {"wallTime": 1733072397.7869406, "step": 5030, "value": 0.031139375641942024}, {"wallTime": 1733072411.2997167, "step": 5040, "value": 0.04197237640619278}, {"wallTime": 1733072419.4757073, "step": 5050, "value": 0.03984901309013367}, {"wallTime": 1733072428.3736103, "step": 5060, "value": 0.04722732678055763}, {"wallTime": 1733072437.118332, "step": 5070, "value": 0.04170205816626549}, {"wallTime": 1733072446.1766343, "step": 5080, "value": 0.05167439207434654}, {"wallTime": 1733072454.4300032, "step": 5090, "value": 0.03882528096437454}, {"wallTime": 1733072462.411977, "step": 5100, "value": 0.04469602555036545}, {"wallTime": 1733072471.1520514, "step": 5110, "value": 0.03036275878548622}, {"wallTime": 1733072478.9481263, "step": 5120, "value": 0.030634861439466476}, {"wallTime": 1733072491.3231192, "step": 5130, "value": 0.04650471732020378}, {"wallTime": 1733072499.2601585, "step": 5140, "value": 0.024857688695192337}, {"wallTime": 1733072507.1134737, "step": 5150, "value": 0.0418371744453907}, {"wallTime": 1733072515.3186927, "step": 5160, "value": 0.025130940601229668}, {"wallTime": 1733072523.5183601, "step": 5170, "value": 0.031095504760742188}, {"wallTime": 1733072531.08866, "step": 5180, "value": 0.0253278911113739}, {"wallTime": 1733072540.0247023, "step": 5190, "value": 0.030534587800502777}, {"wallTime": 1733072548.6548793, "step": 5200, "value": 0.02905968390405178}, {"wallTime": 1733072561.4180653, "step": 5210, "value": 0.04707593470811844}, {"wallTime": 1733072569.8991225, "step": 5220, "value": 0.036382969468832016}, {"wallTime": 1733072578.6817083, "step": 5230, "value": 0.04660242795944214}, {"wallTime": 1733072586.9450006, "step": 5240, "value": 0.03303447365760803}, {"wallTime": 1733072595.0357625, "step": 5250, "value": 0.047581374645233154}, {"wallTime": 1733072603.1748939, "step": 5260, "value": 0.04709833115339279}, {"wallTime": 1733072611.0821571, "step": 5270, "value": 0.0701727643609047}, {"wallTime": 1733072619.9575808, "step": 5280, "value": 0.02943401038646698}, {"wallTime": 1733072628.6359906, "step": 5290, "value": 0.02688484452664852}, {"wallTime": 1733072641.3769836, "step": 5300, "value": 0.02722378447651863}, {"wallTime": 1733072649.8599882, "step": 5310, "value": 0.03581027686595917}, {"wallTime": 1733072657.9727314, "step": 5320, "value": 0.03515671193599701}, {"wallTime": 1733072667.0308926, "step": 5330, "value": 0.03894899785518646}, {"wallTime": 1733072675.9444695, "step": 5340, "value": 0.026257047429680824}, {"wallTime": 1733072684.2398424, "step": 5350, "value": 0.04121512547135353}, {"wallTime": 1733072691.8595448, "step": 5360, "value": 0.029435086995363235}, {"wallTime": 1733072700.1494153, "step": 5370, "value": 0.03766106069087982}, {"wallTime": 1733072713.184532, "step": 5380, "value": 0.03702979162335396}, {"wallTime": 1733072721.0261347, "step": 5390, "value": 0.03233955055475235}, {"wallTime": 1733072729.8783572, "step": 5400, "value": 0.0421355739235878}, {"wallTime": 1733072738.3722796, "step": 5410, "value": 0.037624794989824295}, {"wallTime": 1733072746.3841085, "step": 5420, "value": 0.027845073491334915}, {"wallTime": 1733072754.6190624, "step": 5430, "value": 0.03455819934606552}, {"wallTime": 1733072762.5497203, "step": 5440, "value": 0.037822991609573364}, {"wallTime": 1733072771.362046, "step": 5450, "value": 0.033078379929065704}, {"wallTime": 1733072787.1531453, "step": 5460, "value": 0.03995247185230255}, {"wallTime": 1733072795.8042684, "step": 5470, "value": 0.045765943825244904}, {"wallTime": 1733072804.2434607, "step": 5480, "value": 0.02828783355653286}, {"wallTime": 1733072812.374488, "step": 5490, "value": 0.03182528167963028}, {"wallTime": 1733072821.1606293, "step": 5500, "value": 0.031504299491643906}, {"wallTime": 1733072830.0240505, "step": 5510, "value": 0.03660408407449722}, {"wallTime": 1733072838.6964922, "step": 5520, "value": 0.035946134477853775}, {"wallTime": 1733072846.9063134, "step": 5530, "value": 0.02972181886434555}, {"wallTime": 1733072855.2489667, "step": 5540, "value": 0.04637445881962776}, {"wallTime": 1733072870.6469905, "step": 5550, "value": 0.03555479645729065}, {"wallTime": 1733072878.7319465, "step": 5560, "value": 0.03404157608747482}, {"wallTime": 1733072886.6133063, "step": 5570, "value": 0.03937072679400444}, {"wallTime": 1733072895.0226033, "step": 5580, "value": 0.03535265102982521}, {"wallTime": 1733072903.4041324, "step": 5590, "value": 0.0295358058065176}, {"wallTime": 1733072911.211179, "step": 5600, "value": 0.031307004392147064}, {"wallTime": 1733072919.8411164, "step": 5610, "value": 0.027261434122920036}, {"wallTime": 1733072928.7342873, "step": 5620, "value": 0.037435147911310196}, {"wallTime": 1733072941.7049415, "step": 5630, "value": 0.03923701122403145}, {"wallTime": 1733072949.9813905, "step": 5640, "value": 0.03159463405609131}, {"wallTime": 1733072958.72207, "step": 5650, "value": 0.07236163318157196}, {"wallTime": 1733072966.8169267, "step": 5660, "value": 0.03316415846347809}, {"wallTime": 1733072974.9643595, "step": 5670, "value": 0.02895706333220005}, {"wallTime": 1733072983.5631917, "step": 5680, "value": 0.05144327133893967}, {"wallTime": 1733072992.230747, "step": 5690, "value": 0.029229503124952316}, {"wallTime": 1733073000.8184152, "step": 5700, "value": 0.020489506423473358}, {"wallTime": 1733073009.784442, "step": 5710, "value": 0.049627333879470825}, {"wallTime": 1733073022.8694425, "step": 5720, "value": 0.04661243036389351}, {"wallTime": 1733073031.536667, "step": 5730, "value": 0.027650047093629837}, {"wallTime": 1733073039.5730798, "step": 5740, "value": 0.04468071460723877}, {"wallTime": 1733073047.8441, "step": 5750, "value": 0.03136458992958069}, {"wallTime": 1733073056.1577508, "step": 5760, "value": 0.0292728953063488}, {"wallTime": 1733073064.9563162, "step": 5770, "value": 0.04464717581868172}, {"wallTime": 1733073073.838941, "step": 5780, "value": 0.041948240250349045}, {"wallTime": 1733073082.7262592, "step": 5790, "value": 0.028649836778640747}, {"wallTime": 1733073095.1043022, "step": 5800, "value": 0.046210382133722305}, {"wallTime": 1733073103.3170514, "step": 5810, "value": 0.02808074653148651}, {"wallTime": 1733073111.9718888, "step": 5820, "value": 0.02709341049194336}, {"wallTime": 1733073120.3583038, "step": 5830, "value": 0.03763970360159874}, {"wallTime": 1733073128.2104921, "step": 5840, "value": 0.037402812391519547}, {"wallTime": 1733073136.7169728, "step": 5850, "value": 0.028398921713232994}, {"wallTime": 1733073144.929099, "step": 5860, "value": 0.05490732192993164}, {"wallTime": 1733073153.043366, "step": 5870, "value": 0.03454383835196495}, {"wallTime": 1733073166.00441, "step": 5880, "value": 0.03493068739771843}, {"wallTime": 1733073174.6603563, "step": 5890, "value": 0.03411291539669037}, {"wallTime": 1733073182.5095994, "step": 5900, "value": 0.05093899369239807}, {"wallTime": 1733073191.560828, "step": 5910, "value": 0.02380516566336155}, {"wallTime": 1733073199.4137173, "step": 5920, "value": 0.04644604027271271}, {"wallTime": 1733073207.4668262, "step": 5930, "value": 0.02727724425494671}, {"wallTime": 1733073215.6042125, "step": 5940, "value": 0.032403238117694855}, {"wallTime": 1733073224.359514, "step": 5950, "value": 0.027018871158361435}, {"wallTime": 1733073232.87888, "step": 5960, "value": 0.0411805734038353}, {"wallTime": 1733073245.3752766, "step": 5970, "value": 0.043429844081401825}, {"wallTime": 1733073253.1809132, "step": 5980, "value": 0.038883309811353683}, {"wallTime": 1733073261.8022277, "step": 5990, "value": 0.03469216078519821}, {"wallTime": 1733073270.0612106, "step": 6000, "value": 0.03798215463757515}, {"wallTime": 1733073278.897767, "step": 6010, "value": 0.039804622530937195}, {"wallTime": 1733073287.6836405, "step": 6020, "value": 0.04209761321544647}, {"wallTime": 1733073297.2760217, "step": 6030, "value": 0.03898782283067703}, {"wallTime": 1733073305.9198098, "step": 6040, "value": 0.0392465703189373}, {"wallTime": 1733073322.3562434, "step": 6050, "value": 0.034837812185287476}, {"wallTime": 1733073331.9788477, "step": 6060, "value": 0.041898176074028015}, {"wallTime": 1733073340.5238073, "step": 6070, "value": 0.03412983939051628}, {"wallTime": 1733073349.6035426, "step": 6080, "value": 0.029118996113538742}, {"wallTime": 1733073359.0728, "step": 6090, "value": 0.04631555825471878}, {"wallTime": 1733073368.4045222, "step": 6100, "value": 0.02730187401175499}, {"wallTime": 1733073377.6765618, "step": 6110, "value": 0.03476935997605324}, {"wallTime": 1733073386.402038, "step": 6120, "value": 0.03134636953473091}, {"wallTime": 1733073395.453078, "step": 6130, "value": 0.03712014481425285}, {"wallTime": 1733073408.1528525, "step": 6140, "value": 0.02692745067179203}, {"wallTime": 1733073417.325471, "step": 6150, "value": 0.02926822379231453}, {"wallTime": 1733073426.2591972, "step": 6160, "value": 0.03974801301956177}, {"wallTime": 1733073434.8109004, "step": 6170, "value": 0.03720482438802719}, {"wallTime": 1733073444.514222, "step": 6180, "value": 0.06692998856306076}, {"wallTime": 1733073453.1189113, "step": 6190, "value": 0.03297027572989464}, {"wallTime": 1733073462.5671415, "step": 6200, "value": 0.031053761020302773}, {"wallTime": 1733073472.0260937, "step": 6210, "value": 0.038527779281139374}, {"wallTime": 1733073484.4498818, "step": 6220, "value": 0.03387589380145073}, {"wallTime": 1733073493.6613958, "step": 6230, "value": 0.02631254307925701}, {"wallTime": 1733073502.4427042, "step": 6240, "value": 0.04233108460903168}, {"wallTime": 1733073511.257876, "step": 6250, "value": 0.037321895360946655}, {"wallTime": 1733073520.511263, "step": 6260, "value": 0.02836514264345169}, {"wallTime": 1733073529.782886, "step": 6270, "value": 0.03857508674263954}, {"wallTime": 1733073539.640565, "step": 6280, "value": 0.033855635672807693}, {"wallTime": 1733073548.9124088, "step": 6290, "value": 0.029417799785733223}, {"wallTime": 1733073560.6212342, "step": 6300, "value": 0.031555626541376114}, {"wallTime": 1733073570.0704308, "step": 6310, "value": 0.037074074149131775}, {"wallTime": 1733073579.4826663, "step": 6320, "value": 0.036156944930553436}, {"wallTime": 1733073587.6687768, "step": 6330, "value": 0.03457669913768768}, {"wallTime": 1733073597.2193413, "step": 6340, "value": 0.03668585419654846}, {"wallTime": 1733073606.2395651, "step": 6350, "value": 0.03235633671283722}, {"wallTime": 1733073615.079133, "step": 6360, "value": 0.03571468964219093}, {"wallTime": 1733073624.8359177, "step": 6370, "value": 0.03213180974125862}, {"wallTime": 1733073634.6740284, "step": 6380, "value": 0.04225695878267288}, {"wallTime": 1733073646.5296888, "step": 6390, "value": 0.03232988715171814}, {"wallTime": 1733073655.7469378, "step": 6400, "value": 0.03359364718198776}, {"wallTime": 1733073665.608613, "step": 6410, "value": 0.03155890479683876}, {"wallTime": 1733073674.6442156, "step": 6420, "value": 0.030644331127405167}, {"wallTime": 1733073683.6717966, "step": 6430, "value": 0.03596512973308563}, {"wallTime": 1733073692.8782268, "step": 6440, "value": 0.03326060250401497}, {"wallTime": 1733073702.5206144, "step": 6450, "value": 0.032958682626485825}, {"wallTime": 1733073712.6287787, "step": 6460, "value": 0.031733669340610504}, {"wallTime": 1733073724.0490017, "step": 6470, "value": 0.026404011994600296}, {"wallTime": 1733073732.8298674, "step": 6480, "value": 0.04337668418884277}, {"wallTime": 1733073741.95917, "step": 6490, "value": 0.03938762843608856}, {"wallTime": 1733073750.7190917, "step": 6500, "value": 0.06231363117694855}, {"wallTime": 1733073760.4895356, "step": 6510, "value": 0.03725793957710266}, {"wallTime": 1733073769.864835, "step": 6520, "value": 0.031193161383271217}, {"wallTime": 1733073779.1285052, "step": 6530, "value": 0.034505825489759445}, {"wallTime": 1733073789.4791412, "step": 6540, "value": 0.0369747057557106}, {"wallTime": 1733073798.104831, "step": 6550, "value": 0.03547706454992294}, {"wallTime": 1733073810.554398, "step": 6560, "value": 0.0501437783241272}, {"wallTime": 1733073820.0379221, "step": 6570, "value": 0.0457523837685585}, {"wallTime": 1733073828.2401013, "step": 6580, "value": 0.032598502933979034}, {"wallTime": 1733073836.7997208, "step": 6590, "value": 0.028717905282974243}, {"wallTime": 1733073845.98901, "step": 6600, "value": 0.036593496799468994}, {"wallTime": 1733073855.25361, "step": 6610, "value": 0.03401169180870056}, {"wallTime": 1733073864.6951895, "step": 6620, "value": 0.03132976219058037}, {"wallTime": 1733073873.8361242, "step": 6630, "value": 0.028098229318857193}, {"wallTime": 1733073887.5262055, "step": 6640, "value": 0.03496481478214264}, {"wallTime": 1733073897.3357913, "step": 6650, "value": 0.03778436779975891}, {"wallTime": 1733073906.878341, "step": 6660, "value": 0.047601763159036636}, {"wallTime": 1733073916.3518057, "step": 6670, "value": 0.037749070674180984}, {"wallTime": 1733073925.6203856, "step": 6680, "value": 0.030711403116583824}, {"wallTime": 1733073934.9184387, "step": 6690, "value": 0.03484082967042923}, {"wallTime": 1733073943.7440534, "step": 6700, "value": 0.04894670471549034}, {"wallTime": 1733073952.4787295, "step": 6710, "value": 0.04661593213677406}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15018" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Lr/pg_1%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Lr/pg_1", "runToSeries": {".": [{"wallTime": 1733067631.5365763, "step": 0, "value": 9.999999974752427e-07}, {"wallTime": 1733067646.6496286, "step": 10, "value": 6.000000212225132e-06}, {"wallTime": 1733067660.7815785, "step": 20, "value": 1.1000000085914508e-05}, {"wallTime": 1733067674.134738, "step": 30, "value": 1.5999999959603883e-05}, {"wallTime": 1733067687.054418, "step": 40, "value": 2.099999983329326e-05}, {"wallTime": 1733067699.4903154, "step": 50, "value": 2.5999999706982635e-05}, {"wallTime": 1733067710.626599, "step": 60, "value": 3.099999958067201e-05}, {"wallTime": 1733067722.7528353, "step": 70, "value": 3.600000127335079e-05}, {"wallTime": 1733067733.7227175, "step": 80, "value": 4.099999932805076e-05}, {"wallTime": 1733067750.9442036, "step": 90, "value": 4.600000102072954e-05}, {"wallTime": 1733067761.9780962, "step": 100, "value": 5.0999999075429514e-05}, {"wallTime": 1733067771.6035137, "step": 110, "value": 5.6000000768108293e-05}, {"wallTime": 1733067780.5444016, "step": 120, "value": 6.0999998822808266e-05}, {"wallTime": 1733067790.4824226, "step": 130, "value": 6.600000051548705e-05}, {"wallTime": 1733067799.1027906, "step": 140, "value": 7.100000220816582e-05}, {"wallTime": 1733067809.4417655, "step": 150, "value": 7.599999662488699e-05}, {"wallTime": 1733067818.9180439, "step": 160, "value": 8.099999831756577e-05}, {"wallTime": 1733067836.6473687, "step": 170, "value": 8.600000001024455e-05}, {"wallTime": 1733067846.3879194, "step": 180, "value": 9.100000170292333e-05}, {"wallTime": 1733067855.6641686, "step": 190, "value": 9.600000339560211e-05}, {"wallTime": 1733067864.8856006, "step": 200, "value": 0.00010099999781232327}, {"wallTime": 1733067873.9989097, "step": 210, "value": 0.00010599999950500205}, {"wallTime": 1733067883.7819333, "step": 220, "value": 0.00011100000119768083}, {"wallTime": 1733067892.12019, "step": 230, "value": 0.00011600000289035961}, {"wallTime": 1733067901.0665507, "step": 240, "value": 0.00012099999730708078}, {"wallTime": 1733067910.072245, "step": 250, "value": 0.00012599999899975955}, {"wallTime": 1733067925.9478283, "step": 260, "value": 0.00013099999341648072}, {"wallTime": 1733067935.4578652, "step": 270, "value": 0.00013600000238511711}, {"wallTime": 1733067944.01154, "step": 280, "value": 0.00014099999680183828}, {"wallTime": 1733067952.5426064, "step": 290, "value": 0.00014600000577047467}, {"wallTime": 1733067961.0240088, "step": 300, "value": 0.00015100000018719584}, {"wallTime": 1733067970.1317801, "step": 310, "value": 0.000155999994603917}, {"wallTime": 1733067980.223088, "step": 320, "value": 0.0001610000035725534}, {"wallTime": 1733067988.813264, "step": 330, "value": 0.00016599999798927456}, {"wallTime": 1733068005.088336, "step": 340, "value": 0.00017100000695791095}, {"wallTime": 1733068014.0621333, "step": 350, "value": 0.00017600000137463212}, {"wallTime": 1733068022.5503333, "step": 360, "value": 0.00018099999579135329}, {"wallTime": 1733068031.8220408, "step": 370, "value": 0.00018600000475998968}, {"wallTime": 1733068040.7849264, "step": 380, "value": 0.00019099999917671084}, {"wallTime": 1733068050.1574302, "step": 390, "value": 0.000195999993593432}, {"wallTime": 1733068059.123376, "step": 400, "value": 0.0002010000025620684}, {"wallTime": 1733068068.0875134, "step": 410, "value": 0.00020599999697878957}, {"wallTime": 1733068084.8416576, "step": 420, "value": 0.00021100000594742596}, {"wallTime": 1733068094.6639555, "step": 430, "value": 0.00021600000036414713}, {"wallTime": 1733068103.7055218, "step": 440, "value": 0.0002209999947808683}, {"wallTime": 1733068112.6971889, "step": 450, "value": 0.00022600000374950469}, {"wallTime": 1733068121.498526, "step": 460, "value": 0.00023099999816622585}, {"wallTime": 1733068130.7251978, "step": 470, "value": 0.00023600000713486224}, {"wallTime": 1733068139.8532217, "step": 480, "value": 0.0002410000015515834}, {"wallTime": 1733068149.367732, "step": 490, "value": 0.0002460000105202198}, {"wallTime": 1733068158.0677316, "step": 500, "value": 0.0002500000118743628}, {"wallTime": 1733068174.1132796, "step": 510, "value": 0.0002500000118743628}, {"wallTime": 1733068182.717282, "step": 520, "value": 0.0002500000118743628}, {"wallTime": 1733068192.4113486, "step": 530, "value": 0.0002500000118743628}, {"wallTime": 1733068201.8058722, "step": 540, "value": 0.0002500000118743628}, {"wallTime": 1733068210.652261, "step": 550, "value": 0.0002500000118743628}, {"wallTime": 1733068220.192693, "step": 560, "value": 0.0002500000118743628}, {"wallTime": 1733068229.156787, "step": 570, "value": 0.0002500000118743628}, {"wallTime": 1733068238.5889223, "step": 580, "value": 0.0002500000118743628}, {"wallTime": 1733068256.0707574, "step": 590, "value": 0.0002500000118743628}, {"wallTime": 1733068265.429575, "step": 600, "value": 0.0002500000118743628}, {"wallTime": 1733068274.6542048, "step": 610, "value": 0.0002500000118743628}, {"wallTime": 1733068283.7676766, "step": 620, "value": 0.0002500000118743628}, {"wallTime": 1733068293.3317153, "step": 630, "value": 0.0002500000118743628}, {"wallTime": 1733068302.6447546, "step": 640, "value": 0.0002500000118743628}, {"wallTime": 1733068311.385749, "step": 650, "value": 0.0002500000118743628}, {"wallTime": 1733068320.3878994, "step": 660, "value": 0.0002500000118743628}, {"wallTime": 1733068328.7290623, "step": 670, "value": 0.0002500000118743628}, {"wallTime": 1733068344.4594998, "step": 680, "value": 0.0002500000118743628}, {"wallTime": 1733068353.7147639, "step": 690, "value": 0.0002500000118743628}, {"wallTime": 1733068362.0553858, "step": 700, "value": 0.0002500000118743628}, {"wallTime": 1733068371.1017663, "step": 710, "value": 0.0002500000118743628}, {"wallTime": 1733068380.5308733, "step": 720, "value": 0.0002500000118743628}, {"wallTime": 1733068390.0845816, "step": 730, "value": 0.0002500000118743628}, {"wallTime": 1733068398.7188818, "step": 740, "value": 0.0002500000118743628}, {"wallTime": 1733068407.1217098, "step": 750, "value": 0.0002500000118743628}, {"wallTime": 1733068423.0680943, "step": 760, "value": 0.0002500000118743628}, {"wallTime": 1733068431.4028335, "step": 770, "value": 0.0002500000118743628}, {"wallTime": 1733068440.4228013, "step": 780, "value": 0.0002500000118743628}, {"wallTime": 1733068449.004281, "step": 790, "value": 0.0002500000118743628}, {"wallTime": 1733068457.6340241, "step": 800, "value": 0.0002500000118743628}, {"wallTime": 1733068467.0451338, "step": 810, "value": 0.0002500000118743628}, {"wallTime": 1733068475.6179507, "step": 820, "value": 0.0002500000118743628}, {"wallTime": 1733068484.9766357, "step": 830, "value": 0.0002500000118743628}, {"wallTime": 1733068500.7300417, "step": 840, "value": 0.0002500000118743628}, {"wallTime": 1733068509.3054957, "step": 850, "value": 0.0002500000118743628}, {"wallTime": 1733068519.0201142, "step": 860, "value": 0.0002500000118743628}, {"wallTime": 1733068527.496594, "step": 870, "value": 0.0002500000118743628}, {"wallTime": 1733068536.918173, "step": 880, "value": 0.0002500000118743628}, {"wallTime": 1733068544.9066973, "step": 890, "value": 0.0002500000118743628}, {"wallTime": 1733068553.5691023, "step": 900, "value": 0.0002500000118743628}, {"wallTime": 1733068562.684079, "step": 910, "value": 0.0002500000118743628}, {"wallTime": 1733068571.2441676, "step": 920, "value": 0.0002500000118743628}, {"wallTime": 1733068584.775011, "step": 930, "value": 0.0002500000118743628}, {"wallTime": 1733068593.7707958, "step": 940, "value": 0.0002500000118743628}, {"wallTime": 1733068602.765001, "step": 950, "value": 0.0002500000118743628}, {"wallTime": 1733068611.0388644, "step": 960, "value": 0.0002500000118743628}, {"wallTime": 1733068620.2258976, "step": 970, "value": 0.0002500000118743628}, {"wallTime": 1733068628.840889, "step": 980, "value": 0.0002500000118743628}, {"wallTime": 1733068637.62978, "step": 990, "value": 0.0002500000118743628}, {"wallTime": 1733068646.6720645, "step": 1000, "value": 0.0002500000118743628}, {"wallTime": 1733068662.7566333, "step": 1010, "value": 0.0002500000118743628}, {"wallTime": 1733068672.0537066, "step": 1020, "value": 0.0002500000118743628}, {"wallTime": 1733068680.5624921, "step": 1030, "value": 0.0002500000118743628}, {"wallTime": 1733068690.1850708, "step": 1040, "value": 0.0002500000118743628}, {"wallTime": 1733068698.847457, "step": 1050, "value": 0.0002500000118743628}, {"wallTime": 1733068707.7427487, "step": 1060, "value": 0.0002500000118743628}, {"wallTime": 1733068717.3441756, "step": 1070, "value": 0.0002500000118743628}, {"wallTime": 1733068726.360895, "step": 1080, "value": 0.0002500000118743628}, {"wallTime": 1733068735.2509618, "step": 1090, "value": 0.0002500000118743628}, {"wallTime": 1733068749.547999, "step": 1100, "value": 0.0002500000118743628}, {"wallTime": 1733068758.3748827, "step": 1110, "value": 0.0002500000118743628}, {"wallTime": 1733068767.0033672, "step": 1120, "value": 0.0002500000118743628}, {"wallTime": 1733068776.6184242, "step": 1130, "value": 0.0002500000118743628}, {"wallTime": 1733068785.4005384, "step": 1140, "value": 0.0002500000118743628}, {"wallTime": 1733068794.278592, "step": 1150, "value": 0.0002500000118743628}, {"wallTime": 1733068802.6969004, "step": 1160, "value": 0.0002500000118743628}, {"wallTime": 1733068811.5509768, "step": 1170, "value": 0.0002500000118743628}, {"wallTime": 1733068824.9658954, "step": 1180, "value": 0.0002500000118743628}, {"wallTime": 1733068834.376583, "step": 1190, "value": 0.0002500000118743628}, {"wallTime": 1733068843.5156658, "step": 1200, "value": 0.0002500000118743628}, {"wallTime": 1733068852.227821, "step": 1210, "value": 0.0002500000118743628}, {"wallTime": 1733068861.1162999, "step": 1220, "value": 0.0002500000118743628}, {"wallTime": 1733068870.055329, "step": 1230, "value": 0.0002500000118743628}, {"wallTime": 1733068878.7199857, "step": 1240, "value": 0.0002500000118743628}, {"wallTime": 1733068887.7315865, "step": 1250, "value": 0.0002500000118743628}, {"wallTime": 1733068903.1668262, "step": 1260, "value": 0.0002500000118743628}, {"wallTime": 1733068912.4052086, "step": 1270, "value": 0.0002500000118743628}, {"wallTime": 1733068921.4715676, "step": 1280, "value": 0.0002500000118743628}, {"wallTime": 1733068929.7462296, "step": 1290, "value": 0.0002500000118743628}, {"wallTime": 1733068939.500476, "step": 1300, "value": 0.0002500000118743628}, {"wallTime": 1733068948.9269583, "step": 1310, "value": 0.0002500000118743628}, {"wallTime": 1733068957.233992, "step": 1320, "value": 0.0002500000118743628}, {"wallTime": 1733068966.0766108, "step": 1330, "value": 0.0002500000118743628}, {"wallTime": 1733068975.5647347, "step": 1340, "value": 0.0002500000118743628}, {"wallTime": 1733068989.797395, "step": 1350, "value": 0.0002500000118743628}, {"wallTime": 1733068998.25712, "step": 1360, "value": 0.0002500000118743628}, {"wallTime": 1733069007.1469107, "step": 1370, "value": 0.0002500000118743628}, {"wallTime": 1733069015.9198868, "step": 1380, "value": 0.0002500000118743628}, {"wallTime": 1733069025.3027878, "step": 1390, "value": 0.0002500000118743628}, {"wallTime": 1733069034.480947, "step": 1400, "value": 0.0002500000118743628}, {"wallTime": 1733069042.7924516, "step": 1410, "value": 0.0002500000118743628}, {"wallTime": 1733069052.1368217, "step": 1420, "value": 0.0002500000118743628}, {"wallTime": 1733069065.0015388, "step": 1430, "value": 0.0002500000118743628}, {"wallTime": 1733069074.523338, "step": 1440, "value": 0.0002500000118743628}, {"wallTime": 1733069083.7758172, "step": 1450, "value": 0.0002500000118743628}, {"wallTime": 1733069092.2568212, "step": 1460, "value": 0.0002500000118743628}, {"wallTime": 1733069101.0289626, "step": 1470, "value": 0.0002500000118743628}, {"wallTime": 1733069109.9044936, "step": 1480, "value": 0.0002500000118743628}, {"wallTime": 1733069119.117035, "step": 1490, "value": 0.0002500000118743628}, {"wallTime": 1733069128.4142506, "step": 1500, "value": 0.0002500000118743628}, {"wallTime": 1733069137.6049953, "step": 1510, "value": 0.0002500000118743628}, {"wallTime": 1733069150.5423179, "step": 1520, "value": 0.0002500000118743628}, {"wallTime": 1733069159.7553766, "step": 1530, "value": 0.0002500000118743628}, {"wallTime": 1733069168.168533, "step": 1540, "value": 0.0002500000118743628}, {"wallTime": 1733069176.839287, "step": 1550, "value": 0.0002500000118743628}, {"wallTime": 1733069185.8906164, "step": 1560, "value": 0.0002500000118743628}, {"wallTime": 1733069194.921963, "step": 1570, "value": 0.0002500000118743628}, {"wallTime": 1733069203.9099288, "step": 1580, "value": 0.0002500000118743628}, {"wallTime": 1733069212.713594, "step": 1590, "value": 0.0002500000118743628}, {"wallTime": 1733069225.5327098, "step": 1600, "value": 0.0002500000118743628}, {"wallTime": 1733069235.462104, "step": 1610, "value": 0.0002500000118743628}, {"wallTime": 1733069244.6276772, "step": 1620, "value": 0.0002500000118743628}, {"wallTime": 1733069254.2699802, "step": 1630, "value": 0.0002500000118743628}, {"wallTime": 1733069263.003527, "step": 1640, "value": 0.0002500000118743628}, {"wallTime": 1733069271.8648605, "step": 1650, "value": 0.0002500000118743628}, {"wallTime": 1733069280.5081725, "step": 1660, "value": 0.0002500000118743628}, {"wallTime": 1733069289.6780946, "step": 1670, "value": 0.0002500000118743628}, {"wallTime": 1733069303.6071951, "step": 1680, "value": 0.0002500000118743628}, {"wallTime": 1733069312.4775786, "step": 1690, "value": 0.0002500000118743628}, {"wallTime": 1733069321.8368053, "step": 1700, "value": 0.0002500000118743628}, {"wallTime": 1733069330.3462465, "step": 1710, "value": 0.0002500000118743628}, {"wallTime": 1733069339.2432284, "step": 1720, "value": 0.0002500000118743628}, {"wallTime": 1733069346.8547873, "step": 1730, "value": 0.0002500000118743628}, {"wallTime": 1733069355.6503756, "step": 1740, "value": 0.0002500000118743628}, {"wallTime": 1733069364.51002, "step": 1750, "value": 0.0002500000118743628}, {"wallTime": 1733069373.7365897, "step": 1760, "value": 0.0002500000118743628}, {"wallTime": 1733069387.5398042, "step": 1770, "value": 0.0002500000118743628}, {"wallTime": 1733069396.4646752, "step": 1780, "value": 0.0002500000118743628}, {"wallTime": 1733069405.9945245, "step": 1790, "value": 0.0002500000118743628}, {"wallTime": 1733069415.0518515, "step": 1800, "value": 0.0002500000118743628}, {"wallTime": 1733069423.905855, "step": 1810, "value": 0.0002500000118743628}, {"wallTime": 1733069432.52917, "step": 1820, "value": 0.0002500000118743628}, {"wallTime": 1733069441.214867, "step": 1830, "value": 0.0002500000118743628}, {"wallTime": 1733069450.0845916, "step": 1840, "value": 0.0002500000118743628}, {"wallTime": 1733069463.1053588, "step": 1850, "value": 0.0002500000118743628}, {"wallTime": 1733069471.5705562, "step": 1860, "value": 0.0002500000118743628}, {"wallTime": 1733069480.495955, "step": 1870, "value": 0.0002500000118743628}, {"wallTime": 1733069489.3828573, "step": 1880, "value": 0.0002500000118743628}, {"wallTime": 1733069497.9744594, "step": 1890, "value": 0.0002500000118743628}, {"wallTime": 1733069506.7919765, "step": 1900, "value": 0.0002500000118743628}, {"wallTime": 1733069515.8225274, "step": 1910, "value": 0.0002500000118743628}, {"wallTime": 1733069524.6343865, "step": 1920, "value": 0.0002500000118743628}, {"wallTime": 1733069533.5398893, "step": 1930, "value": 0.0002500000118743628}, {"wallTime": 1733069550.476355, "step": 1940, "value": 0.0002500000118743628}, {"wallTime": 1733069558.8255882, "step": 1950, "value": 0.0002500000118743628}, {"wallTime": 1733069567.7556837, "step": 1960, "value": 0.0002500000118743628}, {"wallTime": 1733069576.342859, "step": 1970, "value": 0.0002500000118743628}, {"wallTime": 1733069585.5268114, "step": 1980, "value": 0.0002500000118743628}, {"wallTime": 1733069594.3480604, "step": 1990, "value": 0.0002500000118743628}, {"wallTime": 1733069602.3992488, "step": 2000, "value": 0.0002500000118743628}, {"wallTime": 1733069610.2474906, "step": 2010, "value": 0.0002500000118743628}, {"wallTime": 1733069626.6851559, "step": 2020, "value": 0.0002500000118743628}, {"wallTime": 1733069635.028576, "step": 2030, "value": 0.0002500000118743628}, {"wallTime": 1733069643.820416, "step": 2040, "value": 0.0002500000118743628}, {"wallTime": 1733069652.1922798, "step": 2050, "value": 0.0002500000118743628}, {"wallTime": 1733069660.4512289, "step": 2060, "value": 0.0002500000118743628}, {"wallTime": 1733069669.5898829, "step": 2070, "value": 0.0002500000118743628}, {"wallTime": 1733069678.7759435, "step": 2080, "value": 0.0002500000118743628}, {"wallTime": 1733069686.9425807, "step": 2090, "value": 0.0002500000118743628}, {"wallTime": 1733069700.6003075, "step": 2100, "value": 0.0002500000118743628}, {"wallTime": 1733069708.7241178, "step": 2110, "value": 0.0002500000118743628}, {"wallTime": 1733069717.446135, "step": 2120, "value": 0.0002500000118743628}, {"wallTime": 1733069726.139016, "step": 2130, "value": 0.0002500000118743628}, {"wallTime": 1733069735.0357227, "step": 2140, "value": 0.0002500000118743628}, {"wallTime": 1733069743.3036127, "step": 2150, "value": 0.0002500000118743628}, {"wallTime": 1733069752.498456, "step": 2160, "value": 0.0002500000118743628}, {"wallTime": 1733069761.4487958, "step": 2170, "value": 0.0002500000118743628}, {"wallTime": 1733069770.4310248, "step": 2180, "value": 0.0002500000118743628}, {"wallTime": 1733069784.3617368, "step": 2190, "value": 0.0002500000118743628}, {"wallTime": 1733069793.120194, "step": 2200, "value": 0.0002500000118743628}, {"wallTime": 1733069801.6291583, "step": 2210, "value": 0.0002500000118743628}, {"wallTime": 1733069810.6054604, "step": 2220, "value": 0.0002500000118743628}, {"wallTime": 1733069819.3392804, "step": 2230, "value": 0.0002500000118743628}, {"wallTime": 1733069827.3239076, "step": 2240, "value": 0.0002500000118743628}, {"wallTime": 1733069835.8651547, "step": 2250, "value": 0.0002500000118743628}, {"wallTime": 1733069844.2333217, "step": 2260, "value": 0.0002500000118743628}, {"wallTime": 1733069856.7474053, "step": 2270, "value": 0.0002500000118743628}, {"wallTime": 1733069865.2551954, "step": 2280, "value": 0.0002500000118743628}, {"wallTime": 1733069874.0024986, "step": 2290, "value": 0.0002500000118743628}, {"wallTime": 1733069881.7791655, "step": 2300, "value": 0.0002500000118743628}, {"wallTime": 1733069890.4112036, "step": 2310, "value": 0.0002500000118743628}, {"wallTime": 1733069898.8742251, "step": 2320, "value": 0.0002500000118743628}, {"wallTime": 1733069908.3153641, "step": 2330, "value": 0.0002500000118743628}, {"wallTime": 1733069917.4128144, "step": 2340, "value": 0.0002500000118743628}, {"wallTime": 1733069925.8476245, "step": 2350, "value": 0.0002500000118743628}, {"wallTime": 1733069938.699821, "step": 2360, "value": 0.0002500000118743628}, {"wallTime": 1733069947.4236393, "step": 2370, "value": 0.0002500000118743628}, {"wallTime": 1733069956.2031057, "step": 2380, "value": 0.0002500000118743628}, {"wallTime": 1733069964.2719615, "step": 2390, "value": 0.0002500000118743628}, {"wallTime": 1733069973.323687, "step": 2400, "value": 0.0002500000118743628}, {"wallTime": 1733069981.4294705, "step": 2410, "value": 0.0002500000118743628}, {"wallTime": 1733069990.1371062, "step": 2420, "value": 0.0002500000118743628}, {"wallTime": 1733069998.7951834, "step": 2430, "value": 0.0002500000118743628}, {"wallTime": 1733070012.4538045, "step": 2440, "value": 0.0002500000118743628}, {"wallTime": 1733070021.5722675, "step": 2450, "value": 0.0002500000118743628}, {"wallTime": 1733070030.1885252, "step": 2460, "value": 0.0002500000118743628}, {"wallTime": 1733070039.216832, "step": 2470, "value": 0.0002500000118743628}, {"wallTime": 1733070048.2664595, "step": 2480, "value": 0.0002500000118743628}, {"wallTime": 1733070056.1531017, "step": 2490, "value": 0.0002500000118743628}, {"wallTime": 1733070064.4478943, "step": 2500, "value": 0.0002500000118743628}, {"wallTime": 1733070072.5465634, "step": 2510, "value": 0.0002500000118743628}, {"wallTime": 1733070087.654756, "step": 2520, "value": 0.0002500000118743628}, {"wallTime": 1733070095.438834, "step": 2530, "value": 0.0002500000118743628}, {"wallTime": 1733070103.7663057, "step": 2540, "value": 0.0002500000118743628}, {"wallTime": 1733070113.046182, "step": 2550, "value": 0.0002500000118743628}, {"wallTime": 1733070121.0352306, "step": 2560, "value": 0.0002500000118743628}, {"wallTime": 1733070129.5763373, "step": 2570, "value": 0.0002500000118743628}, {"wallTime": 1733070138.3581085, "step": 2580, "value": 0.0002500000118743628}, {"wallTime": 1733070147.0847862, "step": 2590, "value": 0.0002500000118743628}, {"wallTime": 1733070155.484278, "step": 2600, "value": 0.0002500000118743628}, {"wallTime": 1733070172.5752661, "step": 2610, "value": 0.0002500000118743628}, {"wallTime": 1733070181.2084684, "step": 2620, "value": 0.0002500000118743628}, {"wallTime": 1733070189.689535, "step": 2630, "value": 0.0002500000118743628}, {"wallTime": 1733070198.3966188, "step": 2640, "value": 0.0002500000118743628}, {"wallTime": 1733070206.7048354, "step": 2650, "value": 0.0002500000118743628}, {"wallTime": 1733070215.5971491, "step": 2660, "value": 0.0002500000118743628}, {"wallTime": 1733070224.3127935, "step": 2670, "value": 0.0002500000118743628}, {"wallTime": 1733070233.5366974, "step": 2680, "value": 0.0002500000118743628}, {"wallTime": 1733070246.7560854, "step": 2690, "value": 0.0002500000118743628}, {"wallTime": 1733070256.0260854, "step": 2700, "value": 0.0002500000118743628}, {"wallTime": 1733070264.9482725, "step": 2710, "value": 0.0002500000118743628}, {"wallTime": 1733070273.8021939, "step": 2720, "value": 0.0002500000118743628}, {"wallTime": 1733070282.956404, "step": 2730, "value": 0.0002500000118743628}, {"wallTime": 1733070292.2753854, "step": 2740, "value": 0.0002500000118743628}, {"wallTime": 1733070300.3340178, "step": 2750, "value": 0.0002500000118743628}, {"wallTime": 1733070309.4096236, "step": 2760, "value": 0.0002500000118743628}, {"wallTime": 1733070317.5289803, "step": 2770, "value": 0.0002500000118743628}, {"wallTime": 1733070330.4340837, "step": 2780, "value": 0.0002500000118743628}, {"wallTime": 1733070339.8200276, "step": 2790, "value": 0.0002500000118743628}, {"wallTime": 1733070347.9903836, "step": 2800, "value": 0.0002500000118743628}, {"wallTime": 1733070356.8882947, "step": 2810, "value": 0.0002500000118743628}, {"wallTime": 1733070365.574318, "step": 2820, "value": 0.0002500000118743628}, {"wallTime": 1733070374.3899584, "step": 2830, "value": 0.0002500000118743628}, {"wallTime": 1733070382.42448, "step": 2840, "value": 0.0002500000118743628}, {"wallTime": 1733070390.938616, "step": 2850, "value": 0.0002500000118743628}, {"wallTime": 1733070406.6767378, "step": 2860, "value": 0.0002500000118743628}, {"wallTime": 1733070415.086265, "step": 2870, "value": 0.0002500000118743628}, {"wallTime": 1733070422.9175198, "step": 2880, "value": 0.0002500000118743628}, {"wallTime": 1733070431.5348244, "step": 2890, "value": 0.0002500000118743628}, {"wallTime": 1733070439.978276, "step": 2900, "value": 0.0002500000118743628}, {"wallTime": 1733070448.082797, "step": 2910, "value": 0.0002500000118743628}, {"wallTime": 1733070457.4211214, "step": 2920, "value": 0.0002500000118743628}, {"wallTime": 1733070466.720374, "step": 2930, "value": 0.0002500000118743628}, {"wallTime": 1733070479.3305144, "step": 2940, "value": 0.0002500000118743628}, {"wallTime": 1733070488.779567, "step": 2950, "value": 0.0002500000118743628}, {"wallTime": 1733070497.2223473, "step": 2960, "value": 0.0002500000118743628}, {"wallTime": 1733070505.6311278, "step": 2970, "value": 0.0002500000118743628}, {"wallTime": 1733070513.3513267, "step": 2980, "value": 0.0002500000118743628}, {"wallTime": 1733070522.298387, "step": 2990, "value": 0.0002500000118743628}, {"wallTime": 1733070530.2099419, "step": 3000, "value": 0.0002500000118743628}, {"wallTime": 1733070538.2975357, "step": 3010, "value": 0.0002500000118743628}, {"wallTime": 1733070547.3978074, "step": 3020, "value": 0.0002500000118743628}, {"wallTime": 1733070564.0487642, "step": 3030, "value": 0.0002500000118743628}, {"wallTime": 1733070572.367139, "step": 3040, "value": 0.0002500000118743628}, {"wallTime": 1733070580.668142, "step": 3050, "value": 0.0002500000118743628}, {"wallTime": 1733070588.6506932, "step": 3060, "value": 0.0002500000118743628}, {"wallTime": 1733070597.417985, "step": 3070, "value": 0.0002500000118743628}, {"wallTime": 1733070606.134705, "step": 3080, "value": 0.0002500000118743628}, {"wallTime": 1733070614.4364662, "step": 3090, "value": 0.0002500000118743628}, {"wallTime": 1733070623.997272, "step": 3100, "value": 0.0002500000118743628}, {"wallTime": 1733070637.2499576, "step": 3110, "value": 0.0002500000118743628}, {"wallTime": 1733070645.6792045, "step": 3120, "value": 0.0002500000118743628}, {"wallTime": 1733070654.2670097, "step": 3130, "value": 0.0002500000118743628}, {"wallTime": 1733070663.3178046, "step": 3140, "value": 0.0002500000118743628}, {"wallTime": 1733070671.1143572, "step": 3150, "value": 0.0002500000118743628}, {"wallTime": 1733070679.761992, "step": 3160, "value": 0.0002500000118743628}, {"wallTime": 1733070687.8410807, "step": 3170, "value": 0.0002500000118743628}, {"wallTime": 1733070695.8521795, "step": 3180, "value": 0.0002500000118743628}, {"wallTime": 1733070704.618973, "step": 3190, "value": 0.0002500000118743628}, {"wallTime": 1733070717.1059391, "step": 3200, "value": 0.0002500000118743628}, {"wallTime": 1733070726.0951936, "step": 3210, "value": 0.0002500000118743628}, {"wallTime": 1733070734.7724688, "step": 3220, "value": 0.0002500000118743628}, {"wallTime": 1733070744.4081209, "step": 3230, "value": 0.0002500000118743628}, {"wallTime": 1733070752.497971, "step": 3240, "value": 0.0002500000118743628}, {"wallTime": 1733070761.7174804, "step": 3250, "value": 0.0002500000118743628}, {"wallTime": 1733070770.372965, "step": 3260, "value": 0.0002500000118743628}, {"wallTime": 1733070779.72656, "step": 3270, "value": 0.0002500000118743628}, {"wallTime": 1733070793.6753376, "step": 3280, "value": 0.0002500000118743628}, {"wallTime": 1733070801.896579, "step": 3290, "value": 0.0002500000118743628}, {"wallTime": 1733070810.1576226, "step": 3300, "value": 0.0002500000118743628}, {"wallTime": 1733070818.72252, "step": 3310, "value": 0.0002500000118743628}, {"wallTime": 1733070827.002576, "step": 3320, "value": 0.0002500000118743628}, {"wallTime": 1733070835.5702531, "step": 3330, "value": 0.0002500000118743628}, {"wallTime": 1733070843.9699817, "step": 3340, "value": 0.0002500000118743628}, {"wallTime": 1733070853.0878158, "step": 3350, "value": 0.0002500000118743628}, {"wallTime": 1733070865.416607, "step": 3360, "value": 0.0002500000118743628}, {"wallTime": 1733070873.657914, "step": 3370, "value": 0.0002500000118743628}, {"wallTime": 1733070883.332412, "step": 3380, "value": 0.0002500000118743628}, {"wallTime": 1733070892.373323, "step": 3390, "value": 0.0002500000118743628}, {"wallTime": 1733070900.7188036, "step": 3400, "value": 0.0002500000118743628}, {"wallTime": 1733070908.5007782, "step": 3410, "value": 0.0002500000118743628}, {"wallTime": 1733070916.6523576, "step": 3420, "value": 0.0002500000118743628}, {"wallTime": 1733070925.2042804, "step": 3430, "value": 0.0002500000118743628}, {"wallTime": 1733070933.8068898, "step": 3440, "value": 0.0002500000118743628}, {"wallTime": 1733070947.4768796, "step": 3450, "value": 0.0002500000118743628}, {"wallTime": 1733070956.1837177, "step": 3460, "value": 0.0002500000118743628}, {"wallTime": 1733070964.2629015, "step": 3470, "value": 0.0002500000118743628}, {"wallTime": 1733070972.382619, "step": 3480, "value": 0.0002500000118743628}, {"wallTime": 1733070980.6437614, "step": 3490, "value": 0.0002500000118743628}, {"wallTime": 1733070989.6840284, "step": 3500, "value": 0.0002500000118743628}, {"wallTime": 1733070997.7848773, "step": 3510, "value": 0.0002500000118743628}, {"wallTime": 1733071006.2679656, "step": 3520, "value": 0.0002500000118743628}, {"wallTime": 1733071018.893147, "step": 3530, "value": 0.0002500000118743628}, {"wallTime": 1733071027.1931632, "step": 3540, "value": 0.0002500000118743628}, {"wallTime": 1733071035.3171399, "step": 3550, "value": 0.0002500000118743628}, {"wallTime": 1733071043.7422683, "step": 3560, "value": 0.0002500000118743628}, {"wallTime": 1733071051.8687963, "step": 3570, "value": 0.0002500000118743628}, {"wallTime": 1733071060.492799, "step": 3580, "value": 0.0002500000118743628}, {"wallTime": 1733071068.8757734, "step": 3590, "value": 0.0002500000118743628}, {"wallTime": 1733071077.7096004, "step": 3600, "value": 0.0002500000118743628}, {"wallTime": 1733071086.2090025, "step": 3610, "value": 0.0002500000118743628}, {"wallTime": 1733071101.655859, "step": 3620, "value": 0.0002500000118743628}, {"wallTime": 1733071109.6163962, "step": 3630, "value": 0.0002500000118743628}, {"wallTime": 1733071118.1259484, "step": 3640, "value": 0.0002500000118743628}, {"wallTime": 1733071126.9896562, "step": 3650, "value": 0.0002500000118743628}, {"wallTime": 1733071135.824065, "step": 3660, "value": 0.0002500000118743628}, {"wallTime": 1733071144.2449105, "step": 3670, "value": 0.0002500000118743628}, {"wallTime": 1733071152.9612586, "step": 3680, "value": 0.0002500000118743628}, {"wallTime": 1733071160.5999217, "step": 3690, "value": 0.0002500000118743628}, {"wallTime": 1733071173.7474782, "step": 3700, "value": 0.0002500000118743628}, {"wallTime": 1733071182.8799677, "step": 3710, "value": 0.0002500000118743628}, {"wallTime": 1733071191.2065964, "step": 3720, "value": 0.0002500000118743628}, {"wallTime": 1733071200.330004, "step": 3730, "value": 0.0002500000118743628}, {"wallTime": 1733071208.3624508, "step": 3740, "value": 0.0002500000118743628}, {"wallTime": 1733071216.5685499, "step": 3750, "value": 0.0002500000118743628}, {"wallTime": 1733071224.6586342, "step": 3760, "value": 0.0002500000118743628}, {"wallTime": 1733071232.8573122, "step": 3770, "value": 0.0002500000118743628}, {"wallTime": 1733071248.5305777, "step": 3780, "value": 0.0002500000118743628}, {"wallTime": 1733071257.3882148, "step": 3790, "value": 0.0002500000118743628}, {"wallTime": 1733071265.5641482, "step": 3800, "value": 0.0002500000118743628}, {"wallTime": 1733071274.1754873, "step": 3810, "value": 0.0002500000118743628}, {"wallTime": 1733071283.0147822, "step": 3820, "value": 0.0002500000118743628}, {"wallTime": 1733071291.7263129, "step": 3830, "value": 0.0002500000118743628}, {"wallTime": 1733071299.888419, "step": 3840, "value": 0.0002500000118743628}, {"wallTime": 1733071308.4761817, "step": 3850, "value": 0.0002500000118743628}, {"wallTime": 1733071316.9482424, "step": 3860, "value": 0.0002500000118743628}, {"wallTime": 1733071330.212411, "step": 3870, "value": 0.0002500000118743628}, {"wallTime": 1733071338.985787, "step": 3880, "value": 0.0002500000118743628}, {"wallTime": 1733071347.7338412, "step": 3890, "value": 0.0002500000118743628}, {"wallTime": 1733071357.0310104, "step": 3900, "value": 0.0002500000118743628}, {"wallTime": 1733071365.2222812, "step": 3910, "value": 0.0002500000118743628}, {"wallTime": 1733071374.131789, "step": 3920, "value": 0.0002500000118743628}, {"wallTime": 1733071382.8109, "step": 3930, "value": 0.0002500000118743628}, {"wallTime": 1733071391.5654933, "step": 3940, "value": 0.0002500000118743628}, {"wallTime": 1733071404.4648201, "step": 3950, "value": 0.0002500000118743628}, {"wallTime": 1733071412.3357196, "step": 3960, "value": 0.0002500000118743628}, {"wallTime": 1733071421.1544886, "step": 3970, "value": 0.0002500000118743628}, {"wallTime": 1733071430.1174629, "step": 3980, "value": 0.0002500000118743628}, {"wallTime": 1733071438.4111445, "step": 3990, "value": 0.0002500000118743628}, {"wallTime": 1733071447.7256682, "step": 4000, "value": 0.0002500000118743628}, {"wallTime": 1733071456.1936693, "step": 4010, "value": 0.0002500000118743628}, {"wallTime": 1733071464.746656, "step": 4020, "value": 0.0002500000118743628}, {"wallTime": 1733071473.3939312, "step": 4030, "value": 0.0002500000118743628}, {"wallTime": 1733071490.2841313, "step": 4040, "value": 0.0002500000118743628}, {"wallTime": 1733071498.7089427, "step": 4050, "value": 0.0002500000118743628}, {"wallTime": 1733071507.0945697, "step": 4060, "value": 0.0002500000118743628}, {"wallTime": 1733071515.0649436, "step": 4070, "value": 0.0002500000118743628}, {"wallTime": 1733071523.878522, "step": 4080, "value": 0.0002500000118743628}, {"wallTime": 1733071532.2825193, "step": 4090, "value": 0.0002500000118743628}, {"wallTime": 1733071540.915083, "step": 4100, "value": 0.0002500000118743628}, {"wallTime": 1733071549.1736395, "step": 4110, "value": 0.0002500000118743628}, {"wallTime": 1733071565.8339264, "step": 4120, "value": 0.0002500000118743628}, {"wallTime": 1733071573.6291535, "step": 4130, "value": 0.0002500000118743628}, {"wallTime": 1733071582.093579, "step": 4140, "value": 0.0002500000118743628}, {"wallTime": 1733071590.0199962, "step": 4150, "value": 0.0002500000118743628}, {"wallTime": 1733071599.2384896, "step": 4160, "value": 0.0002500000118743628}, {"wallTime": 1733071608.0614004, "step": 4170, "value": 0.0002500000118743628}, {"wallTime": 1733071616.1815352, "step": 4180, "value": 0.0002500000118743628}, {"wallTime": 1733071626.0805957, "step": 4190, "value": 0.0002500000118743628}, {"wallTime": 1733071641.0060935, "step": 4200, "value": 0.0002500000118743628}, {"wallTime": 1733071649.0382109, "step": 4210, "value": 0.0002500000118743628}, {"wallTime": 1733071658.529154, "step": 4220, "value": 0.0002500000118743628}, {"wallTime": 1733071667.963839, "step": 4230, "value": 0.0002500000118743628}, {"wallTime": 1733071676.1065009, "step": 4240, "value": 0.0002500000118743628}, {"wallTime": 1733071684.3762047, "step": 4250, "value": 0.0002500000118743628}, {"wallTime": 1733071693.107439, "step": 4260, "value": 0.0002500000118743628}, {"wallTime": 1733071702.181704, "step": 4270, "value": 0.0002500000118743628}, {"wallTime": 1733071710.627612, "step": 4280, "value": 0.0002500000118743628}, {"wallTime": 1733071726.6752079, "step": 4290, "value": 0.0002500000118743628}, {"wallTime": 1733071735.2134588, "step": 4300, "value": 0.0002500000118743628}, {"wallTime": 1733071742.9550014, "step": 4310, "value": 0.0002500000118743628}, {"wallTime": 1733071751.5837562, "step": 4320, "value": 0.0002500000118743628}, {"wallTime": 1733071760.0325716, "step": 4330, "value": 0.0002500000118743628}, {"wallTime": 1733071768.4292936, "step": 4340, "value": 0.0002500000118743628}, {"wallTime": 1733071777.3998475, "step": 4350, "value": 0.0002500000118743628}, {"wallTime": 1733071785.5453346, "step": 4360, "value": 0.0002500000118743628}, {"wallTime": 1733071800.883255, "step": 4370, "value": 0.0002500000118743628}, {"wallTime": 1733071809.2635763, "step": 4380, "value": 0.0002500000118743628}, {"wallTime": 1733071817.3441396, "step": 4390, "value": 0.0002500000118743628}, {"wallTime": 1733071826.428179, "step": 4400, "value": 0.0002500000118743628}, {"wallTime": 1733071834.8856153, "step": 4410, "value": 0.0002500000118743628}, {"wallTime": 1733071843.444594, "step": 4420, "value": 0.0002500000118743628}, {"wallTime": 1733071851.593809, "step": 4430, "value": 0.0002500000118743628}, {"wallTime": 1733071859.9215045, "step": 4440, "value": 0.0002500000118743628}, {"wallTime": 1733071868.671087, "step": 4450, "value": 0.0002500000118743628}, {"wallTime": 1733071881.334721, "step": 4460, "value": 0.0002500000118743628}, {"wallTime": 1733071889.6340187, "step": 4470, "value": 0.0002500000118743628}, {"wallTime": 1733071898.4188004, "step": 4480, "value": 0.0002500000118743628}, {"wallTime": 1733071907.3340456, "step": 4490, "value": 0.0002500000118743628}, {"wallTime": 1733071916.2759116, "step": 4500, "value": 0.0002500000118743628}, {"wallTime": 1733071925.346716, "step": 4510, "value": 0.0002500000118743628}, {"wallTime": 1733071933.3271787, "step": 4520, "value": 0.0002500000118743628}, {"wallTime": 1733071941.480634, "step": 4530, "value": 0.0002500000118743628}, {"wallTime": 1733071954.167438, "step": 4540, "value": 0.0002500000118743628}, {"wallTime": 1733071962.3936558, "step": 4550, "value": 0.0002500000118743628}, {"wallTime": 1733071970.511053, "step": 4560, "value": 0.0002500000118743628}, {"wallTime": 1733071978.867731, "step": 4570, "value": 0.0002500000118743628}, {"wallTime": 1733071987.708453, "step": 4580, "value": 0.0002500000118743628}, {"wallTime": 1733071996.4418628, "step": 4590, "value": 0.0002500000118743628}, {"wallTime": 1733072004.4738352, "step": 4600, "value": 0.0002500000118743628}, {"wallTime": 1733072012.7423654, "step": 4610, "value": 0.0002500000118743628}, {"wallTime": 1733072025.398464, "step": 4620, "value": 0.0002500000118743628}, {"wallTime": 1733072034.1157722, "step": 4630, "value": 0.0002500000118743628}, {"wallTime": 1733072043.035039, "step": 4640, "value": 0.0002500000118743628}, {"wallTime": 1733072051.7819152, "step": 4650, "value": 0.0002500000118743628}, {"wallTime": 1733072060.1056154, "step": 4660, "value": 0.0002500000118743628}, {"wallTime": 1733072068.6004798, "step": 4670, "value": 0.0002500000118743628}, {"wallTime": 1733072076.8339112, "step": 4680, "value": 0.0002500000118743628}, {"wallTime": 1733072085.373457, "step": 4690, "value": 0.0002500000118743628}, {"wallTime": 1733072093.7459028, "step": 4700, "value": 0.0002500000118743628}, {"wallTime": 1733072106.9875052, "step": 4710, "value": 0.0002500000118743628}, {"wallTime": 1733072115.6623278, "step": 4720, "value": 0.0002500000118743628}, {"wallTime": 1733072123.9477348, "step": 4730, "value": 0.0002500000118743628}, {"wallTime": 1733072132.2777457, "step": 4740, "value": 0.0002500000118743628}, {"wallTime": 1733072140.4176025, "step": 4750, "value": 0.0002500000118743628}, {"wallTime": 1733072149.084434, "step": 4760, "value": 0.0002500000118743628}, {"wallTime": 1733072157.4089398, "step": 4770, "value": 0.0002500000118743628}, {"wallTime": 1733072165.4865265, "step": 4780, "value": 0.0002500000118743628}, {"wallTime": 1733072179.6455326, "step": 4790, "value": 0.0002500000118743628}, {"wallTime": 1733072188.3267124, "step": 4800, "value": 0.0002500000118743628}, {"wallTime": 1733072196.8442457, "step": 4810, "value": 0.0002500000118743628}, {"wallTime": 1733072204.559406, "step": 4820, "value": 0.0002500000118743628}, {"wallTime": 1733072213.0967755, "step": 4830, "value": 0.0002500000118743628}, {"wallTime": 1733072221.6640177, "step": 4840, "value": 0.0002500000118743628}, {"wallTime": 1733072229.891216, "step": 4850, "value": 0.0002500000118743628}, {"wallTime": 1733072238.0533257, "step": 4860, "value": 0.0002500000118743628}, {"wallTime": 1733072246.340715, "step": 4870, "value": 0.0002500000118743628}, {"wallTime": 1733072261.2651193, "step": 4880, "value": 0.0002500000118743628}, {"wallTime": 1733072269.8492913, "step": 4890, "value": 0.0002500000118743628}, {"wallTime": 1733072278.858465, "step": 4900, "value": 0.0002500000118743628}, {"wallTime": 1733072287.531806, "step": 4910, "value": 0.0002500000118743628}, {"wallTime": 1733072295.9442766, "step": 4920, "value": 0.0002500000118743628}, {"wallTime": 1733072304.3528247, "step": 4930, "value": 0.0002500000118743628}, {"wallTime": 1733072313.5072384, "step": 4940, "value": 0.0002500000118743628}, {"wallTime": 1733072321.322504, "step": 4950, "value": 0.0002500000118743628}, {"wallTime": 1733072337.022863, "step": 4960, "value": 0.0002500000118743628}, {"wallTime": 1733072345.5278323, "step": 4970, "value": 0.0002500000118743628}, {"wallTime": 1733072353.427127, "step": 4980, "value": 0.0002500000118743628}, {"wallTime": 1733072362.4107828, "step": 4990, "value": 0.0002500000118743628}, {"wallTime": 1733072371.7434897, "step": 5000, "value": 0.0002500000118743628}, {"wallTime": 1733072380.5272102, "step": 5010, "value": 0.0002500000118743628}, {"wallTime": 1733072389.0238528, "step": 5020, "value": 0.0002500000118743628}, {"wallTime": 1733072397.7828217, "step": 5030, "value": 0.0002500000118743628}, {"wallTime": 1733072411.296325, "step": 5040, "value": 0.0002500000118743628}, {"wallTime": 1733072419.471305, "step": 5050, "value": 0.0002500000118743628}, {"wallTime": 1733072428.3697639, "step": 5060, "value": 0.0002500000118743628}, {"wallTime": 1733072437.1139784, "step": 5070, "value": 0.0002500000118743628}, {"wallTime": 1733072446.1727357, "step": 5080, "value": 0.0002500000118743628}, {"wallTime": 1733072454.4259398, "step": 5090, "value": 0.0002500000118743628}, {"wallTime": 1733072462.4080694, "step": 5100, "value": 0.0002500000118743628}, {"wallTime": 1733072471.1475005, "step": 5110, "value": 0.0002500000118743628}, {"wallTime": 1733072478.9440124, "step": 5120, "value": 0.0002500000118743628}, {"wallTime": 1733072491.3197036, "step": 5130, "value": 0.0002500000118743628}, {"wallTime": 1733072499.2562346, "step": 5140, "value": 0.0002500000118743628}, {"wallTime": 1733072507.1093755, "step": 5150, "value": 0.0002500000118743628}, {"wallTime": 1733072515.3145864, "step": 5160, "value": 0.0002500000118743628}, {"wallTime": 1733072523.4966242, "step": 5170, "value": 0.0002500000118743628}, {"wallTime": 1733072531.0848064, "step": 5180, "value": 0.0002500000118743628}, {"wallTime": 1733072540.0184922, "step": 5190, "value": 0.0002500000118743628}, {"wallTime": 1733072548.6487982, "step": 5200, "value": 0.0002500000118743628}, {"wallTime": 1733072561.4126375, "step": 5210, "value": 0.0002500000118743628}, {"wallTime": 1733072569.8930614, "step": 5220, "value": 0.0002500000118743628}, {"wallTime": 1733072578.6758177, "step": 5230, "value": 0.0002500000118743628}, {"wallTime": 1733072586.9388232, "step": 5240, "value": 0.0002500000118743628}, {"wallTime": 1733072595.0319211, "step": 5250, "value": 0.0002500000118743628}, {"wallTime": 1733072603.1709032, "step": 5260, "value": 0.0002500000118743628}, {"wallTime": 1733072611.0769901, "step": 5270, "value": 0.0002500000118743628}, {"wallTime": 1733072619.9518034, "step": 5280, "value": 0.0002500000118743628}, {"wallTime": 1733072628.632145, "step": 5290, "value": 0.0002500000118743628}, {"wallTime": 1733072641.373458, "step": 5300, "value": 0.0002500000118743628}, {"wallTime": 1733072649.8551238, "step": 5310, "value": 0.0002500000118743628}, {"wallTime": 1733072657.968674, "step": 5320, "value": 0.0002500000118743628}, {"wallTime": 1733072667.0265865, "step": 5330, "value": 0.0002500000118743628}, {"wallTime": 1733072675.940429, "step": 5340, "value": 0.0002500000118743628}, {"wallTime": 1733072684.2359827, "step": 5350, "value": 0.0002500000118743628}, {"wallTime": 1733072691.8557084, "step": 5360, "value": 0.0002500000118743628}, {"wallTime": 1733072700.1455407, "step": 5370, "value": 0.0002500000118743628}, {"wallTime": 1733072713.1810825, "step": 5380, "value": 0.0002500000118743628}, {"wallTime": 1733072721.021889, "step": 5390, "value": 0.0002500000118743628}, {"wallTime": 1733072729.8745277, "step": 5400, "value": 0.0002500000118743628}, {"wallTime": 1733072738.3659518, "step": 5410, "value": 0.0002500000118743628}, {"wallTime": 1733072746.3800495, "step": 5420, "value": 0.0002500000118743628}, {"wallTime": 1733072754.615197, "step": 5430, "value": 0.0002500000118743628}, {"wallTime": 1733072762.543741, "step": 5440, "value": 0.0002500000118743628}, {"wallTime": 1733072771.35802, "step": 5450, "value": 0.0002500000118743628}, {"wallTime": 1733072787.1497304, "step": 5460, "value": 0.0002500000118743628}, {"wallTime": 1733072795.7997575, "step": 5470, "value": 0.0002500000118743628}, {"wallTime": 1733072804.239558, "step": 5480, "value": 0.0002500000118743628}, {"wallTime": 1733072812.3703337, "step": 5490, "value": 0.0002500000118743628}, {"wallTime": 1733072821.1565716, "step": 5500, "value": 0.0002500000118743628}, {"wallTime": 1733072830.0200415, "step": 5510, "value": 0.0002500000118743628}, {"wallTime": 1733072838.692519, "step": 5520, "value": 0.0002500000118743628}, {"wallTime": 1733072846.9024982, "step": 5530, "value": 0.0002500000118743628}, {"wallTime": 1733072855.2429485, "step": 5540, "value": 0.0002500000118743628}, {"wallTime": 1733072870.6417143, "step": 5550, "value": 0.0002500000118743628}, {"wallTime": 1733072878.7258837, "step": 5560, "value": 0.0002500000118743628}, {"wallTime": 1733072886.6073568, "step": 5570, "value": 0.0002500000118743628}, {"wallTime": 1733072895.0179832, "step": 5580, "value": 0.0002500000118743628}, {"wallTime": 1733072903.400026, "step": 5590, "value": 0.0002500000118743628}, {"wallTime": 1733072911.2072556, "step": 5600, "value": 0.0002500000118743628}, {"wallTime": 1733072919.8369665, "step": 5610, "value": 0.0002500000118743628}, {"wallTime": 1733072928.7302983, "step": 5620, "value": 0.0002500000118743628}, {"wallTime": 1733072941.7014773, "step": 5630, "value": 0.0002500000118743628}, {"wallTime": 1733072949.9771261, "step": 5640, "value": 0.0002500000118743628}, {"wallTime": 1733072958.715957, "step": 5650, "value": 0.0002500000118743628}, {"wallTime": 1733072966.8108919, "step": 5660, "value": 0.0002500000118743628}, {"wallTime": 1733072974.9583035, "step": 5670, "value": 0.0002500000118743628}, {"wallTime": 1733072983.5591996, "step": 5680, "value": 0.0002500000118743628}, {"wallTime": 1733072992.2246964, "step": 5690, "value": 0.0002500000118743628}, {"wallTime": 1733073000.81436, "step": 5700, "value": 0.0002500000118743628}, {"wallTime": 1733073009.7804878, "step": 5710, "value": 0.0002500000118743628}, {"wallTime": 1733073022.8660574, "step": 5720, "value": 0.0002500000118743628}, {"wallTime": 1733073031.530765, "step": 5730, "value": 0.0002500000118743628}, {"wallTime": 1733073039.567216, "step": 5740, "value": 0.0002500000118743628}, {"wallTime": 1733073047.8400648, "step": 5750, "value": 0.0002500000118743628}, {"wallTime": 1733073056.1537797, "step": 5760, "value": 0.0002500000118743628}, {"wallTime": 1733073064.9524546, "step": 5770, "value": 0.0002500000118743628}, {"wallTime": 1733073073.834839, "step": 5780, "value": 0.0002500000118743628}, {"wallTime": 1733073082.722118, "step": 5790, "value": 0.0002500000118743628}, {"wallTime": 1733073095.1007786, "step": 5800, "value": 0.0002500000118743628}, {"wallTime": 1733073103.313038, "step": 5810, "value": 0.0002500000118743628}, {"wallTime": 1733073111.9677594, "step": 5820, "value": 0.0002500000118743628}, {"wallTime": 1733073120.3524945, "step": 5830, "value": 0.0002500000118743628}, {"wallTime": 1733073128.2066202, "step": 5840, "value": 0.0002500000118743628}, {"wallTime": 1733073136.7131252, "step": 5850, "value": 0.0002500000118743628}, {"wallTime": 1733073144.9252386, "step": 5860, "value": 0.0002500000118743628}, {"wallTime": 1733073153.037857, "step": 5870, "value": 0.0002500000118743628}, {"wallTime": 1733073166.0004127, "step": 5880, "value": 0.0002500000118743628}, {"wallTime": 1733073174.6561458, "step": 5890, "value": 0.0002500000118743628}, {"wallTime": 1733073182.5057242, "step": 5900, "value": 0.0002500000118743628}, {"wallTime": 1733073191.556986, "step": 5910, "value": 0.0002500000118743628}, {"wallTime": 1733073199.4076214, "step": 5920, "value": 0.0002500000118743628}, {"wallTime": 1733073207.46272, "step": 5930, "value": 0.0002500000118743628}, {"wallTime": 1733073215.6002555, "step": 5940, "value": 0.0002500000118743628}, {"wallTime": 1733073224.3555994, "step": 5950, "value": 0.0002500000118743628}, {"wallTime": 1733073232.8739445, "step": 5960, "value": 0.0002500000118743628}, {"wallTime": 1733073245.3717833, "step": 5970, "value": 0.0002500000118743628}, {"wallTime": 1733073253.177035, "step": 5980, "value": 0.0002500000118743628}, {"wallTime": 1733073261.769608, "step": 5990, "value": 0.0002500000118743628}, {"wallTime": 1733073270.0574448, "step": 6000, "value": 0.0002500000118743628}, {"wallTime": 1733073278.892901, "step": 6010, "value": 0.0002500000118743628}, {"wallTime": 1733073287.6797755, "step": 6020, "value": 0.0002500000118743628}, {"wallTime": 1733073297.2721484, "step": 6030, "value": 0.0002500000118743628}, {"wallTime": 1733073305.9157994, "step": 6040, "value": 0.0002500000118743628}, {"wallTime": 1733073322.352921, "step": 6050, "value": 0.0002500000118743628}, {"wallTime": 1733073331.9748921, "step": 6060, "value": 0.0002500000118743628}, {"wallTime": 1733073340.5198076, "step": 6070, "value": 0.0002500000118743628}, {"wallTime": 1733073349.5995095, "step": 6080, "value": 0.0002500000118743628}, {"wallTime": 1733073359.0686038, "step": 6090, "value": 0.0002500000118743628}, {"wallTime": 1733073368.4004743, "step": 6100, "value": 0.0002500000118743628}, {"wallTime": 1733073377.6726096, "step": 6110, "value": 0.0002500000118743628}, {"wallTime": 1733073386.3978763, "step": 6120, "value": 0.0002500000118743628}, {"wallTime": 1733073395.449142, "step": 6130, "value": 0.0002500000118743628}, {"wallTime": 1733073408.149441, "step": 6140, "value": 0.0002500000118743628}, {"wallTime": 1733073417.3213625, "step": 6150, "value": 0.0002500000118743628}, {"wallTime": 1733073426.253231, "step": 6160, "value": 0.0002500000118743628}, {"wallTime": 1733073434.8067446, "step": 6170, "value": 0.0002500000118743628}, {"wallTime": 1733073444.5102363, "step": 6180, "value": 0.0002500000118743628}, {"wallTime": 1733073453.1128645, "step": 6190, "value": 0.0002500000118743628}, {"wallTime": 1733073462.5631638, "step": 6200, "value": 0.0002500000118743628}, {"wallTime": 1733073472.0218315, "step": 6210, "value": 0.0002500000118743628}, {"wallTime": 1733073484.44636, "step": 6220, "value": 0.0002500000118743628}, {"wallTime": 1733073493.6576023, "step": 6230, "value": 0.0002500000118743628}, {"wallTime": 1733073502.438591, "step": 6240, "value": 0.0002500000118743628}, {"wallTime": 1733073511.2533388, "step": 6250, "value": 0.0002500000118743628}, {"wallTime": 1733073520.48261, "step": 6260, "value": 0.0002500000118743628}, {"wallTime": 1733073529.7790525, "step": 6270, "value": 0.0002500000118743628}, {"wallTime": 1733073539.636764, "step": 6280, "value": 0.0002500000118743628}, {"wallTime": 1733073548.908222, "step": 6290, "value": 0.0002500000118743628}, {"wallTime": 1733073560.617814, "step": 6300, "value": 0.0002500000118743628}, {"wallTime": 1733073570.066469, "step": 6310, "value": 0.0002500000118743628}, {"wallTime": 1733073579.4786596, "step": 6320, "value": 0.0002500000118743628}, {"wallTime": 1733073587.664711, "step": 6330, "value": 0.0002500000118743628}, {"wallTime": 1733073597.215544, "step": 6340, "value": 0.0002500000118743628}, {"wallTime": 1733073606.2357554, "step": 6350, "value": 0.0002500000118743628}, {"wallTime": 1733073615.0751185, "step": 6360, "value": 0.0002500000118743628}, {"wallTime": 1733073624.832105, "step": 6370, "value": 0.0002500000118743628}, {"wallTime": 1733073634.6700637, "step": 6380, "value": 0.0002500000118743628}, {"wallTime": 1733073646.526276, "step": 6390, "value": 0.0002500000118743628}, {"wallTime": 1733073655.743021, "step": 6400, "value": 0.0002500000118743628}, {"wallTime": 1733073665.6047978, "step": 6410, "value": 0.0002500000118743628}, {"wallTime": 1733073674.6403363, "step": 6420, "value": 0.0002500000118743628}, {"wallTime": 1733073683.6679225, "step": 6430, "value": 0.0002500000118743628}, {"wallTime": 1733073692.874311, "step": 6440, "value": 0.0002500000118743628}, {"wallTime": 1733073702.516739, "step": 6450, "value": 0.0002500000118743628}, {"wallTime": 1733073712.6249824, "step": 6460, "value": 0.0002500000118743628}, {"wallTime": 1733073724.0450606, "step": 6470, "value": 0.0002500000118743628}, {"wallTime": 1733073732.8259587, "step": 6480, "value": 0.0002500000118743628}, {"wallTime": 1733073741.9547262, "step": 6490, "value": 0.0002500000118743628}, {"wallTime": 1733073750.715291, "step": 6500, "value": 0.0002500000118743628}, {"wallTime": 1733073760.4857268, "step": 6510, "value": 0.0002500000118743628}, {"wallTime": 1733073769.8608427, "step": 6520, "value": 0.0002500000118743628}, {"wallTime": 1733073779.124714, "step": 6530, "value": 0.0002500000118743628}, {"wallTime": 1733073789.475315, "step": 6540, "value": 0.0002500000118743628}, {"wallTime": 1733073798.1009488, "step": 6550, "value": 0.0002500000118743628}, {"wallTime": 1733073810.5509205, "step": 6560, "value": 0.0002500000118743628}, {"wallTime": 1733073820.0339057, "step": 6570, "value": 0.0002500000118743628}, {"wallTime": 1733073828.2359116, "step": 6580, "value": 0.0002500000118743628}, {"wallTime": 1733073836.7958264, "step": 6590, "value": 0.0002500000118743628}, {"wallTime": 1733073845.985134, "step": 6600, "value": 0.0002500000118743628}, {"wallTime": 1733073855.2496011, "step": 6610, "value": 0.0002500000118743628}, {"wallTime": 1733073864.6911805, "step": 6620, "value": 0.0002500000118743628}, {"wallTime": 1733073873.8323212, "step": 6630, "value": 0.0002500000118743628}, {"wallTime": 1733073887.5227523, "step": 6640, "value": 0.0002500000118743628}, {"wallTime": 1733073897.3315735, "step": 6650, "value": 0.0002500000118743628}, {"wallTime": 1733073906.8744667, "step": 6660, "value": 0.0002500000118743628}, {"wallTime": 1733073916.3480155, "step": 6670, "value": 0.0002500000118743628}, {"wallTime": 1733073925.6163278, "step": 6680, "value": 0.0002500000118743628}, {"wallTime": 1733073934.9144487, "step": 6690, "value": 0.0002500000118743628}, {"wallTime": 1733073943.740066, "step": 6700, "value": 0.0002500000118743628}, {"wallTime": 1733073952.4749053, "step": 6710, "value": 0.0002500000118743628}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "8646" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_5%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_5", "runToSeries": {".": [{"wallTime": 1733067631.5413737, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.6547234, "step": 10, "value": 0.05347784608602524}, {"wallTime": 1733067660.7867973, "step": 20, "value": 0.04542408511042595}, {"wallTime": 1733067674.1400561, "step": 30, "value": 0.05108048766851425}, {"wallTime": 1733067687.059695, "step": 40, "value": 0.06526210159063339}, {"wallTime": 1733067699.4957654, "step": 50, "value": 0.10036180913448334}, {"wallTime": 1733067710.6319606, "step": 60, "value": 0.08755029737949371}, {"wallTime": 1733067722.7581198, "step": 70, "value": 0.03462652117013931}, {"wallTime": 1733067733.7279058, "step": 80, "value": 0.12450746446847916}, {"wallTime": 1733067750.948823, "step": 90, "value": 0.04494864121079445}, {"wallTime": 1733067761.983496, "step": 100, "value": 0.06692086905241013}, {"wallTime": 1733067771.60892, "step": 110, "value": 0.07100476324558258}, {"wallTime": 1733067780.549924, "step": 120, "value": 0.12651564180850983}, {"wallTime": 1733067790.4880195, "step": 130, "value": 0.05122794210910797}, {"wallTime": 1733067799.1081336, "step": 140, "value": 0.08658525347709656}, {"wallTime": 1733067809.4480078, "step": 150, "value": 0.13995516300201416}, {"wallTime": 1733067818.9232085, "step": 160, "value": 0.06187867000699043}, {"wallTime": 1733067836.6521952, "step": 170, "value": 0.06713108718395233}, {"wallTime": 1733067846.393095, "step": 180, "value": 0.07833882421255112}, {"wallTime": 1733067855.669612, "step": 190, "value": 0.07688968628644943}, {"wallTime": 1733067864.8940606, "step": 200, "value": 0.07955846190452576}, {"wallTime": 1733067874.0044715, "step": 210, "value": 0.06472114473581314}, {"wallTime": 1733067883.7903168, "step": 220, "value": 0.06264929473400116}, {"wallTime": 1733067892.1256642, "step": 230, "value": 0.05724669247865677}, {"wallTime": 1733067901.0718606, "step": 240, "value": 0.10187117755413055}, {"wallTime": 1733067910.0774238, "step": 250, "value": 0.08319167792797089}, {"wallTime": 1733067925.9526207, "step": 260, "value": 0.06234649941325188}, {"wallTime": 1733067935.4782057, "step": 270, "value": 0.05130508914589882}, {"wallTime": 1733067944.0198536, "step": 280, "value": 0.05336274951696396}, {"wallTime": 1733067952.5509734, "step": 290, "value": 0.1208934634923935}, {"wallTime": 1733067961.0293422, "step": 300, "value": 0.10828837752342224}, {"wallTime": 1733067970.1371412, "step": 310, "value": 0.08746173977851868}, {"wallTime": 1733067980.2283688, "step": 320, "value": 0.06028653681278229}, {"wallTime": 1733067988.818558, "step": 330, "value": 0.06775514036417007}, {"wallTime": 1733068005.093224, "step": 340, "value": 0.06316618621349335}, {"wallTime": 1733068014.0678272, "step": 350, "value": 0.02933790720999241}, {"wallTime": 1733068022.5556307, "step": 360, "value": 0.05959209427237511}, {"wallTime": 1733068031.8273098, "step": 370, "value": 0.06290905922651291}, {"wallTime": 1733068040.7904313, "step": 380, "value": 0.05432869866490364}, {"wallTime": 1733068050.1629078, "step": 390, "value": 0.09856481850147247}, {"wallTime": 1733068059.128751, "step": 400, "value": 0.104705311357975}, {"wallTime": 1733068068.092731, "step": 410, "value": 0.11080435663461685}, {"wallTime": 1733068084.846998, "step": 420, "value": 0.0798480361700058}, {"wallTime": 1733068094.6693356, "step": 430, "value": 0.04461841657757759}, {"wallTime": 1733068103.710848, "step": 440, "value": 0.05373779684305191}, {"wallTime": 1733068112.7022398, "step": 450, "value": 0.05593208223581314}, {"wallTime": 1733068121.5038407, "step": 460, "value": 0.04622523486614227}, {"wallTime": 1733068130.73051, "step": 470, "value": 0.06927679479122162}, {"wallTime": 1733068139.8584795, "step": 480, "value": 0.06115708127617836}, {"wallTime": 1733068149.3727484, "step": 490, "value": 0.07210154831409454}, {"wallTime": 1733068158.0728014, "step": 500, "value": 0.07292340695858002}, {"wallTime": 1733068174.1180437, "step": 510, "value": 0.08611492067575455}, {"wallTime": 1733068182.7225025, "step": 520, "value": 0.047480739653110504}, {"wallTime": 1733068192.416604, "step": 530, "value": 0.08095002919435501}, {"wallTime": 1733068201.8338556, "step": 540, "value": 0.0729367733001709}, {"wallTime": 1733068210.6574793, "step": 550, "value": 0.07196083664894104}, {"wallTime": 1733068220.1980379, "step": 560, "value": 0.07507804781198502}, {"wallTime": 1733068229.162357, "step": 570, "value": 0.0782080888748169}, {"wallTime": 1733068238.5944853, "step": 580, "value": 0.06952767074108124}, {"wallTime": 1733068256.0784962, "step": 590, "value": 0.05215022340416908}, {"wallTime": 1733068265.4348838, "step": 600, "value": 0.12192635238170624}, {"wallTime": 1733068274.6594427, "step": 610, "value": 0.05331986024975777}, {"wallTime": 1733068283.7730627, "step": 620, "value": 0.05774565786123276}, {"wallTime": 1733068293.3372018, "step": 630, "value": 0.05836743861436844}, {"wallTime": 1733068302.6501887, "step": 640, "value": 0.07436776161193848}, {"wallTime": 1733068311.3912082, "step": 650, "value": 0.05682958662509918}, {"wallTime": 1733068320.3932056, "step": 660, "value": 0.07240501046180725}, {"wallTime": 1733068328.7345405, "step": 670, "value": 0.07182169705629349}, {"wallTime": 1733068344.464285, "step": 680, "value": 0.080032117664814}, {"wallTime": 1733068353.7199345, "step": 690, "value": 0.050345923751592636}, {"wallTime": 1733068362.0608516, "step": 700, "value": 0.08060914278030396}, {"wallTime": 1733068371.107085, "step": 710, "value": 0.04258348047733307}, {"wallTime": 1733068380.5361793, "step": 720, "value": 0.07643885165452957}, {"wallTime": 1733068390.0896158, "step": 730, "value": 0.04337596893310547}, {"wallTime": 1733068398.7240005, "step": 740, "value": 0.08665859699249268}, {"wallTime": 1733068407.1269948, "step": 750, "value": 0.05905803665518761}, {"wallTime": 1733068423.0762606, "step": 760, "value": 0.06409914791584015}, {"wallTime": 1733068431.4084125, "step": 770, "value": 0.07462890446186066}, {"wallTime": 1733068440.4281225, "step": 780, "value": 0.045258816331624985}, {"wallTime": 1733068449.009742, "step": 790, "value": 0.05970015376806259}, {"wallTime": 1733068457.6428094, "step": 800, "value": 0.040967464447021484}, {"wallTime": 1733068467.0667021, "step": 810, "value": 0.058106064796447754}, {"wallTime": 1733068475.6235754, "step": 820, "value": 0.05948595702648163}, {"wallTime": 1733068484.9820952, "step": 830, "value": 0.0466899499297142}, {"wallTime": 1733068500.7348278, "step": 840, "value": 0.041543811559677124}, {"wallTime": 1733068509.3110552, "step": 850, "value": 0.044095881283283234}, {"wallTime": 1733068519.02578, "step": 860, "value": 0.03563300147652626}, {"wallTime": 1733068527.5018678, "step": 870, "value": 0.060831647366285324}, {"wallTime": 1733068536.9236362, "step": 880, "value": 0.05587875843048096}, {"wallTime": 1733068544.912152, "step": 890, "value": 0.04986610636115074}, {"wallTime": 1733068553.582513, "step": 900, "value": 0.059508852660655975}, {"wallTime": 1733068562.689361, "step": 910, "value": 0.06928755342960358}, {"wallTime": 1733068571.249771, "step": 920, "value": 0.05261273682117462}, {"wallTime": 1733068584.7798562, "step": 930, "value": 0.03978411853313446}, {"wallTime": 1733068593.7767806, "step": 940, "value": 0.06172863394021988}, {"wallTime": 1733068602.770348, "step": 950, "value": 0.02608385682106018}, {"wallTime": 1733068611.0443292, "step": 960, "value": 0.06920969486236572}, {"wallTime": 1733068620.2310207, "step": 970, "value": 0.05166921392083168}, {"wallTime": 1733068628.8462129, "step": 980, "value": 0.04722634702920914}, {"wallTime": 1733068637.6348782, "step": 990, "value": 0.03759410232305527}, {"wallTime": 1733068646.677541, "step": 1000, "value": 0.06459864974021912}, {"wallTime": 1733068662.7618163, "step": 1010, "value": 0.0535544790327549}, {"wallTime": 1733068672.0591106, "step": 1020, "value": 0.050653211772441864}, {"wallTime": 1733068680.5678024, "step": 1030, "value": 0.06585156917572021}, {"wallTime": 1733068690.1907027, "step": 1040, "value": 0.03899834677577019}, {"wallTime": 1733068698.853039, "step": 1050, "value": 0.06281311810016632}, {"wallTime": 1733068707.7481618, "step": 1060, "value": 0.04280824214220047}, {"wallTime": 1733068717.3493385, "step": 1070, "value": 0.0435321070253849}, {"wallTime": 1733068726.366042, "step": 1080, "value": 0.032866623252630234}, {"wallTime": 1733068735.2564127, "step": 1090, "value": 0.04382433742284775}, {"wallTime": 1733068749.5527966, "step": 1100, "value": 0.032943788915872574}, {"wallTime": 1733068758.38011, "step": 1110, "value": 0.054608847945928574}, {"wallTime": 1733068767.0086584, "step": 1120, "value": 0.05971483141183853}, {"wallTime": 1733068776.6236353, "step": 1130, "value": 0.05039718747138977}, {"wallTime": 1733068785.406233, "step": 1140, "value": 0.06384766101837158}, {"wallTime": 1733068794.2839146, "step": 1150, "value": 0.06720618903636932}, {"wallTime": 1733068802.7021139, "step": 1160, "value": 0.06872794777154922}, {"wallTime": 1733068811.5568583, "step": 1170, "value": 0.05468226969242096}, {"wallTime": 1733068824.970525, "step": 1180, "value": 0.04922592639923096}, {"wallTime": 1733068834.3820035, "step": 1190, "value": 0.044639911502599716}, {"wallTime": 1733068843.5209117, "step": 1200, "value": 0.051408134400844574}, {"wallTime": 1733068852.2333324, "step": 1210, "value": 0.04052630811929703}, {"wallTime": 1733068861.1216638, "step": 1220, "value": 0.04066119343042374}, {"wallTime": 1733068870.0605872, "step": 1230, "value": 0.0644284263253212}, {"wallTime": 1733068878.7250874, "step": 1240, "value": 0.06865043938159943}, {"wallTime": 1733068887.7428932, "step": 1250, "value": 0.03830073028802872}, {"wallTime": 1733068903.1715689, "step": 1260, "value": 0.036607060581445694}, {"wallTime": 1733068912.4224367, "step": 1270, "value": 0.051857490092515945}, {"wallTime": 1733068921.480232, "step": 1280, "value": 0.06540394574403763}, {"wallTime": 1733068929.7514162, "step": 1290, "value": 0.04623384028673172}, {"wallTime": 1733068939.5061722, "step": 1300, "value": 0.041573118418455124}, {"wallTime": 1733068948.9328537, "step": 1310, "value": 0.03214329853653908}, {"wallTime": 1733068957.2391393, "step": 1320, "value": 0.060994379222393036}, {"wallTime": 1733068966.0817144, "step": 1330, "value": 0.057965461164712906}, {"wallTime": 1733068975.5700061, "step": 1340, "value": 0.05796365812420845}, {"wallTime": 1733068989.8051372, "step": 1350, "value": 0.030356451869010925}, {"wallTime": 1733068998.2887073, "step": 1360, "value": 0.02885265089571476}, {"wallTime": 1733069007.156237, "step": 1370, "value": 0.03903147578239441}, {"wallTime": 1733069015.9281843, "step": 1380, "value": 0.03634236752986908}, {"wallTime": 1733069025.3080149, "step": 1390, "value": 0.04717621952295303}, {"wallTime": 1733069034.4862356, "step": 1400, "value": 0.05595572292804718}, {"wallTime": 1733069042.7977593, "step": 1410, "value": 0.0599282942712307}, {"wallTime": 1733069052.1423354, "step": 1420, "value": 0.04272891581058502}, {"wallTime": 1733069065.0064266, "step": 1430, "value": 0.0440361425280571}, {"wallTime": 1733069074.5286546, "step": 1440, "value": 0.047478094696998596}, {"wallTime": 1733069083.7872748, "step": 1450, "value": 0.049467846751213074}, {"wallTime": 1733069092.2639444, "step": 1460, "value": 0.056160569190979004}, {"wallTime": 1733069101.034664, "step": 1470, "value": 0.05369752272963524}, {"wallTime": 1733069109.910501, "step": 1480, "value": 0.06341448426246643}, {"wallTime": 1733069119.1224701, "step": 1490, "value": 0.04375160485506058}, {"wallTime": 1733069128.4197361, "step": 1500, "value": 0.05159753933548927}, {"wallTime": 1733069137.6102455, "step": 1510, "value": 0.05934637412428856}, {"wallTime": 1733069150.5471861, "step": 1520, "value": 0.034243352711200714}, {"wallTime": 1733069159.7606146, "step": 1530, "value": 0.04476863145828247}, {"wallTime": 1733069168.174369, "step": 1540, "value": 0.053828559815883636}, {"wallTime": 1733069176.8445616, "step": 1550, "value": 0.05330660939216614}, {"wallTime": 1733069185.8957384, "step": 1560, "value": 0.03486224263906479}, {"wallTime": 1733069194.927916, "step": 1570, "value": 0.061051927506923676}, {"wallTime": 1733069203.918467, "step": 1580, "value": 0.032340582460165024}, {"wallTime": 1733069212.7201383, "step": 1590, "value": 0.03810111805796623}, {"wallTime": 1733069225.5377285, "step": 1600, "value": 0.038112442940473557}, {"wallTime": 1733069235.4674103, "step": 1610, "value": 0.046860311180353165}, {"wallTime": 1733069244.6345239, "step": 1620, "value": 0.04097651317715645}, {"wallTime": 1733069254.2972584, "step": 1630, "value": 0.05023738369345665}, {"wallTime": 1733069263.009039, "step": 1640, "value": 0.047140397131443024}, {"wallTime": 1733069271.870184, "step": 1650, "value": 0.05433069169521332}, {"wallTime": 1733069280.5134423, "step": 1660, "value": 0.09502115845680237}, {"wallTime": 1733069289.6833496, "step": 1670, "value": 0.04705366492271423}, {"wallTime": 1733069303.6148982, "step": 1680, "value": 0.05974993854761124}, {"wallTime": 1733069312.4832094, "step": 1690, "value": 0.04084520787000656}, {"wallTime": 1733069321.8425155, "step": 1700, "value": 0.043547533452510834}, {"wallTime": 1733069330.3514569, "step": 1710, "value": 0.04473138973116875}, {"wallTime": 1733069339.2491786, "step": 1720, "value": 0.03631582111120224}, {"wallTime": 1733069346.8630266, "step": 1730, "value": 0.07561521977186203}, {"wallTime": 1733069355.6581182, "step": 1740, "value": 0.03451135382056236}, {"wallTime": 1733069364.5155518, "step": 1750, "value": 0.06541527807712555}, {"wallTime": 1733069373.7421873, "step": 1760, "value": 0.08768349140882492}, {"wallTime": 1733069387.5446684, "step": 1770, "value": 0.04828450828790665}, {"wallTime": 1733069396.4730952, "step": 1780, "value": 0.06649535894393921}, {"wallTime": 1733069405.9998946, "step": 1790, "value": 0.049229271709918976}, {"wallTime": 1733069415.057386, "step": 1800, "value": 0.042629532516002655}, {"wallTime": 1733069423.9109995, "step": 1810, "value": 0.042473483830690384}, {"wallTime": 1733069432.5346982, "step": 1820, "value": 0.050441280007362366}, {"wallTime": 1733069441.2233572, "step": 1830, "value": 0.040677085518836975}, {"wallTime": 1733069450.0940197, "step": 1840, "value": 0.0343160443007946}, {"wallTime": 1733069463.1107306, "step": 1850, "value": 0.03634493425488472}, {"wallTime": 1733069471.5762007, "step": 1860, "value": 0.031267620623111725}, {"wallTime": 1733069480.5013843, "step": 1870, "value": 0.07234561443328857}, {"wallTime": 1733069489.3881028, "step": 1880, "value": 0.0461878627538681}, {"wallTime": 1733069497.9798882, "step": 1890, "value": 0.05593712627887726}, {"wallTime": 1733069506.818009, "step": 1900, "value": 0.03240714222192764}, {"wallTime": 1733069515.82777, "step": 1910, "value": 0.05009167641401291}, {"wallTime": 1733069524.6396341, "step": 1920, "value": 0.03546890243887901}, {"wallTime": 1733069533.5454314, "step": 1930, "value": 0.05750851705670357}, {"wallTime": 1733069550.4810736, "step": 1940, "value": 0.02405719831585884}, {"wallTime": 1733069558.8311088, "step": 1950, "value": 0.05900149792432785}, {"wallTime": 1733069567.7609596, "step": 1960, "value": 0.039524197578430176}, {"wallTime": 1733069576.3482783, "step": 1970, "value": 0.05078563839197159}, {"wallTime": 1733069585.532196, "step": 1980, "value": 0.048822421580553055}, {"wallTime": 1733069594.3533602, "step": 1990, "value": 0.05135587602853775}, {"wallTime": 1733069602.4047692, "step": 2000, "value": 0.0601138174533844}, {"wallTime": 1733069610.2529695, "step": 2010, "value": 0.05235648155212402}, {"wallTime": 1733069626.6898856, "step": 2020, "value": 0.04810536280274391}, {"wallTime": 1733069635.0339808, "step": 2030, "value": 0.03675886616110802}, {"wallTime": 1733069643.8257136, "step": 2040, "value": 0.05302657186985016}, {"wallTime": 1733069652.1974425, "step": 2050, "value": 0.0561838373541832}, {"wallTime": 1733069660.4565892, "step": 2060, "value": 0.07674233615398407}, {"wallTime": 1733069669.5950644, "step": 2070, "value": 0.03462802246212959}, {"wallTime": 1733069678.7815003, "step": 2080, "value": 0.05182243138551712}, {"wallTime": 1733069686.9479222, "step": 2090, "value": 0.04907951131463051}, {"wallTime": 1733069700.6051807, "step": 2100, "value": 0.036018580198287964}, {"wallTime": 1733069708.7294216, "step": 2110, "value": 0.03886827826499939}, {"wallTime": 1733069717.4513276, "step": 2120, "value": 0.044244080781936646}, {"wallTime": 1733069726.1443214, "step": 2130, "value": 0.03145899251103401}, {"wallTime": 1733069735.0411444, "step": 2140, "value": 0.03257012367248535}, {"wallTime": 1733069743.3091843, "step": 2150, "value": 0.03987235575914383}, {"wallTime": 1733069752.5039198, "step": 2160, "value": 0.04305320233106613}, {"wallTime": 1733069761.454033, "step": 2170, "value": 0.03662395849823952}, {"wallTime": 1733069770.4361997, "step": 2180, "value": 0.05213179066777229}, {"wallTime": 1733069784.3669617, "step": 2190, "value": 0.04312809184193611}, {"wallTime": 1733069793.125482, "step": 2200, "value": 0.03408731520175934}, {"wallTime": 1733069801.6392179, "step": 2210, "value": 0.05407002195715904}, {"wallTime": 1733069810.610851, "step": 2220, "value": 0.03994027152657509}, {"wallTime": 1733069819.3461332, "step": 2230, "value": 0.05815040320158005}, {"wallTime": 1733069827.329025, "step": 2240, "value": 0.04739200696349144}, {"wallTime": 1733069835.8712685, "step": 2250, "value": 0.03459552675485611}, {"wallTime": 1733069844.2389116, "step": 2260, "value": 0.04714670032262802}, {"wallTime": 1733069856.7524538, "step": 2270, "value": 0.06587553024291992}, {"wallTime": 1733069865.2605875, "step": 2280, "value": 0.05848260596394539}, {"wallTime": 1733069874.0088267, "step": 2290, "value": 0.04031447321176529}, {"wallTime": 1733069881.7845519, "step": 2300, "value": 0.046415381133556366}, {"wallTime": 1733069890.4167016, "step": 2310, "value": 0.03143306449055672}, {"wallTime": 1733069898.8795424, "step": 2320, "value": 0.050260983407497406}, {"wallTime": 1733069908.3205147, "step": 2330, "value": 0.03746509552001953}, {"wallTime": 1733069917.4180648, "step": 2340, "value": 0.03720790520310402}, {"wallTime": 1733069925.853634, "step": 2350, "value": 0.03844916447997093}, {"wallTime": 1733069938.707555, "step": 2360, "value": 0.07460607588291168}, {"wallTime": 1733069947.4290457, "step": 2370, "value": 0.029836194589734077}, {"wallTime": 1733069956.2114625, "step": 2380, "value": 0.04456588625907898}, {"wallTime": 1733069964.277652, "step": 2390, "value": 0.07464223355054855}, {"wallTime": 1733069973.3289042, "step": 2400, "value": 0.03244059532880783}, {"wallTime": 1733069981.4349377, "step": 2410, "value": 0.02421245351433754}, {"wallTime": 1733069990.1425824, "step": 2420, "value": 0.047616176307201385}, {"wallTime": 1733069998.8019018, "step": 2430, "value": 0.04165374115109444}, {"wallTime": 1733070012.4585772, "step": 2440, "value": 0.04073236882686615}, {"wallTime": 1733070021.6018445, "step": 2450, "value": 0.03736191242933273}, {"wallTime": 1733070030.1936934, "step": 2460, "value": 0.03698471188545227}, {"wallTime": 1733070039.2219853, "step": 2470, "value": 0.04872102290391922}, {"wallTime": 1733070048.271611, "step": 2480, "value": 0.043440356850624084}, {"wallTime": 1733070056.1584542, "step": 2490, "value": 0.03548650071024895}, {"wallTime": 1733070064.4533458, "step": 2500, "value": 0.027178790420293808}, {"wallTime": 1733070072.5553033, "step": 2510, "value": 0.05635960027575493}, {"wallTime": 1733070087.6597235, "step": 2520, "value": 0.03114483319222927}, {"wallTime": 1733070095.4444203, "step": 2530, "value": 0.026165671646595}, {"wallTime": 1733070103.7717006, "step": 2540, "value": 0.05321064963936806}, {"wallTime": 1733070113.0524771, "step": 2550, "value": 0.04271234571933746}, {"wallTime": 1733070121.0404994, "step": 2560, "value": 0.054527219384908676}, {"wallTime": 1733070129.588234, "step": 2570, "value": 0.038898732513189316}, {"wallTime": 1733070138.3635678, "step": 2580, "value": 0.040802113711833954}, {"wallTime": 1733070147.0900044, "step": 2590, "value": 0.044060394167900085}, {"wallTime": 1733070155.4896393, "step": 2600, "value": 0.03643965721130371}, {"wallTime": 1733070172.5800285, "step": 2610, "value": 0.04647866263985634}, {"wallTime": 1733070181.213877, "step": 2620, "value": 0.03618796169757843}, {"wallTime": 1733070189.6952174, "step": 2630, "value": 0.04643196612596512}, {"wallTime": 1733070198.4018598, "step": 2640, "value": 0.050599355250597}, {"wallTime": 1733070206.7101886, "step": 2650, "value": 0.040045011788606644}, {"wallTime": 1733070215.6026347, "step": 2660, "value": 0.03585273399949074}, {"wallTime": 1733070224.3190453, "step": 2670, "value": 0.04250218719244003}, {"wallTime": 1733070233.5421453, "step": 2680, "value": 0.048607099801301956}, {"wallTime": 1733070246.7609615, "step": 2690, "value": 0.03233065456151962}, {"wallTime": 1733070256.031878, "step": 2700, "value": 0.05691808462142944}, {"wallTime": 1733070264.9534318, "step": 2710, "value": 0.03184569627046585}, {"wallTime": 1733070273.8297129, "step": 2720, "value": 0.04544967785477638}, {"wallTime": 1733070282.9618, "step": 2730, "value": 0.04091548174619675}, {"wallTime": 1733070292.280586, "step": 2740, "value": 0.03540005907416344}, {"wallTime": 1733070300.3394632, "step": 2750, "value": 0.054063327610492706}, {"wallTime": 1733070309.4148843, "step": 2760, "value": 0.04825309291481972}, {"wallTime": 1733070317.5342596, "step": 2770, "value": 0.04397693648934364}, {"wallTime": 1733070330.4389775, "step": 2780, "value": 0.04211338236927986}, {"wallTime": 1733070339.8265302, "step": 2790, "value": 0.040867358446121216}, {"wallTime": 1733070347.9981067, "step": 2800, "value": 0.03435993939638138}, {"wallTime": 1733070356.8979135, "step": 2810, "value": 0.04010160267353058}, {"wallTime": 1733070365.5797858, "step": 2820, "value": 0.03425163775682449}, {"wallTime": 1733070374.3964355, "step": 2830, "value": 0.031883809715509415}, {"wallTime": 1733070382.4297779, "step": 2840, "value": 0.05240674316883087}, {"wallTime": 1733070390.944004, "step": 2850, "value": 0.02972882241010666}, {"wallTime": 1733070406.6814833, "step": 2860, "value": 0.06230652704834938}, {"wallTime": 1733070415.0933278, "step": 2870, "value": 0.057752661406993866}, {"wallTime": 1733070422.9229195, "step": 2880, "value": 0.02975083701312542}, {"wallTime": 1733070431.5402765, "step": 2890, "value": 0.033561982214450836}, {"wallTime": 1733070439.9838715, "step": 2900, "value": 0.036167386919260025}, {"wallTime": 1733070448.0883126, "step": 2910, "value": 0.04766976460814476}, {"wallTime": 1733070457.4264684, "step": 2920, "value": 0.03297482058405876}, {"wallTime": 1733070466.7257507, "step": 2930, "value": 0.050900399684906006}, {"wallTime": 1733070479.3354402, "step": 2940, "value": 0.042219728231430054}, {"wallTime": 1733070488.7851512, "step": 2950, "value": 0.029723087325692177}, {"wallTime": 1733070497.2276695, "step": 2960, "value": 0.032354533672332764}, {"wallTime": 1733070505.6365101, "step": 2970, "value": 0.03209041804075241}, {"wallTime": 1733070513.3566287, "step": 2980, "value": 0.05781920999288559}, {"wallTime": 1733070522.3201659, "step": 2990, "value": 0.037677329033613205}, {"wallTime": 1733070530.2153103, "step": 3000, "value": 0.05281979590654373}, {"wallTime": 1733070538.3027034, "step": 3010, "value": 0.03046068549156189}, {"wallTime": 1733070547.4032137, "step": 3020, "value": 0.04433441534638405}, {"wallTime": 1733070564.053925, "step": 3030, "value": 0.038211774080991745}, {"wallTime": 1733070572.3725076, "step": 3040, "value": 0.029860083013772964}, {"wallTime": 1733070580.6740406, "step": 3050, "value": 0.0520709864795208}, {"wallTime": 1733070588.655952, "step": 3060, "value": 0.028968151658773422}, {"wallTime": 1733070597.4235756, "step": 3070, "value": 0.033724039793014526}, {"wallTime": 1733070606.1401334, "step": 3080, "value": 0.06396501511335373}, {"wallTime": 1733070614.4427774, "step": 3090, "value": 0.06009557098150253}, {"wallTime": 1733070624.0031328, "step": 3100, "value": 0.028118614107370377}, {"wallTime": 1733070637.2547576, "step": 3110, "value": 0.04787038266658783}, {"wallTime": 1733070645.6847706, "step": 3120, "value": 0.032372403889894485}, {"wallTime": 1733070654.2723348, "step": 3130, "value": 0.04533514752984047}, {"wallTime": 1733070663.323199, "step": 3140, "value": 0.03713485598564148}, {"wallTime": 1733070671.1197832, "step": 3150, "value": 0.05701431632041931}, {"wallTime": 1733070679.767342, "step": 3160, "value": 0.027019429951906204}, {"wallTime": 1733070687.8475103, "step": 3170, "value": 0.05607619509100914}, {"wallTime": 1733070695.8575296, "step": 3180, "value": 0.030629344284534454}, {"wallTime": 1733070704.6242642, "step": 3190, "value": 0.034518174827098846}, {"wallTime": 1733070717.11062, "step": 3200, "value": 0.046121347695589066}, {"wallTime": 1733070726.100465, "step": 3210, "value": 0.046341389417648315}, {"wallTime": 1733070734.7808666, "step": 3220, "value": 0.04274607449769974}, {"wallTime": 1733070744.4143903, "step": 3230, "value": 0.027923619374632835}, {"wallTime": 1733070752.503396, "step": 3240, "value": 0.039651066064834595}, {"wallTime": 1733070761.7231388, "step": 3250, "value": 0.026314185932278633}, {"wallTime": 1733070770.3992586, "step": 3260, "value": 0.02655554935336113}, {"wallTime": 1733070779.7316637, "step": 3270, "value": 0.034856442362070084}, {"wallTime": 1733070793.6805031, "step": 3280, "value": 0.034102097153663635}, {"wallTime": 1733070801.9017615, "step": 3290, "value": 0.027435513213276863}, {"wallTime": 1733070810.1628578, "step": 3300, "value": 0.026630990207195282}, {"wallTime": 1733070818.7284107, "step": 3310, "value": 0.0377616360783577}, {"wallTime": 1733070827.010897, "step": 3320, "value": 0.043787188827991486}, {"wallTime": 1733070835.5784848, "step": 3330, "value": 0.06379906088113785}, {"wallTime": 1733070843.9787207, "step": 3340, "value": 0.03934447467327118}, {"wallTime": 1733070853.0938966, "step": 3350, "value": 0.05775297433137894}, {"wallTime": 1733070865.4213898, "step": 3360, "value": 0.03042522631585598}, {"wallTime": 1733070873.663359, "step": 3370, "value": 0.03328607976436615}, {"wallTime": 1733070883.3377297, "step": 3380, "value": 0.0346604622900486}, {"wallTime": 1733070892.378711, "step": 3390, "value": 0.03558790683746338}, {"wallTime": 1733070900.7240648, "step": 3400, "value": 0.04642607271671295}, {"wallTime": 1733070908.5058918, "step": 3410, "value": 0.029405344277620316}, {"wallTime": 1733070916.6574867, "step": 3420, "value": 0.04447723180055618}, {"wallTime": 1733070925.2141361, "step": 3430, "value": 0.03413188457489014}, {"wallTime": 1733070933.812041, "step": 3440, "value": 0.03712930530309677}, {"wallTime": 1733070947.4816172, "step": 3450, "value": 0.032258566468954086}, {"wallTime": 1733070956.1895728, "step": 3460, "value": 0.030432334169745445}, {"wallTime": 1733070964.2681856, "step": 3470, "value": 0.09352245926856995}, {"wallTime": 1733070972.38803, "step": 3480, "value": 0.040977902710437775}, {"wallTime": 1733070980.6489367, "step": 3490, "value": 0.041693780571222305}, {"wallTime": 1733070989.689512, "step": 3500, "value": 0.03498924896121025}, {"wallTime": 1733070997.7904942, "step": 3510, "value": 0.051247771829366684}, {"wallTime": 1733071006.2732496, "step": 3520, "value": 0.06353165954351425}, {"wallTime": 1733071018.898036, "step": 3530, "value": 0.04141877591609955}, {"wallTime": 1733071027.1992147, "step": 3540, "value": 0.02343815751373768}, {"wallTime": 1733071035.3227892, "step": 3550, "value": 0.05006043612957001}, {"wallTime": 1733071043.7476408, "step": 3560, "value": 0.03260800614953041}, {"wallTime": 1733071051.874178, "step": 3570, "value": 0.04636480659246445}, {"wallTime": 1733071060.498087, "step": 3580, "value": 0.03979693725705147}, {"wallTime": 1733071068.8814862, "step": 3590, "value": 0.04639647156000137}, {"wallTime": 1733071077.7149963, "step": 3600, "value": 0.03991854935884476}, {"wallTime": 1733071086.2144015, "step": 3610, "value": 0.03828781470656395}, {"wallTime": 1733071101.6607754, "step": 3620, "value": 0.03932042047381401}, {"wallTime": 1733071109.6246247, "step": 3630, "value": 0.047946106642484665}, {"wallTime": 1733071118.1312394, "step": 3640, "value": 0.035260945558547974}, {"wallTime": 1733071126.9951124, "step": 3650, "value": 0.03227844089269638}, {"wallTime": 1733071135.8293633, "step": 3660, "value": 0.04373561590909958}, {"wallTime": 1733071144.2504752, "step": 3670, "value": 0.03767068311572075}, {"wallTime": 1733071152.96644, "step": 3680, "value": 0.03359159082174301}, {"wallTime": 1733071160.6054058, "step": 3690, "value": 0.03356074541807175}, {"wallTime": 1733071173.7523727, "step": 3700, "value": 0.03720507025718689}, {"wallTime": 1733071182.885256, "step": 3710, "value": 0.030078090727329254}, {"wallTime": 1733071191.2122478, "step": 3720, "value": 0.058594368398189545}, {"wallTime": 1733071200.3354197, "step": 3730, "value": 0.02430201694369316}, {"wallTime": 1733071208.367737, "step": 3740, "value": 0.026671094819903374}, {"wallTime": 1733071216.5740063, "step": 3750, "value": 0.053991448134183884}, {"wallTime": 1733071224.6638377, "step": 3760, "value": 0.026207519695162773}, {"wallTime": 1733071232.8627918, "step": 3770, "value": 0.05486682802438736}, {"wallTime": 1733071248.5356658, "step": 3780, "value": 0.02751835435628891}, {"wallTime": 1733071257.393797, "step": 3790, "value": 0.03267974033951759}, {"wallTime": 1733071265.5694191, "step": 3800, "value": 0.032565273344516754}, {"wallTime": 1733071274.2002077, "step": 3810, "value": 0.03357095643877983}, {"wallTime": 1733071283.0200036, "step": 3820, "value": 0.033224258571863174}, {"wallTime": 1733071291.7318816, "step": 3830, "value": 0.03163978084921837}, {"wallTime": 1733071299.8962855, "step": 3840, "value": 0.029569556936621666}, {"wallTime": 1733071308.481652, "step": 3850, "value": 0.04434419423341751}, {"wallTime": 1733071316.9537563, "step": 3860, "value": 0.037982337176799774}, {"wallTime": 1733071330.217467, "step": 3870, "value": 0.040488116443157196}, {"wallTime": 1733071338.9910882, "step": 3880, "value": 0.04322480037808418}, {"wallTime": 1733071347.739014, "step": 3890, "value": 0.025713570415973663}, {"wallTime": 1733071357.037216, "step": 3900, "value": 0.03168780729174614}, {"wallTime": 1733071365.2276318, "step": 3910, "value": 0.06034977361559868}, {"wallTime": 1733071374.1369157, "step": 3920, "value": 0.04749128594994545}, {"wallTime": 1733071382.8161635, "step": 3930, "value": 0.05040586367249489}, {"wallTime": 1733071391.5706704, "step": 3940, "value": 0.029726380482316017}, {"wallTime": 1733071404.4698055, "step": 3950, "value": 0.028251444920897484}, {"wallTime": 1733071412.3413148, "step": 3960, "value": 0.028809573501348495}, {"wallTime": 1733071421.15995, "step": 3970, "value": 0.042648933827877045}, {"wallTime": 1733071430.1230066, "step": 3980, "value": 0.03391343727707863}, {"wallTime": 1733071438.416477, "step": 3990, "value": 0.047740183770656586}, {"wallTime": 1733071447.731388, "step": 4000, "value": 0.023910922929644585}, {"wallTime": 1733071456.1990385, "step": 4010, "value": 0.07395904511213303}, {"wallTime": 1733071464.751891, "step": 4020, "value": 0.03747253865003586}, {"wallTime": 1733071473.4004917, "step": 4030, "value": 0.035265278071165085}, {"wallTime": 1733071490.2889428, "step": 4040, "value": 0.039112720638513565}, {"wallTime": 1733071498.7141886, "step": 4050, "value": 0.04292737692594528}, {"wallTime": 1733071507.1000326, "step": 4060, "value": 0.0292765274643898}, {"wallTime": 1733071515.0703356, "step": 4070, "value": 0.06655175238847733}, {"wallTime": 1733071523.9093368, "step": 4080, "value": 0.02904863841831684}, {"wallTime": 1733071532.2881742, "step": 4090, "value": 0.03537866845726967}, {"wallTime": 1733071540.9201703, "step": 4100, "value": 0.025676477700471878}, {"wallTime": 1733071549.1793728, "step": 4110, "value": 0.027529116719961166}, {"wallTime": 1733071565.838732, "step": 4120, "value": 0.02754850499331951}, {"wallTime": 1733071573.6344576, "step": 4130, "value": 0.03259873762726784}, {"wallTime": 1733071582.0989957, "step": 4140, "value": 0.043142884969711304}, {"wallTime": 1733071590.025586, "step": 4150, "value": 0.037920329719781876}, {"wallTime": 1733071599.243955, "step": 4160, "value": 0.032645948231220245}, {"wallTime": 1733071608.074704, "step": 4170, "value": 0.03581073507666588}, {"wallTime": 1733071616.1869476, "step": 4180, "value": 0.06248824670910835}, {"wallTime": 1733071626.0858464, "step": 4190, "value": 0.026958884671330452}, {"wallTime": 1733071641.011565, "step": 4200, "value": 0.035147979855537415}, {"wallTime": 1733071649.0438647, "step": 4210, "value": 0.042276740074157715}, {"wallTime": 1733071658.5345976, "step": 4220, "value": 0.040746331214904785}, {"wallTime": 1733071667.969246, "step": 4230, "value": 0.02761922962963581}, {"wallTime": 1733071676.1120253, "step": 4240, "value": 0.026165785267949104}, {"wallTime": 1733071684.381824, "step": 4250, "value": 0.04900428652763367}, {"wallTime": 1733071693.1129377, "step": 4260, "value": 0.023690229281783104}, {"wallTime": 1733071702.1871204, "step": 4270, "value": 0.043032631278038025}, {"wallTime": 1733071710.6343286, "step": 4280, "value": 0.02346501499414444}, {"wallTime": 1733071726.6800156, "step": 4290, "value": 0.03494216501712799}, {"wallTime": 1733071735.2189493, "step": 4300, "value": 0.03908388689160347}, {"wallTime": 1733071742.960364, "step": 4310, "value": 0.03542055934667587}, {"wallTime": 1733071751.5890553, "step": 4320, "value": 0.03057384490966797}, {"wallTime": 1733071760.0385191, "step": 4330, "value": 0.03137221932411194}, {"wallTime": 1733071768.4346356, "step": 4340, "value": 0.03252892568707466}, {"wallTime": 1733071777.4225452, "step": 4350, "value": 0.04368913918733597}, {"wallTime": 1733071785.5505893, "step": 4360, "value": 0.04137402027845383}, {"wallTime": 1733071800.8880472, "step": 4370, "value": 0.03916310518980026}, {"wallTime": 1733071809.2691054, "step": 4380, "value": 0.03137381374835968}, {"wallTime": 1733071817.349788, "step": 4390, "value": 0.06764788925647736}, {"wallTime": 1733071826.43367, "step": 4400, "value": 0.045018039643764496}, {"wallTime": 1733071834.8907995, "step": 4410, "value": 0.04595896601676941}, {"wallTime": 1733071843.450089, "step": 4420, "value": 0.05255097150802612}, {"wallTime": 1733071851.5992694, "step": 4430, "value": 0.03295311704277992}, {"wallTime": 1733071859.9274006, "step": 4440, "value": 0.028337368741631508}, {"wallTime": 1733071868.6764486, "step": 4450, "value": 0.03989368677139282}, {"wallTime": 1733071881.3394635, "step": 4460, "value": 0.033274754881858826}, {"wallTime": 1733071889.6413846, "step": 4470, "value": 0.03502705693244934}, {"wallTime": 1733071898.4241087, "step": 4480, "value": 0.032836463302373886}, {"wallTime": 1733071907.3392816, "step": 4490, "value": 0.04024612158536911}, {"wallTime": 1733071916.2814825, "step": 4500, "value": 0.04426097497344017}, {"wallTime": 1733071925.3519368, "step": 4510, "value": 0.046799685806035995}, {"wallTime": 1733071933.3326414, "step": 4520, "value": 0.04956191033124924}, {"wallTime": 1733071941.4859436, "step": 4530, "value": 0.03586028516292572}, {"wallTime": 1733071954.1725307, "step": 4540, "value": 0.026839179918169975}, {"wallTime": 1733071962.3990817, "step": 4550, "value": 0.030227357521653175}, {"wallTime": 1733071970.516513, "step": 4560, "value": 0.04116952419281006}, {"wallTime": 1733071978.8731337, "step": 4570, "value": 0.030441321432590485}, {"wallTime": 1733071987.713683, "step": 4580, "value": 0.05280251055955887}, {"wallTime": 1733071996.448569, "step": 4590, "value": 0.051920972764492035}, {"wallTime": 1733072004.479145, "step": 4600, "value": 0.019760653376579285}, {"wallTime": 1733072012.7478874, "step": 4610, "value": 0.03205592930316925}, {"wallTime": 1733072025.403476, "step": 4620, "value": 0.04203362017869949}, {"wallTime": 1733072034.1214037, "step": 4630, "value": 0.025267351418733597}, {"wallTime": 1733072043.040907, "step": 4640, "value": 0.03773093968629837}, {"wallTime": 1733072051.7902727, "step": 4650, "value": 0.031115129590034485}, {"wallTime": 1733072060.1111119, "step": 4660, "value": 0.04598280042409897}, {"wallTime": 1733072068.6058655, "step": 4670, "value": 0.05072847381234169}, {"wallTime": 1733072076.8392515, "step": 4680, "value": 0.04029645025730133}, {"wallTime": 1733072085.3785586, "step": 4690, "value": 0.02736518159508705}, {"wallTime": 1733072093.7510688, "step": 4700, "value": 0.039201583713293076}, {"wallTime": 1733072106.9923215, "step": 4710, "value": 0.04271462559700012}, {"wallTime": 1733072115.6678052, "step": 4720, "value": 0.05376184731721878}, {"wallTime": 1733072123.9532313, "step": 4730, "value": 0.04726016893982887}, {"wallTime": 1733072132.2832792, "step": 4740, "value": 0.031119808554649353}, {"wallTime": 1733072140.423302, "step": 4750, "value": 0.060939621180295944}, {"wallTime": 1733072149.0897005, "step": 4760, "value": 0.027103375643491745}, {"wallTime": 1733072157.4143834, "step": 4770, "value": 0.030995143577456474}, {"wallTime": 1733072165.491917, "step": 4780, "value": 0.055362895131111145}, {"wallTime": 1733072179.65341, "step": 4790, "value": 0.035706449300050735}, {"wallTime": 1733072188.3320544, "step": 4800, "value": 0.028586173430085182}, {"wallTime": 1733072196.8494694, "step": 4810, "value": 0.04073787108063698}, {"wallTime": 1733072204.5647018, "step": 4820, "value": 0.03608081862330437}, {"wallTime": 1733072213.102079, "step": 4830, "value": 0.023845916613936424}, {"wallTime": 1733072221.6696248, "step": 4840, "value": 0.02639910951256752}, {"wallTime": 1733072229.8965826, "step": 4850, "value": 0.026472648605704308}, {"wallTime": 1733072238.0586972, "step": 4860, "value": 0.03827964514493942}, {"wallTime": 1733072246.3461845, "step": 4870, "value": 0.025604134425520897}, {"wallTime": 1733072261.2701516, "step": 4880, "value": 0.03563198819756508}, {"wallTime": 1733072269.855436, "step": 4890, "value": 0.03788788989186287}, {"wallTime": 1733072278.88294, "step": 4900, "value": 0.03737052530050278}, {"wallTime": 1733072287.53709, "step": 4910, "value": 0.030058644711971283}, {"wallTime": 1733072295.949906, "step": 4920, "value": 0.03481445834040642}, {"wallTime": 1733072304.357929, "step": 4930, "value": 0.046633027493953705}, {"wallTime": 1733072313.5124164, "step": 4940, "value": 0.03041410818696022}, {"wallTime": 1733072321.3280466, "step": 4950, "value": 0.033809397369623184}, {"wallTime": 1733072337.0277553, "step": 4960, "value": 0.030561817809939384}, {"wallTime": 1733072345.5364165, "step": 4970, "value": 0.026876218616962433}, {"wallTime": 1733072353.432477, "step": 4980, "value": 0.025325000286102295}, {"wallTime": 1733072362.4159474, "step": 4990, "value": 0.04358294606208801}, {"wallTime": 1733072371.7487264, "step": 5000, "value": 0.04408962279558182}, {"wallTime": 1733072380.5324214, "step": 5010, "value": 0.028957456350326538}, {"wallTime": 1733072389.0293033, "step": 5020, "value": 0.040999654680490494}, {"wallTime": 1733072397.7883394, "step": 5030, "value": 0.03059365786612034}, {"wallTime": 1733072411.3017116, "step": 5040, "value": 0.04016260802745819}, {"wallTime": 1733072419.4770498, "step": 5050, "value": 0.03948213532567024}, {"wallTime": 1733072428.3749423, "step": 5060, "value": 0.04699118435382843}, {"wallTime": 1733072437.1201506, "step": 5070, "value": 0.040660277009010315}, {"wallTime": 1733072446.1781683, "step": 5080, "value": 0.049051009118556976}, {"wallTime": 1733072454.4313736, "step": 5090, "value": 0.037000350654125214}, {"wallTime": 1733072462.4133017, "step": 5100, "value": 0.04442160949110985}, {"wallTime": 1733072471.153794, "step": 5110, "value": 0.02888190746307373}, {"wallTime": 1733072478.9495208, "step": 5120, "value": 0.03005838207900524}, {"wallTime": 1733072491.3244984, "step": 5130, "value": 0.04434606432914734}, {"wallTime": 1733072499.2615514, "step": 5140, "value": 0.023482413962483406}, {"wallTime": 1733072507.1148672, "step": 5150, "value": 0.04010673239827156}, {"wallTime": 1733072515.320123, "step": 5160, "value": 0.024995237588882446}, {"wallTime": 1733072523.5207434, "step": 5170, "value": 0.029945150017738342}, {"wallTime": 1733072531.0905042, "step": 5180, "value": 0.024705959483981133}, {"wallTime": 1733072540.027077, "step": 5190, "value": 0.029529539868235588}, {"wallTime": 1733072548.657128, "step": 5200, "value": 0.02918442338705063}, {"wallTime": 1733072561.4204016, "step": 5210, "value": 0.0461660698056221}, {"wallTime": 1733072569.901504, "step": 5220, "value": 0.03576609119772911}, {"wallTime": 1733072578.6840653, "step": 5230, "value": 0.04581356793642044}, {"wallTime": 1733072586.9474206, "step": 5240, "value": 0.03283414989709854}, {"wallTime": 1733072595.0371828, "step": 5250, "value": 0.045606598258018494}, {"wallTime": 1733072603.1763217, "step": 5260, "value": 0.045167386531829834}, {"wallTime": 1733072611.084096, "step": 5270, "value": 0.06701843440532684}, {"wallTime": 1733072619.9597986, "step": 5280, "value": 0.02917364053428173}, {"wallTime": 1733072628.6373713, "step": 5290, "value": 0.026719579473137856}, {"wallTime": 1733072641.3784006, "step": 5300, "value": 0.02678343839943409}, {"wallTime": 1733072649.8613827, "step": 5310, "value": 0.03567999601364136}, {"wallTime": 1733072657.9741342, "step": 5320, "value": 0.033978357911109924}, {"wallTime": 1733072667.032196, "step": 5330, "value": 0.036878667771816254}, {"wallTime": 1733072675.9458785, "step": 5340, "value": 0.025466740131378174}, {"wallTime": 1733072684.2411804, "step": 5350, "value": 0.04069184884428978}, {"wallTime": 1733072691.8608663, "step": 5360, "value": 0.029037268832325935}, {"wallTime": 1733072700.1511598, "step": 5370, "value": 0.03669539839029312}, {"wallTime": 1733072713.1859205, "step": 5380, "value": 0.0341595858335495}, {"wallTime": 1733072721.0275495, "step": 5390, "value": 0.03218122944235802}, {"wallTime": 1733072729.8797476, "step": 5400, "value": 0.04035719484090805}, {"wallTime": 1733072738.3746414, "step": 5410, "value": 0.03586301952600479}, {"wallTime": 1733072746.3854852, "step": 5420, "value": 0.02691853977739811}, {"wallTime": 1733072754.6205153, "step": 5430, "value": 0.033694252371788025}, {"wallTime": 1733072762.5761952, "step": 5440, "value": 0.03667454794049263}, {"wallTime": 1733072771.3634875, "step": 5450, "value": 0.032168369740247726}, {"wallTime": 1733072787.1545613, "step": 5460, "value": 0.03859535604715347}, {"wallTime": 1733072795.8056169, "step": 5470, "value": 0.04518084600567818}, {"wallTime": 1733072804.2448356, "step": 5480, "value": 0.027665752917528152}, {"wallTime": 1733072812.3757763, "step": 5490, "value": 0.0306549072265625}, {"wallTime": 1733072821.1620543, "step": 5500, "value": 0.03140087425708771}, {"wallTime": 1733072830.0253584, "step": 5510, "value": 0.035552941262722015}, {"wallTime": 1733072838.6978278, "step": 5520, "value": 0.03529295697808266}, {"wallTime": 1733072846.9076257, "step": 5530, "value": 0.028366679325699806}, {"wallTime": 1733072855.2512078, "step": 5540, "value": 0.0460791252553463}, {"wallTime": 1733072870.6493518, "step": 5550, "value": 0.034347228705883026}, {"wallTime": 1733072878.7343392, "step": 5560, "value": 0.032919153571128845}, {"wallTime": 1733072886.6156864, "step": 5570, "value": 0.038821689784526825}, {"wallTime": 1733072895.0240304, "step": 5580, "value": 0.03419553488492966}, {"wallTime": 1733072903.405543, "step": 5590, "value": 0.028766881674528122}, {"wallTime": 1733072911.2125173, "step": 5600, "value": 0.030273139476776123}, {"wallTime": 1733072919.842487, "step": 5610, "value": 0.02714936062693596}, {"wallTime": 1733072928.7356122, "step": 5620, "value": 0.0348360501229763}, {"wallTime": 1733072941.7063193, "step": 5630, "value": 0.039146557450294495}, {"wallTime": 1733072949.9828506, "step": 5640, "value": 0.03123088926076889}, {"wallTime": 1733072958.724492, "step": 5650, "value": 0.06887368112802505}, {"wallTime": 1733072966.819313, "step": 5660, "value": 0.032698869705200195}, {"wallTime": 1733072974.96674, "step": 5670, "value": 0.028050575405359268}, {"wallTime": 1733072983.5647001, "step": 5680, "value": 0.04920066148042679}, {"wallTime": 1733072992.2331283, "step": 5690, "value": 0.02814142033457756}, {"wallTime": 1733073000.8198156, "step": 5700, "value": 0.019913019612431526}, {"wallTime": 1733073009.7859085, "step": 5710, "value": 0.048127103596925735}, {"wallTime": 1733073022.8708456, "step": 5720, "value": 0.04513789713382721}, {"wallTime": 1733073031.5389512, "step": 5730, "value": 0.026048313826322556}, {"wallTime": 1733073039.5753286, "step": 5740, "value": 0.04241889342665672}, {"wallTime": 1733073047.8454494, "step": 5750, "value": 0.030599061399698257}, {"wallTime": 1733073056.1590977, "step": 5760, "value": 0.02827543020248413}, {"wallTime": 1733073064.9576545, "step": 5770, "value": 0.04315929114818573}, {"wallTime": 1733073073.8402796, "step": 5780, "value": 0.03719346597790718}, {"wallTime": 1733073082.7277224, "step": 5790, "value": 0.02843579463660717}, {"wallTime": 1733073095.1056414, "step": 5800, "value": 0.04683735966682434}, {"wallTime": 1733073103.318427, "step": 5810, "value": 0.02750260941684246}, {"wallTime": 1733073111.9732826, "step": 5820, "value": 0.026556702330708504}, {"wallTime": 1733073120.3604083, "step": 5830, "value": 0.03670072183012962}, {"wallTime": 1733073128.211914, "step": 5840, "value": 0.03601745143532753}, {"wallTime": 1733073136.71837, "step": 5850, "value": 0.02728208154439926}, {"wallTime": 1733073144.9304233, "step": 5860, "value": 0.05441446229815483}, {"wallTime": 1733073153.045819, "step": 5870, "value": 0.03303144872188568}, {"wallTime": 1733073166.005784, "step": 5880, "value": 0.03480067849159241}, {"wallTime": 1733073174.6617951, "step": 5890, "value": 0.033692386001348495}, {"wallTime": 1733073182.5110223, "step": 5900, "value": 0.049651194363832474}, {"wallTime": 1733073191.5621994, "step": 5910, "value": 0.023352976888418198}, {"wallTime": 1733073199.4161294, "step": 5920, "value": 0.04380614310503006}, {"wallTime": 1733073207.4681888, "step": 5930, "value": 0.026961278170347214}, {"wallTime": 1733073215.6056058, "step": 5940, "value": 0.03105498105287552}, {"wallTime": 1733073224.360917, "step": 5950, "value": 0.026917066425085068}, {"wallTime": 1733073232.880723, "step": 5960, "value": 0.039041634649038315}, {"wallTime": 1733073245.3767664, "step": 5970, "value": 0.04172942042350769}, {"wallTime": 1733073253.1823156, "step": 5980, "value": 0.037048522382974625}, {"wallTime": 1733073261.8046732, "step": 5990, "value": 0.03404268994927406}, {"wallTime": 1733073270.0624964, "step": 6000, "value": 0.03790876641869545}, {"wallTime": 1733073278.899548, "step": 6010, "value": 0.03825732320547104}, {"wallTime": 1733073287.6849737, "step": 6020, "value": 0.039623431861400604}, {"wallTime": 1733073297.277343, "step": 6030, "value": 0.03971800208091736}, {"wallTime": 1733073305.9211302, "step": 6040, "value": 0.03800855949521065}, {"wallTime": 1733073322.3576071, "step": 6050, "value": 0.033220335841178894}, {"wallTime": 1733073331.9802237, "step": 6060, "value": 0.04049815610051155}, {"wallTime": 1733073340.5252602, "step": 6070, "value": 0.032256051898002625}, {"wallTime": 1733073349.6049469, "step": 6080, "value": 0.028628280386328697}, {"wallTime": 1733073359.074227, "step": 6090, "value": 0.0439174547791481}, {"wallTime": 1733073368.4059944, "step": 6100, "value": 0.02688007615506649}, {"wallTime": 1733073377.6780121, "step": 6110, "value": 0.03394129127264023}, {"wallTime": 1733073386.4034722, "step": 6120, "value": 0.030020754784345627}, {"wallTime": 1733073395.4543786, "step": 6130, "value": 0.036773499101400375}, {"wallTime": 1733073408.154248, "step": 6140, "value": 0.02646922692656517}, {"wallTime": 1733073417.3268876, "step": 6150, "value": 0.02848772145807743}, {"wallTime": 1733073426.2615714, "step": 6160, "value": 0.03825591132044792}, {"wallTime": 1733073434.8123963, "step": 6170, "value": 0.035319846123456955}, {"wallTime": 1733073444.5156138, "step": 6180, "value": 0.06309746205806732}, {"wallTime": 1733073453.1212678, "step": 6190, "value": 0.03174474835395813}, {"wallTime": 1733073462.5685802, "step": 6200, "value": 0.030490733683109283}, {"wallTime": 1733073472.0277367, "step": 6210, "value": 0.03721838817000389}, {"wallTime": 1733073484.451297, "step": 6220, "value": 0.032256677746772766}, {"wallTime": 1733073493.662799, "step": 6230, "value": 0.02565743215382099}, {"wallTime": 1733073502.4441078, "step": 6240, "value": 0.040740422904491425}, {"wallTime": 1733073511.2594051, "step": 6250, "value": 0.03655475378036499}, {"wallTime": 1733073520.5125573, "step": 6260, "value": 0.027645893394947052}, {"wallTime": 1733073529.7842093, "step": 6270, "value": 0.03795938566327095}, {"wallTime": 1733073539.6418772, "step": 6280, "value": 0.03187716752290726}, {"wallTime": 1733073548.9138033, "step": 6290, "value": 0.029098980128765106}, {"wallTime": 1733073560.6226077, "step": 6300, "value": 0.03115411102771759}, {"wallTime": 1733073570.0718, "step": 6310, "value": 0.03504757583141327}, {"wallTime": 1733073579.484118, "step": 6320, "value": 0.03549100458621979}, {"wallTime": 1733073587.670183, "step": 6330, "value": 0.032820578664541245}, {"wallTime": 1733073597.2207773, "step": 6340, "value": 0.03568866103887558}, {"wallTime": 1733073606.240973, "step": 6350, "value": 0.031767792999744415}, {"wallTime": 1733073615.0805707, "step": 6360, "value": 0.03413967043161392}, {"wallTime": 1733073624.8372211, "step": 6370, "value": 0.0310825165361166}, {"wallTime": 1733073634.675409, "step": 6380, "value": 0.04111427441239357}, {"wallTime": 1733073646.5310476, "step": 6390, "value": 0.031553156673908234}, {"wallTime": 1733073655.748325, "step": 6400, "value": 0.032671090215444565}, {"wallTime": 1733073665.6100621, "step": 6410, "value": 0.030880507081747055}, {"wallTime": 1733073674.6455514, "step": 6420, "value": 0.029398465529084206}, {"wallTime": 1733073683.6732287, "step": 6430, "value": 0.03542989492416382}, {"wallTime": 1733073692.8796375, "step": 6440, "value": 0.03252054750919342}, {"wallTime": 1733073702.5220354, "step": 6450, "value": 0.031965769827365875}, {"wallTime": 1733073712.6301699, "step": 6460, "value": 0.031226985156536102}, {"wallTime": 1733073724.0504253, "step": 6470, "value": 0.025912711396813393}, {"wallTime": 1733073732.831254, "step": 6480, "value": 0.04200644791126251}, {"wallTime": 1733073741.9608169, "step": 6490, "value": 0.03839590400457382}, {"wallTime": 1733073750.7203808, "step": 6500, "value": 0.05931131914258003}, {"wallTime": 1733073760.490869, "step": 6510, "value": 0.03563285246491432}, {"wallTime": 1733073769.8661811, "step": 6520, "value": 0.030622735619544983}, {"wallTime": 1733073779.153186, "step": 6530, "value": 0.032708629965782166}, {"wallTime": 1733073789.4804611, "step": 6540, "value": 0.03588682785630226}, {"wallTime": 1733073798.106184, "step": 6550, "value": 0.03287484869360924}, {"wallTime": 1733073810.555821, "step": 6560, "value": 0.04871879518032074}, {"wallTime": 1733073820.0393956, "step": 6570, "value": 0.042877551168203354}, {"wallTime": 1733073828.24154, "step": 6580, "value": 0.03218318521976471}, {"wallTime": 1733073836.8011265, "step": 6590, "value": 0.028310146182775497}, {"wallTime": 1733073845.9905403, "step": 6600, "value": 0.034541331231594086}, {"wallTime": 1733073855.2550368, "step": 6610, "value": 0.0335749126970768}, {"wallTime": 1733073864.6965141, "step": 6620, "value": 0.030776003375649452}, {"wallTime": 1733073873.8374205, "step": 6630, "value": 0.027362149208784103}, {"wallTime": 1733073887.5275905, "step": 6640, "value": 0.034329310059547424}, {"wallTime": 1733073897.3371496, "step": 6650, "value": 0.035403184592723846}, {"wallTime": 1733073906.8797383, "step": 6660, "value": 0.045500364154577255}, {"wallTime": 1733073916.353193, "step": 6670, "value": 0.0359695665538311}, {"wallTime": 1733073925.6217742, "step": 6680, "value": 0.029230386018753052}, {"wallTime": 1733073934.9199154, "step": 6690, "value": 0.03402328118681908}, {"wallTime": 1733073943.7455482, "step": 6700, "value": 0.04493296146392822}, {"wallTime": 1733073952.480089, "step": 6710, "value": 0.04401128739118576}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "15045" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Loss/loss_bbox_dn_4%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Loss/loss_bbox_dn_4", "runToSeries": {".": [{"wallTime": 1733067631.5410483, "step": 0, "value": 0.05436157435178757}, {"wallTime": 1733067646.6543863, "step": 10, "value": 0.053492043167352676}, {"wallTime": 1733067660.7864525, "step": 20, "value": 0.0454615093767643}, {"wallTime": 1733067674.1397154, "step": 30, "value": 0.051169052720069885}, {"wallTime": 1733067687.0593555, "step": 40, "value": 0.06545911729335785}, {"wallTime": 1733067699.4954247, "step": 50, "value": 0.10058657824993134}, {"wallTime": 1733067710.6316037, "step": 60, "value": 0.08768133819103241}, {"wallTime": 1733067722.7577744, "step": 70, "value": 0.03460625559091568}, {"wallTime": 1733067733.7275789, "step": 80, "value": 0.12427864968776703}, {"wallTime": 1733067750.948493, "step": 90, "value": 0.04416661709547043}, {"wallTime": 1733067761.9831614, "step": 100, "value": 0.06600657105445862}, {"wallTime": 1733067771.6085727, "step": 110, "value": 0.07098889350891113}, {"wallTime": 1733067780.5495799, "step": 120, "value": 0.12664175033569336}, {"wallTime": 1733067790.4876828, "step": 130, "value": 0.051584482192993164}, {"wallTime": 1733067799.1078029, "step": 140, "value": 0.08716867119073868}, {"wallTime": 1733067809.4475021, "step": 150, "value": 0.13950517773628235}, {"wallTime": 1733067818.9228952, "step": 160, "value": 0.06196673959493637}, {"wallTime": 1733067836.6518056, "step": 170, "value": 0.06659971177577972}, {"wallTime": 1733067846.3927054, "step": 180, "value": 0.07842497527599335}, {"wallTime": 1733067855.6692204, "step": 190, "value": 0.07675199210643768}, {"wallTime": 1733067864.8934908, "step": 200, "value": 0.07954708486795425}, {"wallTime": 1733067874.004144, "step": 210, "value": 0.06462325155735016}, {"wallTime": 1733067883.7897592, "step": 220, "value": 0.06281305849552155}, {"wallTime": 1733067892.1253357, "step": 230, "value": 0.057184092700481415}, {"wallTime": 1733067901.071532, "step": 240, "value": 0.10183814913034439}, {"wallTime": 1733067910.0771008, "step": 250, "value": 0.0835985317826271}, {"wallTime": 1733067925.9522803, "step": 260, "value": 0.06277906894683838}, {"wallTime": 1733067935.4778554, "step": 270, "value": 0.05140148103237152}, {"wallTime": 1733067944.0192838, "step": 280, "value": 0.05350206792354584}, {"wallTime": 1733067952.5504048, "step": 290, "value": 0.12138354778289795}, {"wallTime": 1733067961.0290043, "step": 300, "value": 0.10843223333358765}, {"wallTime": 1733067970.1368105, "step": 310, "value": 0.0877746120095253}, {"wallTime": 1733067980.2280524, "step": 320, "value": 0.06027646362781525}, {"wallTime": 1733067988.8182356, "step": 330, "value": 0.06793221831321716}, {"wallTime": 1733068005.0928814, "step": 340, "value": 0.06324193626642227}, {"wallTime": 1733068014.0674686, "step": 350, "value": 0.02933472767472267}, {"wallTime": 1733068022.5552914, "step": 360, "value": 0.05964384227991104}, {"wallTime": 1733068031.8269625, "step": 370, "value": 0.0631527379155159}, {"wallTime": 1733068040.790103, "step": 380, "value": 0.05437774211168289}, {"wallTime": 1733068050.1625469, "step": 390, "value": 0.0989898294210434}, {"wallTime": 1733068059.128401, "step": 400, "value": 0.10493934154510498}, {"wallTime": 1733068068.0923798, "step": 410, "value": 0.11031164228916168}, {"wallTime": 1733068084.8466606, "step": 420, "value": 0.0798245370388031}, {"wallTime": 1733068094.6690056, "step": 430, "value": 0.044539399445056915}, {"wallTime": 1733068103.7104945, "step": 440, "value": 0.05393720418214798}, {"wallTime": 1733068112.7019095, "step": 450, "value": 0.05601560324430466}, {"wallTime": 1733068121.503486, "step": 460, "value": 0.046386800706386566}, {"wallTime": 1733068130.730187, "step": 470, "value": 0.06923477351665497}, {"wallTime": 1733068139.858151, "step": 480, "value": 0.06116907298564911}, {"wallTime": 1733068149.3724296, "step": 490, "value": 0.0722808837890625}, {"wallTime": 1733068158.072452, "step": 500, "value": 0.07254188507795334}, {"wallTime": 1733068174.1177032, "step": 510, "value": 0.0862586498260498}, {"wallTime": 1733068182.722167, "step": 520, "value": 0.047665610909461975}, {"wallTime": 1733068192.4162679, "step": 530, "value": 0.0809178426861763}, {"wallTime": 1733068201.8333933, "step": 540, "value": 0.07303236424922943}, {"wallTime": 1733068210.6571574, "step": 550, "value": 0.07246383279561996}, {"wallTime": 1733068220.1977067, "step": 560, "value": 0.07363689690828323}, {"wallTime": 1733068229.1620264, "step": 570, "value": 0.07856752723455429}, {"wallTime": 1733068238.5941727, "step": 580, "value": 0.0695878192782402}, {"wallTime": 1733068256.07791, "step": 590, "value": 0.05222150683403015}, {"wallTime": 1733068265.4345462, "step": 600, "value": 0.12189963459968567}, {"wallTime": 1733068274.659119, "step": 610, "value": 0.053404271602630615}, {"wallTime": 1733068283.7727334, "step": 620, "value": 0.05780193209648132}, {"wallTime": 1733068293.336863, "step": 630, "value": 0.05845624953508377}, {"wallTime": 1733068302.649868, "step": 640, "value": 0.07446281611919403}, {"wallTime": 1733068311.3908658, "step": 650, "value": 0.05694613233208656}, {"wallTime": 1733068320.3928678, "step": 660, "value": 0.07250191271305084}, {"wallTime": 1733068328.7342067, "step": 670, "value": 0.07181918621063232}, {"wallTime": 1733068344.4639657, "step": 680, "value": 0.08006039261817932}, {"wallTime": 1733068353.7195973, "step": 690, "value": 0.05032617598772049}, {"wallTime": 1733068362.060515, "step": 700, "value": 0.08069393038749695}, {"wallTime": 1733068371.1067405, "step": 710, "value": 0.042698364704847336}, {"wallTime": 1733068380.5358634, "step": 720, "value": 0.07648716121912003}, {"wallTime": 1733068390.0892992, "step": 730, "value": 0.043413322418928146}, {"wallTime": 1733068398.7236838, "step": 740, "value": 0.08681207150220871}, {"wallTime": 1733068407.1266687, "step": 750, "value": 0.059120044112205505}, {"wallTime": 1733068423.075699, "step": 760, "value": 0.06407716125249863}, {"wallTime": 1733068431.408098, "step": 770, "value": 0.07468865811824799}, {"wallTime": 1733068440.4277773, "step": 780, "value": 0.04526204615831375}, {"wallTime": 1733068449.009405, "step": 790, "value": 0.05969075486063957}, {"wallTime": 1733068457.6421916, "step": 800, "value": 0.04095645248889923}, {"wallTime": 1733068467.066358, "step": 810, "value": 0.05816430598497391}, {"wallTime": 1733068475.6232457, "step": 820, "value": 0.059492744505405426}, {"wallTime": 1733068484.9817631, "step": 830, "value": 0.04674962908029556}, {"wallTime": 1733068500.7344944, "step": 840, "value": 0.041596606373786926}, {"wallTime": 1733068509.3106987, "step": 850, "value": 0.04407608509063721}, {"wallTime": 1733068519.025378, "step": 860, "value": 0.0356336385011673}, {"wallTime": 1733068527.5015235, "step": 870, "value": 0.0608348548412323}, {"wallTime": 1733068536.9233081, "step": 880, "value": 0.055942222476005554}, {"wallTime": 1733068544.911811, "step": 890, "value": 0.049863774329423904}, {"wallTime": 1733068553.582176, "step": 900, "value": 0.05955533683300018}, {"wallTime": 1733068562.6890333, "step": 910, "value": 0.0693008229136467}, {"wallTime": 1733068571.2494116, "step": 920, "value": 0.052633509039878845}, {"wallTime": 1733068584.7795088, "step": 930, "value": 0.03978171944618225}, {"wallTime": 1733068593.7764206, "step": 940, "value": 0.06175252050161362}, {"wallTime": 1733068602.7700033, "step": 950, "value": 0.026124047115445137}, {"wallTime": 1733068611.0440042, "step": 960, "value": 0.06918744742870331}, {"wallTime": 1733068620.230682, "step": 970, "value": 0.05172371119260788}, {"wallTime": 1733068628.8458717, "step": 980, "value": 0.04722628742456436}, {"wallTime": 1733068637.6345506, "step": 990, "value": 0.03759907931089401}, {"wallTime": 1733068646.6772332, "step": 1000, "value": 0.06474670022726059}, {"wallTime": 1733068662.7614005, "step": 1010, "value": 0.053528618067502975}, {"wallTime": 1733068672.0587764, "step": 1020, "value": 0.050655387341976166}, {"wallTime": 1733068680.567462, "step": 1030, "value": 0.06599181890487671}, {"wallTime": 1733068690.190352, "step": 1040, "value": 0.03900947421789169}, {"wallTime": 1733068698.8527117, "step": 1050, "value": 0.06291777640581131}, {"wallTime": 1733068707.747823, "step": 1060, "value": 0.042802706360816956}, {"wallTime": 1733068717.349018, "step": 1070, "value": 0.04354242980480194}, {"wallTime": 1733068726.3657222, "step": 1080, "value": 0.03286686912178993}, {"wallTime": 1733068735.2561066, "step": 1090, "value": 0.043843332678079605}, {"wallTime": 1733068749.5524445, "step": 1100, "value": 0.032972075045108795}, {"wallTime": 1733068758.3797717, "step": 1110, "value": 0.05463157594203949}, {"wallTime": 1733068767.0083106, "step": 1120, "value": 0.059832897037267685}, {"wallTime": 1733068776.6233046, "step": 1130, "value": 0.0504230298101902}, {"wallTime": 1733068785.405894, "step": 1140, "value": 0.06385409832000732}, {"wallTime": 1733068794.2835608, "step": 1150, "value": 0.0672716498374939}, {"wallTime": 1733068802.701779, "step": 1160, "value": 0.06884538382291794}, {"wallTime": 1733068811.5564666, "step": 1170, "value": 0.05486397445201874}, {"wallTime": 1733068824.9701915, "step": 1180, "value": 0.0492488294839859}, {"wallTime": 1733068834.3816595, "step": 1190, "value": 0.044647883623838425}, {"wallTime": 1733068843.5205681, "step": 1200, "value": 0.05143742635846138}, {"wallTime": 1733068852.2329836, "step": 1210, "value": 0.040552299469709396}, {"wallTime": 1733068861.121335, "step": 1220, "value": 0.0406804159283638}, {"wallTime": 1733068870.0602732, "step": 1230, "value": 0.06448809057474136}, {"wallTime": 1733068878.724751, "step": 1240, "value": 0.06867291778326035}, {"wallTime": 1733068887.7425308, "step": 1250, "value": 0.0382993146777153}, {"wallTime": 1733068903.1712525, "step": 1260, "value": 0.036680854856967926}, {"wallTime": 1733068912.4218597, "step": 1270, "value": 0.05192888528108597}, {"wallTime": 1733068921.4796026, "step": 1280, "value": 0.06548856198787689}, {"wallTime": 1733068929.7510839, "step": 1290, "value": 0.04625660181045532}, {"wallTime": 1733068939.5058293, "step": 1300, "value": 0.04159998893737793}, {"wallTime": 1733068948.9324498, "step": 1310, "value": 0.03215256333351135}, {"wallTime": 1733068957.23881, "step": 1320, "value": 0.06104011461138725}, {"wallTime": 1733068966.0813875, "step": 1330, "value": 0.057970430701971054}, {"wallTime": 1733068975.5696695, "step": 1340, "value": 0.057917945086956024}, {"wallTime": 1733068989.8045266, "step": 1350, "value": 0.030345061793923378}, {"wallTime": 1733068998.288132, "step": 1360, "value": 0.02885255590081215}, {"wallTime": 1733069007.1555717, "step": 1370, "value": 0.03902166336774826}, {"wallTime": 1733069015.927607, "step": 1380, "value": 0.03643045201897621}, {"wallTime": 1733069025.3076675, "step": 1390, "value": 0.04714782536029816}, {"wallTime": 1733069034.4858985, "step": 1400, "value": 0.05592978000640869}, {"wallTime": 1733069042.7974203, "step": 1410, "value": 0.05996324494481087}, {"wallTime": 1733069052.141993, "step": 1420, "value": 0.04272397235035896}, {"wallTime": 1733069065.0060954, "step": 1430, "value": 0.04401523992419243}, {"wallTime": 1733069074.5283222, "step": 1440, "value": 0.047460053116083145}, {"wallTime": 1733069083.7869315, "step": 1450, "value": 0.04944935068488121}, {"wallTime": 1733069092.2634847, "step": 1460, "value": 0.056173957884311676}, {"wallTime": 1733069101.0342796, "step": 1470, "value": 0.05377745255827904}, {"wallTime": 1733069109.9101105, "step": 1480, "value": 0.0633876845240593}, {"wallTime": 1733069119.1221278, "step": 1490, "value": 0.043893229216337204}, {"wallTime": 1733069128.4194036, "step": 1500, "value": 0.0516354963183403}, {"wallTime": 1733069137.6099298, "step": 1510, "value": 0.05929887667298317}, {"wallTime": 1733069150.5468404, "step": 1520, "value": 0.03427477180957794}, {"wallTime": 1733069159.7602851, "step": 1530, "value": 0.04477257281541824}, {"wallTime": 1733069168.1739945, "step": 1540, "value": 0.0538136288523674}, {"wallTime": 1733069176.8442342, "step": 1550, "value": 0.05325502157211304}, {"wallTime": 1733069185.8954093, "step": 1560, "value": 0.03484417125582695}, {"wallTime": 1733069194.9275067, "step": 1570, "value": 0.06113966926932335}, {"wallTime": 1733069203.917908, "step": 1580, "value": 0.03235400468111038}, {"wallTime": 1733069212.7197123, "step": 1590, "value": 0.03812183439731598}, {"wallTime": 1733069225.5373745, "step": 1600, "value": 0.03811879828572273}, {"wallTime": 1733069235.4670968, "step": 1610, "value": 0.046857766807079315}, {"wallTime": 1733069244.6340013, "step": 1620, "value": 0.04097766801714897}, {"wallTime": 1733069254.2969193, "step": 1630, "value": 0.05026064068078995}, {"wallTime": 1733069263.008674, "step": 1640, "value": 0.04718845337629318}, {"wallTime": 1733069271.8698628, "step": 1650, "value": 0.05432271212339401}, {"wallTime": 1733069280.5131044, "step": 1660, "value": 0.09516321122646332}, {"wallTime": 1733069289.683026, "step": 1670, "value": 0.047071658074855804}, {"wallTime": 1733069303.6143901, "step": 1680, "value": 0.05975859612226486}, {"wallTime": 1733069312.482877, "step": 1690, "value": 0.04086025059223175}, {"wallTime": 1733069321.8421023, "step": 1700, "value": 0.04356549680233002}, {"wallTime": 1733069330.3511274, "step": 1710, "value": 0.04466325417160988}, {"wallTime": 1733069339.2487495, "step": 1720, "value": 0.03630686178803444}, {"wallTime": 1733069346.8624418, "step": 1730, "value": 0.07561876624822617}, {"wallTime": 1733069355.6577687, "step": 1740, "value": 0.034513503313064575}, {"wallTime": 1733069364.5152285, "step": 1750, "value": 0.06544976681470871}, {"wallTime": 1733069373.741861, "step": 1760, "value": 0.08770574629306793}, {"wallTime": 1733069387.544345, "step": 1770, "value": 0.048328232020139694}, {"wallTime": 1733069396.4724834, "step": 1780, "value": 0.06641072034835815}, {"wallTime": 1733069405.9994848, "step": 1790, "value": 0.04937540367245674}, {"wallTime": 1733069415.057045, "step": 1800, "value": 0.042663514614105225}, {"wallTime": 1733069423.910669, "step": 1810, "value": 0.042474135756492615}, {"wallTime": 1733069432.534361, "step": 1820, "value": 0.05046801641583443}, {"wallTime": 1733069441.2228043, "step": 1830, "value": 0.04068281129002571}, {"wallTime": 1733069450.0934343, "step": 1840, "value": 0.03433625027537346}, {"wallTime": 1733069463.1103601, "step": 1850, "value": 0.03637339174747467}, {"wallTime": 1733069471.5758564, "step": 1860, "value": 0.03127928823232651}, {"wallTime": 1733069480.5010636, "step": 1870, "value": 0.07239574193954468}, {"wallTime": 1733069489.3877573, "step": 1880, "value": 0.04617404192686081}, {"wallTime": 1733069497.979542, "step": 1890, "value": 0.055940210819244385}, {"wallTime": 1733069506.817671, "step": 1900, "value": 0.032425254583358765}, {"wallTime": 1733069515.8274353, "step": 1910, "value": 0.05009763687849045}, {"wallTime": 1733069524.63932, "step": 1920, "value": 0.03549708425998688}, {"wallTime": 1733069533.545096, "step": 1930, "value": 0.05755649879574776}, {"wallTime": 1733069550.4807377, "step": 1940, "value": 0.024073898792266846}, {"wallTime": 1733069558.8307853, "step": 1950, "value": 0.058972831815481186}, {"wallTime": 1733069567.7606099, "step": 1960, "value": 0.03955110162496567}, {"wallTime": 1733069576.347937, "step": 1970, "value": 0.05083836615085602}, {"wallTime": 1733069585.531869, "step": 1980, "value": 0.04882197082042694}, {"wallTime": 1733069594.353036, "step": 1990, "value": 0.051342375576496124}, {"wallTime": 1733069602.404417, "step": 2000, "value": 0.06011459231376648}, {"wallTime": 1733069610.252631, "step": 2010, "value": 0.05234841629862785}, {"wallTime": 1733069626.689542, "step": 2020, "value": 0.048127662390470505}, {"wallTime": 1733069635.0336256, "step": 2030, "value": 0.03673407435417175}, {"wallTime": 1733069643.825373, "step": 2040, "value": 0.053006429225206375}, {"wallTime": 1733069652.1971266, "step": 2050, "value": 0.05619873106479645}, {"wallTime": 1733069660.456247, "step": 2060, "value": 0.0767570212483406}, {"wallTime": 1733069669.5947342, "step": 2070, "value": 0.0346190519630909}, {"wallTime": 1733069678.781161, "step": 2080, "value": 0.051810599863529205}, {"wallTime": 1733069686.9475725, "step": 2090, "value": 0.049085699021816254}, {"wallTime": 1733069700.6048503, "step": 2100, "value": 0.036006052047014236}, {"wallTime": 1733069708.7290986, "step": 2110, "value": 0.038887687027454376}, {"wallTime": 1733069717.450994, "step": 2120, "value": 0.04428422451019287}, {"wallTime": 1733069726.1439953, "step": 2130, "value": 0.031504906713962555}, {"wallTime": 1733069735.0407565, "step": 2140, "value": 0.032558564096689224}, {"wallTime": 1733069743.3087678, "step": 2150, "value": 0.039969462901353836}, {"wallTime": 1733069752.5035486, "step": 2160, "value": 0.04297899082303047}, {"wallTime": 1733069761.4536934, "step": 2170, "value": 0.036608390510082245}, {"wallTime": 1733069770.435859, "step": 2180, "value": 0.05213940143585205}, {"wallTime": 1733069784.3665528, "step": 2190, "value": 0.04314158111810684}, {"wallTime": 1733069793.1251435, "step": 2200, "value": 0.03409654274582863}, {"wallTime": 1733069801.6388748, "step": 2210, "value": 0.05409017205238342}, {"wallTime": 1733069810.610483, "step": 2220, "value": 0.0399019718170166}, {"wallTime": 1733069819.345678, "step": 2230, "value": 0.05820439010858536}, {"wallTime": 1733069827.3286777, "step": 2240, "value": 0.047365497797727585}, {"wallTime": 1733069835.8708854, "step": 2250, "value": 0.034599561244249344}, {"wallTime": 1733069844.2385435, "step": 2260, "value": 0.04714298993349075}, {"wallTime": 1733069856.752109, "step": 2270, "value": 0.06593552231788635}, {"wallTime": 1733069865.2601783, "step": 2280, "value": 0.05852318927645683}, {"wallTime": 1733069874.0084705, "step": 2290, "value": 0.040330346673727036}, {"wallTime": 1733069881.7842329, "step": 2300, "value": 0.04647671431303024}, {"wallTime": 1733069890.416373, "step": 2310, "value": 0.03143300861120224}, {"wallTime": 1733069898.8792062, "step": 2320, "value": 0.050274141132831573}, {"wallTime": 1733069908.3201919, "step": 2330, "value": 0.03751295059919357}, {"wallTime": 1733069917.417731, "step": 2340, "value": 0.03722057491540909}, {"wallTime": 1733069925.853319, "step": 2350, "value": 0.038466937839984894}, {"wallTime": 1733069938.7069738, "step": 2360, "value": 0.07461019605398178}, {"wallTime": 1733069947.4286928, "step": 2370, "value": 0.029829710721969604}, {"wallTime": 1733069956.210902, "step": 2380, "value": 0.04460472986102104}, {"wallTime": 1733069964.2773206, "step": 2390, "value": 0.07468776404857635}, {"wallTime": 1733069973.328559, "step": 2400, "value": 0.032464105635881424}, {"wallTime": 1733069981.4345856, "step": 2410, "value": 0.024222582578659058}, {"wallTime": 1733069990.1422234, "step": 2420, "value": 0.04760870710015297}, {"wallTime": 1733069998.8014545, "step": 2430, "value": 0.04167809709906578}, {"wallTime": 1733070012.4582586, "step": 2440, "value": 0.04072946310043335}, {"wallTime": 1733070021.6014848, "step": 2450, "value": 0.03737806901335716}, {"wallTime": 1733070030.1933546, "step": 2460, "value": 0.03694228455424309}, {"wallTime": 1733070039.2216659, "step": 2470, "value": 0.04873356223106384}, {"wallTime": 1733070048.2712917, "step": 2480, "value": 0.04342168942093849}, {"wallTime": 1733070056.1581304, "step": 2490, "value": 0.035495854914188385}, {"wallTime": 1733070064.4530127, "step": 2500, "value": 0.02718302607536316}, {"wallTime": 1733070072.5547488, "step": 2510, "value": 0.05642911046743393}, {"wallTime": 1733070087.659365, "step": 2520, "value": 0.031141268089413643}, {"wallTime": 1733070095.4440985, "step": 2530, "value": 0.026171479374170303}, {"wallTime": 1733070103.7713466, "step": 2540, "value": 0.053200628608465195}, {"wallTime": 1733070113.0519423, "step": 2550, "value": 0.042732395231723785}, {"wallTime": 1733070121.0401776, "step": 2560, "value": 0.054489314556121826}, {"wallTime": 1733070129.5877829, "step": 2570, "value": 0.038917575031518936}, {"wallTime": 1733070138.363242, "step": 2580, "value": 0.040833644568920135}, {"wallTime": 1733070147.0896742, "step": 2590, "value": 0.04404423385858536}, {"wallTime": 1733070155.4893212, "step": 2600, "value": 0.036485426127910614}, {"wallTime": 1733070172.5796947, "step": 2610, "value": 0.04647988826036453}, {"wallTime": 1733070181.2135403, "step": 2620, "value": 0.03618490695953369}, {"wallTime": 1733070189.6948564, "step": 2630, "value": 0.04644274339079857}, {"wallTime": 1733070198.401531, "step": 2640, "value": 0.05059434100985527}, {"wallTime": 1733070206.7098622, "step": 2650, "value": 0.040101997554302216}, {"wallTime": 1733070215.60231, "step": 2660, "value": 0.035861048847436905}, {"wallTime": 1733070224.3186984, "step": 2670, "value": 0.04258498549461365}, {"wallTime": 1733070233.5418048, "step": 2680, "value": 0.04862077534198761}, {"wallTime": 1733070246.7606063, "step": 2690, "value": 0.03234679996967316}, {"wallTime": 1733070256.0315435, "step": 2700, "value": 0.05692204087972641}, {"wallTime": 1733070264.9531097, "step": 2710, "value": 0.03185727447271347}, {"wallTime": 1733070273.829363, "step": 2720, "value": 0.04546646401286125}, {"wallTime": 1733070282.961454, "step": 2730, "value": 0.04089858755469322}, {"wallTime": 1733070292.2802606, "step": 2740, "value": 0.03541379049420357}, {"wallTime": 1733070300.3391447, "step": 2750, "value": 0.054058950394392014}, {"wallTime": 1733070309.4145458, "step": 2760, "value": 0.04826348274946213}, {"wallTime": 1733070317.5339286, "step": 2770, "value": 0.044001635164022446}, {"wallTime": 1733070330.4386191, "step": 2780, "value": 0.04214717075228691}, {"wallTime": 1733070339.8261042, "step": 2790, "value": 0.04085147753357887}, {"wallTime": 1733070347.9976006, "step": 2800, "value": 0.03435023874044418}, {"wallTime": 1733070356.8972743, "step": 2810, "value": 0.04011107236146927}, {"wallTime": 1733070365.5794463, "step": 2820, "value": 0.03426196798682213}, {"wallTime": 1733070374.3961034, "step": 2830, "value": 0.03188701346516609}, {"wallTime": 1733070382.4294405, "step": 2840, "value": 0.05238337814807892}, {"wallTime": 1733070390.943685, "step": 2850, "value": 0.029703432694077492}, {"wallTime": 1733070406.681163, "step": 2860, "value": 0.06230044364929199}, {"wallTime": 1733070415.092994, "step": 2870, "value": 0.05775204300880432}, {"wallTime": 1733070422.9225523, "step": 2880, "value": 0.02974599599838257}, {"wallTime": 1733070431.5399354, "step": 2890, "value": 0.03356830030679703}, {"wallTime": 1733070439.9835107, "step": 2900, "value": 0.03616458922624588}, {"wallTime": 1733070448.087995, "step": 2910, "value": 0.047669917345047}, {"wallTime": 1733070457.4261436, "step": 2920, "value": 0.032960787415504456}, {"wallTime": 1733070466.7254055, "step": 2930, "value": 0.05090823024511337}, {"wallTime": 1733070479.3351123, "step": 2940, "value": 0.04221335053443909}, {"wallTime": 1733070488.784808, "step": 2950, "value": 0.029721718281507492}, {"wallTime": 1733070497.2273343, "step": 2960, "value": 0.03235593065619469}, {"wallTime": 1733070505.6361887, "step": 2970, "value": 0.032097361981868744}, {"wallTime": 1733070513.3563151, "step": 2980, "value": 0.05775994062423706}, {"wallTime": 1733070522.3198276, "step": 2990, "value": 0.037683356553316116}, {"wallTime": 1733070530.2149954, "step": 3000, "value": 0.052810169756412506}, {"wallTime": 1733070538.3023598, "step": 3010, "value": 0.030459929257631302}, {"wallTime": 1733070547.4028904, "step": 3020, "value": 0.04432585835456848}, {"wallTime": 1733070564.0535245, "step": 3030, "value": 0.03820214048027992}, {"wallTime": 1733070572.3721833, "step": 3040, "value": 0.02984875813126564}, {"wallTime": 1733070580.6736975, "step": 3050, "value": 0.05208642780780792}, {"wallTime": 1733070588.655603, "step": 3060, "value": 0.02897593192756176}, {"wallTime": 1733070597.4232602, "step": 3070, "value": 0.03369714692234993}, {"wallTime": 1733070606.1397922, "step": 3080, "value": 0.06395800411701202}, {"wallTime": 1733070614.4423668, "step": 3090, "value": 0.060107406228780746}, {"wallTime": 1733070624.002796, "step": 3100, "value": 0.028119154274463654}, {"wallTime": 1733070637.254422, "step": 3110, "value": 0.047879479825496674}, {"wallTime": 1733070645.6844208, "step": 3120, "value": 0.032368384301662445}, {"wallTime": 1733070654.271997, "step": 3130, "value": 0.045332640409469604}, {"wallTime": 1733070663.3228617, "step": 3140, "value": 0.03718060627579689}, {"wallTime": 1733070671.1194513, "step": 3150, "value": 0.05702708289027214}, {"wallTime": 1733070679.7670112, "step": 3160, "value": 0.027017861604690552}, {"wallTime": 1733070687.8471324, "step": 3170, "value": 0.05609710142016411}, {"wallTime": 1733070695.8571925, "step": 3180, "value": 0.030624037608504295}, {"wallTime": 1733070704.623928, "step": 3190, "value": 0.03447488322854042}, {"wallTime": 1733070717.1102984, "step": 3200, "value": 0.046143539249897}, {"wallTime": 1733070726.1001284, "step": 3210, "value": 0.04631034657359123}, {"wallTime": 1733070734.780303, "step": 3220, "value": 0.04294508695602417}, {"wallTime": 1733070744.4140053, "step": 3230, "value": 0.02793312259018421}, {"wallTime": 1733070752.5030732, "step": 3240, "value": 0.03965437784790993}, {"wallTime": 1733070761.7228024, "step": 3250, "value": 0.026316259056329727}, {"wallTime": 1733070770.378085, "step": 3260, "value": 0.026553606614470482}, {"wallTime": 1733070779.7313461, "step": 3270, "value": 0.034868404269218445}, {"wallTime": 1733070793.6800828, "step": 3280, "value": 0.03411014378070831}, {"wallTime": 1733070801.9014292, "step": 3290, "value": 0.027438124641776085}, {"wallTime": 1733070810.1625063, "step": 3300, "value": 0.02664363756775856}, {"wallTime": 1733070818.7280743, "step": 3310, "value": 0.03777085617184639}, {"wallTime": 1733070827.010339, "step": 3320, "value": 0.043772272765636444}, {"wallTime": 1733070835.5779312, "step": 3330, "value": 0.06381838023662567}, {"wallTime": 1733070843.9781306, "step": 3340, "value": 0.03932703286409378}, {"wallTime": 1733070853.0935018, "step": 3350, "value": 0.05773424729704857}, {"wallTime": 1733070865.4210606, "step": 3360, "value": 0.03044077381491661}, {"wallTime": 1733070873.663049, "step": 3370, "value": 0.03331859037280083}, {"wallTime": 1733070883.3373878, "step": 3380, "value": 0.03466062992811203}, {"wallTime": 1733070892.3783844, "step": 3390, "value": 0.035595908761024475}, {"wallTime": 1733070900.723747, "step": 3400, "value": 0.04642697423696518}, {"wallTime": 1733070908.505554, "step": 3410, "value": 0.029407214373350143}, {"wallTime": 1733070916.6571648, "step": 3420, "value": 0.04449424892663956}, {"wallTime": 1733070925.2134922, "step": 3430, "value": 0.034156426787376404}, {"wallTime": 1733070933.811702, "step": 3440, "value": 0.03712489828467369}, {"wallTime": 1733070947.4812832, "step": 3450, "value": 0.03226092457771301}, {"wallTime": 1733070956.1891787, "step": 3460, "value": 0.03042798861861229}, {"wallTime": 1733070964.267859, "step": 3470, "value": 0.09337853640317917}, {"wallTime": 1733070972.3876705, "step": 3480, "value": 0.04098392650485039}, {"wallTime": 1733070980.6485887, "step": 3490, "value": 0.041656944900751114}, {"wallTime": 1733070989.6891837, "step": 3500, "value": 0.034986335784196854}, {"wallTime": 1733070997.790164, "step": 3510, "value": 0.05132025107741356}, {"wallTime": 1733071006.2729132, "step": 3520, "value": 0.06351660937070847}, {"wallTime": 1733071018.897688, "step": 3530, "value": 0.041418857872486115}, {"wallTime": 1733071027.1988754, "step": 3540, "value": 0.023441359400749207}, {"wallTime": 1733071035.3223875, "step": 3550, "value": 0.05007225275039673}, {"wallTime": 1733071043.7473247, "step": 3560, "value": 0.03260120376944542}, {"wallTime": 1733071051.8738227, "step": 3570, "value": 0.04657343775033951}, {"wallTime": 1733071060.4977481, "step": 3580, "value": 0.039812121540308}, {"wallTime": 1733071068.8811436, "step": 3590, "value": 0.04641249030828476}, {"wallTime": 1733071077.7146606, "step": 3600, "value": 0.03992210328578949}, {"wallTime": 1733071086.214067, "step": 3610, "value": 0.03827560693025589}, {"wallTime": 1733071101.660412, "step": 3620, "value": 0.03931296989321709}, {"wallTime": 1733071109.6240764, "step": 3630, "value": 0.04797592759132385}, {"wallTime": 1733071118.1309016, "step": 3640, "value": 0.035259414464235306}, {"wallTime": 1733071126.994791, "step": 3650, "value": 0.032287511974573135}, {"wallTime": 1733071135.829028, "step": 3660, "value": 0.04377958923578262}, {"wallTime": 1733071144.2501369, "step": 3670, "value": 0.037645116448402405}, {"wallTime": 1733071152.96613, "step": 3680, "value": 0.03358769789338112}, {"wallTime": 1733071160.6050873, "step": 3690, "value": 0.03358146548271179}, {"wallTime": 1733071173.7520251, "step": 3700, "value": 0.03718256950378418}, {"wallTime": 1733071182.884932, "step": 3710, "value": 0.030075687915086746}, {"wallTime": 1733071191.2119102, "step": 3720, "value": 0.05860607326030731}, {"wallTime": 1733071200.335093, "step": 3730, "value": 0.024323664605617523}, {"wallTime": 1733071208.3673959, "step": 3740, "value": 0.026676859706640244}, {"wallTime": 1733071216.5736666, "step": 3750, "value": 0.0539848767220974}, {"wallTime": 1733071224.6635103, "step": 3760, "value": 0.02620677277445793}, {"wallTime": 1733071232.8624299, "step": 3770, "value": 0.054859522730112076}, {"wallTime": 1733071248.5352921, "step": 3780, "value": 0.027531366795301437}, {"wallTime": 1733071257.3934429, "step": 3790, "value": 0.03267604485154152}, {"wallTime": 1733071265.569081, "step": 3800, "value": 0.032586172223091125}, {"wallTime": 1733071274.1998675, "step": 3810, "value": 0.03357958048582077}, {"wallTime": 1733071283.0196576, "step": 3820, "value": 0.03322836384177208}, {"wallTime": 1733071291.7315392, "step": 3830, "value": 0.031646765768527985}, {"wallTime": 1733071299.8959558, "step": 3840, "value": 0.029600832611322403}, {"wallTime": 1733071308.481306, "step": 3850, "value": 0.044370148330926895}, {"wallTime": 1733071316.9533877, "step": 3860, "value": 0.03798574581742287}, {"wallTime": 1733071330.2171364, "step": 3870, "value": 0.04049690067768097}, {"wallTime": 1733071338.9907608, "step": 3880, "value": 0.043225135654211044}, {"wallTime": 1733071347.738669, "step": 3890, "value": 0.025710929185152054}, {"wallTime": 1733071357.036745, "step": 3900, "value": 0.03170240297913551}, {"wallTime": 1733071365.2273183, "step": 3910, "value": 0.06040109694004059}, {"wallTime": 1733071374.1365705, "step": 3920, "value": 0.04748965799808502}, {"wallTime": 1733071382.8158214, "step": 3930, "value": 0.05035850405693054}, {"wallTime": 1733071391.570343, "step": 3940, "value": 0.02972753718495369}, {"wallTime": 1733071404.4694593, "step": 3950, "value": 0.028255615383386612}, {"wallTime": 1733071412.340973, "step": 3960, "value": 0.0288127139210701}, {"wallTime": 1733071421.1596134, "step": 3970, "value": 0.042664479464292526}, {"wallTime": 1733071430.1226754, "step": 3980, "value": 0.033917296677827835}, {"wallTime": 1733071438.4161336, "step": 3990, "value": 0.04768054932355881}, {"wallTime": 1733071447.7310424, "step": 4000, "value": 0.02391517348587513}, {"wallTime": 1733071456.1987004, "step": 4010, "value": 0.07395816594362259}, {"wallTime": 1733071464.7515466, "step": 4020, "value": 0.03746597096323967}, {"wallTime": 1733071473.400053, "step": 4030, "value": 0.035285573452711105}, {"wallTime": 1733071490.2886016, "step": 4040, "value": 0.03915325179696083}, {"wallTime": 1733071498.7138515, "step": 4050, "value": 0.04294562339782715}, {"wallTime": 1733071507.0996964, "step": 4060, "value": 0.029286181554198265}, {"wallTime": 1733071515.0700004, "step": 4070, "value": 0.06656694412231445}, {"wallTime": 1733071523.9090087, "step": 4080, "value": 0.029048128053545952}, {"wallTime": 1733071532.2878375, "step": 4090, "value": 0.03539133071899414}, {"wallTime": 1733071540.9198477, "step": 4100, "value": 0.025681547820568085}, {"wallTime": 1733071549.1788723, "step": 4110, "value": 0.027533207088708878}, {"wallTime": 1733071565.8383963, "step": 4120, "value": 0.02754763513803482}, {"wallTime": 1733071573.6341307, "step": 4130, "value": 0.03259171172976494}, {"wallTime": 1733071582.0986729, "step": 4140, "value": 0.04316355288028717}, {"wallTime": 1733071590.0252416, "step": 4150, "value": 0.03797096014022827}, {"wallTime": 1733071599.2435849, "step": 4160, "value": 0.03265368938446045}, {"wallTime": 1733071608.074361, "step": 4170, "value": 0.03581180423498154}, {"wallTime": 1733071616.186597, "step": 4180, "value": 0.062487661838531494}, {"wallTime": 1733071626.0855124, "step": 4190, "value": 0.026954317465424538}, {"wallTime": 1733071641.0111904, "step": 4200, "value": 0.035154107958078384}, {"wallTime": 1733071649.043516, "step": 4210, "value": 0.04222414642572403}, {"wallTime": 1733071658.5342755, "step": 4220, "value": 0.040728285908699036}, {"wallTime": 1733071667.9688969, "step": 4230, "value": 0.02760964259505272}, {"wallTime": 1733071676.1116788, "step": 4240, "value": 0.026167068630456924}, {"wallTime": 1733071684.3814461, "step": 4250, "value": 0.04898908734321594}, {"wallTime": 1733071693.1125665, "step": 4260, "value": 0.023686908185482025}, {"wallTime": 1733071702.18679, "step": 4270, "value": 0.04303034767508507}, {"wallTime": 1733071710.6338952, "step": 4280, "value": 0.023467477411031723}, {"wallTime": 1733071726.6796775, "step": 4290, "value": 0.03495413437485695}, {"wallTime": 1733071735.218501, "step": 4300, "value": 0.03910104185342789}, {"wallTime": 1733071742.960019, "step": 4310, "value": 0.035438068211078644}, {"wallTime": 1733071751.5886126, "step": 4320, "value": 0.030566507950425148}, {"wallTime": 1733071760.0381315, "step": 4330, "value": 0.03137673810124397}, {"wallTime": 1733071768.4342966, "step": 4340, "value": 0.032533250749111176}, {"wallTime": 1733071777.4051359, "step": 4350, "value": 0.04368812218308449}, {"wallTime": 1733071785.5502627, "step": 4360, "value": 0.04139624536037445}, {"wallTime": 1733071800.887842, "step": 4370, "value": 0.03915417939424515}, {"wallTime": 1733071809.2687733, "step": 4380, "value": 0.03137852996587753}, {"wallTime": 1733071817.349447, "step": 4390, "value": 0.06765416264533997}, {"wallTime": 1733071826.4333193, "step": 4400, "value": 0.04500792175531387}, {"wallTime": 1733071834.8904588, "step": 4410, "value": 0.045962415635585785}, {"wallTime": 1733071843.4497516, "step": 4420, "value": 0.05256124213337898}, {"wallTime": 1733071851.5989237, "step": 4430, "value": 0.03295208513736725}, {"wallTime": 1733071859.9270782, "step": 4440, "value": 0.028319042176008224}, {"wallTime": 1733071868.676122, "step": 4450, "value": 0.039922140538692474}, {"wallTime": 1733071881.3391373, "step": 4460, "value": 0.03330002725124359}, {"wallTime": 1733071889.6409245, "step": 4470, "value": 0.03503638505935669}, {"wallTime": 1733071898.4237585, "step": 4480, "value": 0.03283651918172836}, {"wallTime": 1733071907.338957, "step": 4490, "value": 0.04024948179721832}, {"wallTime": 1733071916.2811544, "step": 4500, "value": 0.044236522167921066}, {"wallTime": 1733071925.351586, "step": 4510, "value": 0.04678841307759285}, {"wallTime": 1733071933.3323224, "step": 4520, "value": 0.04957306757569313}, {"wallTime": 1733071941.4855917, "step": 4530, "value": 0.03585081920027733}, {"wallTime": 1733071954.1721377, "step": 4540, "value": 0.02684435062110424}, {"wallTime": 1733071962.3987415, "step": 4550, "value": 0.03023095801472664}, {"wallTime": 1733071970.516189, "step": 4560, "value": 0.04121289402246475}, {"wallTime": 1733071978.8727922, "step": 4570, "value": 0.030442383140325546}, {"wallTime": 1733071987.7133374, "step": 4580, "value": 0.052838247269392014}, {"wallTime": 1733071996.4481447, "step": 4590, "value": 0.0519174262881279}, {"wallTime": 1733072004.4787776, "step": 4600, "value": 0.01975892297923565}, {"wallTime": 1733072012.7475543, "step": 4610, "value": 0.032088760286569595}, {"wallTime": 1733072025.4030788, "step": 4620, "value": 0.042079031467437744}, {"wallTime": 1733072034.1210625, "step": 4630, "value": 0.025268815457820892}, {"wallTime": 1733072043.0405421, "step": 4640, "value": 0.037725068628787994}, {"wallTime": 1733072051.7897096, "step": 4650, "value": 0.03110884502530098}, {"wallTime": 1733072060.1107752, "step": 4660, "value": 0.04601053148508072}, {"wallTime": 1733072068.605505, "step": 4670, "value": 0.05070129409432411}, {"wallTime": 1733072076.838905, "step": 4680, "value": 0.04032108932733536}, {"wallTime": 1733072085.3782392, "step": 4690, "value": 0.027366718277335167}, {"wallTime": 1733072093.7507281, "step": 4700, "value": 0.03920180723071098}, {"wallTime": 1733072106.9919672, "step": 4710, "value": 0.04268956929445267}, {"wallTime": 1733072115.6674395, "step": 4720, "value": 0.0537589006125927}, {"wallTime": 1733072123.9528832, "step": 4730, "value": 0.047282058745622635}, {"wallTime": 1733072132.2829432, "step": 4740, "value": 0.03112579509615898}, {"wallTime": 1733072140.422952, "step": 4750, "value": 0.06099314242601395}, {"wallTime": 1733072149.0893688, "step": 4760, "value": 0.027109840884804726}, {"wallTime": 1733072157.414042, "step": 4770, "value": 0.031002890318632126}, {"wallTime": 1733072165.491492, "step": 4780, "value": 0.05531037226319313}, {"wallTime": 1733072179.6528554, "step": 4790, "value": 0.03569783270359039}, {"wallTime": 1733072188.3317304, "step": 4800, "value": 0.02860303781926632}, {"wallTime": 1733072196.849144, "step": 4810, "value": 0.04074103385210037}, {"wallTime": 1733072204.5643725, "step": 4820, "value": 0.0360347256064415}, {"wallTime": 1733072213.101748, "step": 4830, "value": 0.02384401112794876}, {"wallTime": 1733072221.6693, "step": 4840, "value": 0.026405854150652885}, {"wallTime": 1733072229.8962376, "step": 4850, "value": 0.026477903127670288}, {"wallTime": 1733072238.0583704, "step": 4860, "value": 0.03828498721122742}, {"wallTime": 1733072246.3458388, "step": 4870, "value": 0.02559954673051834}, {"wallTime": 1733072261.269633, "step": 4880, "value": 0.03562465310096741}, {"wallTime": 1733072269.8550665, "step": 4890, "value": 0.03789009153842926}, {"wallTime": 1733072278.882599, "step": 4900, "value": 0.03737112507224083}, {"wallTime": 1733072287.536771, "step": 4910, "value": 0.03008563071489334}, {"wallTime": 1733072295.9495614, "step": 4920, "value": 0.03479225933551788}, {"wallTime": 1733072304.357567, "step": 4930, "value": 0.046643249690532684}, {"wallTime": 1733072313.5120938, "step": 4940, "value": 0.030410785228013992}, {"wallTime": 1733072321.3276722, "step": 4950, "value": 0.03381738066673279}, {"wallTime": 1733072337.0273976, "step": 4960, "value": 0.030568085610866547}, {"wallTime": 1733072345.5358253, "step": 4970, "value": 0.026876116171479225}, {"wallTime": 1733072353.4321468, "step": 4980, "value": 0.025331394746899605}, {"wallTime": 1733072362.4156132, "step": 4990, "value": 0.04358958452939987}, {"wallTime": 1733072371.748386, "step": 5000, "value": 0.04409841448068619}, {"wallTime": 1733072380.5320954, "step": 5010, "value": 0.028962738811969757}, {"wallTime": 1733072389.0289657, "step": 5020, "value": 0.040997300297021866}, {"wallTime": 1733072397.7879992, "step": 5030, "value": 0.03059360384941101}, {"wallTime": 1733072411.301258, "step": 5040, "value": 0.04015301167964935}, {"wallTime": 1733072419.4767187, "step": 5050, "value": 0.039476994425058365}, {"wallTime": 1733072428.3746104, "step": 5060, "value": 0.047011714428663254}, {"wallTime": 1733072437.1197271, "step": 5070, "value": 0.04065984487533569}, {"wallTime": 1733072446.1778357, "step": 5080, "value": 0.04907741770148277}, {"wallTime": 1733072454.43105, "step": 5090, "value": 0.03696061298251152}, {"wallTime": 1733072462.4129844, "step": 5100, "value": 0.04442073404788971}, {"wallTime": 1733072471.1533613, "step": 5110, "value": 0.028880342841148376}, {"wallTime": 1733072478.949146, "step": 5120, "value": 0.03005482256412506}, {"wallTime": 1733072491.3241742, "step": 5130, "value": 0.044338408857584}, {"wallTime": 1733072499.2612326, "step": 5140, "value": 0.023486780002713203}, {"wallTime": 1733072507.1145296, "step": 5150, "value": 0.040102556347846985}, {"wallTime": 1733072515.3197758, "step": 5160, "value": 0.02498696558177471}, {"wallTime": 1733072523.5201635, "step": 5170, "value": 0.029948299750685692}, {"wallTime": 1733072531.0898492, "step": 5180, "value": 0.024711089208722115}, {"wallTime": 1733072540.0264978, "step": 5190, "value": 0.029531843960285187}, {"wallTime": 1733072548.6565633, "step": 5200, "value": 0.029183395206928253}, {"wallTime": 1733072561.4198203, "step": 5210, "value": 0.04617655277252197}, {"wallTime": 1733072569.9009116, "step": 5220, "value": 0.03572617098689079}, {"wallTime": 1733072578.6834629, "step": 5230, "value": 0.04580496996641159}, {"wallTime": 1733072586.9468167, "step": 5240, "value": 0.03282883018255234}, {"wallTime": 1733072595.0368407, "step": 5250, "value": 0.0456300750374794}, {"wallTime": 1733072603.1759892, "step": 5260, "value": 0.04512746259570122}, {"wallTime": 1733072611.0836163, "step": 5270, "value": 0.06700699776411057}, {"wallTime": 1733072619.9592018, "step": 5280, "value": 0.02916646935045719}, {"wallTime": 1733072628.6370554, "step": 5290, "value": 0.026731891557574272}, {"wallTime": 1733072641.378069, "step": 5300, "value": 0.02677125111222267}, {"wallTime": 1733072649.861049, "step": 5310, "value": 0.035680413246154785}, {"wallTime": 1733072657.9738, "step": 5320, "value": 0.03395463526248932}, {"wallTime": 1733072667.031872, "step": 5330, "value": 0.036886509507894516}, {"wallTime": 1733072675.9455295, "step": 5340, "value": 0.025464622303843498}, {"wallTime": 1733072684.2408369, "step": 5350, "value": 0.04069067910313606}, {"wallTime": 1733072691.8605194, "step": 5360, "value": 0.029054338112473488}, {"wallTime": 1733072700.150685, "step": 5370, "value": 0.03670726343989372}, {"wallTime": 1733072713.185573, "step": 5380, "value": 0.034206029027700424}, {"wallTime": 1733072721.0272217, "step": 5390, "value": 0.03214763477444649}, {"wallTime": 1733072729.8794007, "step": 5400, "value": 0.040361203253269196}, {"wallTime": 1733072738.3740797, "step": 5410, "value": 0.03586425259709358}, {"wallTime": 1733072746.3851619, "step": 5420, "value": 0.02690858207643032}, {"wallTime": 1733072754.6201372, "step": 5430, "value": 0.03368833288550377}, {"wallTime": 1733072762.575522, "step": 5440, "value": 0.03664818033576012}, {"wallTime": 1733072771.3631563, "step": 5450, "value": 0.03215358406305313}, {"wallTime": 1733072787.154205, "step": 5460, "value": 0.03858792781829834}, {"wallTime": 1733072795.8052943, "step": 5470, "value": 0.045166127383708954}, {"wallTime": 1733072804.244504, "step": 5480, "value": 0.027660736814141273}, {"wallTime": 1733072812.375448, "step": 5490, "value": 0.030660199001431465}, {"wallTime": 1733072821.161713, "step": 5500, "value": 0.03139496222138405}, {"wallTime": 1733072830.0250442, "step": 5510, "value": 0.03554673492908478}, {"wallTime": 1733072838.6974897, "step": 5520, "value": 0.03529076278209686}, {"wallTime": 1733072846.9073086, "step": 5530, "value": 0.028365198522806168}, {"wallTime": 1733072855.2506325, "step": 5540, "value": 0.04607338458299637}, {"wallTime": 1733072870.648792, "step": 5550, "value": 0.034347765147686005}, {"wallTime": 1733072878.7337554, "step": 5560, "value": 0.03292093053460121}, {"wallTime": 1733072886.6150978, "step": 5570, "value": 0.03879625350236893}, {"wallTime": 1733072895.0236742, "step": 5580, "value": 0.03420250862836838}, {"wallTime": 1733072903.4052086, "step": 5590, "value": 0.028762081637978554}, {"wallTime": 1733072911.2122023, "step": 5600, "value": 0.03026563674211502}, {"wallTime": 1733072919.8421638, "step": 5610, "value": 0.027146080508828163}, {"wallTime": 1733072928.735297, "step": 5620, "value": 0.03486527502536774}, {"wallTime": 1733072941.7059932, "step": 5630, "value": 0.0391269288957119}, {"wallTime": 1733072949.982478, "step": 5640, "value": 0.031231902539730072}, {"wallTime": 1733072958.7239273, "step": 5650, "value": 0.06886620074510574}, {"wallTime": 1733072966.818733, "step": 5660, "value": 0.03269008919596672}, {"wallTime": 1733072974.966155, "step": 5670, "value": 0.02802949585020542}, {"wallTime": 1733072983.5643528, "step": 5680, "value": 0.04918111860752106}, {"wallTime": 1733072992.2325306, "step": 5690, "value": 0.0281462911516428}, {"wallTime": 1733073000.8194706, "step": 5700, "value": 0.019899878650903702}, {"wallTime": 1733073009.7855363, "step": 5710, "value": 0.04812910407781601}, {"wallTime": 1733073022.8705022, "step": 5720, "value": 0.045069534331560135}, {"wallTime": 1733073031.538364, "step": 5730, "value": 0.026095809414982796}, {"wallTime": 1733073039.5747707, "step": 5740, "value": 0.04239930957555771}, {"wallTime": 1733073047.8451025, "step": 5750, "value": 0.03059939667582512}, {"wallTime": 1733073056.1587298, "step": 5760, "value": 0.028276799246668816}, {"wallTime": 1733073064.957326, "step": 5770, "value": 0.04317791014909744}, {"wallTime": 1733073073.8399425, "step": 5780, "value": 0.03722577914595604}, {"wallTime": 1733073082.7273748, "step": 5790, "value": 0.028437398374080658}, {"wallTime": 1733073095.105321, "step": 5800, "value": 0.04681260883808136}, {"wallTime": 1733073103.318094, "step": 5810, "value": 0.02750552073121071}, {"wallTime": 1733073111.972928, "step": 5820, "value": 0.02655400149524212}, {"wallTime": 1733073120.360065, "step": 5830, "value": 0.036697641015052795}, {"wallTime": 1733073128.2115684, "step": 5840, "value": 0.036036621779203415}, {"wallTime": 1733073136.7180314, "step": 5850, "value": 0.02728518843650818}, {"wallTime": 1733073144.930103, "step": 5860, "value": 0.05440320074558258}, {"wallTime": 1733073153.0452807, "step": 5870, "value": 0.033009376376867294}, {"wallTime": 1733073166.0054538, "step": 5880, "value": 0.034776221960783005}, {"wallTime": 1733073174.661426, "step": 5890, "value": 0.033707574009895325}, {"wallTime": 1733073182.5106866, "step": 5900, "value": 0.04964831471443176}, {"wallTime": 1733073191.5618703, "step": 5910, "value": 0.023353464901447296}, {"wallTime": 1733073199.4155416, "step": 5920, "value": 0.043789125978946686}, {"wallTime": 1733073207.467859, "step": 5930, "value": 0.026960819959640503}, {"wallTime": 1733073215.605283, "step": 5940, "value": 0.031080489978194237}, {"wallTime": 1733073224.360582, "step": 5950, "value": 0.026917075738310814}, {"wallTime": 1733073232.8802798, "step": 5960, "value": 0.039021823555231094}, {"wallTime": 1733073245.3764338, "step": 5970, "value": 0.04172457754611969}, {"wallTime": 1733073253.181982, "step": 5980, "value": 0.0370720773935318}, {"wallTime": 1733073261.8040988, "step": 5990, "value": 0.03403555601835251}, {"wallTime": 1733073270.0621717, "step": 6000, "value": 0.037915125489234924}, {"wallTime": 1733073278.8991015, "step": 6010, "value": 0.038253821432590485}, {"wallTime": 1733073287.6846573, "step": 6020, "value": 0.03963792696595192}, {"wallTime": 1733073297.277016, "step": 6030, "value": 0.03972552716732025}, {"wallTime": 1733073305.9207993, "step": 6040, "value": 0.03803503140807152}, {"wallTime": 1733073322.3572884, "step": 6050, "value": 0.033226851373910904}, {"wallTime": 1733073331.9799001, "step": 6060, "value": 0.04050269350409508}, {"wallTime": 1733073340.524914, "step": 6070, "value": 0.03225026652216911}, {"wallTime": 1733073349.6045904, "step": 6080, "value": 0.028626475483179092}, {"wallTime": 1733073359.073903, "step": 6090, "value": 0.043917760252952576}, {"wallTime": 1733073368.4056232, "step": 6100, "value": 0.02687702886760235}, {"wallTime": 1733073377.6776302, "step": 6110, "value": 0.03394892066717148}, {"wallTime": 1733073386.403117, "step": 6120, "value": 0.030027523636817932}, {"wallTime": 1733073395.454057, "step": 6130, "value": 0.036765310913324356}, {"wallTime": 1733073408.1539059, "step": 6140, "value": 0.026470588520169258}, {"wallTime": 1733073417.326543, "step": 6150, "value": 0.028488483279943466}, {"wallTime": 1733073426.2609835, "step": 6160, "value": 0.038257163017988205}, {"wallTime": 1733073434.8119912, "step": 6170, "value": 0.03532514348626137}, {"wallTime": 1733073444.5152965, "step": 6180, "value": 0.06310641020536423}, {"wallTime": 1733073453.1206942, "step": 6190, "value": 0.03173726797103882}, {"wallTime": 1733073462.5682566, "step": 6200, "value": 0.03048887476325035}, {"wallTime": 1733073472.0273812, "step": 6210, "value": 0.037213727831840515}, {"wallTime": 1733073484.450955, "step": 6220, "value": 0.03225211426615715}, {"wallTime": 1733073493.6624534, "step": 6230, "value": 0.02567889913916588}, {"wallTime": 1733073502.443788, "step": 6240, "value": 0.040753595530986786}, {"wallTime": 1733073511.2590303, "step": 6250, "value": 0.03654373064637184}, {"wallTime": 1733073520.5122411, "step": 6260, "value": 0.027645103633403778}, {"wallTime": 1733073529.7838738, "step": 6270, "value": 0.037919268012046814}, {"wallTime": 1733073539.6415555, "step": 6280, "value": 0.03187784552574158}, {"wallTime": 1733073548.913413, "step": 6290, "value": 0.02909514121711254}, {"wallTime": 1733073560.6222777, "step": 6300, "value": 0.031148072332143784}, {"wallTime": 1733073570.0714698, "step": 6310, "value": 0.0350482203066349}, {"wallTime": 1733073579.483778, "step": 6320, "value": 0.035492755472660065}, {"wallTime": 1733073587.669852, "step": 6330, "value": 0.032817959785461426}, {"wallTime": 1733073597.2204306, "step": 6340, "value": 0.03567996993660927}, {"wallTime": 1733073606.2406282, "step": 6350, "value": 0.03176107630133629}, {"wallTime": 1733073615.0802324, "step": 6360, "value": 0.034144774079322815}, {"wallTime": 1733073624.8369064, "step": 6370, "value": 0.03108575940132141}, {"wallTime": 1733073634.675061, "step": 6380, "value": 0.04111044108867645}, {"wallTime": 1733073646.530714, "step": 6390, "value": 0.03155871480703354}, {"wallTime": 1733073655.7479851, "step": 6400, "value": 0.0326690673828125}, {"wallTime": 1733073665.6097043, "step": 6410, "value": 0.030881639569997787}, {"wallTime": 1733073674.6452332, "step": 6420, "value": 0.029414508491754532}, {"wallTime": 1733073683.6728792, "step": 6430, "value": 0.03542488068342209}, {"wallTime": 1733073692.8793006, "step": 6440, "value": 0.03251758962869644}, {"wallTime": 1733073702.5216966, "step": 6450, "value": 0.031970903277397156}, {"wallTime": 1733073712.6298409, "step": 6460, "value": 0.031232178211212158}, {"wallTime": 1733073724.0501015, "step": 6470, "value": 0.02591085620224476}, {"wallTime": 1733073732.8309278, "step": 6480, "value": 0.04200228303670883}, {"wallTime": 1733073741.9604094, "step": 6490, "value": 0.038383763283491135}, {"wallTime": 1733073750.7200608, "step": 6500, "value": 0.05930346995592117}, {"wallTime": 1733073760.4905305, "step": 6510, "value": 0.035635657608509064}, {"wallTime": 1733073769.8658605, "step": 6520, "value": 0.030621828511357307}, {"wallTime": 1733073779.1528409, "step": 6530, "value": 0.03270969167351723}, {"wallTime": 1733073789.4801397, "step": 6540, "value": 0.035883378237485886}, {"wallTime": 1733073798.1058497, "step": 6550, "value": 0.03286884352564812}, {"wallTime": 1733073810.5554676, "step": 6560, "value": 0.048731714487075806}, {"wallTime": 1733073820.0390403, "step": 6570, "value": 0.04288362339138985}, {"wallTime": 1733073828.2412002, "step": 6580, "value": 0.032179735600948334}, {"wallTime": 1733073836.8007896, "step": 6590, "value": 0.028315477073192596}, {"wallTime": 1733073845.9901454, "step": 6600, "value": 0.03453938663005829}, {"wallTime": 1733073855.2546985, "step": 6610, "value": 0.03357457369565964}, {"wallTime": 1733073864.6961832, "step": 6620, "value": 0.03077792376279831}, {"wallTime": 1733073873.8371096, "step": 6630, "value": 0.027341824024915695}, {"wallTime": 1733073887.5272593, "step": 6640, "value": 0.03432890772819519}, {"wallTime": 1733073897.3368282, "step": 6650, "value": 0.03538826107978821}, {"wallTime": 1733073906.879403, "step": 6660, "value": 0.045507416129112244}, {"wallTime": 1733073916.3528657, "step": 6670, "value": 0.035973865538835526}, {"wallTime": 1733073925.6214414, "step": 6680, "value": 0.02923617511987686}, {"wallTime": 1733073934.9195476, "step": 6690, "value": 0.034007370471954346}, {"wallTime": 1733073943.7452044, "step": 6700, "value": 0.04495009034872055}, {"wallTime": 1733073952.4797568, "step": 6710, "value": 0.04402913898229599}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "14996" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Lr/pg_2%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Lr/pg_2", "runToSeries": {".": [{"wallTime": 1733067631.5365915, "step": 0, "value": 9.999999974752427e-07}, {"wallTime": 1733067646.6496546, "step": 10, "value": 6.000000212225132e-06}, {"wallTime": 1733067660.7815938, "step": 20, "value": 1.1000000085914508e-05}, {"wallTime": 1733067674.1347532, "step": 30, "value": 1.5999999959603883e-05}, {"wallTime": 1733067687.0544338, "step": 40, "value": 2.099999983329326e-05}, {"wallTime": 1733067699.4903307, "step": 50, "value": 2.5999999706982635e-05}, {"wallTime": 1733067710.6266146, "step": 60, "value": 3.099999958067201e-05}, {"wallTime": 1733067722.7528498, "step": 70, "value": 3.600000127335079e-05}, {"wallTime": 1733067733.722733, "step": 80, "value": 4.099999932805076e-05}, {"wallTime": 1733067750.9442184, "step": 90, "value": 4.600000102072954e-05}, {"wallTime": 1733067761.9781117, "step": 100, "value": 5.0999999075429514e-05}, {"wallTime": 1733067771.6035285, "step": 110, "value": 5.6000000768108293e-05}, {"wallTime": 1733067780.5444245, "step": 120, "value": 6.0999998822808266e-05}, {"wallTime": 1733067790.4824378, "step": 130, "value": 6.600000051548705e-05}, {"wallTime": 1733067799.1028092, "step": 140, "value": 7.100000220816582e-05}, {"wallTime": 1733067809.441779, "step": 150, "value": 7.599999662488699e-05}, {"wallTime": 1733067818.9180584, "step": 160, "value": 8.099999831756577e-05}, {"wallTime": 1733067836.6473837, "step": 170, "value": 8.600000001024455e-05}, {"wallTime": 1733067846.3879337, "step": 180, "value": 9.100000170292333e-05}, {"wallTime": 1733067855.664183, "step": 190, "value": 9.600000339560211e-05}, {"wallTime": 1733067864.8856187, "step": 200, "value": 0.00010099999781232327}, {"wallTime": 1733067873.9989243, "step": 210, "value": 0.00010599999950500205}, {"wallTime": 1733067883.7819486, "step": 220, "value": 0.00011100000119768083}, {"wallTime": 1733067892.120204, "step": 230, "value": 0.00011600000289035961}, {"wallTime": 1733067901.066566, "step": 240, "value": 0.00012099999730708078}, {"wallTime": 1733067910.0722587, "step": 250, "value": 0.00012599999899975955}, {"wallTime": 1733067925.9478433, "step": 260, "value": 0.00013099999341648072}, {"wallTime": 1733067935.4578803, "step": 270, "value": 0.00013600000238511711}, {"wallTime": 1733067944.01156, "step": 280, "value": 0.00014099999680183828}, {"wallTime": 1733067952.5426235, "step": 290, "value": 0.00014600000577047467}, {"wallTime": 1733067961.0240226, "step": 300, "value": 0.00015100000018719584}, {"wallTime": 1733067970.131795, "step": 310, "value": 0.000155999994603917}, {"wallTime": 1733067980.2231028, "step": 320, "value": 0.0001610000035725534}, {"wallTime": 1733067988.8132784, "step": 330, "value": 0.00016599999798927456}, {"wallTime": 1733068005.0883505, "step": 340, "value": 0.00017100000695791095}, {"wallTime": 1733068014.0621483, "step": 350, "value": 0.00017600000137463212}, {"wallTime": 1733068022.5503473, "step": 360, "value": 0.00018099999579135329}, {"wallTime": 1733068031.822058, "step": 370, "value": 0.00018600000475998968}, {"wallTime": 1733068040.7849474, "step": 380, "value": 0.00019099999917671084}, {"wallTime": 1733068050.1574447, "step": 390, "value": 0.000195999993593432}, {"wallTime": 1733068059.123391, "step": 400, "value": 0.0002010000025620684}, {"wallTime": 1733068068.0875278, "step": 410, "value": 0.00020599999697878957}, {"wallTime": 1733068084.841683, "step": 420, "value": 0.00021100000594742596}, {"wallTime": 1733068094.6639705, "step": 430, "value": 0.00021600000036414713}, {"wallTime": 1733068103.7055366, "step": 440, "value": 0.0002209999947808683}, {"wallTime": 1733068112.6972034, "step": 450, "value": 0.00022600000374950469}, {"wallTime": 1733068121.4985409, "step": 460, "value": 0.00023099999816622585}, {"wallTime": 1733068130.7252126, "step": 470, "value": 0.00023600000713486224}, {"wallTime": 1733068139.8532364, "step": 480, "value": 0.0002410000015515834}, {"wallTime": 1733068149.3677464, "step": 490, "value": 0.0002460000105202198}, {"wallTime": 1733068158.0677466, "step": 500, "value": 0.0002500000118743628}, {"wallTime": 1733068174.1132944, "step": 510, "value": 0.0002500000118743628}, {"wallTime": 1733068182.7172968, "step": 520, "value": 0.0002500000118743628}, {"wallTime": 1733068192.4113634, "step": 530, "value": 0.0002500000118743628}, {"wallTime": 1733068201.8058867, "step": 540, "value": 0.0002500000118743628}, {"wallTime": 1733068210.6522758, "step": 550, "value": 0.0002500000118743628}, {"wallTime": 1733068220.192707, "step": 560, "value": 0.0002500000118743628}, {"wallTime": 1733068229.1568017, "step": 570, "value": 0.0002500000118743628}, {"wallTime": 1733068238.588937, "step": 580, "value": 0.0002500000118743628}, {"wallTime": 1733068256.0707738, "step": 590, "value": 0.0002500000118743628}, {"wallTime": 1733068265.4295897, "step": 600, "value": 0.0002500000118743628}, {"wallTime": 1733068274.65422, "step": 610, "value": 0.0002500000118743628}, {"wallTime": 1733068283.7676916, "step": 620, "value": 0.0002500000118743628}, {"wallTime": 1733068293.3317304, "step": 630, "value": 0.0002500000118743628}, {"wallTime": 1733068302.644769, "step": 640, "value": 0.0002500000118743628}, {"wallTime": 1733068311.3857644, "step": 650, "value": 0.0002500000118743628}, {"wallTime": 1733068320.3879142, "step": 660, "value": 0.0002500000118743628}, {"wallTime": 1733068328.7290766, "step": 670, "value": 0.0002500000118743628}, {"wallTime": 1733068344.4595156, "step": 680, "value": 0.0002500000118743628}, {"wallTime": 1733068353.7147782, "step": 690, "value": 0.0002500000118743628}, {"wallTime": 1733068362.0554032, "step": 700, "value": 0.0002500000118743628}, {"wallTime": 1733068371.1017807, "step": 710, "value": 0.0002500000118743628}, {"wallTime": 1733068380.5308876, "step": 720, "value": 0.0002500000118743628}, {"wallTime": 1733068390.0845966, "step": 730, "value": 0.0002500000118743628}, {"wallTime": 1733068398.7188969, "step": 740, "value": 0.0002500000118743628}, {"wallTime": 1733068407.1217244, "step": 750, "value": 0.0002500000118743628}, {"wallTime": 1733068423.0681117, "step": 760, "value": 0.0002500000118743628}, {"wallTime": 1733068431.4028487, "step": 770, "value": 0.0002500000118743628}, {"wallTime": 1733068440.4228168, "step": 780, "value": 0.0002500000118743628}, {"wallTime": 1733068449.0042963, "step": 790, "value": 0.0002500000118743628}, {"wallTime": 1733068457.6340408, "step": 800, "value": 0.0002500000118743628}, {"wallTime": 1733068467.0451493, "step": 810, "value": 0.0002500000118743628}, {"wallTime": 1733068475.6179655, "step": 820, "value": 0.0002500000118743628}, {"wallTime": 1733068484.976663, "step": 830, "value": 0.0002500000118743628}, {"wallTime": 1733068500.7300575, "step": 840, "value": 0.0002500000118743628}, {"wallTime": 1733068509.3055098, "step": 850, "value": 0.0002500000118743628}, {"wallTime": 1733068519.0201287, "step": 860, "value": 0.0002500000118743628}, {"wallTime": 1733068527.4966087, "step": 870, "value": 0.0002500000118743628}, {"wallTime": 1733068536.9181876, "step": 880, "value": 0.0002500000118743628}, {"wallTime": 1733068544.9067123, "step": 890, "value": 0.0002500000118743628}, {"wallTime": 1733068553.569116, "step": 900, "value": 0.0002500000118743628}, {"wallTime": 1733068562.6840935, "step": 910, "value": 0.0002500000118743628}, {"wallTime": 1733068571.2441823, "step": 920, "value": 0.0002500000118743628}, {"wallTime": 1733068584.775026, "step": 930, "value": 0.0002500000118743628}, {"wallTime": 1733068593.7708104, "step": 940, "value": 0.0002500000118743628}, {"wallTime": 1733068602.7650166, "step": 950, "value": 0.0002500000118743628}, {"wallTime": 1733068611.038884, "step": 960, "value": 0.0002500000118743628}, {"wallTime": 1733068620.2259123, "step": 970, "value": 0.0002500000118743628}, {"wallTime": 1733068628.8409038, "step": 980, "value": 0.0002500000118743628}, {"wallTime": 1733068637.6297946, "step": 990, "value": 0.0002500000118743628}, {"wallTime": 1733068646.6720798, "step": 1000, "value": 0.0002500000118743628}, {"wallTime": 1733068662.7566597, "step": 1010, "value": 0.0002500000118743628}, {"wallTime": 1733068672.0537212, "step": 1020, "value": 0.0002500000118743628}, {"wallTime": 1733068680.562507, "step": 1030, "value": 0.0002500000118743628}, {"wallTime": 1733068690.1850855, "step": 1040, "value": 0.0002500000118743628}, {"wallTime": 1733068698.8474717, "step": 1050, "value": 0.0002500000118743628}, {"wallTime": 1733068707.742764, "step": 1060, "value": 0.0002500000118743628}, {"wallTime": 1733068717.34419, "step": 1070, "value": 0.0002500000118743628}, {"wallTime": 1733068726.36091, "step": 1080, "value": 0.0002500000118743628}, {"wallTime": 1733068735.25098, "step": 1090, "value": 0.0002500000118743628}, {"wallTime": 1733068749.548014, "step": 1100, "value": 0.0002500000118743628}, {"wallTime": 1733068758.374897, "step": 1110, "value": 0.0002500000118743628}, {"wallTime": 1733068767.0033815, "step": 1120, "value": 0.0002500000118743628}, {"wallTime": 1733068776.6184385, "step": 1130, "value": 0.0002500000118743628}, {"wallTime": 1733068785.4005523, "step": 1140, "value": 0.0002500000118743628}, {"wallTime": 1733068794.278607, "step": 1150, "value": 0.0002500000118743628}, {"wallTime": 1733068802.6969147, "step": 1160, "value": 0.0002500000118743628}, {"wallTime": 1733068811.5509934, "step": 1170, "value": 0.0002500000118743628}, {"wallTime": 1733068824.9659107, "step": 1180, "value": 0.0002500000118743628}, {"wallTime": 1733068834.3765984, "step": 1190, "value": 0.0002500000118743628}, {"wallTime": 1733068843.5156806, "step": 1200, "value": 0.0002500000118743628}, {"wallTime": 1733068852.2278361, "step": 1210, "value": 0.0002500000118743628}, {"wallTime": 1733068861.116314, "step": 1220, "value": 0.0002500000118743628}, {"wallTime": 1733068870.0553432, "step": 1230, "value": 0.0002500000118743628}, {"wallTime": 1733068878.7199998, "step": 1240, "value": 0.0002500000118743628}, {"wallTime": 1733068887.731602, "step": 1250, "value": 0.0002500000118743628}, {"wallTime": 1733068903.1668413, "step": 1260, "value": 0.0002500000118743628}, {"wallTime": 1733068912.4052358, "step": 1270, "value": 0.0002500000118743628}, {"wallTime": 1733068921.471586, "step": 1280, "value": 0.0002500000118743628}, {"wallTime": 1733068929.7462454, "step": 1290, "value": 0.0002500000118743628}, {"wallTime": 1733068939.5004907, "step": 1300, "value": 0.0002500000118743628}, {"wallTime": 1733068948.9269757, "step": 1310, "value": 0.0002500000118743628}, {"wallTime": 1733068957.2340071, "step": 1320, "value": 0.0002500000118743628}, {"wallTime": 1733068966.0766253, "step": 1330, "value": 0.0002500000118743628}, {"wallTime": 1733068975.5647495, "step": 1340, "value": 0.0002500000118743628}, {"wallTime": 1733068989.797411, "step": 1350, "value": 0.0002500000118743628}, {"wallTime": 1733068998.257136, "step": 1360, "value": 0.0002500000118743628}, {"wallTime": 1733069007.1469297, "step": 1370, "value": 0.0002500000118743628}, {"wallTime": 1733069015.9199116, "step": 1380, "value": 0.0002500000118743628}, {"wallTime": 1733069025.302802, "step": 1390, "value": 0.0002500000118743628}, {"wallTime": 1733069034.480962, "step": 1400, "value": 0.0002500000118743628}, {"wallTime": 1733069042.792467, "step": 1410, "value": 0.0002500000118743628}, {"wallTime": 1733069052.1368365, "step": 1420, "value": 0.0002500000118743628}, {"wallTime": 1733069065.0015645, "step": 1430, "value": 0.0002500000118743628}, {"wallTime": 1733069074.5233533, "step": 1440, "value": 0.0002500000118743628}, {"wallTime": 1733069083.7758317, "step": 1450, "value": 0.0002500000118743628}, {"wallTime": 1733069092.2568364, "step": 1460, "value": 0.0002500000118743628}, {"wallTime": 1733069101.0289795, "step": 1470, "value": 0.0002500000118743628}, {"wallTime": 1733069109.904517, "step": 1480, "value": 0.0002500000118743628}, {"wallTime": 1733069119.1170502, "step": 1490, "value": 0.0002500000118743628}, {"wallTime": 1733069128.414266, "step": 1500, "value": 0.0002500000118743628}, {"wallTime": 1733069137.6050088, "step": 1510, "value": 0.0002500000118743628}, {"wallTime": 1733069150.5423331, "step": 1520, "value": 0.0002500000118743628}, {"wallTime": 1733069159.755391, "step": 1530, "value": 0.0002500000118743628}, {"wallTime": 1733069168.1685503, "step": 1540, "value": 0.0002500000118743628}, {"wallTime": 1733069176.8393016, "step": 1550, "value": 0.0002500000118743628}, {"wallTime": 1733069185.8906312, "step": 1560, "value": 0.0002500000118743628}, {"wallTime": 1733069194.92198, "step": 1570, "value": 0.0002500000118743628}, {"wallTime": 1733069203.909948, "step": 1580, "value": 0.0002500000118743628}, {"wallTime": 1733069212.7136092, "step": 1590, "value": 0.0002500000118743628}, {"wallTime": 1733069225.5327256, "step": 1600, "value": 0.0002500000118743628}, {"wallTime": 1733069235.462119, "step": 1610, "value": 0.0002500000118743628}, {"wallTime": 1733069244.6276915, "step": 1620, "value": 0.0002500000118743628}, {"wallTime": 1733069254.2699955, "step": 1630, "value": 0.0002500000118743628}, {"wallTime": 1733069263.0035417, "step": 1640, "value": 0.0002500000118743628}, {"wallTime": 1733069271.864875, "step": 1650, "value": 0.0002500000118743628}, {"wallTime": 1733069280.508188, "step": 1660, "value": 0.0002500000118743628}, {"wallTime": 1733069289.6781092, "step": 1670, "value": 0.0002500000118743628}, {"wallTime": 1733069303.60721, "step": 1680, "value": 0.0002500000118743628}, {"wallTime": 1733069312.477594, "step": 1690, "value": 0.0002500000118743628}, {"wallTime": 1733069321.8368201, "step": 1700, "value": 0.0002500000118743628}, {"wallTime": 1733069330.3462617, "step": 1710, "value": 0.0002500000118743628}, {"wallTime": 1733069339.2432451, "step": 1720, "value": 0.0002500000118743628}, {"wallTime": 1733069346.8548057, "step": 1730, "value": 0.0002500000118743628}, {"wallTime": 1733069355.6503935, "step": 1740, "value": 0.0002500000118743628}, {"wallTime": 1733069364.5100353, "step": 1750, "value": 0.0002500000118743628}, {"wallTime": 1733069373.7366054, "step": 1760, "value": 0.0002500000118743628}, {"wallTime": 1733069387.5398252, "step": 1770, "value": 0.0002500000118743628}, {"wallTime": 1733069396.4646938, "step": 1780, "value": 0.0002500000118743628}, {"wallTime": 1733069405.994539, "step": 1790, "value": 0.0002500000118743628}, {"wallTime": 1733069415.0518668, "step": 1800, "value": 0.0002500000118743628}, {"wallTime": 1733069423.9058697, "step": 1810, "value": 0.0002500000118743628}, {"wallTime": 1733069432.529185, "step": 1820, "value": 0.0002500000118743628}, {"wallTime": 1733069441.2148879, "step": 1830, "value": 0.0002500000118743628}, {"wallTime": 1733069450.0846155, "step": 1840, "value": 0.0002500000118743628}, {"wallTime": 1733069463.1053739, "step": 1850, "value": 0.0002500000118743628}, {"wallTime": 1733069471.5705733, "step": 1860, "value": 0.0002500000118743628}, {"wallTime": 1733069480.4959695, "step": 1870, "value": 0.0002500000118743628}, {"wallTime": 1733069489.3828716, "step": 1880, "value": 0.0002500000118743628}, {"wallTime": 1733069497.9744744, "step": 1890, "value": 0.0002500000118743628}, {"wallTime": 1733069506.7919908, "step": 1900, "value": 0.0002500000118743628}, {"wallTime": 1733069515.8225427, "step": 1910, "value": 0.0002500000118743628}, {"wallTime": 1733069524.634401, "step": 1920, "value": 0.0002500000118743628}, {"wallTime": 1733069533.5399048, "step": 1930, "value": 0.0002500000118743628}, {"wallTime": 1733069550.47637, "step": 1940, "value": 0.0002500000118743628}, {"wallTime": 1733069558.825602, "step": 1950, "value": 0.0002500000118743628}, {"wallTime": 1733069567.7556982, "step": 1960, "value": 0.0002500000118743628}, {"wallTime": 1733069576.342874, "step": 1970, "value": 0.0002500000118743628}, {"wallTime": 1733069585.5268257, "step": 1980, "value": 0.0002500000118743628}, {"wallTime": 1733069594.3480744, "step": 1990, "value": 0.0002500000118743628}, {"wallTime": 1733069602.3992639, "step": 2000, "value": 0.0002500000118743628}, {"wallTime": 1733069610.2475061, "step": 2010, "value": 0.0002500000118743628}, {"wallTime": 1733069626.6851707, "step": 2020, "value": 0.0002500000118743628}, {"wallTime": 1733069635.0285907, "step": 2030, "value": 0.0002500000118743628}, {"wallTime": 1733069643.8204303, "step": 2040, "value": 0.0002500000118743628}, {"wallTime": 1733069652.1922946, "step": 2050, "value": 0.0002500000118743628}, {"wallTime": 1733069660.4512498, "step": 2060, "value": 0.0002500000118743628}, {"wallTime": 1733069669.5899029, "step": 2070, "value": 0.0002500000118743628}, {"wallTime": 1733069678.7759583, "step": 2080, "value": 0.0002500000118743628}, {"wallTime": 1733069686.9425964, "step": 2090, "value": 0.0002500000118743628}, {"wallTime": 1733069700.600323, "step": 2100, "value": 0.0002500000118743628}, {"wallTime": 1733069708.7241328, "step": 2110, "value": 0.0002500000118743628}, {"wallTime": 1733069717.446149, "step": 2120, "value": 0.0002500000118743628}, {"wallTime": 1733069726.13903, "step": 2130, "value": 0.0002500000118743628}, {"wallTime": 1733069735.0357385, "step": 2140, "value": 0.0002500000118743628}, {"wallTime": 1733069743.303627, "step": 2150, "value": 0.0002500000118743628}, {"wallTime": 1733069752.4984705, "step": 2160, "value": 0.0002500000118743628}, {"wallTime": 1733069761.4488103, "step": 2170, "value": 0.0002500000118743628}, {"wallTime": 1733069770.4310398, "step": 2180, "value": 0.0002500000118743628}, {"wallTime": 1733069784.361752, "step": 2190, "value": 0.0002500000118743628}, {"wallTime": 1733069793.1202085, "step": 2200, "value": 0.0002500000118743628}, {"wallTime": 1733069801.629173, "step": 2210, "value": 0.0002500000118743628}, {"wallTime": 1733069810.6054757, "step": 2220, "value": 0.0002500000118743628}, {"wallTime": 1733069819.339295, "step": 2230, "value": 0.0002500000118743628}, {"wallTime": 1733069827.3239222, "step": 2240, "value": 0.0002500000118743628}, {"wallTime": 1733069835.8651721, "step": 2250, "value": 0.0002500000118743628}, {"wallTime": 1733069844.233336, "step": 2260, "value": 0.0002500000118743628}, {"wallTime": 1733069856.7474203, "step": 2270, "value": 0.0002500000118743628}, {"wallTime": 1733069865.2552102, "step": 2280, "value": 0.0002500000118743628}, {"wallTime": 1733069874.0025227, "step": 2290, "value": 0.0002500000118743628}, {"wallTime": 1733069881.7791803, "step": 2300, "value": 0.0002500000118743628}, {"wallTime": 1733069890.411222, "step": 2310, "value": 0.0002500000118743628}, {"wallTime": 1733069898.8742394, "step": 2320, "value": 0.0002500000118743628}, {"wallTime": 1733069908.3153784, "step": 2330, "value": 0.0002500000118743628}, {"wallTime": 1733069917.4128287, "step": 2340, "value": 0.0002500000118743628}, {"wallTime": 1733069925.847642, "step": 2350, "value": 0.0002500000118743628}, {"wallTime": 1733069938.699837, "step": 2360, "value": 0.0002500000118743628}, {"wallTime": 1733069947.4236667, "step": 2370, "value": 0.0002500000118743628}, {"wallTime": 1733069956.2031205, "step": 2380, "value": 0.0002500000118743628}, {"wallTime": 1733069964.2719767, "step": 2390, "value": 0.0002500000118743628}, {"wallTime": 1733069973.3237092, "step": 2400, "value": 0.0002500000118743628}, {"wallTime": 1733069981.4294848, "step": 2410, "value": 0.0002500000118743628}, {"wallTime": 1733069990.1371205, "step": 2420, "value": 0.0002500000118743628}, {"wallTime": 1733069998.7951977, "step": 2430, "value": 0.0002500000118743628}, {"wallTime": 1733070012.4538198, "step": 2440, "value": 0.0002500000118743628}, {"wallTime": 1733070021.5722823, "step": 2450, "value": 0.0002500000118743628}, {"wallTime": 1733070030.1885402, "step": 2460, "value": 0.0002500000118743628}, {"wallTime": 1733070039.216846, "step": 2470, "value": 0.0002500000118743628}, {"wallTime": 1733070048.2664742, "step": 2480, "value": 0.0002500000118743628}, {"wallTime": 1733070056.1531155, "step": 2490, "value": 0.0002500000118743628}, {"wallTime": 1733070064.447916, "step": 2500, "value": 0.0002500000118743628}, {"wallTime": 1733070072.54658, "step": 2510, "value": 0.0002500000118743628}, {"wallTime": 1733070087.6547716, "step": 2520, "value": 0.0002500000118743628}, {"wallTime": 1733070095.4388483, "step": 2530, "value": 0.0002500000118743628}, {"wallTime": 1733070103.7663205, "step": 2540, "value": 0.0002500000118743628}, {"wallTime": 1733070113.046199, "step": 2550, "value": 0.0002500000118743628}, {"wallTime": 1733070121.035245, "step": 2560, "value": 0.0002500000118743628}, {"wallTime": 1733070129.5763524, "step": 2570, "value": 0.0002500000118743628}, {"wallTime": 1733070138.3581223, "step": 2580, "value": 0.0002500000118743628}, {"wallTime": 1733070147.0848005, "step": 2590, "value": 0.0002500000118743628}, {"wallTime": 1733070155.4842925, "step": 2600, "value": 0.0002500000118743628}, {"wallTime": 1733070172.5752811, "step": 2610, "value": 0.0002500000118743628}, {"wallTime": 1733070181.208483, "step": 2620, "value": 0.0002500000118743628}, {"wallTime": 1733070189.6895492, "step": 2630, "value": 0.0002500000118743628}, {"wallTime": 1733070198.3966336, "step": 2640, "value": 0.0002500000118743628}, {"wallTime": 1733070206.704851, "step": 2650, "value": 0.0002500000118743628}, {"wallTime": 1733070215.5971694, "step": 2660, "value": 0.0002500000118743628}, {"wallTime": 1733070224.3128085, "step": 2670, "value": 0.0002500000118743628}, {"wallTime": 1733070233.5367162, "step": 2680, "value": 0.0002500000118743628}, {"wallTime": 1733070246.7560997, "step": 2690, "value": 0.0002500000118743628}, {"wallTime": 1733070256.0260994, "step": 2700, "value": 0.0002500000118743628}, {"wallTime": 1733070264.9482868, "step": 2710, "value": 0.0002500000118743628}, {"wallTime": 1733070273.8022084, "step": 2720, "value": 0.0002500000118743628}, {"wallTime": 1733070282.9564195, "step": 2730, "value": 0.0002500000118743628}, {"wallTime": 1733070292.2754, "step": 2740, "value": 0.0002500000118743628}, {"wallTime": 1733070300.3340323, "step": 2750, "value": 0.0002500000118743628}, {"wallTime": 1733070309.4096372, "step": 2760, "value": 0.0002500000118743628}, {"wallTime": 1733070317.5289943, "step": 2770, "value": 0.0002500000118743628}, {"wallTime": 1733070330.4340992, "step": 2780, "value": 0.0002500000118743628}, {"wallTime": 1733070339.8200428, "step": 2790, "value": 0.0002500000118743628}, {"wallTime": 1733070347.9903982, "step": 2800, "value": 0.0002500000118743628}, {"wallTime": 1733070356.8883107, "step": 2810, "value": 0.0002500000118743628}, {"wallTime": 1733070365.5743332, "step": 2820, "value": 0.0002500000118743628}, {"wallTime": 1733070374.389974, "step": 2830, "value": 0.0002500000118743628}, {"wallTime": 1733070382.4244943, "step": 2840, "value": 0.0002500000118743628}, {"wallTime": 1733070390.9386306, "step": 2850, "value": 0.0002500000118743628}, {"wallTime": 1733070406.6767523, "step": 2860, "value": 0.0002500000118743628}, {"wallTime": 1733070415.086283, "step": 2870, "value": 0.0002500000118743628}, {"wallTime": 1733070422.9175344, "step": 2880, "value": 0.0002500000118743628}, {"wallTime": 1733070431.5348394, "step": 2890, "value": 0.0002500000118743628}, {"wallTime": 1733070439.9782913, "step": 2900, "value": 0.0002500000118743628}, {"wallTime": 1733070448.082811, "step": 2910, "value": 0.0002500000118743628}, {"wallTime": 1733070457.4211361, "step": 2920, "value": 0.0002500000118743628}, {"wallTime": 1733070466.7203887, "step": 2930, "value": 0.0002500000118743628}, {"wallTime": 1733070479.3305292, "step": 2940, "value": 0.0002500000118743628}, {"wallTime": 1733070488.7795825, "step": 2950, "value": 0.0002500000118743628}, {"wallTime": 1733070497.222361, "step": 2960, "value": 0.0002500000118743628}, {"wallTime": 1733070505.6311421, "step": 2970, "value": 0.0002500000118743628}, {"wallTime": 1733070513.3513415, "step": 2980, "value": 0.0002500000118743628}, {"wallTime": 1733070522.2984025, "step": 2990, "value": 0.0002500000118743628}, {"wallTime": 1733070530.2099566, "step": 3000, "value": 0.0002500000118743628}, {"wallTime": 1733070538.29755, "step": 3010, "value": 0.0002500000118743628}, {"wallTime": 1733070547.3978217, "step": 3020, "value": 0.0002500000118743628}, {"wallTime": 1733070564.0487797, "step": 3030, "value": 0.0002500000118743628}, {"wallTime": 1733070572.3671536, "step": 3040, "value": 0.0002500000118743628}, {"wallTime": 1733070580.6681638, "step": 3050, "value": 0.0002500000118743628}, {"wallTime": 1733070588.650708, "step": 3060, "value": 0.0002500000118743628}, {"wallTime": 1733070597.418, "step": 3070, "value": 0.0002500000118743628}, {"wallTime": 1733070606.1347203, "step": 3080, "value": 0.0002500000118743628}, {"wallTime": 1733070614.4364843, "step": 3090, "value": 0.0002500000118743628}, {"wallTime": 1733070623.9972866, "step": 3100, "value": 0.0002500000118743628}, {"wallTime": 1733070637.2499726, "step": 3110, "value": 0.0002500000118743628}, {"wallTime": 1733070645.67922, "step": 3120, "value": 0.0002500000118743628}, {"wallTime": 1733070654.267025, "step": 3130, "value": 0.0002500000118743628}, {"wallTime": 1733070663.3178189, "step": 3140, "value": 0.0002500000118743628}, {"wallTime": 1733070671.1143713, "step": 3150, "value": 0.0002500000118743628}, {"wallTime": 1733070679.7620075, "step": 3160, "value": 0.0002500000118743628}, {"wallTime": 1733070687.8410978, "step": 3170, "value": 0.0002500000118743628}, {"wallTime": 1733070695.8521945, "step": 3180, "value": 0.0002500000118743628}, {"wallTime": 1733070704.6189878, "step": 3190, "value": 0.0002500000118743628}, {"wallTime": 1733070717.1059535, "step": 3200, "value": 0.0002500000118743628}, {"wallTime": 1733070726.0952082, "step": 3210, "value": 0.0002500000118743628}, {"wallTime": 1733070734.7724848, "step": 3220, "value": 0.0002500000118743628}, {"wallTime": 1733070744.4081376, "step": 3230, "value": 0.0002500000118743628}, {"wallTime": 1733070752.4979856, "step": 3240, "value": 0.0002500000118743628}, {"wallTime": 1733070761.7174947, "step": 3250, "value": 0.0002500000118743628}, {"wallTime": 1733070770.37298, "step": 3260, "value": 0.0002500000118743628}, {"wallTime": 1733070779.7265742, "step": 3270, "value": 0.0002500000118743628}, {"wallTime": 1733070793.6753526, "step": 3280, "value": 0.0002500000118743628}, {"wallTime": 1733070801.8965938, "step": 3290, "value": 0.0002500000118743628}, {"wallTime": 1733070810.1576371, "step": 3300, "value": 0.0002500000118743628}, {"wallTime": 1733070818.7225356, "step": 3310, "value": 0.0002500000118743628}, {"wallTime": 1733070827.0025938, "step": 3320, "value": 0.0002500000118743628}, {"wallTime": 1733070835.5702753, "step": 3330, "value": 0.0002500000118743628}, {"wallTime": 1733070843.9699967, "step": 3340, "value": 0.0002500000118743628}, {"wallTime": 1733070853.0878334, "step": 3350, "value": 0.0002500000118743628}, {"wallTime": 1733070865.416622, "step": 3360, "value": 0.0002500000118743628}, {"wallTime": 1733070873.65793, "step": 3370, "value": 0.0002500000118743628}, {"wallTime": 1733070883.3324273, "step": 3380, "value": 0.0002500000118743628}, {"wallTime": 1733070892.3733382, "step": 3390, "value": 0.0002500000118743628}, {"wallTime": 1733070900.7188187, "step": 3400, "value": 0.0002500000118743628}, {"wallTime": 1733070908.5007925, "step": 3410, "value": 0.0002500000118743628}, {"wallTime": 1733070916.6523726, "step": 3420, "value": 0.0002500000118743628}, {"wallTime": 1733070925.204298, "step": 3430, "value": 0.0002500000118743628}, {"wallTime": 1733070933.806904, "step": 3440, "value": 0.0002500000118743628}, {"wallTime": 1733070947.4768994, "step": 3450, "value": 0.0002500000118743628}, {"wallTime": 1733070956.1837354, "step": 3460, "value": 0.0002500000118743628}, {"wallTime": 1733070964.2629163, "step": 3470, "value": 0.0002500000118743628}, {"wallTime": 1733070972.382633, "step": 3480, "value": 0.0002500000118743628}, {"wallTime": 1733070980.6437757, "step": 3490, "value": 0.0002500000118743628}, {"wallTime": 1733070989.6840434, "step": 3500, "value": 0.0002500000118743628}, {"wallTime": 1733070997.7848918, "step": 3510, "value": 0.0002500000118743628}, {"wallTime": 1733071006.2679806, "step": 3520, "value": 0.0002500000118743628}, {"wallTime": 1733071018.893162, "step": 3530, "value": 0.0002500000118743628}, {"wallTime": 1733071027.1931815, "step": 3540, "value": 0.0002500000118743628}, {"wallTime": 1733071035.3171546, "step": 3550, "value": 0.0002500000118743628}, {"wallTime": 1733071043.7422833, "step": 3560, "value": 0.0002500000118743628}, {"wallTime": 1733071051.8688118, "step": 3570, "value": 0.0002500000118743628}, {"wallTime": 1733071060.4928145, "step": 3580, "value": 0.0002500000118743628}, {"wallTime": 1733071068.8757894, "step": 3590, "value": 0.0002500000118743628}, {"wallTime": 1733071077.709615, "step": 3600, "value": 0.0002500000118743628}, {"wallTime": 1733071086.2090168, "step": 3610, "value": 0.0002500000118743628}, {"wallTime": 1733071101.6558735, "step": 3620, "value": 0.0002500000118743628}, {"wallTime": 1733071109.616413, "step": 3630, "value": 0.0002500000118743628}, {"wallTime": 1733071118.1259637, "step": 3640, "value": 0.0002500000118743628}, {"wallTime": 1733071126.9896722, "step": 3650, "value": 0.0002500000118743628}, {"wallTime": 1733071135.8240786, "step": 3660, "value": 0.0002500000118743628}, {"wallTime": 1733071144.2449257, "step": 3670, "value": 0.0002500000118743628}, {"wallTime": 1733071152.9612734, "step": 3680, "value": 0.0002500000118743628}, {"wallTime": 1733071160.5999367, "step": 3690, "value": 0.0002500000118743628}, {"wallTime": 1733071173.7474923, "step": 3700, "value": 0.0002500000118743628}, {"wallTime": 1733071182.8799822, "step": 3710, "value": 0.0002500000118743628}, {"wallTime": 1733071191.2066112, "step": 3720, "value": 0.0002500000118743628}, {"wallTime": 1733071200.330019, "step": 3730, "value": 0.0002500000118743628}, {"wallTime": 1733071208.362466, "step": 3740, "value": 0.0002500000118743628}, {"wallTime": 1733071216.568565, "step": 3750, "value": 0.0002500000118743628}, {"wallTime": 1733071224.6586611, "step": 3760, "value": 0.0002500000118743628}, {"wallTime": 1733071232.8573275, "step": 3770, "value": 0.0002500000118743628}, {"wallTime": 1733071248.5305927, "step": 3780, "value": 0.0002500000118743628}, {"wallTime": 1733071257.3882353, "step": 3790, "value": 0.0002500000118743628}, {"wallTime": 1733071265.564163, "step": 3800, "value": 0.0002500000118743628}, {"wallTime": 1733071274.1755013, "step": 3810, "value": 0.0002500000118743628}, {"wallTime": 1733071283.014797, "step": 3820, "value": 0.0002500000118743628}, {"wallTime": 1733071291.7263288, "step": 3830, "value": 0.0002500000118743628}, {"wallTime": 1733071299.888438, "step": 3840, "value": 0.0002500000118743628}, {"wallTime": 1733071308.4761965, "step": 3850, "value": 0.0002500000118743628}, {"wallTime": 1733071316.948257, "step": 3860, "value": 0.0002500000118743628}, {"wallTime": 1733071330.2124257, "step": 3870, "value": 0.0002500000118743628}, {"wallTime": 1733071338.985801, "step": 3880, "value": 0.0002500000118743628}, {"wallTime": 1733071347.733856, "step": 3890, "value": 0.0002500000118743628}, {"wallTime": 1733071357.0310276, "step": 3900, "value": 0.0002500000118743628}, {"wallTime": 1733071365.2222955, "step": 3910, "value": 0.0002500000118743628}, {"wallTime": 1733071374.1318042, "step": 3920, "value": 0.0002500000118743628}, {"wallTime": 1733071382.8109155, "step": 3930, "value": 0.0002500000118743628}, {"wallTime": 1733071391.5655081, "step": 3940, "value": 0.0002500000118743628}, {"wallTime": 1733071404.4648352, "step": 3950, "value": 0.0002500000118743628}, {"wallTime": 1733071412.3357346, "step": 3960, "value": 0.0002500000118743628}, {"wallTime": 1733071421.1545043, "step": 3970, "value": 0.0002500000118743628}, {"wallTime": 1733071430.1174777, "step": 3980, "value": 0.0002500000118743628}, {"wallTime": 1733071438.4111598, "step": 3990, "value": 0.0002500000118743628}, {"wallTime": 1733071447.7256842, "step": 4000, "value": 0.0002500000118743628}, {"wallTime": 1733071456.193685, "step": 4010, "value": 0.0002500000118743628}, {"wallTime": 1733071464.7466722, "step": 4020, "value": 0.0002500000118743628}, {"wallTime": 1733071473.393946, "step": 4030, "value": 0.0002500000118743628}, {"wallTime": 1733071490.2841465, "step": 4040, "value": 0.0002500000118743628}, {"wallTime": 1733071498.70896, "step": 4050, "value": 0.0002500000118743628}, {"wallTime": 1733071507.094584, "step": 4060, "value": 0.0002500000118743628}, {"wallTime": 1733071515.0649588, "step": 4070, "value": 0.0002500000118743628}, {"wallTime": 1733071523.8785365, "step": 4080, "value": 0.0002500000118743628}, {"wallTime": 1733071532.282534, "step": 4090, "value": 0.0002500000118743628}, {"wallTime": 1733071540.9150972, "step": 4100, "value": 0.0002500000118743628}, {"wallTime": 1733071549.1736662, "step": 4110, "value": 0.0002500000118743628}, {"wallTime": 1733071565.8339412, "step": 4120, "value": 0.0002500000118743628}, {"wallTime": 1733071573.629169, "step": 4130, "value": 0.0002500000118743628}, {"wallTime": 1733071582.0935934, "step": 4140, "value": 0.0002500000118743628}, {"wallTime": 1733071590.0200114, "step": 4150, "value": 0.0002500000118743628}, {"wallTime": 1733071599.2385058, "step": 4160, "value": 0.0002500000118743628}, {"wallTime": 1733071608.0614152, "step": 4170, "value": 0.0002500000118743628}, {"wallTime": 1733071616.1815574, "step": 4180, "value": 0.0002500000118743628}, {"wallTime": 1733071626.0806108, "step": 4190, "value": 0.0002500000118743628}, {"wallTime": 1733071641.0061111, "step": 4200, "value": 0.0002500000118743628}, {"wallTime": 1733071649.0382261, "step": 4210, "value": 0.0002500000118743628}, {"wallTime": 1733071658.529169, "step": 4220, "value": 0.0002500000118743628}, {"wallTime": 1733071667.963854, "step": 4230, "value": 0.0002500000118743628}, {"wallTime": 1733071676.1065156, "step": 4240, "value": 0.0002500000118743628}, {"wallTime": 1733071684.376219, "step": 4250, "value": 0.0002500000118743628}, {"wallTime": 1733071693.1074536, "step": 4260, "value": 0.0002500000118743628}, {"wallTime": 1733071702.181719, "step": 4270, "value": 0.0002500000118743628}, {"wallTime": 1733071710.6276274, "step": 4280, "value": 0.0002500000118743628}, {"wallTime": 1733071726.6752226, "step": 4290, "value": 0.0002500000118743628}, {"wallTime": 1733071735.2134738, "step": 4300, "value": 0.0002500000118743628}, {"wallTime": 1733071742.9550166, "step": 4310, "value": 0.0002500000118743628}, {"wallTime": 1733071751.5837717, "step": 4320, "value": 0.0002500000118743628}, {"wallTime": 1733071760.0325885, "step": 4330, "value": 0.0002500000118743628}, {"wallTime": 1733071768.4293082, "step": 4340, "value": 0.0002500000118743628}, {"wallTime": 1733071777.399863, "step": 4350, "value": 0.0002500000118743628}, {"wallTime": 1733071785.5453496, "step": 4360, "value": 0.0002500000118743628}, {"wallTime": 1733071800.88327, "step": 4370, "value": 0.0002500000118743628}, {"wallTime": 1733071809.2635915, "step": 4380, "value": 0.0002500000118743628}, {"wallTime": 1733071817.3441544, "step": 4390, "value": 0.0002500000118743628}, {"wallTime": 1733071826.4281936, "step": 4400, "value": 0.0002500000118743628}, {"wallTime": 1733071834.8856301, "step": 4410, "value": 0.0002500000118743628}, {"wallTime": 1733071843.4446087, "step": 4420, "value": 0.0002500000118743628}, {"wallTime": 1733071851.593823, "step": 4430, "value": 0.0002500000118743628}, {"wallTime": 1733071859.9215195, "step": 4440, "value": 0.0002500000118743628}, {"wallTime": 1733071868.6711023, "step": 4450, "value": 0.0002500000118743628}, {"wallTime": 1733071881.3347359, "step": 4460, "value": 0.0002500000118743628}, {"wallTime": 1733071889.634035, "step": 4470, "value": 0.0002500000118743628}, {"wallTime": 1733071898.4188159, "step": 4480, "value": 0.0002500000118743628}, {"wallTime": 1733071907.3340602, "step": 4490, "value": 0.0002500000118743628}, {"wallTime": 1733071916.275927, "step": 4500, "value": 0.0002500000118743628}, {"wallTime": 1733071925.3467307, "step": 4510, "value": 0.0002500000118743628}, {"wallTime": 1733071933.3271945, "step": 4520, "value": 0.0002500000118743628}, {"wallTime": 1733071941.480661, "step": 4530, "value": 0.0002500000118743628}, {"wallTime": 1733071954.1674528, "step": 4540, "value": 0.0002500000118743628}, {"wallTime": 1733071962.3936725, "step": 4550, "value": 0.0002500000118743628}, {"wallTime": 1733071970.5110683, "step": 4560, "value": 0.0002500000118743628}, {"wallTime": 1733071978.8677456, "step": 4570, "value": 0.0002500000118743628}, {"wallTime": 1733071987.7084677, "step": 4580, "value": 0.0002500000118743628}, {"wallTime": 1733071996.4418786, "step": 4590, "value": 0.0002500000118743628}, {"wallTime": 1733072004.4738507, "step": 4600, "value": 0.0002500000118743628}, {"wallTime": 1733072012.7423806, "step": 4610, "value": 0.0002500000118743628}, {"wallTime": 1733072025.398479, "step": 4620, "value": 0.0002500000118743628}, {"wallTime": 1733072034.1157882, "step": 4630, "value": 0.0002500000118743628}, {"wallTime": 1733072043.0350564, "step": 4640, "value": 0.0002500000118743628}, {"wallTime": 1733072051.7819347, "step": 4650, "value": 0.0002500000118743628}, {"wallTime": 1733072060.10563, "step": 4660, "value": 0.0002500000118743628}, {"wallTime": 1733072068.6004941, "step": 4670, "value": 0.0002500000118743628}, {"wallTime": 1733072076.833926, "step": 4680, "value": 0.0002500000118743628}, {"wallTime": 1733072085.3734722, "step": 4690, "value": 0.0002500000118743628}, {"wallTime": 1733072093.7459183, "step": 4700, "value": 0.0002500000118743628}, {"wallTime": 1733072106.9875197, "step": 4710, "value": 0.0002500000118743628}, {"wallTime": 1733072115.662342, "step": 4720, "value": 0.0002500000118743628}, {"wallTime": 1733072123.9477499, "step": 4730, "value": 0.0002500000118743628}, {"wallTime": 1733072132.27776, "step": 4740, "value": 0.0002500000118743628}, {"wallTime": 1733072140.417617, "step": 4750, "value": 0.0002500000118743628}, {"wallTime": 1733072149.084448, "step": 4760, "value": 0.0002500000118743628}, {"wallTime": 1733072157.4089541, "step": 4770, "value": 0.0002500000118743628}, {"wallTime": 1733072165.4865406, "step": 4780, "value": 0.0002500000118743628}, {"wallTime": 1733072179.64555, "step": 4790, "value": 0.0002500000118743628}, {"wallTime": 1733072188.3267267, "step": 4800, "value": 0.0002500000118743628}, {"wallTime": 1733072196.8442597, "step": 4810, "value": 0.0002500000118743628}, {"wallTime": 1733072204.5594206, "step": 4820, "value": 0.0002500000118743628}, {"wallTime": 1733072213.09679, "step": 4830, "value": 0.0002500000118743628}, {"wallTime": 1733072221.6640325, "step": 4840, "value": 0.0002500000118743628}, {"wallTime": 1733072229.8912308, "step": 4850, "value": 0.0002500000118743628}, {"wallTime": 1733072238.0533438, "step": 4860, "value": 0.0002500000118743628}, {"wallTime": 1733072246.340731, "step": 4870, "value": 0.0002500000118743628}, {"wallTime": 1733072261.2651339, "step": 4880, "value": 0.0002500000118743628}, {"wallTime": 1733072269.849309, "step": 4890, "value": 0.0002500000118743628}, {"wallTime": 1733072278.858479, "step": 4900, "value": 0.0002500000118743628}, {"wallTime": 1733072287.5318208, "step": 4910, "value": 0.0002500000118743628}, {"wallTime": 1733072295.9442916, "step": 4920, "value": 0.0002500000118743628}, {"wallTime": 1733072304.3528392, "step": 4930, "value": 0.0002500000118743628}, {"wallTime": 1733072313.5072525, "step": 4940, "value": 0.0002500000118743628}, {"wallTime": 1733072321.3225183, "step": 4950, "value": 0.0002500000118743628}, {"wallTime": 1733072337.0228782, "step": 4960, "value": 0.0002500000118743628}, {"wallTime": 1733072345.5278523, "step": 4970, "value": 0.0002500000118743628}, {"wallTime": 1733072353.4271417, "step": 4980, "value": 0.0002500000118743628}, {"wallTime": 1733072362.410797, "step": 4990, "value": 0.0002500000118743628}, {"wallTime": 1733072371.743505, "step": 5000, "value": 0.0002500000118743628}, {"wallTime": 1733072380.527225, "step": 5010, "value": 0.0002500000118743628}, {"wallTime": 1733072389.0238683, "step": 5020, "value": 0.0002500000118743628}, {"wallTime": 1733072397.7828374, "step": 5030, "value": 0.0002500000118743628}, {"wallTime": 1733072411.2963398, "step": 5040, "value": 0.0002500000118743628}, {"wallTime": 1733072419.471319, "step": 5050, "value": 0.0002500000118743628}, {"wallTime": 1733072428.3697782, "step": 5060, "value": 0.0002500000118743628}, {"wallTime": 1733072437.1139936, "step": 5070, "value": 0.0002500000118743628}, {"wallTime": 1733072446.1727543, "step": 5080, "value": 0.0002500000118743628}, {"wallTime": 1733072454.4259558, "step": 5090, "value": 0.0002500000118743628}, {"wallTime": 1733072462.4080844, "step": 5100, "value": 0.0002500000118743628}, {"wallTime": 1733072471.147516, "step": 5110, "value": 0.0002500000118743628}, {"wallTime": 1733072478.9440272, "step": 5120, "value": 0.0002500000118743628}, {"wallTime": 1733072491.319718, "step": 5130, "value": 0.0002500000118743628}, {"wallTime": 1733072499.25625, "step": 5140, "value": 0.0002500000118743628}, {"wallTime": 1733072507.1093936, "step": 5150, "value": 0.0002500000118743628}, {"wallTime": 1733072515.3146014, "step": 5160, "value": 0.0002500000118743628}, {"wallTime": 1733072523.4966404, "step": 5170, "value": 0.0002500000118743628}, {"wallTime": 1733072531.0848215, "step": 5180, "value": 0.0002500000118743628}, {"wallTime": 1733072540.0185082, "step": 5190, "value": 0.0002500000118743628}, {"wallTime": 1733072548.648815, "step": 5200, "value": 0.0002500000118743628}, {"wallTime": 1733072561.4126651, "step": 5210, "value": 0.0002500000118743628}, {"wallTime": 1733072569.8930812, "step": 5220, "value": 0.0002500000118743628}, {"wallTime": 1733072578.6758342, "step": 5230, "value": 0.0002500000118743628}, {"wallTime": 1733072586.9388456, "step": 5240, "value": 0.0002500000118743628}, {"wallTime": 1733072595.031937, "step": 5250, "value": 0.0002500000118743628}, {"wallTime": 1733072603.170918, "step": 5260, "value": 0.0002500000118743628}, {"wallTime": 1733072611.077005, "step": 5270, "value": 0.0002500000118743628}, {"wallTime": 1733072619.951818, "step": 5280, "value": 0.0002500000118743628}, {"wallTime": 1733072628.63216, "step": 5290, "value": 0.0002500000118743628}, {"wallTime": 1733072641.3734725, "step": 5300, "value": 0.0002500000118743628}, {"wallTime": 1733072649.8551393, "step": 5310, "value": 0.0002500000118743628}, {"wallTime": 1733072657.9686887, "step": 5320, "value": 0.0002500000118743628}, {"wallTime": 1733072667.026602, "step": 5330, "value": 0.0002500000118743628}, {"wallTime": 1733072675.9404438, "step": 5340, "value": 0.0002500000118743628}, {"wallTime": 1733072684.235997, "step": 5350, "value": 0.0002500000118743628}, {"wallTime": 1733072691.8557227, "step": 5360, "value": 0.0002500000118743628}, {"wallTime": 1733072700.145555, "step": 5370, "value": 0.0002500000118743628}, {"wallTime": 1733072713.1810975, "step": 5380, "value": 0.0002500000118743628}, {"wallTime": 1733072721.0219035, "step": 5390, "value": 0.0002500000118743628}, {"wallTime": 1733072729.874542, "step": 5400, "value": 0.0002500000118743628}, {"wallTime": 1733072738.3659682, "step": 5410, "value": 0.0002500000118743628}, {"wallTime": 1733072746.3800645, "step": 5420, "value": 0.0002500000118743628}, {"wallTime": 1733072754.6152112, "step": 5430, "value": 0.0002500000118743628}, {"wallTime": 1733072762.5437617, "step": 5440, "value": 0.0002500000118743628}, {"wallTime": 1733072771.3580344, "step": 5450, "value": 0.0002500000118743628}, {"wallTime": 1733072787.1497471, "step": 5460, "value": 0.0002500000118743628}, {"wallTime": 1733072795.799773, "step": 5470, "value": 0.0002500000118743628}, {"wallTime": 1733072804.2395725, "step": 5480, "value": 0.0002500000118743628}, {"wallTime": 1733072812.3703494, "step": 5490, "value": 0.0002500000118743628}, {"wallTime": 1733072821.1565878, "step": 5500, "value": 0.0002500000118743628}, {"wallTime": 1733072830.0200577, "step": 5510, "value": 0.0002500000118743628}, {"wallTime": 1733072838.6925342, "step": 5520, "value": 0.0002500000118743628}, {"wallTime": 1733072846.9025126, "step": 5530, "value": 0.0002500000118743628}, {"wallTime": 1733072855.2429693, "step": 5540, "value": 0.0002500000118743628}, {"wallTime": 1733072870.6417298, "step": 5550, "value": 0.0002500000118743628}, {"wallTime": 1733072878.7259054, "step": 5560, "value": 0.0002500000118743628}, {"wallTime": 1733072886.6073794, "step": 5570, "value": 0.0002500000118743628}, {"wallTime": 1733072895.0180004, "step": 5580, "value": 0.0002500000118743628}, {"wallTime": 1733072903.4000404, "step": 5590, "value": 0.0002500000118743628}, {"wallTime": 1733072911.2072704, "step": 5600, "value": 0.0002500000118743628}, {"wallTime": 1733072919.8369827, "step": 5610, "value": 0.0002500000118743628}, {"wallTime": 1733072928.7303135, "step": 5620, "value": 0.0002500000118743628}, {"wallTime": 1733072941.7014925, "step": 5630, "value": 0.0002500000118743628}, {"wallTime": 1733072949.9771407, "step": 5640, "value": 0.0002500000118743628}, {"wallTime": 1733072958.7159772, "step": 5650, "value": 0.0002500000118743628}, {"wallTime": 1733072966.8109174, "step": 5660, "value": 0.0002500000118743628}, {"wallTime": 1733072974.958326, "step": 5670, "value": 0.0002500000118743628}, {"wallTime": 1733072983.559214, "step": 5680, "value": 0.0002500000118743628}, {"wallTime": 1733072992.2247143, "step": 5690, "value": 0.0002500000118743628}, {"wallTime": 1733073000.814375, "step": 5700, "value": 0.0002500000118743628}, {"wallTime": 1733073009.780502, "step": 5710, "value": 0.0002500000118743628}, {"wallTime": 1733073022.8660717, "step": 5720, "value": 0.0002500000118743628}, {"wallTime": 1733073031.530782, "step": 5730, "value": 0.0002500000118743628}, {"wallTime": 1733073039.5672379, "step": 5740, "value": 0.0002500000118743628}, {"wallTime": 1733073047.8400786, "step": 5750, "value": 0.0002500000118743628}, {"wallTime": 1733073056.1537945, "step": 5760, "value": 0.0002500000118743628}, {"wallTime": 1733073064.9524698, "step": 5770, "value": 0.0002500000118743628}, {"wallTime": 1733073073.8348541, "step": 5780, "value": 0.0002500000118743628}, {"wallTime": 1733073082.722133, "step": 5790, "value": 0.0002500000118743628}, {"wallTime": 1733073095.1007936, "step": 5800, "value": 0.0002500000118743628}, {"wallTime": 1733073103.3130527, "step": 5810, "value": 0.0002500000118743628}, {"wallTime": 1733073111.967773, "step": 5820, "value": 0.0002500000118743628}, {"wallTime": 1733073120.352513, "step": 5830, "value": 0.0002500000118743628}, {"wallTime": 1733073128.2066357, "step": 5840, "value": 0.0002500000118743628}, {"wallTime": 1733073136.7131398, "step": 5850, "value": 0.0002500000118743628}, {"wallTime": 1733073144.9252534, "step": 5860, "value": 0.0002500000118743628}, {"wallTime": 1733073153.0378714, "step": 5870, "value": 0.0002500000118743628}, {"wallTime": 1733073166.0004272, "step": 5880, "value": 0.0002500000118743628}, {"wallTime": 1733073174.65616, "step": 5890, "value": 0.0002500000118743628}, {"wallTime": 1733073182.5057395, "step": 5900, "value": 0.0002500000118743628}, {"wallTime": 1733073191.557001, "step": 5910, "value": 0.0002500000118743628}, {"wallTime": 1733073199.4076378, "step": 5920, "value": 0.0002500000118743628}, {"wallTime": 1733073207.462735, "step": 5930, "value": 0.0002500000118743628}, {"wallTime": 1733073215.6002705, "step": 5940, "value": 0.0002500000118743628}, {"wallTime": 1733073224.3556142, "step": 5950, "value": 0.0002500000118743628}, {"wallTime": 1733073232.8739588, "step": 5960, "value": 0.0002500000118743628}, {"wallTime": 1733073245.3717983, "step": 5970, "value": 0.0002500000118743628}, {"wallTime": 1733073253.1770499, "step": 5980, "value": 0.0002500000118743628}, {"wallTime": 1733073261.769632, "step": 5990, "value": 0.0002500000118743628}, {"wallTime": 1733073270.0574594, "step": 6000, "value": 0.0002500000118743628}, {"wallTime": 1733073278.8929234, "step": 6010, "value": 0.0002500000118743628}, {"wallTime": 1733073287.6797895, "step": 6020, "value": 0.0002500000118743628}, {"wallTime": 1733073297.2721627, "step": 6030, "value": 0.0002500000118743628}, {"wallTime": 1733073305.915814, "step": 6040, "value": 0.0002500000118743628}, {"wallTime": 1733073322.352936, "step": 6050, "value": 0.0002500000118743628}, {"wallTime": 1733073331.974907, "step": 6060, "value": 0.0002500000118743628}, {"wallTime": 1733073340.5198221, "step": 6070, "value": 0.0002500000118743628}, {"wallTime": 1733073349.5995245, "step": 6080, "value": 0.0002500000118743628}, {"wallTime": 1733073359.068618, "step": 6090, "value": 0.0002500000118743628}, {"wallTime": 1733073368.4004896, "step": 6100, "value": 0.0002500000118743628}, {"wallTime": 1733073377.6726243, "step": 6110, "value": 0.0002500000118743628}, {"wallTime": 1733073386.397891, "step": 6120, "value": 0.0002500000118743628}, {"wallTime": 1733073395.4491565, "step": 6130, "value": 0.0002500000118743628}, {"wallTime": 1733073408.149456, "step": 6140, "value": 0.0002500000118743628}, {"wallTime": 1733073417.3213768, "step": 6150, "value": 0.0002500000118743628}, {"wallTime": 1733073426.2532477, "step": 6160, "value": 0.0002500000118743628}, {"wallTime": 1733073434.8067594, "step": 6170, "value": 0.0002500000118743628}, {"wallTime": 1733073444.5102518, "step": 6180, "value": 0.0002500000118743628}, {"wallTime": 1733073453.1128848, "step": 6190, "value": 0.0002500000118743628}, {"wallTime": 1733073462.563178, "step": 6200, "value": 0.0002500000118743628}, {"wallTime": 1733073472.0218465, "step": 6210, "value": 0.0002500000118743628}, {"wallTime": 1733073484.4463744, "step": 6220, "value": 0.0002500000118743628}, {"wallTime": 1733073493.6576164, "step": 6230, "value": 0.0002500000118743628}, {"wallTime": 1733073502.4386053, "step": 6240, "value": 0.0002500000118743628}, {"wallTime": 1733073511.253353, "step": 6250, "value": 0.0002500000118743628}, {"wallTime": 1733073520.482624, "step": 6260, "value": 0.0002500000118743628}, {"wallTime": 1733073529.7790666, "step": 6270, "value": 0.0002500000118743628}, {"wallTime": 1733073539.6367788, "step": 6280, "value": 0.0002500000118743628}, {"wallTime": 1733073548.9082386, "step": 6290, "value": 0.0002500000118743628}, {"wallTime": 1733073560.6178281, "step": 6300, "value": 0.0002500000118743628}, {"wallTime": 1733073570.0664837, "step": 6310, "value": 0.0002500000118743628}, {"wallTime": 1733073579.478676, "step": 6320, "value": 0.0002500000118743628}, {"wallTime": 1733073587.6647253, "step": 6330, "value": 0.0002500000118743628}, {"wallTime": 1733073597.215558, "step": 6340, "value": 0.0002500000118743628}, {"wallTime": 1733073606.2357695, "step": 6350, "value": 0.0002500000118743628}, {"wallTime": 1733073615.075134, "step": 6360, "value": 0.0002500000118743628}, {"wallTime": 1733073624.8321192, "step": 6370, "value": 0.0002500000118743628}, {"wallTime": 1733073634.670078, "step": 6380, "value": 0.0002500000118743628}, {"wallTime": 1733073646.526291, "step": 6390, "value": 0.0002500000118743628}, {"wallTime": 1733073655.7430353, "step": 6400, "value": 0.0002500000118743628}, {"wallTime": 1733073665.6048124, "step": 6410, "value": 0.0002500000118743628}, {"wallTime": 1733073674.6403508, "step": 6420, "value": 0.0002500000118743628}, {"wallTime": 1733073683.667937, "step": 6430, "value": 0.0002500000118743628}, {"wallTime": 1733073692.8743248, "step": 6440, "value": 0.0002500000118743628}, {"wallTime": 1733073702.516753, "step": 6450, "value": 0.0002500000118743628}, {"wallTime": 1733073712.6249962, "step": 6460, "value": 0.0002500000118743628}, {"wallTime": 1733073724.045076, "step": 6470, "value": 0.0002500000118743628}, {"wallTime": 1733073732.825974, "step": 6480, "value": 0.0002500000118743628}, {"wallTime": 1733073741.9547436, "step": 6490, "value": 0.0002500000118743628}, {"wallTime": 1733073750.715306, "step": 6500, "value": 0.0002500000118743628}, {"wallTime": 1733073760.4857414, "step": 6510, "value": 0.0002500000118743628}, {"wallTime": 1733073769.860858, "step": 6520, "value": 0.0002500000118743628}, {"wallTime": 1733073779.1247282, "step": 6530, "value": 0.0002500000118743628}, {"wallTime": 1733073789.4753294, "step": 6540, "value": 0.0002500000118743628}, {"wallTime": 1733073798.1009624, "step": 6550, "value": 0.0002500000118743628}, {"wallTime": 1733073810.550935, "step": 6560, "value": 0.0002500000118743628}, {"wallTime": 1733073820.033921, "step": 6570, "value": 0.0002500000118743628}, {"wallTime": 1733073828.2359266, "step": 6580, "value": 0.0002500000118743628}, {"wallTime": 1733073836.7958407, "step": 6590, "value": 0.0002500000118743628}, {"wallTime": 1733073845.9851484, "step": 6600, "value": 0.0002500000118743628}, {"wallTime": 1733073855.249616, "step": 6610, "value": 0.0002500000118743628}, {"wallTime": 1733073864.6911955, "step": 6620, "value": 0.0002500000118743628}, {"wallTime": 1733073873.832335, "step": 6630, "value": 0.0002500000118743628}, {"wallTime": 1733073887.5227668, "step": 6640, "value": 0.0002500000118743628}, {"wallTime": 1733073897.3315885, "step": 6650, "value": 0.0002500000118743628}, {"wallTime": 1733073906.874481, "step": 6660, "value": 0.0002500000118743628}, {"wallTime": 1733073916.3480294, "step": 6670, "value": 0.0002500000118743628}, {"wallTime": 1733073925.6163425, "step": 6680, "value": 0.0002500000118743628}, {"wallTime": 1733073934.9144638, "step": 6690, "value": 0.0002500000118743628}, {"wallTime": 1733073943.7400813, "step": 6700, "value": 0.0002500000118743628}, {"wallTime": 1733073952.4749205, "step": 6710, "value": 0.0002500000118743628}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "8650" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Lr/pg_0%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Lr/pg_0", "runToSeries": {".": [{"wallTime": 1733067631.536557, "step": 0, "value": 5.000000058430487e-08}, {"wallTime": 1733067646.6496048, "step": 10, "value": 3.000000106112566e-07}, {"wallTime": 1733067660.7815595, "step": 20, "value": 5.499999815583578e-07}, {"wallTime": 1733067674.1347141, "step": 30, "value": 8.000000093488779e-07}, {"wallTime": 1733067687.0543995, "step": 40, "value": 1.050000037139398e-06}, {"wallTime": 1733067699.4902966, "step": 50, "value": 1.3000000080864993e-06}, {"wallTime": 1733067710.6265802, "step": 60, "value": 1.5499999790336005e-06}, {"wallTime": 1733067722.7528167, "step": 70, "value": 1.7999999499807018e-06}, {"wallTime": 1733067733.7226985, "step": 80, "value": 2.049999920927803e-06}, {"wallTime": 1733067750.944184, "step": 90, "value": 2.300000005561742e-06}, {"wallTime": 1733067761.9780767, "step": 100, "value": 2.550000090195681e-06}, {"wallTime": 1733067771.6034951, "step": 110, "value": 2.7999999474559445e-06}, {"wallTime": 1733067780.5443792, "step": 120, "value": 3.0500000320898835e-06}, {"wallTime": 1733067790.4824038, "step": 130, "value": 3.299999889350147e-06}, {"wallTime": 1733067799.102769, "step": 140, "value": 3.549999973984086e-06}, {"wallTime": 1733067809.4417474, "step": 150, "value": 3.800000058618025e-06}, {"wallTime": 1733067818.918026, "step": 160, "value": 4.0499999158782884e-06}, {"wallTime": 1733067836.6473477, "step": 170, "value": 4.300000000512227e-06}, {"wallTime": 1733067846.3878958, "step": 180, "value": 4.550000085146166e-06}, {"wallTime": 1733067855.6641512, "step": 190, "value": 4.800000169780105e-06}, {"wallTime": 1733067864.8855722, "step": 200, "value": 5.0499997996666934e-06}, {"wallTime": 1733067873.9988914, "step": 210, "value": 5.299999884300632e-06}, {"wallTime": 1733067883.7819028, "step": 220, "value": 5.549999968934571e-06}, {"wallTime": 1733067892.1201713, "step": 230, "value": 5.80000005356851e-06}, {"wallTime": 1733067901.0665321, "step": 240, "value": 6.050000138202449e-06}, {"wallTime": 1733067910.0722272, "step": 250, "value": 6.300000222836388e-06}, {"wallTime": 1733067925.94781, "step": 260, "value": 6.549999852722976e-06}, {"wallTime": 1733067935.4578474, "step": 270, "value": 6.799999937356915e-06}, {"wallTime": 1733067944.0115118, "step": 280, "value": 7.050000021990854e-06}, {"wallTime": 1733067952.5425746, "step": 290, "value": 7.300000106624793e-06}, {"wallTime": 1733067961.0239909, "step": 300, "value": 7.550000191258732e-06}, {"wallTime": 1733067970.131762, "step": 310, "value": 7.800000275892671e-06}, {"wallTime": 1733067980.2230701, "step": 320, "value": 8.05000036052661e-06}, {"wallTime": 1733067988.8132455, "step": 330, "value": 8.300000445160549e-06}, {"wallTime": 1733068005.0883172, "step": 340, "value": 8.549999620299786e-06}, {"wallTime": 1733068014.0621142, "step": 350, "value": 8.799999704933725e-06}, {"wallTime": 1733068022.5503154, "step": 360, "value": 9.049999789567664e-06}, {"wallTime": 1733068031.8220227, "step": 370, "value": 9.299999874201603e-06}, {"wallTime": 1733068040.7849078, "step": 380, "value": 9.549999958835542e-06}, {"wallTime": 1733068050.1574116, "step": 390, "value": 9.800000043469481e-06}, {"wallTime": 1733068059.1233578, "step": 400, "value": 1.005000012810342e-05}, {"wallTime": 1733068068.0874956, "step": 410, "value": 1.0300000212737359e-05}, {"wallTime": 1733068084.841626, "step": 420, "value": 1.0550000297371298e-05}, {"wallTime": 1733068094.6639369, "step": 430, "value": 1.0800000382005237e-05}, {"wallTime": 1733068103.7055042, "step": 440, "value": 1.1049999557144474e-05}, {"wallTime": 1733068112.6971717, "step": 450, "value": 1.1299999641778413e-05}, {"wallTime": 1733068121.4985075, "step": 460, "value": 1.1549999726412352e-05}, {"wallTime": 1733068130.7251797, "step": 470, "value": 1.1799999811046291e-05}, {"wallTime": 1733068139.8532035, "step": 480, "value": 1.204999989568023e-05}, {"wallTime": 1733068149.3677146, "step": 490, "value": 1.2299999980314169e-05}, {"wallTime": 1733068158.067713, "step": 500, "value": 1.249999968422344e-05}, {"wallTime": 1733068174.11326, "step": 510, "value": 1.249999968422344e-05}, {"wallTime": 1733068182.7172635, "step": 520, "value": 1.249999968422344e-05}, {"wallTime": 1733068192.4113297, "step": 530, "value": 1.249999968422344e-05}, {"wallTime": 1733068201.8058538, "step": 540, "value": 1.249999968422344e-05}, {"wallTime": 1733068210.6522427, "step": 550, "value": 1.249999968422344e-05}, {"wallTime": 1733068220.1926746, "step": 560, "value": 1.249999968422344e-05}, {"wallTime": 1733068229.156769, "step": 570, "value": 1.249999968422344e-05}, {"wallTime": 1733068238.5889041, "step": 580, "value": 1.249999968422344e-05}, {"wallTime": 1733068256.0707269, "step": 590, "value": 1.249999968422344e-05}, {"wallTime": 1733068265.4295568, "step": 600, "value": 1.249999968422344e-05}, {"wallTime": 1733068274.654187, "step": 610, "value": 1.249999968422344e-05}, {"wallTime": 1733068283.7676578, "step": 620, "value": 1.249999968422344e-05}, {"wallTime": 1733068293.3316967, "step": 630, "value": 1.249999968422344e-05}, {"wallTime": 1733068302.6447368, "step": 640, "value": 1.249999968422344e-05}, {"wallTime": 1733068311.3857307, "step": 650, "value": 1.249999968422344e-05}, {"wallTime": 1733068320.387876, "step": 660, "value": 1.249999968422344e-05}, {"wallTime": 1733068328.7290444, "step": 670, "value": 1.249999968422344e-05}, {"wallTime": 1733068344.4594798, "step": 680, "value": 1.249999968422344e-05}, {"wallTime": 1733068353.7147458, "step": 690, "value": 1.249999968422344e-05}, {"wallTime": 1733068362.0553637, "step": 700, "value": 1.249999968422344e-05}, {"wallTime": 1733068371.1017478, "step": 710, "value": 1.249999968422344e-05}, {"wallTime": 1733068380.5308557, "step": 720, "value": 1.249999968422344e-05}, {"wallTime": 1733068390.0845635, "step": 730, "value": 1.249999968422344e-05}, {"wallTime": 1733068398.7188644, "step": 740, "value": 1.249999968422344e-05}, {"wallTime": 1733068407.1216912, "step": 750, "value": 1.249999968422344e-05}, {"wallTime": 1733068423.06806, "step": 760, "value": 1.249999968422344e-05}, {"wallTime": 1733068431.4028146, "step": 770, "value": 1.249999968422344e-05}, {"wallTime": 1733068440.4227822, "step": 780, "value": 1.249999968422344e-05}, {"wallTime": 1733068449.0042632, "step": 790, "value": 1.249999968422344e-05}, {"wallTime": 1733068457.6339953, "step": 800, "value": 1.249999968422344e-05}, {"wallTime": 1733068467.045116, "step": 810, "value": 1.249999968422344e-05}, {"wallTime": 1733068475.6179328, "step": 820, "value": 1.249999968422344e-05}, {"wallTime": 1733068484.9766176, "step": 830, "value": 1.249999968422344e-05}, {"wallTime": 1733068500.7300224, "step": 840, "value": 1.249999968422344e-05}, {"wallTime": 1733068509.3054779, "step": 850, "value": 1.249999968422344e-05}, {"wallTime": 1733068519.020096, "step": 860, "value": 1.249999968422344e-05}, {"wallTime": 1733068527.4965758, "step": 870, "value": 1.249999968422344e-05}, {"wallTime": 1733068536.9181545, "step": 880, "value": 1.249999968422344e-05}, {"wallTime": 1733068544.906678, "step": 890, "value": 1.249999968422344e-05}, {"wallTime": 1733068553.5690846, "step": 900, "value": 1.249999968422344e-05}, {"wallTime": 1733068562.6840608, "step": 910, "value": 1.249999968422344e-05}, {"wallTime": 1733068571.2441492, "step": 920, "value": 1.249999968422344e-05}, {"wallTime": 1733068584.7749915, "step": 930, "value": 1.249999968422344e-05}, {"wallTime": 1733068593.7707772, "step": 940, "value": 1.249999968422344e-05}, {"wallTime": 1733068602.7649825, "step": 950, "value": 1.249999968422344e-05}, {"wallTime": 1733068611.0388448, "step": 960, "value": 1.249999968422344e-05}, {"wallTime": 1733068620.225874, "step": 970, "value": 1.249999968422344e-05}, {"wallTime": 1733068628.8408713, "step": 980, "value": 1.249999968422344e-05}, {"wallTime": 1733068637.6297624, "step": 990, "value": 1.249999968422344e-05}, {"wallTime": 1733068646.6720452, "step": 1000, "value": 1.249999968422344e-05}, {"wallTime": 1733068662.7566144, "step": 1010, "value": 1.249999968422344e-05}, {"wallTime": 1733068672.053688, "step": 1020, "value": 1.249999968422344e-05}, {"wallTime": 1733068680.5624745, "step": 1030, "value": 1.249999968422344e-05}, {"wallTime": 1733068690.185052, "step": 1040, "value": 1.249999968422344e-05}, {"wallTime": 1733068698.8474379, "step": 1050, "value": 1.249999968422344e-05}, {"wallTime": 1733068707.7427301, "step": 1060, "value": 1.249999968422344e-05}, {"wallTime": 1733068717.3441575, "step": 1070, "value": 1.249999968422344e-05}, {"wallTime": 1733068726.360877, "step": 1080, "value": 1.249999968422344e-05}, {"wallTime": 1733068735.250876, "step": 1090, "value": 1.249999968422344e-05}, {"wallTime": 1733068749.5479736, "step": 1100, "value": 1.249999968422344e-05}, {"wallTime": 1733068758.3748653, "step": 1110, "value": 1.249999968422344e-05}, {"wallTime": 1733068767.0033503, "step": 1120, "value": 1.249999968422344e-05}, {"wallTime": 1733068776.618407, "step": 1130, "value": 1.249999968422344e-05}, {"wallTime": 1733068785.4005206, "step": 1140, "value": 1.249999968422344e-05}, {"wallTime": 1733068794.2785742, "step": 1150, "value": 1.249999968422344e-05}, {"wallTime": 1733068802.6968825, "step": 1160, "value": 1.249999968422344e-05}, {"wallTime": 1733068811.5509558, "step": 1170, "value": 1.249999968422344e-05}, {"wallTime": 1733068824.9658704, "step": 1180, "value": 1.249999968422344e-05}, {"wallTime": 1733068834.376565, "step": 1190, "value": 1.249999968422344e-05}, {"wallTime": 1733068843.5156353, "step": 1200, "value": 1.249999968422344e-05}, {"wallTime": 1733068852.2278018, "step": 1210, "value": 1.249999968422344e-05}, {"wallTime": 1733068861.1162815, "step": 1220, "value": 1.249999968422344e-05}, {"wallTime": 1733068870.0553117, "step": 1230, "value": 1.249999968422344e-05}, {"wallTime": 1733068878.7199678, "step": 1240, "value": 1.249999968422344e-05}, {"wallTime": 1733068887.7315686, "step": 1250, "value": 1.249999968422344e-05}, {"wallTime": 1733068903.1668062, "step": 1260, "value": 1.249999968422344e-05}, {"wallTime": 1733068912.4051764, "step": 1270, "value": 1.249999968422344e-05}, {"wallTime": 1733068921.4715397, "step": 1280, "value": 1.249999968422344e-05}, {"wallTime": 1733068929.7462065, "step": 1290, "value": 1.249999968422344e-05}, {"wallTime": 1733068939.5004575, "step": 1300, "value": 1.249999968422344e-05}, {"wallTime": 1733068948.9269376, "step": 1310, "value": 1.249999968422344e-05}, {"wallTime": 1733068957.2339733, "step": 1320, "value": 1.249999968422344e-05}, {"wallTime": 1733068966.0765932, "step": 1330, "value": 1.249999968422344e-05}, {"wallTime": 1733068975.5647166, "step": 1340, "value": 1.249999968422344e-05}, {"wallTime": 1733068989.7973669, "step": 1350, "value": 1.249999968422344e-05}, {"wallTime": 1733068998.257093, "step": 1360, "value": 1.249999968422344e-05}, {"wallTime": 1733069007.1468704, "step": 1370, "value": 1.249999968422344e-05}, {"wallTime": 1733069015.919858, "step": 1380, "value": 1.249999968422344e-05}, {"wallTime": 1733069025.3027692, "step": 1390, "value": 1.249999968422344e-05}, {"wallTime": 1733069034.4809284, "step": 1400, "value": 1.249999968422344e-05}, {"wallTime": 1733069042.7924328, "step": 1410, "value": 1.249999968422344e-05}, {"wallTime": 1733069052.136804, "step": 1420, "value": 1.249999968422344e-05}, {"wallTime": 1733069065.0015063, "step": 1430, "value": 1.249999968422344e-05}, {"wallTime": 1733069074.5233195, "step": 1440, "value": 1.249999968422344e-05}, {"wallTime": 1733069083.775799, "step": 1450, "value": 1.249999968422344e-05}, {"wallTime": 1733069092.2568026, "step": 1460, "value": 1.249999968422344e-05}, {"wallTime": 1733069101.0289423, "step": 1470, "value": 1.249999968422344e-05}, {"wallTime": 1733069109.9044738, "step": 1480, "value": 1.249999968422344e-05}, {"wallTime": 1733069119.117016, "step": 1490, "value": 1.249999968422344e-05}, {"wallTime": 1733069128.4142327, "step": 1500, "value": 1.249999968422344e-05}, {"wallTime": 1733069137.6049776, "step": 1510, "value": 1.249999968422344e-05}, {"wallTime": 1733069150.5422988, "step": 1520, "value": 1.249999968422344e-05}, {"wallTime": 1733069159.755358, "step": 1530, "value": 1.249999968422344e-05}, {"wallTime": 1733069168.168512, "step": 1540, "value": 1.249999968422344e-05}, {"wallTime": 1733069176.8392684, "step": 1550, "value": 1.249999968422344e-05}, {"wallTime": 1733069185.8905978, "step": 1560, "value": 1.249999968422344e-05}, {"wallTime": 1733069194.9219427, "step": 1570, "value": 1.249999968422344e-05}, {"wallTime": 1733069203.9098995, "step": 1580, "value": 1.249999968422344e-05}, {"wallTime": 1733069212.7135751, "step": 1590, "value": 1.249999968422344e-05}, {"wallTime": 1733069225.5326903, "step": 1600, "value": 1.249999968422344e-05}, {"wallTime": 1733069235.4620845, "step": 1610, "value": 1.249999968422344e-05}, {"wallTime": 1733069244.6276577, "step": 1620, "value": 1.249999968422344e-05}, {"wallTime": 1733069254.2699614, "step": 1630, "value": 1.249999968422344e-05}, {"wallTime": 1733069263.0035076, "step": 1640, "value": 1.249999968422344e-05}, {"wallTime": 1733069271.864842, "step": 1650, "value": 1.249999968422344e-05}, {"wallTime": 1733069280.5081487, "step": 1660, "value": 1.249999968422344e-05}, {"wallTime": 1733069289.6780765, "step": 1670, "value": 1.249999968422344e-05}, {"wallTime": 1733069303.6071763, "step": 1680, "value": 1.249999968422344e-05}, {"wallTime": 1733069312.4775603, "step": 1690, "value": 1.249999968422344e-05}, {"wallTime": 1733069321.836787, "step": 1700, "value": 1.249999968422344e-05}, {"wallTime": 1733069330.3462205, "step": 1710, "value": 1.249999968422344e-05}, {"wallTime": 1733069339.2432067, "step": 1720, "value": 1.249999968422344e-05}, {"wallTime": 1733069346.8547583, "step": 1730, "value": 1.249999968422344e-05}, {"wallTime": 1733069355.650348, "step": 1740, "value": 1.249999968422344e-05}, {"wallTime": 1733069364.5100014, "step": 1750, "value": 1.249999968422344e-05}, {"wallTime": 1733069373.7365708, "step": 1760, "value": 1.249999968422344e-05}, {"wallTime": 1733069387.5397813, "step": 1770, "value": 1.249999968422344e-05}, {"wallTime": 1733069396.4646327, "step": 1780, "value": 1.249999968422344e-05}, {"wallTime": 1733069405.9945064, "step": 1790, "value": 1.249999968422344e-05}, {"wallTime": 1733069415.0518332, "step": 1800, "value": 1.249999968422344e-05}, {"wallTime": 1733069423.9058366, "step": 1810, "value": 1.249999968422344e-05}, {"wallTime": 1733069432.5291517, "step": 1820, "value": 1.249999968422344e-05}, {"wallTime": 1733069441.2148397, "step": 1830, "value": 1.249999968422344e-05}, {"wallTime": 1733069450.0845654, "step": 1840, "value": 1.249999968422344e-05}, {"wallTime": 1733069463.1053398, "step": 1850, "value": 1.249999968422344e-05}, {"wallTime": 1733069471.5705352, "step": 1860, "value": 1.249999968422344e-05}, {"wallTime": 1733069480.495936, "step": 1870, "value": 1.249999968422344e-05}, {"wallTime": 1733069489.3828392, "step": 1880, "value": 1.249999968422344e-05}, {"wallTime": 1733069497.9744413, "step": 1890, "value": 1.249999968422344e-05}, {"wallTime": 1733069506.7919583, "step": 1900, "value": 1.249999968422344e-05}, {"wallTime": 1733069515.822509, "step": 1910, "value": 1.249999968422344e-05}, {"wallTime": 1733069524.6343677, "step": 1920, "value": 1.249999968422344e-05}, {"wallTime": 1733069533.5398707, "step": 1930, "value": 1.249999968422344e-05}, {"wallTime": 1733069550.4763312, "step": 1940, "value": 1.249999968422344e-05}, {"wallTime": 1733069558.8255706, "step": 1950, "value": 1.249999968422344e-05}, {"wallTime": 1733069567.7556636, "step": 1960, "value": 1.249999968422344e-05}, {"wallTime": 1733069576.3428404, "step": 1970, "value": 1.249999968422344e-05}, {"wallTime": 1733069585.5267935, "step": 1980, "value": 1.249999968422344e-05}, {"wallTime": 1733069594.3480418, "step": 1990, "value": 1.249999968422344e-05}, {"wallTime": 1733069602.3992307, "step": 2000, "value": 1.249999968422344e-05}, {"wallTime": 1733069610.2474725, "step": 2010, "value": 1.249999968422344e-05}, {"wallTime": 1733069626.6851363, "step": 2020, "value": 1.249999968422344e-05}, {"wallTime": 1733069635.0285575, "step": 2030, "value": 1.249999968422344e-05}, {"wallTime": 1733069643.820398, "step": 2040, "value": 1.249999968422344e-05}, {"wallTime": 1733069652.192262, "step": 2050, "value": 1.249999968422344e-05}, {"wallTime": 1733069660.4512105, "step": 2060, "value": 1.249999968422344e-05}, {"wallTime": 1733069669.589865, "step": 2070, "value": 1.249999968422344e-05}, {"wallTime": 1733069678.7759247, "step": 2080, "value": 1.249999968422344e-05}, {"wallTime": 1733069686.9425492, "step": 2090, "value": 1.249999968422344e-05}, {"wallTime": 1733069700.600289, "step": 2100, "value": 1.249999968422344e-05}, {"wallTime": 1733069708.7240994, "step": 2110, "value": 1.249999968422344e-05}, {"wallTime": 1733069717.4461167, "step": 2120, "value": 1.249999968422344e-05}, {"wallTime": 1733069726.138997, "step": 2130, "value": 1.249999968422344e-05}, {"wallTime": 1733069735.035704, "step": 2140, "value": 1.249999968422344e-05}, {"wallTime": 1733069743.3035946, "step": 2150, "value": 1.249999968422344e-05}, {"wallTime": 1733069752.498438, "step": 2160, "value": 1.249999968422344e-05}, {"wallTime": 1733069761.448778, "step": 2170, "value": 1.249999968422344e-05}, {"wallTime": 1733069770.431007, "step": 2180, "value": 1.249999968422344e-05}, {"wallTime": 1733069784.3617144, "step": 2190, "value": 1.249999968422344e-05}, {"wallTime": 1733069793.1201758, "step": 2200, "value": 1.249999968422344e-05}, {"wallTime": 1733069801.6291392, "step": 2210, "value": 1.249999968422344e-05}, {"wallTime": 1733069810.605442, "step": 2220, "value": 1.249999968422344e-05}, {"wallTime": 1733069819.3392627, "step": 2230, "value": 1.249999968422344e-05}, {"wallTime": 1733069827.323884, "step": 2240, "value": 1.249999968422344e-05}, {"wallTime": 1733069835.865131, "step": 2250, "value": 1.249999968422344e-05}, {"wallTime": 1733069844.2333033, "step": 2260, "value": 1.249999968422344e-05}, {"wallTime": 1733069856.7473865, "step": 2270, "value": 1.249999968422344e-05}, {"wallTime": 1733069865.2551773, "step": 2280, "value": 1.249999968422344e-05}, {"wallTime": 1733069874.0024707, "step": 2290, "value": 1.249999968422344e-05}, {"wallTime": 1733069881.7791471, "step": 2300, "value": 1.249999968422344e-05}, {"wallTime": 1733069890.4111636, "step": 2310, "value": 1.249999968422344e-05}, {"wallTime": 1733069898.8742077, "step": 2320, "value": 1.249999968422344e-05}, {"wallTime": 1733069908.3153458, "step": 2330, "value": 1.249999968422344e-05}, {"wallTime": 1733069917.4127967, "step": 2340, "value": 1.249999968422344e-05}, {"wallTime": 1733069925.8476038, "step": 2350, "value": 1.249999968422344e-05}, {"wallTime": 1733069938.6997933, "step": 2360, "value": 1.249999968422344e-05}, {"wallTime": 1733069947.4236212, "step": 2370, "value": 1.249999968422344e-05}, {"wallTime": 1733069956.2030792, "step": 2380, "value": 1.249999968422344e-05}, {"wallTime": 1733069964.271938, "step": 2390, "value": 1.249999968422344e-05}, {"wallTime": 1733069973.3236587, "step": 2400, "value": 1.249999968422344e-05}, {"wallTime": 1733069981.429452, "step": 2410, "value": 1.249999968422344e-05}, {"wallTime": 1733069990.1370878, "step": 2420, "value": 1.249999968422344e-05}, {"wallTime": 1733069998.7951653, "step": 2430, "value": 1.249999968422344e-05}, {"wallTime": 1733070012.4537852, "step": 2440, "value": 1.249999968422344e-05}, {"wallTime": 1733070021.572249, "step": 2450, "value": 1.249999968422344e-05}, {"wallTime": 1733070030.1885068, "step": 2460, "value": 1.249999968422344e-05}, {"wallTime": 1733070039.2168138, "step": 2470, "value": 1.249999968422344e-05}, {"wallTime": 1733070048.2664409, "step": 2480, "value": 1.249999968422344e-05}, {"wallTime": 1733070056.1530836, "step": 2490, "value": 1.249999968422344e-05}, {"wallTime": 1733070064.4478757, "step": 2500, "value": 1.249999968422344e-05}, {"wallTime": 1733070072.5465353, "step": 2510, "value": 1.249999968422344e-05}, {"wallTime": 1733070087.6547363, "step": 2520, "value": 1.249999968422344e-05}, {"wallTime": 1733070095.4388158, "step": 2530, "value": 1.249999968422344e-05}, {"wallTime": 1733070103.7662873, "step": 2540, "value": 1.249999968422344e-05}, {"wallTime": 1733070113.0461605, "step": 2550, "value": 1.249999968422344e-05}, {"wallTime": 1733070121.035212, "step": 2560, "value": 1.249999968422344e-05}, {"wallTime": 1733070129.576319, "step": 2570, "value": 1.249999968422344e-05}, {"wallTime": 1733070138.3580902, "step": 2580, "value": 1.249999968422344e-05}, {"wallTime": 1733070147.0847676, "step": 2590, "value": 1.249999968422344e-05}, {"wallTime": 1733070155.484259, "step": 2600, "value": 1.249999968422344e-05}, {"wallTime": 1733070172.5752468, "step": 2610, "value": 1.249999968422344e-05}, {"wallTime": 1733070181.2084506, "step": 2620, "value": 1.249999968422344e-05}, {"wallTime": 1733070189.6895165, "step": 2630, "value": 1.249999968422344e-05}, {"wallTime": 1733070198.3966002, "step": 2640, "value": 1.249999968422344e-05}, {"wallTime": 1733070206.7048173, "step": 2650, "value": 1.249999968422344e-05}, {"wallTime": 1733070215.5971313, "step": 2660, "value": 1.249999968422344e-05}, {"wallTime": 1733070224.3127754, "step": 2670, "value": 1.249999968422344e-05}, {"wallTime": 1733070233.536668, "step": 2680, "value": 1.249999968422344e-05}, {"wallTime": 1733070246.7560668, "step": 2690, "value": 1.249999968422344e-05}, {"wallTime": 1733070256.0260673, "step": 2700, "value": 1.249999968422344e-05}, {"wallTime": 1733070264.9482548, "step": 2710, "value": 1.249999968422344e-05}, {"wallTime": 1733070273.8021758, "step": 2720, "value": 1.249999968422344e-05}, {"wallTime": 1733070282.9563854, "step": 2730, "value": 1.249999968422344e-05}, {"wallTime": 1733070292.2753677, "step": 2740, "value": 1.249999968422344e-05}, {"wallTime": 1733070300.3339994, "step": 2750, "value": 1.249999968422344e-05}, {"wallTime": 1733070309.4096065, "step": 2760, "value": 1.249999968422344e-05}, {"wallTime": 1733070317.5289624, "step": 2770, "value": 1.249999968422344e-05}, {"wallTime": 1733070330.4340641, "step": 2780, "value": 1.249999968422344e-05}, {"wallTime": 1733070339.8200097, "step": 2790, "value": 1.249999968422344e-05}, {"wallTime": 1733070347.990365, "step": 2800, "value": 1.249999968422344e-05}, {"wallTime": 1733070356.8882668, "step": 2810, "value": 1.249999968422344e-05}, {"wallTime": 1733070365.5742996, "step": 2820, "value": 1.249999968422344e-05}, {"wallTime": 1733070374.38994, "step": 2830, "value": 1.249999968422344e-05}, {"wallTime": 1733070382.4244616, "step": 2840, "value": 1.249999968422344e-05}, {"wallTime": 1733070390.9385977, "step": 2850, "value": 1.249999968422344e-05}, {"wallTime": 1733070406.676718, "step": 2860, "value": 1.249999968422344e-05}, {"wallTime": 1733070415.0862448, "step": 2870, "value": 1.249999968422344e-05}, {"wallTime": 1733070422.9175017, "step": 2880, "value": 1.249999968422344e-05}, {"wallTime": 1733070431.5348063, "step": 2890, "value": 1.249999968422344e-05}, {"wallTime": 1733070439.9782577, "step": 2900, "value": 1.249999968422344e-05}, {"wallTime": 1733070448.082779, "step": 2910, "value": 1.249999968422344e-05}, {"wallTime": 1733070457.421103, "step": 2920, "value": 1.249999968422344e-05}, {"wallTime": 1733070466.7203553, "step": 2930, "value": 1.249999968422344e-05}, {"wallTime": 1733070479.330495, "step": 2940, "value": 1.249999968422344e-05}, {"wallTime": 1733070488.7795491, "step": 2950, "value": 1.249999968422344e-05}, {"wallTime": 1733070497.2223294, "step": 2960, "value": 1.249999968422344e-05}, {"wallTime": 1733070505.6311104, "step": 2970, "value": 1.249999968422344e-05}, {"wallTime": 1733070513.3513088, "step": 2980, "value": 1.249999968422344e-05}, {"wallTime": 1733070522.2983687, "step": 2990, "value": 1.249999968422344e-05}, {"wallTime": 1733070530.209923, "step": 3000, "value": 1.249999968422344e-05}, {"wallTime": 1733070538.2975178, "step": 3010, "value": 1.249999968422344e-05}, {"wallTime": 1733070547.3977897, "step": 3020, "value": 1.249999968422344e-05}, {"wallTime": 1733070564.0487444, "step": 3030, "value": 1.249999968422344e-05}, {"wallTime": 1733070572.3671207, "step": 3040, "value": 1.249999968422344e-05}, {"wallTime": 1733070580.6681132, "step": 3050, "value": 1.249999968422344e-05}, {"wallTime": 1733070588.650674, "step": 3060, "value": 1.249999968422344e-05}, {"wallTime": 1733070597.4179661, "step": 3070, "value": 1.249999968422344e-05}, {"wallTime": 1733070606.1346867, "step": 3080, "value": 1.249999968422344e-05}, {"wallTime": 1733070614.436445, "step": 3090, "value": 1.249999968422344e-05}, {"wallTime": 1733070623.9972537, "step": 3100, "value": 1.249999968422344e-05}, {"wallTime": 1733070637.2499385, "step": 3110, "value": 1.249999968422344e-05}, {"wallTime": 1733070645.6791856, "step": 3120, "value": 1.249999968422344e-05}, {"wallTime": 1733070654.2669919, "step": 3130, "value": 1.249999968422344e-05}, {"wallTime": 1733070663.3177862, "step": 3140, "value": 1.249999968422344e-05}, {"wallTime": 1733070671.1143396, "step": 3150, "value": 1.249999968422344e-05}, {"wallTime": 1733070679.7619739, "step": 3160, "value": 1.249999968422344e-05}, {"wallTime": 1733070687.841059, "step": 3170, "value": 1.249999968422344e-05}, {"wallTime": 1733070695.8521602, "step": 3180, "value": 1.249999968422344e-05}, {"wallTime": 1733070704.6189544, "step": 3190, "value": 1.249999968422344e-05}, {"wallTime": 1733070717.10592, "step": 3200, "value": 1.249999968422344e-05}, {"wallTime": 1733070726.0951753, "step": 3210, "value": 1.249999968422344e-05}, {"wallTime": 1733070734.7724426, "step": 3220, "value": 1.249999968422344e-05}, {"wallTime": 1733070744.4080935, "step": 3230, "value": 1.249999968422344e-05}, {"wallTime": 1733070752.497953, "step": 3240, "value": 1.249999968422344e-05}, {"wallTime": 1733070761.7174625, "step": 3250, "value": 1.249999968422344e-05}, {"wallTime": 1733070770.3729467, "step": 3260, "value": 1.249999968422344e-05}, {"wallTime": 1733070779.7265418, "step": 3270, "value": 1.249999968422344e-05}, {"wallTime": 1733070793.6753175, "step": 3280, "value": 1.249999968422344e-05}, {"wallTime": 1733070801.8965616, "step": 3290, "value": 1.249999968422344e-05}, {"wallTime": 1733070810.1576047, "step": 3300, "value": 1.249999968422344e-05}, {"wallTime": 1733070818.722502, "step": 3310, "value": 1.249999968422344e-05}, {"wallTime": 1733070827.0025358, "step": 3320, "value": 1.249999968422344e-05}, {"wallTime": 1733070835.5702252, "step": 3330, "value": 1.249999968422344e-05}, {"wallTime": 1733070843.969958, "step": 3340, "value": 1.249999968422344e-05}, {"wallTime": 1733070853.0877955, "step": 3350, "value": 1.249999968422344e-05}, {"wallTime": 1733070865.4165874, "step": 3360, "value": 1.249999968422344e-05}, {"wallTime": 1733070873.6578898, "step": 3370, "value": 1.249999968422344e-05}, {"wallTime": 1733070883.3323934, "step": 3380, "value": 1.249999968422344e-05}, {"wallTime": 1733070892.3733048, "step": 3390, "value": 1.249999968422344e-05}, {"wallTime": 1733070900.7187858, "step": 3400, "value": 1.249999968422344e-05}, {"wallTime": 1733070908.5007596, "step": 3410, "value": 1.249999968422344e-05}, {"wallTime": 1733070916.6523395, "step": 3420, "value": 1.249999968422344e-05}, {"wallTime": 1733070925.2042499, "step": 3430, "value": 1.249999968422344e-05}, {"wallTime": 1733070933.8068717, "step": 3440, "value": 1.249999968422344e-05}, {"wallTime": 1733070947.4768612, "step": 3450, "value": 1.249999968422344e-05}, {"wallTime": 1733070956.183697, "step": 3460, "value": 1.249999968422344e-05}, {"wallTime": 1733070964.2628775, "step": 3470, "value": 1.249999968422344e-05}, {"wallTime": 1733070972.3826005, "step": 3480, "value": 1.249999968422344e-05}, {"wallTime": 1733070980.6437435, "step": 3490, "value": 1.249999968422344e-05}, {"wallTime": 1733070989.68401, "step": 3500, "value": 1.249999968422344e-05}, {"wallTime": 1733070997.7848587, "step": 3510, "value": 1.249999968422344e-05}, {"wallTime": 1733071006.2679472, "step": 3520, "value": 1.249999968422344e-05}, {"wallTime": 1733071018.8931277, "step": 3530, "value": 1.249999968422344e-05}, {"wallTime": 1733071027.1930718, "step": 3540, "value": 1.249999968422344e-05}, {"wallTime": 1733071035.317122, "step": 3550, "value": 1.249999968422344e-05}, {"wallTime": 1733071043.74225, "step": 3560, "value": 1.249999968422344e-05}, {"wallTime": 1733071051.8687775, "step": 3570, "value": 1.249999968422344e-05}, {"wallTime": 1733071060.4927807, "step": 3580, "value": 1.249999968422344e-05}, {"wallTime": 1733071068.8757539, "step": 3590, "value": 1.249999968422344e-05}, {"wallTime": 1733071077.7095819, "step": 3600, "value": 1.249999968422344e-05}, {"wallTime": 1733071086.2089846, "step": 3610, "value": 1.249999968422344e-05}, {"wallTime": 1733071101.6558397, "step": 3620, "value": 1.249999968422344e-05}, {"wallTime": 1733071109.6163685, "step": 3630, "value": 1.249999968422344e-05}, {"wallTime": 1733071118.12593, "step": 3640, "value": 1.249999968422344e-05}, {"wallTime": 1733071126.9896266, "step": 3650, "value": 1.249999968422344e-05}, {"wallTime": 1733071135.824047, "step": 3660, "value": 1.249999968422344e-05}, {"wallTime": 1733071144.2448921, "step": 3670, "value": 1.249999968422344e-05}, {"wallTime": 1733071152.9612408, "step": 3680, "value": 1.249999968422344e-05}, {"wallTime": 1733071160.5999033, "step": 3690, "value": 1.249999968422344e-05}, {"wallTime": 1733071173.7474597, "step": 3700, "value": 1.249999968422344e-05}, {"wallTime": 1733071182.8799493, "step": 3710, "value": 1.249999968422344e-05}, {"wallTime": 1733071191.206578, "step": 3720, "value": 1.249999968422344e-05}, {"wallTime": 1733071200.3299863, "step": 3730, "value": 1.249999968422344e-05}, {"wallTime": 1733071208.362433, "step": 3740, "value": 1.249999968422344e-05}, {"wallTime": 1733071216.568532, "step": 3750, "value": 1.249999968422344e-05}, {"wallTime": 1733071224.6586165, "step": 3760, "value": 1.249999968422344e-05}, {"wallTime": 1733071232.857294, "step": 3770, "value": 1.249999968422344e-05}, {"wallTime": 1733071248.530559, "step": 3780, "value": 1.249999968422344e-05}, {"wallTime": 1733071257.3881967, "step": 3790, "value": 1.249999968422344e-05}, {"wallTime": 1733071265.5641305, "step": 3800, "value": 1.249999968422344e-05}, {"wallTime": 1733071274.1754694, "step": 3810, "value": 1.249999968422344e-05}, {"wallTime": 1733071283.014764, "step": 3820, "value": 1.249999968422344e-05}, {"wallTime": 1733071291.7262938, "step": 3830, "value": 1.249999968422344e-05}, {"wallTime": 1733071299.8883896, "step": 3840, "value": 1.249999968422344e-05}, {"wallTime": 1733071308.4761631, "step": 3850, "value": 1.249999968422344e-05}, {"wallTime": 1733071316.948224, "step": 3860, "value": 1.249999968422344e-05}, {"wallTime": 1733071330.2123919, "step": 3870, "value": 1.249999968422344e-05}, {"wallTime": 1733071338.9857688, "step": 3880, "value": 1.249999968422344e-05}, {"wallTime": 1733071347.7338219, "step": 3890, "value": 1.249999968422344e-05}, {"wallTime": 1733071357.0309892, "step": 3900, "value": 1.249999968422344e-05}, {"wallTime": 1733071365.2222636, "step": 3910, "value": 1.249999968422344e-05}, {"wallTime": 1733071374.1317713, "step": 3920, "value": 1.249999968422344e-05}, {"wallTime": 1733071382.8108819, "step": 3930, "value": 1.249999968422344e-05}, {"wallTime": 1733071391.5654743, "step": 3940, "value": 1.249999968422344e-05}, {"wallTime": 1733071404.464801, "step": 3950, "value": 1.249999968422344e-05}, {"wallTime": 1733071412.3357015, "step": 3960, "value": 1.249999968422344e-05}, {"wallTime": 1733071421.15447, "step": 3970, "value": 1.249999968422344e-05}, {"wallTime": 1733071430.1174436, "step": 3980, "value": 1.249999968422344e-05}, {"wallTime": 1733071438.4111257, "step": 3990, "value": 1.249999968422344e-05}, {"wallTime": 1733071447.7256374, "step": 4000, "value": 1.249999968422344e-05}, {"wallTime": 1733071456.1936357, "step": 4010, "value": 1.249999968422344e-05}, {"wallTime": 1733071464.7466264, "step": 4020, "value": 1.249999968422344e-05}, {"wallTime": 1733071473.393913, "step": 4030, "value": 1.249999968422344e-05}, {"wallTime": 1733071490.2841122, "step": 4040, "value": 1.249999968422344e-05}, {"wallTime": 1733071498.7089229, "step": 4050, "value": 1.249999968422344e-05}, {"wallTime": 1733071507.0945516, "step": 4060, "value": 1.249999968422344e-05}, {"wallTime": 1733071515.0649257, "step": 4070, "value": 1.249999968422344e-05}, {"wallTime": 1733071523.878504, "step": 4080, "value": 1.249999968422344e-05}, {"wallTime": 1733071532.2825015, "step": 4090, "value": 1.249999968422344e-05}, {"wallTime": 1733071540.915065, "step": 4100, "value": 1.249999968422344e-05}, {"wallTime": 1733071549.1736207, "step": 4110, "value": 1.249999968422344e-05}, {"wallTime": 1733071565.8339064, "step": 4120, "value": 1.249999968422344e-05}, {"wallTime": 1733071573.629135, "step": 4130, "value": 1.249999968422344e-05}, {"wallTime": 1733071582.093562, "step": 4140, "value": 1.249999968422344e-05}, {"wallTime": 1733071590.0199776, "step": 4150, "value": 1.249999968422344e-05}, {"wallTime": 1733071599.2384634, "step": 4160, "value": 1.249999968422344e-05}, {"wallTime": 1733071608.0613816, "step": 4170, "value": 1.249999968422344e-05}, {"wallTime": 1733071616.1815078, "step": 4180, "value": 1.249999968422344e-05}, {"wallTime": 1733071626.0805767, "step": 4190, "value": 1.249999968422344e-05}, {"wallTime": 1733071641.0060723, "step": 4200, "value": 1.249999968422344e-05}, {"wallTime": 1733071649.0381916, "step": 4210, "value": 1.249999968422344e-05}, {"wallTime": 1733071658.529136, "step": 4220, "value": 1.249999968422344e-05}, {"wallTime": 1733071667.9638205, "step": 4230, "value": 1.249999968422344e-05}, {"wallTime": 1733071676.1064825, "step": 4240, "value": 1.249999968422344e-05}, {"wallTime": 1733071684.3761868, "step": 4250, "value": 1.249999968422344e-05}, {"wallTime": 1733071693.1074207, "step": 4260, "value": 1.249999968422344e-05}, {"wallTime": 1733071702.1816854, "step": 4270, "value": 1.249999968422344e-05}, {"wallTime": 1733071710.6275933, "step": 4280, "value": 1.249999968422344e-05}, {"wallTime": 1733071726.6751895, "step": 4290, "value": 1.249999968422344e-05}, {"wallTime": 1733071735.2134404, "step": 4300, "value": 1.249999968422344e-05}, {"wallTime": 1733071742.9549835, "step": 4310, "value": 1.249999968422344e-05}, {"wallTime": 1733071751.5837383, "step": 4320, "value": 1.249999968422344e-05}, {"wallTime": 1733071760.03255, "step": 4330, "value": 1.249999968422344e-05}, {"wallTime": 1733071768.429276, "step": 4340, "value": 1.249999968422344e-05}, {"wallTime": 1733071777.3998291, "step": 4350, "value": 1.249999968422344e-05}, {"wallTime": 1733071785.545317, "step": 4360, "value": 1.249999968422344e-05}, {"wallTime": 1733071800.8832357, "step": 4370, "value": 1.249999968422344e-05}, {"wallTime": 1733071809.2635577, "step": 4380, "value": 1.249999968422344e-05}, {"wallTime": 1733071817.3441207, "step": 4390, "value": 1.249999968422344e-05}, {"wallTime": 1733071826.4281602, "step": 4400, "value": 1.249999968422344e-05}, {"wallTime": 1733071834.885597, "step": 4410, "value": 1.249999968422344e-05}, {"wallTime": 1733071843.4445755, "step": 4420, "value": 1.249999968422344e-05}, {"wallTime": 1733071851.5937905, "step": 4430, "value": 1.249999968422344e-05}, {"wallTime": 1733071859.921486, "step": 4440, "value": 1.249999968422344e-05}, {"wallTime": 1733071868.6710682, "step": 4450, "value": 1.249999968422344e-05}, {"wallTime": 1733071881.3347015, "step": 4460, "value": 1.249999968422344e-05}, {"wallTime": 1733071889.633986, "step": 4470, "value": 1.249999968422344e-05}, {"wallTime": 1733071898.418782, "step": 4480, "value": 1.249999968422344e-05}, {"wallTime": 1733071907.3340273, "step": 4490, "value": 1.249999968422344e-05}, {"wallTime": 1733071916.2758863, "step": 4500, "value": 1.249999968422344e-05}, {"wallTime": 1733071925.3466966, "step": 4510, "value": 1.249999968422344e-05}, {"wallTime": 1733071933.3271601, "step": 4520, "value": 1.249999968422344e-05}, {"wallTime": 1733071941.4806156, "step": 4530, "value": 1.249999968422344e-05}, {"wallTime": 1733071954.1674187, "step": 4540, "value": 1.249999968422344e-05}, {"wallTime": 1733071962.393624, "step": 4550, "value": 1.249999968422344e-05}, {"wallTime": 1733071970.511034, "step": 4560, "value": 1.249999968422344e-05}, {"wallTime": 1733071978.8677132, "step": 4570, "value": 1.249999968422344e-05}, {"wallTime": 1733071987.7084346, "step": 4580, "value": 1.249999968422344e-05}, {"wallTime": 1733071996.441844, "step": 4590, "value": 1.249999968422344e-05}, {"wallTime": 1733072004.4738164, "step": 4600, "value": 1.249999968422344e-05}, {"wallTime": 1733072012.7423463, "step": 4610, "value": 1.249999968422344e-05}, {"wallTime": 1733072025.3984435, "step": 4620, "value": 1.249999968422344e-05}, {"wallTime": 1733072034.1157532, "step": 4630, "value": 1.249999968422344e-05}, {"wallTime": 1733072043.0350182, "step": 4640, "value": 1.249999968422344e-05}, {"wallTime": 1733072051.781878, "step": 4650, "value": 1.249999968422344e-05}, {"wallTime": 1733072060.1055973, "step": 4660, "value": 1.249999968422344e-05}, {"wallTime": 1733072068.6004615, "step": 4670, "value": 1.249999968422344e-05}, {"wallTime": 1733072076.8338926, "step": 4680, "value": 1.249999968422344e-05}, {"wallTime": 1733072085.3734393, "step": 4690, "value": 1.249999968422344e-05}, {"wallTime": 1733072093.745884, "step": 4700, "value": 1.249999968422344e-05}, {"wallTime": 1733072106.9874856, "step": 4710, "value": 1.249999968422344e-05}, {"wallTime": 1733072115.6623094, "step": 4720, "value": 1.249999968422344e-05}, {"wallTime": 1733072123.9477155, "step": 4730, "value": 1.249999968422344e-05}, {"wallTime": 1733072132.2777271, "step": 4740, "value": 1.249999968422344e-05}, {"wallTime": 1733072140.4175844, "step": 4750, "value": 1.249999968422344e-05}, {"wallTime": 1733072149.0844157, "step": 4760, "value": 1.249999968422344e-05}, {"wallTime": 1733072157.408921, "step": 4770, "value": 1.249999968422344e-05}, {"wallTime": 1733072165.4865088, "step": 4780, "value": 1.249999968422344e-05}, {"wallTime": 1733072179.645502, "step": 4790, "value": 1.249999968422344e-05}, {"wallTime": 1733072188.3266943, "step": 4800, "value": 1.249999968422344e-05}, {"wallTime": 1733072196.8442273, "step": 4810, "value": 1.249999968422344e-05}, {"wallTime": 1733072204.559388, "step": 4820, "value": 1.249999968422344e-05}, {"wallTime": 1733072213.0967574, "step": 4830, "value": 1.249999968422344e-05}, {"wallTime": 1733072221.6639993, "step": 4840, "value": 1.249999968422344e-05}, {"wallTime": 1733072229.891198, "step": 4850, "value": 1.249999968422344e-05}, {"wallTime": 1733072238.053305, "step": 4860, "value": 1.249999968422344e-05}, {"wallTime": 1733072246.340686, "step": 4870, "value": 1.249999968422344e-05}, {"wallTime": 1733072261.2650998, "step": 4880, "value": 1.249999968422344e-05}, {"wallTime": 1733072269.8492703, "step": 4890, "value": 1.249999968422344e-05}, {"wallTime": 1733072278.8584476, "step": 4900, "value": 1.249999968422344e-05}, {"wallTime": 1733072287.5317867, "step": 4910, "value": 1.249999968422344e-05}, {"wallTime": 1733072295.9442585, "step": 4920, "value": 1.249999968422344e-05}, {"wallTime": 1733072304.3528059, "step": 4930, "value": 1.249999968422344e-05}, {"wallTime": 1733072313.507221, "step": 4940, "value": 1.249999968422344e-05}, {"wallTime": 1733072321.322486, "step": 4950, "value": 1.249999968422344e-05}, {"wallTime": 1733072337.0228422, "step": 4960, "value": 1.249999968422344e-05}, {"wallTime": 1733072345.5278046, "step": 4970, "value": 1.249999968422344e-05}, {"wallTime": 1733072353.4271088, "step": 4980, "value": 1.249999968422344e-05}, {"wallTime": 1733072362.4107647, "step": 4990, "value": 1.249999968422344e-05}, {"wallTime": 1733072371.7434716, "step": 5000, "value": 1.249999968422344e-05}, {"wallTime": 1733072380.5271919, "step": 5010, "value": 1.249999968422344e-05}, {"wallTime": 1733072389.0238347, "step": 5020, "value": 1.249999968422344e-05}, {"wallTime": 1733072397.7828026, "step": 5030, "value": 1.249999968422344e-05}, {"wallTime": 1733072411.296306, "step": 5040, "value": 1.249999968422344e-05}, {"wallTime": 1733072419.4712865, "step": 5050, "value": 1.249999968422344e-05}, {"wallTime": 1733072428.369746, "step": 5060, "value": 1.249999968422344e-05}, {"wallTime": 1733072437.1139603, "step": 5070, "value": 1.249999968422344e-05}, {"wallTime": 1733072446.1727164, "step": 5080, "value": 1.249999968422344e-05}, {"wallTime": 1733072454.4259202, "step": 5090, "value": 1.249999968422344e-05}, {"wallTime": 1733072462.4080505, "step": 5100, "value": 1.249999968422344e-05}, {"wallTime": 1733072471.147482, "step": 5110, "value": 1.249999968422344e-05}, {"wallTime": 1733072478.943994, "step": 5120, "value": 1.249999968422344e-05}, {"wallTime": 1733072491.3196843, "step": 5130, "value": 1.249999968422344e-05}, {"wallTime": 1733072499.2562168, "step": 5140, "value": 1.249999968422344e-05}, {"wallTime": 1733072507.1093543, "step": 5150, "value": 1.249999968422344e-05}, {"wallTime": 1733072515.314568, "step": 5160, "value": 1.249999968422344e-05}, {"wallTime": 1733072523.4965968, "step": 5170, "value": 1.249999968422344e-05}, {"wallTime": 1733072531.0847883, "step": 5180, "value": 1.249999968422344e-05}, {"wallTime": 1733072540.0184643, "step": 5190, "value": 1.249999968422344e-05}, {"wallTime": 1733072548.6487699, "step": 5200, "value": 1.249999968422344e-05}, {"wallTime": 1733072561.4126112, "step": 5210, "value": 1.249999968422344e-05}, {"wallTime": 1733072569.8930328, "step": 5220, "value": 1.249999968422344e-05}, {"wallTime": 1733072578.675791, "step": 5230, "value": 1.249999968422344e-05}, {"wallTime": 1733072586.9387953, "step": 5240, "value": 1.249999968422344e-05}, {"wallTime": 1733072595.0319011, "step": 5250, "value": 1.249999968422344e-05}, {"wallTime": 1733072603.1708846, "step": 5260, "value": 1.249999968422344e-05}, {"wallTime": 1733072611.0769663, "step": 5270, "value": 1.249999968422344e-05}, {"wallTime": 1733072619.9517853, "step": 5280, "value": 1.249999968422344e-05}, {"wallTime": 1733072628.632127, "step": 5290, "value": 1.249999968422344e-05}, {"wallTime": 1733072641.373439, "step": 5300, "value": 1.249999968422344e-05}, {"wallTime": 1733072649.8551047, "step": 5310, "value": 1.249999968422344e-05}, {"wallTime": 1733072657.9686549, "step": 5320, "value": 1.249999968422344e-05}, {"wallTime": 1733072667.0265687, "step": 5330, "value": 1.249999968422344e-05}, {"wallTime": 1733072675.9404113, "step": 5340, "value": 1.249999968422344e-05}, {"wallTime": 1733072684.2359643, "step": 5350, "value": 1.249999968422344e-05}, {"wallTime": 1733072691.85569, "step": 5360, "value": 1.249999968422344e-05}, {"wallTime": 1733072700.1455224, "step": 5370, "value": 1.249999968422344e-05}, {"wallTime": 1733072713.1810632, "step": 5380, "value": 1.249999968422344e-05}, {"wallTime": 1733072721.021871, "step": 5390, "value": 1.249999968422344e-05}, {"wallTime": 1733072729.8745096, "step": 5400, "value": 1.249999968422344e-05}, {"wallTime": 1733072738.3659217, "step": 5410, "value": 1.249999968422344e-05}, {"wallTime": 1733072746.3800309, "step": 5420, "value": 1.249999968422344e-05}, {"wallTime": 1733072754.6151788, "step": 5430, "value": 1.249999968422344e-05}, {"wallTime": 1733072762.5437121, "step": 5440, "value": 1.249999968422344e-05}, {"wallTime": 1733072771.3580017, "step": 5450, "value": 1.249999968422344e-05}, {"wallTime": 1733072787.1497114, "step": 5460, "value": 1.249999968422344e-05}, {"wallTime": 1733072795.7997391, "step": 5470, "value": 1.249999968422344e-05}, {"wallTime": 1733072804.2395391, "step": 5480, "value": 1.249999968422344e-05}, {"wallTime": 1733072812.370315, "step": 5490, "value": 1.249999968422344e-05}, {"wallTime": 1733072821.1565535, "step": 5500, "value": 1.249999968422344e-05}, {"wallTime": 1733072830.020023, "step": 5510, "value": 1.249999968422344e-05}, {"wallTime": 1733072838.6925, "step": 5520, "value": 1.249999968422344e-05}, {"wallTime": 1733072846.90248, "step": 5530, "value": 1.249999968422344e-05}, {"wallTime": 1733072855.2429209, "step": 5540, "value": 1.249999968422344e-05}, {"wallTime": 1733072870.641686, "step": 5550, "value": 1.249999968422344e-05}, {"wallTime": 1733072878.7258549, "step": 5560, "value": 1.249999968422344e-05}, {"wallTime": 1733072886.6073303, "step": 5570, "value": 1.249999968422344e-05}, {"wallTime": 1733072895.0179622, "step": 5580, "value": 1.249999968422344e-05}, {"wallTime": 1733072903.4000077, "step": 5590, "value": 1.249999968422344e-05}, {"wallTime": 1733072911.2072375, "step": 5600, "value": 1.249999968422344e-05}, {"wallTime": 1733072919.8369424, "step": 5610, "value": 1.249999968422344e-05}, {"wallTime": 1733072928.7302754, "step": 5620, "value": 1.249999968422344e-05}, {"wallTime": 1733072941.701458, "step": 5630, "value": 1.249999968422344e-05}, {"wallTime": 1733072949.9771078, "step": 5640, "value": 1.249999968422344e-05}, {"wallTime": 1733072958.7159278, "step": 5650, "value": 1.249999968422344e-05}, {"wallTime": 1733072966.8108623, "step": 5660, "value": 1.249999968422344e-05}, {"wallTime": 1733072974.9582732, "step": 5670, "value": 1.249999968422344e-05}, {"wallTime": 1733072983.5591812, "step": 5680, "value": 1.249999968422344e-05}, {"wallTime": 1733072992.2246654, "step": 5690, "value": 1.249999968422344e-05}, {"wallTime": 1733073000.8143415, "step": 5700, "value": 1.249999968422344e-05}, {"wallTime": 1733073009.780469, "step": 5710, "value": 1.249999968422344e-05}, {"wallTime": 1733073022.866039, "step": 5720, "value": 1.249999968422344e-05}, {"wallTime": 1733073031.530737, "step": 5730, "value": 1.249999968422344e-05}, {"wallTime": 1733073039.5671878, "step": 5740, "value": 1.249999968422344e-05}, {"wallTime": 1733073047.8400474, "step": 5750, "value": 1.249999968422344e-05}, {"wallTime": 1733073056.153761, "step": 5760, "value": 1.249999968422344e-05}, {"wallTime": 1733073064.9524372, "step": 5770, "value": 1.249999968422344e-05}, {"wallTime": 1733073073.8348212, "step": 5780, "value": 1.249999968422344e-05}, {"wallTime": 1733073082.7221, "step": 5790, "value": 1.249999968422344e-05}, {"wallTime": 1733073095.1007593, "step": 5800, "value": 1.249999968422344e-05}, {"wallTime": 1733073103.3130205, "step": 5810, "value": 1.249999968422344e-05}, {"wallTime": 1733073111.967742, "step": 5820, "value": 1.249999968422344e-05}, {"wallTime": 1733073120.352467, "step": 5830, "value": 1.249999968422344e-05}, {"wallTime": 1733073128.206602, "step": 5840, "value": 1.249999968422344e-05}, {"wallTime": 1733073136.7131069, "step": 5850, "value": 1.249999968422344e-05}, {"wallTime": 1733073144.9252203, "step": 5860, "value": 1.249999968422344e-05}, {"wallTime": 1733073153.0378392, "step": 5870, "value": 1.249999968422344e-05}, {"wallTime": 1733073166.0003927, "step": 5880, "value": 1.249999968422344e-05}, {"wallTime": 1733073174.6561275, "step": 5890, "value": 1.249999968422344e-05}, {"wallTime": 1733073182.5057008, "step": 5900, "value": 1.249999968422344e-05}, {"wallTime": 1733073191.5569623, "step": 5910, "value": 1.249999968422344e-05}, {"wallTime": 1733073199.4075942, "step": 5920, "value": 1.249999968422344e-05}, {"wallTime": 1733073207.4627013, "step": 5930, "value": 1.249999968422344e-05}, {"wallTime": 1733073215.6002374, "step": 5940, "value": 1.249999968422344e-05}, {"wallTime": 1733073224.3555806, "step": 5950, "value": 1.249999968422344e-05}, {"wallTime": 1733073232.8739264, "step": 5960, "value": 1.249999968422344e-05}, {"wallTime": 1733073245.371764, "step": 5970, "value": 1.249999968422344e-05}, {"wallTime": 1733073253.177017, "step": 5980, "value": 1.249999968422344e-05}, {"wallTime": 1733073261.7695818, "step": 5990, "value": 1.249999968422344e-05}, {"wallTime": 1733073270.057427, "step": 6000, "value": 1.249999968422344e-05}, {"wallTime": 1733073278.892882, "step": 6010, "value": 1.249999968422344e-05}, {"wallTime": 1733073287.6797576, "step": 6020, "value": 1.249999968422344e-05}, {"wallTime": 1733073297.2721298, "step": 6030, "value": 1.249999968422344e-05}, {"wallTime": 1733073305.9157805, "step": 6040, "value": 1.249999968422344e-05}, {"wallTime": 1733073322.3529015, "step": 6050, "value": 1.249999968422344e-05}, {"wallTime": 1733073331.9748733, "step": 6060, "value": 1.249999968422344e-05}, {"wallTime": 1733073340.5197885, "step": 6070, "value": 1.249999968422344e-05}, {"wallTime": 1733073349.5994911, "step": 6080, "value": 1.249999968422344e-05}, {"wallTime": 1733073359.0685847, "step": 6090, "value": 1.249999968422344e-05}, {"wallTime": 1733073368.4004562, "step": 6100, "value": 1.249999968422344e-05}, {"wallTime": 1733073377.6725855, "step": 6110, "value": 1.249999968422344e-05}, {"wallTime": 1733073386.3978572, "step": 6120, "value": 1.249999968422344e-05}, {"wallTime": 1733073395.449124, "step": 6130, "value": 1.249999968422344e-05}, {"wallTime": 1733073408.1494224, "step": 6140, "value": 1.249999968422344e-05}, {"wallTime": 1733073417.3213437, "step": 6150, "value": 1.249999968422344e-05}, {"wallTime": 1733073426.2532032, "step": 6160, "value": 1.249999968422344e-05}, {"wallTime": 1733073434.806726, "step": 6170, "value": 1.249999968422344e-05}, {"wallTime": 1733073444.5102174, "step": 6180, "value": 1.249999968422344e-05}, {"wallTime": 1733073453.1128354, "step": 6190, "value": 1.249999968422344e-05}, {"wallTime": 1733073462.5631454, "step": 6200, "value": 1.249999968422344e-05}, {"wallTime": 1733073472.0218124, "step": 6210, "value": 1.249999968422344e-05}, {"wallTime": 1733073484.446341, "step": 6220, "value": 1.249999968422344e-05}, {"wallTime": 1733073493.6575842, "step": 6230, "value": 1.249999968422344e-05}, {"wallTime": 1733073502.438573, "step": 6240, "value": 1.249999968422344e-05}, {"wallTime": 1733073511.2533212, "step": 6250, "value": 1.249999968422344e-05}, {"wallTime": 1733073520.4825912, "step": 6260, "value": 1.249999968422344e-05}, {"wallTime": 1733073529.7790344, "step": 6270, "value": 1.249999968422344e-05}, {"wallTime": 1733073539.6367464, "step": 6280, "value": 1.249999968422344e-05}, {"wallTime": 1733073548.908202, "step": 6290, "value": 1.249999968422344e-05}, {"wallTime": 1733073560.6177914, "step": 6300, "value": 1.249999968422344e-05}, {"wallTime": 1733073570.0664508, "step": 6310, "value": 1.249999968422344e-05}, {"wallTime": 1733073579.478626, "step": 6320, "value": 1.249999968422344e-05}, {"wallTime": 1733073587.664692, "step": 6330, "value": 1.249999968422344e-05}, {"wallTime": 1733073597.2155254, "step": 6340, "value": 1.249999968422344e-05}, {"wallTime": 1733073606.235737, "step": 6350, "value": 1.249999968422344e-05}, {"wallTime": 1733073615.0751, "step": 6360, "value": 1.249999968422344e-05}, {"wallTime": 1733073624.8320868, "step": 6370, "value": 1.249999968422344e-05}, {"wallTime": 1733073634.6700454, "step": 6380, "value": 1.249999968422344e-05}, {"wallTime": 1733073646.5262566, "step": 6390, "value": 1.249999968422344e-05}, {"wallTime": 1733073655.7430027, "step": 6400, "value": 1.249999968422344e-05}, {"wallTime": 1733073665.6047795, "step": 6410, "value": 1.249999968422344e-05}, {"wallTime": 1733073674.6403186, "step": 6420, "value": 1.249999968422344e-05}, {"wallTime": 1733073683.667903, "step": 6430, "value": 1.249999968422344e-05}, {"wallTime": 1733073692.8742924, "step": 6440, "value": 1.249999968422344e-05}, {"wallTime": 1733073702.51672, "step": 6450, "value": 1.249999968422344e-05}, {"wallTime": 1733073712.6249642, "step": 6460, "value": 1.249999968422344e-05}, {"wallTime": 1733073724.0450408, "step": 6470, "value": 1.249999968422344e-05}, {"wallTime": 1733073732.8259397, "step": 6480, "value": 1.249999968422344e-05}, {"wallTime": 1733073741.954706, "step": 6490, "value": 1.249999968422344e-05}, {"wallTime": 1733073750.7152727, "step": 6500, "value": 1.249999968422344e-05}, {"wallTime": 1733073760.4857085, "step": 6510, "value": 1.249999968422344e-05}, {"wallTime": 1733073769.8608243, "step": 6520, "value": 1.249999968422344e-05}, {"wallTime": 1733073779.1246955, "step": 6530, "value": 1.249999968422344e-05}, {"wallTime": 1733073789.475297, "step": 6540, "value": 1.249999968422344e-05}, {"wallTime": 1733073798.100931, "step": 6550, "value": 1.249999968422344e-05}, {"wallTime": 1733073810.5509007, "step": 6560, "value": 1.249999968422344e-05}, {"wallTime": 1733073820.0338817, "step": 6570, "value": 1.249999968422344e-05}, {"wallTime": 1733073828.235887, "step": 6580, "value": 1.249999968422344e-05}, {"wallTime": 1733073836.7958083, "step": 6590, "value": 1.249999968422344e-05}, {"wallTime": 1733073845.9851148, "step": 6600, "value": 1.249999968422344e-05}, {"wallTime": 1733073855.2495837, "step": 6610, "value": 1.249999968422344e-05}, {"wallTime": 1733073864.6911619, "step": 6620, "value": 1.249999968422344e-05}, {"wallTime": 1733073873.8323033, "step": 6630, "value": 1.249999968422344e-05}, {"wallTime": 1733073887.5227323, "step": 6640, "value": 1.249999968422344e-05}, {"wallTime": 1733073897.3315554, "step": 6650, "value": 1.249999968422344e-05}, {"wallTime": 1733073906.8744476, "step": 6660, "value": 1.249999968422344e-05}, {"wallTime": 1733073916.3479972, "step": 6670, "value": 1.249999968422344e-05}, {"wallTime": 1733073925.6163094, "step": 6680, "value": 1.249999968422344e-05}, {"wallTime": 1733073934.9144282, "step": 6690, "value": 1.249999968422344e-05}, {"wallTime": 1733073943.7400472, "step": 6700, "value": 1.249999968422344e-05}, {"wallTime": 1733073952.4748812, "step": 6710, "value": 1.249999968422344e-05}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "8627" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_1%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_1", "runToSeries": {".": [{"wallTime": 1733067740.151836, "step": 0, "value": 5.797238372906577e-06}, {"wallTime": 1733067829.7558172, "step": 1, "value": 0.000601289386395365}, {"wallTime": 1733067913.793311, "step": 2, "value": 0.001547801191918552}, {"wallTime": 1733067996.9953825, "step": 3, "value": 0.004785832948982716}, {"wallTime": 1733068080.1570914, "step": 4, "value": 0.004569558892399073}, {"wallTime": 1733068164.192284, "step": 5, "value": 0.010153036564588547}, {"wallTime": 1733068247.8721805, "step": 6, "value": 0.010090337134897709}, {"wallTime": 1733068333.2570462, "step": 7, "value": 0.011977569200098515}, {"wallTime": 1733068414.560368, "step": 8, "value": 0.019513074308633804}, {"wallTime": 1733068496.3602805, "step": 9, "value": 0.02463163621723652}, {"wallTime": 1733068577.3381753, "step": 10, "value": 0.02244265004992485}, {"wallTime": 1733068657.0192268, "step": 11, "value": 0.03286128118634224}, {"wallTime": 1733068739.5047586, "step": 12, "value": 0.02608911693096161}, {"wallTime": 1733068819.3494747, "step": 13, "value": 0.02779446542263031}, {"wallTime": 1733068898.771067, "step": 14, "value": 0.045324474573135376}, {"wallTime": 1733068981.8786888, "step": 15, "value": 0.030338918790221214}, {"wallTime": 1733069061.526333, "step": 16, "value": 0.030101286247372627}, {"wallTime": 1733069141.7473598, "step": 17, "value": 0.034253716468811035}, {"wallTime": 1733069220.0106905, "step": 18, "value": 0.04365364834666252}, {"wallTime": 1733069301.653452, "step": 19, "value": 0.047274328768253326}, {"wallTime": 1733069380.193128, "step": 20, "value": 0.03812017664313316}, {"wallTime": 1733069459.2525024, "step": 21, "value": 0.0377979539334774}, {"wallTime": 1733069538.2866, "step": 22, "value": 0.04762904718518257}, {"wallTime": 1733069618.3286872, "step": 23, "value": 0.06339874118566513}, {"wallTime": 1733069698.6703775, "step": 24, "value": 0.06507151573896408}, {"wallTime": 1733069776.6244328, "step": 25, "value": 0.05640654265880585}, {"wallTime": 1733069853.4836042, "step": 26, "value": 0.052852511405944824}, {"wallTime": 1733069929.9052813, "step": 27, "value": 0.06202346459031105}, {"wallTime": 1733070006.6464844, "step": 28, "value": 0.05882394686341286}, {"wallTime": 1733070083.3184175, "step": 29, "value": 0.0655234158039093}, {"wallTime": 1733070161.8746076, "step": 30, "value": 0.07552926987409592}, {"wallTime": 1733070242.7125793, "step": 31, "value": 0.07447107136249542}, {"wallTime": 1733070321.6595123, "step": 32, "value": 0.07492593675851822}, {"wallTime": 1733070398.7567403, "step": 33, "value": 0.08008856326341629}, {"wallTime": 1733070477.577766, "step": 34, "value": 0.0822264775633812}, {"wallTime": 1733070554.4161096, "step": 35, "value": 0.08402921259403229}, {"wallTime": 1733070633.463592, "step": 36, "value": 0.07694658637046814}, {"wallTime": 1733070708.8288379, "step": 37, "value": 0.0821809321641922}, {"wallTime": 1733070788.195689, "step": 38, "value": 0.08168943226337433}, {"wallTime": 1733070863.7623653, "step": 39, "value": 0.08317789435386658}, {"wallTime": 1733070940.4243357, "step": 40, "value": 0.08373670279979706}, {"wallTime": 1733071015.5076017, "step": 41, "value": 0.0845416933298111}, {"wallTime": 1733071090.3860686, "step": 42, "value": 0.08684147894382477}, {"wallTime": 1733071168.6895347, "step": 43, "value": 0.09005101025104523}, {"wallTime": 1733071243.9710674, "step": 44, "value": 0.08946315944194794}, {"wallTime": 1733071323.4959195, "step": 45, "value": 0.09132350236177444}, {"wallTime": 1733071400.5768428, "step": 46, "value": 0.08972126990556717}, {"wallTime": 1733071478.5944333, "step": 47, "value": 0.09405429661273956}, {"wallTime": 1733071557.341999, "step": 48, "value": 0.09486924856901169}, {"wallTime": 1733071636.6233792, "step": 49, "value": 0.09285476058721542}, {"wallTime": 1733071716.2512398, "step": 50, "value": 0.09857837110757828}, {"wallTime": 1733071795.0558147, "step": 51, "value": 0.09645617753267288}, {"wallTime": 1733071872.7900476, "step": 52, "value": 0.09700236469507217}, {"wallTime": 1733071948.357699, "step": 53, "value": 0.09554199874401093}, {"wallTime": 1733072023.6569371, "step": 54, "value": 0.09595850110054016}, {"wallTime": 1733072099.4581442, "step": 55, "value": 0.09804624319076538}, {"wallTime": 1733072175.7665064, "step": 56, "value": 0.09660413861274719}, {"wallTime": 1733072250.3279643, "step": 57, "value": 0.09895820170640945}, {"wallTime": 1733072328.7791114, "step": 58, "value": 0.10175241529941559}, {"wallTime": 1733072409.4393828, "step": 59, "value": 0.09921041876077652}, {"wallTime": 1733072484.42235, "step": 60, "value": 0.09785899519920349}, {"wallTime": 1733072557.8963194, "step": 61, "value": 0.09899191558361053}, {"wallTime": 1733072632.6974227, "step": 62, "value": 0.10156828910112381}, {"wallTime": 1733072707.4898052, "step": 63, "value": 0.10274185240268707}, {"wallTime": 1733072782.3872738, "step": 64, "value": 0.1041083112359047}, {"wallTime": 1733072861.065383, "step": 65, "value": 0.10819727927446365}, {"wallTime": 1733072938.1309516, "step": 66, "value": 0.10893139988183975}, {"wallTime": 1733073013.9311638, "step": 67, "value": 0.10743618756532669}, {"wallTime": 1733073089.947729, "step": 68, "value": 0.10669972002506256}, {"wallTime": 1733073164.1273048, "step": 69, "value": 0.10717129707336426}, {"wallTime": 1733073238.5223823, "step": 70, "value": 0.10683275759220123}, {"wallTime": 1733073316.8101208, "step": 71, "value": 0.10537775605916977}, {"wallTime": 1733073398.2830873, "step": 72, "value": 0.1098509281873703}, {"wallTime": 1733073478.719259, "step": 73, "value": 0.1043056845664978}, {"wallTime": 1733073559.0350945, "step": 74, "value": 0.10880772024393082}, {"wallTime": 1733073639.2056248, "step": 75, "value": 0.10349300503730774}, {"wallTime": 1733073720.5342584, "step": 76, "value": 0.1068519577383995}, {"wallTime": 1733073800.892346, "step": 77, "value": 0.1082286685705185}, {"wallTime": 1733073880.6262043, "step": 78, "value": 0.10231336951255798}, {"wallTime": 1733073962.4194226, "step": 79, "value": 0.10957641899585724}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1942" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_5%22%7D%5D": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "1826" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_4%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_4", "runToSeries": {".": [{"wallTime": 1733067740.1518855, "step": 0, "value": 0.0002755564055405557}, {"wallTime": 1733067829.7558758, "step": 1, "value": 0.00036830693716183305}, {"wallTime": 1733067913.7933693, "step": 2, "value": 0.0018198048928752542}, {"wallTime": 1733067996.995439, "step": 3, "value": 0.0029268416110426188}, {"wallTime": 1733068080.1571784, "step": 4, "value": 0.011601727455854416}, {"wallTime": 1733068164.1923454, "step": 5, "value": 0.008875029161572456}, {"wallTime": 1733068247.8722239, "step": 6, "value": 0.020969443023204803}, {"wallTime": 1733068333.2570934, "step": 7, "value": 0.029322518035769463}, {"wallTime": 1733068414.5604286, "step": 8, "value": 0.06990769505500793}, {"wallTime": 1733068496.3603513, "step": 9, "value": 0.09154456853866577}, {"wallTime": 1733068577.3382225, "step": 10, "value": 0.07034648209810257}, {"wallTime": 1733068657.0192993, "step": 11, "value": 0.1038217544555664}, {"wallTime": 1733068739.504813, "step": 12, "value": 0.06439543515443802}, {"wallTime": 1733068819.3495317, "step": 13, "value": 0.08525680750608444}, {"wallTime": 1733068898.771126, "step": 14, "value": 0.13731777667999268}, {"wallTime": 1733068981.878746, "step": 15, "value": 0.03522314876317978}, {"wallTime": 1733069061.5263817, "step": 16, "value": 0.08046506345272064}, {"wallTime": 1733069141.7474046, "step": 17, "value": 0.10022810101509094}, {"wallTime": 1733069220.010752, "step": 18, "value": 0.09010624885559082}, {"wallTime": 1733069301.6534991, "step": 19, "value": 0.0936770960688591}, {"wallTime": 1733069380.19322, "step": 20, "value": 0.08094573020935059}, {"wallTime": 1733069459.252548, "step": 21, "value": 0.08652836084365845}, {"wallTime": 1733069538.2866714, "step": 22, "value": 0.12702080607414246}, {"wallTime": 1733069618.3287454, "step": 23, "value": 0.15862900018692017}, {"wallTime": 1733069698.6704288, "step": 24, "value": 0.17127621173858643}, {"wallTime": 1733069776.6244788, "step": 25, "value": 0.13854651153087616}, {"wallTime": 1733069853.483674, "step": 26, "value": 0.08747392147779465}, {"wallTime": 1733069929.9053533, "step": 27, "value": 0.164773091673851}, {"wallTime": 1733070006.6465442, "step": 28, "value": 0.11265247315168381}, {"wallTime": 1733070083.3184643, "step": 29, "value": 0.11467260867357254}, {"wallTime": 1733070161.8746686, "step": 30, "value": 0.15715919435024261}, {"wallTime": 1733070242.7126274, "step": 31, "value": 0.16435782611370087}, {"wallTime": 1733070321.6595705, "step": 32, "value": 0.17257694900035858}, {"wallTime": 1733070398.75679, "step": 33, "value": 0.19230182468891144}, {"wallTime": 1733070477.5778277, "step": 34, "value": 0.12110389769077301}, {"wallTime": 1733070554.416167, "step": 35, "value": 0.180283784866333}, {"wallTime": 1733070633.463641, "step": 36, "value": 0.18624970316886902}, {"wallTime": 1733070708.8288848, "step": 37, "value": 0.18426881730556488}, {"wallTime": 1733070788.195737, "step": 38, "value": 0.19582432508468628}, {"wallTime": 1733070863.7624257, "step": 39, "value": 0.19021376967430115}, {"wallTime": 1733070940.4243796, "step": 40, "value": 0.17704947292804718}, {"wallTime": 1733071015.5076723, "step": 41, "value": 0.1935054361820221}, {"wallTime": 1733071090.386126, "step": 42, "value": 0.20506474375724792}, {"wallTime": 1733071168.6895826, "step": 43, "value": 0.18701817095279694}, {"wallTime": 1733071243.9711103, "step": 44, "value": 0.2253703773021698}, {"wallTime": 1733071323.4959779, "step": 45, "value": 0.19332334399223328}, {"wallTime": 1733071400.576899, "step": 46, "value": 0.18974366784095764}, {"wallTime": 1733071478.5944898, "step": 47, "value": 0.19827800989151}, {"wallTime": 1733071557.3420467, "step": 48, "value": 0.1998101770877838}, {"wallTime": 1733071636.623427, "step": 49, "value": 0.20320874452590942}, {"wallTime": 1733071716.251297, "step": 50, "value": 0.22767935693264008}, {"wallTime": 1733071795.0558612, "step": 51, "value": 0.2076587826013565}, {"wallTime": 1733071872.7901042, "step": 52, "value": 0.19385874271392822}, {"wallTime": 1733071948.357756, "step": 53, "value": 0.20209543406963348}, {"wallTime": 1733072023.657002, "step": 54, "value": 0.1946266144514084}, {"wallTime": 1733072099.4582045, "step": 55, "value": 0.20646829903125763}, {"wallTime": 1733072175.7665758, "step": 56, "value": 0.21024765074253082}, {"wallTime": 1733072250.3280225, "step": 57, "value": 0.21073299646377563}, {"wallTime": 1733072328.7791693, "step": 58, "value": 0.2279415726661682}, {"wallTime": 1733072409.4394293, "step": 59, "value": 0.21245069801807404}, {"wallTime": 1733072484.4223955, "step": 60, "value": 0.22362585365772247}, {"wallTime": 1733072557.896387, "step": 61, "value": 0.21897630393505096}, {"wallTime": 1733072632.6974695, "step": 62, "value": 0.21978910267353058}, {"wallTime": 1733072707.4898639, "step": 63, "value": 0.22801433503627777}, {"wallTime": 1733072782.3873188, "step": 64, "value": 0.22956199944019318}, {"wallTime": 1733072861.0654585, "step": 65, "value": 0.2318967580795288}, {"wallTime": 1733072938.131009, "step": 66, "value": 0.22471527755260468}, {"wallTime": 1733073013.9312074, "step": 67, "value": 0.22809042036533356}, {"wallTime": 1733073089.9477913, "step": 68, "value": 0.22536003589630127}, {"wallTime": 1733073164.1273682, "step": 69, "value": 0.22399091720581055}, {"wallTime": 1733073238.5224414, "step": 70, "value": 0.22696250677108765}, {"wallTime": 1733073316.8101773, "step": 71, "value": 0.23795273900032043}, {"wallTime": 1733073398.2831378, "step": 72, "value": 0.2387324422597885}, {"wallTime": 1733073478.7193062, "step": 73, "value": 0.2384522259235382}, {"wallTime": 1733073559.0351508, "step": 74, "value": 0.24058526754379272}, {"wallTime": 1733073639.205697, "step": 75, "value": 0.23586320877075195}, {"wallTime": 1733073720.5343165, "step": 76, "value": 0.23124960064888}, {"wallTime": 1733073800.8923914, "step": 77, "value": 0.23241406679153442}, {"wallTime": 1733073880.626261, "step": 78, "value": 0.23155398666858673}, {"wallTime": 1733073962.4194803, "step": 79, "value": 0.23788897693157196}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1926" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_2%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_2", "runToSeries": {".": [{"wallTime": 1733067740.1518555, "step": 0, "value": 0.0}, {"wallTime": 1733067829.7558362, "step": 1, "value": 9.095964742300566e-06}, {"wallTime": 1733067913.7933297, "step": 2, "value": 3.36349944518588e-06}, {"wallTime": 1733067996.995401, "step": 3, "value": 0.000908753601834178}, {"wallTime": 1733068080.1571114, "step": 4, "value": 0.0010262628784403205}, {"wallTime": 1733068164.1923058, "step": 5, "value": 0.0008423675899393857}, {"wallTime": 1733068247.8721979, "step": 6, "value": 0.0006782222772017121}, {"wallTime": 1733068333.257064, "step": 7, "value": 0.0018826497253030539}, {"wallTime": 1733068414.5603876, "step": 8, "value": 0.004509201738983393}, {"wallTime": 1733068496.3603206, "step": 9, "value": 0.008048479445278645}, {"wallTime": 1733068577.3381932, "step": 10, "value": 0.0050351740792393684}, {"wallTime": 1733068657.0192647, "step": 11, "value": 0.01173190213739872}, {"wallTime": 1733068739.5047767, "step": 12, "value": 0.007234570104628801}, {"wallTime": 1733068819.3494933, "step": 13, "value": 0.006804953329265118}, {"wallTime": 1733068898.7710867, "step": 14, "value": 0.012012297287583351}, {"wallTime": 1733068981.8787076, "step": 15, "value": 0.004971494898200035}, {"wallTime": 1733069061.5263522, "step": 16, "value": 0.005862734746187925}, {"wallTime": 1733069141.7473774, "step": 17, "value": 0.00747448205947876}, {"wallTime": 1733069220.01071, "step": 18, "value": 0.008197670802474022}, {"wallTime": 1733069301.6534708, "step": 19, "value": 0.007127481047064066}, {"wallTime": 1733069380.1931748, "step": 20, "value": 0.009257899597287178}, {"wallTime": 1733069459.252521, "step": 21, "value": 0.009359296411275864}, {"wallTime": 1733069538.2866192, "step": 22, "value": 0.010025206953287125}, {"wallTime": 1733069618.328707, "step": 23, "value": 0.012167714536190033}, {"wallTime": 1733069698.670397, "step": 24, "value": 0.009120792150497437}, {"wallTime": 1733069776.6244504, "step": 25, "value": 0.0118150245398283}, {"wallTime": 1733069853.4836223, "step": 26, "value": 0.012687968090176582}, {"wallTime": 1733069929.9053202, "step": 27, "value": 0.011028583161532879}, {"wallTime": 1733070006.646504, "step": 28, "value": 0.011874896474182606}, {"wallTime": 1733070083.3184357, "step": 29, "value": 0.01187661848962307}, {"wallTime": 1733070161.8746264, "step": 30, "value": 0.013248014263808727}, {"wallTime": 1733070242.7125983, "step": 31, "value": 0.013955015689134598}, {"wallTime": 1733070321.6595316, "step": 32, "value": 0.01598764955997467}, {"wallTime": 1733070398.75676, "step": 33, "value": 0.015500092878937721}, {"wallTime": 1733070477.577785, "step": 34, "value": 0.015535143204033375}, {"wallTime": 1733070554.4161277, "step": 35, "value": 0.016266897320747375}, {"wallTime": 1733070633.4636114, "step": 36, "value": 0.015158399939537048}, {"wallTime": 1733070708.8288562, "step": 37, "value": 0.016561832278966904}, {"wallTime": 1733070788.1957076, "step": 38, "value": 0.015697211027145386}, {"wallTime": 1733070863.7623844, "step": 39, "value": 0.015542283654212952}, {"wallTime": 1733070940.4243534, "step": 40, "value": 0.016229605302214622}, {"wallTime": 1733071015.5076203, "step": 41, "value": 0.016633180901408195}, {"wallTime": 1733071090.3860867, "step": 42, "value": 0.01878153346478939}, {"wallTime": 1733071168.6895535, "step": 43, "value": 0.01939283311367035}, {"wallTime": 1733071243.9710846, "step": 44, "value": 0.021140603348612785}, {"wallTime": 1733071323.495938, "step": 45, "value": 0.020113162696361542}, {"wallTime": 1733071400.5768604, "step": 46, "value": 0.01870330609381199}, {"wallTime": 1733071478.5944517, "step": 47, "value": 0.018861839547753334}, {"wallTime": 1733071557.3420184, "step": 48, "value": 0.020965538918972015}, {"wallTime": 1733071636.6233978, "step": 49, "value": 0.021187007427215576}, {"wallTime": 1733071716.2512586, "step": 50, "value": 0.02218533866107464}, {"wallTime": 1733071795.0558333, "step": 51, "value": 0.022678520530462265}, {"wallTime": 1733071872.7900667, "step": 52, "value": 0.0228196419775486}, {"wallTime": 1733071948.3577175, "step": 53, "value": 0.02231430634856224}, {"wallTime": 1733072023.6569564, "step": 54, "value": 0.021746113896369934}, {"wallTime": 1733072099.4581637, "step": 55, "value": 0.022611254826188087}, {"wallTime": 1733072175.7665265, "step": 56, "value": 0.022313768044114113}, {"wallTime": 1733072250.3279836, "step": 57, "value": 0.022950468584895134}, {"wallTime": 1733072328.7791297, "step": 58, "value": 0.02491321973502636}, {"wallTime": 1733072409.4394011, "step": 59, "value": 0.02258063480257988}, {"wallTime": 1733072484.4223678, "step": 60, "value": 0.02300945669412613}, {"wallTime": 1733072557.896349, "step": 61, "value": 0.02440403774380684}, {"wallTime": 1733072632.6974413, "step": 62, "value": 0.024549096822738647}, {"wallTime": 1733072707.4898248, "step": 63, "value": 0.02375064417719841}, {"wallTime": 1733072782.3872924, "step": 64, "value": 0.025104565545916557}, {"wallTime": 1733072861.065422, "step": 65, "value": 0.025875821709632874}, {"wallTime": 1733072938.130971, "step": 66, "value": 0.025710484012961388}, {"wallTime": 1733073013.931181, "step": 67, "value": 0.025680560618638992}, {"wallTime": 1733073089.9477515, "step": 68, "value": 0.02377069741487503}, {"wallTime": 1733073164.1273236, "step": 69, "value": 0.026191001757979393}, {"wallTime": 1733073238.5224013, "step": 70, "value": 0.026752451434731483}, {"wallTime": 1733073316.8101401, "step": 71, "value": 0.02542157843708992}, {"wallTime": 1733073398.283107, "step": 72, "value": 0.028471939265727997}, {"wallTime": 1733073478.719278, "step": 73, "value": 0.027684897184371948}, {"wallTime": 1733073559.0351129, "step": 74, "value": 0.028469735756516457}, {"wallTime": 1733073639.2056558, "step": 75, "value": 0.027843978255987167}, {"wallTime": 1733073720.5342774, "step": 76, "value": 0.026445887982845306}, {"wallTime": 1733073800.8923635, "step": 77, "value": 0.02867269143462181}, {"wallTime": 1733073880.6262336, "step": 78, "value": 0.02670918218791485}, {"wallTime": 1733073962.419441, "step": 79, "value": 0.026418369263410568}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1939" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_3%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_3", "runToSeries": {".": [{"wallTime": 1733067740.1518712, "step": 0, "value": 1.1444723213571706e-06}, {"wallTime": 1733067829.7558517, "step": 1, "value": 0.00011352438014000654}, {"wallTime": 1733067913.793345, "step": 2, "value": 0.000496681488584727}, {"wallTime": 1733067996.9954152, "step": 3, "value": 0.0013017809251323342}, {"wallTime": 1733068080.1571276, "step": 4, "value": 0.0014160135760903358}, {"wallTime": 1733068164.1923215, "step": 5, "value": 0.002791814273223281}, {"wallTime": 1733068247.8722115, "step": 6, "value": 0.0029623929876834154}, {"wallTime": 1733068333.2570794, "step": 7, "value": 0.004206664860248566}, {"wallTime": 1733068414.5604038, "step": 8, "value": 0.006449609529227018}, {"wallTime": 1733068496.360338, "step": 9, "value": 0.00732426019385457}, {"wallTime": 1733068577.3382084, "step": 10, "value": 0.00694578792899847}, {"wallTime": 1733068657.0192857, "step": 11, "value": 0.0068427142687141895}, {"wallTime": 1733068739.5048008, "step": 12, "value": 0.010313737206161022}, {"wallTime": 1733068819.3495076, "step": 13, "value": 0.009560993872582912}, {"wallTime": 1733068898.7711124, "step": 14, "value": 0.012996803037822247}, {"wallTime": 1733068981.8787222, "step": 15, "value": 0.011540326289832592}, {"wallTime": 1733069061.5263672, "step": 16, "value": 0.011869599111378193}, {"wallTime": 1733069141.7473915, "step": 17, "value": 0.01449509896337986}, {"wallTime": 1733069220.010726, "step": 18, "value": 0.016241660341620445}, {"wallTime": 1733069301.6534858, "step": 19, "value": 0.01535643171519041}, {"wallTime": 1733069380.1931984, "step": 20, "value": 0.01603824272751808}, {"wallTime": 1733069459.252535, "step": 21, "value": 0.014754343777894974}, {"wallTime": 1733069538.2866342, "step": 22, "value": 0.0214798916131258}, {"wallTime": 1733069618.3287325, "step": 23, "value": 0.025844667106866837}, {"wallTime": 1733069698.6704128, "step": 24, "value": 0.025970980525016785}, {"wallTime": 1733069776.624465, "step": 25, "value": 0.021697865799069405}, {"wallTime": 1733069853.483637, "step": 26, "value": 0.023478565737605095}, {"wallTime": 1733069929.90534, "step": 27, "value": 0.02315225824713707}, {"wallTime": 1733070006.6465192, "step": 28, "value": 0.019900361075997353}, {"wallTime": 1733070083.3184507, "step": 29, "value": 0.023604359477758408}, {"wallTime": 1733070161.874641, "step": 30, "value": 0.02805347740650177}, {"wallTime": 1733070242.7126136, "step": 31, "value": 0.027020979672670364}, {"wallTime": 1733070321.6595464, "step": 32, "value": 0.025135479867458344}, {"wallTime": 1733070398.756776, "step": 33, "value": 0.029962455853819847}, {"wallTime": 1733070477.5778131, "step": 34, "value": 0.02901240810751915}, {"wallTime": 1733070554.4161534, "step": 35, "value": 0.03124331682920456}, {"wallTime": 1733070633.4636264, "step": 36, "value": 0.030180733650922775}, {"wallTime": 1733070708.8288717, "step": 37, "value": 0.029764043167233467}, {"wallTime": 1733070788.1957233, "step": 38, "value": 0.030010581016540527}, {"wallTime": 1733070863.7624002, "step": 39, "value": 0.031769104301929474}, {"wallTime": 1733070940.4243674, "step": 40, "value": 0.029558567330241203}, {"wallTime": 1733071015.5076354, "step": 41, "value": 0.03150808811187744}, {"wallTime": 1733071090.3861117, "step": 42, "value": 0.03210863471031189}, {"wallTime": 1733071168.689569, "step": 43, "value": 0.03361421078443527}, {"wallTime": 1733071243.9710982, "step": 44, "value": 0.034774601459503174}, {"wallTime": 1733071323.4959638, "step": 45, "value": 0.03494948148727417}, {"wallTime": 1733071400.5768745, "step": 46, "value": 0.0344405323266983}, {"wallTime": 1733071478.594466, "step": 47, "value": 0.035613518208265305}, {"wallTime": 1733071557.3420334, "step": 48, "value": 0.03844735771417618}, {"wallTime": 1733071636.6234133, "step": 49, "value": 0.03665156289935112}, {"wallTime": 1733071716.251284, "step": 50, "value": 0.03873857483267784}, {"wallTime": 1733071795.055848, "step": 51, "value": 0.03537360951304436}, {"wallTime": 1733071872.790091, "step": 52, "value": 0.0361025296151638}, {"wallTime": 1733071948.357732, "step": 53, "value": 0.03469866141676903}, {"wallTime": 1733072023.6569822, "step": 54, "value": 0.03662841394543648}, {"wallTime": 1733072099.45819, "step": 55, "value": 0.03712652251124382}, {"wallTime": 1733072175.7665422, "step": 56, "value": 0.035295166075229645}, {"wallTime": 1733072250.3279984, "step": 57, "value": 0.03532186895608902}, {"wallTime": 1733072328.779155, "step": 58, "value": 0.03781914338469505}, {"wallTime": 1733072409.4394155, "step": 59, "value": 0.035419315099716187}, {"wallTime": 1733072484.422382, "step": 60, "value": 0.036764003336429596}, {"wallTime": 1733072557.8963723, "step": 61, "value": 0.03727861866354942}, {"wallTime": 1733072632.697456, "step": 62, "value": 0.03793194144964218}, {"wallTime": 1733072707.4898398, "step": 63, "value": 0.03818034380674362}, {"wallTime": 1733072782.3873065, "step": 64, "value": 0.039228230714797974}, {"wallTime": 1733072861.0654454, "step": 65, "value": 0.04170675203204155}, {"wallTime": 1733072938.130996, "step": 66, "value": 0.04079412668943405}, {"wallTime": 1733073013.931195, "step": 67, "value": 0.039965469390153885}, {"wallTime": 1733073089.9477777, "step": 68, "value": 0.03950217366218567}, {"wallTime": 1733073164.1273396, "step": 69, "value": 0.04027253016829491}, {"wallTime": 1733073238.5224166, "step": 70, "value": 0.041028231382369995}, {"wallTime": 1733073316.8101628, "step": 71, "value": 0.04017013683915138}, {"wallTime": 1733073398.2831233, "step": 72, "value": 0.04212845489382744}, {"wallTime": 1733073478.7192929, "step": 73, "value": 0.03843143209815025}, {"wallTime": 1733073559.035138, "step": 74, "value": 0.0410548634827137}, {"wallTime": 1733073639.2056732, "step": 75, "value": 0.038188569247722626}, {"wallTime": 1733073720.5343025, "step": 76, "value": 0.03993958234786987}, {"wallTime": 1733073800.8923786, "step": 77, "value": 0.04157397896051407}, {"wallTime": 1733073880.6262481, "step": 78, "value": 0.038675907999277115}, {"wallTime": 1733073962.4194667, "step": 79, "value": 0.04260871559381485}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1938" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_0%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_0", "runToSeries": {".": [{"wallTime": 1733067740.1517694, "step": 0, "value": 1.181977040687343e-06}, {"wallTime": 1733067829.7557466, "step": 1, "value": 0.00010961259249597788}, {"wallTime": 1733067913.7932427, "step": 2, "value": 0.0002828161814250052}, {"wallTime": 1733067996.9953134, "step": 3, "value": 0.0014412864111363888}, {"wallTime": 1733068080.1570058, "step": 4, "value": 0.0014631444355472922}, {"wallTime": 1733068164.192213, "step": 5, "value": 0.00287190661765635}, {"wallTime": 1733068247.8720953, "step": 6, "value": 0.0028854995034635067}, {"wallTime": 1733068333.256983, "step": 7, "value": 0.003950766287744045}, {"wallTime": 1733068414.560295, "step": 8, "value": 0.007344170473515987}, {"wallTime": 1733068496.3601975, "step": 9, "value": 0.01072083692997694}, {"wallTime": 1733068577.338112, "step": 10, "value": 0.008485957980155945}, {"wallTime": 1733068657.0191467, "step": 11, "value": 0.01386372372508049}, {"wallTime": 1733068739.5046859, "step": 12, "value": 0.010783785954117775}, {"wallTime": 1733068819.3494017, "step": 13, "value": 0.010859142988920212}, {"wallTime": 1733068898.7709956, "step": 14, "value": 0.01855442486703396}, {"wallTime": 1733068981.8785996, "step": 15, "value": 0.011090526357293129}, {"wallTime": 1733069061.5262444, "step": 16, "value": 0.011400219984352589}, {"wallTime": 1733069141.7472897, "step": 17, "value": 0.013318398036062717}, {"wallTime": 1733069220.0106077, "step": 18, "value": 0.016244105994701385}, {"wallTime": 1733069301.6533806, "step": 19, "value": 0.016136251389980316}, {"wallTime": 1733069380.1930509, "step": 20, "value": 0.015583508647978306}, {"wallTime": 1733069459.2524312, "step": 21, "value": 0.015063920989632607}, {"wallTime": 1733069538.2865252, "step": 22, "value": 0.018852049484848976}, {"wallTime": 1733069618.3286018, "step": 23, "value": 0.02352958358824253}, {"wallTime": 1733069698.6703076, "step": 24, "value": 0.02282092720270157}, {"wallTime": 1733069776.6243706, "step": 25, "value": 0.02150830812752247}, {"wallTime": 1733069853.4835334, "step": 26, "value": 0.021754376590251923}, {"wallTime": 1733069929.9051998, "step": 27, "value": 0.02232671156525612}, {"wallTime": 1733070006.6464121, "step": 28, "value": 0.021528752520680428}, {"wallTime": 1733070083.3183455, "step": 29, "value": 0.023576797917485237}, {"wallTime": 1733070161.8745432, "step": 30, "value": 0.029212014749646187}, {"wallTime": 1733070242.7125087, "step": 31, "value": 0.026507535949349403}, {"wallTime": 1733070321.6594412, "step": 32, "value": 0.027416041120886803}, {"wallTime": 1733070398.7566743, "step": 33, "value": 0.032211776822805405}, {"wallTime": 1733070477.5776932, "step": 34, "value": 0.030121400952339172}, {"wallTime": 1733070554.4160361, "step": 35, "value": 0.03588876500725746}, {"wallTime": 1733070633.4635215, "step": 36, "value": 0.031201060861349106}, {"wallTime": 1733070708.828765, "step": 37, "value": 0.0336836501955986}, {"wallTime": 1733070788.1956084, "step": 38, "value": 0.03196285292506218}, {"wallTime": 1733070863.762295, "step": 39, "value": 0.03479166701436043}, {"wallTime": 1733070940.4242518, "step": 40, "value": 0.03234388306736946}, {"wallTime": 1733071015.5075305, "step": 41, "value": 0.03208162635564804}, {"wallTime": 1733071090.385999, "step": 42, "value": 0.0368201769888401}, {"wallTime": 1733071168.6894712, "step": 43, "value": 0.036768365651369095}, {"wallTime": 1733071243.9709842, "step": 44, "value": 0.03912518173456192}, {"wallTime": 1733071323.4958475, "step": 45, "value": 0.03908279165625572}, {"wallTime": 1733071400.5767725, "step": 46, "value": 0.03690294921398163}, {"wallTime": 1733071478.5943604, "step": 47, "value": 0.03950349986553192}, {"wallTime": 1733071557.3419359, "step": 48, "value": 0.03988131508231163}, {"wallTime": 1733071636.6233077, "step": 49, "value": 0.04052713140845299}, {"wallTime": 1733071716.2511683, "step": 50, "value": 0.043427444994449615}, {"wallTime": 1733071795.0557516, "step": 51, "value": 0.04358917474746704}, {"wallTime": 1733071872.7899761, "step": 52, "value": 0.041153840720653534}, {"wallTime": 1733071948.357614, "step": 53, "value": 0.04267030209302902}, {"wallTime": 1733072023.656864, "step": 54, "value": 0.042196109890937805}, {"wallTime": 1733072099.4580724, "step": 55, "value": 0.04332948103547096}, {"wallTime": 1733072175.766442, "step": 56, "value": 0.042585231363773346}, {"wallTime": 1733072250.3278842, "step": 57, "value": 0.04362503066658974}, {"wallTime": 1733072328.7790415, "step": 58, "value": 0.046290457248687744}, {"wallTime": 1733072409.4393194, "step": 59, "value": 0.04477960243821144}, {"wallTime": 1733072484.4222684, "step": 60, "value": 0.04519711434841156}, {"wallTime": 1733072557.896246, "step": 61, "value": 0.044851984828710556}, {"wallTime": 1733072632.6973543, "step": 62, "value": 0.045721568167209625}, {"wallTime": 1733072707.489735, "step": 63, "value": 0.046136558055877686}, {"wallTime": 1733072782.3871891, "step": 64, "value": 0.0474918968975544}, {"wallTime": 1733072861.0652921, "step": 65, "value": 0.05034753680229187}, {"wallTime": 1733072938.1308787, "step": 66, "value": 0.05008821561932564}, {"wallTime": 1733073013.9310849, "step": 67, "value": 0.04885455593466759}, {"wallTime": 1733073089.947656, "step": 68, "value": 0.04825744777917862}, {"wallTime": 1733073164.1272326, "step": 69, "value": 0.04890834167599678}, {"wallTime": 1733073238.5223053, "step": 70, "value": 0.04911619797348976}, {"wallTime": 1733073316.8100488, "step": 71, "value": 0.04835519194602966}, {"wallTime": 1733073398.2830017, "step": 72, "value": 0.05215868353843689}, {"wallTime": 1733073478.7191963, "step": 73, "value": 0.048868171870708466}, {"wallTime": 1733073559.0350235, "step": 74, "value": 0.05163055285811424}, {"wallTime": 1733073639.2055528, "step": 75, "value": 0.048815492540597916}, {"wallTime": 1733073720.5341878, "step": 76, "value": 0.04948084056377411}, {"wallTime": 1733073800.8922658, "step": 77, "value": 0.05053531378507614}, {"wallTime": 1733073880.626127, "step": 78, "value": 0.04784637689590454}, {"wallTime": 1733073962.4193509, "step": 79, "value": 0.05167156085371971}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1936" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_7%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_7", "runToSeries": {".": [{"wallTime": 1733067740.1519444, "step": 0, "value": 2.2118999822851038e-06}, {"wallTime": 1733067829.7559137, "step": 1, "value": 0.0008615325787104666}, {"wallTime": 1733067913.7934077, "step": 2, "value": 0.001307845814153552}, {"wallTime": 1733067996.9954762, "step": 3, "value": 0.0018658291082829237}, {"wallTime": 1733068080.1573043, "step": 4, "value": 0.003472906071692705}, {"wallTime": 1733068164.1923811, "step": 5, "value": 0.012611509300768375}, {"wallTime": 1733068247.8722599, "step": 6, "value": 0.011049710214138031}, {"wallTime": 1733068333.257133, "step": 7, "value": 0.015422430820763111}, {"wallTime": 1733068414.5604672, "step": 8, "value": 0.022032272070646286}, {"wallTime": 1733068496.3603868, "step": 9, "value": 0.02895553596317768}, {"wallTime": 1733068577.3382714, "step": 10, "value": 0.022790933027863503}, {"wallTime": 1733068657.0193343, "step": 11, "value": 0.02425343543291092}, {"wallTime": 1733068739.5048482, "step": 12, "value": 0.0192203801125288}, {"wallTime": 1733068819.3495688, "step": 13, "value": 0.02461247146129608}, {"wallTime": 1733068898.7711632, "step": 14, "value": 0.049605678766965866}, {"wallTime": 1733068981.878782, "step": 15, "value": 0.032269593328237534}, {"wallTime": 1733069061.5264213, "step": 16, "value": 0.037560854107141495}, {"wallTime": 1733069141.7474508, "step": 17, "value": 0.043695952743291855}, {"wallTime": 1733069220.0107899, "step": 18, "value": 0.048559363931417465}, {"wallTime": 1733069301.653547, "step": 19, "value": 0.042834196239709854}, {"wallTime": 1733069380.1932845, "step": 20, "value": 0.04357271268963814}, {"wallTime": 1733069459.2525952, "step": 21, "value": 0.026111355051398277}, {"wallTime": 1733069538.286709, "step": 22, "value": 0.04077022522687912}, {"wallTime": 1733069618.3287802, "step": 23, "value": 0.04432269185781479}, {"wallTime": 1733069698.6704772, "step": 24, "value": 0.05586566776037216}, {"wallTime": 1733069776.6245172, "step": 25, "value": 0.057799018919467926}, {"wallTime": 1733069853.483711, "step": 26, "value": 0.05631629750132561}, {"wallTime": 1733069929.9053898, "step": 27, "value": 0.05902326479554176}, {"wallTime": 1733070006.6465812, "step": 28, "value": 0.030177395790815353}, {"wallTime": 1733070083.3185112, "step": 29, "value": 0.05988772585988045}, {"wallTime": 1733070161.874718, "step": 30, "value": 0.0647992491722107}, {"wallTime": 1733070242.712689, "step": 31, "value": 0.05982503294944763}, {"wallTime": 1733070321.659606, "step": 32, "value": 0.06065824255347252}, {"wallTime": 1733070398.756838, "step": 33, "value": 0.06286030262708664}, {"wallTime": 1733070477.5778663, "step": 34, "value": 0.06055698171257973}, {"wallTime": 1733070554.4162033, "step": 35, "value": 0.06608540564775467}, {"wallTime": 1733070633.463702, "step": 36, "value": 0.05770350992679596}, {"wallTime": 1733070708.828931, "step": 37, "value": 0.06749477982521057}, {"wallTime": 1733070788.1957865, "step": 38, "value": 0.06419137120246887}, {"wallTime": 1733070863.7624662, "step": 39, "value": 0.06465346366167068}, {"wallTime": 1733070940.4244165, "step": 40, "value": 0.06761077791452408}, {"wallTime": 1733071015.5077128, "step": 41, "value": 0.0649750754237175}, {"wallTime": 1733071090.3861616, "step": 42, "value": 0.07099347561597824}, {"wallTime": 1733071168.689621, "step": 43, "value": 0.0704336017370224}, {"wallTime": 1733071243.9711478, "step": 44, "value": 0.06943656504154205}, {"wallTime": 1733071323.4960167, "step": 45, "value": 0.0724199116230011}, {"wallTime": 1733071400.5769377, "step": 46, "value": 0.070383220911026}, {"wallTime": 1733071478.5945258, "step": 47, "value": 0.07041948288679123}, {"wallTime": 1733071557.342095, "step": 48, "value": 0.06680688261985779}, {"wallTime": 1733071636.6234736, "step": 49, "value": 0.06596025824546814}, {"wallTime": 1733071716.2513318, "step": 50, "value": 0.0719744861125946}, {"wallTime": 1733071795.0558994, "step": 51, "value": 0.07124576717615128}, {"wallTime": 1733071872.7901416, "step": 52, "value": 0.07372603565454483}, {"wallTime": 1733071948.357792, "step": 53, "value": 0.07340776175260544}, {"wallTime": 1733072023.6570404, "step": 54, "value": 0.06986378878355026}, {"wallTime": 1733072099.4582424, "step": 55, "value": 0.07126609981060028}, {"wallTime": 1733072175.7666163, "step": 56, "value": 0.05517217889428139}, {"wallTime": 1733072250.3280613, "step": 57, "value": 0.0590442530810833}, {"wallTime": 1733072328.7792058, "step": 58, "value": 0.0766228437423706}, {"wallTime": 1733072409.4394774, "step": 59, "value": 0.07089044898748398}, {"wallTime": 1733072484.4224334, "step": 60, "value": 0.07063434273004532}, {"wallTime": 1733072557.896436, "step": 61, "value": 0.07254806905984879}, {"wallTime": 1733072632.6975188, "step": 62, "value": 0.07391422241926193}, {"wallTime": 1733072707.489899, "step": 63, "value": 0.07154710590839386}, {"wallTime": 1733072782.387354, "step": 64, "value": 0.0735773965716362}, {"wallTime": 1733072861.065496, "step": 65, "value": 0.07600753009319305}, {"wallTime": 1733072938.1310449, "step": 66, "value": 0.07637643814086914}, {"wallTime": 1733073013.9536097, "step": 67, "value": 0.07579903304576874}, {"wallTime": 1733073089.9478266, "step": 68, "value": 0.07321774959564209}, {"wallTime": 1733073164.1274066, "step": 69, "value": 0.07331662625074387}, {"wallTime": 1733073238.5224793, "step": 70, "value": 0.07410096377134323}, {"wallTime": 1733073316.810228, "step": 71, "value": 0.07328485697507858}, {"wallTime": 1733073398.2831876, "step": 72, "value": 0.07663382589817047}, {"wallTime": 1733073478.7193458, "step": 73, "value": 0.06333596259355545}, {"wallTime": 1733073559.0351875, "step": 74, "value": 0.07650427520275116}, {"wallTime": 1733073639.205735, "step": 75, "value": 0.06370122730731964}, {"wallTime": 1733073720.5343535, "step": 76, "value": 0.07606290280818939}, {"wallTime": 1733073800.8924284, "step": 77, "value": 0.0766129419207573}, {"wallTime": 1733073880.626297, "step": 78, "value": 0.06235744431614876}, {"wallTime": 1733073962.4195158, "step": 79, "value": 0.07703141123056412}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1922" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_8%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_8", "runToSeries": {".": [{"wallTime": 1733067740.151957, "step": 0, "value": 1.1133302905363962e-05}, {"wallTime": 1733067829.755925, "step": 1, "value": 0.0019107715925201774}, {"wallTime": 1733067913.7934196, "step": 2, "value": 0.002463674871250987}, {"wallTime": 1733067996.9954875, "step": 3, "value": 0.0035323575139045715}, {"wallTime": 1733068080.1573172, "step": 4, "value": 0.005280012730509043}, {"wallTime": 1733068164.192393, "step": 5, "value": 0.01819615624845028}, {"wallTime": 1733068247.8722713, "step": 6, "value": 0.018196510151028633}, {"wallTime": 1733068333.2571561, "step": 7, "value": 0.022110220044851303}, {"wallTime": 1733068414.5604792, "step": 8, "value": 0.03611044958233833}, {"wallTime": 1733068496.360398, "step": 9, "value": 0.04256277531385422}, {"wallTime": 1733068577.338283, "step": 10, "value": 0.03710201010107994}, {"wallTime": 1733068657.0193455, "step": 11, "value": 0.03856692835688591}, {"wallTime": 1733068739.5048594, "step": 12, "value": 0.04201896861195564}, {"wallTime": 1733068819.34958, "step": 13, "value": 0.033111341297626495}, {"wallTime": 1733068898.771175, "step": 14, "value": 0.06921771913766861}, {"wallTime": 1733068981.8787932, "step": 15, "value": 0.04942765086889267}, {"wallTime": 1733069061.526433, "step": 16, "value": 0.05176355689764023}, {"wallTime": 1733069141.7474625, "step": 17, "value": 0.05745995044708252}, {"wallTime": 1733069220.0108016, "step": 18, "value": 0.0637790858745575}, {"wallTime": 1733069301.6535592, "step": 19, "value": 0.05433628335595131}, {"wallTime": 1733069380.1933095, "step": 20, "value": 0.05828366428613663}, {"wallTime": 1733069459.2526066, "step": 21, "value": 0.04297640174627304}, {"wallTime": 1733069538.2867205, "step": 22, "value": 0.055069148540496826}, {"wallTime": 1733069618.3287916, "step": 23, "value": 0.06081752851605415}, {"wallTime": 1733069698.670489, "step": 24, "value": 0.0708334743976593}, {"wallTime": 1733069776.6245396, "step": 25, "value": 0.07420958578586578}, {"wallTime": 1733069853.4837232, "step": 26, "value": 0.07156144827604294}, {"wallTime": 1733069929.9054012, "step": 27, "value": 0.07505777478218079}, {"wallTime": 1733070006.6465933, "step": 28, "value": 0.04721797630190849}, {"wallTime": 1733070083.318523, "step": 29, "value": 0.07234872877597809}, {"wallTime": 1733070161.8747296, "step": 30, "value": 0.08071787655353546}, {"wallTime": 1733070242.7127001, "step": 31, "value": 0.07743910700082779}, {"wallTime": 1733070321.659617, "step": 32, "value": 0.07919274270534515}, {"wallTime": 1733070398.7568538, "step": 33, "value": 0.0801338478922844}, {"wallTime": 1733070477.5778785, "step": 34, "value": 0.07695375382900238}, {"wallTime": 1733070554.4162147, "step": 35, "value": 0.08216968923807144}, {"wallTime": 1733070633.463714, "step": 36, "value": 0.07359253615140915}, {"wallTime": 1733070708.8289423, "step": 37, "value": 0.08272691816091537}, {"wallTime": 1733070788.1957989, "step": 38, "value": 0.08130522072315216}, {"wallTime": 1733070863.7624786, "step": 39, "value": 0.08024866878986359}, {"wallTime": 1733070940.4244287, "step": 40, "value": 0.08334790915250778}, {"wallTime": 1733071015.5077245, "step": 41, "value": 0.08230097591876984}, {"wallTime": 1733071090.3861732, "step": 42, "value": 0.0890149250626564}, {"wallTime": 1733071168.6896439, "step": 43, "value": 0.08830343931913376}, {"wallTime": 1733071243.9711607, "step": 44, "value": 0.08810004591941833}, {"wallTime": 1733071323.496029, "step": 45, "value": 0.09128209203481674}, {"wallTime": 1733071400.5769496, "step": 46, "value": 0.08887474983930588}, {"wallTime": 1733071478.5945375, "step": 47, "value": 0.08948009461164474}, {"wallTime": 1733071557.342107, "step": 48, "value": 0.08598936349153519}, {"wallTime": 1733071636.6234848, "step": 49, "value": 0.08434058725833893}, {"wallTime": 1733071716.2513433, "step": 50, "value": 0.09104359149932861}, {"wallTime": 1733071795.0559278, "step": 51, "value": 0.09048759937286377}, {"wallTime": 1733071872.7901542, "step": 52, "value": 0.09251578897237778}, {"wallTime": 1733071948.3578033, "step": 53, "value": 0.09254087507724762}, {"wallTime": 1733072023.6570525, "step": 54, "value": 0.08970753103494644}, {"wallTime": 1733072099.458254, "step": 55, "value": 0.09106539934873581}, {"wallTime": 1733072175.7666283, "step": 56, "value": 0.07551687210798264}, {"wallTime": 1733072250.328073, "step": 57, "value": 0.07948879897594452}, {"wallTime": 1733072328.7792177, "step": 58, "value": 0.09688552469015121}, {"wallTime": 1733072409.4394896, "step": 59, "value": 0.091319240629673}, {"wallTime": 1733072484.4224458, "step": 60, "value": 0.09095357358455658}, {"wallTime": 1733072557.8964489, "step": 61, "value": 0.09278681874275208}, {"wallTime": 1733072632.697531, "step": 62, "value": 0.09494195133447647}, {"wallTime": 1733072707.4899106, "step": 63, "value": 0.09211282432079315}, {"wallTime": 1733072782.3873656, "step": 64, "value": 0.09385934472084045}, {"wallTime": 1733072861.0655081, "step": 65, "value": 0.09629669040441513}, {"wallTime": 1733072938.1310563, "step": 66, "value": 0.09680911153554916}, {"wallTime": 1733073013.9536233, "step": 67, "value": 0.0961763933300972}, {"wallTime": 1733073089.9478383, "step": 68, "value": 0.09372412413358688}, {"wallTime": 1733073164.1274183, "step": 69, "value": 0.0943269282579422}, {"wallTime": 1733073238.5224912, "step": 70, "value": 0.0948810949921608}, {"wallTime": 1733073316.8102412, "step": 71, "value": 0.09432858228683472}, {"wallTime": 1733073398.2832017, "step": 72, "value": 0.0977267473936081}, {"wallTime": 1733073478.7193696, "step": 73, "value": 0.08442912995815277}, {"wallTime": 1733073559.0351992, "step": 74, "value": 0.09763060510158539}, {"wallTime": 1733073639.205747, "step": 75, "value": 0.08500119298696518}, {"wallTime": 1733073720.5343654, "step": 76, "value": 0.0965607613325119}, {"wallTime": 1733073800.8924398, "step": 77, "value": 0.0971808135509491}, {"wallTime": 1733073880.6263087, "step": 78, "value": 0.08330515027046204}, {"wallTime": 1733073962.4195275, "step": 79, "value": 0.09835547208786011}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1909" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_10%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_10", "runToSeries": {".": [{"wallTime": 1733067740.1519818, "step": 0, "value": 0.0071428571827709675}, {"wallTime": 1733067829.7559493, "step": 1, "value": 0.0015625000232830644}, {"wallTime": 1733067913.7934427, "step": 2, "value": 0.03605654835700989}, {"wallTime": 1733067996.99551, "step": 3, "value": 0.010669643059372902}, {"wallTime": 1733068080.1573408, "step": 4, "value": 0.022872023284435272}, {"wallTime": 1733068164.1924157, "step": 5, "value": 0.07175595313310623}, {"wallTime": 1733068247.872295, "step": 6, "value": 0.20537202060222626}, {"wallTime": 1733068333.2571814, "step": 7, "value": 0.09718749672174454}, {"wallTime": 1733068414.5605032, "step": 8, "value": 0.15583333373069763}, {"wallTime": 1733068496.3604212, "step": 9, "value": 0.3227827250957489}, {"wallTime": 1733068577.3383067, "step": 10, "value": 0.18528273701667786}, {"wallTime": 1733068657.0193682, "step": 11, "value": 0.216889888048172}, {"wallTime": 1733068739.5048826, "step": 12, "value": 0.22450892627239227}, {"wallTime": 1733068819.3496027, "step": 13, "value": 0.17592261731624603}, {"wallTime": 1733068898.7711985, "step": 14, "value": 0.3352232277393341}, {"wallTime": 1733068981.8788157, "step": 15, "value": 0.12604166567325592}, {"wallTime": 1733069061.5264573, "step": 16, "value": 0.13177083432674408}, {"wallTime": 1733069141.7474852, "step": 17, "value": 0.18778273463249207}, {"wallTime": 1733069220.0108254, "step": 18, "value": 0.18260416388511658}, {"wallTime": 1733069301.6535835, "step": 19, "value": 0.23334822058677673}, {"wallTime": 1733069380.193341, "step": 20, "value": 0.2071131020784378}, {"wallTime": 1733069459.25263, "step": 21, "value": 0.20999999344348907}, {"wallTime": 1733069538.286744, "step": 22, "value": 0.2670833468437195}, {"wallTime": 1733069618.328814, "step": 23, "value": 0.38276785612106323}, {"wallTime": 1733069698.670513, "step": 24, "value": 0.35787200927734375}, {"wallTime": 1733069776.624565, "step": 25, "value": 0.36375001072883606}, {"wallTime": 1733069853.4837468, "step": 26, "value": 0.20230655372142792}, {"wallTime": 1733069929.9054239, "step": 27, "value": 0.326264888048172}, {"wallTime": 1733070006.6466165, "step": 28, "value": 0.22840774059295654}, {"wallTime": 1733070083.3185468, "step": 29, "value": 0.23805059492588043}, {"wallTime": 1733070161.874753, "step": 30, "value": 0.2807440459728241}, {"wallTime": 1733070242.7127233, "step": 31, "value": 0.3702976107597351}, {"wallTime": 1733070321.6596391, "step": 32, "value": 0.33781251311302185}, {"wallTime": 1733070398.756892, "step": 33, "value": 0.36541667580604553}, {"wallTime": 1733070477.5779023, "step": 34, "value": 0.2136755883693695}, {"wallTime": 1733070554.4162388, "step": 35, "value": 0.3428422510623932}, {"wallTime": 1733070633.4637372, "step": 36, "value": 0.2787202298641205}, {"wallTime": 1733070708.8289647, "step": 37, "value": 0.2877380847930908}, {"wallTime": 1733070788.195822, "step": 38, "value": 0.3475446403026581}, {"wallTime": 1733070863.7625027, "step": 39, "value": 0.2962351143360138}, {"wallTime": 1733070940.4244525, "step": 40, "value": 0.2834226191043854}, {"wallTime": 1733071015.5077481, "step": 41, "value": 0.3383482098579407}, {"wallTime": 1733071090.3861961, "step": 42, "value": 0.30879464745521545}, {"wallTime": 1733071168.6896806, "step": 43, "value": 0.2873660624027252}, {"wallTime": 1733071243.971184, "step": 44, "value": 0.3449702262878418}, {"wallTime": 1733071323.496053, "step": 45, "value": 0.2936904728412628}, {"wallTime": 1733071400.5769727, "step": 46, "value": 0.2927529811859131}, {"wallTime": 1733071478.5945606, "step": 47, "value": 0.28971725702285767}, {"wallTime": 1733071557.3421307, "step": 48, "value": 0.29997023940086365}, {"wallTime": 1733071636.6235075, "step": 49, "value": 0.281934529542923}, {"wallTime": 1733071716.251367, "step": 50, "value": 0.38043153285980225}, {"wallTime": 1733071795.0559509, "step": 51, "value": 0.29252976179122925}, {"wallTime": 1733071872.790179, "step": 52, "value": 0.2727232277393341}, {"wallTime": 1733071948.3578262, "step": 53, "value": 0.2843005955219269}, {"wallTime": 1733072023.6570768, "step": 54, "value": 0.2895684540271759}, {"wallTime": 1733072099.4582813, "step": 55, "value": 0.3183928430080414}, {"wallTime": 1733072175.7666523, "step": 56, "value": 0.32577380537986755}, {"wallTime": 1733072250.328096, "step": 57, "value": 0.3284672498703003}, {"wallTime": 1733072328.7792408, "step": 58, "value": 0.3311309516429901}, {"wallTime": 1733072409.4395132, "step": 59, "value": 0.2985416650772095}, {"wallTime": 1733072484.42247, "step": 60, "value": 0.30433034896850586}, {"wallTime": 1733072557.8964746, "step": 61, "value": 0.30751487612724304}, {"wallTime": 1733072632.6975543, "step": 62, "value": 0.312604159116745}, {"wallTime": 1733072707.4899333, "step": 63, "value": 0.3148958384990692}, {"wallTime": 1733072782.3873887, "step": 64, "value": 0.3213690519332886}, {"wallTime": 1733072861.0655315, "step": 65, "value": 0.30781251192092896}, {"wallTime": 1733072938.1310797, "step": 66, "value": 0.31708332896232605}, {"wallTime": 1733073013.9536605, "step": 67, "value": 0.3093898892402649}, {"wallTime": 1733073089.9478612, "step": 68, "value": 0.30555060505867004}, {"wallTime": 1733073164.1274416, "step": 69, "value": 0.3232142925262451}, {"wallTime": 1733073238.522515, "step": 70, "value": 0.3116517961025238}, {"wallTime": 1733073316.8102658, "step": 71, "value": 0.32635417580604553}, {"wallTime": 1733073398.2832303, "step": 72, "value": 0.3266369104385376}, {"wallTime": 1733073478.719394, "step": 73, "value": 0.3444196283817291}, {"wallTime": 1733073559.0352228, "step": 74, "value": 0.31514880061149597}, {"wallTime": 1733073639.2057703, "step": 75, "value": 0.3189285695552826}, {"wallTime": 1733073720.5343897, "step": 76, "value": 0.3136458396911621}, {"wallTime": 1733073800.8924632, "step": 77, "value": 0.32357141375541687}, {"wallTime": 1733073880.6263316, "step": 78, "value": 0.32255953550338745}, {"wallTime": 1733073962.41955, "step": 79, "value": 0.31349703669548035}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1903" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_6%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_6", "runToSeries": {".": [{"wallTime": 1733067740.1519318, "step": 0, "value": 0.0}, {"wallTime": 1733067829.7559018, "step": 1, "value": 0.00014399236533790827}, {"wallTime": 1733067913.793396, "step": 2, "value": 0.00020468203001655638}, {"wallTime": 1733067996.9954638, "step": 3, "value": 0.0005657461588270962}, {"wallTime": 1733068080.1572902, "step": 4, "value": 0.0007262744475156069}, {"wallTime": 1733068164.1923697, "step": 5, "value": 0.003218971425667405}, {"wallTime": 1733068247.8722472, "step": 6, "value": 0.002444834215566516}, {"wallTime": 1733068333.25712, "step": 7, "value": 0.004302285611629486}, {"wallTime": 1733068414.5604544, "step": 8, "value": 0.003153186524286866}, {"wallTime": 1733068496.360375, "step": 9, "value": 0.006374009884893894}, {"wallTime": 1733068577.338259, "step": 10, "value": 0.005928525701165199}, {"wallTime": 1733068657.019323, "step": 11, "value": 0.004377336241304874}, {"wallTime": 1733068739.5048366, "step": 12, "value": 0.00511807668954134}, {"wallTime": 1733068819.3495567, "step": 13, "value": 0.004619639366865158}, {"wallTime": 1733068898.7711506, "step": 14, "value": 0.02348700538277626}, {"wallTime": 1733068981.8787706, "step": 15, "value": 0.003300339449197054}, {"wallTime": 1733069061.5264082, "step": 16, "value": 0.006334901787340641}, {"wallTime": 1733069141.7474396, "step": 17, "value": 0.005124639254063368}, {"wallTime": 1733069220.010777, "step": 18, "value": 0.01488371193408966}, {"wallTime": 1733069301.6535342, "step": 19, "value": 0.010632997378706932}, {"wallTime": 1733069380.1932623, "step": 20, "value": 0.005219663958996534}, {"wallTime": 1733069459.2525837, "step": 21, "value": 0.004254963714629412}, {"wallTime": 1733069538.2866964, "step": 22, "value": 0.013882651925086975}, {"wallTime": 1733069618.328769, "step": 23, "value": 0.007376194000244141}, {"wallTime": 1733069698.6704652, "step": 24, "value": 0.0066057960502803326}, {"wallTime": 1733069776.6245043, "step": 25, "value": 0.007809990085661411}, {"wallTime": 1733069853.483699, "step": 26, "value": 0.01728884130716324}, {"wallTime": 1733069929.9053783, "step": 27, "value": 0.028079362586140633}, {"wallTime": 1733070006.6465695, "step": 28, "value": 0.0048633539117872715}, {"wallTime": 1733070083.3184993, "step": 29, "value": 0.006509245838969946}, {"wallTime": 1733070161.8747053, "step": 30, "value": 0.029583217576146126}, {"wallTime": 1733070242.712677, "step": 31, "value": 0.015500234439969063}, {"wallTime": 1733070321.6595948, "step": 32, "value": 0.01743396185338497}, {"wallTime": 1733070398.756826, "step": 33, "value": 0.020298050716519356}, {"wallTime": 1733070477.577854, "step": 34, "value": 0.02565738745033741}, {"wallTime": 1733070554.4161913, "step": 35, "value": 0.03188512846827507}, {"wallTime": 1733070633.46369, "step": 36, "value": 0.016959600150585175}, {"wallTime": 1733070708.8289196, "step": 37, "value": 0.035212915390729904}, {"wallTime": 1733070788.1957738, "step": 38, "value": 0.03049165941774845}, {"wallTime": 1733070863.7624533, "step": 39, "value": 0.020152974873781204}, {"wallTime": 1733070940.4244044, "step": 40, "value": 0.0194319486618042}, {"wallTime": 1733071015.5077002, "step": 41, "value": 0.008599044755101204}, {"wallTime": 1733071090.3861501, "step": 42, "value": 0.00875853281468153}, {"wallTime": 1733071168.6896083, "step": 43, "value": 0.008153071627020836}, {"wallTime": 1733071243.9711344, "step": 44, "value": 0.020325487479567528}, {"wallTime": 1733071323.496004, "step": 45, "value": 0.00893571600317955}, {"wallTime": 1733071400.576925, "step": 46, "value": 0.019982242956757545}, {"wallTime": 1733071478.5945141, "step": 47, "value": 0.008547857403755188}, {"wallTime": 1733071557.3420715, "step": 48, "value": 0.00920194759964943}, {"wallTime": 1733071636.6234622, "step": 49, "value": 0.018734872341156006}, {"wallTime": 1733071716.2513201, "step": 50, "value": 0.008957646787166595}, {"wallTime": 1733071795.0558872, "step": 51, "value": 0.009892793372273445}, {"wallTime": 1733071872.7901292, "step": 52, "value": 0.009287030436098576}, {"wallTime": 1733071948.3577805, "step": 53, "value": 0.009383942000567913}, {"wallTime": 1733072023.6570275, "step": 54, "value": 0.009567715227603912}, {"wallTime": 1733072099.4582298, "step": 55, "value": 0.009775403887033463}, {"wallTime": 1733072175.7666035, "step": 56, "value": 0.009403837844729424}, {"wallTime": 1733072250.3280492, "step": 57, "value": 0.008959637954831123}, {"wallTime": 1733072328.7791939, "step": 58, "value": 0.009250693954527378}, {"wallTime": 1733072409.439465, "step": 59, "value": 0.009140054695308208}, {"wallTime": 1733072484.4224205, "step": 60, "value": 0.009698564186692238}, {"wallTime": 1733072557.8964233, "step": 61, "value": 0.009364929981529713}, {"wallTime": 1733072632.6975062, "step": 62, "value": 0.009390727616846561}, {"wallTime": 1733072707.4898875, "step": 63, "value": 0.009117956273257732}, {"wallTime": 1733072782.3873425, "step": 64, "value": 0.020452184602618217}, {"wallTime": 1733072861.0654838, "step": 65, "value": 0.023569202050566673}, {"wallTime": 1733072938.1310332, "step": 66, "value": 0.02344849891960621}, {"wallTime": 1733073013.953593, "step": 67, "value": 0.0345558300614357}, {"wallTime": 1733073089.9478152, "step": 68, "value": 0.02106270007789135}, {"wallTime": 1733073164.127394, "step": 69, "value": 0.021042579784989357}, {"wallTime": 1733073238.5224674, "step": 70, "value": 0.010058213025331497}, {"wallTime": 1733073316.8102047, "step": 71, "value": 0.010010222904384136}, {"wallTime": 1733073398.2831736, "step": 72, "value": 0.023182226344943047}, {"wallTime": 1733073478.719333, "step": 73, "value": 0.009715688414871693}, {"wallTime": 1733073559.0351753, "step": 74, "value": 0.023449573665857315}, {"wallTime": 1733073639.2057228, "step": 75, "value": 0.009674716740846634}, {"wallTime": 1733073720.5343416, "step": 76, "value": 0.009481617249548435}, {"wallTime": 1733073800.8924162, "step": 77, "value": 0.009804029017686844}, {"wallTime": 1733073880.626285, "step": 78, "value": 0.009800569154322147}, {"wallTime": 1733073962.4195042, "step": 79, "value": 0.023420516401529312}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1923" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_9%22%7D%5D": { + "data": "[{"plugin": "scalars", "tag": "Test/coco_eval_bbox_9", "runToSeries": {".": [{"wallTime": 1733067740.1519692, "step": 0, "value": 6.684048912575236e-06}, {"wallTime": 1733067829.7559369, "step": 1, "value": 0.002073458628728986}, {"wallTime": 1733067913.7934308, "step": 2, "value": 0.002061847597360611}, {"wallTime": 1733067996.9954984, "step": 3, "value": 0.003430028911679983}, {"wallTime": 1733068080.1573288, "step": 4, "value": 0.005441515706479549}, {"wallTime": 1733068164.1924043, "step": 5, "value": 0.012274672277271748}, {"wallTime": 1733068247.8722832, "step": 6, "value": 0.014647375792264938}, {"wallTime": 1733068333.257169, "step": 7, "value": 0.024767443537712097}, {"wallTime": 1733068414.5604913, "step": 8, "value": 0.038779307156801224}, {"wallTime": 1733068496.3604093, "step": 9, "value": 0.03253353014588356}, {"wallTime": 1733068577.3382945, "step": 10, "value": 0.036951154470443726}, {"wallTime": 1733068657.0193567, "step": 11, "value": 0.030356390401721}, {"wallTime": 1733068739.504871, "step": 12, "value": 0.04081573709845543}, {"wallTime": 1733068819.3495913, "step": 13, "value": 0.03270383179187775}, {"wallTime": 1733068898.7711864, "step": 14, "value": 0.06497424095869064}, {"wallTime": 1733068981.8788042, "step": 15, "value": 0.05568074434995651}, {"wallTime": 1733069061.5264452, "step": 16, "value": 0.06029221788048744}, {"wallTime": 1733069141.7474737, "step": 17, "value": 0.06443183869123459}, {"wallTime": 1733069220.0108135, "step": 18, "value": 0.06886637210845947}, {"wallTime": 1733069301.6535716, "step": 19, "value": 0.05306315794587135}, {"wallTime": 1733069380.1933262, "step": 20, "value": 0.06009689345955849}, {"wallTime": 1733069459.2526183, "step": 21, "value": 0.042109400033950806}, {"wallTime": 1733069538.2867322, "step": 22, "value": 0.05322858691215515}, {"wallTime": 1733069618.3288028, "step": 23, "value": 0.056789468973875046}, {"wallTime": 1733069698.6705008, "step": 24, "value": 0.069350965321064}, {"wallTime": 1733069776.6245522, "step": 25, "value": 0.0737883448600769}, {"wallTime": 1733069853.4837348, "step": 26, "value": 0.07697335630655289}, {"wallTime": 1733069929.9054124, "step": 27, "value": 0.07850117236375809}, {"wallTime": 1733070006.6466048, "step": 28, "value": 0.04465571790933609}, {"wallTime": 1733070083.3185344, "step": 29, "value": 0.07106722891330719}, {"wallTime": 1733070161.8747413, "step": 30, "value": 0.07862686365842819}, {"wallTime": 1733070242.7127113, "step": 31, "value": 0.07606863975524902}, {"wallTime": 1733070321.6596277, "step": 32, "value": 0.07669545710086823}, {"wallTime": 1733070398.7568722, "step": 33, "value": 0.0763465091586113}, {"wallTime": 1733070477.5778906, "step": 34, "value": 0.07596945762634277}, {"wallTime": 1733070554.4162266, "step": 35, "value": 0.07745145261287689}, {"wallTime": 1733070633.4637253, "step": 36, "value": 0.07112746685743332}, {"wallTime": 1733070708.8289533, "step": 37, "value": 0.07669731974601746}, {"wallTime": 1733070788.1958108, "step": 38, "value": 0.07625365257263184}, {"wallTime": 1733070863.7624903, "step": 39, "value": 0.07581155747175217}, {"wallTime": 1733070940.4244406, "step": 40, "value": 0.08308868855237961}, {"wallTime": 1733071015.507736, "step": 41, "value": 0.07903845608234406}, {"wallTime": 1733071090.3861845, "step": 42, "value": 0.08453068882226944}, {"wallTime": 1733071168.6896684, "step": 43, "value": 0.08448376506567001}, {"wallTime": 1733071243.9711723, "step": 44, "value": 0.0811365395784378}, {"wallTime": 1733071323.496041, "step": 45, "value": 0.08728682994842529}, {"wallTime": 1733071400.576961, "step": 46, "value": 0.08589828014373779}, {"wallTime": 1733071478.5945487, "step": 47, "value": 0.08564985543489456}, {"wallTime": 1733071557.342119, "step": 48, "value": 0.0834183618426323}, {"wallTime": 1733071636.6234958, "step": 49, "value": 0.07762496173381805}, {"wallTime": 1733071716.251355, "step": 50, "value": 0.08672305941581726}, {"wallTime": 1733071795.0559394, "step": 51, "value": 0.08481330424547195}, {"wallTime": 1733071872.7901664, "step": 52, "value": 0.08859042078256607}, {"wallTime": 1733071948.3578146, "step": 53, "value": 0.08559554815292358}, {"wallTime": 1733072023.6570647, "step": 54, "value": 0.08512848615646362}, {"wallTime": 1733072099.4582682, "step": 55, "value": 0.08521803468465805}, {"wallTime": 1733072175.7666404, "step": 56, "value": 0.06807860732078552}, {"wallTime": 1733072250.3280845, "step": 57, "value": 0.07260553538799286}, {"wallTime": 1733072328.7792292, "step": 58, "value": 0.09032462537288666}, {"wallTime": 1733072409.439501, "step": 59, "value": 0.08422074466943741}, {"wallTime": 1733072484.422458, "step": 60, "value": 0.08312493562698364}, {"wallTime": 1733072557.8964615, "step": 61, "value": 0.08583468198776245}, {"wallTime": 1733072632.6975427, "step": 62, "value": 0.08820506930351257}, {"wallTime": 1733072707.4899216, "step": 63, "value": 0.08568596094846725}, {"wallTime": 1733072782.3873768, "step": 64, "value": 0.08692464977502823}, {"wallTime": 1733072861.0655196, "step": 65, "value": 0.08991467207670212}, {"wallTime": 1733072938.1310682, "step": 66, "value": 0.08986104279756546}, {"wallTime": 1733073013.9536357, "step": 67, "value": 0.08903561532497406}, {"wallTime": 1733073089.9478495, "step": 68, "value": 0.08680862188339233}, {"wallTime": 1733073164.12743, "step": 69, "value": 0.08658663928508759}, {"wallTime": 1733073238.522503, "step": 70, "value": 0.08707484602928162}, {"wallTime": 1733073316.8102534, "step": 71, "value": 0.08655466139316559}, {"wallTime": 1733073398.2832158, "step": 72, "value": 0.0899362862110138}, {"wallTime": 1733073478.719382, "step": 73, "value": 0.0761806070804596}, {"wallTime": 1733073559.0352108, "step": 74, "value": 0.08997105062007904}, {"wallTime": 1733073639.2057588, "step": 75, "value": 0.07709036767482758}, {"wallTime": 1733073720.5343776, "step": 76, "value": 0.08915881812572479}, {"wallTime": 1733073800.8924515, "step": 77, "value": 0.09008131921291351}, {"wallTime": 1733073880.6263201, "step": 78, "value": 0.07559683173894882}, {"wallTime": 1733073962.4195387, "step": 79, "value": 0.091497503221035}]}}]", + "ok": true, + "headers": [ + [ + "content-length", + "1925" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + }, + "https://localhost:6007/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22Test/coco_eval_bbox_11%22%7D%5D": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-length", + "1379" + ], + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 821 + }, + "id": "HutUlygrSfch", + "outputId": "da1c151e-4e0b-4334-e76b-f7cd171c53ee" + }, + "id": "HutUlygrSfch", + "execution_count": 18, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " (async () => {\n", + " const url = new URL(await google.colab.kernel.proxyPort(6007, {'cache': true}));\n", + " url.searchParams.set('tensorboardColab', 'true');\n", + " const iframe = document.createElement('iframe');\n", + " iframe.src = url;\n", + " iframe.setAttribute('width', '100%');\n", + " iframe.setAttribute('height', '800');\n", + " iframe.setAttribute('frameborder', 0);\n", + " document.body.appendChild(iframe);\n", + " })();\n", + " " + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Inference custom model on a example image" + ], + "metadata": { + "id": "oPXFdSCac0U7" + }, + "id": "oPXFdSCac0U7" + }, + { + "cell_type": "code", + "source": [ + "!wget -O arduino.jpg https://images.unsplash.com/photo-1603732551658-5fabbafa84eb?ixlib=rb-4.0.3&q=85&fm=jpg&crop=entropy&cs=srgb&dl=sahand-babali-gavODTHG36Y-unsplash.jpg&w=1920" + ], + "metadata": { + "id": "Z8h72WZcTNLJ" + }, + "id": "Z8h72WZcTNLJ", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Preview of the image\n", + "from IPython.display import Image as IPyImage\n", + "IPyImage(filename=f'{HOME}/arduino.jpg', width=600)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 417 + }, + "id": "AA-zVp6NTrmL", + "outputId": "4f3a3db9-ab6a-4599-c9b3-aea9cd173576" + }, + "id": "AA-zVp6NTrmL", + "execution_count": 34, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/jpeg": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/jpeg": { + "width": 600 + } + }, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from PIL import Image\n", + "\n", + "# Resize image\n", + "image = Image.open(\"arduino.jpg\")\n", + "image = image.resize((640, 640))\n", + "image.save(\"arduino_640.jpg\")" + ], + "metadata": { + "id": "eM4yayxBamBv" + }, + "id": "eM4yayxBamBv", + "execution_count": 36, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!python D-FINE/tools/inference/torch_inf.py -c D-FINE/configs/dfine/custom/dfine_hgnetv2_l_custom.yml -r output/dfine_hgnetv2_l_custom/last.pth --input arduino_640.jpg --device cuda:0" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0VwBjSFIZhOb", + "outputId": "804abada-febc-4eb5-fa03-20a9ae079b53" + }, + "id": "0VwBjSFIZhOb", + "execution_count": 30, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2024-12-01 18:11:22.983370: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-12-01 18:11:23.000386: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-12-01 18:11:23.021204: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-12-01 18:11:23.027462: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-12-01 18:11:23.042368: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-12-01 18:11:24.274637: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "/content/D-FINE/tools/inference/torch_inf.py:118: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " checkpoint = torch.load(args.resume, map_location='cpu')\n", + "Image processing complete.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Show results\n", + "IPyImage(filename=f'{HOME}/torch_results.jpg', width=600)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 617 + }, + "id": "P6NTL3rhZ0uY", + "outputId": "bd7c1a27-30b2-4ba2-df9b-e93d6c7d3086" + }, + "id": "P6NTL3rhZ0uY", + "execution_count": 35, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAKAAoADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD0uiiivRPECiiigBKWkNFMBaKSigQUUUUALSUUUAFFFFABRRRQAtJRRQAh6VEzEVJ1qNhQMkVlmXBOH7e9QmXc32eTI9DVe53RkYPvT4Z0mVVnwH/hb1rCS69DojK/uv4n+Jj61amz0+4kCl2fgYqLwfH5FkAV2gksQa3zhFMFyu+M9M0wWIt0LQfNGfTtSVr3e7KbbXKvhXQd5uHaT1q1HwgFZ6/vJ0jH1NaNbJanNJ6WYUlLRVEFZ8xzBx0PBqZmKEOP4f5UkiblIqOBsgo3UcVLWvqXFu2m6LB9R0PNJUcb/wDLM9V/lT6cdrMJpXuuoGkNLSVRA0io3TIqUikxQIptFz0qP7Pk9KvFRRtA7U7k2IoYQnPerAGKQCnUikFLSUUDFopKKAClpDVaafEvlggYHP1pPRXBK7sWTSYqlBdSIwjmUknoR3q8GDdDQmmDi1uHSilNJTEJRRmlALHAGTQA00LAkoTzchd3zH2qR1FpPELhSQ3O0UPeLcTbWUIg4C/41y1ql/hO3D0+VvnGXN3HAkkNmoEbjGcdaxYot0656Z5Na13bxxSxFHBDLkj0NMkihig2qcyNTpLTTqKtK0teg9No+VDlR0NPqvbIY12mrFdCVlY5G7u4UUUUwEooooEJTXQMKfSdqAKE0LAHacVn/Pbtuwa3WUGoHt1btQ0mrMSbTujKSOQsZOcmr1veSo2HO4e9S+TjgCmtCD2ocYyVmEZyi7pltJY5T8p2t6U8qCMOOPWswoyHjkVNHdMpweR6GspU2tjeNZPRnDeNrO4guriWxggl/dQgmVdxUvIyjb+PevL/ALTf6bebLrzAynlZOQfwr3LUbcajqN0kbFCIrWQD1KSyMP1UVzOqWumSzyx6zCIpZ3GJGPHAAwPbv9Sa54ulGF3FOXvdNd9Pu1/A9qVepC0IzaVo9Xb4UY+iX9vqLwq9tabZXaMARDcCFJyT3+6e3pV+6EMOowWqWVuys5SVjGODsZgB7/Lz7EetcI9wmka5IbGUmKNyEYHOOMZ/WvRNMGl+IYobpYo0uUbzC6ouWO0jk4565+oFenSng5vWK2fTrrb9PmedXrYmDv7SVvV/5lewKJdSrNZ2cnlhSQIQQCc5XnOSOOfccVsC00rVJLuIW8MCGCIhUQKN26TJwPwqiNJk0+Moksky9cybc57ngDJPvWJqN1La+e6Eq2xen1Nc2Mw9J1FKmktenoaYXMazhUjUk5Ky3b/micjrGmYvJBA5IRiBWakjQPsnUj3rXt79Wf8AejDZ71bntYLxOQDXnyTT1OmDjJe6Z0UEVwuVINRS6LuO6M4brUM9lc2Dl4CSvpU9pra7tk42mp1K06n07RS0lemeIFLSUUwCiiigQUUUlAC0UlFAC0UUlAC0UlFABSM+1ST2oJqulwjrK7nhTjFZVqns43OjC0PbTs9luR2Wox3ryKmQyHBBFXa56w2jVH8ogZyxrfU7hmow05zh7+5pjadKFT9z8PmOpDgDcegpcelRXEmBsH41tLsjljp7z6FZ1M0v1plzGEIAH3atwrsUuevaoHUu/uaFq7dED0jfqwhuVePZc8qOjelK8klixkHzRNz7GmTRBUA9aiS8MBETr5kbHBU+lZSju4/cbQlspvXuX7QQXTNPCNrsOVNTEFSQRzTEt4iga1baRztPUVILjny7pSp7NThLl0X/AAQnHm1e/foxlFSPEUGRyvqKj7Z7A1rzK1zHkfNysKryrslWQdOhqcHNI67kINDV0SnZkE2UkSQfQ1YpjhZIQB6YP1oicNGvPzjhhUp6p9zRx0a7fkPpKWkrQyCkpaSgQYooooAKWkooAWiiigYUUUhoEKTgVj3gbz2I/irWbpVP5ROFcZBNKV7FRavqGmeZuZ3+ZF7HrV4xbpD5RxuqtJG0DDyz8ueRTZN0UYkV+GOc5/SuKonfm2PQpSSXLa5aQkg57GlNV7STzU46+lakdqsa+ZcHaOy9zXSqiUdTjdKUpOy0K8FtJO2FHHcmrYaK1BWEB5O7noKjnu8Jgfu4+yjqayri8ZvlTgegqHzVNDT3KSv1/rYffXq7yS2+X19Kz4p3WR5JM4PepFty7bn/ACqUwhxjHFaqlFKzMJV5OV0VTI88g2Hgd6txKe/J9aRIQhwo4qyqgCrSSVkZttu7ALinUdqM0AFFLSUDCikzS0AFJS0mKBBRiiigBMU0qDT6KAIWSoJIgenWrhFMZc00FjnyjrrFyOf+PeH/ANCkrlfGlhdajbLkllj5HHNduqf8T27BH/LtD/6FLTrmySZCpAINZ01FrVdX+Z0YtyVRcr+zH/0lHzvPbvblldTxXX2sQ8O6JZ6rFMTI5HmR56+1anijw0qM0kafKeuBXEatPdGKK2lOY4uBXPVpOm+aJ0Yeuq0eSa1PY9J1C21uwWaJgSRyKxdZ0sS3VyiryIoz+Zf/AArz/wALa1d6XqcawktHIwDJ/hXsKw+fqVwXHJtoSR/wKSt41Oflfn+jM3R5I1V/d/8Abonjmo6VJBIx2kVSiuZrZsHJHoa9e1LRI5wfkGa4vVPDbRklV4+lVOjfY5qWIcNzIgvYrhdr4yfWq95o0VwpePAPtUU+nSxNwCCKu6N9olv44HBKk81xyoO+h6UMUnH3j6MozRRXaecJS0lFAC0UlFABRRRQAUUUUCEPWjtS0UAFIaKDzQAh4rnNSadbiSG3GS4L49cV0TDis26hxcJOv3kP6VM4c0bF06jhLyOU0qS6N39pbIPpXcWkvmwg1mLYhJmCrwTkfjV2yXymcHhRzQ2klJCjGTbi9y5JIIlz37VXiUyyZNNJM8pParO4RJx16Clsr9R6SduiGzEBto6CmxL1Y9KYMu2BUrnaNo7daNlZbgnzNyeyIpR5jZNUxH512Wx8q8CrUpKp7mnW0W1MnqacVr6Ck3bXdirx/jVhLnI2yqJF9+tRMtMIx0puKluTGcobF2FCMm1feveF/wClMl2OriMFZMcxnqKrBypByQR3FTfayzKZV3N0DjqKwnTlFXWp1U6sJNKSsNX5XZT606qdzqtrEwV5AWCkl653Q9fub7XJrZsG35KnvjtSp4iLfJ1NK2ClGHtb6PY6ZiY7kf3X/nSqAl2CfuuNv49qbcqXhJH3hyKRGFzahgfm/ka3cehxKVrPsWjwcGkqKCbzV+bhxw1S1Sd0KSsw70UhpaZIlGaWkoAKWkpaACkozRQAUGjtUc88dvbyTzNtiiQu7YzgAZJ4pN21Y4xcnZatjzyKrzxbue9Q/wBsW3/PK9/8AZv/AIikOr2x/wCWV7/4Azf/ABFL2tP+ZfebvBYn/n3L7mQy3E8RGecHrVmS6R7VlCgZH61Um1C1cH9ze/8AgDN/8RVL7XCrE7LzHp9jm/8Aiazm6U/tL7y4YfFwuvZy+5m1Z6illDxbGS4Y4Vuyj1pzXk6StK0nnAjOT2PpWKdRgVc+Xef+Akv/AMTSJqsQJxHd49Pskv8A8TWUo073jJfeawp4rl5ZU5fczXaUzHIOc96ekIXk8msyPVrQcGO7Vv8Arzl/+JqePV4M4MV6fQiym/8Aia0jXglZtGcsDiJO6py+5mgEzT9uBiq9rqFveSyRxeaHjAZlkheMgHODhgM9D+VWq2U1JXTOapSnSlyzVn5jduKXFLRTMxMUUUUAFJmlpKADvS0UUAFFJS0DCikpRQAlFFFACUhpTRQBnxj/AIn13/16wf8AoUtW2WoLjTre5uPPfzlkKhC0U7x5AJIB2kZ6n86jOkW3/PW9/wDA2b/4qskpx0SXXr/wDrqSw9RqTk07JfCnskv5l2Ir+yS4hZWXORXmOv6EFldSvB6GvT30e3xjzLz/AMDZv/iqytR8PwSIdpuCf9q4kb+Zq7zas0vv/wCAZcuHT5ozlf8Awr/5I8z8NaDNHqq3LJuWE7gPWvVdOnW71O5ccH7NCCPT5pKx7LQ0gclzMB/szOv8jWgLD+zp/tdp5hDACRWdnPHuSfU1iqc4tOyt6+XodKrUXTnFSbk1bZLqn/M+xry24YdKzbmwVwcrW1E3mxK+OopHiB7V1JnnOPQ4a+0BJCSFwaj0zQvJnDlBn1xXaPag9qEtwvam2JKxt0UUVmbBRRRQAUUUUAFBoooEJQaKKAAUGk70tABRRRQAh5FRGEEHPNTUlAyGNOOeq8VBLKDOsSrlTwSPWnXUzLIsUPLucH2p8EBRSxHzVlbmujZvltLr1JUi8qIfrULsWP1qa4dvIjOMA5JqvGyb8swHpRCd05S6BUpNNQgtWTJ+7Gf4qbnLc0hGGY5zu/lTXOEz3P8AKqvpzdyLa8r2W41/3s2B07VcUYAFV7dONx71ODnvVpWVjJtydxSKawBp9JTAhZcVBMCBkdjVw1BKmVNAtjgvFZeK58tf4pBn3HWo/Dcudc3RDCcjj0rS8W6ZNeIHhyGXa34Hg0/w5pP2CMEjMh6k1yUqKU3I9HE4lypxh0SOvHzJVO3PkXTxH7r8j61cjGEFU75QqeYDgpyDXVLa5wQV5Jdx7vHb3BdnVQRyM1YinjuIw8Thl9RXmOp6xc3krushChivHeuh8EXLlLiJmJHDc+tcWHrznP3loz1cZhaFKlaDbkt+x2NFAoNdx5AdKKKM0AFFFFAAeaKM0UAJVHWz/wAU/qX/AF6y/wDoBq90qhrn/IA1L/r1l/8AQDU1f4cvRnRg/wDeaf8AiX5nPS21vaDUI/3f2aPVkLpcufLkzbR/6xjnA3EHJz8wHrUyD/iQ6X9vCCyN65mDf6sQky+VnP8ADnyuvtXV0Z7DrXfLGe6uZfj5W+/rcxV27I56zmuV8NmOwQy3G9/JQMu5IWlcRvhiOAgyAeuMVkQWUTeGrZnhnRrbV9sYlkyeb0Ak4JBPUZPvjg5Pcxq8uAqkn0Aq2NP2MRcSpGVAJGecVCx6g3Zby5vz0/EuNOb2RkmEd6WOwlkP7tDj1NaRmtrd/wB0nmEd26VBNdTTNjJwf4VFcPPN/CvvD2cI/E7+n+ZGtvaw/wDHw+8/3VqozyQSM1scIeiHsK1ItGuJV8yUrBH1LSHFV7r+z7eBo4neeY8BxworJqMnZu7Nk5xV0lFfiYdtK02vXrR5WT7PDlG7/NJWtBK0oYMhQqcc96y7bjXbpsc/Zoef+BS1ro2a1oxsvm/zFjJc1Rf4Y/8ApKHUUGkrU5BaKKTNAC0UUlABSmkooAO9LSheCx4Ud6jdsttPA9KylU15Vubwpac0thQwPI6etLSDpS1aVkZN3YUUhoNMQtNo6UtACUUtJQAnWo3jBHNS0hFAilJAD2pEXbwRxVxlqMx80wHJjaAOlPxmmquKfSAZto2Cn9qXFAyzRRRSKCkzQaKAFopKKBhRRSUCFozSUtACUd6WkoADRRmmu6xruYgCgNxJJFj256scCodRnksrJ52QhF+83oKz7rVIxOjY/do2QT3NM1LXEu9Nlt3xtdcZrjr1ailaK0PUwtCg4pzer/AvWaLLElwrbs/Mpq/vEp3AYzyayNAdF0mGFWzsGKuzSC3gck43nC/U1vzNxU7HFypTlC90n+RHqNznyYwQN3OPauO1rVrnTNeRmBa22jj+Zro7lg+pxMR8qYT6DFZPizTWuLdXRcvH1x6VnGnzU3B9dTZ1vZ1lUXTQ27PU7W6t42EgGcY5qz/rJcDof5V5jpUskOp26PIyoD93NeoWg3IH9aMPGSVpdNgxtSnOSlDd7lpV2qBTI+GI96euSo9QStOwICSRmVhkL6D1rWU7K5zwp3bXSwrqUIU/e6kelNppbnrknuaX2NWr9TOTTfurQDTWGRT6aaohlSWEOvI6oy/kcikhgC84qwRjJ/usD+B4pyr8orOGkpI2qawiwHSq14u+3dfUGrRqKVdyketamPoeTXSpa5t92ZA5yK63wnBJHHvKFQw/OrT+H7U3xuXjDOT3ratYBGo4AHoKxhRUHdG9TEOpGzLy9KKQGitTAKKKKACijFFMQUUlLQAtZ2usqeHtRycZtpAP++TV+sXxPIf7FuU6jyZCf++TWdbSEvQ68Ek8TTv/ADL8zQjupLiZUijITPLtxV2aA2ygs+D3JrGl1I7v3S4x0Jrq7uw+3aDC0mDeFQygHnntXPW3XNsa0LcslDcoi9eJNiMFB5z3qJVlup8orSSN3Pf8aLdLfT2xfRNJIo4UHjPvSXOrtJIhixAqZwsf9aqne3ux+ZnUtf8AeS+RfOmw2wDX1yqH/nmnLU1tVitgVsbVU/6aScmsUzs5JAJPqaNkj/eOK19lf43cx9vb4Fb8ye6u5bht08zP7E8D8Krbgx4FSCFe5zTwgHQVokkrIxbcndszrdT/AG5d8cfZof8A0KWtVRiqMI/4n13/ANesH/oUtPvNQW0njiVN7MMtg/dFZwaS17v8zqxMW6it/LH/ANJRepKjt5lubdJlBCt61LWqaexzNNOzDvSUtFAhKWkJx1pVBZgFGSegFAxKlSPABYHnovc1JFEqvtwHk/u9h9ahvL5IMxwtvkPDP/QVzyqOT5YHTGlGC55jLmcRcMRuHRR0WqSSNI+fWmKjzNlqsxqEGB1rWFNQXmY1KrqPyJF4FPpo5paszFPSkooFIANFFJQMWiiigApKWg0AIRSYpaWgQ3FLS0lACCnUlLQNFikoNHakULSUd6KACijvSUALRSdKWgBKWkooAWkoooAMVFPEs0ZQ9DUtIaBGbPYRSwtCUyCpx9cVx2m2N5JfW4uGzFvG4e1egdJFPoazIrUq7EDBUn9KiSTbv2NYNrlt3IdHg8l5Qv3TIxUegzxVy+ja4vIoU5KEH8aWxVYbcyvwoGSakscnfdSfec5HtnpUzso27IqndyT7srCLzLufIxztFTSR+bGCwyeh+oqG0LJezROc7mLqfbNacSBmkj7sNy/Uf/Wpp2in2E1eTXc5iXw9bteLchcMDnFdFbLsjAp2wHmp1URx+aw68IPU1pJpamUIuTsPRTGGOAXI3Kp7Y71Vl3u2VyWJ5JqTJyZXfaB95j/Kq1xLmJhjC9Ao6n61gk+Zrq/wOltKKfRfiOMyxqNpBb+92oics2SSSe5qnbI7qC457Cr8abB71rBaX6nPOTvy9CSkpRRVkBHjzSh6SKU/HqP1pMEdRgnmmS5C7l4YHIqTzN+fYbl91P8A9fIrJ+7UT7m8fepNdUJTSM06krUwIzGCelKBin4pKYhaKTtRQAtFIKKBi0d6KKQCUvvSUUxAaxteRp9Mu4lVmkaBwgUZLHaeBWyapXURdeOtKUeeLRpSqulUjUXRp/cZkU1qOXS8H/bjN/8AEVam8URwuPL+2uwGObWRR/6DVqOZ41CKmOOSeage2WRy7ck1j7KT+Jr7v+CdLxGHj8MJf+BL/wCRM19aW7lJeO6HOSfs0p/9lqzHf2igfurwn1NlN/8AE1eit1U8CraLgVajNKya+7/gmTqYeTu4S/8AAl/8iZw1S37Q3o/7cpv/AIil/tS27x3v/gDN/wDEVp0U7VO6+7/ghzYb+SX/AIEv/kTO/tW1/wCeV7/4Azf/ABFL/a1t/wA8r3/wBm/+IrQootU7r7v+CPmw38kv/Al/8iZtg32zWbqWOOdY2ghjDSwvHkhpCQNwGeo/OrTeHRLK7iUlyeuatRHEoJ7c1Zjn22bsuCXcY9RWb9xWZcpRrT5krKyXfZJeXYzbeGWyVrOUfdYsp9Qanpt/cmS5hB+8q8n1pQcjNaQVkc03eQtIzBAWY4AodgiFm4ArPWb7ZKd52wA/i1NySFGLkSW0kt/eFIxhB0JFacMqw7iOGU8v/dHtSxPC3+hWjrGSpLyAckegrNvh8ipCxKE4+tcd3Unba56FlSp33sOuNR3l47cbVY8nuahigLHc9OgthGAW5NWAM12xioqyPOnOU3eQgAAwBTguKUClApiAUd6BRQAUUUUgDFFFFAwooFFABRQaSgBaKTtS0AFFFFABRRS0DJjRSim96QxaKSigBaQmgniigAooooAKSl60UAFGaSigA70UdKKYhjdM+lQO22O4Ye/61Yb7pqpIpKuo7uo/lWczWnt/XYSVN0MNqv8AHy/+6Kt7QTBEOAXyfoBTY4RG7vklm9e1KHBuFH90H9ama91lU5e8vIoTRnKzJ95DmryS5RJo+q4YVHGNymm2q7JXiPC/eB7AVcrLV7EQu9Fv0LuFYmQcR/e/+tQW3ku/yoo/IUxDv/djhU5UH09ahuJgcBf9WvT/AGj61nG8tOprPlir9Pz8vRDLmbzB0wv8K/1+tQW8cskavIPvZwfpxTlRpXNXYlC22wfwSfoR/iK0aUbWMFJzvf8AqwyKMIpHof51IKYxKsMdDxUlOOjaCWqTEpaSjpVECNyKpuzpyvLRHp6qe1XDVacbHWTt0P0qZq6LhK0ieORZIw6HKmnVQRja3GM/uZD/AN8mr9OL6CkuqEpaKKZIneiijvTAKKM0ZoAKKKKBBR0oooAO1NK5FOpKYERizSiMDrUgooFYaFANOpcUUhhRRRQAUlKOtNagABbJwpPY4q1I+YIYNhj2HJz3JFVbW8FtclnAaMEFoz/FVjVZV+0SQjKRPtYj0OM159acvaWPToQh7K/UoOpa5Of4eKnHAqvE5dy34VY7V3x2R5stGyO8dRYTDHzEVh/aMMDGPrWuWUzCGQ4SUbcnsarLpgEzKD8g5JrF6TafU6I+9TTXQkWUM4mGU46+lRQ3CNKUXOF6VDPHJJPsiOI14zVq2tlixxk+tXGmlqZTrN3RcXkc0/FIoxTq0MxKDRRQAUZoooAKKKKQBSUtFACd6WkqN2YjCce9TKSjuXCDk7IkoppBKYJpwHAojLm2CUHHcKWiiqJCiijvQAUUUUDJ6KKO1IYlHWigUAFFHakzQAvej8KKTNABS5zSd6KYB1oozQDSAKKKKYhG6Gqp/wBeR/tr/KrZ6VUzm6X/AHz+grOe6Nafwy/ruW6qk7L5f9oVaNV5o8yRODyrg5/GnNXi7E03aauOgH8I60l2SFCwnIU5JH8Z/wAKYWJmeMHGCdx9BnpUjSBF+X7+OP8AZHrUX5l5fmaJODts/wAkRzXGxDgAlf8AWf4VHtZ5cHHHpVSFVLOgHBbJz/FmtiOMG0ibADIPLfH6H8v5U4+69fmTP31ptuv1GIgQYFOHG8Y6rn8jS4pOd64OM5X8xVz+FkQ+JDZR8mR1HNORgyAjpQDuQH1FQW5Ks0Z7Hih7pgtYtFiiiiqICopVDIRUpppFNAykqiWJoX5Iqa1kJQxufnT17io5Mxy7x07/AEpZQQyyr1HP1rO3RdDS/V7Pct0lVpNSs45EjaZVZ/uqTz+NWacZxlsxTpThZyVk9vP0DNHakzWTr9xe29vbix3maSYrtQqGcCN2wCysByo7flVt/wBeo6NJ1Z8qdt9/JXNYUVww8QagYJQJrp7lLl4FjSaIo+0xruDGAdWlVenvmrNrq15fW8Rtru7a5dWkaNpIVUIER87vJ5yJY+w6+1bvC4hK7h+Mf8zX6tD/AJ+R/wDJv/kTsOtHSuRtdZe50m61D7dqKLHKsUEZWEvOXRGTA8vgtvAA/H6NsdYnvzZ+Xf3I85ImkQyweYpkRXwq+V8wUMuTx16cUvq2IV37N6ea/wAw+rQ/5+R/8m/+ROwqlp2r2OqCX7HOsnlOUcDqD6/Q+tcr421G70bSTDbanczXlwpCxyCILt7k7UB9uCK8/wDAt3e/2orRO9ozTpBuTJzkgMDuJHTHauCVdqaiov8AD/M3jgoODk6iX/gX/wAie8UlVNLmkuNIsp5W3SSwRu7YxklQSatmuiMuZJo4atN05uD3Tt9wClpKBVEBS0UUgCkpaSgBT0pjZxTqSgCsbY3FzFGB8zMAKqTT3E+o3WJCU3kAn24rYtiI52nP/LGNpPyHH61k2ifIWPU1k0pVNei/M0u4UtHu/wAizbJsXrk1a7VFGuBUvatTMqXcAlTFQxrKIkiLYQdfer5GaaYwaYrEKoOgFTKgFKFxSuyohZj0oBIjnnS2hMj9BVaHVIZ5VRVYKR94+vpTJ7W61GCadVxbwjLEnp/9esyNZPNjtohwzDb9axc+qexvGnpZrc6TFFG1k+VhhhwR70VqmYtW0CiiigAooooASignFNLhSMDc56ConO2i3NIU+bV7CthVy/fovrSEbV3P949F9KUjyfmkIaU9B2WqzOWb1JrGMXN3f9enkbzmqa5Vv/W/mTB8981IDUUaY5apR1rotbQ5W23di0UUUAFFFFABRS0lICejtSHpRQUFJ2paTpTAM0tJmjFABRig0CgAo60UmaAF70UUlAhaKKTNACM20biMgcmqMZzNAcfey351auTi2kPcjaPqeKgKhbyIDoFxWb+I1Wkf69C5UM7bUwoy54UGpjwCT0HU1Xkb+MjkjAHoKqWvuomPurmZStt0E80Url3ViWb1qV2LkqO/LH+lMuCj6pLADtchn3erYyBU9vGCoPbr9azo6l4jR2XXchMRjKyAcDt7VfjuEjidnbEUi4Y+hHQ011yuKSJQF2EDHpWso3MozcbEw6A0xztG70OafTXGVIp2voTe2qBCChx2JqI/LMTjqM/l/wDWzS25ypB60TfLh/7pzUbxNNFPy/zJuopM02M5QD04p1WnczatoFIaU9KSgCGRcimCWNINrD5k6ehH/wBapm5Fc74okuLfTGmtz8ynkexrOtfkbjujbCuPtYqezOS1m6H29vLkDq7FgQeRz3r0LR5Hk0m1Mrln8sZY9TXlcIkur9IgNz/xegr1HSwY7aND2FY4XDxpRdt3udWY4+eKmrvRbI0aytbinn+wxW04t5nndUlKbthMMvOMjOK1ao6h/wAful/9fTf+iZK6ZuyTXdfmjnwn8R/4Zf8ApLMl/Cz/ANmWlrDeRQS2vyxSR25xjcj8qX5bfGrZz+FMXwk0dmkEd6gbynhlYwnDoyxpgAOCMLEnc9PwrpzTa7Vja6+157Lr8jn5mYNp4R0+2RkZ7l0WVZIcXMqGLbEsfUNycKeeODjoKgt/D8OiaaiyXwFpb+TNcO8ZLs8IUAhix2qdi/LzgZAIFdLmvO/iTrJmtZtDtXbf5e+XYeS3VV+nc/hWVXH1oxd5N3/Q1pRlUkoo4LxTqWqaz4ja63OkM7AQhTwir0z+tavhbUI7rxVp9uMBRcKUOMbsc5/GuZtbl7TT9szvm4JYKeqL3/M1HYPKdSW4twyiFg5deNnOAfzxXlUpe/zM9GtBOnyo+idF/wCQBp3/AF6xf+gir9cd4Q8UQ3dvDpdziO4iURwnoJAOAPrXYZrtpfw4+iOHGq2JqX/mf5i9KWk7UVRzC0UUUwFpKKXNIBDSUtIaACVtmm3Ld3Kxj8Tk/wAqr26bYwMU++OLS2j7u7SH+Q/rSxjCis6erb8/yLq/Zj2X56kgGBS0lLWpAlFFFIAPAyKYLcTNHubAYfOfTmnbWkcRrjcxwMnip1ltYB5Ay5U4dweGPfHtXLiZtWSOzCQTvzbFe+mRoVtLRtttydhPJPqayvKKFJl4MZ3A+9ad+YmljZSAqJtLDjPNVt3nsu0YjTp706MbonEStKxYgkaVdzEljySamzUKAAcDFSg8V0nKFAopryLEhdzhRQA9VZ2CqMsegpjAoSH4IODntUdncPIxuFbA6KB296hW4kleWM5cjkt6CuSVVufu7I74UIqn7yu2QzPJHcy3LSsYo04QD8yas2twDapKEZZXGTvHK0pdY4jEo6/eJ71GqmQ8dPWtIQ5leW35+phUq8rtHf8AL0Fyzt61KiBOTyaVVCjApwHrW5zh1p1GKWkAUUUUDCiiigAzQvzEhQSR1x2prMFUknAFYuu67d6Z9igsFyJvmeULkdawrVvZpWV2zpw9BVW7uyR0WaSlpK2MANGDRRTEJSmkpaBgaTpRRQIXNIaWkoGLSUUZoEFFFJ1oAhuDult4vUmRvoOB+ppJF/0uL3XP601CHvriTtHiMH6df1NVdMv11W+na3KiGAbPMJ4yK56lWNNKUurOyhQnXcox6L9UXd5kLf8APNTj6mkZgiPM/IUcD1PYU75WVQn3e2KqXTmSQRL0Q/ma06WW7Oe9nqtEMlUtqMc56lUcnHsM1oRps3J/dJFQFfljB6hNv5E1MhzIevIB5+lEdLfcE9bv5/eSYoAxS0VoZBSGloNAFZG2TlfWppBuUiqtySk8Tds4NWuq0o6XRUtUmRWxOCp61PUKjayn3I/r/Wps0o7BPe4GkoNIasgQ1marZ/bLV4j0YYrU7Ux1yKAOQ0rQE04k7cnPWumtk2rmnGHLZqRRimSSA8VRv/8Aj90v/r6b/wBEyVdqjf8A/H5pf/X03/omSs6m3zX5o68J/Ef+GX/pLLxpKCeeKQ+lWcxna7rEOh6RPfTMo2DCBj95j0FeB3X2qbxHJfXMkjoSZ2lz94en4nium+JGsvr13Ja2Mokt7B9rRqfvt3b+g+lcs872dpBZvuHljcx/2uw/DOK4a8+eVlsj1cLS9nDme7Kd7eNdOXYYYnn+gq1b+Zap9ikjWOQyBnY9cYGAfYdarWiyiT7f5SPFDIu4P0LHOBjv0rW0qzF8bqeZxJcEqsUe8BpJXbAPuByT+FVSjd3fQdWXRHU3GmXdxBDd20ShILcPKEYZjwpYE47sAW/Kur8KeMBehLDUXAuekcp6Sex9/wCdcVbX93o/n2oZVgvI1M/l7C7RnnG7nBx2rS8R2GmsF1LRZFNqURpUBx5bsThf97gnHbGa3oO0Ip7NbizCCnXm+qb/ADPVhTq4Dw343jjgFrrEhGwfu7jBO4ejY7+9as/j7R49wh+0TMBkbY8An05rZo8vld7HV0VT03UrbVbJLq1kDI3Ud1PofQ1cpCCiijPFABTWNKaEXzJkT+8wFDdlcEruyIbzLXqR9o41X8cZP86kUVWV/Pu5Zv77FvwzVoVFNWgi6jvJtC0ZooqyBaVI3lcIiksxwAKFRncKqksTgAd6vAJaRSLvAwP30o7f7K+9Z1J8q8zWlT53rsUr6S0sxFDIWb5iZJF/i/2R7ViC+lkvJJcbYjxjHQdqlv531G5UKu2NBtRR0Ap626om0D61MKXWe7HUr6qMNkV2Ju5Aqn5Ack+tX4owqhR0psUCxDCjrVhVGK1ilFWRjKTk+ZjscUtFFMAHWs3UQz3JiLfKozirsz7UJFZV2jzyLKpJBGKznujalaz7i2V75MxgyNjjBY9qsi6ZmdIsCAEAvjGaoi2UfvJOEXr70ecbsKiAqgPCis3SUpXNfbuETTUee5bouanAAGFFQW6lUANWQMVulZWORvmd2AFLRQaACnKo2mR22Rr1Y0mEjjM0rbYx+bH0FMZshJ7lcL/yxtx39zWU6nSJ0U6XWX9f8AkzuUOEKq33QaSkeUq4Ep3zv/AvRBS06croirFRkFFAorQzILqMy27oDjcCK5ZNZgsrY6bqUDSeWx8tweceldeRkVn3Ok2t1IJJIlZvUis6lNTVmaU6sqbvE1hQetFJWhIvFJQaKBBRmgUUAFFFFABQTRRQACiik6mgApC6xq0jfdQFj+FLVTUHP2MxjrKyxj8Tk/oKUtiofEJZqRYjf96TLN9TXnd7qF5ok1zbWzGOKRyTz94A16URtjwOwrhNX0pr2PzQCXQZwO9RUpKpHkZth8RLDzVRdzY8MasJNOkQsWYDKE9s1t2kPV2/CvPvC9y0d+bVFOwtls9vavS48eWAPSssLTnThyz3X5GuZV6Vau50lZPX5vcjc/Nj0/r/AJNPjzlT9V/r/Ws3WdTTS0jcjc0jBQvr7/59aw7zxXcWmoNFG0UsWAecAg1NWuoS5bN210Lw+DdeHO5KN9NdNjtD0oqjpWoLqemxXSgAtkMM5wQcGr1dSfMk0cEouMnF9BKCaDSVRJBcIGAJGQGBqXaU+XIOO47jsaSQZBFRxuApDMAFIGT6Hp+v9KiT5XzPYuCc1yrfoLI4QAEgfOCB9eP8KmzxXPeMtTtLKyisS5NxPgjaeUH94ntUnhbU3v8ATmSUs0kJwGbqy9j/ADrCjX55tW06HXicJ7KlGV9eqN38KQ0uaO1dRwCUnSg0HmgBDSdKXvSGmAZqhfn/AEzS/wDr6b/0TJV6qF//AMfml/8AXy3/AKJkrOpt81+aOnCfxH/hl/6Sy8a5jxr4gTRdJ8pJhHdXeY42P8I7t/T8a6OaaOCF5ZWCRxqWZj0AHU14H4xvbjxTqv2+3l3w7vKSP/nkuf8AJNTWqckdN2LDUvaTu9kZdrBdaZcT3s6g4BWM5++x749uvNVJZHu5UjRfmY4A9SasXF28Z8kMXSNPLVm7+p/Gm2Sz2irqEbR/MzRKGGSOOWA9s9fWuKKZ6kmi1bxGW5ttKmlihijmKPKo4yTgsT3xWlfSW0GsK+nRND5BXO5lbMi9WG3IwcdATRo2n202myu8a3F1NMIIYhJtdCVYhuw5IA56896m8P6VNfa1FB5ZBjYvIpQEgLyRtPU9sd67YJR+RxSbl8zZs5LPUNMvIrwvJqKBUtsYBKjKqq8cnLDOT0HHSoNZkS2SDSIGVo7XJmZekkx+8fcDhR9Per0L2ltpKayIlgvELWkKLkh5AAfOGf7qnkDjdiubPPI5+tGHV4p+Rvjn+/qLzf5jwz9zkAYA9KP3sjhY1eRyQFVepPpQiNI6oilmY4CqMkn0q9pDpHqCpIwj3cBm4wa3mm1ZOxxp21tcu6VqWoeGrvzfJaPB2zQMcpIMA9fUAiu01LxdDcaVby6ZLKsr3Uccn7hvlBJyucYzgdAcmuS1Cxi1LUv7Mt0hku5J0PmBQTyigDPp94/8B96567nksNb8pZUee0v1SNyoHyqT1x2z1rJUZNcvP0vttrbv879tTvdCg+WTg72T+JdUn/Ke2HWbQNtKXmT0H2KbJ/8AHKP7Xtv+eV7/AOAM3/xFcHb6p9v+IFpdNFazTCFEaJfnKlmALI3sMvkds1seELwXGpPG0YN1HbkXjohQiXKkh8k72yWweMYYV0Rw03T5+bont5ev4nJOOHjo4y8/eX/yJ18E0dzbxzxNujkUOjYxkEZBpJLhbbLnIJVgmAT8xBxVTRT/AMSDTv8Ar1i/9BFWpBkGueP7yF2c9aKo1pQjtFtfiQ2q7Vq2OKghXaMVOKswQtKqlmAAJJ4AFAyTjGTVviyUgMPtGPmbtEP8aic+VGtOnzvyHootVZQ4WQD97L2jHoPesa9uzdsIYQVhQ/Kvr7n3ou7szYhiBEYP4k+poiiEa5/iqacHfmkOrV05IbBFEIlGOtShRj3pVXvTxitjFIaBTsUUtIApDS0lAyOUZWs6CVreVoHUbGJIY9q1GGageFSeRmk4qSswUpRd4leTFyuxBiPufWnxQJEMKKmVMcAVIq4pqy0E7t3Yiin5rJ8SXlxp/h+6urWTy5k2bWwDjLgHg8dDXPSa/ex6VdXxe/jNvceS0UzwRsVKK4bmLg4YfLzRFSnJxgr2tfVLe6W7XY7aeDcqCrymkm2le97pRb2T/mR3GacxSCLzpshT91R1c+1eV6R8QLy9vGicX0jyMFtoomgG5yeAzGLHTnpXSweK5bfTZr+5SS71IXv2SOG5dIxCQq7txAC8NvGcDpSlSrOSgobvl3W+vn5PXbTc2jglGLnzp210v3S6pd9jq2LK6TXKb52/1FsOij1NNd2hlbLCW9f7zdoh6Vjtr/2OwW5kgd7uWJprmSJ1lECDqdwOCMEHjJ/KteGIRL6k8knvWf1eS1mtP8v0/MwqVeXRb/1+I6CEIHJJLbSxJ6k1YZVUtjPCgj8aiX77D1RqkJySfWJTUyk1KxMIpwuxgoo7UVsc4UUZopAS4pKXNJQUFFJRTELRRQKACkFLSdqAFpKWk7UAFFGaKBCHoapXH7y/to+yBpD/ACH9auGqkeH1G4fsgCD8Bz+tJ7pFLSLZPMcRO3+yf5Vmw24MecdavXbYt398D9adCgEQFNbsUvhSMqHSYIrozpGFcnnFbKDCgelIEA5p3QU2SlY5XxnA7xWkysFCOVJJxjI/+sa4cAtMWTcwTnnggdq9R1W2+1WjwsoYEdCMiuRsfCypKxuJHZSfuDgVnKld3RtGu4x5X0N/wpIx0xFOMZJ46V0YNZ2nW6QRBEXaq8ACtAGrtbQyvfUUikNKaO1ADSMiud8WCZNBuZIWKugDZH1rojVLUIVntZYmXKspUj1FKUVKLi+pdKo6c4zW6dzx/UXmnlE887XDsAruw7j+n+Fdn4Dklf7Q7fdO1RxgcZyf1rHh0G4urlrEwGOFHyZWPb29673TNPhsoEhgTaij86xo0XB3Z04nFKorI1e1FIOlFdBxC5pp6UZpDQAUUnPSgcdaBAaz9Q/4/NM/6+W/9EyVfNZmrTR28unzzOEjjuHZmPYCGSoq/D81+aOnCfxH/hl/6Szn/iPeSw6LFZxt5aXbMrvnHQAgfTJ/SvG7aO40q0uPNUCaYhV56KOp/Gt3WPE//CTareRSO0cbufs4J+UADA49a5d7mR49kj7yvyhs56cVx1ZKcro78PTdOFmSQQvqN7HAhClzjceij1NaFi0VzqNml9IqWkRVGYIcBAeeBySefzqtBHNZW28SKGuoypXHzBc/pnB/Kugs9Nhn8PL5CW819IzsFWQ+aoXB+73GN3GMnII6HGlKNveZNV3fKijfG0fVZ308OtqZCYQwwyjsK7zQ9IntNOu4bvBa8Rd6Bz5m/ccAkE8cElv4SCCOx4nSZEtr6G4lj8yNG+ZR1I6HHv6e9dvqEhezgktZ4Zrq9haKGRFMQWLcTJIwIAVmPynBIOGx1ArapfSJlTtrJnMalfm8+zxhSsVvCsSJ79WP4nP6elUwMnArSjstPmwv9qKk7DpJCwQHjgt+fOOw9agXTpxqi6fKBHM7rHzgjnoc9CMHOe4ohNQoXXb9DqqUva49xls5W/Ev+G5dPtNRFxqSJIibdqSZxycE8A8gZIHcj6VTv5pdS1G4uDGC0jFjhQv5gYGf61va3Ypb6XZ6TYKJZhLekl5BGQsc7KHZ88napGPf2Fcps86KH58sYi7YHJIHAHuct+ArpjRl7S8pJr3unZvz8n/Vx1aNJ0eaCaaa3ae6fkuxtaLqKaOlxPHMY78qI7YhFdVLH5jnnB2g4rBtpIWUic8SXeCT2GfmP5Uy4uJm04IiNJdSAMgjGNrA5PHrgEfnWfY3BvGkRhiVcKh3dQPvE1ySwU5Rc27JNr8X+GhvOdpJeUf/AElHSafcG11uC5W5aELGfLkjBOWGSB9DwPxrv/A+q299NqxZljuri8ebySeQvA/HFeXJMxuLbbkLD8v1b/61W9Nv7rSNSElq481JGlJIyADxj6c1xUJOM0uhhiaSnBvqe06J/wAgHTv+vWL/ANBFXCAaxPCurWuo6RBBC3762iSOSNuoIGNw9RxW6RXo0v4cfRHm41NYmon/ADP8xoAFOFGKTpVnKLuYEMjMjA5DKeRVOed3Pl9ADng5z7mrTVEIscmk4pu7HzNKyI4ogvJHNWAvOTSBcmpMcVRKQUUUUigFKKbXJaDp/wBsitbVtO0tpGsVm3mzDmPlQu/kbi43HtgqetS+a/u276v/AID/AK8zqw+HhUhKc5NWaWivvfzXY6+iuOglNjLFeQ21irzLLFA1vb+Urq00MaMwycjLFuvQjpXQWd+xivftrxK1lKUlkUFUI2K+7BJx8rDuehrSNObUm+jtp8v80LE0FS5eR3TV9rdWu77GhRXKN4lvvMlV4UtwJnC/6PJM4QRRyKGRSDkiQ5PRcAd810llO91YW1xIgR5YldkDbgpIBIz3+tbVcPOlFSl1OdqxPxSGlpDXOIwfGP8AyK15/wAAyP8Aga15Fqmq3XiLU7lmcQxzSiQxA8D5VX88KK9a8Yk/8Izdjt8n/oa14/runSaRq0kJyFzlD6iuZVZ068pR3tH82/0PZg19QpX/AJ6n/pNMZdzR2s0b6c5ikjcNuXjDAYBH5132jW95q2gyxwGzuXkvEvWmuYyd8jx5kU+2X4+hz1rzeys5tRuFjjQ7ScAdzXtfhKxFhZ3FqBxFKq/j5UdaYevVgoJ9HfbXZ9fm/vFUrR5KnJvy/wDt0SO10K/tNLsrBUtJoEZ5bhDK0YclywQfK3yDP44A6ZFdRSCiumrWlVd5eb+88hu4KQJR7qw/SnjkL7wD+dRrzOg9c/yp6fdi94WH61x1PiOqj8H9eQlLSDpRW5yhS0lLQBJRRR060ihKKKKYgoozSUALRUE93DbDMrgH+6OT+Vc9qHi+yt7n7MbqK3c8fOckfXsPxqlFsai3sdRRWbptyDEyyyD72VZm65rSpNWdhNWYhozQTSUhACNwz93qfpVSwG6FpD1kYt+dSXfmfZ3EWNxGPwNPgTy4EX0FFtbjv7tiG758tPVs/wCfzqygwoqpIHa7+YgqPugf1q4OlCVtwk7vQWkpaSmSRyLkVX8jLdKtnmjFMTQ1FCjGKkFJilpDAUUUUAIaY6hhzT6SgCqLcbs4xU6LgU6jvTFYUUZpM0UhgaQ0c0maBBmkpabTAOled/EzxDBawx6aoDypieUA9FPygfkxP5V22r6pBo2l3F/cECOFCcf3j2FeCXV/F4kku57hhHeSElnPddwP9K5MXU5Y8q62PTyulzVbvaz/ABTKUsNpaSfabd96TjKL/cHf/D86q2Nmb2SQbxHHGruzkdAMn/6341avII1cf6REi4woIbgD8KW3iaO1eJLuPy5SGcYbnHTtXNB32v8Acz0J0ZLdr/wKP+ZpaOsOo65HJqc0KRYyTL8qcDAHGOPYYzjHU1Pdaf8A8TNVsVEkNy262ER3EqTgLjqD2wf161FcwWUcUEdqwPy7mmdjucn/AGRkLg5GOvv0rf8ACNqYL37WInkkZZEt5IsfJIFJLDcRkgdsjOeCCK6/aKKvr9zORYWcna6/8Cj/AJmzB4bso9Jga88hWMLESxOdwXJLtIh5VkwR6E4XrWVqN405WGNCjXWxfLj58qBceXFwev8AEQR1APer9xeqtsIprTyIn2z3CKw2bPvKFBPHmON5XjjGOBmsm1kLXEk+o2sjxXO0NMqMzxKHXJQtwTgFRn1rN1bRctb+jOijhOatCErNNq/vR2v6l5L3RLu1Wxm0YW8nlBY7u1kLTPLgDJUnBBPYdM1Tiu5bO5sZZo2M9jNtbzBxhSG2FcDJB3Zyc4x0xUV3b6dZkTXESpcJdQvsC+bbSp5MbEE7gdxYgsMgfMRkVS1Gcvp9v5sUMSXFw9w0UQZEQHIX5TwFOMjHau2nldSdGP7x2dvs91fvq/I6a2NwtPEyqRo3abd+Z9zY1G7ttU1O8uZrTNtcymZcJ80a5YjHODksdx989aq6gbe6t/OZGDM7OGdcrNkt8xOeCMY49DWMJWOnxh3jZY3/AHccgz1J2/h160SSAwxxO4ESxfulbnjJzsH8BYjP4itY5RWUlJVmmm1t+O/oL+0MK6bh7HR2+0+l/wDMutYXU1q9zGj+WvyvKEJUHB2/N2PHHoAaxZtLbyt8d5EkkbjBzgc8kZHQjGR1713+m6/badohtJ/M+xyzb5QjrlsopdcZB5KgZ6AMcZ6HlpbOW682+WONI5JvLKjiMk5IQe4A49MCvFjVq3cXJrfoddSOGfLOFJPRfb8l5lK3KRWsUNxeQGVDuJ80HdnkZz14Iq1axs93lpEYO4aYRnJ8vjAA9Cf6VSubGynCSHIeBwuQDlwOisMcEdMjgjtkVsaZE0FjJdRRRvKZFZpD90DIATHGRxnB9B6Gs3GUHzcz+4SdCat7Jf8Agxf5ltL9rS9hu7AvBKiIDyCCwGD07HGfxNd9p/jiC7jVP7OvZbkLl0t4g4Hv1zivNP3gn2kZTGST71LbXE9hNHcW8rJNGchgcEf/AFq1w86jik5W+Rz454OVWUlRvq/tPuepf8JN/wBQTWv/AAE/+vWhp2pJqUMki29xAY5PLaO4TYwOAemfRhWf4b8Swa3D5cm2K9QfPHnhvdav2H/H5qn/AF9L/wCiY67EqkZK8rp+XkeRVeHnTmoUuVpXvzN9UuvqXaTBJp1FdB5gvWkNLRSABzQaKD0oGITisHQtJa30GJI9SvAL21R3IKAgsg6MFzwOBknArdYZU1l6Rqlrb6JZW13DfRzQwojYspSOFAIPy1jUqyhJO9rr/I9HBwlOjNRTbvHb0kJqVnDPqNlaMCiC0kUeXwVKvCVI+hAx9Ksw6XDFFJHI73CzFmmEwVhKxwMsMY4CgADAx2qv9rTUNct5IYJ1hit5QWkgeMZLR45YD0P5Vqr0qsPUmoy10v8AoiMddOnFqzS2/wC3pGOnhqxguZbmyL2U0jElrdUXClUUqAVIx8in1zk55rUtreO0tYbaFdsUKLGgznCgYFS55xSV0zrTmrSdzhuFB6UUVkBma1p39qaXNZeb5Xmbfn27sYYHpkelcp4o8NXWqwrI8kEksfI8uIoT7ZLGu8K5phjFZulCTu9/V/11OiGLrQpqlG3Km3qk9XZPdeS+44nw/wCFZ9PRZFkgWQ9pIC5H5MK6zTrWW1Fw00qSSTS+YSiFAPlVcYJP931qyse05qQU1Tinf9WKWKqSi4u1n2il59EOoNFJmqMAT/j4i+v9KfEflg/3JBUaf8fMP++BT0BCW2f78grCpudVD4fn+qEHSlFNB4FOFbHKwooFFMZIaKM0ZoGHWiop5fJheTaW2jOBXGeI/F7acoj+UyMpfZv2Kq+rHr+HemlpcuEHN2Rv+IL6OKw8iO58u4kmiVQjEN/rFyPlIPTPQiuHvvE8WmS3Ud1c3MsiNtjW2uJ1JIHzFt0hwM8fUGsmbX7fXbew1GOPyJ9Puw0q5yNrKcEe2Vrlr2znu9duoN5CwyMskj9euBn3PFLnoxbdRX26ebuepS9pToQVOTV3LZ26ROqi1mYeIYp0uzNb/YZJduXI3gNgHcSc5HrjgcVx7fbdcmYmQKoYEnH3mP4/rXRaZos1lpUdwMTs13HtER5Kbcsp7j3rorPwxp9jI5i3yxNn/WAAnPIyRgHHNaScHTl7FbtdNNlfptv2Lqzv7N1Xd2/9ukS+H7m6Twlp0s2RIoAy3dQx2k/gK9Gt5xLGCDzivPZ7d7Kxt7ZWcxpGFQN3CjArrdGuvPhRv7yDj0pVre1utuh5VTW9jbpO9IDQetSYAee1L2pPrS96AG7RuzTqB70UAHtRRRQAc0DrRRQAtJSig0DCk6mlpD1oEFBopKADvRRSZoAKKSj3oAKbQaDTEBpKD1rn/GXiFPDegS3IYfaJBsgX/aPf8KTaSuyoxcnZHB/EXxVbXOrrop+e0iyJmB/jP+FcK9iljFMkUocsclv9nsP61JLBaamyair7WDfvozyWb/69UrmRvMfLE5OTXmyk5y5me1CCpwUUSWRhkuTJdENHEpfy2/5aHsv59fbNX7ewuBpv2zYvkbtuQwz9dvXGeM9M1BHZ/aJ4LSzj86Xby0YJMjHk/gOn4E1rTanePpcGkyKI47ZiCuCCTnofoc/15rqoxa1Rz1ZJ7lOJNzDsK9QS7sYPD0Yt8f2fGjMWWQiRogfuOD0ZnZl47FiOM15vEmAK6aXTrhrFtJtQm+2X7TfMzBQZT8qx59VBwB/eLVrVina5nTk43sUtTvHkKpIwd5SLi4KMMMzDIXIP3VXAAPKksK7b+03u/DMMWmX00dkJ4lgZpfmsZN6kRzesYxuVv9nmuWj1CC01FxqNr9psL+CIuMkyKu0AMjsAdykEehwRz1qa50aPSdL1G7i1e1uLK5hEdv5coDzfOjYZOq4CnOehFY14p02vI6cC2sRB+a/MZqOo65qVzJp+u3UksVg7STKwHykcfeVeMkhQemWFY5ne5uJpdsYY/OQUXG3PIxjHA9MUt2ptLZLMg+e5EkwYcqcfKvIyOCScEg5HpUOz5ERQC7n72M7VHU/p+ldFklocqbctSyQIwWZflC/dPHB659Mnj6A1U3p5IXy1DDjcM5P1/DjtSSl97xuGBVyCCMc+/vUfWrjFbinN3sKfmXBrqdMubCy8KTvLMtzdeU1raWXk52yScvIR0PAAHcYH48tU9vH5hwRkd8fX/Gs61KM7N9CqFRxdl1Czto7m4PmN5cgAD4Jy+Ocd+T/Or80k677SSJYlilY7F656c4/H6ZNTAf2dHbz20MUjB8vN1AJGQPqMf49Kp5JJJJJPJJ7muCtPmlbojvpQ5VfuIZFLY3Lu6Yzz+VIelVBbOL3zeNuc5qS9uPItywBLnhQO5rE1uJb3rpfEwOUkhIZZFOCDXpvhDxDHqT3UdyyR38sgk2DowCKvy/8AfOce9ecCSO0sbSxe0SOeJXnvpXPzkttKgfQY4PfNMErxMksbMkituRl4KmuyjNS5V2f6M5Z0rxqPvH/26J7rmg1yvhbxamqqtlekR3wHyt0Ew9R7+1dUeldh4zVnZi5pPpR0o70hBR1o70UAJSFc06g0ANAxThRxRQAtJ3oozQMWko7UUABFJjinUmaQCCilpOtACmmml60jcCgDlPGXiKbw4LS5jabHzkLEUBLApg5ZWwOW6D0rkpviHrcCW8xlZoD+8VAYg2WHr5Xb6flV74qsWtLTngbzj8VrjJ7WN7GF5WJ8uAbAF5zjrUxlhkm6yu031lquVWWjtv8Aqe7h5ONCHKlt2i/tPuux6NZeNZY4Li4kge5s4TFJLPJIqSRpIAANqoA3zbvStvxT4nh8M2CztB9omdsLCH25GeSTg4HI7Vx/hTw+2taJLuvBFazNFHcQ+VuMgQBhhs8ck9jXVa34Rh16xkFxP5eoOix/aY94UKHDY8vfgjjuevNehhPqVqbqvS75t9tN/wAb26W6nn4xRVba2kdtN4o0NN1n7fNCjQrGLmA3EGJdzFAQDuGBtPzLxz354rVrH0zQ10+6Nw0iSSLGYkZYtjEEgkucnex2rk8dPetgVz1/Z8/7rb+u5yO3Qf1oopKxAbIu+J19VIrxLxZYPqHjCWGfzBD9nEqBO+Bjr2Gc5Ne2scDPYVxk7w3sruIUIZWRWZctsJyR9DgUpwlODjF2Zvh5KMtdjjU8OpBpGpPZ27RefEIlt/N8xs5U9foeuByTWsbOyuZ4rmSC4S5Kq0+yFyJHCgEkY9q6RLYhlR1bzHXIDdW9KngQDUGhVSTkEYP3SByD7cmsoUHGKTd36f8ABPQVeDSjKL0bejtvbyfYwgiM1qsMUoVHLYMLqFXawzkjHXA/GttgtlJHIgDAhgCDnI7fjzS2qtJY3EJLFkOVXb0pJWWXToSQAYztHy9fXvW8E43T6mdacZ8vKrJK29+rfZdylqpMscUpRFQKPuDA9/50nhi7QzzwoxPlsOoxg9CPzH61Z1KWO4tNsQwm4jnscZ6fj+lYGlyeR4k4wFuYtwH+0OD/AOg/rVtXhfscVVe96no6HIyKf1qrBJuQVZB4qTnHCik7UtABS96SlpAFHvRR2oAKKKKAFopKM0AFHaikoAWkoooAKQ0dqM0AJQaO1JQAhNJSk8U0nmmIGZVUsxAUDJJ7CvDvFfiC18V67PaM5WGM+XayZ4yO/wCJruviN4oj0XTksUO6e6++AeRH3/OvJWsraGX7bBIHilGYx3U9/wAq48RU+wj0cHSsudleaL7Fbpbo4OxiWYfxNTbXySs80212C7Y4z3Y/xfh1+uKg5aZUDgZONzdBnuavi3Sa7MVpGWRRhSo5fA5b8cE+1Z04XZ01JWRp6PJdaHJFqD2jmOdGWMsSobpnB9OxHcEjvSzGCacSQeb8ygyCQgkP3we479utaAvLTUbJIH8q2mLJHl9zAfKAZM4wBhVUDtljzVO2tZZLhbeJfMldwihDnc2cDB712wWt3uckn0WxqaMi2iS6tKoK2pAhUjh5z90fRcFj9AO9a2l6D4l1XR3+y6cWglZnW4dhGz7uG5JG8HA68ccVNoenW+teKNP0RCJNPstzykdJmHLt9CQFH+yBXZ6z4h8Qme7bQbW1TTNO3pNcTYwzIAWUDPA5wPXHWsqlR3st/M1pwVrvbyPMp7drRv7M1iCW0miJKSFPmQEHgj+JScc54AOM5qHy7G1YyRXn2iZSCiiHCnAB+Yv1HLDp2yeDXd+N3i8Q+BtL8RrEEnDCOQDsDkEfQMOPrXmqAlgB1wf5VV+ejJvTR3Lw65MVTW+qt95LGGnnaR+5JOBj64H+e1Ty3DwgCORo2zx5bEdOp/oPpQmIofQnofT/AD1/KqbvvYtjA6AegrZLmfkczfIvMfJKZTk9epPcn1NMxSCl96u1jK99xVAbjoa07ONRNHEY2cucbV6k9h+uPxNU7aPJ3Htzz/n/ADitUXstlDbPbxOUYOfMfosmMZHuAQR+JrmxFTlWh1Yend6kFxdz3CrFMm0xs2RnJLE8kn14A/CoO1NHrS15p6IE1W0/Ure11+O/uoTLa2WWQdmmx8v1AOCfpTdQuTb2x2AtK/yoo6k0XcsE+n6ZpUSFYLANc3jHGXmPB5/AAfSgTM64ll2s87Mbi9l8+YntuOQP1rVUg46ZxwDWWb+UyAiNCZxgsV5++eP5da14pQ1gbhrUyeacQv5nOQybvlA5PzAdf4vau+jhcRyxnGKs79V2f9W3NHCilNSk78q6d3F9/wDIt2+nahJG18tmxt05Eiv+8AH8QGcj16V1emfEKK2sRFqys9wjKiSJgeaD3Pof51g6Rq1uZUSTesJ53i9ZW28fwjHZgTz0z6GuP1e6a6nZrJE+zKzMFZQ5Az7jggEV0vAY2Dso367nnxhhqr99tW/ur/5I+hbS8t7+2S4tpFkiboR/I+hqbrxXnvwseRrO+82QuymMcYC/xHjHHQAfhXoRNTFTStNWaODFUo0arhGV1ZP70n+oD3ozRS8UznAUGjNFAB2ooo96Bhmik5o70ALS+1JRQAUlLRSAKKTmloAKY3Sn000Aea/FDAtrXccD5x/6DXm11rcy2qxBEKhQvvivavFfh5NdhjDsymIkgdjnH+FcBrPg6LS9Olu2COqD7uDyfzrkq05czdvy7I9ajVpOlCPOk0ra37t9E+51Hw91W1tvBrXl1MsMQmIy3qFUY9+ldzYX9vqNnHd2sm+CQZVsYzXjPhLUIbnQNS02WNE2L5karng55HJ967L4eXphS50iV8mM+bF/unr+tGHqtvkZOPoxf7yDvsvuSR3tLTQacK6zzB2aCeKQmkJ4oGNY8VyVugt7lxj/AFUpAX6H/CurY8VzV6PL1S5XoH2yD8Rj+lXHsXSfvE8+FmhLZ2rggk5yM880kwZb6Fjn+75jL978B9adNJ9og27GwiDLnoO2BUNy6LDA4YbgBtVT0Hf8c/zqYnYyeNIxezA4AdSVwSePQGkhQ/Y7iM8BScZP5cfhTbqXFzFMpZUb5S5HbFQwzyyXreUhdpCNu/2707Nq4rpOwkgtmsFYI5l9QMAHpye9clfyfZL61ucf6ifBwf4WIzXZ2Mvlwyo7BUDYPy/Nz256DiuQ8QwZWZUyQw+U/SrWqlExrbKR6BZv+7AzV9TXO6BdNcaZbSn7zRqT9cc/rW/G2azTurnK1Z2JxRSDpSimAtGaTvS0gCl7UlFABS0neloAKDQKCcUAJRRQKACk6+ooNHbmgAoopKAENIaU0nWgBCarX15Bp1lNd3D7YoVLMas968w+Ivia1e9TQGc+VjM7KejdgfpUVJ8kbmlGk6k1E4nWr2PxhdXF2ZPKulYkBjxs7fkKyborGqLGSEUbVHt6/jU66X9iM6ecrO/3T6J/9eqsUKy3qQzSiOPPzOewHJx7+leetXc9mySsiS3SAWTu215pG2qO8ajkt9T0H41taSEsZAt5EyW93GFMy5LLGWG4rjqSAV/E1RtbWW5mmuLezYwRHzHRQSqLnoT6VuanfRX1ojq7FmlPlwsf+PdABwAAF+YnsOiiuynGysck5XdyrcRLIy3SPBtmLHy4xgxHP3SPpjB7/nWtYL/Zuly6ieJ5SYLTHBBx87/gDtHu3tWdptjJfXcdtGQpc8s3RFAyWPsACfwrufCekWvibXZLm4T/AIk+mxqkUT8BgM43fX5mb3Nazkox1IhFyehV+Gcht/FkLNG/lzQvEr7TtzwRz/wGtCaXXdJ1TWNFsdHF2L67dmleJnWRHU4H90Y3A5/Ot7/hZulx34tLawnezDrEs6EKmScDC9h/h0q14t8cT+F9QWzGmrOJIhJHIZio6kEEY7EetcspTlP4dzojGEYfFsYPjGBPD3w80zQGkV7h3DPj2yzH6biBXFLoLR6WL8XVs7GJZXt9x8xY2bap5GCMnnB4q291d+KtWm1PVpJBa26qbh4V/wBTGWwAgPuc4781t+KZ7GDTIbOKSO6kY7kka3MR2E5Lxsp24Y9QejEkAcgVUcoU3BbtamuEUZ4iE3smrfecTcOcAf3hkH1Gev4n+Qqtj3I56itALahFLpGJDyWkmPPp8ijIFSx4IzDE7D1htgB/30+TXUppKxxOm273KMMKu+PmKduQCfxPAqaaKRET5EEDHCuNrZPfDDrjvU0xLkCWREAIyZZ/NbHptHQVVitWN3+6BnO4LFsUjzHPTANS5NlqCS1NGxikjYTRIWaM/KAMkv2A/L/x33qKe9kvUgBTy1jTATOeTySfcmrctyNNme3hifeYSnnFuAx4Yjt6rx9azVHpXnVp88jtpQ5YjsUhOBUoXA5rN1S4aCHZEC0sp2IB15rJM0ehLpOqQWmrXGq3EbOtlGwteMqZyOCfpyfwFYs5az09bdiTPOfNl9iei1taq9nJJp9lbKRZaVb7pmIwZZWOWz/wLj6CsaO+kuBdRmNGFw6l3I+YbcnCnt1/QVdOPM7mdSXKtTV061fVtUtl8uIPKgjSPGFABPfPBAGc9Oua17UxaVrG8zyJawhfIYQEO4RldR833GO1DuxwcZGM1PothC1m0sb7jMfs7MqlfLi+Xe3Q4J3Kv4sRmtC7ltbvxAul3YW1haVZJ3lmVtmY1DJv7FSrbSO/HQnPbDF1UoxT0V1sv73l5vXfU2nH4315I/8AthzEmjRx6VFdx3duZJ3KRIRtZWXB+ZQ3HTng56jOaw9JsJ/t8i3GYVjOXJGQfw7jgVJ4jgkW+V7RjJZrIRFInXrwanu5pUtYrYtunkxvI6k1v/amKlO/Pp6L/I4pRUYW6s9M+HrRO2pyRzrL5nls2wYAPzjGPwH513Aryf4fx3Fpr0UKyArtkEu08Nxx+uK9XB4pU5uonJ93+Zw4+PLWX+GP/pKHcUUUVZyC0UUUhiAUtFFABRR9aSgBaKKO1ABRSUe1AC0UUhpAFI3pS5pDQBE6ZFc14p0032jzxDrtyMV1BHFV7mISIQfSqEfPej3P9k+JInkXMTNtkQ9x3Fdq1xFonjeG5tZVa34DhWzhG7Vka54aln8YQ2EACvdSgQljgbj0yfrXc+DfBVrayadqV+pnacS2N0kq8W9wrfKw/IfnXnSXJUPXhNVKNu526nKg06k2NEzRt95DtNLmu48rbRi00mlNNzVCGE1ga2Nl5by4++pQ/hyP61vHmsnXI82aSAcxyA/geP61cdyouzRDC3mWioTlcH5Seh7cVnbQxPXAq/p8yrvDFl+XouB+tVnQw5A9enWiOjaO2WqTHSJvsPNDZIYbhzwOg9qsTAC5tZZFEZYAFY89O386ridfsMkZOCTgALyfx9OKdKHNjBKAoXO35eufUmiz6gOkidtSkKAiRRvA6kke1ZHiCBYz8oIwASCc4JHStZbYwXEUjydX+c5wRVfxAjPaIHVdwU7mQfKec04v3kiKivBlTwhc7rBounlSMuD6dR/OuxiPFeeeFJvK1S7gJ4ZVkH4cH+YrvoG461mla6OOWruXQeKdUamn5piFFO7U2lFIYopaSjrQAveik60dKAF+tBpBQRQAdqKO9JQAtIaWm96AFpKT86SgQEUhpc0hFAGP4l1yLw9oc9/IRvA2xKf4mPSvCb+1i1a4XVVuCUkbM4c/MG/+vXf/ABSglvrq3tDKVQRb4x23ZIOfyFeWlGt0W0DfvM5kwf4uw/CuLESblY9XBwShzdWWrqUwztIvzL0IPQe1XdO0tdSRI0kgWdyHeViSF3cJHgA8k5J9PwNS6fb2t3ZrbzW7NfRTFypfAlXb8sYHqT+lXrKO/wDDcsklt5MwGIpxjcFkwT3GQRyAfZhWdLV6HRUslqGmulnnTbofZmFxvmm53bQrKU74zkgEf3uaha3O4y+Xs3HcYwpATJ4Az1rf1j7HfwxXlvZCZ5pB5RjkzLOTkuGAPBB9s+nFaUSTeKtU/sbT7aSC0tgnlLPH80aqCSTg/wC3+PHrXR7blktPUx9jeLu/QyYYmsdFO3Aub9erMF8uAH1P99h+S+9df4PR5Ph34jitgTc/PkL1I2D+m6uU8QafLpusRW15eCeVoA0jQvuKADAU5A7DH0Na3gXxI3h66kWWGaW1lUCVYhkxDPynHcjPPfn2qptzhePqEYKMrMiPlT6TpHhvSHWea8kW5vJEH/LQ8Kn0UZJrV+K0qHWNPt1O54rYlvXluP5V0D+LPBekLJf6bDC95KDhYLcozHuCSBgZ6/yrkdGF94n8TzazKYjNDIkixMhZWYnCJgcheMbug49amDbfO1ZK/wB7FJJLkTu3+SE0qwu9OsY2iZorhwZlY58qbCEtBKh6MF3EcYIPuDWFqdzb3eoSNZQGCzz+6hyflX8ScEnn8faum8TanPFp0MK314LiZn8xJyyzJDgfu5em4Bt2D3Ga4/GBznJ5OOw/z+pod5QlN9mdGHssRTiu6/MkWbYpzIyD1RFJP4np+dRtNDIQDHJMc8edKWH5D/GoJiSQOg9P6Vc0nTpdRvI4IiA8jbRkdu5/AV0StGPNI4YuUpcsSBrmSJigjjiI7LGP5nNS21zOjNdsWlWNTgMSxBI6ge3r7VpeIxYSaoun2EG1bRFgadRxuH97H6ntg1D9ujtraazgEm7aI1ZiMKp5fH1P6VzTxEXTulqzphQkqlm9EQXt2byZXCGONECRoTnaB/UnJ/GoBxQKCOlcJ1ji/wAuT2qrpd/aw/2pq06F5Iojb2SlcqXYYZvqAePrUGozNiK1jP724cIMc4B71Prj2Q1VEsMHTdLgWJSOk0nXcfcnn8BRboDfUxbiQ2NlBYn55CRJMD/E3938BWvotl/bGqSB1SJp2LEKMCNepZf90Dkdx05rHhuTcQyQtEmZJxI0+3LjAxge3JPvXWrbjTtIeW2wLi6QZ2NnbCDy698MwA9Rgg9a66cbLzOWcrvyN2wuLbSUv9RltU8n5I7dEnwXUKNodeQQysDkjggjiua1VvtNnNcK0j6lM5dWO0KykA8qOjc+uPatdLq11u58o28NvajF1OqDbg7FEjJjODuUnGOc+wNcLrck8Gr24s2kKDiJj3+Y8n6jFYSdkuju/u1PQaT5+q5I/wDtgmgyXCrcGckQJ1Vv71WrJZ5rs6isqxiKTAzyeQeR9P8ACl1CV3EdsgXzpCN20dTWppOnu80VpM6vDb7mkKdNueefc4H5VrFWVjzpSu+Y63wRbNazO0i4eSJZFHdVJbj9Aa9AU5FcloiN/aE8jDBaKNsDsCz/AOFdVFXVRXLG3m/zODGy5qyl/dj/AOkonB4pRTR0pRzWxyi/1paTpSBlYkA5IOD7UgHUlFHegANFFFAC0UlLSGFJR2opgFFFJSAXFIKMjFJmgBcUxlzTgwYZDAj1BzRQBg6xo8V4Fl24mjO5HHUEciukth9rScxjY2pWouAF6faIz82Pc4/SqzqGBqXTpjBbPtGXsphcIPVDw4/z61nWV0mbYeVpNPqTXD+eIrr/AJ7IGb/e6H9aizVuaFI2uoE+6rCeL3R//r1Topu8QrRtK/cDTTTqaTWpiMPrVLUozLYToOpQkfUcirjVFJyCPWqQHP2B3uMBGV0OQ/T1/pSzMHZyJA/OcqMCqsYKGSEZDRsVGPQcVotbPbaa6lDvLqXJHbngfpTdkzujrEr29rLNBLJ0RBn6n0q/cLB/Z4kjBC7lZR2B7io7XUoEMYkhI2KVyp4IPtSreQf2YLcsVbB3cdRngfrUy5m9ily2EueLQMSOF4755H+FZ9zdS3UPlStkZJ/TFRmR2UKWJUdBnpWVqM92LyKK3kWNeCWYZ3EngVrCFjOUrmbp8n2PxTAD0ctEfxHH64r0iBvlFeZa5m2uo7kDDIyyfiCDXotnKJIkZTwwyPpUT0mcbWnoainipgarRnipwakkeKcKaDTqChcUUUUgCg0UUAFFFJQAAZ60cUUUABpKUmkNABSGignigQ0801jTvxqC4uIrW3luJ3CRRqWZj2Apgeb/ABWuEgm08KR5zo4IB5C5HP8AOvMtHS1k16Nb9ZHtgzF1jbDHg9DXR+MLufVnbU5FZSZMqpIOE6AYznp7etZItrb7TZ3Nor5EG6fecguc9PbFefiZXdj18JBxiFpaSyzFWkO6TkE+3I5ruNB1m0v1XStVRE81lijGz5ewJLAjDAqpz3xjvWJo4dYJbZ9hhkgMu7ALDbzjPYetR2luXvHV04DjZuUEMT6Z4Nc0JXlZ/wBaHZKNo3RaY/2Vqu2ylha7jlAFzBuOG9VOeceuOcV2Pg7U/wCyLPVdbvbmKa6EW5oi5M33urZ45JUY69K4ifUYrgRxwmaFkbckhcABh04UAD61es721axeK4s5JNU37fNdtyOuckuD0IGQPXI9OfQnT5o2OWEuVl+SF9UjnupmtpGmIma4iPWRsEoxPRVyMjqPxrLEFwFmjIQJt+d5JNqnvkc/NnsOanjuY2mcxzedHMSssIGGYcFmUHADYXAPccV2uj6Po7eE5fEOqq8kaJi3SRiGEIOFHXqx5/EelYKpKj7sldGvJGpqtDzoW7iB585KSIrgn+8MfnXZ+G7rSrbQpLuQS22oWBO6a3OWlRyAAyHhhyQc47Vy0dncGz+3YFvZzNIqPIN2Oc4yR1I4z3wRVUPcRR8NgMMHB69+fxx+ldbSqK1zm+B8zRbu5mnupJpVZdxyEZidoJ+VeSTj/CqpnQFSBvU8nnHyj3x3NLKi7opPOLpt8xwEK4bpjnqeOtV4mMckLrgEA9QCODnv9aVT+HL0NsL/ALzC/dfmOcqx3LuAPQN1q/pOrz6XM0tuUWYqUV2XdgEdP5H61nkMBlgepGfXmgKWYAdSa2qQVSHLI4oTcJ3iakAGmWq3M7shufk+R95kVj8zemcgj8O1R3tz9rvHmCbE4VF/uqOAPypyXduumPaxfNKZNrsRwqjnA+p6/SqwryJWvoerHYUnJpGcAEngAUE1VmH2y8tdMSRY2upAjOx4Rc8k1IxbSa0/sTVdUkO+9kItbGPumerj9B+NZNzKtmbW0KiXymDyr/fbqQfbHFa2qyWqa1dSWK40yxAhtkPQvjlvxOTWPFKl3BHH9nAmWVpHnJ5cHAA+g5/OtKUeZmVSXKjZ8P6ZFqVxJ5rLAhYySMvHkoOS2D1XHHqDj1q/dX039pyGVGiiBAijU5MKgYXZ2Py49mqhaRrGQwufJmAyp2nH0J6DPvW9otlb63KbeZSBEm8xocMvIHynB+TJyc/dwT0ruso77HMm5baP8zA1smHTXntJF859ylIRhVTAJYd8HP3T0qhpk7HSYnnUMiKSrN1B3EfyAp3idZtC13yVkLhI1ZTkEMrfMPwKkdOKiuXe4W0tbdFUzAEIOmTXB8Uk2+r/AFPTqaRmkrNwj/7YOsI5nuDf7lCqSoJGTnHUfT19SK7jQrLbAkO3Es2JJf8AZX+Ff6/iK57SbRpDAk4Uw26kvsHDAHp9Se/0r0DRbVwjTy8ySHcTXbRjd3fQ8PFVOWPIupfsI9uq3A7C3i/9CkraXisq241m59fs8P8A6FJWoDW1P4fm/wA2Y4r+Iv8ADH/0lE6mnAtk5A29veowcVIzA+WR024/HJzTe6MktGLVaEsl5co33W2yKfqMEfpUzttRmHYVBZyedGsxIJKAZ9f85pN6pDivdbLVJRniiqIF6UtJ0ooAWkpaSgYUUUgoAWkPrR2oNADT3rhfFF9aWUWrN5Vob93JiknjRiirDGeNw5OTgD3z2Ndy1eW/EfVXtrG9sISfNuLsFsddgij/AK4pc1OFSE6seZJ7fJndgJTj7Rwdny9NPtRMAXt5o99JNFHDdW+FldZYUkQqScDJB2jj+Gusv/E2jy6dBc6GttYaknmyENCqtGFifjOMNkkAep9cV5pp2uqoWK+jMiDjOSCPr6/jXovhSx0y8vIvNjdLe9Zo/OdiIypilDLxz1I5Gcd6xpV8PCVO9O6TV9F5deuuuve2x6nNVnf33tLq/wCVnZm7uRrNl5d351ndO4BUJ5WAjEKpHzF8rnJOMBu9bNs62+owu/8AqpMxSf7rcf4H8KhbRre1vvtPk/vSS6nzGZCSMFlGcZPqBnk+tPnj8yNlPcV1Vp06iXKuh8+/dlfqjSTMawGTrbSNZzf7jfdP+fSqroY5XRuqnFWYmF6Y9541CAxOfSZOh/MfrUUrGaOKdh8zrh/Z14P8q5KbtKzOmqk43XQhJphp5phOK6EchGajfpUhqNqYjmr0eTqMpHGSHH5f/WrXgvluY2QXAUsPuSDIz9azdZUJdRSf3lK/l/8ArqmjbRmrcFNHXSm0h5UrkA5+lUr3UrayTM0gB/ujkmmajexx28kXniKV1O09xWQ0mkaQd8rm8uz1yd3P9K2S7ib7GoNWthapO7bAwztPWsW98SszYt0Ax0YjmsfUb9r+7eYoEz0Udqp7qTklsTqzVine+huFmYu+NwLenevQPC9z9p0K0Yn5lTYT7qcf0FeY6dNsvkz9xjtb6Hiu58FSlIbu0Y8xTZH0Yf4isam6Zk1udxEasrVOI1aQ8VJmiYdKcKYKcKBju1HtSUtIYUnvS96KAE70UUUAHbmgUUZoASijvRQAhpCK5+x1a8vFtFN1DFNcoGVG02YLnbuIDlwpx696nS9upLxrRNSszMCRj7DIFJHUBvMwSM8gHNJKo1fke1/l33OueEjCThKpG6/xf/ImxXC+NtWMt1Bolt8zMQ0voT/Cp/Qn8K0tS8QyadbTyvf2rNGWQD7DIFkcdVDl9pIOeM9j6V5rPezPqH21/M+1B/MbflTk+vHSnKNXld4P8P8AMqnhoX5nUjZf4v8A5Em1XQUi3eSZJXUfvJGP3j347Csuzja1vExjEaqWVhnK59O9b95r8iacVER3upyBCRj1O7cf5VkRSRysAwAl24BznePrXnYnl0UYtfd/mejhKLV3UqK//b3/AMiWNWhZbsNGA24hmEYwBvGcY7DmqunrO2tJAql4IZI3X1ZwRtQfVsD2ANQ3E7Wlq10UkLBgu0sOR+VdBpfh3VLnSW1G1CbLGZpwrSgNJIMM2OPmC9Occg/WuaneyuvyOydODelRf+Tf5G34i0W60u3VPKsV3oZA9nAdsi7grIVPO4Fhz3B9q5BXkWGSJJHiDfu3Gcbf9lvb0Nd5Hruo629ks0y2ckkWY0tIsSBGkVVHMigB2YHqOFB74rlvECiGYXDTpK24x+c5T9+ABneUdgSMkdT0GTngdtGtK/I4u/pf8jOWA54c8Jx69bba9Uiro2iXuqtPDBEwYAq7lgoU4JC8kcsRiul1XUDrraJ4WsovIiQqtzHGdwGDzyCcjqep7Vz0GsS6dAYEkH2dmEirJ2YYAIPqvGD9R3NamhrFoKjWbySS3kkT/RHUIQdoJORuB5AxjHOR7ZucXN3s9dtH/kYwozirXXn70f8AM6f4g6rbW8VtoFigTy0UzoOgUH5E/rXC3mnX0C5mt/LAIO5jhiCM9PTv+Ip5u4LrUJNQvBBOpkE8kJkC+blh8g9sHA+hqrcLPcaNc6jdrILSQyx24ikGEbHCAbs7QPQEYXHfjXDYWfMot8t5W2Vtr7vr5eaNKjpunF8qd1fr3a6Ndh9pZHUbqDT4Ay3LHBeRvlI6ggdvp6morjTbmyuEtLyGSKfcQY8ZfB9B3rXs9Nj+zvcSQLbXT2wkshuO9pgWA288MSY247YrO8ax3MWu3UUrCRAH2vEAoIGR0H+0Gz7gitoUHUjFOVuZb9Nltrrv5a6EKmqeKSitpfqNQOC0M0LLLjMkJGC3H319G9R3/lJZxWtvdxPdTqYHPylOSw69Ox7VRe2mi1OOO6ZkkaNmjcPv2tlTgN3A/rWlcvaSWluIwkk5Jd5APu9sD+ZrHFS9nFJP4l+tv0OalSTlzPoVpnEtxJMqLGHYsEUYApmajuHKIu08k80sZLKCa8067iuyohdjhVGSajhtIz4ck1QSqNSvpjDafN/q4lHzEj36U6G0/tjWLXSFkCLKd8z5+5GOWP5VWQRS6rcvbjFjBIYrQdyB3Prxms6kmoNrojqwVONXE06ctpSSfzdiD7RZ29xawTeXPFCS0sZLYkcj1UYxnFWNJ0xAUkuGX7Kg8yVo2GRGDg9cDPQD1OKpaZBNd363drYSzpbOJp4oELYTdnOPTtXT2Wm6pJZpdfZJGka6W+nbyS+IgcqNg7cuxHptNfSf2ZSp2tVa1W9vu9fw9dzilXhLemv/ACb/AOSMvMAWWVwnzdHz91fb36VWuLuOCEyx3Cq/IUjJGfwBq20UuoXczrDIsT3TSvFbwFjGp6AZ6+w68c1gTXkcsstn8rqHwjlQrHnPNaSy6Fre03dui0+7p18jNVYuV/ZrT/F/8kSauRqFil7JLvnRFQkZwVBIHUD0q3YxOqxXYRdnksgZuqkN1Hvz+tMu7aKLTVtMM4DgfK2Cc5Poa3NMtfOdS0axRQqGK43AnsMcck8n/wCtXzcVKLtZ7vt2PUr+xnB1IySvBfzaWkl2faxs6NprgxQMMFsSyj37D8B/Ou5t4gigAYrD0yxvQpl86APIdx3Qlv8A2cVrJDqQHF1a/wDgM3/xyvTi3FW5X+H+Z8vOnTnJydWP/k3/AMiSQj/idXX/AF7w/wDoUlaSc1n2lrPHdTXFxNHI8iIgEcZQAKWPdj/erRWqpp8uq7/mTipRdT3HdWir69IpPez3CeaO3t5JpW2xxqXY4zgAZNUo9Xtv3ihLo4bn/Q5eDgf7P0p2snGh3/8A17Sf+gmvNp9Vuo/EF9a29xdrFG8hZ3vZRuKkAZweMAY+nXpWtHDVcRNxptaJP7/n5f1ut6EMOqPtK17ttaNdEu68z0z+1rYjHl3n/gFN/wDE1hP4pTT7lbZbOVoA2WmZHTap5PBXPFchHqmpf2LJcm6vFLzAKDeynClwuMk8dx+tLLqN4ukagsk1ywjm8vZ9qkkGPk45PP3j1FaYjL8XThKcbPldvy8/P/gnZg6OAqVY0pcy5mlutLu3b+ux632pRXB6TqN5qrTfvzcEXUkhCXckCY8qM7VbAOAS3GOOCeuT2djOl1p9tcRBxHLErqHOWAIBGc96vEYWVDSX9f16HjNWLWKSij3rlAM0UdTSUALQaSl7UAJRn3opM0AI3SvNvF3hu41e8vLq3bLxS7fLPQjyozXpJ5zVC40mxuZGlms7eSRurtEpJ/HFROLla3Q6MPUjDmU7pNW0V+qfddj52v8ATJIZWR42jlXqpFev+FbU6ZoGiIk/2+z8/wAyW1YlHhkMUmeOo4ydw4OOlad/4UsLsYWBYuc5iGz+VPttGTTLiK5skSOaL7sgUZH41zyoSb2X3/8AAOyni6FO/vNuzWy6pr+Z9zqLa4EFsXgzd6d/FG/34f8AD6jg1K9ukkH2i1k82Dv/AHk9mH9azbadbiYSWzLZ6gOqdI5fp6E+nQ1NE7NdlrX/AELUV4e3bhJfYZ/kapXizmaU1/X4ElsX+z3MCHEkTC6hPuMBv/ZTV6ULK0xjH7udVu4x6Z4cfniq1ncwXWpQ/ILW+Rtsts5wJFPDbc98HOPap4v9HWSKTrYzHPvC/DfkeamT1uioR92z22Kh6Uw04nimmutHEMIqI1KelMIpiMLxIVh08XLAkQuCceh4rgL3xFPOSIh5afrXp9/bJeWctu/3ZFKmvGLqJ7e4lhkGGjYqfqK1g9DSDbfKNvLya6lMkjfNgAewqsM7Cc801n3HFMXJB7ChsuxMqsyFvSliA5DUgmBXOABjBxVdrgKzd6hs0SsWlIR+OorrPCl3jWcZ4uIP/HlOf8a4Jpyx64+ldB4blkt7yzuJAUjWcBS3G4NwceoqZtcpLV9j2KFsiriHIqhb52jJ56VfTpQciJ19adTF5pw7UFDhS4pKKQxaTOaKKAEpaSl70AJRxSKyuvyMGA4JBzRQAUd6KSmIxNAgleC1u5l2rHZxQ24yDwUVnb8Tgf8AAPeoo7K8iuoUNqzR213cXYlV1/ehxJhAM5z+8xzgfL1rS0U40LTv+vWP/wBBFW3cRoznt0HqadPEuFJXXRL8Lfq/vOzExc8XOK/mf5nCanpU0t6D5L+fFdS3IeSYmBgclQEB4b7uTgZ+bk5rmvEtw02tySSLMk7xqZhPIJGZ8k8HJ+UDaB+PTNdpc3QknaRN3Xkt3pus6JDrNhHMuI5toKvjJx/dNcscydWb5rbW6979/wCuh6lbBVKVFaWTKfg2K1h0bUryKNri9iTy/J25+QjJ59GIA+gPrXnzaTqdtZz6o1sZIHmZQoBDg4LMwAH3Vxz6V9BeEPD8ekaKsbR4lmAaUHqPQfhVDXfC8cj7GkMWnzgxzlePLjJ3Ptx3bAB9q4KlW82+hpCnaCj2Pn+1kfU4rmR8vsQwxRLyXdhy2PQDJ/KvTPDHiazg0uTTZwYbicMJIWVt2SvzbDjADAd8YJPWuLj0lE1CWHThNBbzTY818kxRZ4BI745IrX8PaYt9q8aR3T+bZjzN6LufcDgBV/iGSP1rrVKPKc/PLm0Oq1nwpHFptlrMNwrXVzLEJ43IMeXIwqjHRcAYOeBmuJ1Lc1zGpeUJDPcbGWLcTukZgce/Hb0rovEfieeXR4tKu7W6truJdyxyKFSIg5yoxk9MDJOASK59OIoj5hkJ53k53cGphiJUE01fb9V+p6FOCnCNv7//AKSitcxNILd542PyEOqDPzHHH6EUPcXh0W30yZyyxv8AKCPuEjnDenbHrVmWby9oAyW4AAySfzqnLeM7hVRj/DwMHPcfln8q3p4mpKMYqGzX53XyV35aeREMNFe/KaV1Le/ZrsQNFLBMZIjJGWdPKdVIUkY/ixwc/wAhXTDTLfUNU0yxi0+68+3Cm8iikV/MxgZVcgZbgde9Zi2l2dK/tIW7SWsnynGCODtwQTkckc+pplvcahot1BqMEF0XlTcBMgCvGeATz37emARV141K2qTTjo9Y72t+nUVOUIwjGTi1/wBv92+i8z1W3W20zwtHZ6pZPFqenr5iRqeJCcA4b+IkYUjpyBivLr7Urm81NoL20SOdiEcSg7gB0XJ5GAK3dX8VXmuxW/8AaJLxW4+ZYzsd2CfKcEnO0sSTkZGPSqlzFC8dm0sqS3e8LDdAHbL83JZurAcD25FedGXs4NNbo0Sc8XFvdyT082mYyzWmmybbuRzbbz+6IwytjBB9OeDUEIQR/uwAvYDsKxNemN1fmaVuXBYAdOtN0zUjBiKU5iP3W9KurdzbZx02krG+2DwRmo5JVgiaRjhVGadkHBHIPSm22nHX9UGneZ5VvGhmuZf7iCsrmhFcWUunaNZ34bOpaq5CR90g7H2Jx+VVlkiTUoLOMsY4VO3B6uRyT7daab5pIpL+bjywYLVM8BRxkfhUFgsMl/FLDvOE+ct3bHOPapnG9KbfZ/kdWXytjqCX88fzRueELaSC8+0b3SGGMtcbTjzEPHl/8CJC/jXbanfPpNrNbx3Nul5eFTLGCxdXdiDkkAAAbcEYI2jqK5W9jGnafBpo4mcCe5+pHyJ+AOfq3tWgmj3mt6Pc6nLch5LWPbgryyoAfmb1wQB649q9GUV8T2PIhJ/CtzM8WWbeEJIT5zSGePhWG1sZwQwBP1/KuditLGWddSgwFIJZD/C1Ldz2/iAyQSyt9oiOImds7gO1Qyp9ktktIhlsc47mue7nO76Gj9yNo9S5ZN9qlkkkB2KVYZHB4PFdnotjJJMYJV+4+9z7kAgfhzWBpUatLGNmBCqkIeRkdvfk5Nd74ettoui4y/nAE/8AAFP9a1pJud30f/toYmSVDlXWH/uQ2bePaoGOBVgDjFCrinqMmu08EcgqTHFIBTj0pDM/Wj/xJL/P/PvJ/wCgmvLtP0fUta1y+XT4oVEkjeZIYhgBj93Ga9N11j/Y17/17v8A+gmszw1dw6TosLFMTSszMPfcetJYqphnN03q0vzZ6FGClRgnspS/KJBceAdTOki3We2O1VwNpOcEEfyrhLiO90+8n067ghjYtvOyMDH3T8voPlFeh2HxCbUNYu7OKJfJt2CeZz8zdxj65Fcv4ouLfVfEFzd27g+Tbqsi4+64fH9axeYYmVCrCTuuVv52PTwFOmsfh+X+eH/pSO9tNJt2jnN5HBdPPN577oRsDbQvCnOOFHf1rXVcDA6VWgOUFWQeK6Z1JT+JnzydxaOlGKKgAoo7UlAw5FHejNFAhDQaM0tAxOopuKdikFAhNoNIUB4Ip9FAFOezSUHsexqM3I2Lb6orPGOI7lB88f19RV+mtGrjBAINJpS3HGTjsVrwJJbxxat++tmH7jUYeSo7bsdR+oqYXk9ksUep+ZLamPYmoxPvZl/28D5l6epHvVVYbnT2drPbLA/MtpKfkf6f3T7ipbOSONZJrCXFoGBvLC5HMQJ5YAcj/eHBrCcOXf8Ar/I6oT5tv6/zRcNN7U6m10HKMPFMNSGmH3piIHry7x1YfZtZE6jCXC7v+BDg/wBK9SauT8cWQutF80D5oHDZ9jwaqLsOO6PKWyCQO3eoWkPTNXLpolj2xc4zk1mzJLFCk8kTrE5wrEcH6etRKoktTqVN30HNLjjNLJDcJam5aJxF2YjG76etXoIGQL9jt4pXK5NzOwZV/wB1f8c0y4S6MTqRPcSmQF5WU89gB7VyTxKvZM66WEnNXjFv0RV+2w2ygW0AebHzSzAEA/7K9PxOfwq1piX+o3pMST3NwBuO0FiAO/sKvWXheCYywTXvmXgid1ithvRCozh3PGe2Bnk10ujzGAWUsUiwacsMUojjcRiSXAznu7ZDdc9e1S6ltdwdFyXK9Du9IuRd2MM6niSNX/MVrxniuY8MSxGzeGGVZI4ZpIkZTwVDZX9DXSxniuyDvE8qatJonX61IKjXmpBVCQ6iijrSGBopKWgQUhmhgjmnnUtFDE0rAHG7GAF/EkUpFU7t4CrW10/l292jQNJjiMkZVj7ZA/Os61/ZvlN8OourFS2MfR/F76/ez2M0MS4VjbSQxbNhUZ2j1HBGDW/FKJY0kX7rgEfjWHstvC9kJ5Z7GWeFDHbx20u8sxGN7cfKACeOck1qaWWbTbfeNrbBkHtxWOGTV7O6N8ZK/LdWev3dC3SUp+tIcV1nCZ+jsF0GwJOALWMk/wDARUDXUV7EtxbyLLbyRnYynIz3/Gsi4nnudC0rRbQkXN3aoZGX/lnCFG5j+HH51iaRfJoGvvpF55trY3H/AB7+Y4ZUlDcnI/hIwM+v0rz6sv3cYrsj2lT/ANoq1H/M1+JKdQgiWRLiZUkiJDhjg/X8a6XQH3aPHczqQgYuFPU88Cn3miabdXSyT2cbSpgAkA81cdQJI4EH7uLk+hb/AOtXBClyNtPc9fEYz29OMLWsdlYXMV1bh4z1HI9DVh40kQq65B4rkrK7lt5xJGMDoV7EV1VtcJcxh0P1HpV2scqZ534y8OXun2dxJpAAgnJM8e3OcqVz+Rrz6O3utO0+DUYVEMUUg2SAAOecBxz83IIIxx+NfRUkazRlHUFSOQa8x8V+EG0+6+3WcKy2j5EsLDIQEglkHZuK0pVXT06Ezp8+vU4HUL+81e4ae6EdzOeA7nAjGeg/2T09ulQiyOn2ySrMjxBsSQxnJjODg+4xuJ+nvVme2Fs5PysrkNHlM4Oc444VsdR+NN+0XUNxDPs2MCdu4YUjHPAA4retyz1Xl+ZthE+RK6uufql9ld2UryMTfZzGqSsW/dqejkjAH61GumyQPDbho5ZRKMMD8hzkYz75P4CpI5fs19JKIgEYZjiHSItnJH4dsdDXQ6fazTtZTLFHcrLceQkQl3NnacnAXI67s/7JzThialGFuifZ/P8AN/1YudFTULtW5X1XeVuvextaF4Y1i6M1rcRraQ28ZiYb8hmeUtIVx6D7o9QK6jxN4b/tO0kNvZ2W1LTy0kkdleDaThkwCOM9Pl6dSDW5pumx6Xp8NnGpIT77E8sx6ms/xPqElrBa6VZjN9fuFx/djB+Yn+VYrG1VU9ot7t/eY+zXLY8d1SyFvrV1E9zJujKtGJAWZuMhc9iBgfhVWW4aK2aM7ZBLwytnIA5JQ/w5JINb+u3CS+KtSMLgRu4G9NufujPJ6AVgyoILkOs8TSkgRhDuEYBzk9uuK3sp0G2u/wCoJtYyFn/J+SOd1e2iubmGKyDtLgAIf4h/iO/51hl0WUqhDAdR611ksos5lvoSkrqxDxsCDgjHP1BPIrA1TTkYfbrLJhY/ih/ut7+/erqwvqcEJ20J7LUjbx7WO+PHyn0rWe3vNKgt4ll/f6zF5ku08xx54B/nXK20m1kkZdy5G9PWugnvt9vJfthZbgeXGn/PNB1xXI1rY6U9LkF09rOJoDIyiGMJbIo+82Rkn2xk1qaTprizmn4CwqpJPckgAfXkn6A1n2emebfyfZi88a4w+3rxzj2zmuiNvdwWTRyZSHcHKkgc4wOOvStqkEsPP0f5GmWybzGhp9uP5orySyXNy9xO26WRy7E9yabdX8ml2yRXRmhhveSASNy+uPStlvD8y6Q2opcQSxKNzIjchR1auQ1aFvEG2+S6eZ1+RwxyQBwK2xFRcvLE4KMHzXZFFpUen3T3IcPHjMbZ65qSxk3yzzFW3kbVPbB6/n0/OopysaQ2gY7VwpI5+tdBp8AnuwyL+5twFjBHU/w/4ms4RtoE5rWb2Rs6FYAXcEbAFgrSO3qxK/yziuy01cXF8B/z3H/otKytNtfJvbZT94wyk/8AfSVs6cMXOoDH/LwP/RSVulyyt5/+2mMpOdJyf8n/ALkNECpFXHNNUVKBXQeYKBgUnFOpMUAZWuDOjX2O0D/+gmueaSC3ufIlZUK52q3GQT2rr7mBLiCSGQbo5FKsM4yCMGsW68PWc5O9Zm/3p5G/maynByb/AK7+R2Uq1JU1GbaabeiT3S812MGwtbXTpp5Wkj/fPu6ior3ToIdL1W+iTBuHViT3G9a24/C9grcQsD/syP8A41f/ALAsZIDFMszxt1RrmQg/hurCWHmqcoJLVNb9/kduFxuHpYqlXlKTUJJ/CujT/mNiMYXFTDpxUaDipBXYeQhc0UU0mkA7NZl74g0+xnMEkpaZfvJHglfrzTdc1ePRdKkumwZPuxKf4mPT8O9eXxabf31u+qeYC7vuVW+8/q30zWkVBK83ZFRhKb91Hr1neQX9stxbtujbgHoQfQ1NXnfhbXnsZEWQ7reUhZk/ut0z9RXohGDjNTNWlZbPYcotK4UUdqBUkBRQaMUDCilpM0AJS44oo7UAFV7iyhuGDsCJFBAdSVYDuMjsfSrFFAIU009ad2ppzQA00xhk08000xETj2rM1a3Fxp1xEQSGQjA61rMOKrSrwaBrRnk93YaXo91NbTPPPcpnc6xBhB7kH5cj05/CuR1C2u11O4S7maSSNyhkc/ewe3tXeeNL5LWaRBbq+3DbguWZSSGJOfXjn2rkbhG1BzeXBdWdQzFIiV4AGc56nA/OuCLcpPRu3ZX/ACPbWHnNJQt31aX52KdiJRcxIIyMOCSDj/61a7i6j028hSORrCU+WGTOyR153ZPXp2469KesputHit/IIt7KUO062+M8fdZh1J68+lWnsERRb3dtHm4dHIgAj+VsFQMZ2g9QT6104fEqhJtwk72fwvZO9/8Ag/8ADrsp4GpUoqClG6b3nFbpd35Fe0kRIUkQymf7ThnLspP3iFGMEcquee/aptJS7jsC29WKk2qRbGc53hhjaDkZJP4Nj0rotIso/wB/Yw2Fnc71ZJ/N+Zg2RuZXKY4LY4zjA56Etg1Gz0vWLyGS3s5kaOIAQSnYjou3hgpycEnGOPWlUxlPkcZ02tb2at38ut7fJfKqmDnOu3Tknq9pL/MxrB59PimSOW73eVK4UPJCVcSMu7AA3bQo4PHUdeK9hTmuEW60/UtUsxc2dhPNKH2FMkRgktgqVHzFskkkk5ruLc7kU+ortnjaeKgnTVrN/jr/AFoeFmGGnh6ijPrrun5dPQtLUq+lRLUgrE4kOpRSUopDCij8KSgBapahZx31q0EgJVvQ4q5SHmmI5W18LJDeiV5C6g5CsB17EnvXURoEXA6UuMUtABTTxSmmt0NAHl96NT0W503XLOVxi2iAPXaNg4+lbvh+w0vxc2teINYaFpIYHEdlF8nkKAMMOwH+Jp9zbyv4dsWjAb/RY9ykcMNo4rlINKupL4RaY8iwXR8qUDI2A8sp9q45U70ot9lqevLEWxVSH95/mbvw1TVVtrye9mDWbSn7MrDJLHqQeuOOld2IVXHr1NQWtrbwpDBAoSG3UIijpx3q+6kqSAOa4XudyRCisDwOe1SW93JZzCUMSCeV7EU056556VFIScK3QCkM622uo7qESRng9R6VM0SzoY5AChHOfSuOtL6WxnDA5Toy+tWvGfimPQvCcs8bYup12RKeoJ70vIZ5j4oubGHxBd2+n6g1tZ+ZiVVydz9NwHsKwdUgt4L7Ftei5BQb2UkqpBxwT1B6/jirPh5YJtD1vUJbmL7XHHt8iZdwlViASPcHB4rPgjVEiik+Yn53A68dBiuumml5Jr80RFpyfdqX/pLL2g6fJqWprECdoy8rZ5VQeSPzr1bwnYWUkMWo20UZggRobaTZh2AY5Y/XtXl9mjrdtDcTXVq0yssZhUK25yqlT7FcivcvDljb22g29lCdyWwMJ9QV45rHEylKcl0v+iNIRUaVPvbX/wACkWZZoYbaS7nYJFCpd2z2FeYajrMy2t94im+W8vcwWKH/AJZJ0z+A/U103i+9GpXsXh21fbCv72+kB4CjkKf5mvM/E+pLqF8sVu3+jwL5cS4yOOB+fT86xpxvL8y4pN2bto39yuZMcJuT5QkCDILyN3Hb8epptwoESxwDecYQf3vVj9ev4Uac5eFYZIneUyybnRUywU4CgsML6k+lF4ZUkWGzJMMq+YkhUBySq89OFw2R7H2r03SkrUpWacmnq+jd76eT8zaFOMavt6cneME9V/dVupAbi1kSJ7a0OBD5l1E78OvqO55z7cVUvw2mXp2xhLaQfvIZU27xuIwcD/ZPXuDViLTHutLW4ilVdsKBkbGW6AAenLfzq8bC91myuZi6CC0G57iRgNykSEKB3LMz9B1PtXoVKGCpVk3bl95PTtby9bW7rzOeni606Em97xtrLtLzMC206TVNTjt9Ma2Zrgny43RFO7OMZI69OuM1oad4V1LWHihs/LnkniaWIKkJOEIB3AnKjJwCcHPQV6P8N/A63mjXmoCZYBfiS1kRod7LESM+W24bTx1IbscV1kPgCLTNXhurS/kFtayPJb26xqGi3kll3fxKdx6jOAvPFYVI5dySt8VtNPW3Te9vKyfoOONr/wBOX/yR4RazS2lv5Ut06BkDqkceFOehxxkVfCRNaPKiMxDqrSMuwqTu+XbknnAP4fn1PibSjN4wt9I026YSRweVvJUeUAR8q4AOAAOuTxWFrGlXeiXs1pcTed5hWYyHq/BCn24zxXBmH1d4Zulo/RdvRf8AD99z18ixM546MJrTTrJ9V3kyDVby7hsbnQJhDayTEMFQDPHofQ8Vy+n2MmmiZ5Z1BPy8Bv8ACl12C+vddF75m9Jm3K47VJcyi4uYrd5NqkgM/XHvWSi5y5m/y/yPBnWhFcqpr/yb/wCSJrJYjHK4cSTOwUHacBevp1J/lXX6JavEVX7NLJs5baV5Y9epFY2nQia5afywqR4VFA43YwPyHNd9pNn5FuikfMeSa66NJ35nJ/h/kefisVBJQVNf+Tf/ACQJPMNStz/Z9xkQyjbujyfmTn73+c1p6ekoa7llheHzZgyq5UnGxF7EjqDTCv8AxOLX/r3m/wDQo60lxmtIQ99tvZ+XZeRniMQvYwjGCXNHz/nb6t9iRBxmpO1NUYqQYxWx5wlFOxSUANIzTGSpcUmM0AQ7OlOC1JtoAxQFgUYFOFJS0DA01mwOaU9awL3UheWN6nkXEaquFcDGef8APFTKXKjSEHN2vY4zxFqTeJdfSygdvs8Z8uMgZz/eb/PYV1h8iwu4rFxHcBICdqcBQR2+nFcjbXtj4f8AEO5ZFuLQqElcIQUz/EO/B6+ozXaaxYxWyx30LLtkjCb1UMrKecf7J/PIwRXPj53ceX4baHpYKlyxknvfU4C9lW11qRYlPlzfM/orf/qr0rw1eyX2iQSStudcoT64OB+leY6nOLzVHjhBOyTlvwAx/X8q9I8NWrWOkxQO2W5Y+xPOK6qWtCLktTixTSqtJm7RSZpaRzhRSUtABmijNJQMXHvRRSUALR1opOKAHGmmn/pTTQA33pp5px4HNIaYhjVBJ3FWWFQuKBM4TxHZl7m5QpHsniZDJKwVUBww5+qngetchb6deLbwoqpMjboASflDEdfwBr1S/wBLtdS2R3vmCBG3Fo2UYOMDOTjGa5+7tRfy3keix7IhPGFmztRVjjCcZ5LEsc8AZ2kda86fNCq7df8AJn0WFqc2GafRfP4onDStBBp0yW87tBeQp1zxKpXIwOvIPbuPStXTb9kka5uoZZbs+SFLEBfLRQrIwP8AsrxwcHBqkXhs2jaRNyvKRlhxk9/5/lSXIaGKCeNjiF8OCc5B6/5966frcoLlSW1vy8/JeRjGLlaQ21u7i1lSLzJolnhxtZsguuOn5dD6+1StHFY6oz226SAqJIjJjJVlB5xxnqPwrHvtftyPKSJi8MpKMenpxVu21LzrG1csv2lUIZT6BiRn8D+lceNq1MRFye56mVSp0sVDm21/FGrCzQmO9xhopgyj1HU/yr1ewYNEMHjt9O1eNXd2bg+Yu0DywNi9FOcV6j4Xu/tWk2rk8mIA/UcH+VPLW+Rxf9aGHFPs3XhKHVfqzohT+1MXpTq9M+XHA0tN70tAC9KKTPPSlpAJQelLSZFAw70UlFMQtNIyKWjHFAGPpsQfQLAEZ/0aP/0EUlnpcVjNNcoMSzDaPYetWdHH/Eg0/wD69o//AEEVoXNqk8CX1k5lhA2yL3Q1w1ZtUYx7pHrRpKWNqzfST/MhiUKgA7VbUZQrmoLURtHjPJqwMdq4j0CEqVywGRTCA4Aq03yqQOc0ohIdSBQMhsbISz7pCBEgLSE9ABXjvjbxEPEXiln3lbOI+XH6bR3r1Hx5qn9k6B/ZtuwS7vRmQjqqd68I1GXzbnCLgcKAKqGrJm7IuWhK29y0IPkrIoZs9c5x/I10WhtDDIuo3cYNvb3JD7EzJv2Mycf3cj9K5RH8p/JDfJEctg/efv8Al0rfW/lvbpriKT7PLMMSAnhvlI3fXBI/GuppulyruvzIoOKrcz7S/wDSWLLrE1/qcWp3AxN5gkYAcfeyBXdeJLbxQsx1jwndztZX+1p47fBMb4wcj+teeSIQArqgdAB8vRx2arkGv3trCLWKQgAYOJHQ49CVYZH1pVKEn8K/LsvMuFWm4x5ppO22vdvovM6m+lPh/wAOSW8sxk1Kfm5YtlgT0Un17n2HvXEWvmSOPvNgZ49hnPv3qa4uprzYHCIiglUXoCep56n3NW9HWR7+C2XZH5sgZZGUnYQGAPUcc5P074xUSpyp0n7rvp27+pph1TqV/wCIrWl/N/K/7pQkjt4YJpHBCIS2QxByeTyPrUNmst1HGX3K7gjIbGF9OPbireu6dMt+tuu1rfAmkaNQFIONnGTjPUg960dIgWO8s53gaZVuV3xHhXQLuIz7iiM6kYRnNv4r7+rOiMozrVIQ1Xs7fckjOayEbvCzeZGjAFkyFD7R8vPcA8inzXcRhW3jj8xonZiW4C8kgD8K3tdsGn0+71+xBlUK73ELkqsd1K+FCjuVUCn+Hfh/qGoaQt1JKkJfKkNy25TsP6qacajdS9R9H+hyOL+ryUF1j+Uj034f6vaahoc4tYTAkDgLEeqjaP65ra1S8XTbCa+kcgxKSF/vMeleUW95qPw91a0e5j3wPF5MuPuvgnB+uDS+NPiHDq6wWWlxN5WN7vIcDce34VitXoS3bVnG63qsz69Gwk2yoWkMi8EMTnrVjWtYu9RkhS8C+asKAufvOBuIb/x/+Vc5qaS+fEsZLzXDFdw6+5qzMrJqaIxJ2RFevThOKyxatRZ6/D0r4+Py/NGPps08Gkt5zfKT8gPardlCn2VZcJJNM/y+qYOAPxP8qpXspllWJRgDjAroNEstqiTH+r+Vfdz3/Cu6MdEkfNzna8mdDodgAyJjKxfeP95u5rs7dAAKzNJshbwKMc96241wBXfGKirI8eUnOTkys/Os23/XvN/6FHWkoqhIP+J3a/8AXvN/6FHWkBUQ+KXr+iOiv/Dpf4f/AG6Q4cU8Cm4p3arOYO1LikFLQMO9HSj6UUALSUUUAA60UDikNADGPFYmvM0lqyISCfStmQ1Qlt/NYlulNEs82uvDd0+J4iXmdsMhPUVTudTuF0qPS5XnjngkKDHePn5c9Rg8fTHpXoc8lot1HBJIYwjBncdsVw2rr/aevSPbJuDEYOOvvSjKFSpySWi1+Z1w5qdLnvZv8h3hyxElwGYEheck5JNenWAIiUVzuh6ObeNQV57muphTYoA7VpUld6HKrt3ZZHNLTV6U6sig70hoooAKDQKOlAxc0lGaSgBe1J70tFADzTaXrSUAJnnHNJ0p1NPHamIQ1GwFSU1ulAHO+JEAsfMxkxuCufU5H9a5eaEGC7WOeZIS4LBGxn5VP867jUrdbq2eJujd65SRoUtL2CNg1w8yqFIxhSi5JP1zXl49SU4yRvQlJRqNfyr/ANKicLqV59htHt503sx+VieAAcg4/GsEPd6i7GOWSSWWQAQqpJxjrgV3r6NH4i1CW3e58q0iCySnAzgZHBP1/WmwPpvh29jksYYri4WNozHHygJOcl+r9qqEXNXPQVX3U2Ylv4Rvi1lBehEhlYsxDAPHkcF2IwAeOPrVy6tNHtJvL0yJ5t0QVh1UNzkg9T29Kl1PUbrUCr6pdllX7sKdB+H9TUVvFd3h8u1i8mM9wPmP410Qp9kc1TEJdRgijACzJGgGNyRElmI7n0rvvCEjGEIseyJfur9aw9P8M+RNambJMshU5/3Gb+ldzYWiWwCIMYFXRpKDl6/oicbXnVjScv5f/bpGotOpqj5adW5xijrTu1QXF1b2kYkuZ4oUJ2hpHCgn0yahTV9MlkWOPUbR3YhVVZ1JJPQAZqXOKdmzaGHrTjzRi2u9mXKBRS0zEOtIc+lGaQ8UAFBHFFANMAopDxQT3oAo6Mf+JDpw/wCnaP8A9BFZ9r4hXQdYaN2/dsfnjPRh/jV7Rm/4kOn/APXtH/6CK5LxhAG1GNTkeZyCO5x0rmaXsVfsjvqtrGzs/tP8z0O5tIjEup6c++0k5ZR/B/8AWp8BDx7s1zPhTV5tJt4vMzJbsNs0Z5/Gunu7RII1vLF/MsZfm452f/Wrz5Kx6kJqSHrjJJHAq1A0UMct3cMFggUuxPtVOHLcDkt0rkfin4gGnaXDoNs/76YeZcEHovYVKV3ZFtpK7OU16/m8Ta40ySYkuH2oD0VP/wBVYFzpM0rzHTIGmksY2eZuygd/r3xUGj6sLPUTLMx2+UyqQM844r1fw7pSaB4E1LVNRQxSXELlhIMFiw4FNqUZWEmpxueJW43MIxzgZat3TbmOC+hd4kl2EP5TjIYDt9K6HwD4K/tvT726lcIg4jyM8j19qowab/aGrPHCsMkiRy7NrbVwkbMBx/ufpXRKtFxcIvVW/MnD0n7VSls1L/0lklykA1KW50yNhZI2P3o3eWpA5P45xQ8UV5HtVI2uJT8k4GBIB/Djs1YFrqN9MsyBTFGwUSKXKhiMnmrMV0YoYnaEusp/1PmkAnkg5HQ4HpXZQp1qkeaKVtt/K5lOFGNuaT17K/Vruuxdls0hUqs6NKPvRjqP8af5P7k2yo0z8thVz5bH39D3FLbNaao1slmsVrJkiSS6uCsUJ55ZuoBYAZ7kgd6oSXkkOIonIbrKVn4kOSPl/vZwSPUVusPiaityLtv/AMAUY0KUueE5L5L/AOSNK3ha3eNLy2iRyf3bug2se4b2/lV6KWSxurEWVmJc3JDQF9rM7DaF56YBbB75rMjjlgRPtyySW8vO3zDx/tYB/nUs22ymhknDTx5zHOJGBZcHvnjBx0rzq1G8fhS2/P0O/DYhSm1KpJq0t1/df947Dw3YT3XiKOxuJmaJwLq6gB+QSDovvjI5rtNPt3bTHeMnKXt3gZ/6eJK4DwLd6bea6LeUXSSzFgJI7yVMLgYXKsD6muqg0m4hjuIf7P1t/wDSJnjlh1LCMhkZgcGcc4IzkZznPNclVzUldbf12NqMKE6UlGb3W6S795FP4i3tqnhIpeR75ZHAi/vDHU14M1w3mHy97DPGa9A8X3iXl8wVLtIgNkaXNwZsY68l26+xriZtOnQ7bQr5cp2kMpOCfTAohLW1vz/yM62FaipRkmn3cVtb+8+5v6JcLfacWgSNtTkmAQhcmKNRzj0zk/WsnVJmtNTupDyVLZ3dz+7H9a6Tws2maBqEJ1CC5mtQCZoowu4yYOMcjgfhVfxfpX2hjqVvC62N2SIXcpuYgqTuCscMMD61U+WSVPzNcGqtBzrKSTUXazW616M5ewU3E29bdN7HCYLck/jXc6Tpe6QIkzqkXQqF5bvjINYej2gh/eKAdv7uMerHqfwrv9KsxBbovfGTXoUqCvfXTzZ89isdP4Ul/wCAx/yJ4NPm2jGoXI+ix/8AxFWBZT4x/ad3/wB8xf8AxFWkXAFSqvNbezj5/e/8zj+t1O0f/AY/5Fe208x3S3El3PO6oyKJAgABIJ+6o/uitAU1RTs4qoxUdjOpVlUacunkl+CHClpKXtTMwpe1FFAwopRSdKADNFFFABSdRS0lAEZGaiddqkVYxUbjNAjGvrNJUcbVy3U4pmnaPBbjIjXPritRotxqZV2rtAp3FbUakYUcCpUGKUDPWlAxSKHDine1NFLSGL/OkooPWgA70UZ70UAFApO9LQAlLSd6WgY+kPNLSUAJTTk+1O4pDTEIaY3Sn9frTT0oAqTjivNL24Nrq91DctIkZdgGVCwY46Y+lenSjIwK4TxNpNw1208Dt+9PKjscVzYig6qVjqwtalBTVVtXVtFfqn3XY5RpHRZDPK0cbuWEQPPsMfSlgS5uj5dpCY0P8RHJroNO8KtMQ9zyevTFdNaeHrSNRsWUY7rM6/yNVClOKs0vv/4ATnh5bTl/4Cv/AJI5vSvCBJElxkk+tdfZaTBbrhEA98VOmi246vdf+Bcv/wAVUq6Rbf37v/wMl/8Aiq05qi0SX3/8Az5MNu5y/wDAV/8AJEN1Eq3WnDH/AC8H/wBFSVqKoHSqcWmW8dxHKDOzxklPMuJHAJBGcMxHQn860AMCiCkruXX/ACRVedOShGm20lbVW6t933FHFOzSd6Ks5znfGNz9j0+0nJkHl3S/6uRkYgo4wCCDzk1mX2q2baZo1jZ6lcXW67hS9diwYHO87XJ3Y3AAHPTFafi1EmsLdJFVlErNgjusTkfqBXGags11qen20qRlEjhBURgbs4HOOv41hKu4Nxvpdv8A8l0t6bnt4WMXGk7X2/GbO8t9Qnh8OtOqy3MyyyRREI0hYCVkRmwCSNoBJ+tP8NTvPo37yaeZ0uZ0Mk6srMBK4HBA7YGO3Ttir1jCkUClYkQ7AnyqB8ozgfQZP51YSOOJSsaKilixCjAySST9SST+Nd86sJRlFLd3/PT8TxbjqTrSnpikFc4g7UmOaKKBB1NNY4oprUAUdHP/ABI9P/69o/8A0EVR162iurfLj50OVb0q3pB/4ken/wDXtH/6CKZdhZFIJyO9Z00nSin2R04ttYqo1/M/zMKxuTICCAJV++v94eorpND1z+y5fLl/eWMpw6Hnb71wt7JJY3vmDIQnqO1asV0Ly2ZoseZjlex9xXJVpezdnsdlCv7VXj8SPTLhrPSLObVfNVrOOMyJz37CvnfXtTm1bVrm9uWJeZyf90dhXYajqFzNoy2LySeXv3bM8Vxt/Cu1vainQtqxVsXzNRXzM2GRYElOCZGG1eOAD1Nbtpfa14juLHRri/nmhZgqK7kgAf8A1qwrbj93NxGejY+7XRaRtgdURVF1uBilY4C+mKt07aPculW5tj1HV0tfDvhm30bQwo1HVsRBgcEAD5mPpgcVyP8Awj7z+IbLR7CSNHigMMtzESFaQxu2GHqQpB9jWU/iTUbLXW1G7t455ljMbhh05zuHoa7+10ubTNH8PtE4kv76/E9xJ1yGik3c+yk/lXiVKdajUV3q9n3Pdws6c4v0l/6SzzO+0Wa0LJPIgJbYQpzkY5/w/GmfYRckN9oSEQ/MCwzntwPXmtzxdqsGseJJZ7UBbWPEMO0Yyqgjd+NYXmo1x5GRuUbiK+hpV506bb3T/RHkVoKUqcY7W/8AbpG7pTWOjaHFqVtdR/2skxfynjyFYB/mIzyCHGBxggHJrStPCS3nhe/1u5vljaZZDPvh4lAYltpyNpyzAcHoPSuYXCzJIVDbGDYPQ47V1+pap/wlLWkFkkoDMWmsozgJgD5vfnn8Kxjjq6d1LV76I19nFK3Q5ua3MbKdxKsMoCeQPf0qFHiVo4J332xfc8YOSp2kZH55/Cut+IWpaTpeh2kVnDC10g8pnj6FAByffJ/nXlGmTzm4kuN53HnH4ipniE4K66r8xYag1Vdn0l/6SztdP0+Wxa/WBw0ywrdWki/xhTzj8DXWT/E5G8MmJYWF/IoQAfdA7nNebXV3dWk1rqNjKymA8xnke4+hqC5vrC/ImgY27nl4iOFPt7VlU+Lm6MUHpZbo1QxuJmvbkgrCVd1HRV3D/EUnh2NksJ9SuRgOw8pT644x+dQabqtmstvpmx3gmlVrt+7oCOPp1Nbeo6fLcaFNdNILa0t7lI7cKPlBY8D6Bf1NRGVpt/11Olxf1eKfd/lEyJZBGZJZGyoyzE1Vgu73UdMt4nwLdZXEQH95jyTVG8uZLycaTGSXMxR5AOCo710slutrbWtnANu1uPXOD/n8aqMevmvzMo1FFy7csv8A0llrQ7ETTKQP3UQ2r7+9dnDHtAGKpaPYi2tUAHOK1woAr1UrKyPmm3J3YgGKlUcU0LmpVFAhwHFL3oxRSGL3o70U13SNGkkZVRQSzMcAAdyaBpNuyH0v0qh/bOlf9BKz/wC/6/40o1rSz/zErL/v+v8AjUe1p/zL7zp+pYn/AJ9y+5l6iqX9taUOupWX/f8AX/GrFvdW92hktp4pkBwWjcMAfTIpqpCTsmRPDVqa5pwaXmmS0UlFUYhR7UtFACetMI5p5ptACbcDNJinUUACinUgpc8UDClpB60vWkAnSjtRSUAL2pc0lFABR2oooAWiiigY40hoooAQ8UUdaKYhKQ06m0ARlM1XmtkkHIBPvVztTGHNAmU1twPYVZjQKvAp23NOUdqBIAKUClxSigYgHNPFNFLQMUjnikPFLmkIzQBzvi07dPjJ7O4/8gyVzfl58Rbevlm3X/x9K6Lxjzp1sv8Aen2/nG4rGhTf4gvW/u3Nuv8A5FSuCr/Fl6P8ke3htIUfNx/9LZ3sY2qB7U/tSYwKK7zxAzxQSMUUlAC96Sg47UhoASmGnGmkUCMPTNV06PRrKN7+1V1t4wytMoIO0cHmibVNOYHF9an/ALbL/jWw3eq8q5FZwhOMUrrTy/4J2Vq+Hq1JVHCWrb+Jdf8At05TUJdPuEI+125z6Sr/AI1g293/AGdc4WRXiJ4KsDtrup4gRWJf2KyqQRVShOas2vu/4JnGrQhLmjCX/gS/+RMu+v7e6XcrIGxyNwwa5+dfNl25GO5rTkhmtSUwSvb2p9hZEvuYdTURpVI2V193/BHOvh5Ny5JXf95f/ImabKFo8F4/++hTI/3YETtwv+rdecV2lvZDHSm3ujxzxH5eauVOUla6+7/gip16EHfkl/4Ev/kTDjmt9RtRHcOkdynCSOcBh6GtSXxMW0CKzG4ajHOcSq+V8oxuhx6E76wZYZrK6VWYqVP7uT09jWuqR6vaFXwt8nB/2hXLOk3JKfTy/wCCetQxlFRlKnF3s18S6q38pij5ygQd8D8jWppXw/uNb1ZJVvhblIyWcfMC38K/jVa4iiheONFdWVvm3dc4Nes+EdN05/CMQik3PKd0koPzRyUV5WjL1/RFRiv3fp/7dI8mvLS5029lsb6LyrmM8jsw9R6iqy63deHZ1v7KQLcj5EyM5zxivQ/iVHnwzNJcWrPq1ntaGZF4ZMgEk+mO1eJT6ib0i5ZSqRjCr6tXEtVc1k7FjW9Rk1O9KgBFJ3Mq9Ae9XdOgWOME8dqy9Nt2lk3tySc1s3Ti3t8A4NEldF0ZqEuaSvuvvViCaeRJyRC7xdGUKeRVF7acSi4ghIA/gPG4e4rPnl3OSTXVeDoRqIms55HESruwDxitKfO9G9PT/gkTlQvdRd/8S/8AkRmj2O9zf3c6WxZlCxA5YDcMn8Bz+Fek6L4j0GHSpPD2pL9o065kJeViMoT3/A4+lcXfa1YaVMtja2ivsIkLem07sfjjFdbZXtnrGji9gQCMgrJHjoe4os3Nxv26evmdDnQVCL5Xu+q7R/umDfWmjWuvXEun3EcltbxiKB2cZkI6t+f8qdpxS81i3PmIx8wjAPJGxjn9KW7x8ltEoUE9B2rqdJsxbWqjHPeuqlRk1v8Ah/wTyMTjKMZNKLvZr4l1TX8vmaMSbQAOlTAUiLwKkrsPHEUU8CjFLSGHWlpKWgAqjrP/ACA9Q/69pP8A0E1dPJqjrP8AyBNR/wCvaT/0E1FX+HL0Z04L/eaf+Jfmea3t/e2V/qjJHbXsdu0puDNaxkxlpNqndsyWyQeTjnpgUyy8SJbwaiJrWyu3W1jlhkaziGx2KAjAUA43nr3Wurk0zTrXQtUuyku6WS4Mga4kKufMZQSpbBPA5x71ymmw6PHbSRttXziFIZ2yQDnrmvbo1MtqUFz0k9teWKvtf9fW+p31MdiIV5xUmrN9Wa2n6rp8mvapp9xcaa1la2rtHdPYwqzOCnQBRkj5wB3688VV8MatLLPrciX6WaboXRY0iMjJtfCIoG0sflHTr2yamGnWVuplgBJCn5hKxJzjqc89Bj0xxV3wzp9lrN/qc9zHMX8yGQEXMgYOqsudwbOeT371EquX0WrUvisk+WOjWrfzSd/utYt1q+Io1bzdoq7Tb1XNFfm09Tq/D1zeXOhW0uoMrXfzLNtGMMrFSD7jGDjjINafeoba2itLdIIF2xp0GST6kknkknnJ61NXnVZKVSUoqybZ4z3F6UnWjqKMYrMANIeKWk70CCijmoLiZ4dpSFpF77eooY0ruxPS1ThvGaXy5oWiJ+6T0NYl7r95aMrbkxJPJGgFozAbGcDc3mDJIjPAH5VPM3pFXer+S3OilhnNNuSSVt79b9k+zOnorm9N1q+1O7a2R4Y3WPzCXtgQBnAHyzE5PPbsaktNbuZtQs4XeNorksYz9nKeYgVjvU+Y3GQvUA4YU2qi15XbTt19GX9UvflqJtJv7XRX6xN+iqMmrW0WotYESNMsDXDFE3AKpUEcclvmBwB/MZk0+9TUbUXEcckYLuhSUAMCrFTkAnuprV0pxjzNaHLYt0lFKayEJS9qDxRn8qAClFJSjmgYuaSikzxTEFL1pAOKKAA9aKKKAE9qQjIp3WkoEAGKKdxikoCwUUUUDFHNAoFGaACl7UUYoAw/EtncXdlALaJpGjm3kKQCPlcA8kdyKxdIsNSLs9xZy+dLcRSM+5NoCyKxJ+bPQHoK7UjI5oVQo4FYyoqTbvv6HZSxjpqC5U+XZu/e/RpbvsP7U2l7UVscYmaKKO9ABxTTS4pDQJgaYacaSgQw1DIvHFTmo2Gc0AU3QHNU5oN2citNlFRNHk8VSYjDmsFl+8KbFYCJunFbZh9qUQ57UXFYpww4A4qYxVOI8cUpXii4zA1PTI7pCCozXKt9o067QtkMh+Rz3Hoa9GMIPWsfVdJS7hYbRmlKKkrMqE3CV0ZM3k6vFbSxIFuzKVZc9fkY/wBKv+HL7UNAvZLuT/j2biWAnhx9PX3rmomm0rU4SygsjZU9iMEYP510eoXVpPo51EHbKOCue/oa4tY80ZbX/RHvc6qQpzW9v/bpGt4z8RWOrxRWFreYh8sSSbhyO4Q/jXid7snvzFCAI1POBwTW68rOzFz8zHJNUksRFOWHQnNcrlpZGttblqwhWKLcewrN1O63uVB4rQupxDBhfSubuJC7k1INkR+Z66/wPHIdbliQ8tbM231rmbO3eeZUVSSTgD1Ne1eDfAcU0SXUV35Wo28WUTAIfPUGtObl0MormdzzuXTJZNSndlJJbbz78f1rpfD0Mml6feRsPkZgQD/epdVs7m2vmnjkUxSSKXBHKNuHH54q9dAfZ1hiJ5OM+p7mujSTslrZfqZVFKnSVST05pflEbpFsbq8MxGVXgGuwhTCgVm6RZi3tlGOTWyi4FdiSSsjxW3J3YlPAoAp1ACUvaiigAo7UUmaACqGtf8AIEv/APr2k/8AQTV81na0f+JJf/8AXvJ/6Cair/Dl6M6cF/vNP/EvzOb8RT+V4Ruxn791Kv8A5GenfD7wfpWsaZdX2o2/mxJGsYB67jySP0rTttBj8S25sJmYRi4uJSVODxI+P1Ndl4M0FtD8MPaw5lYzu3zcEjoK5qtVKhGC3sj0YUr4qrN7cz/M8s8ZeG4/Bk1vJplxLLbXaMTHKc7MY6H8am8AzhjfsON3l/puFWvi9qCf2olirrvt4FVl/wB6qPgVdhuRjH7uI/mD/jTjUm401J/a/wDbZGyilTxLX8i/9OUzv1ORTutRoeKfmus8AUGl6im0ucUDENB5opOtAgrLu9ZjsZjFLbzn+6yJuB/KtM1DKgYdKGrjTt0ILO6g1iFlg3Fs424wyntxXNXF1daZJp7XEPmWsOoXLsyj5sgyIePq+a0NTsZQTNayNFKRg7TjcPesBFvLxQ1xI7lJZAmTzuZyWJ9TnNZpSVVPyf6I7KdRLDTtvzR06bSL0Jt2u5722ZN8zFmKZG0dFXH0AJ9yak02xvY5dBllaJ0tWe2g+Y5ZDGck8cEBBgc5PcVBDGRFIwjMe6RjtJzjnH9K2tOgZLDR5GP37yQ/h5UtdFbEctJP+Zr/AC/LQ3w8G5ySW0Zf+ksmt9EkttbjvUvJZIgk/mJJsyWdkPZQcfL3PGFA4zV3TbV7O1eKQqWa4mlG08YeVnH44YVape1VOtOatL+t/wDM81sKWkzg0VgIU0lHWimAopRyNo6mm0zzMSDkZ6getTO/K7FQtzK5LSHpxR7UlUSGaWkpc0AJS54pKKBBSjrSUooAKUUUGgYmMHNLxRik70AL2opM0ooAXtQPeil4NIBKKKKACjNFJ0piA0DiijGKADtSUtFACGkpaQ8UANIprDinnpSEUAQFaTbUpFJjFMkj2YpQoxUhpuKBkZHNJtzUhFAWgBoWopIs5qzjFNYYHvQI5PxBpqzm3CjDNIVz/wAAY/0ri9WaWC0MDlldW69mr0zUUBubD/r4P/op65jxdpqtpks4HzJzmsnFT5r9/wBEd0puEaTX8v8A7dI4qGbz1/2hVhckc1y0d/JaXbI/TNdNazrPCCpBrzpRs9D1Kc+ZalDU1dFz/DWMPmbiupmVHhYP0xXPCPYXcDIXpSj3CfYu2Ti1eGVTykik4+tfQXw/ga3trvXLslYmjyM9lFfO+hSEatFcuA0cMiu0Z/j56V7vrHjS11DR4NN06BoI2A80bcAe1PkcmioySRzuryeZC04GBJcB/wAS4qTSoftMwc/dHTNZeqT+a8VrH90OoH03Cus0u0EFuoI5NdtCNpNvsv1PPx9TnpRitlKX5RNKBNo9qsCmIMCn10HmC0d6KKACiiigBOKKMUdDQAlZ+t8aJff9e8n/AKCa0e1Z+tD/AIkl/wCn2eT/ANBNRV/hy9GdOC/3mn/iX5l7wbZQ3SXj3AzHHJPznGMytz+lJBrN1okWrXFozz2ccoVPNYsA2OcH8axJLSU+GZ5Yblo2e8miKK2Nw81qS5gvNM8F21g4/dXDtLu7tzXFGHPyv0R6eIq+ynUS7yf42RFPpc2spc6/qdjgXyko6ncoGMKMdRVfw/bLb6xqcSLgIsAA/wCAGuh0vXhP4KFjJF5UsTrCgHIcdc1kaV/yMms4/wCmH/oBqlFxnFf3v/bZFU5qeHrv/p2v/TlM30qSo1p9dx4QveikooAD0pM0tJQA1s7eOtP2rMheJSCPvRk5I9/cVG5Paq74JG7II6EHBFJp7oqMktGiWS2eQHMbcDJ46CudEsenWTXjKGEVzK+09DiVq1bia9WZZ7a7fci4Cs3aua1TVbaXw5cQ31vtm8+VlkjOMsZGPI6Hkmspc/tErdH+h2U1D6vJ3+1Hf0kXBcxyWsku5WwCxwe/eugnCQ6boYHBE/8A7RlryGyuZGuYYY3Yea4VhnqCa9Sv7jcdKRegnJ/8hvRj48rpwXl+Z04Gpzc8vKX/AKSzYU5p1QxH5alFbHkhS0lGaAF7UdqSjtQAp6VDIhPzKcMOhqUGjGaACivMh4k1gKAZZd2OuR1pTr2tFjtunC54BxTsNxZ6ZR3rzQa7rZwftbcewpG17WQM/bG/Snyi1PTDS5rlvB+tXepx3MV2294iCrY5INdNnmkIeOKKbmlB9qQDqM5pM0tABniijpRQMKWkozQAtFFFAAfalzikpc0AHvSUUdqADNHtSUtAgpKU0hoADQaKSgANNNOpKAG0lPxSEUCGGkNOIpueaAKbapp0bsj39qrqSGVplBB9DzR/bGljP/EytDj/AKbr/jWXpMIm1SV4pJwlvNOZh57lGd5HCrtzt4GSeO6mmJLM91E/nymWe8ubeSIuSqxoH24XoPupz/te9VClOpDmjJbX28m+/ZHo1qVCjUdOUW7O3xL/AORNb+2NMA/5CNpnGQfPX/GrCTRXEIlhkSSNujIwIP4iuPF/qUBumvZpopE+0RI0chfARHx+7PA+5kHqTweDV3wrJcB72GdiNrbxH5zSgZkkBO488lcY/wBkH+KrWGqRhzTknp+qXfz/AM7E4ijRUZSppqzW7vvfyXY1r/m407/r4P8A6KkqPULSO6tZYJBlHUg1Jfc3Wnf9fB/9FSU+c/Ka56e8vX9EY1/4dL/D/wC3SPDPFGhPZXbKOQD8reorO0m+e3l8lz9K9M8Q6eLlWLDP9K81vtOeO5yvBBrnrUrO62OnDV1KPK90a95dgwhVPJ61nW90FuURlyh4NExIjGeuKs6LZC7MztGzMCFix3Y9qwlCysjqhPmd2dFLodrpur6d9mlWXzFWVgOdpJ6V2V6yhmAwoXrj1rF0fw9Payrd3YCiPlUzkk9qsXshmlWBCSznn+tVRg7KPUK9VQi5C2lv57i5YfL58QXPoZFFd1EuMelYItRb6XEoH/LeD/0atdFGMcV2pWm0uy/U8ubbw8G/5pflElA4p1IOlLVnOFFFFABRRSHmgBaKKSgANZ2tf8gS/wD+veT/ANBNaFVdRga6066t0IDyxMilumSCOaiom4NLsdGFkoV4SlsmvzMqKxUQW90JyzS3FyDFnhcStzWhqE0t5b28EmNkCbEA9Kzre01K3Zibe1YtI75+0MPvMWx9z3qZ31Hn/RbX/wACW/8AjdZUuWMUpJ/czsxkJ1a85QceV/3o9/UsQ3Vo+nw6fFFieCVnkbHXI4qjpQ/4qTW/+2H/AKAasGe8lkjMWnWiMkYVj9pb5j3P+rpdMsbmHUtQvLkQr9q8vakbltu0EckgVCvKUdPtN7Ps1+prFKlRrqTWsElqnd88H0b6Js1hTs00U4Gus8YWkoooGJQaO9GaAGEZqKRdw5qamstAjLuImAJQ4NcRr3nvpDKU3KtzISR/vtXockfFYt5o1vIrjbLh2LECZ8ZJyeM46mj3lJSj5/odFKdL2cqdRtXaeivtfzXc800uZItRhlkB2q2eBXo8cv2i401wcjzjj/v29ZY8LxeaCqMOf7xroLDR4bd4pCJWaPO3dKxAOCOhOOhNZ1o1KklJpdOvn6G9GrQpKXLKT0a+FdU1/N5mynAqQdKjFSCtDhHZ4pKKBQMOlL9ab1NKelACiikFLmgDy94go9zUezHFQC4J+0NPLtWEZJRg2eMn+Ee1Cs2yYzyFDEgkYAhvlOfYehpuNRfYf3rrbz80egsIv+fsf/Jv/kSftVW4k2oRnrUQmkYAAhnZwi7ZAVyQTgnHBGDx9KoT3RfI6nJU89wcHpRUVSmryg/vX+YfVIrepH/yb/5E6TwnqbWtzcsiblKgHP1rqx4ibp5I/OuP0qxeK1DCRoy3JC4/qDVxo5B/y8S/kv8AhXJ7eTfwv8P8wlhKd/4i/wDJv/kToj4nZTzAPzqN/F2wf8e/61zjxOf+W8n5L/hVKbeuf3rn8B/hSdaXZ/h/mL6pT/5+L/yb/wCROp/4TgBtv2Qknp81dPYXZvLSOcoULdVPavLNOh+0aiuXYBPmyMZ/UYr0LR3lS7urd7h5o1RHXeFBBJcHoB/dFVTrOUkmt/QVTBxjTlOE07a9e6XVLubZNGaaGzS10nALS+1JRQA72ozxSDrQTzQMKXNJSDigQtFJS9qBBS9KQUZoGBoPFHaigAzSGlpKACijtSUABpKUikoEIaZjFPPFNJoAxrO1j0+0l1Npwsct5OJY8cAh2G4/gBWNeeKdHX7RJBaxSzyx7Gk8sfOvoT3FUPE19PZWkW07opJrlGXtnzX5rkDKEjAVRzXBCvOkrJ9Ez3cRQjWrSm+ja+5nWaX4l+36/DNcwwrdT4ikdUGSMcZP4Cut0SCC3tJFgijiBuJshFC9JGA6ewFeX6faXk8y3FrbySeUwdmVeBj3r0zRZd9jn1llb/yI1a4epJvlb6f5GOMp2pSl3cfykT3x/wBJ07/r4P8A6Kkp8w4NLdWv2kRETSRPE+9Wj25zgjuCOjGqz2U+P+QldH/gMX/xFbLmi3pe/p2ORqnVpw99JpW1v3b6J9zLv4t4IxXG6vpecso5rt5rGXJ/064P1WP/AOJrLudNZs5uJW+oX/CrcnJWcX+H+ZmqMIu6qx/8m/8AkTzWeB94Qjkda6jwq9pHfLLKNu0fdHQN61Pc6P8ANuwT9apGwkgbfGmD0rmnCXSL/D/M7Kc6aa/ex/8AJv8A5E7bVb1Y0UhhtIwvPU+tVNDtPtNybhhxnisG1trm8lVZGfC9K7bT9KlhgULfXCH0VY/6rVUlKOri/wAP8yMRyVHZVY2/7e/+RLl8mLOMf9PEH/o1K1VrNGmvIUEuoXUiK6vsIjAJVgwzhAeoFaYrWN3Jyatt+pz1nCNKNOMk7NvS/VLul2HU4U0UtWcwtHaiigYUlL2pKBAKKKKAE70hpaQnFADCvNM2Z7VN9KQ0ARrGFzgdetSAUY70nQUAOFRXNylrCZJM7R6DNM+1rv24Ygd8cVV1HWLeys5pcq8qjCIe5qJT00NoUm5K+xYsNRj1FpUjSRGjx99cZq0M9zXL+Hdcn1PX7jz444wYBtVOhwef511MSZ1BVJ+V0zj3BolLkV2b+xjOK5NwpKfMuyVl9KYapO6ujkkuV2YU0jNLmg0xDCvFRmMNU1JgGmIhWMDtUmKcFoxSGAp1JS0ALmikooAWlFJmigYooJpOvSjkGgDylINE+x+RJNIzsjh2HGWPepraz0eS3kWfUSXdNj7U2/Jg8Dk85Oc/pXNZJwfYGlVWNwxUHGK5liq2tpb6ntciOkOm6WyOW1RGkO0f6r5CBngrnnr6+lU4jp2i6lDcXEP2y0X74K/eJ5PFZbo4XoadfnfpCt1wKmriqtSHJJ6f0hqKTTO6j8e+FGwo0dxj/ZH+NPPjXwoRzpMn/fA/xryuEDzPqKmJxXn3fc6rR7HpTeMfCB66XL7/AC//AF6gbxX4Kc86ZL/3yf8AGvPbYK97CjjKMwBFTaxbW8N/m3GInzhfQg4NF3tcLRteyPRLa88P6jHLLpFs0DR4DbgRnn61pafKE1e7GeTDD/N64bwWPMkuIwf7prsv9Vrc4zn9zFx/31XRQb9pFef6M5q6XsKrXb/26J0sbZHWpQRVKB8qKuJXpnhIcKUUlLmgAooooAWkoHSigA70UZooAWkoooAWkJ5oooAU0lFFABRR0NJQAtNJpSaSgBDUb9Keajb9KBHCa/aNe6SvzAYvJeT0GZWqhK3hPw6oN7O2pXYGREn3QfoP6muju7IXug3UGcFpp8Edj5rV5TdaJNBLsOSVJyTXDOi5QjJdke08QoV6kX/M/wAzopvG+patdiys4Y7KzyBsjAyV/p+Fd3oLZsx/10k/9DavOtD0rbOsmMt0r0fQ4ytlz/z0lH/j7VrQp8jXo/0OfEVva0p22Uo/lI2AM0jKMU9RxQRxXUeYUpEyarSW4PatBl5pPLpgZD2akYxUP9mI3G2tsxe1KIhRcLGdZ6akL7gBWvGu2mqmKmUc0mA9eKkpgHFOFIB1FIKXvQMdRSCg0AFA5FJ2oFAC0ZpKSgBaTFGaO9ABRRRQAlRTKsgCliPoalNUry2W5UBiwA9DjNDV0OLsylLrttDKY1ikZF4LhcisvVtdttQt1tbXTPLfPzzMclvwrZNsoQIqAKB6VSNh+9JCgChQXVlOrvyrcqeHLSddSjnWNfLjYrIwHI3Dj8MiuuMqxXts7fdDFfzrkJ9WfQ5mYf6h3TzQB2B/+vTbvxpa3FxFBAjHMinefrUunKfMkjso1IRhG7O4vWBuNw6EVW61ELkThSDUorOg7wRhiVaqxelBoo7VsYCUUtJigBaKBjFFACUUtJmgBaSiigBwIopO2aBQMX6UtJ1NGaAPBixUDHpinLO6SjaeDVhbeJicyDAHFMe3QOu1wcVzKhKx6TxML2uONw/QnjFLN8+jN9TTls96k7wKJFSGyaMuGGaf1ee9hLFU9rmDbuXcVdZDitCzTTvKU+Tz3NXPK01hypH41yfVqh0fXaS3MKNvKnjc9FYE1PrLRtPGYXDD5mz6ZOa1fsOlt3b86T+ytLc8u350fVqnYn69R7k/gFwNRuc9BFu/I109rdG61eWU9fKQfq1YelQ2OlzvNbuSzRlCCeua0NHB+1yE/wBxf5tW9Gi4yTl3/RmVTERqU6ig9OX/ANuidjangVoJWbbdq0FrtPLRKKKRadSGJS0Dmk6UAKKKSlJoAKKTPaigAooooELSUUUDFpabS0AIaKKM0AFJS5pDQAh5qNh8tSGmkZFAjKn0mxlLu9lbF2OSxiXJPrnFYN74dhd90cSqD2UAV2DLxULIDxioVKH8qOhYzEJWVSX3s5qy8PW8ZBlhjfH95Qa6C3t4oIliijVEHRVGAPwp4WpVXFXGEY6pWIqYitUVpzbXm2xw6UY4o7UvemZEZXmk21IRQBQIbtB7UbcU+jrQMaBThS0CgQ4dKWkxS0hi0vtTe9TLBKyB9vynoT3pNpbjjFy0SGUlKQVJBGCO1JTE+wUlJS0AFHWiigApMc8UtFABSGiigBDTCM0801jgGgBjKKs22nxSYe7uFtISMq7/AMX0qca2pt/KltIH2j5WxyK5/WdTe8kTzV3iMYRR0Wo9+WlrG9qUNb38hfEieEYNKuGMs95cBTsKkhc/hivH4XJmVxwN2RXdaiJr2JovL2qRWBa6A6zgMCQDxXRQ/dp3d7mVSr7TRKyR3GhXJuIA2T0A5roFPFYmjWZtosY7VsrWKio6IHKUneRJQevFJRTEFFFFABQay/EV5PYaDc3Ns+yZNu04B6sB3471zmnatql9JLHLqtxatDbC5maSzhZEUgEcqxOSDkZA4BqOacpOFODk0ru1tr26tHpUMu9rh/rM6sYRu46826Sf2Yy7ncA0lcTpurX+pPIi6zcwMsH2lRNYRDzI843Lhjx9cdaZFrOpyRu7ajfoBbfaVzp8LF03BRgK5OSTxnHQnpWro4pNr2Mrr/D/APJFf2fR/wCgmH3VP/lZ3OaO1cro8uqa1Zm5t9dljUMFKy2UYYZVWHRiOjA9e9aH9m63/wBDB/5JJ/jWE51YScZU2mv8P/yQvqFBf8xMPuqf/KzbpcYrE/s3XP8AoYf/ACST/GnLpOvMpI8QcD/pyT/GoeIkt6b/APJf/khrL6L0WJh91T/5WbOaKxP7M1zp/wAJD/5JJ/jR/Zmuf9DD/wCSSf40/bT/AOfb/wDJf/khfUaH/QTD7qn/AMrPGBcSjsv/AHwP8KDcygfw/wDfA/wq8Yh/dpphB/hrRUIfyr7jN5jVf/Lx/eyqt5MB1H/fIpRcSyZXjn/ZFWlgX+6KlS2VWyF5qvZQ/lX3EfX6y155fexsalVAO3j0UCp1jJ9PyqWKDcelaENkW7U/YU39lfcc7zDE3/iS+9mYsR9vyqVYTWsLE56VMlj7UfV6f8q+4X1/Ff8APyX3szYLbJ7/AIE10Wk2qxZcZywAJLE9Pr9ajhssY4rZs7fYBxR7OEXdJCeKxM04ym2n0uzRgGKvJyKqxLhatR9KZCJR0pelAopDDNFFAOKAAUUZo+tAAaKSlBoAKKKTvQAtFBpKAFozxRSZoAWjNJmigQUGkooAKSlpKAEI4pm3NSUlADCtLinYpAKYCEUYpaO1ACYpKWjrQA0U6m96M80ASFSACR16UlW9pNkwccxkYP1qpURlcucOWwZpe1N6ClBNUQLnFVNVnv1ms4Le4kTzIpGSOEoGdw0YGS4IA+Yn8O/SrJPFYV7bhtZt2JYnyZWBz0+ZOn51lVV0vVfmduAmo1btX0lur/Zfco3/AIluksbK5N1O8lxBHLseSJSC4BCjEBz1HPH0qTUNUuYre6ew1C4uDbWxuJGYxKFHOMDy/m+6xxkdOtcq9tMXiWebzEtFEEeVxnaoUH8s8e9aaadImhX91DPsFxG1vIpTduRVJ4ORjqw79arnwsajhJO2ut5d/Xtt5vU9OCqVXGUVF3tvGP8AkdTquvLpdz5TRRn92JBvm2NJyRtjGDvbjpx95fWrX2+Qa0untbFY2heVZi4+YqUBAX0+ccn0PHeq17pEt7JO32pEFxD5Ev7nJ2BmI2nd8rYY888gHAxV17TfqcF5vx5UMkWzHXeUOc+2z9a7m6HKrb2d997afieDoWqDRRXISFLSd6KADvQaSigA6U1xkUpooAqtAC3pUTWycjGauFeaaVHpTAoNaqeMUkdiituxV4rS4wKdwEQBegqUUwCngUgHCiiikAZpaSigZi+LP+RZvP8AgH/oa1R8O6CU8LTx3MoNxqUJ8yRedqsmFAz6A/mTV7xZ/wAizef8A/8AQ1q7o/GiWH/XtH/6CKxp1p08TKMesY/g3/X3Hty/5EsH/wBPZf8ApETndO8N6tbTpLcGxcx2C6cgWR8GPOSx+UcjA4788imaJ4X1bRTdT281nFM0CRRxqzNG7KR8z/KCDgEcZ+8TxXZd6O9eq8xrNNO1na+nY8bnZieFNFm0LRzaT+TuMm7ETlh9xQTkgHkgn2zW6BRjNXLWzL4Z+E9PWvPxeK5pOrU3ZrSpTrSsiO2tWnbPRO5rTWFEj2KOKrvMxykPyoOMjvTVeVDkMT7GvCq4pzlrse9QwkacdNylPH5UrLUVX7kLNH5ijDDqKoE16+Hq+0gmeJiqPsqjXQ8gNmewpPshz0rqTpvtTf7N9q7dDz7M5oWh9KlW1PpXQjTvapE0/wBqNBWbMq0sSSOK24LMBeRU9vaBOoq4kYHGKTZSiVFswe1TLZr6VeSIAVKIxU3KsU0tQO1WYogtTKvtTlXmk2OwqrU6jFNAp4qRj8iikpaBhmkoNIaAFooFFABRRSUCFoz60lFAwz82KWmZ+elzgZpJ3uU0k0Ozg0U3dmlFEXdXFJWk0LRSUUyQNFFFABSUUlAB2oozRQAUUlLQAho7UUYoASnJGXR2HRBk009Ku6aolS4jbhSo596mpLljc0pQ558pQNRyyLHGzMcKBkmqmpanFplyLeUEuSRgVh3mpy3oZB8sR7etKdWMVdsunh6k3ZI6/TrlbnRrhhKH2uAvrimA964jRNVaPVxaqSsTDBHYntXaK2RUUHeLfdl4uPJNR7If1oJxSCgmtzlGk1lXrhNRhY9reY/+PR1qBS7bR1rA18yxuGSJ2YWs3AUn+KOsqrXL81+aOvBxk6jsvsy/9JZzTS+ZHx1Zi2asaxez6f4f02CNf+PgyF8/3SNtZMN0uFjztcDBVuCDR41vmTWdI09GBjjtlyB6k/8A1q8qpJ6teZ7+FilOEXtdfmeo2kxmto5CMFlBNT+1Z+msTboPQAVoCvZPlRelLSUooASijqaM0AHSkzRQaAA0ZpM0UAHWkpaTNABRigZzS0wG9KdRRmgAopKWkMKWkzSZoAx/Fh/4pm7/AOAf+hrVzRz/AMSSw/69o/8A0EVT8Wf8izd/8A/9DWrmj/8AIFsP+veP/wBBFci/3t/4V+bPbl/yJIf9fZf+kRL1OVSTwOaWONnYKoya1Le2S3G5yN3vVV8RGkrdTz8NhZVXfoR2tkFw8nXsKszttgbHHYU8MG6EGobr/Vj615FWpKd5SPdo0o00oxRHGgCinlKIzUjsMVjbQ2vqVsbXHo3BqhMhSRlrQl+5UWoIPlcde9duBq8s+V9TgzGjz0+Zbo5wwj0pPIGOlWytG2vbufP2Kgtx6U4QD0qzjFLt7UXAg8sDFKsfNT7RTguKLgRheKkVeKdt7UoFIBCOlKq0uKcOKAFApRR2oFIY6iiloASkNLQaBCUUDrQaACiiigYUlHakoAZI2GBpQcimy/w0q1K3ZUtkHQ1IOaiPWpAeBRDYKm9x1JRRVEBRR2ooGFJQaKBBR1oooASgVBc3UVoqGUv87bFCRs5JwT0UE9Aag/tS3HHl3f8A4By//E1LqQTs2jeGFrzjzQg2vJMv00mqg1KFgSI7wgdf9Dm/+Jph1S3/AOed3/4By/8AxNT7an/MvvLeBxS3py+5lwtipbG6jgvVSb/VS/KT6HsaqQ3MdzAJYiShJHzKVOQSCCDyOQao3915TpCsEsrurMAm3gDAOckf3hTm4uF+hFGnVVbkStJXunpa2977WMLxvetB4vlV48YRVB/ve/5YqPT7W51RglrCzk9T0C/U9qztZvGuPEdveavHJ9nUBSuVBKj8cfrU9/8AEmKaJdL8PxJaRDOXKkMPoBx+JNeXUvF2d/uZ9DRpucbpr/wKP+Zu3mj6VoMKm5ull1OVh5aIcAfQdT9TW1A+UBrxvTGu5PEQmkuTdSl8vuJLEfjx+tesaZdfaI3HlvG0b7GV8ZzgHsT2IrswrSieXmFKfM5aWXZp/kzTFIaBQa7Dyjmte8SnRNQMbgiEQCTcluZW3FtuPvqAPema7qXiLTtQtN9mGaRZIYX2KA65UsQPMJwNo6gYqp4o06TVtVnsIHjWaWxQKZCQMiUNzgHsDU2v315aXjalqJHlpEILZATkA8sT6E9OO1ZKlQqUXKesk5dX05eW3zbvvomfTQxCwnsuVLWCb0T3und7/iebX2oRXmqSXMxuo7h2wwTaADVu1C6jqMcjLNJLnylkkxgHHHSobxkvTJJFGgV7hpyTkNk/w9OlamgaRNLqGnShki8yd5PMQkthV5XGMY/xqlhcBZL2jTsuvVtfjv3t2Z1QxdRybVKLspPRdot3+Vr/AOW53+iaslzey2AtriOSCMM7uF2cnAGQx54P5GuiHIrm9A0ObS7+6nkumlSZEVVJBI2s+CflHOCPqS2exro1NdeJVONS1LbT8tfxPkZWvoPopKTOK5hC96KTNGaACijNJQAtHaiigBKXtRSUALRmkxRmgAooozTAWkzzSUUhimkooFMRj+Kz/wAU1d/8A/8AQ1rS0GBptGsMDj7PHz/wEVmeK+fDV3/wD/0Na3PCkwOh2kR+8sEZH02ivMxE5Qrtx/lX5s+lw9KNTKacZf8AP2X/AKRE1lRLWIkDJ/mah2tKdzkkmpLg5dF/GnquRxXmTblLU6YxUYpIgCtEdyH8KskieAkdf601l4psDbZivZhSXYfmCHinZ5pkqMjblGVqMzAfX0pbaMaV9hZjkBR1Y4qSWFnXd1H8qbDGzSeY4+gqc5Bxng9qqF1qTOz0MDbRtp9FfTHyRGVo21JRigBoXilp2KTGKAACloFKKQBRQKWgQtAopRQAoGTTmRkAJ6Gp7a33fM3SrU0QeIgCuaeIUZ8qOynhHKDk/kZlFHQ4PagV0nGIaO1LTT1oAKBRSUALSGiigZFNyo9jQhpZPu01OlJfEyn8KHMeaevQVG/Y09Pu0luwlqkx9BpKKogKKKKBhmkNBpKBCnpSdKWmmgDM1w2yrZtdoj26TM0iuu4YEUh6d+lUXshZeGn/AHKwmaZJrmONcBUZ13rx2CZX6CtG9uUg1LSfN/1ZuSCfQ7HA/nWlcBY5mVTkZ4p0MT7Obgv5k/uSO6tB+wpT6W/9ukYWh3k1nDrMllBHPZhmezjRwobAXO3tt3nqOOa56LEdxdG+jUr9ocut6RseRoYSSNpb5hg7V9GIB4ru18QaZo9pew6nMEjmiO0Huax9J1WK+j8tWBZVBxWtDHKnXknH4vPX7/8AgbhUV6Cmumgzw356+HrYXOftAMnm7uu7e2c/jSajClzfwRSAlGglyASM/NHxxVvTTm0f/r4n/wDRrVDOM6tbf9cJf/Qo65XNuEZLTb80ay1xtX/uJ+UjzzV7KW50iwCsgIsIDCrdXfB3Bff7v6Vzb6RLpVyY52HnqoK47t/nFeqeMta/s7SYfITEu7ANedwXj3xaaZt0meauvmUpVVJwslfr6eXlr3uzbD04qGj1NrxBp1vC8lxZpm3ubZ3zGy/eUHI5Pr1+mK6DTvLbxIHRQkv2lxJGV/fKPJHLHJ/d56Dpkqc1lCU3fhpLhSfP02QOP9zv+n8q63RJ1ukuplPDyqf/ACGlPDY391Gkltfr3XXv+HQivTcfaS6W/wDbomyKQmlFBPFM8g52ZHHji2nQjdDbLLtPRgHIwfzqn8VPEzXul2tsbJUIfhxzk1rwwG58brEGClrHqe37yofiD4TZrO0WK4V5C+cEYrzW6UXJy0d2fQ11WkqKhquSP6nlFoGW1G7qa7LSZEtzobEd5c/8C4Fc5dadcaZiK5QKTyMHrWzE4Y6Qi9VUH9f/AK1czleUWv5l+aO7Bx1mpfyVP/Tcj0mPoKmXiqtu2UBq0DXtnyI7NBNJQOtACjpRmk70meaAFHWikNRyyrDE0jnCqMmgCYUGr/hu0g1mwN4xIXeVAz6Vn3kiQ61cWK9IwCDmslVi58i3N5YecYKb2YmeKBmkA5zS1qYC0GikzSGBPFFIaOlMQtJnmjNGaACikz3o96AMfxV/yLV3/wAA/wDQ1q/oMpt9P06TsbeMN9Noqj4r/wCRbu/+Af8Aoa1a0sZ0OxH/AE7x/wDoIrglFSxMk/5V+bPfjNwyanJdKsv/AEiJ00+PMU+1SRvgVRtpvOslyfnjODVlGyAa8icXCbizupyU4KSJmwah6XEf1p4NMj+e5HoopFFs81GY13ZwKkpjttBPoM1oyEVLm5YN5MXDfxN6VW8uQfNvbP1p0Cl8uerHJq4YjtyRisdXqa7aGTRiiivqD48SilooABzS0Dg0negApaKKAClpM0tAhasW8HmNk9KZBEZG9q0o1CDArlxFfkXKtzuwuG53zS2HqoVcAVEHLyYH3RVgdKbtA6CvPUj1HHsZV9GY5dw6GoVNaV2qyIYz1I4rJViCVPUV6WGnzRs+h4+Lpck+ZbMlpKAaK6DlCkNHejNACZooooAbJ9w0yPpWNp2pXeoxxKt1DHNJCJjG+nyqADjoxYA8nt1qWxu7m7leODULRmUZ5s5ACM4yCXG4Z7jNTapvyP8Ar5ndPCxgnGVSN0/73/yJruPlpY+RWcZL03w08X9mboxGYRi0fOwEDP8ArPUillOo2cZea8tFA9bVv/jlZubjL3ov8P8AMFhouGlSP/k3/wAiaR4pM1R028lvFuPOeNzFLsVo0KgjYrdCT/ePerorWMuZXOWrTdOXK9dvxV0LRmkPWjtTMxaM0lANACGkJpSeaaTTArskTazpBmUNH9q5Uj/pm5z+YFVPGV//AMIxeTj/AFoOHXHYGnag225sD3Fwf/RUleaeL9RvFv7lZpXl844y5zgDpXFVjKMnOPR/oj2KcoSpU6U+sf8A26Rn67rkutXiyyjaijCrVvwjqclpryKzEpKNuK5yCGe8uEihUsx/Suu0eztdPu4lZhLck8n+79KxjOTqJ9S6lOEaLjsj0LTGzZv/ANd5v/RjUxrm1HifTbaeXyxMrxFvQsUx/I0zSHzaN/12l/8ARjVleIl26jYz+XvI3HAHOAV/xrqd/Yq3l+hirfX6l1f+J+Ujr/Huj6dqOiDS9OaNZ4T5hfrzjoTXg1hG9pcPbzcSBiGHvXr0vmqdsYZXbsawdX0jTNGuf7RuSshK5I9DXJiI+y3d7nRhpqqtFaxiaFexR3z2sx/c3CFHBrsPDEItbWe3DbgkoXPqNi15msg1DVw8I2oz5GPSvTfD6lBcrn/lqP8A0BK0w8GmpPq/0ZGIqxlTqQXSP/t0ToR0pDQo4oPSvQPFMfTI5tT8etb2/wAkiWZXJOOjZzWJ8UE1fRdQsfMuSQQSpDZFdCbO5t9aGqWN0sE3k+Vhoi3Gc54Ye1YHi6yv9aVHvbsTtH0Kxlcfmxrz3Sq3kuXRvy/zPfnXws4U5KpZqKT0luv+3Tz671W8v3QzvvZRgV0WlF5r2w8wYKrtx9ATWdB4eZJwRv49Wz/Sus0jRnS5gneVdsWflCdcjHXNL6u2laOzXbo031KoYunSlJyqp3jNbS3cJJfZ7tHW2wxGKtCoYwMCphXonzw6ikoBoAWjtSZozxQAGs/VSTYyqO61oNVedBIpBGc0CPP7fxPrGlb4LKdo4y2SuM81v+Hrm6vLyS6umLyOOWNSzaFDJNv2jmtSysktVAUc1lGkoy5jolWlKCgaI6UE00E0Z5rUwFopKM0AGaBSUZoAX60Z4ptL0oAKKM0UAY/in/kWrvP+x/6GtXdJ/wCQLY/9e8f/AKCKpeKf+Rau/wDgH/oa1c0n/kDWP/XvH/6CK5F/vb/wr82e5L/kSQ/6+y/9IiaFlJ5V3sP3ZOD9a0CrwscDK1kODjcPvDkVuWswuLdJPUc1yY+j7yn3Fltb3XB9CMPJJwqn6mrESLCnJ+pNO+VQSeAOaosWuG3N93sK8+yiepfmNBZFbowNMl5jYe1UvKxypwasRSmRCrfeFNSvoJq2qI7X5QParMku4VVTjK9wafULRWKerMzNLSHrSZr6c+RFooooELRSUtABS5pKO9AC1JHGZGwKaqljgVoW6KqAjvWFesqa03OnDYd1ZXewQr5TbD+FQXd08NzGi9G4PtVmYfLuHUU0JHOA5GTXlVJOTue7h1Gno1oWkPyjPWlJpoOBims2AakGQXQOA69VrOulw4lX7rdatRXsU88kKsCy8EVGyZ3wnvytdeHqW17HFiaXMrdysjZp4NQKdrFT1FTA16Z4m24tIaWmmgAzTHfYjNjOBmnZ4qGYnYcUxnPeF9TjW2aS7RxKUjiUKCTsRcKPz3N/wKrmiw6jGdPMelyYs7Q2u4lf3pLJ8456AJnnnk8UvgpY2u7ZXUHMC8f8BFeiSSwW6nJVcdq8z67VSa01S+Wlvydj6epRp+0m31k/zOBg0LxCuvreF4Nrxz75RHgjc0e1fvHsgAwOinPJzS65YT28T/abgyuUzjpit3VPEcNuCBMq4964/UfENtdllMuTsIzms6tWrWacuit+JLdOEWtET+HZCRdr284H/wAcWt/tXO+GSHF0w/56j/0Ba6OvSpfD83+Z4eM/iL/DH/0lCHpSZp3Wm961OYXPNHeim5oAVvWmZpT6U09KAM3UzmexH/Tc/wDot64rxhpYnZZM7QTgt6V22opKWtZI4Wl8qUsyoQDjYw7kDqRWPqkcl5bPG1hcDI7tH/8AFVi7e8nf7n2R6Ci5RpSi1orayS+1J9Wjzq81GHSIRb2K5kYfM5qfw1BcPfG5lYnee9Pn0Iif54jwehxXQ6NYyxFSLWVgP7pX+pFc9GChO7v9z/yN8Rz1Icqcdf70f8zptFyLQ5/56Sf+htWlLpS3gW5IYyQk7QkjIQOM8qR6CsdLh9Ns42liKhpn3LkEqGckdOOhFbTXn2W2dy+1NuTmt3HmopW6IwqVfZ4ydSEravVPzezXc4/xvrllZ+StkbpbsnDq91K//oTGuGudQvLlD50xkDdn+bH51seK7Az3S6ojB42+U+1YlpbteXkcA6MeT6DvXmzUG9FsevTxGIS1m7vzZq6FZyuyyyKAD93aoU/pXo2k26wQ/KD8zbmJYsScAd/oKw9OtU84BMbFAAxXVQIFUAV6VCnGME7aniYvFVqk3Fzbj6suKeKU01c4p1bnGRvVKe383gir5HNN2jNMDHGmqGzirsFuI6tbaAKAFUVIKaMCl96Qh2eeaM0Z5pDQMX2pKKKBC9RTSKcKM0DI9vOKAMGnGkoAcDxRmkpe1AC9aSkzRmgBT0ptLnmkoAXPSjtSCgn2oAXOaCab3p1AGP4p/wCRcu/+Af8Aoa1c0rjRrH/r3j/9BFU/FP8AyLl3/wAA/wDQ1q3pX/IGsf8Ar3j/APQRXIv97f8AhX5s9yf/ACJIf9fZf+kRLuas6VNsmeAng/MtVaYXMUqSr1U5rWvT9pBxPLw9X2dRSN+5bEJHqcUkMW7AHWo5XEkKODwcGnxybenpXz7+LU+mXw6EjIFzVVjsmVvU4NWGbIqrP90fUVMmVEkmUht60wTpjk4qwOQKzr+6itz5caiS4P8AD2X3NaKm5u0dzN1YwV5bEWaKSlPWvoz5QOlA60maWgApaQGloAKcASeKb3qzb7CeoJ9Kzq1FCN2a0aLqysSwIoTPelgzEXUnjdkVGgMUz8/I3I9qr6ncSWqoyIX3EYxXkVJuTuz3aVNQXKjRlm2Bcj5ScGoo38mdoj91uVpUO+NQ45IyRTLuMtCHT7ycismaolhull3AdVOCKgOpRDUFtSfnYZxVITCK5Scf6uXhvY1Ye0gF0L1gN6jAPtQm2bVIJarZipZ2+n3E91nBk5JNSSMJY1lQ5I5qteousaZJHDJgnjIPSpbKEWdlFbM+5guCT3rWD5XdHNUjdEFyoyJl6N1pqtmrJQfPCeh5FUgSjFT2NepQndcp4eKp2lzdyx1ptIDmlHWtzlA0xxxTzTWGRQM4eS81DRRbtHbyRSpEqMWKkEgY4wTVK68Qa5fEhpWUH+7Xa3tklypDAGqSaTEv8IrlWEjvd/h/kenPMpTbbpx11+1/8kcQbW+nbMnmuT6kf41attGnZwTazN9Cv+NdsljGvRRxVmOFV6CtVRttJ/h/kYPFRe9KP/k3/wAkUtCtZLaOffC0W+XKqxBONqjsT3BraFRquBTs1pGPKrGFaq6s+Zq2y08lbrfsOzSd6SjNMyFzmmmiimAU1jTqaaAI25qCWIMDxVk0wimBkvpkcj7mUVZht1iXCirhFNC807iK0mFZGZA6owbafasD4i67BNp0cdkCjy8OBxiumkUFa5LxTpIu7Ysg+deRWU6fN7y3N6VXl92Sujz46ncLZfY3YtHnjNXrSRbDTZrxvvuNsdZwtHeUpINu08mrX2Wa/uba2UEwxngDua8+dB3909SniVb3tztPCXmmxjMpJY8812kI4Fc7oVq0CbHQqRxgjFdLGOK9NKySPGk7ybJRxS5zSUUCFo4o60hoASjFFHegApwPFJigHFAC0GkooAXPNApOKDQAueaKSjPFAC5pKTNGaBC0ZpM0lAxc0ZpM0UAKTRjikoB4oAcKTOKTNGeKAF60tNFGaAMnxSf+Kcu/+Af+hrVvSf8AkDWP/XvH/wCgiqnij/kXLv8A4B/6GtWtK/5A9j/17x/+giuRf72/8K/NnuT/AORJD/r7L/0iJdyKRxkUDpSZzXWeIW7CUtbvCT8ydPpVxGBUVkRSeRcCTseDWkysh3pyDzivCxtJwqXXU+iwFZVKVnuixmon+eVIx1zk1EbhugXms6e9kkdobc4PR5f6CualTlVlyxOqrVhRjzSL17qRRjb2pBk6M/Zf/r1nxxBMkkljyWPU0RxrGoUCn5r3qFCNJeZ85iMTKq9dibNGeaTPaiug5haXvTelLQAopaQe1KJFW4jjf+PpUTmoK7Lp03UlyoIpo/tPlMfmxxTY7d4b55Nx2k5FQ3tm4v4p4zxkZq1fNItg80I3OoOBXk1ajqSue7RoqnGyF1O4ktrMzxoZDjgCp7R2uLCN5kxJjOD2qloc1xd6UhvI9sh52mkOqJFqsdoQd7dvasvM38ieC/jkvTApJcDJHpWkDuGKzbn7Pp/m3ZAUkZLVPY3aXdsk0ZyrdDSYylcQ7ZJLc/df5kPoadE5u7F4WOHA2mrOoRGSHen305FZySiK5SccJLww9DWezOmn78HHr0JtGsRo9p5LSFyzE5Y1Fd2962uwPG3+j4+aodat725mtvsj7QHBb6VtMzLanbzIq1qjmkgmXgMvVap3afdmXoetRaHc3F3FM1whXa5Az3q80ed0R6HkV1UKltexw4mlzJruUkan5qAZRyh6iplOa9Na6niNNOzHE5pDmk6UZpgNK5pmypT0ptACBaXb3oFKTQAtFGaTNACnijNJSd6AHUE0neigBCeaCaO9IaAA80007tTSeaAExSEU6kpgMbpVK4iDqQRV4ioXXNNCscZqugJKxkjGCeuKp6fENM1C3ZkyQ4wMda7h4Q2arLYwrdwzugbynDgfSpnG6di4S95XehqX11BJ5LJHtcjDcYP406Igjg1neP8AW9NstNs57Bl+1O/7xQece9cxpXjBG1ERSnCOOvvXJRqpPkO/EUHKPtF/w/md7SZpiOHQMpyCMg04da6zzh1LxTaXNABTaUmg0AGeKSig0wCjNJmkoAXNGcU3NGaAHg0Z5pmeK43xX4s/s6QW9u3z9zSbSV2Fm3ZbnaZpc1574d8ZPcXQiuTweAa75HDqGU5B6UJqSuhuLi7SVmSZopuaM0AFLmm5opiHZzRmm0UAOzRTaXNAC0d6bmjNAzO8RxyT6DcxwxvI7bcKikk/MO1UrDxFpUGmWsMl1tkSFFYeWxwQAD2rfzSVzToz9r7SEkna2qv+qPVoY6gsJ9Ur03JKTkmpKLu0lreMu3kZI8T6P/z+f+Qn/wAKD4n0f/n8/wDIT/4VrZozmny1/wCZf+Av/wCSI9rlv/Pqf/gyP/yox38TaQyEfa//ACG/+FaVr4y0P7OizX2HAwf3LnP/AI7UtRMhb5dx2E5K+tYV8PWqpJyX3P8A+SOjD43L6LbVKev/AE8j/wDKype+MNLnYxw3XlxdC/lvlv0qBPEeiouBd4A/6Zv/AIVrBQBxS5qqWHq01ZSX/gL/APkia2MwFWV5Up/+DI//ACsy/wDhKNH/AOfv/wAhP/hSf8JPo/8Az+f+Qn/wrVorXlr/AMy/8Bf/AMkY+1y3/n1P/wAGR/8AlR//2Q==\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/jpeg": { + "width": 600 + } + }, + "execution_count": 35 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Load Test and Valid Dataset" + ], + "metadata": { + "id": "eYezvhv_iEpY" + }, + "id": "eYezvhv_iEpY" + }, + { + "cell_type": "code", + "source": [ + "import supervision as sv\n", + "\n", + "ds_test = sv.DetectionDataset.from_coco(\n", + " images_directory_path=f\"{dataset.location}/test\",\n", + " annotations_path=f\"{dataset.location}/test/_annotations.coco.json\",\n", + ")\n", + "\n", + "ds_valid = sv.DetectionDataset.from_coco(\n", + " images_directory_path=f\"{dataset.location}/valid\",\n", + " annotations_path=f\"{dataset.location}/valid/_annotations.coco.json\",\n", + ")\n", + "\n", + "ds_merged = sv.DetectionDataset.merge([ds_test, ds_valid])\n", + "len(ds_merged)\n", + "\n", + "\n", + "print(ds_test.classes)\n", + "print(ds_valid.classes)\n", + "print(ds_merged.classes)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bETZFp1tbEV6", + "outputId": "9791f571-e953-44e8-da2e-14b888cdf514" + }, + "id": "bETZFp1tbEV6", + "execution_count": 48, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['circuit', 'Button', 'Buzzer', 'Capacitor', 'Capacitor Jumper', 'Capacitor Network', 'Clock', 'Connector', 'Diode', 'EM', 'Electrolytic Capacitor', 'Electrolytic capacitor', 'Ferrite Bead', 'Flex Cable', 'Fuse', 'IC', 'Inductor', 'Jumper', 'Led', 'Pads', 'Pins', 'Potentiometer', 'RP', 'Resistor', 'Resistor Jumper', 'Resistor Network', 'Switch', 'Test Point', 'Transducer', 'Transformer', 'Transistor', 'Unknown Unlabeled']\n", + "['circuit', 'Button', 'Buzzer', 'Capacitor', 'Capacitor Jumper', 'Capacitor Network', 'Clock', 'Connector', 'Diode', 'EM', 'Electrolytic Capacitor', 'Electrolytic capacitor', 'Ferrite Bead', 'Flex Cable', 'Fuse', 'IC', 'Inductor', 'Jumper', 'Led', 'Pads', 'Pins', 'Potentiometer', 'RP', 'Resistor', 'Resistor Jumper', 'Resistor Network', 'Switch', 'Test Point', 'Transducer', 'Transformer', 'Transistor', 'Unknown Unlabeled']\n", + "['Button', 'Buzzer', 'Capacitor', 'Capacitor Jumper', 'Capacitor Network', 'Clock', 'Connector', 'Diode', 'EM', 'Electrolytic Capacitor', 'Electrolytic capacitor', 'Ferrite Bead', 'Flex Cable', 'Fuse', 'IC', 'Inductor', 'Jumper', 'Led', 'Pads', 'Pins', 'Potentiometer', 'RP', 'Resistor', 'Resistor Jumper', 'Resistor Network', 'Switch', 'Test Point', 'Transducer', 'Transformer', 'Transistor', 'Unknown Unlabeled', 'circuit']\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Calculate Model Metrics\n", + "\n", + "\n", + "* Mean Average Precission\n", + "* F1 Score\n", + "* Confusion Matrix\n", + "\n", + "\n" + ], + "metadata": { + "id": "fEqJhh47iK0o" + }, + "id": "fEqJhh47iK0o" + }, + { + "cell_type": "code", + "source": [ + "import supervision as sv\n", + "import torch\n", + "import torch.nn as nn\n", + "import torchvision.transforms as T\n", + "from PIL import Image\n", + "from supervision.metrics import F1Score, MeanAveragePrecision\n", + "from tqdm import tqdm\n", + "\n", + "MODEL_FILENAME = \"output/dfine_hgnetv2_l_custom/last.pth\"\n", + "YAML_CONFIG_PATH = \"./D-FINE/configs/dfine/custom/dfine_hgnetv2_l_custom.yml\"\n", + "TRANSFORMS = T.Compose(\n", + " [T.Resize((640,640)), T.ToTensor()]\n", + ")\n", + "\n", + "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ], + "metadata": { + "id": "PgiW8-ShhzgE" + }, + "id": "PgiW8-ShhzgE", + "execution_count": 53, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def run_on_image(model, image_array):\n", + " im_pil = Image.fromarray(image_array)\n", + " w, h = im_pil.size\n", + " orig_size = torch.tensor([[w, h]]).to(DEVICE)\n", + " im_data = TRANSFORMS(im_pil).unsqueeze(0).to(DEVICE)\n", + " output = model(im_data, orig_size)\n", + " labels, boxes, scores = output\n", + " class_id = labels.detach().cpu().numpy().astype(int)\n", + " xyxy = boxes.detach().cpu().numpy()\n", + " confidence = scores.detach().cpu().numpy()\n", + "\n", + " detections = sv.Detections(\n", + " xyxy=xyxy[0],\n", + " confidence=confidence[0],\n", + " class_id=class_id[0],\n", + " )\n", + " return detections" + ], + "metadata": { + "id": "KC3kwCNbiusI" + }, + "id": "KC3kwCNbiusI", + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cfg = YAMLConfig(\n", + " YAML_CONFIG_PATH, resume=MODEL_FILENAME\n", + ")\n", + "\n", + "if \"HGNetv2\" in cfg.yaml_cfg:\n", + " cfg.yaml_cfg[\"HGNetv2\"][\"pretrained\"] = False\n", + "checkpoint = torch.load(MODEL_FILENAME, map_location=DEVICE)\n", + "if \"ema\" in checkpoint:\n", + " state = checkpoint[\"ema\"][\"module\"]\n", + "else:\n", + " state = checkpoint[\"model\"]\n", + "\n", + "\n", + "cfg.model.load_state_dict(state)\n", + "\n", + "class Model(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.model = cfg.model.deploy()\n", + " self.postprocessor = cfg.postprocessor.deploy()\n", + "\n", + " def forward(self, images, orig_target_sizes):\n", + " outputs = self.model(images)\n", + " outputs = self.postprocessor(outputs, orig_target_sizes)\n", + " return outputs\n", + "\n", + "model = Model().to(DEVICE)\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vfP6Tj2si4EV", + "outputId": "b4e4654a-f964-498e-a0aa-70535ee94391" + }, + "id": "vfP6Tj2si4EV", + "execution_count": 55, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# @title Collect predictions\n", + "\n", + "predictions = []\n", + "targets = []\n", + "print(\"Evaluating...\")\n", + "for _, image, target_detections in tqdm(ds_valid, total=len(ds_valid)):\n", + " detections = run_on_image(model, image)\n", + " detections = detections[detections.confidence > 0.001]\n", + " predictions.append(detections)\n", + " targets.append(target_detections)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "psDNR0SgkCoO", + "outputId": "59bd9f0c-88d8-406b-c3e4-f31decdcafe4" + }, + "id": "psDNR0SgkCoO", + "execution_count": 68, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Evaluating...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 64/64 [00:03<00:00, 17.25it/s]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# @title Collect maP and F1 metrics\n", + "\n", + "mAP_metric = MeanAveragePrecision()\n", + "f1_score = F1Score()\n", + "\n", + "f1_score_result = f1_score.update(predictions, targets).compute()\n", + "mAP_result = mAP_metric.update(predictions, targets).compute()" + ], + "metadata": { + "id": "EzyutMQxk1V7" + }, + "id": "EzyutMQxk1V7", + "execution_count": 69, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# @title maP Results\n", + "\n", + "print(mAP_result.map50_95)\n", + "print(mAP_result.map50)\n", + "print(mAP_result.map75)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JMgfVOYuk93p", + "outputId": "c282e6fb-2335-44ec-bfeb-74aa35376939" + }, + "id": "JMgfVOYuk93p", + "execution_count": 81, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.04512539627062785\n", + "0.09946413772293412\n", + "0.026075016568393537\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "mAP_result.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 607 + }, + "id": "7TmvFvHilnpN", + "outputId": "1a4858a8-76fd-4b21-f126-5e4207c99066" + }, + "id": "7TmvFvHilnpN", + "execution_count": 71, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# @title F1 Results\n", + "\n", + "print(f1_score_result.f1_50)\n", + "print(f1_score_result.f1_75)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6vSxW4NHqt-S", + "outputId": "44988692-f909-4bc1-d7bd-e2d046e48639" + }, + "id": "6vSxW4NHqt-S", + "execution_count": 82, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.07544642837625108\n", + "0.027499445961266147\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "f1_score_result.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 607 + }, + "id": "tONUkmSutw9j", + "outputId": "739f95f4-3fa6-4305-bfa5-68ee6676a58b" + }, + "id": "tONUkmSutw9j", + "execution_count": 83, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# @title Calculate Confusion Matrix\n", + "\n", + "confusion_matrix = sv.ConfusionMatrix.from_detections(\n", + " predictions=predictions,\n", + " targets=targets,\n", + " classes=ds_merged.classes\n", + ")\n", + "\n", + "_ = confusion_matrix.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "BQrL04NpmiiU", + "outputId": "b4e42938-3390-4944-e695-154fee80d19c" + }, + "id": "BQrL04NpmiiU", + "execution_count": 76, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "WizJNF2OmtKE" + }, + "id": "WizJNF2OmtKE", + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "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.7" + }, + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "A100" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file